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
•	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
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
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
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
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)
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?
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)
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)
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
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
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