More on Efficiency Issues

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 euclidimplicit noneinteger * :: n,m,tempread *, n,mdo! if n < m, first iteration will exchange themif ( m == 0 ) exit temp = modulo(n,m) n = m m = tempend doprint *, "gcd is", n! original values of n and m are lost! better to preserve them and use other variablesend 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 skippedgcd = 1doif (n < m) then! make n the larger value temp = m m = n n = tempendif 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*gcdelseif (n_1 == 0) then; n = n/2! more than one statement in one line separated by ;! this should however be avoidedelseif (n_2 == 0) then; m = m/2else; n = n-mendif ; end dogcd = 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 ofnumber 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(log2m+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(log2(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 = 2k, k = log2n 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 1050 iterations • not feasible even on the fastest computer • Finding factors is more difficult than finding common factors