Impressum  |   Kontakt  |   Lebenslauf  |   Sitemap  |   Links
Kunst aus Rostock

Die goße Primzahlenseite - Informationen und Berechnungen

Primzahlen - Javascriptprojekt ohne Nährwert

Aus der Schule ist kaum mehr bekannt, als dass Primzahlen nur durch sich selbst und durch 1 teilbar sind. Die Mathematiker haben diesen Zahlen jedoch noch viele Geheimnisse entlockt. Einige interessante Fakten sind auf dieser Seite zusammengetragen.

Primzahlenalgorithmen im Geschwindigkeitsvergleich mit Javascript
Alle berechnen bis Anzahl Rechenzeit in ms
mit Modulo Trivial Skriptinfos
mit Probedivision
mit Sieb des Eratosthenes
mit Bühler-Algorithmus
mit Sieb von AtkinBenannt nach dem amerikanischen Mathematiker Oliver Atkin. Er entwickelte zusammen mit Daniel Bernstein 2004 einen Primzahlenalgorithmus, der auf einer Modulo 60 - Operation basiert. Er ist bei Wikipedia erläutert.
Das Sieb des EratosthenesBenannt nach Eratosthenes von Kyrene. Der grichische Mathematiker hat die Bezeichnung "Sieb" eingeführt. Der Primzahlenalgorithmus selbst war bereits bekannt.
Primzahlen sieben Glückliche ZahlenUnendliche Zahlenfolge, die der polnische Mathematiker Stanislaw Ulam benannt hat. Der Algorithmus zur Bildung geht auf eine Geschichte des jüdischen Geschichtsschreibers Flavius Josephus zurück. Die Zahlen sind glücklich, weil sie nie gestrichen werden. sieben
Vorführen bis
Zahlen nebeneinander
Kommentar
Ausgabefeld
    Primzahlen ermitteln und analysieren mit Javascript
    Alle berechnen bis Ab der Zahl
    Erwartung nach Gaus Fehler in %
    Erwartung nach Legendre Fehler in %
    Anzahl der Primzahlen Anteil in % ms
    AnzahlAnteil der Paare, die Primzahlzwilling sind der ZwillingePrimzahlenzwillinge Zwei beieinanderliegende Primzahlen der Form n, n+2. AnteilProzentualer Anteil der Zahlen, die Zwilling sind, von den gefundenen Primzahlen in %
    Anzahl der DrillingePrimzahlendrillinge Von drei aufeinander folgenden ungeraden Zahlen ist immer eine durch 3 teilbar. Also können die Zahlen n, n+2, n+4 nicht alle eine Primzahl sein.
    Daher definiert man Drillinge in der Form n, n+2, n+6
    oder n, n+4, n+6.
    Anteil in %
    Brunsche KonstanteBrunsche Konstante Die Summe der Kehrwerte aller Primzahlzwillinge konvergiert überraschenderweise gegen einen Grenzwert. Dieser ist nach seinem Entdecker Viggo Brun benannt. Er beträgt
    b2 = 1.831808063432379
    Die Behauptung, es gibt nur endlich viele Primzahlzwillinge, ist unbewiesen.
    Abweichung
    Alle Primzahlen
    Zwillinge
    Drillinge
    Die Goldbachsche Vermutung testenDie Goldbachsche Vermutung Sie ist benannt nach dem Mathematiker Christian Goldbach.
    Heute versteht man unter ihr die unbewiesene Behauptung:
    Jede gerade Zahl größer als 2 kann als Summe zweier Primzahlen geschrieben werden.
    Bitte eine gerade Zahl eingeben:
    Bearbeitungsstatus
    Summanden
    Eine Zahl in ihre PrimfaktorenPrimfaktorenzerlegung Darstellung einer natürlichen Zahl n als Produkt von Primzahlen. Sie werden als Primfaktoren von n bezeichnet. zerlegen mit Javascript
    Eingabe
    AusgabeDie Ausgabe erfolgt in kanonischer Primfaktorzerlegung, d. h. ansteigende Anordnung der Zahlen und Darstellung in Exponentenschreibweise.
    Zahl mit maximal 15 Stellen eingeben
    Bitte warten ...[0%]
    rechnen ... [0%]


    Skriptinfos

    Information zu den verschieden Algorithmen des Geschwindigkeitsvergleiches zu Beginn auf dieser Seite.

    function modulo_trivial(c_max){
    	 var jetzt = new Date(); 
    	 var startzeit = jetzt.getTime(); // zur Berechnung der Rechendauer
         var p_modulo1; p_modulo1 = new Array(2,3,5,7);
    	 var i, j;
    	 for ( i=11; i<=c_max; i++){
    		var c_wurzel = Math.floor(Math.sqrt(i))+1; // floor() rundet ab
    		for ( j=2; j<=c_wurzel; j++) {
    			if (i % j == 0) break;
    			else if (j==c_wurzel) p_modulo1.push(i);
    		}
         }
    	 document.vergleich.anzahl1.value = p_modulo1.length;	// gibt die Anzahl Primzahlen aus
    	 document.vergleich.zeit1.value = rechenzeit_ermitteln(startzeit);
    	 return false;
    }
    function probedivision(c_max){
    	var jetzt = new Date(); 	
    	var startzeit = jetzt.getTime(); // zur Berechnung der Rechendauer
        var p_modulo; p_modulo = new Array(2,3,5,7);
    	var i, j, hv, c_wurzel;
    	for ( i=11; i<=c_max; i++){
    		c_wurzel = Math.floor(Math.sqrt(i))+1; // floor() rundet ab
    		for (j=0; j<=c_wurzel; j++) {
    			hv = p_modulo[j];
    			if (hv > c_wurzel) 
    				{
    				p_modulo.push(i);
    				break;
    				}
    			else if (i % hv == 0) break;
    		}
    	}	
    	document.vergleich.anzahl2.value = p_modulo.length;	// gibt die Anzahl Primzahlen aus
    	document.vergleich.zeit2.value = rechenzeit_ermitteln(startzeit);
    	return false;
    }
    function eratosthenes(c_max){
    	var jetzt = new Date(); 	
    	 var startzeit = jetzt.getTime(); // zur Berechnung der Rechendauer
         var p_eras; p_eras = new Array();
         var index=0;
         var primSieb=new Array();
         primSieb[0]=false; primSieb[1]=false;
         for (var i=2; i<=c_max; i++){
            primSieb[i]=true;
         }
    	 for (i=2; i<=c_max; i++){
    		var hv = c_max/i;
    		index=i;
    		for (var j=2; j<=hv; j++) {
    			index=index+i // entspricht primSieb[i*j]=0;
    			primSieb[index]=false;				
    		}
         }
         for (i=2;i<=c_max;i++){
            if (primSieb[i]==true) p_eras.push(i);
         }
    	 document.vergleich.anzahl3.value = p_eras.length;	// gibt die Anzahl Primzahlen aus
    	 document.vergleich.zeit3.value = rechenzeit_ermitteln(startzeit);
    	 return false;
    }
    function buehler(c_o){
    	var jetzt = new Date();  // 
    	var startzeit = jetzt.getTime(); // zur Berechnung der Rechendauer
    	var k;
    	var pmax; 	pmax = 0;
    	var p;	p = new Array(); p[0] = 2; // Liste der gefundenen Primzahlen
    	var psum; 	psum = new Array(); psum[0] = 0; // Liste der Summen einer gefundenen Primzahl bis zur Wurzel dr Grenzzahl
    	var prim; // logische Statusvariable, Hilfsvariable
    	var c_o_wurzel = Math.floor(Math.sqrt(c_o)) + 1;	//Nur Primzahlen bis zur Wurzel
    	for (var i=3; i < c_o; i++) 
    	{
    		k = 0;
    		prim = true;  // Status wird erst einmal auf wahr gesetzt
    		while ((k < pmax) && prim && p[k] <= c_o_wurzel) 
    		{
    			while (psum[k] < i){ // prüfen, ob eine gefundene Primzahl an Stelle k Teiler von i ist
    				psum[k] = psum[k] + p[k];} // durch fortlaufende Aufsummierung der Primzahl an Stelle k zur Summe an Stelle k
    			if (psum[k] == i) prim = false; // wenn eine Primzahl an einer Stelle k Teiler von i ist, ist i nicht prim
    			k++; // die nächst größere Primzahl aus dem Summenarray wird geprüft
    		} // alle Primzahlen bis zur Wurzel von i sind geprüft
    		if (prim) // Eintragen einer neu gefundenen Primzahl
    		{
    			pmax++; //Array-Zeiger erhöhen
    			p[pmax] = i; // neue Primzahl am Ende eintragen
    			psum[pmax]=0; // an gleicher Stelle Summenelement schaffen
    		}
    	}		
    	 document.vergleich.anzahl4.value = p.length;	// gibt die Anzahl Primzahlen aus
    	 document.vergleich.zeit4.value = rechenzeit_ermitteln(startzeit);
    	 return false;
    }
    function atkin(c_max){
    	var jetzt = new Date();  // 
    	var startzeit = jetzt.getTime(); // zur Berechnung der Rechendauer
    	var Zahlenfeld;	Zahlenfeld = new Array(); 
    	var i, a, b, wurzel_c_max, n, k;
    	for (i=0; i <= c_max; i++) 	Zahlenfeld[i] = false;  
    	wurzel_c_max = Math.sqrt(c_max);
    	for (a = 1; a <= wurzel_c_max; a++){ 
    		for (b = 1; b <= wurzel_c_max; b++){ 
    			n = 4 * a*a + b*b; 
    			if (n <= c_max &&  (n%12 == 1 || n%12 == 5)){ 
    				if (Zahlenfeld[n]) Zahlenfeld[n] = false; 
    				else Zahlenfeld[n] = true; 
    			} 
    			n = 3 * a*a + b*b; 
    			if (n <= c_max &&  n%12 == 7){ 
    				if (Zahlenfeld[n]) Zahlenfeld[n] = false; 
    				else Zahlenfeld[n] = true; 
    			} 
    			n = 3 * a*a - b*b; 
    			if (a > b &&  n <= c_max && n%12 == 11) { 
    				if (Zahlenfeld[n]) Zahlenfeld[n] = false; 
    				else Zahlenfeld[n] = true; 
    			} 
    		}
    	} 
    	for (n = 0; n <= wurzel_c_max; n++) { 
    		if (Zahlenfeld[n]){ 
    			for ( k = 1; k * n*n <= c_max; k++) Zahlenfeld[k * n*n] = false; 
    		} 
    	} 
    	Zahlenfeld[2] = true;
    	Zahlenfeld[3] = true;
    	var count=0;
    	for(i=2; i<=c_max; i++){
    		if(Zahlenfeld[i]==true) count++ 
    	}
    	document.vergleich.zeitAtkin.value = rechenzeit_ermitteln(startzeit);
    	document.vergleich.anzahlAtkin.value = count;	// gibt die Anzahl Primzahlen aus	
    } 
    
    Impressum  |   Kontakt  |   Lebenslauf  |   Sitemap  |   Links  |