Ich weiß nicht, ob das möglich ist oder nicht, aber ich muss nur fragen. Meine mathematischen und algorithmischen Fähigkeiten scheitern hier irgendwie: P

Die Sache ist, dass ich jetzt diese Klasse habe, die Primzahlen bis zu einer bestimmten Grenze erzeugt:

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

Nun möchte ich das Limit loswerden, damit die Sequenz (theoretisch) nie aufhört.

Ich denke, es könnte so etwas gehen:

Beginnen Sie mit einem kleinen LimitFinde alle Primzahlen bis zum LimitErgib alle neu gefundenen PrimzahlenErhöhen Sie das Limit (indem Sie das alte Limit verdoppeln oder quadrieren oder ähnliches)Weiter zu Schritt 2

Und optimalerweise sollte dieser zweite Schritt nur zwischen der alten und der neuen Grenze funktionieren müssen. Mit anderen Worten, es sollte nicht nötig sein, immer wieder die niedrigsten Primzahlen zu finden.

Gibt es eine Möglichkeit, dies zu tun? Mein Hauptproblem ist, dass ich nicht ganz verstehe, wasx undy Zum Beispiel ist in diesem Algorithmus. Wie könnte ich nur die gleiche Art von Algorithmus verwenden, aber gesetztx undy zuoldLimit (anfangs 1) und starte es bisnewLimit? Oder wie würde das gehen? Haben Sie kluge Köpfe, die Licht ins Dunkel bringen möchten?

Der Punkt dabei ist, dass ich dieses Limit nicht setzen muss. Damit kann ich zum Beispiel Linq benutzen und ebenTake() wie viele Primzahlen ich auch brauche, keine Sorge, ob das Limit hoch genug ist, und so weiter.