### Archive

Posts Tagged ‘Python’

## Generating primes

September 27, 2011 1 comment

Here’s my implementation of the sieve of Eratosthenes in pyhton:

```cur_num = 2
multiples = {2 : 2}

while True:
is_prime = True

for v in multiples:
nv = multiples[v] - 1
if nv == 0:
is_prime = False
multiples[v] = v
else:
multiples[v] = nv

if is_prime == True:
print cur_num
multiples[cur_num] = cur_num

cur_num = cur_num + 1
```

The difference with the pseudocode found on the wikipedia page is that it doesn’t try to reject numbers on a fixed range, it just compute every occurrence of multiples of known primes at every step. I based my implementation on the fact that every non-prime number is composed of n primes multiplied together where n>1, in a unique way. My previous post on prime numbers used that fact to implement a quick RTTI IsChildOf test.

How does it works? For every prime number encountered, a counter equal to that number is created (in the multiples map). Then, at each iteration, we decrement every counters. When a counter reaches zero, it means that the current number can be divided by this prime number, thus it is not prime. When all counters are different from zero, the current number must be a prime, since there’s no known prime divisor to compose it.

A nice property of this implementation is that when we encounter a non-prime number, all counters that are currently at zero represents all the primes that are used to compose the current non-prime number. Here’s the updated code:

```cur_num = 2
multiples = {2 : 2}

while True:
is_prime = True

for v in multiples:
nv = multiples[v] - 1
if nv == 0:
is_prime = False
multiples[v] = v
else:
multiples[v] = nv

if is_prime == True:
print cur_num, "[prime]"
multiples[cur_num] = cur_num
else:
primes = list()
for v in multiples:
if multiples[v] == v:
primes.append(v)
print cur_num, "[nonprime] ", primes

cur_num = cur_num + 1
```

Which outputs this:

```...
83 [prime]
84 [nonprime]  [2, 3, 7]
85 [nonprime]  [5, 17]
86 [nonprime]  [2, 43]
87 [nonprime]  [3, 29]
88 [nonprime]  [2, 11]
89 [prime]
90 [nonprime]  [2, 3, 5]
91 [nonprime]  [7, 13]
92 [nonprime]  [2, 23]
93 [nonprime]  [3, 31]
94 [nonprime]  [2, 47]
95 [nonprime]  [5, 19]
96 [nonprime]  [2, 3]
97 [prime]
...
```

This is not the best implementation for this algorithm, as it was mainly done to test the idea I had in mind and to learn python. The main problem is as we search for higher primes, speed decrease quite fast due to the number of prime counters to lookup. There are several things we could do, like skip even numbers and updates counters accordingly or write a C++ implementation.

Advertisements