kleine Mathe-Spielereien

mit matplotlib, NumPy, pandas, SciPy, SymPy und weiteren mathematischen Programmbibliotheken.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Mit diesem kurzen Programm lassen sich in kürzester Zeit sehr hohe Primzahlen er,itteln.
Die Bestimmung von z.B einem Intervall von 2 bis in den Milliardenbereich dauert sicher Stunden oder Tage, je nach
Leistung des Computers.
Mit einem Trick ist die Bestimmung von sehr hohen Primzahlen in Sekunden erledigt.
Beispiel:
Untergrenze 1000000500
Obergrenze 1000000700
Ergebnis :
1000000513
1000000531
1000000579
1000000607
1000000637
1000000637
1000000663
Diese Zahlen -( sind sie vollständig ??, das könnte mandurch Veränderung des Intervalls nachprüfen) wurdenalle durch ein Primfaktorenzerlegungsprogramm bestätigt.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Wie sind die Primzahlen bei sehr hohen Zahlenwerten verteilt ?

Der Versuch zeigt das Ergebnis der Auswertung:

10500 bis 10600 10 Primzahlen
100500 100600 7
1000500 1000600 4
10000500 10000600 5
100000500 100000600 3
1000000500 1000000600 5
10000000500 10000000600 3
100000000500 100000000600 4

ein Vergleich dazu mit größeren Intervallen :
1000000000500 100000000800 10
hier auch die Primzahlen dazu
1000000000519
567 3
579
621
631 4
637
669
703
739 3
747
ergibt sich auch bei größeren ein gleiches Veetewilunsmuster.

Kann daraus ein Verteilungsmuster auf die gesamten Primzahlen geschlossen werden?
Eine Vermutung könnte wohl aufgestellt werden, etwa so wie bereits oben im Plot gezeigt ?

Oswald
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Über Primzahlzwillinge ist eigentlich alles bekannt.
Es gibt komplizierte Programme tzur Ermittlung derselben.
Durch eine kleine Ergänzung meines vorliegendes Programm
konnte ich zwar nicht die kompletten Twillingspaare identifizieren,
aber doch zumindest kennzeichnen
Dabei wird jedes Zwillingspaar durch ein 'Z' erkannt. Der zweite Teil
des Zwillingspaares ist bekannt( n, n+2).

import math


def prim(n):
if n == 2:
return True
if n % 2 == 0:
return False
else:
for i in range(2,int(math.sqrt(n))+1):
if n % i == 0:
return False
return True


unten = int(input ("Anfangswert :", ))
oben = int(input("Maximalwert eingeben: ")) # hier der Zusatz #

for i in range(unten,oben+1):
if prim(i) == True and prim(i) == prim(i+2):

print(i)
print("Z ") # und auch hier #

Dieses kieine Programm zeigt wie mächtig Python ist. Und das machtr einfach Spaß.
Oswald
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Der erste Test für einen hohen Zahlenbereich for Primzahlzwillinge.

Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.

============= RESTART: C:\Python310\Beispiele\PRIMZASHLZwillinge.py ============
Anfangswert :5000000000100
Maximalwert eingeben: 5000000000900
5000000000447
Z
5000000000729
Z
################
Mit 4 GB Hauptspeicher schafft mein Pc diesen hohen Bereich noch ganz gut.
5 Trillonen schaffte er in 30 min nicht mehr. (Abbruch)
Mit mehr Hauptspeicher sollten 1000fach höhere Bereiche geschafft werden.

Der Test beweist die Seltenheit von Primzahlzwillingen in hohen Zahlenbereichen( chin. Mathematiker)
(Wie hoch ist der ekannteste Prim.Zahl.UZw. ?)
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Endlich ist es mir gelungen: Das Programm zur Berechnung aller Primzahlen im Bereich von Unter- bis Obergrenze.
Es war eigentlich einfacher als zunächst angenommen.


import math

def prim(n):
if n == 2:
return True
if n % 2 == 0:
return False
else:
for i in range(2,int(math.sqrt(n))+1):
if n % i == 0:
return False
return True


unten = int(input ("Anfangswert :", ))
oben = int(input("Maximalwert eingeben: "))

pzahl = list
pzahl = []

for i in range(unten,oben+1):

if prim(i) == True :
pzahl == pzahl.append (i)

print(" Anzahl Primzahlen von Anfangswert ", unten, "bis Maximalwert", oben )
print(len(pzahl))
########################################



Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.

============== RESTART: C:\Python310\Beispiele\AnzahlPrimzahlen.py =============
Anfangswert : 2
Maximalwert eingeben: 10000000
Anzahl Primzahlen von Anfangswert 2 bis Maximalwert 10000000
664579
Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.

============== RESTART: C:\Python310\Beispiele\AnzahlPrimzahlen.py =============
Anfangswert :2
Maximalwert eingeben: 1000000
Anzahl Primzahlen von Anfangswert 2 bis Maximalwert 1000000
78498
Hier zwei Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.




============== RESTART: C:\Python310\Beispiele\AnzahlPrimzahlen.py =============
Anfangswert :2
Maximalwert eingeben: 1000000
Anzahl Primzahlen von Anfangswert 2 bis Maximalwert 1000000
78498
#######################################################
Hier zwei erste Ergenisse. Bearbewitungsdauer wenige Sec.
Ein weiterer Versuch mit 100, 000,000 Zahlen musste nach 20 20 min beendet werden. Mein Pc mit 4 GB (LENOVO)
leistet offenbar nicht mehr.
Als nächstes verde ich versuchen , die Anzahl von Primzahlzwillingen in diversen Interavallen zu berechnen.

Zum Ende meiner 'Spielereien bin ich erstaunt , was Python im Vergeich zu anderen Programmiersprachen
aber mit relativ geringem Aufwand zu leisten vermag.
Oswald
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Die Ausgabe von P-Zwillingen wird jetzt verbessert


#################Primzahlwillinge anzeigen
import math


def prim(n):
if n == 2:
return True
if n % 2 == 0:
return False
else:
for i in range(2,int(math.sqrt(n))+1):
if n % i == 0:
return False
return True

Z =" "
unten = int(input ("Anfangswert :" , ))
oben = int(input("Maximalwert eingeben: " ,))

for i in range(unten,oben+1):
if prim(i) == True or prim(i+1) == 'Z' :


print('Z',i )
print(i+2)

Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.

=========== RESTART: C:\Python310\Beispiele\PrimwillingeAnzeigenn.py ===========
Anfangswert :2
Maximalwert eingeben: 50
Z 2
4
Z 3
5
Z 5
7
Z 7
9
Z 11
13
Z 13
15
Z 17
19
Z 19
21
Z 23
25
Z 29
31
Z 31
33
Z 37
39
Z 41
43
Z 43
45
Z 47
49
Sirius3
User
Beiträge: 17711
Registriert: Sonntag 21. Oktober 2012, 17:20

Mit "verbessert" meinst Du, dass jede Primzahle ein Zwilling ist. `prim` liefert nie als Rückgabewert den String "Z".
Die Funktion `prim` liefert immer noch falsche Werte.
Ein `pzahl = list` macht keinen Sinn, wenn die Variable eh gleich danach an eine leere Liste gebunden wird.
Was soll der Vergleich von pzahl mit dem Rückgabewert von append (der immer None ist)?
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Offenbar habe ich mich mißverständlich ausgdrückt.
Natürlich ist nicht jede Primzahl ein Zwilling, aber es sind immer 2 Primzahlen, aus denen
ein Zwilling besteht und genau diese wollte ich anzeigen.
Wenn die Funktion prim() immer noch falsche Werte liefert, sind dann alle hier gezeigten Primzahlen falsch ?
Ist damit das ganze Projekt Quatsch ?
Sollte man niemals versuchen Python als A utodidakt zu erlernen?
__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

Ich sehe da oben eine ganze Reihe von falschen Primzahlen. Nicht alle, aber 15, 21, 25, 33, 39, 45 zb sind nicht prim. Wenn du die hier also als Primzahlen postest, möchtest du dann keinen Hinweis darauf, dass das falsch ist?
Sirius3
User
Beiträge: 17711
Registriert: Sonntag 21. Oktober 2012, 17:20

Natürlich kannst Du Python selbst lernen. Aber Du postest ja hier, um Rückmeldung zu bekommen, ob das so richtig ist. Ist es nicht, die Gründe hab ich Dir genannt. Lernen heißt ja nicht, sofort alles richtig zu machen, sondern Fehler erkennen und verbessern.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Statt 'Verbesserungen' also Bockmist.
Es tut mir leid und ich danke für Ihre Korrekturen.
Darf ich davon ausgehen und hoffe n, dass sich die Fehler auf die Programme mit
P-Zwillingen bezogen und nicht auf die 'einfachen ' Primzahlen ?
Jedenfalls herzlichen Dank für Eure Hinweise.
Benutzeravatar
ThomasL
User
Beiträge: 1366
Registriert: Montag 14. Mai 2018, 14:44
Wohnort: Kreis Unna NRW

Hi Oswald,

falls du diese Webseite noch nicht kennst, kann ich sie dir nur empfehlen: https://primes.utm.edu/

Dort findest du auch Links zu Webseiten, wo man sich Dateien mit -verifizierten- Primzahlen runter laden kann.
Mit diesen Daten kannst du dann einfach überprüfen, ob dein Code richtige Primes liefert oder nicht.
Ich bin Pazifist und greife niemanden an, auch nicht mit Worten.
Für alle meine Code Beispiele gilt: "There is always a better way."
https://projecteuler.net/profile/Brotherluii.png
__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

Also so wie ich das sehe ist nicht die Zwillingsberechnung das Problem. Sondern die Primzahlen selbst. Du prüfst im Grunde nur auf ungerade. Das ist notwendige, aber nicht hinreichende Bedingung für eine Primzahl.
Das war quatsch, ich weiss nicht, wieso ich das uebersehen habe, aber du testest ja mit den Divisoren bis sqrt(zahl), und damit passt das natuerlich :shock:
Sirius3
User
Beiträge: 17711
Registriert: Sonntag 21. Oktober 2012, 17:20

@OSWALD: prim liefert fast immer richtige Ergebnisse. Nur prim(1) ist falsch. Die Prüfung auf Primzahlzwillinge war bei Dir in der ersten Version auch richtig, ich kann mir aber nicht erklären, was Du Dir bei `prim(i) == True or prim(i+1) == 'Z'` gedacht hast. Die einfachste Prüfung wäre `prim(i) and prim(i + 2)`.
__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

@Sirius3: aber prim(1) liefert doch True, und 1 ist eine Primzahl.

Code: Alles auswählen

import math

def prim(n):
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    else:
        for i  in range(2,int(math.sqrt(n))+1):
            if n % i == 0:
                return False
        return True

unten = 1
oben = 50

for zahl in range(unten, oben+1):
    print(zahl, prim(zahl))
Sirius3
User
Beiträge: 17711
Registriert: Sonntag 21. Oktober 2012, 17:20

Nein, 1 ist keine Primzahl.
__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

Ich bin nur nach der simplen Definition gegangen. Aber du hast wohl recht. https://de.wikipedia.org/wiki/Primzahl - alles zu lange her.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

### Programm zur Darstellung von Primzahlzwillingen in beliebigen Intervall###
### fertiggestellt am 21.04.2022 von OSWALD ##

import math


def prim(n):
if n == 2:
return True
if n % 2 == 0:
return False
else:
for i in range(2,int(math.sqrt(n))+1):
if n % i == 0:
return False
return True


unten = int(input ("Anfangswert :", ))
oben = int(input("Maximalwert eingeben: ")) # hier der Zusatz #

for i in range(unten,oben+1):
if prim(i) == True and prim(i) == prim(i+2):
print(i ,"/",( i+2))
####################################################
Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.

============== RESTART: C:\Python310\Beispiele\YZwillingemit Z.py ==============
Anfangswert : 200
Maximalwert eingeben: 500
227 / 229
239 / 241
269 / 271
281 / 283
311 / 313
347 / 349
419 / 421
431 / 433
461 / 463
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

21.02.2022
Prüfung der Zahl von " Primzahzwillingen im hohen Billionenbereich"

Nach einer Laufzeit von genau 30 min wurde abgebrochen.
Bitte nachprüfen, ob die Werte in Ordnung gehen.
Mit einem starken PC ( mit mehr als 4GB Haupt- Speicher dürften sicher noch größere Z-Werte in kürzeren Zeit
erreicht werden.
Ich wage anhand der Ergebnisse fast zu behaupten, dass die PriemzahlZwillinge sich gegen Unendlich stark auf NULL
bewegen könnte.




Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.

=========== RESTART: C:\Python310\Beispiele\ZwillingeV9vBis2020OK.py ===========
Anfangswert : 1000000000000100
Maximalwert eingeben: 10000000000001000
1000000000002371 / 1000000000002373
1000000000002767 / 1000000000002769
1000000000002797 / 1000000000002799
1000000000003001 / 1000000000003003
1000000000004249 / 1000000000004251
1000000000005077 / 1000000000005079
1000000000007147 / 1000000000007149
1000000000008629 / 1000000000008631
1000000000009139 / 1000000000009141
1000000000010717 / 1000000000010719
##################
OSWALD
Sirius3
User
Beiträge: 17711
Registriert: Sonntag 21. Oktober 2012, 17:20

Die Primzahlermittlung ist immer noch falsch. Alle Zahlen durchzuprobieren ist ziemlich langsam, da hilft auch nicht mehr Speicher.
Normalerweise benutzt man ein Sieb, das ziemlich schnell viele Primzahlen aussiebt.
Das geht aus Hauptspeichergründen im Billiardenbereich nicht mehr.

Deshalb nimmt man ein mehrstufiges Sieb. Erst nimmt man ein klassisches Sieb bis zur Wurzel der oberen Grenze des Zahlenbereichs, den man untersuchen will.
Das sind in Deinem Fall nur ein paar Millionen.
Dann siebt man mit diesen Primzahlen den gewünschten Bereich durch:

Code: Alles auswählen

import array

def initialize_primes(max_value):
    sieve = array.array('b', [1]) * (max_value // 2)
    null = array.array('b', [0])
    for i in range(int(max_value ** 0.5) // 2):
        if sieve[i]:
            j = i * 2 + 3
            start = j * j // 2 - 1
            sieve[start :: j] = null * len(range(start, len(sieve), j))
    return [2] + [2 * i + 1 for i, v in enumerate(sieve, 1) if v]

def sieve(start, stop):
    primes = initialize_primes(int(stop**0.5) + 1)
    if start % 2 == 0:
        start += 1
    sieve = array.array('b', [1]) * ((stop - start) // 2)
    null = array.array('b', [0])
    for p in primes[1:]:
        s = - (start % -p)
        if s % 2 == 1:
            s += p
        s //= 2
        sieve[s :: p] = null * len(range(s, len(sieve), p))
    return [start + i * 2 for i, v in enumerate(sieve) if v]


def main():
    start = 1000000000000000
    stop  = 1000000001000000
    primes = sieve(start, stop)
    last_prime = 0
    for prime in primes:
        if last_prime + 2 == prime:
            print(last_prime, '/', prime)
        last_prime = prime

if __name__ == "__main__":
    main()
Antworten