Sieve of Eratosthenes

From Wikipedia, the free encyclopedia

Sieve of Eratosthenes

In mathematics, the Sieve of Eratosthenes is a simple, ancient algorithm for finding all prime numbers up to a specified integer. It is the predecessor to the modern Sieve of Atkin, which is faster but more complex. It was created by Eratosthenes, an ancient Greek mathematician. Wheel factorization is often applied on the list of integers to be checked for primality, before the Sieve of Eratosthenes is used, to increase the speed.

Contents

[edit] Algorithm

  1. Write a list of numbers from 2 to the largest number you want to test for primality. Call this List A. (This is the list of squares on the left side of the picture.)
  2. Write the number 2, the first prime number, in another list for primes found. Call this List B. (This is the list on the right side of the picture.)
  3. Strike off 2 and all multiples of 2 from List A.
  4. The first remaining number in the list is a prime number. Write this number into List B.
  5. Strike off this number and all multiples of this number from List A. The crossing-off of multiples can be started at the square of the number, as lower multiples have already been crossed out in previous steps.
  6. Repeat steps 4 and 5 until no more numbers are left in List A. Note that, once you reach a number greater than the square root of the highest number in List A, all the numbers remaining in List A are prime.


The following is pseudocode for the algorithm:

// arbitrary search limit
limit ← 1.000.000                   

// assume all numbers are prime at first                                    
                                                                            
is_prime(i) ← true, i ∈ [2, limit] 

for n in [2, √limit]:
    if is_prime(n):
        // eliminate multiples of each prime,
        // starting with its square
        is_prime(i) ← false, i ∈ {n², n²+n, n²+2n, ..., limit}

for n in [2, limit]:
    if is_prime(n): print n

Or, more simplified:

limit = 1000000
sieve$ = string of the character "P" with length limit

prime = 2
repeat while prime2 < limit
    set the character at the index of each multiple of prime (excluding index prime * 1) in sieve$ to "N"
    prime = index of the next instance of "P" in sieve$ after index prime
end repeat

print the index of each instance of "P" in sieve$

[edit] Complexity

The complexity of the algorithm is O((nlogn)(loglogn)) and has a memory requirement of O(n).[1]

[edit] Mnemonic

A poem, replicating the essence of the algorithm, is as follows:[2]

Sift the Two's and sift the Three's,
 The Sieve of Eratosthenes.
 When the multiples sublime,
 The numbers that remain are Prime.

[edit] See also

[edit] References

  1. ^ Pritchard, Paul Linear prime-number sieves: a family tree. Sci. Comput. Programming 9 (1987), no. 1, 17--35.
  2. ^ William F. Clocksin and Christopher S. Mellish. Programming in PROLOG. Springer-Verlag.

[edit] Sources

  • Κοσκινον Ερατοσθενους or, The Sieve of Eratosthenes. Being an Account of His Method of Finding All the Prime Numbers, by the Rev. Samuel Horsley, F. R. S., Philosophical Transactions (1683-1775), Vol. 62. (1772), pp. 327-347.

[edit] External links

v • d • e
Number-theoretic algorithms
Primality tests
Sieving algorithms
Integer factorization algorithms
Other algorithms
Italics indicate that algorithm is for numbers of special forms; bold indicates deterministic algorithm for primality tests.