Autor Beitrag
IhopeonlyReader Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 600
Erhaltene Danke: 23


Delphi 7 PE
BeitragVerfasst: Sa 20.04.13 13:21 
Guten Tag,
ich habe jetzt 2 verschiedene Bit-Boolean Arten! einmal ein auf einer 32 Bit Grundlage, und einmal auf Byte also 8 Bit Grundlage....

Die 32 Bit Grundlage ist von Horst_H umgesetzt worden :)
und die 8 Byte Grundlage mithilfe von jfheins

Die Units haben ich jeweils im Anhang... das einzige was ich dazu sagen kann:
- im "Alle setzen" ist die 8Bit-Variante schneller !
- im erstellen, loeschen, alle lesen nicht testbar (von mir), da die werte immer schwankten, mal das mal das war größer/brauchte mehr zeit
- im Bereich 1 Bit-Boolean zu schreiben, war die Zeit >1ms und somit zu klein für vergleiche/ Delphi zeigte eine benötige zeit von 0 an.

Deshalb würde ich euch einfach mal bitte diese Units auszutesten und evt. sogar verbesserungen vorzuschlagen :)

Danke für eure Hilfe, IHopeonlyReader (<- schon lange nicht mehr nur Leeser :D)
Einloggen, um Attachments anzusehen!
_________________
Sucht "neueres" Delphi :D
Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!


Zuletzt bearbeitet von IhopeonlyReader am Mo 22.04.13 17:53, insgesamt 1-mal bearbeitet
Delphi-Laie
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 1600
Erhaltene Danke: 232


Delphi 2 - RAD-Studio 10.1 Berlin
BeitragVerfasst: Sa 20.04.13 19:44 
user profile iconMathematiker hat folgendes geschrieben Zum zitierten Posting springen:
Sicher gibt es zwei aufeinanderfolgende Primzahlen mit einem Abstand > 32767, aber die kleinste von denen ist nicht bekannt und wahrscheinlich sehr groß.


Zumindest gibt es erste Kandidaten für eine solche Lücke: 32769! (hier ist Fakultät gemeint) und ff. .

Dieser Zahl, die keine Primzahl ist, folgen die Garantiert-Nicht-Primzahlen 32769!+2, 32769!+3, ... , 32769!+32769, das sind genau 32768 aufeinanderfolgende Zahlen, die keine Primzahlen sind. Die Differenz zwischen 32769!+1 zu 32769!+32769 müßte 32768>32767 sein, womit wenigstens diese Bedinung erfüllt ist.

Als nächstes wäre "nur" zu klären, ob 32769!+1 eine Primzahl ist.
32770 ist keine Primzahl, mithin auch 32769!+32770 keine (z.B. ist 2 gemeinsamer Teiler beider Summanden).
32771 ist eine Primzahl. Wäre als nächstes "nur" noch zu klären, ob 32769!+32771 eine Primzahl ist (falls ja, dann wäre die Differenz ohnehin schon größer als das oben angegebene Minimum).

Ich hoffe, daß ich mich jetzt nicht allzusehr vertan habe. Das genannte Prinzip, wo große Lücken zwischen den Primzahlen sich befinden müssen, dürfte aber für die Mathematiker in diesem Forum obertrivial sein.
Mathematiker
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 2622
Erhaltene Danke: 1448

Win 7, 8.1, 10
Delphi 5, 7, 10.1
BeitragVerfasst: Sa 20.04.13 19:58 
Hallo Delphi-Laie,
user profile iconDelphi-Laie hat folgendes geschrieben Zum zitierten Posting springen:
Zumindest gibt es erste Kandidaten für eine solche Lücke: 32769! (hier ist Fakultät gemeint) und ff.

Vollkommen richtig.
user profile iconDelphi-Laie hat folgendes geschrieben Zum zitierten Posting springen:
Als nächstes wäre "nur" zu klären, ob 32769!+1 eine Primzahl ist.

Ist es nicht. Die einzigen Faktorprimzahlen n!+1 bis n = 60000 existieren für
n = 1, 2, 3, 11, 27, 37, 41, 73, 77, 116, 154, 320, 340, 399, 427, 872, 1477, 6380, 26951, ..., 110059, 150209.
Von den letzten beiden weiß man nur, dass sie "wahrscheinlich" Primzahlen sind.

Beste Grüße
Mathematiker

_________________
Töten im Krieg ist nach meiner Auffassung um nichts besser als gewöhnlicher Mord. Albert Einstein
Delphi-Laie
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 1600
Erhaltene Danke: 232


Delphi 2 - RAD-Studio 10.1 Berlin
BeitragVerfasst: Sa 20.04.13 20:02 
Ich meinte natürlich "einen ersten Kandidaten für eine solche Lücke". Wie schön & danke, daß Du es gleich aufklären konntest.
IhopeonlyReader Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 600
Erhaltene Danke: 23


Delphi 7 PE
BeitragVerfasst: Sa 20.04.13 20:53 
user profile iconMathematiker hat folgendes geschrieben Zum zitierten Posting springen:

n = 1, 2, 3, 11, 27, 37, 41, 73, 77, 116, 154, 320, 340, 399, 427, 872, 1477, 6380, 26951, ..., 110059, 150209.
Von den letzten beiden weiß man nur, dass sie "wahrscheinlich" Primzahlen sind.

110059 ist die 10458. Primzahl !
150209 ist die 13867. Primzahl

wann die lücke so groß ist werde ich euch bald sagen ;) (dann werde ich alle Primzahlen bis 16.000.000.000.000.000.000 (4Milliarden)² durchgehen und euch sagen können und bis zu dieser riesig großen zahl eine große lücke entsteht, bzw. wie groß die lücke ist).. ich denke das das relativ bald sein wird :D (evt morgen)

_________________
Sucht "neueres" Delphi :D
Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!
Mathematiker
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 2622
Erhaltene Danke: 1448

Win 7, 8.1, 10
Delphi 5, 7, 10.1
BeitragVerfasst: Sa 20.04.13 21:52 
Hallo,
user profile iconIhopeonlyReader hat folgendes geschrieben Zum zitierten Posting springen:

110059 ist die 10458. Primzahl !
150209 ist die 13867. Primzahl

Du hast etwas falsch verstanden. Nicht 110059 und 150209 sondern 110059!+1 und 150209!+1 sind gemeint, die erste mit mehr 500000 Ziffern, die zweite mit mehr als 710000.
Ich hatte geschrieben:
Zitat:
Die einzigen Faktorprimzahlen n!+1 bis n = 60000 existieren für
n = 1, 2, 3, 11, 27, 37, 41, 73, 77, 116, 154, 320, 340, 399, 427, 872, 1477, 6380, 26951, ..., 110059, 150209.

Wenn Du aber die nachfolgende Tabelle mit Deiner neuen Unit erweitern könntest, wäre das schon sehr gut. Die Tabelle enthält die gegenwärtig bekannten aufeinanderfolgenden, monoton wachsenden maximalen Abstände von benachbarten Primzahlen.

Beste Grüße
Mathematiker

Anhang: Tabelle der größten wachsenden Abstände benachbarter Primzahlen
ausblenden volle Höhe Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
Abstand  ab  bis
1  2  3
2  3  5
4  7  11
6  23  29
8  89  97
14  113  127
18  523  541
20  887  907
22  1129  1151
34  1327  1361
36  9551  9587
44  15683  15727
52  19609  19661
72  31397  31469
86  155921  156007
96  360653  360749
112  370261  370373
114  492113  492227
118  1349533  1349651
132  1357201  1357333
148  2010733  2010881
154  4652353  4652507
180  17051707  17051887
210  20831323  20831533
220  47326693  47326913
222  122164747  122164969
234  189695659  189695893
248  191912783  191913031
250  387096133  387096383
282  436273009  436273291
288  1294268491  1294268779
292  1453168141  1453168433
320  2300942549  2300942869
336  3842610773  3842611109
354  4302407359  4302407713
382  10726904659  10726905041
384  20678048297  20678048681
394  22367084959  22367085353
456  25056082087  25056082543
464  42652618343  42652618807
468  127976334671  127976335139
474  182226896239  182226896713
485  241160024143  241160024628
490  297501075799  297501076289
500  303371455241  303371455741
514  304599508537  304599509051
516  416608695821  416608696337
532  461690510011  461690510543
534  614487453423  614487453957
540  738832927927  738832928467
582  1346294310749  1346294311331
588  1408695493609  1408695494197
602  1968188556461  1968188557063
652  2614941710599  2614941711251
674  7177162611713  7177162612387
716  13828048559701  13828048560417
766  19581334192423  19581334193189
778  42842283925351  42842283926129
804  90874329411493  90874329412297
806  171231342420521  171231342421327
906  219209405436543  219209405437449
916  1189459969825483  1189459969826399
924  1686994940955803  
1132  1693182318746371
1184  43841547845541059
1198  55350776431903243
1220  80873624627234849
1370  418032645936712127
1442  804212830686677669
1476  1425172824437699411

_________________
Töten im Krieg ist nach meiner Auffassung um nichts besser als gewöhnlicher Mord. Albert Einstein
IhopeonlyReader Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 600
Erhaltene Danke: 23


Delphi 7 PE
BeitragVerfasst: Sa 20.04.13 23:02 
Da fehlt aber was, wenn ich das richtig verstehe !

deine 7 ist der Abstand von 14.. was mit dem Abstand von 10?
das erste aufeinanderfolgende primzahlen-paar mit dem abstand 10 sind
139 und 149.. ein anderes Beispiel: 337 und 347

Habe ich das jetzt falsch verstanden oder ist die Tabelle wirklich nicht vollständig?
weil zum Abstand von 12, 16, 24, 26, 28, 30, 32 etc. fehlen die paare ja immer..

_________________
Sucht "neueres" Delphi :D
Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!
Mathematiker
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 2622
Erhaltene Danke: 1448

Win 7, 8.1, 10
Delphi 5, 7, 10.1
BeitragVerfasst: Sa 20.04.13 23:19 
Hallo,
es geht um das Wachstum der maximalen Primzahlabstände.
Nach dem Abstand 8 zwischen 89 und 97 ist der nächste größere Abstand schon die 14 zwischen 113 und 127.
Abstand 10 folgt erstmals bei 139-149, Abstand 12 bei 199-211. Der größere Abstand 14 war aber eben schon früher aufgetreten.

Eine Tabelle, die für alle möglichen Abstände das kleinste Paar angibt, könnte man auch erstellen. Vielleicht mache ich das einmal.

Beste Grüße
Mathematiker

Nachtrag: Mit dem kleinen Programm
ausblenden volle Höhe Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
procedure TForm1.Button1Click(Sender: TObject);
var abstand:array[1..1000of cardinal;
    a,i,j,grenze:cardinal;
    z:integer;
begin
    fillchar(abstand,sizeof(abstand),0);
    listbox1.clear;
    i:=3;
    j:=5;
    a:=1;
    grenze:=strtoint(edit1.text);
    repeat
      while not istprime(j) do j:=j+2;
      z:=j-i;
      if (z<1001and (abstand[z]=0then
      begin
        abstand[z]:=i;
        listbox1.items.add(format('%4d'#9'%d'#9'%d',[z,i,j]));
      end;
      i:=j;
      j:=j+2;
      inc(a);
      if a mod 100000 = 0 then
      begin
        label2.caption:=inttostr(j);
        application.processmessages;
      end;
    until j>grenze;
    z:=2;
    repeat
      if abstand[z]=0 then listbox1.items.add(format('%4d'#9'-',[z]));
      z:=z+2;
    until z>1000;
    listbox1.items.savetofile('liste2.000');
end;

habe ich schnell mal die Liste mit den kleinsten Paaren erstellt, die einen geradzahligen Abstand haben.
istprime ist die Routine, die ich beim Moser-Problem nutze. www.entwickler-ecke....rProblem_111412.html
Gesucht habe ich bis 1 Milliarde. Der kleinste nicht gefundene Abstand ist 254, der größte gefundene 282.
Einloggen, um Attachments anzusehen!
_________________
Töten im Krieg ist nach meiner Auffassung um nichts besser als gewöhnlicher Mord. Albert Einstein
IhopeonlyReader Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 600
Erhaltene Danke: 23


Delphi 7 PE
BeitragVerfasst: Sa 20.04.13 23:48 
ok, also sozusagen ein weiteres dyn. Array anlegen und die Primzahlen "normal errechnen" und danach die liste der Primzahlen durchgehen und den Abstand zwischen Primzahl[X-1] und Primzahl[X] errechnen und wenn Abstand > AltAbstand dann zum dyn. Array hinzufügen, das heißt man könnte bis zur "Maximal-Errechenbar-Primzahl" auch den größten Abstand errechnen..

P.S: ich habe gerade germerkt, dass mein Programm THEÒRETISCH bis (4Mrd)² die Primzahlen errechnen könnte!, allerdings wären das 1.862.645.149 GB (1,9 Milliarde GB)
da ich natürlich nicht soviel Ram habe, ist das natürlich nicht möglich :/
Mein Maximum liegt bei ca 12.884.901.890 Millarden.. somit kann ich maximal alle Primzahlen bis 12,8 Milliarden errechnen.. mit der Optimierung dass ich nur "ungerade" zahlen verwende (+1 wegn der 2) dann käm ich bis ca 25 Milliarden..

Und: Mathematiker: "die einen geradzahligen Abstand haben".. ein ungerade Abstand ist (außer bei dem Abstand 1 (von 2 zu 3)) NIE möglich ! denn x,y <- Primzahlen (also ungerade, sonst vielfaches von 2) und x-y-> ungeradezahl-ungeradezahl -> geradezahl (also ist der abstand immer GERADE)

Edit1: Der Abstand von 254 ist gefunden :P
bei dem Primzahlenpaar: 1202442343 und 1202442089

_________________
Sucht "neueres" Delphi :D
Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!


Zuletzt bearbeitet von IhopeonlyReader am Sa 20.04.13 23:58, insgesamt 1-mal bearbeitet
Mathematiker
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 2622
Erhaltene Danke: 1448

Win 7, 8.1, 10
Delphi 5, 7, 10.1
BeitragVerfasst: Sa 20.04.13 23:57 
Hallo,
user profile iconIhopeonlyReader hat folgendes geschrieben Zum zitierten Posting springen:
Mein Maximum liegt bei ca 12.884.901.890 Millarden.. somit kann ich maximal alle Primzahlen bis 12,8 Milliarden errechnen.. mit der Optimierung dass ich nur "ungerade" zahlen verwende (+1 wegn der 2) dann käm ich bis ca 25 Milliarden..

Ich bin schon gespannt.
user profile iconIhopeonlyReader hat folgendes geschrieben Zum zitierten Posting springen:
Mathematiker: "die einen geradzahligen Abstand haben".. ein ungerade Abstand ist (außer bei dem Abstand 1 (von 2 zu 3)) NIE möglich ! denn x,y <- Primzahlen (also ungerade, sonst vielfaches von 2) und x-y-> ungeradezahl-ungeradezahl -> geradezahl (also ist der abstand immer GERADE)

Natürlich ist das so. Die Liste enthält aber nicht den Abstand 1. Und um was wollen wir wetten, dass garantiert einer im Forum mich freundlich daraufhinweisen würde, dass dieser Abstand fehlt. :wink: Und deshalb der Kommentar "geradzahliger Abstand".
Aber es ist nett von Dir, dass Du es für mich beweist. :roll:

Ich habe nochmals bis 2 Milliarden gesucht (Rev 1 der Liste2). Der kleinste nicht gefundene Abstand ist nun 264, der größte gefundene 292.

Beste Grüße
Mathematiker

_________________
Töten im Krieg ist nach meiner Auffassung um nichts besser als gewöhnlicher Mord. Albert Einstein
IhopeonlyReader Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 600
Erhaltene Danke: 23


Delphi 7 PE
BeitragVerfasst: So 21.04.13 00:03 
Mathematiker: Der kleinste nicht gefundene Abstand ist nun 264:


Nicht mehr:
2357881993 und 2357882257

Edit: das fehlende paar zu dem fehlenden Abstand von 286 lautet:
2842739311 und 2842739597 (und ein weiteres liegt bei ca 4,05 mrd)

_________________
Sucht "neueres" Delphi :D
Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!
Mathematiker
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 2622
Erhaltene Danke: 1448

Win 7, 8.1, 10
Delphi 5, 7, 10.1
BeitragVerfasst: So 21.04.13 08:36 
Hallo,
ich habe mein altes Primzahlsieb wieder ausgekramt und für die Suche nach Primzahlabständen modifiziert. Grundlage ist user profile iconGammatester mp_arith.
Blockweise werden jeweils 5 Millionen Zahlen gesiebt und danach ausgewertet. Abstände ermittle ich nur ab 200 und die Startzahl sollte auch nicht kleiner als 100 Millionen sein.

Natürlich ist dies nicht so schnell wie Dein Sieb, hat aber den Vorteil, dass es nach "oben offen" ist.
Wenn Dein Computer schnell genug ist und Du ihn quälen willst, kannst Du auch bis in die Billionen hinein suchen.
Mein PC ist im Moment bei 14 Milliarden und bis 332 sind alle Abstände gefunden.

Beste Grüße
Mathematiker

Nachtrag: Ab 30827138509 folgt ein Abstand mit 334. Jetzt bis 35 Milliarden gesucht und kein Paar für 362.
Nachtrag 2: Ich habe eine Erweiterung (Rev 1) eingebaut. Markiert man Weiterrechnen, so werden bei Abbruch die erzielten Ergebnisse in liste.txt gespeichert und beim Neustart an dieser Stelle weitergerechnet.
Jetzt bin ich bei 52 Milliarden. Der kleinste fehlende Wert ist 370, bis 1000 fehlen insgesamt noch 297 Paare.

Rev 2: user profile iconHorst_H hat einen bösen Fehler in meinem Programm gefunden. Ich hoffe, dass er jetzt behoben ist. Danke für den Hinweis.
Einloggen, um Attachments anzusehen!
_________________
Töten im Krieg ist nach meiner Auffassung um nichts besser als gewöhnlicher Mord. Albert Einstein


Zuletzt bearbeitet von Mathematiker am Mo 22.04.13 11:44, insgesamt 1-mal bearbeitet
IhopeonlyReader Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 600
Erhaltene Danke: 23


Delphi 7 PE
BeitragVerfasst: So 21.04.13 15:38 
Freut mich :)
Und ich denke in meinem prog brauch ich das nicht einbauen.. denn
1. mein prog geht nur bis 12 Milliarden und
2. ich bin mir nichtmal mehr sicher, dass meins schneller ist^^
denn vorher habe ich die primzalhne bis 4 Milliarden in ca 15 sek ausgerechnet.. inzwischen bin ich bei nur noch 50 sek (Bit-Boolean)..

ich wüsste zwar jetzt weitere "verkleinerungsmaßnahmen" wie Array halbieren, da nur ungerade zahlen Primzahlen sein können, oder Nach 4 Mrd BooleanArray gegen Int Array ersetzen und nur "richtige" abspeicher.. sozusagen wird aus
Bool[1] (false)
Bool[2] (true)
Bool[3] (true)
Bool[4] (false)
Bool[5] (true)

dann

Int[1] := 2;
Int[2] := 3;
Int[4] := 5;

webei ich natürlich dann wie schon erwähnt wurde nur die Differenz abspeichern müsste, hierdurch wäre kein 32Bit Variable nötig, sondern eine 16bit variante würde reichen (z.B. Word)

aber das würde alles die rechenzeit so stark erhöhen, dass ich mich jetzt daran mache ein nach oben offenes sieb zu programmieren

Denn: ich denke DIREKT auf Minimialer Ram zu programmieren ist letztendlich schneller, als auf Zeit zu programmieren und dann auf Ram zu optimieren

_________________
Sucht "neueres" Delphi :D
Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!
Horst_H
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 1654
Erhaltene Danke: 244

WIN10,PuppyLinux
FreePascal,Lazarus
BeitragVerfasst: So 21.04.13 16:13 
Hallo,

@user profile iconMathematiker:
Wie kannst Du bis 52x1e9 nur noch 297 fehlende haben:
primes.utm.edu/notes/GapsTable.html
Zitat:

gap Auftreten bei
463 42.652.618.343
467 127.976.334.671

Mist, Du bist bei 52x10e9 Primzahl also bei
Zitat:
803 90.874.329.411.493 [Nicely99]


Tatsächlich hat mein Programm 2h17 min für die Primzahlen bis 1e12 gebraucht.
Zitat:
539 738832927927 .. 738832928467

Aber ich habe noch das Auftreten der Abstände gezählt, die im unterern Bereich nicht stimmt, weil ich vorgesiebtes Sieb nutze, in dem 2,3,5,7,11,13 und deren Vielfache fehlen.
Exemplarisch
Zitat:
479 4
477 2
475 2
473 10
471 3
469 4
467 5
465 2
463 3
461 12
...
19 1298682892
17 2246576317
15 1202533146
13 1556469349
11 2753597777
9 2052293026


12 und 18 kommen als Abstand am häufigsten vor.

Gruß Horst

Edit 16:40 Uhr:
In so hohen Zahlbereichen ist so simples sieben zu langsam.50,8 Mio zahlen zu verarbeiten, wovon über 99 % ( ab 10 Mio) bei jedem Durchgang nicht im Sieb landen ist sehr uneffektiv.
deshalb hatte Gammatester mal vorgeschlagen einfach mit den ersten Primzahlen bis 2^16 zu sieben und dann erst Miller-Rabin zu starten.Wenn die 6542 Zahlen gesiebt haben, wobei Zahl und Uebertrag vom Typ word sein können und dann der Test kommt, muss ich hier noch 50.8 Mio Zahlen ( Zahl Dword, Uebertrag int64 )verarbeiten.In der Zeit kann man viele Miller-Rabin Tests machen.
Einloggen, um Attachments anzusehen!

Für diesen Beitrag haben gedankt: Mathematiker
Mathematiker
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 2622
Erhaltene Danke: 1448

Win 7, 8.1, 10
Delphi 5, 7, 10.1
BeitragVerfasst: So 21.04.13 16:58 
Hallo Horst_H,
user profile iconHorst_H hat folgendes geschrieben Zum zitierten Posting springen:
Tatsächlich hat mein Programm 2h17 min für die Primzahlen bis 1e12 gebraucht.

Gratulation. Das ist richtig schnell. Für 1 Billion brauche ich geschätzt 16 Stunden.
user profile iconHorst_H hat folgendes geschrieben Zum zitierten Posting springen:
In so hohen Zahlbereichen ist so simples sieben zu langsam.50,8 Mio zahlen zu verarbeiten, wovon über 99 % ( ab 10 Mio) bei jedem Durchgang nicht im Sieb landen ist sehr uneffektiv.

Deshalb siebe ich mit 41537 Primzahlen (ohne 2) bis 499979 und überlasse den Rest dem Rabin-Miller-Test.

Nachdem ich gesehen habe, dass das Thema im Netz schon soweit abgearbeitet ist, dass schon Paare mit 2000 und mehr Abstand gefunden wurden (wohin ich mit meinem Programm nie komme), habe ich die Suche auf "einsame Primzahlen" abgeändert.
Unter einer einsamen Primzahl versteht man eine Primzahl p, deren Summe s der Abstände zur vorhergehenden und zur nachfolgenden Primzahl größer ist, als bei jeder vorhergehenden Primzahl.
Zum Beispiel ist die 211 eine einsame Primzahl. Die vorhergehende Primzahl ist 199, die nachfolgende 223. Deren Abstand ist mit 24 so groß, wie bei keiner Primzahl < 211.

Dazu habe ich im Netz noch nicht viel gefunden. Man kann also "Geschichte schreiben". :wink:
Gegenwärtig ist mein Programm bei 13 Milliarden (15 Minuten) und hat als größte einsame Primzahl 10726905041; Abstand 438 von 10726904659 bis 10726905097 gefunden.

Beste Grüße
Mathematiker

_________________
Töten im Krieg ist nach meiner Auffassung um nichts besser als gewöhnlicher Mord. Albert Einstein
IhopeonlyReader Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 600
Erhaltene Danke: 23


Delphi 7 PE
BeitragVerfasst: So 21.04.13 17:23 
Wunderbar :) soviele Primzahl Verwendungszwecke^^

Mathematiker: du beschäfitgst dich also mit "einsamen Primzahlen"
Horst_H: du beschäftigst dich also mit dem Abstand?

Dann werde ich mal zurückspringen und eine Liste der "immer größer werdenden Abstände zwischen den Primzahlen" erstellen (bis 4 Mrd)

Und: @alle^^ warum kann Delphi nicht über 2^32 -1 hinaus ? (ja Delphi ist eine 32-Bit Anwendung und somit ist 2^32 -1 die größte mögliche zahl...)
aber Cardinal*Cardinal = >2^32 -1 ... IMMER ! hierdruch erreiche ich viele Fehler :(
also Beispiel:
4 Mrd * 2 = 8Mrd (wäre logisch) mein Delphi spuckt aber ganz komische zahlen aus... (z.B. 3.705.032.704 also ca 3,7 Mrd)

Ihr könnt es ja auch mal testen:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
var   C,X: Cardinal;
begin
X := 4000000000;
C := 2;
Showmessage( IntToStr(  C*X ) );
end;

hierdurch kann nich nämlich keine Primzahlen > 2^32 -1 errechnen :(

teilweise wird auch:
Zitat:

Überlauf bei Konvertierung oder arithmetischer Operation
ausgegeben...

_________________
Sucht "neueres" Delphi :D
Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!
mandras
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 432
Erhaltene Danke: 107

Win 10
Delphi 6 Prof, Delphi 10.4 Prof
BeitragVerfasst: So 21.04.13 17:30 
Cardinal ist vorzeichenloser Int, insofern halt bis 2^32-1.
Dein Ergebnis sind die Bits 0-31 des korrekten Produktes.

Für Größere Zahlen: int64 nehmen
IhopeonlyReader Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 600
Erhaltene Danke: 23


Delphi 7 PE
BeitragVerfasst: So 21.04.13 20:08 
user profile iconIhopeonlyReader hat folgendes geschrieben Zum zitierten Posting springen:

1 im "Alle setzen" ist die 8Bit-Variante schneller !
2 im erstellen, loeschen, alle lesen nicht testbar (von mir), da die werte immer schwankten, mal das mal das war größer/brauchte mehr zeit
Deshalb würde ich euch einfach mal bitte diese Units auszutesten und evt. sogar verbesserungen vorzuschlagen :)

Da sich dazu noch keiner wirklich geäußert hat... habe ich mein Sieb des Eratosthenes mal auf beide Varianten aufgebaut.. (dank der Units nur 3 kleine Änderungen (uses list ändern, typ von TBitBooleans8 zu TBitBooleans32 ändern, beim erstellen anstatt TBitBooleans8.erstellen(Anzahl) TBitBooleans32.erstellen(Anzahl)) also die 8 durch 32 ersetzten

Bei vielfachen Lesen und schreiben, sind hier ein paar Verwerte zum Vergleich:
Zitat:

Basis (8 oder 32)...............Primzahlen bis:...............Initialiserung (alle Setzen)...............Zeit (für alle Berechnungen und Zugriffe auf Booleans)
8..............................100mio..............................0,03..................................................2,668
32..............................100mio..............................0,58..................................................2,21

8..............................1 Mrd...............................0,28..................................................28,174
32..............................1 Mrd...............................5,43..................................................24,54

8..............................2 Mrd................................0,53.................................................57,877
32..............................2 Mrd................................11,51................................................50,099

8..............................3 Mrd................................0,76.................................................92,261
32..............................3 Mrd................................16,5.................................................77,66

8..............................4 Mrd................................1,03 ................................................120,104
32..............................4 Mrd................................21,6 ................................................104,5

Fazit: Zum einzelnen Lesen/Schreiben ist die Bit-Boolean Variante aufbauend auf 32 Bit schneller ( ca 13% schneller )
Allerdings braucht man zum initialisieren ca 20x so lang! Somit ist die GesamtZeit größer als die zum 8 Bit Variante...
Wenn es eine Möglichkeit gäbe, die 32-Booleans aufeinmal auf True/False zu setzen wäre die 32 Bit variante geeigneter, so allerdings ist bei kleinen Berechnungen die 8 Bit Variante besser :)

(Für alle die sich fragen warum das so ist: 1. Schaut euch die Units doch einfach an^^... das liegt daran, dass bei der 8Bit Variante Byte als Grundlage genommen wird, wenn man also alle Bits auf True setzen will, setzt man den ganzen Byte auf 255 (2^8 -1), will man alle Bits in dem Byte auf 0 setzten so genügt es das Byte auf 0 zu setzen.. Bei der 32er Variante wird jedes einzelne Bit durchgeganen)
um 64 Bit-Booleans auf True zu setzen, wird bei der 32-variante 2x32 Bits auf 1 gesetzt, bei der 8-variante 8x1Byte auf 255 gesetzt
somit stehen 64 den 8 gegenüber... ebenfalls dauert es länger ein Bit auf True zu setzen, als ein Byte einem Wert zuzuweisen (komisch?!)
hierdurch entsteht das 20 zu 1 verhältnis

_________________
Sucht "neueres" Delphi :D
Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!
IhopeonlyReader Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 600
Erhaltene Danke: 23


Delphi 7 PE
BeitragVerfasst: So 21.04.13 20:18 
wieso wird gesagt
if ( (VMrd)>=floor(power(T, 1/2))) then
ergäbe immer True? wenn T>(4Mrd)² ist dann nicht! oder sieht Delphi dann nur den Bereich bis 2^64 -1 (aber selbst dann.. die wurzel davon wäre nämlich ca 2^32 und somit >4Mrd?

_________________
Sucht "neueres" Delphi :D
Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!
jfheins
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 918
Erhaltene Danke: 158

Win 10
VS 2013, VS2015
BeitragVerfasst: So 21.04.13 20:48 
Aber beim 32bit kann man das doch genau so machen??

ausblenden Delphi-Quelltext
1:
2:
3:
var x: Cardinal;
begin x := $FFFFFFFF;
end;
oder so...