1. More on Efficiency Issues

2. Greatest Common Divisor given two numbers n and m find their greatest common divisor possible approach –find the common primes in the prime factorizations not very efficient, why? Euclid’s algorithm: one of the oldest algorithms

3. Euclids Algorithm based on simple observation (assume n > m) gcd(n,m) = gcd(n-m,m) (and hence) gcd(n,m) = gcd(m, modulo(n,m)) uses this property to reduce the smaller number repeatedly until the smaller number is 0 larger number then is the gcd

4. Euclid Algorithm program euclid implicit none integer * :: n,m,temp read *, n,m do ! if n < m, first iteration will exchange them if ( m == 0 ) exit temp = modulo(n,m) n = m m = temp end do print *, "gcd is", n ! original values of n and m are lost ! better to preserve them and use other variables end euclid

5. Binary GCD Algorithm Other algorithms possible for gcd The binary algorithm uses the following derived properties: –If n,m are even, gcd(n,m)=2gcd(n/2,m/2) –If n odd, m even, gcd(n,m) = gcd(n,m/2) –If n,m odd, gcd(n,m) = gcd(n-m,m) ( n > m) This involves simple operations - multiplication and division by 2 These operations easy to implement in binary representation –Multiplication by 2 is shifting to left –Division by 2 is shifting to the right

6. Binary GCD Program !declarations skipped gcd = 1 do if (n < m) then ! make n the larger value temp = m m = n n = temp endif if ( m == 0) exit n_1 = modulo(n,2) n_2 = modulo(m,2) if (n_1 == 0.and. n_2 == 0) then n = n/2; m = m/2; gcd = 2*gcd elseif (n_1 == 0) then; n = n/2 ! more than one statement in one line separated by ; ! this should however be avoided elseif (n_2 == 0) then; m = m/2 else; n = n-m endif ; end do gcd = gcd * n

7. Comparison of Algorithms Both the algorithms are correct (prove!) which algorithm is better? How do we compare? – usually based on time for finding the result Time measured in terms of number of arithmetic operations performed Time for a single operation assumed to be a fixed constant assumption not always valid (division by 2 is much simpler than arbitrary division)

8. Comparison of Algorithms How many operations performed in the two programs? –depend on values of n and m Count number of operations as a function of n and m As values of n and m increase, time required also increases How fast does it increase?

9. Euclids Algorithm A fixed number of operations performed in each iteration Time depends on number of iterations after every 2 iterations, value of m is reduced by at least half –if modulo(n,m) > m/2 then modulo(m,modulo(n,m)) < m/2 number of iterations is at most 2(log 2 m+1)

10. Binary Algorithm Fixed number of operations per iteration Number of iterations depends on n and m after every 2 iterations n*m is reduced by at least half –if either n or m is even, it is halved –if both are odd, n-m is even and is halved in the next iteration number of iterations <= 2(log 2 (n*m) +1)

11. Worst-case Bounds Bounds on number of iterations are called worst-case bounds actual number of iterations for particular n and m may be lesser worst-case bounds hold for all inputs n, m Euclid’s algorithm better than binary in the worst-case Operations in binary simpler and can be implemented more efficiently at a lower level

12. Prime Factorization Consider the algorithm given in the last class How many operations are performed by the prime factorization algorithm Depends on value of n if n = 2 k, k = log 2 n iterations are done if n is prime, sqrt(n) iterations are done worst-case bound is sqrt(n) Time required is less if n has many small prime factors

13. Factorization Vs. GCD Consider two 100 decimal digit numbers –Euclids algorithm will take about 600 iterations in the worst case –done easily on modern computers Factorization algorithm may require about 10 50 iterations –not feasible even on the fastest computer Finding factors is more difficult than finding common factors