1. Jordi Cortadella Department of Computer Science
Reusing computations
Jordi Cortadella
Department of Computer Science

2. 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

3. Calculating 
 can be calculated using the following series: 𝜋 2 = 𝑛=0 ∞ 𝑛! 2𝑛+1 ‼ where 𝑛‼=1×3×5×7×⋯×𝑛 (𝑛 odd)
Introduction to Programming
© Dept. CS, UPC

4. Calculating 
𝜋 2 = 0! 1‼ + 1! 3‼ + 2! 5‼ + 3! 7‼ +⋯ 𝜋 2 =1+ 1 1∙3 + 1∙2 1∙3∙5 + 1∙2∙3 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

5. 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

6. Calculating : reusing computations
𝜋 2 =1+ 1 1∙3 + 1∙2 1∙3∙5 + 1∙2∙3 1∙3∙5∙7 +⋯
𝜋 2 = 𝑡 0 + 𝑡 1 + 𝑡 2 + 𝑡 3 +⋯
𝑡 𝑛 = 𝑛! 2𝑛+1 ‼ = 𝑛−1 !∙𝑛 2𝑛−1 ‼∙(2𝑛+1) = 𝑡 𝑛−1 𝑛 2𝑛+1
Introduction to Programming
© Dept. CS, UPC

7. Calculating 
// Pre: nterms > 0 // Returns an estimation of  using nterms terms // of the series. double Pi(int nterms) { double sum = 1; // Approximation of /2 double term = 1; // 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

8. Calculating 
 =
The series approximation:
nterms
Pi(nterms) 1 5 10 15 20 25
Introduction to Programming
© Dept. CS, UPC

9. 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

10. 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

11. Calculating sin x Reducing the computation to the (-2,2) interval:
Incremental computation of terms:
Introduction to Programming
© Dept. CS, UPC

12. 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

13. Combinations Calculating 𝑛 𝑘 = 𝑛! 𝑘! 𝑛−𝑘 ! = 𝑛(𝑛−1)⋯(𝑛−𝑘+1) 𝑘(𝑘−1)⋯1
Naïve method: 2𝑛 multiplications and 1 division (potential overflow with 𝑛!)
Recursion: 𝑛 0 = 𝑛 𝑛 =1 𝑛 𝑘 = 𝑛 𝑘 𝑛−1 𝑘−1 = 𝑛−𝑘+1 𝑘 𝑛 𝑘− = 𝑛 𝑛−𝑘 𝑛−1 𝑘 = 𝑛−1 𝑘−1 + 𝑛−1 𝑘
Introduction to Programming
© Dept. CS, UPC

14. Problem: integer division cn/k may not be integer
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

15. 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

16. 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