Geekality » Primes

The Sieve of Atkin in C#

Torleif — Mon, 19 Oct 2009 19:46:26 +0000

I have previously written about the Sieve of Eratosthenes, which is an algorithm for finding primes. This algorithm worked very well for most of the prime related Euler Problems. However, for one of them it just didn’t do it. Well, it did it, but it did it kind of slow. The problem was to calculate the sum of all the primes below two million, and with that algorithm this took close to 2 seconds on my machine. Not too long you might think, but compared to my other solutions it is ages and ages. So I started to see if I could find a more efficient algorithm to use for that problem.

I quickly found one called the Sieve of Atkin. The Atkin algorithm works similarly to the original Eratosthenes one, but has a more fancy way of sieving out numbers which means it can work a lot faster. However, this also means that it needs to work towards an upper limit and that it have to find all the primes up to that limit in advance. In other words it cannot work incrementally and lazily like my Eratosthenes implementation.

Anyways, without further ado, here is my C# implementation of the Sieve of Atkin:

public class Atkin : IEnumerable<ulong>
{
private readonly List<ulong> primes;
private readonly ulong limit;

public Atkin(ulong limit)
{
this.limit = limit;
primes = new List<ulong>();
}

public IEnumerator<ulong> GetEnumerator()
{
if (!primes.Any())
FindPrimes();

foreach (var p in primes)
yield return p;
}

IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}

private void FindPrimes()
{
var isPrime = new bool[limit + 1];
var sqrt = Math.Sqrt(limit);

for (ulong x = 1; x <= sqrt; x++)
for (ulong y = 1; y <= sqrt; y++)
{
var n = 4 * x * x + y * y;
if (n <= limit && (n % 12 == 1 || n % 12 == 5))
isPrime[n] ^= true;

n = 3 * x * x + y * y;
if (n <= limit && n % 12 == 7)
isPrime[n] ^= true;

n = 3 * x * x - y * y;
if (x > y && n <= limit && n % 12 == 11)
isPrime[n] ^= true;
}

for (ulong n = 5; n <= sqrt; n++)
if (isPrime[n])
{
var s = n * n;
for (ulong k = s; k <= limit; k += s)
isPrime[k] = false;
}

primes.Add(2);
primes.Add(3);
for (ulong n = 5; n <= limit; n++)
if (isPrime[n])
primes.Add(n);
}
}

I am not going to explain my code. Instead I will just tell you to look at the algorithm at Wikipedia and look at my code while reading the pseudocode provided there. Why? Because it is pretty much a direct copy of it, just translated into C#

As a usage example, we can sum up all the primes below a 1000 like so:

var sum = new Atkin(1000)
.Aggregate((sum, x) => sum + x);

Fantastic huh? The even more fantastic part is that when I used this class instead of the Eratosthenes class to solve the problem I mentioned in the beginning, my solution went from taking almost 2 seconds down to around 160 milliseconds

This is just a very straight forward implementation though, so if you have any suggestions to how it can be improved, made faster, cleaner, more efficient, et cetera, please let me know by leaving a comment!

The Sieve of Eratosthenes in C#

Torleif — Mon, 19 Oct 2009 18:37:47 +0000

In some of the Project Euler problems we have needed a source of primes. One algorithm for finding primes is called the Sieve of Eratosthenes. This algorithm is both pretty simple to understand and to implement. It is also fairly fast and usable, at least for the lower primes.

My implementation is based upon the algorithm described on the Wikipedia page and some helpful optimizations I found in an article at Black Wasp. The differences from the original algorithm and the solution at Black Wasp is that it finds the primes incrementally and that it only looks for a new prime when asked.

My code should be pretty self explanatory, but the basic idea is that we have a list of known primes and for each odd number we check it against the these. If a number is not evenly divisible by any of the known primes, then we have found a new one and can add it to our list.

public class Eratosthenes : IEnumerable<ulong>
{
private readonly List<ulong> knownPrimes;

public Eratosthenes()
{
knownPrimes = new List<ulong> {2, 3};
}

public IEnumerator<ulong> GetEnumerator()
{
// Return the ones we know first
foreach (var prime in knownPrimes)
yield return prime;

// Then find new ones
var possible = primes.Last();
while (true)
if (IsPrime(possible += 2))
{
yield return possible;
knownPrimes.Add(possible);
}
}

IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}

private bool IsPrime(ulong value)
{
var sqrt = (ulong) Math.Sqrt(value);
return !knownPrimes
.TakeWhile(x => x <= sqrt)
.Any(x => value%x == 0);
}
}

How do you use it? Simple! For example, to print the first 500 primes you can do this:

var primes = new Eratosthenes().Take(500);

foreach(var prime in primes)
Console.WriteLine(prime);

And that’s all there is to it! What do you think? Let me know if you have any questions about it or any suggestions to how it can be improved. I want to know

Project Euler: Problem 10

Torleif — Wed, 30 Sep 2009 20:29:59 +0000

The sum of the primes below 10 is

Find the sum of all the primes below two million.

Solution

Using our previously made Eratosthenes class for generating primes, this problem can be solved in a very easy way.

var answer = new Eratosthenes()
.TakeWhile(x => x < 2000000)
.Aggregate((sum, x) => sum + x)

And that was it actually. The only problem here is that it takes a bit of time. On my machine this solution takes over 2 seconds. Not very long maybe, but compared to the others that is quite a bit of time actually. Especially when I know that it could go a lot faster if I just had a faster algorithm for generating prime numbers. However, I haven’t found that yet. Actually, I have, but I haven’t managed to implement any of them yet…

Update October, 19th 2009

Managed to finally implement another algorithm called the Sieve of Atkin. I have written about it in a different post.

Using that class, the solution to this problem looks like this:

var answer = new Atkin(2000000)
.Aggregate((sum, x) => sum + x);)

Pretty similar. But! The solution now takes only about 160 milliseconds, instead of the original 2 seconds Is that cool or what?

Project Euler: Problem 7

Torleif — Thu, 24 Sep 2009 16:53:22 +0000

By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.

What is the 10001st prime number?

Solution

This will be a very quick one thanks to the prime number generator created earlier for problem 3. All we need is actually this one line of code:

var answer = new Eratosthenes().Take(10001).Last();

And that’s it. It takes around 50 milliseconds, which is totally acceptable I would say. It can be sped up quite a bit though if we find a more efficient prime number generator. This, however, I will try to do in a later problem.

Project Euler: Problem 3

Torleif — Thu, 17 Sep 2009 21:26:36 +0000

The third Euler problem has to do with prime factorization:

The prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number 600851475143?

Solution

This one I struggled with a bit, cause I wasn’t sure exactly how to do this prime factorization. I knew what it was, and how to do it by hand, but wasn’t quite sure how to do it effective in code. Either way I ended up using something called the Sieve of Eratosthenes. Not the most efficient algorithm for this, if I have understood correctly, but it worked well enough for this use, and it was fairly straight forward to implement with some help from Black Wasp.

I started to make a prime number generator similar to the one I created for Fibonacci numbers in Problem 2.

public interface IPrimeSequence : IEnumerable<ulong> {}

public class Eratosthenes : IPrimeSequence
{
private readonly List<ulong> knownPrimes;

public Eratosthenes()
{
knownPrimes = new List<ulong> {2, 3};
}

#region IPrimeSequence Members
public IEnumerator<ulong> GetEnumerator()
{
// Return the ones we know first
foreach (var prime in knownPrimes)
yield return prime;

// Then find new ones
var possible = primes.Last();
while (true)
if (IsPrime(possible += 2))
{
yield return possible;
knownPrimes.Add(possible);
}
}

IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
#endregion

private bool IsPrime(ulong value)
{
var sqrt = (ulong) Math.Sqrt(value);
return !knownPrimes
.TakeWhile(x => x <= sqrt)
.Any(x => value%x == 0);
}
}

It basically starts with the 2 first primes. And for each new requested prime number, it goes through the following odd numbers until it finds one that is not dividable by any of the primes ones we know so far.

Note: I’ve created a separate post about the Sieve of Eratosthenes, which might be updated with some optimizations, et cetera

With that prime number generator in place, finding prime factors is pretty straight forward here.

public static IEnumerable<ulong> GetPrimeFactors(ulong value, IPrimeSequence primeSequence)
{
foreach (var prime in primeSequence)
{
while (value%prime == 0)
{
value /= prime;
yield return prime;
}

if (value == 1)
{
yield break;
}
}
}

Now, that is pretty much what is needed to solve this problem. A simple LINQ statement finds the answer.

var answer = GetPrimeFactors(600851475143, new Eratosthenes()).Max();

Tadaa