## Generating primes

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.

## Prime numbers

Prime numbers are a very interesting topic. I often find myself quite uncomfortable when setting my car’s radio volume on an even number, and I really feel better when it’s a prime number. But this is a complete different story.

So, what are the uses of prime numbers in programming? Cryptography, random numbers generation, better hashing functions, etc. One thing that I recently discovered about prime numbers is that if you multiply *n* different primes together, it creates a special composite number (if anyone knows the real name of those, please tell me) that has a quite interesting property: there’s a way to know if a certain prime *p* was used or not to compose it simply by dividing by *p*. If the result is an integer, then *p* was used to compose the number. Take this example:

- 3 * 7 * 13 * 53 * 227 = 3284463

To know if prime number 19 was used to compose it, we do:

- 3284463 / 19 = 172866.474

Since the result is not an integer, 19 wasn’t used to compose the number 3284463. But, if we take a look at:

- 3284463 / 3 = 1094821

3284463 / 7 = 469209

3284463 / 13 = 252651

3284463 / 53 = 61971

3284463 / 227 = 14469

A practical usage of this property is for a RTTI system. By assigning a different prime number to each class in the hierarchy, and by multiplying each child’s class value by it’s parent value, we can determine if a class *A* derives from class *B* simply by dividing its composite number by *B*‘s number, instead of going through all the parents chain:

Bool Class::IsChildOf(const Class* B) const { return ((Prime % B->Prime) == 0); }