1 / 13

More on Efficiency Issues

More on Efficiency Issues. 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. Euclids Algorithm.

emilie
Download Presentation

More on Efficiency Issues

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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

More Related