Reusing computations
Jordi Cortadella
Department of Computer Science
Reusing computations
• There are certain algorithms that require a
repeated sequence of similar computations.
For example:
𝑘
𝑆 𝑥 =
𝑡𝑖 (𝑥)
𝑖=0
• Strategy: try to reuse the work done from
previous computations as much as possible.
Introduction to Programming
© Dept. CS, UPC
2
Calculating 
 can be calculated using the following series:
𝜋
=
2
∞
𝑛=0
𝑛!
2𝑛 + 1 ‼
where 𝑛‼ = 1 × 3 × 5 × 7 × ⋯ × 𝑛 (𝑛 odd)
Introduction to Programming
© Dept. CS, UPC
3
Calculating 
𝜋 0! 1! 2! 3!
=
+
+
+
+⋯
2 1‼ 3‼ 5‼ 7‼
𝜋
1
1∙2
1∙2∙3
=1+
+
+
+⋯
2
1∙3 1∙3∙5 1∙3∙5∙7
Since an infinite sum cannot be computed, it may
often be sufficient to compute an approximation
with a finite number of terms.
Introduction to Programming
© Dept. CS, UPC
4
Calculating : naïve approach
// Pre: nterms > 0
// Returns an estimation of  using nterms terms
// of the series.
double Pi(int nterms) {
double sum = 1;
// Approximation of /2
// Inv: sum is an approximation of /2 with k terms,
//
term is the k-th term of the series.
for (int k = 1; k < nterms; ++k) {
term = factorial(k)/double_factorial(2k + 1);
sum = sum + term;
}
return 2sum;
}
It should be a
real division
Introduction to Programming
© Dept. CS, UPC
5
Calculating : reusing computations
𝜋
1
1∙2
1∙2∙3
=1+
+
+
+⋯
2
1∙3 1∙3∙5 1∙3∙5∙7
𝜋
= 𝑡0 + 𝑡1 + 𝑡2 + 𝑡3 + ⋯
2
𝑛!
𝑛−1 !∙𝑛
𝑛
𝑡𝑛 =
=
= 𝑡𝑛−1
2𝑛 + 1 ‼
2𝑛 − 1 ‼ ∙ (2𝑛 + 1)
2𝑛 + 1
Introduction to Programming
© Dept. CS, UPC
6
Calculating 
// Pre: nterms > 0
// Returns an estimation of  using nterms terms
// of the series.
double Pi(int nterms) {
double sum = 1;
double term = 1;
// Approximation of /2
// Current term of the sum
// Inv: sum is an approximation of /2 with k terms,
//
term is the k-th term of the series.
for (int k = 1; k < nterms; ++k) {
term = termk/(2.0k + 1.0);
sum = sum + term;
}
return 2sum;
}
Introduction to Programming
© Dept. CS, UPC
7
Calculating 
•  = 3.14159265358979323846264338327950288...
• The series approximation:
Introduction to Programming
nterms
1
5
Pi(nterms)
2.000000
3.098413
10
15
20
25
3.140578
3.141566
3.141592
3.141593
© Dept. CS, UPC
8
Taylor and McLaurin series
• Many functions can be approximated by using
Taylor or McLaurin series, e.g.:
• Example: sin x
Introduction to Programming
© Dept. CS, UPC
9
Calculating sin x
• McLaurin series:
• It is a periodic function (period is 2)
• Convergence improves as x gets closer to zero
Introduction to Programming
© Dept. CS, UPC
10
Calculating sin x
• Reducing the computation to the (-2,2)
interval:
• Incremental computation of terms:
Introduction to Programming
© Dept. CS, UPC
11
Calculating sin x
#include <cmath>
// Returns an approximation of sin x.
double sin_approx(double x) {
int k = int(x/(2M_PI));
x = x – 2kM_PI; // reduce to the (-2,2) interval
double term = x;
double x2 = xx;
int d = 1;
double sum = term;
while (abs(term) >= 1e-8) {
term = -termx2/((d+1)(d+2));
sum = sum + term;
d = d + 2;
}
}
return sum;
Introduction to Programming
© Dept. CS, UPC
12
Combinations
Calculating
𝑛
=
𝑘!
𝑘
𝑛!
𝑛−𝑘 !
=
𝑛(𝑛−1)⋯(𝑛−𝑘+1)
𝑘(𝑘−1)⋯1
– Naïve method: 2𝑛 multiplications and 1 division
(potential overflow with 𝑛!)
– Recursion:
𝑛
𝑛
=
=1
0
𝑛
𝑛 𝑛−1
𝑛−𝑘+1
𝑛
𝑛
=
=
𝑘
𝑘−1
𝑘 𝑘−1
𝑘
𝑛
𝑛−1
𝑛−1
𝑛−1
=
=
+
𝑘
𝑘−1
𝑘
𝑛−𝑘
Introduction to Programming
© Dept. CS, UPC
13
Combinations
// Pre: n  k  0
// Returns combinations(n k)
int combinations(int n, int k) {
int c = 1;
for (; k > 0; --k) {
c = cn/k;
--n;
}
return c;
}
Problem: integer division
cn/k may not be integer
Introduction to Programming
© Dept. CS, UPC
14
Combinations: recursive solution
// Pre: n  k  0
// Returns combinations(n k)
int combinations(int n, int k) {
if (k == 0) return 1;
return ncombinations(n – 1, k – 1)/k;
}
Always an
integer division!
Introduction to Programming
© Dept. CS, UPC
15
Conclusions
• Try to avoid the brute force to perform
complex computations.
• Reuse previous computations whenever
possible.
• Use your knowledge about the domain of the
problem to minimize the number of
operations.
Introduction to Programming
© Dept. CS, UPC
16