Most elegant way to generate prime numbers [closed]

Use the estimate

pi(n) = n / log(n)

for the number of primes up to n to find a limit, and then use a sieve. The estimate underestimates the number of primes up to n somewhat, so the sieve will be slightly larger than necessary, which is ok.

This is my standard Java sieve, computes the first million primes in about a second on a normal laptop:

public static BitSet computePrimes(int limit){    final BitSet primes = new BitSet();    primes.set(0, false);    primes.set(1, false);    primes.set(2, limit, true);    for (int i = 0; i * i < limit; i++)    {        if (primes.get(i))        {            for (int j = i * i; j < limit; j += i)            {                primes.clear(j);            }        }    }    return primes;}

Many thanks to all who gave helpful answers. Here are my implementations of a few different methods of finding the first n primes in C#. The first two methods are pretty much what was posted here. (The posters names are next to the title.) I plan on doing the sieve of Atkin sometime, although I suspect it won't be quite as simple as the methods here currently. If anybody can see any way of improving any of these methods I'd love to know :-)

Standard Method (Peter Smit, jmservera, Rekreativc)

The first prime number is 2. Add this to a list of primes. The next prime is the next number that is not evenly divisible by any number on this list.

public static List<int> GeneratePrimesNaive(int n){    List<int> primes = new List<int>();    primes.Add(2);    int nextPrime = 3;    while (primes.Count < n)    {        int sqrt = (int)Math.Sqrt(nextPrime);        bool isPrime = true;        for (int i = 0; (int)primes[i] <= sqrt; i++)        {            if (nextPrime % primes[i] == 0)            {                isPrime = false;                break;            }        }        if (isPrime)        {            primes.Add(nextPrime);        }        nextPrime += 2;    }    return primes;}

This has been optimised by only testing for divisibility up to the square root of the number being tested; and by only testing odd numbers. This can be further optimised by testing only numbers of the form 6k+[1, 5], or 30k+[1, 7, 11, 13, 17, 19, 23, 29] or so on.

Sieve of Eratosthenes (starblue)

This finds all the primes to k. To make a list of the first n primes, we first need to approximate value of the nth prime. The following method, as described here, does this.

public static int ApproximateNthPrime(int nn){    double n = (double)nn;    double p;    if (nn >= 7022)    {        p = n * Math.Log(n) + n * (Math.Log(Math.Log(n)) - 0.9385);    }    else if (nn >= 6)    {        p = n * Math.Log(n) + n * Math.Log(Math.Log(n));    }    else if (nn > 0)    {        p = new int[] { 2, 3, 5, 7, 11 }[nn - 1];    }    else    {        p = 0;    }    return (int)p;}// Find all primes up to and including the limitpublic static BitArray SieveOfEratosthenes(int limit){    BitArray bits = new BitArray(limit + 1, true);    bits[0] = false;    bits[1] = false;    for (int i = 0; i * i <= limit; i++)    {        if (bits[i])        {            for (int j = i * i; j <= limit; j += i)            {                bits[j] = false;            }        }    }    return bits;}public static List<int> GeneratePrimesSieveOfEratosthenes(int n){    int limit = ApproximateNthPrime(n);    BitArray bits = SieveOfEratosthenes(limit);    List<int> primes = new List<int>();    for (int i = 0, found = 0; i < limit && found < n; i++)    {        if (bits[i])        {            primes.Add(i);            found++;        }    }    return primes;}

Sieve of Sundaram

I only discovered this sieve recently, but it can be implemented quite simply. My implementation isn't as fast as the sieve of Eratosthenes, but it is significantly faster than the naive method.

public static BitArray SieveOfSundaram(int limit){    limit /= 2;    BitArray bits = new BitArray(limit + 1, true);    for (int i = 1; 3 * i + 1 < limit; i++)    {        for (int j = 1; i + j + 2 * i * j <= limit; j++)        {            bits[i + j + 2 * i * j] = false;        }    }    return bits;}public static List<int> GeneratePrimesSieveOfSundaram(int n){    int limit = ApproximateNthPrime(n);    BitArray bits = SieveOfSundaram(limit);    List<int> primes = new List<int>();    primes.Add(2);    for (int i = 1, found = 1; 2 * i + 1 <= limit && found < n; i++)    {        if (bits[i])        {            primes.Add(2 * i + 1);            found++;        }    }    return primes;}

Ressurecting an old question, but I stumbled over it while playing with LINQ.

This Code Requires .NET4.0 or .NET3.5 With Parallel Extensions

public List<int> GeneratePrimes(int n) {    var r = from i in Enumerable.Range(2, n - 1).AsParallel()            where Enumerable.Range(1, (int)Math.Sqrt(i)).All(j => j == 1 || i % j != 0)            select i;    return r.ToList();}