No sé si esto es posible o no, pero solo tengo que preguntar. Mis habilidades matemáticas y algorítmicas me están fallando aquí: P

La cosa es que ahora tengo esta clase que genera números primos hasta un cierto límite:

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>();
    }

    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);
    }


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

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


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

Ahora, lo que me gustaría es deshacerme del límite para que la secuencia nunca se detenga (teóricamente).

Estoy pensando que podría ser algo como esto:

Empieza con algún límite trivial.Encuentra todos los primos hasta el límite.Ceder todos los primos recién descubiertosAumente el límite (doblando o cuadrando el límite anterior o algo así)Goto paso 2

Y de manera óptima, el paso dos solo debe funcionar entre el límite anterior y el nuevo. En otras palabras, no debería tener que encontrar los primos más bajos una y otra vez.

¿Hay alguna manera de hacer esto? Mi principal problema es que no entiendo muy bien qué.x yy por ejemplo está en este algoritmo. Al igual que, ¿podría simplemente usar el mismo algoritmo, pero establecerx yy aoldLimit (inicialmente 1) y ejecutarlo hastanewLimit? ¿O cómo funcionaría eso? ¿Alguna mente brillante con algo de luz para arrojar sobre esto?

El punto de esto es para que no tenga que establecer ese límite. Para que pueda, por ejemplo, usar Linq y soloTake() Sin embargo, necesito muchos números primos, sin preocuparme por si el límite es lo suficientemente alto, etcétera.