Nahe zusammen liegende Zwillings-Primzahlen finden



  • Will man die wirkliche Bedeutung und Verteilung von Primzahlen verstehen, so hilft es vielleicht, wenn man Häufungen auf engstem Raum versteht. Ein Beispiel sind nahe zusammen liegende Primzahlen-Zwillinge (im nachfolgenden Programm ist der Abstand auf engstmögliche 6 eingestellt).

    #include <iostream>
    #include <vector>
    #include <chrono>
    
    using namespace std;
    
    uint64_t primeLimit = 1000000000;
    uint64_t searchStart = 0; //999900000; 
    uint64_t searchEnd = 100000; //primeLimit
    uint64_t range = 6;
    
    int main()
    {	
    	cout << "Double Twin Primes within range " << range << ":" << endl << endl;
    
    	////////////////////////// Generate primes lookup table ///////////////////////////////////////////////////////////
    
    	cout << "Primes lookup table is produced until " << primeLimit;
    	vector<bool> primes(primeLimit + 1, true); // calculated primes
    	primes.at(0) = primes.at(1) = false;
    	uint64_t iMax = (uint64_t)sqrt((double)primeLimit) + 1; 
    	for (uint64_t i = 2; i < iMax; ++i)
    		if (primes.at(i))
    			for (uint64_t j = 2 * i; j < primeLimit + 1; j += i)
    				primes.at(j) = false; // Erastothenes sieve
    	cout << " (finished)" << endl;
    
        //////////////////////////  Search Double Twin Primes ///////////////////////////////////////////////////////////////
    
    	cout << "Twin Primes searched from " << searchStart << " to " << searchEnd << ":" << endl;
    
    	auto start_time = chrono::high_resolution_clock::now();
    
    	uint64_t p_old = 0;
    
    	for (uint64_t p = searchStart; p <= searchEnd; ++p)
    	{
    		if (primes.at(p) && primes.at(p+2))
    		{
    			auto end_time = chrono::high_resolution_clock::now();
    			uint64_t delta = p - p_old;
    			if ((delta <= range) && (p_old != 0))
    			{
    				cout << p_old << " " << p_old + 2 << "  ";
    				cout << p << " " << p+2;								
    				cout << "\ttime: " << chrono::duration_cast<chrono::milliseconds>(end_time - start_time).count() << " ms" << endl;				
    			}			
    			p_old = p;
    		}					
    	}
    }
    

    output:
    http://codepad.org/HupTMbTb (0 - 100000)

    Double Twin Primes within range 6:
    
    Primes lookup table is produced until 1000000000 (finished)
    Twin Primes searched from 999900000 to 1000000000:
    999900521 999900523  999900527 999900529        time: 0 ms
    999986171 999986173  999986177 999986179        time: 3 ms
    

    Man findet beim max. Abstand 6 (auch bei 8 oder 10) das sich wiederholende Muster: ...1 ...3 ...7 ...9

    Erhöht man auf 12, findet man zwei neue Muster, die eigentlich gleich sind:
    Muster: ...7 ...9 ..19 ..21
    Muster: ...9 ..11 ..21 ..23

    Der Abstand zwischen den Double Twin Primes zeigt kein einfach erkennbares Muster (Code: http://codepad.org/ha73fFMk ).



  • Erhard Henkes schrieb:

    Man findet beim max. Abstand 6 (auch bei 8 oder 10) das sich wiederholende Muster: ...1 ...3 ...7 ...9

    Sonst käme ja auch kein Muster in Frage. Bei 3 aufeinanderfolgenden ungeraden Zahlen muss immer eine durch drei teilbar sein.



  • Es sind keine 3 aufeinander folgenden ungeraden Zahlen, sondern 2 - Lücke - 2.
    Bei 999900521 999900523 999900527 999900529 ist keine der vier Zahlen ohne Rest durch 3 teilbar, wie üblich bei Primzahlen.



  • Kannst du lesen?



  • Ja, durch drei teilbare Zahlen sind nicht dabei. Daher die Lücke. OK, verstanden. Die verbotenen Teiler 3, 5, 7 schaffen die Muster.



  • http://www.mathepedia.de/Primzahlvierlinge.aspx

    wichtig hier nur, die Lücke muss durch 15 teilbar sein.



  • @Bengo: Danke für den Link! "Primzahlvierlinge" ist also der Begriff bei minimalem Abstand.


Log in to reply