Primzahlenrechner

[jerch]

@nooby:
Ja, das ist richtig. Mit Deiner Vorgehensweise ist die Sache gut parallelisierbar. Allerdings ist Dein Primzahltest denkbar ineffizient und wird schnell zum Rechengau für größere Zahlenbereiche. Daher meine Anspielung auf den Algorithmus - hier gibt es noch Potential. Das kannst Du relativ einfach rausfinden, wenn Du Dir mal mit Zettel und Stift die Zahlen von 1-20 aufschreibst und anschaust, wie sich die Primzahlen ergeben (Tipp: Sieb des Eratosthenes bzw. verbesserte Versionen davon).

Ah zu langsam

@BlackJack: Da fehlt ein nicht?

[BlackJack]

@jerch: Hm, irgendwie finde ich die Aussage komisch‽ Mal davon abgesehen dass der Algorithmus an sich nicht so dolle ist, lässt der sich doch gut parallisieren und damit macht es schon einen Unterschied ob man einen Prozessor(kern) mit der ganzen Aufgabe beschäftigt, oder mehrere parallel Teilbereiche filtern lässt.

[jerch]

@BlackJack: Naja ich drück mich manchmal verklausuliert aus. Eigentlich wollte ich genau das sagen damit

Ah - jetzt versteh ich das Missverständnis. Ich meinte - es macht kaum einen Unterschied, ob man die Prozessanzahl genau auf die Kernanzahl anpasst oder den einzelnen Kern mit mehreren Aufgaben beschäftigt (mehr Prozesse als Kerne). Das gilt natürlich nicht für beliebige Zerstückelung, da Kommunikation und Zusammenführen der Daten dann sehr aufwändig werden. Aber für die Frage, ob 4 Prozesse passend zu 4 Kernen oder 8 ins Blaue geschossen, ist dieser Aufwand + Prozessgenerierung eher unerheblich.

[nooby]

Ich habe nun das ganze mit dem Sieb des Eratosthenes programmiert. Das lief auch ganz gut, aber wenn wieder gestartet wurde, begann es immer von vorne.
Und ausserdem ist mein Algorithmus fürn Arsch. Er benötigt für alle Zahlen von 1-1000 3 Sekunden. Das ist ja sau langsam:D

Code: Alles auswählen

from datetime import datetime as DateTime
class Eratosthenes():
    def __init__(self, filename):
        self.sieb = []
        self.start = 2
        self.ende = 0
        self.filename = filename
        self.bereits_berechnet()
        self.calculate()
        self.save_primes()
    def calculate(self):
        for x in self.sieb:
            not_primes = []
            for y in range(self.sieb.index(x), len(self.sieb)):
                vielfache = x * self.sieb[y]
                if vielfache <= self.ende:
                    not_primes.append(vielfache)
            for i in not_primes:
                self.sieb.remove(i)
    def save_primes(self):
        with open(self.filename, "a") as prime_file:
            for i in self.sieb:
                prime_file.write(str(i) + "\n")
                prime_file.flush()
    def bereits_berechnet(self):
        result = 2
        try:
            with open(self.filename) as lines:
                for result in lines:
                    pass
            self.start = int(result)
            self.sieb = list(range(self.start, self.ende+1))
        except EnvironmentError:
            self.start = 2
        print('Es wurde bereits bis {0} berechnet.'.format(self.start))
        ende = int(input('Bitte gib ein, wie weit du berechnen möchtest: '))
        self.ende = ende
        self.sieb = list(range(self.start, self.ende+1))
        print(self.sieb)
if __name__ == "__main__":
    start_time = DateTime.now()
    Eratosthenes("test.txt")
    used_time = DateTime.now() - start_time
    print(
        'Super. Es wurden alle Zahlen geprüft.'
        ' Dafür hat dein Computer {0} gebraucht.'.format(used_time)
    )

Könnt ihr mir noch Mals helfen?

//Edit: Diesen Fehler habe ich gefunden. Lag daran, dass ich das Ende noch nicht eingelesen habe, als die Liste erzeugt wurde. Code erneuert (oben). Wenn ich aber bei einer bereits angefangenen Datei weiter machen möchte, schreibt er einach alle Zahlen in die Datei und ich weiss einfach nicht warum.