Seite 1 von 2

Große Zahlen

Verfasst: 22.09.2014 17:48
von priverteer
Wie kann ich eine riesige Zahl als .txt speichern ?
Finde leider nichts um Ergebnis$=val(str(Z_String(Number))) zu definieren.

Bin noch Anfänger ( meine Güte ist das V2 vom c64 ewig lange her :) )
Wollte mal wieder einsteigen und dachte mir, ..na ja was einfaches
Vielleicht Primzahlen. Aber, uihh....
Hoffe, mir kann jemand helfen.
----------------

STARGÅTE hatte hier geschrieben http://forums.purebasic.com/german/view ... 81&start=0
( Forumneuling findet zitieren-Button nicht ) post 6

Code: Alles auswählen

Wiki hat geschrieben:
Es ist jedoch kein Verfahren bekannt, das effizient beliebig große Primzahlen generiert, so dass es stets eine größte bekannte Primzahl gab, seitdem sich die Menschen mit Primzahlen befassen. Derzeit ist es 2^32.582.657 - 1, eine Zahl mit 9.808.358 (dezimalen) Stellen, gefunden am 4. September 2006 von einem Professorenteam der Central Missouri State University im Rahmen von George Woltmans GIMPS-Projekt (Great Internet Mersenne Prime Search) zur Suche von Mersenne-Primzahlen. Für den ersten Primzahlbeweis einer Zahl mit mehr als 10 Millionen Dezimalstellen hat die Electronic Frontier Foundation einen Preis von 100.000 US-Dollar ausgeschrieben.
Spaßeshalber hab ich mal: von hier http://www.purebasic.fr/german/viewtopi ... =3&t=28039

Code: Alles auswählen

For n = 1 To 1000000
    NumberString.s + Str(CryptRandom(10))
  Next
Gesetztes Ziel ist: Die größte Primzahl der Welt als .txt zu speichern.
Reicht meine 1.2TB HDD überhaupt dafür aus ? Oder müßte das vorher komprimiert werden ?
Daß man dafür auch noch $100.000 gewinnen kann, für eine 10.000.000-stellige Primzahl,
doppel uuihhh...
P.S.: Benutze z.Zt. 5.11 x64 und hab micht noch nicht registriert.
P.P.S.: For n = 1 To 1000 wird gespeichert als Zahl.

Re: Große Zahlen

Verfasst: 22.09.2014 20:10
von matbal
Das Speichern ist kein Problem. 9.808.358 Stellen bedeutet, 9.808.358 Zeichen speichern. Jedes Zeichen ist ein Byte. Also knapp 10MB.

Das Problem wird sein, das auszurechnen. PureBasic kann nativ mit 64 Bit Ganzzahlen rechnen. Das wäre maximal 2^64 und damit zu wenig, um 2^32.582.657 auszurechnen. Du brauchst also einen eigenen Zahlentyp, der mit so vielen Ziffern umgehen kann. Dazu eigene Mathe-Funktionen, die mit diesen eigenen Zahlentyp rechnen können.

Re: Große Zahlen

Verfasst: 22.09.2014 20:51
von priverteer
Deswegen hatte ich ja dieses hier eingebracht http://www.purebasic.fr/german/viewtopi ... =3&t=28039
Wie kann ich Ergebnis$ auf 5000 MB dimensionieren ?
Na ja, und wie kann ich die Textdatei auf 10MB einstellen ?
Reicht das den aus für 2^32.582.657 - 1 ?

Re: Große Zahlen

Verfasst: 22.09.2014 21:10
von Kiffi
priverteer hat geschrieben:Wollte mal wieder einsteigen und dachte mir, ..na ja was einfaches
[...]
Gesetztes Ziel ist: Die größte Primzahl der Welt als .txt zu speichern.
na dann mal viel Erfolg! :allright:

Re: Große Zahlen

Verfasst: 22.09.2014 21:19
von priverteer
Na ja, ich weis, daß da verschiedene Zahlensysteme ineinandergreifen.
Das sind nicht nur 10MB. Eine Zahl mit 2 Milliarden Stellen braucht mehr als 2 GB.
Hat mal grad jemand die größte Primzahl der Welt als link ??

Re: Große Zahlen

Verfasst: 22.09.2014 21:27
von STARGÅTE
Dem "Z_String(Number)" zu urteilen, verwendest du meine DLL für unlimitierte Ganzzahlen.
Wenn du Z_String(Number) verwendest, dann wird die Zahl bereits als Text ausgegeben, ein Val oder Str ist nicht nötig und auch nicht möglich.
Diesen String kannst du dann als Text mit WriteString() in deine Datei schreiben.

Die Zahl 2^32.582.657-1 hat etwa 10MB in Dezimaldarstellung, somit würde dein Ram und auch deine HDD vällig ausreichen.
Auch ist meine DLL in der Lage, solche Zahlen zu benutzen, allerdings wird es Zeit brauchen, Zahlen auf Primzahlen zu testen.

Re: Große Zahlen

Verfasst: 23.09.2014 07:06
von Nino
Kiffi hat geschrieben:
priverteer hat geschrieben:Wollte mal wieder einsteigen und dachte mir, ..na ja was einfaches
[...]
Gesetztes Ziel ist: Die größte Primzahl der Welt als .txt zu speichern.
na dann mal viel Erfolg! :allright:
Dieses Vorhaben ist auch unter dem Aspekt interessant, dass es gar keine "größte Primzahl der Welt" gibt, sondern unendlich viele Primzahlen (Satz von Euklid).
Also wirklich ein schön einfaches Wiedereinstiegsprojekt! :mrgreen:

Re: Große Zahlen

Verfasst: 24.09.2014 17:01
von hyperG
Gibt es doch schon alles: unter
http://piworld.calico.jp/2_57885161-1.zip
kann man sich 2Hoch57885161-1
herunterladen!!
Und mit http://www.lamprechts.de/gerd/php/Rechn ... nktion.php
habe ich die letzten Stellen (pow(2,57885161) Mod N=100000000000000000000000000)
nachgerechnet
( 1 abziehen)
stimmt: endet mit ...746141988071724285951

Und zu "riesige Zahl": im Vergleich zu den 12 TB von Pi sind diese 17 MB winzig... :-)

Oder brauchst Du Unterstützung bei Multiplikationsfunktionen von Mio-stelligen Zahlen?

Muss es Pure Basic sein, oder bist Du auch mit fertiger Software zufrieden?

Oder bist Du scharf auf das Geld? Es gibt weitere Ausschreibungen für noch mehr Stellen,
ABER: nicht das Ausrechnen von 2^n-1 wird belohnt, sondern der Beweis, dass diese Zahl wirklich keine ganzzahligen Teiler (Primfaktoren) hat!
Es gibt auch "Elliptic Curve Method" zum Suchen von Primzahlen -> zig mal schneller als viele andere Algorithmen!!

Re: Große Zahlen

Verfasst: 28.09.2014 20:48
von hyperG
Habe alles unter http://www.gerdlamprecht.de/Primzahlen.htm
unter 4 b) "offline exakt alle Stellen einer Mersenne-Primzahl ausrechnen" zusammengefasst:

- PureBasic Code für M44
- die Ergebnisse für M44 bis M48

Die getrennten Multiplikationen erlauben des Weiteren den Einsatz von Multitasking.

Re: Große Zahlen

Verfasst: 01.03.2015 14:35
von Helle
Sorry fürs "Aufwärmen", aber habe gerade wieder Lust und ein wenig Zeit.
Größte bestätigte Primzahl ist z.Z. 2^{57.885.161}-1 und wird als M48 (?) geführt. Das "(?)" rührt daher, das 2^{57.885.161}-1 zwar als Primzahl feststeht, aber möglicherweise auch M49 oder M... sein kann, weil der Zahlenbereich vor 2^{57.885.161}-1 noch nicht sicher komplett auf Primzahlen überprüft wurde (sollte dies falsch sein, Gerd, bitte korrigieren!).
Bleiben wir mal bei M48: Maître Fabrice Bellard (der hat was drauf!) hat sich den Spaß gemacht, die Dezimal-Ausgabe von M48 in einen C-Code von 447-Bytes Länge zu quetschen.
Das sieht dann so aus (ist übrigens von F.Bellard als Freeware freigegeben):

Code: Alles auswählen

int m=1711276033,N=1,t[1<<25]={2},a,*p,i,e=39717691,s,c,U=1;g(d,h){for(i=s;i<1<<
24;i*=2)d=d*1LL*d%m;for(p=t;p<t+N;p+=s)for(i=s,c=1;i;i--)a=p[s]*(h?c:1LL)%m,p[s]
=(m*1U+*p-a)*(h?1LL:c)%m,*p=(a*1U+*p)%m,p++,c=c*1LL*d%m;}main(){while(e/=2){N*=2
;U=U*1LL*(m+1)/2%m;for(s=N;s/=2;)g(40,0);for(p=t;p<t+N;p++)*p=*p*1LL**p%m*U%m;
for(s=1;s<N;s*=2)g(983983719,1);for(a=0,p=t;p<t+N;)a+=*p<<(e&1),*p++=a%10,a/=10;
}while(!*--p);for(t[0]--;p>=t;)putchar(48+*p--);}
Ich habe das mal nach PB "übersetzt":

Code: Alles auswählen

;PureBasic 5.31 (x64); Achtung: NUR 64-Bit! 
;M48(?): 	2^{57.885.161}-1, 	17.425.170 Dezimal-Stellen
Global pp.q                  ;ich bin halt ein Fan von Global...
Global pt.q
Global LL1.q = 1
Global U1.q = 1
Global HV1.q                 ;Hilfs-Variable 
Global m.l = 1711276033
Global N.l = 1
Global a.l
Global i.l
Global e.l = 39717691
Global e1.l
Global s.l
Global c.l
Global U.l = 1
Global HV0.l                 ;Hilfs-Variable 
Global Dez_Stellen.l

Global Dim t.l(1 << 25)
  t(0) = 2
  pt = @t(0)                 ;Anfangs-Adresse von Array (t)

Procedure.l g(d, h)
  i = s
  While i < (1 << 24)
    d = (d * LL1 * d) % m
    i << 1
  Wend

  pp = pt                    ;pp=Zeiger in Array t, pt bleibt Anfangs-Adresse von Array t
  While pp < (pt + (N << 2))
    i = s
    c = 1 
    While i
      If h
        a = (PeekL(pp + (s << 2)) * c) % m
       Else
        a = (PeekL(pp + (s << 2)) * LL1) % m
      EndIf
      If h
        PokeL(pp + (s << 2), (((m * U1) + PeekL(pp) - a) * LL1) % m)
       Else
        PokeL(pp + (s << 2), (((m * U1) + PeekL(pp) - a) * c) % m)
      EndIf
      PokeL(pp, ((a * U1) + PeekL(pp))%m)
      pp + 4
      c = (c * LL1 * d) % m
      i - 1
    Wend
    pp + (s << 2)
  Wend
EndProcedure

TA = ElapsedMilliseconds()

e >> 1
While e
  N << 1
  U = ((U * LL1 * (m + 1)) >> 1) % m
  s = N
  s >> 1
  While s
    g(40, 0)
    s >> 1
  Wend

  pp = pt
  While pp < (pt + (N << 2))
    HV0 = PeekL(pp)
    HV1 = HV0 * HV0
    PokeL(pp, ((HV1 % m) * U) % m ) 
    pp + 4
  Wend

  s = 1
  While s < N
    g(983983719, 1)
    s << 1
  Wend

  a = 0
  pp = pt
  e1 = e & 1
  While pp < (pt + (N << 2))
    a + PeekL(pp) << e1
    PokeL(pp, (a % 10))
    pp + 4  
    a / 10
  Wend
  e >> 1
Wend

t(0) - 1
While PeekL(pp) = 0
  pp - 4
Wend

OpenFile(0, "M48_PB.txt") 

For j = pp To pt Step -4
  WriteAsciiCharacter(0, PeekA(j) + 48)
  Dez_Stellen + 1
Next

FreeArray(t())
CloseFile(0)

TE = ElapsedMilliseconds() - TA

MessageRequester("Mersenne M48(?)  2^{57.885.161}-1", Str(Dez_Stellen) + " Dezimal-Stellen in " + Str(TE) + "ms")

Auf meinem i7-4790K mit 4.5 GHz dauert es gut 60 Sekunden, dann sind alle 17.425.170 Dezimal-Stellen auf der Platte! In manchen Wohngegenden dauert der Download länger...

Viel Spaß!
Helle