1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

function prim(zahl:integer):boolean;  //Funktion zum Prüfen auf Primzahl
var teiler:integer;
    wurzel:extended;
begin
teiler:=1;
result:=true;
wurzel:=sqrt(zahl);

while ((teiler<=wurzel) and (teiler<>(zahl-1)) and result) do
      begin
      if (odd(zahl) or (zahl=2)) then
        begin
        teiler:=teiler+1;
        if ((zahl mod teiler)=0) then
         result:=false;
        end
      else
        result:=false;
      end;
end;                    

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:

function Prim (Zahl: Real): String;
var
  Zaehler: Integer;
  Wurzel: Integer;
begin
  if (Zahl = 2) OR (Zahl = 3) OR (Zahl = 5) then
  begin
    Result := 'Prim';
    Exit;
  end;

  Wurzel := Round(sqrt(Zahl));
  Zaehler := 2;

  repeat
    if frac(Zahl / Zaehler) = 0 then
    begin
      Result := 'keine Prim';
      Exit;
    end;
    inc(Zaehler);
  until Zaehler = Wurzel;

  Result := 'Prim';
end;                    

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:

function Prim (Zahl: Real): String;  
var  
  Zaehler: Integer;  
  Wurzel: double;  
begin  
  if (Zahl = 2) OR (Zahl = 3) OR (Zahl = 5) then  
  begin  
    Result := 'Prim';  
    Exit;  
  end;  
//  Wurzel := Round(sqrt(Zahl));  //Runden kosten Zeit
  Wurzel := sqrt(Zahl);
  Zaehler := 2;  
  repeat  
//    if frac(Zahl / Zaehler) = 0 then  // frac ist "Arschlangsam"
// in Testläufen war der Test mit frac 10 - 30 mal langsamer als die modulo operation
    if (Zahl mod Zaehler) = 0 then
    begin  
      Result := 'keine Prim';  
      Exit;  
    end;  
    Inc(Zaehler);  
  until Zaehler >= Wurzel;  
  Result := 'Prim';  
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

function Prim (Zahl: Real): String;
var
  Zaehler: Integer;
  Wurzel: double;
  Z64: Int64;
begin
  if (Zahl = 2) OR (Zahl = 3) OR (Zahl = 5) then
  begin
    Result := 'Prim';
    Exit;
  end;
  Wurzel := sqrt(Zahl);
  Zaehler := 2;
  Z64 := Trunc(Zahl);  // so kann man real und mod verwenden
  repeat
    if (Z64 mod Zaehler) = 0 then
    begin
      Result := 'keine Prim';
      Exit;
    end;
    Inc(Zaehler);
  until Zaehler > Wurzel;  // da war in der vorherigen variante der fehlerteufel
  Result := 'Prim';
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

procedure TForm1.StartButClick(Sender: TObject);
var
  Start, Ende: Real;
  X: Integer;
  Erg: String;
begin
  Start := GetTickCount;

  for X := StrToInt(VonEdit.Text) to StrToInt(BisEdit.Text) do
  begin
    Erg := Prim(X);
    if Prim(X) = 'Prim' then
      PrimMemo.Lines.Add(IntToStr(X) + ': Prim');
  end;

  Ende := GetTickCount;
  DauerLab.Caption := 'Diese Überprüfung hat ' + FloatToStr((Ende - Start) / 1000) + ' Sekunden gedauert.'
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

function Prim (Zahl: Real): String;
var
  Zaehler: Integer;
  Wurzel: double;
  Z64: Int64;
begin
  Z64 := Trunc(Zahl);
  if Odd(Z64) then
  begin
    Result := 'Prim';
    Exit;
  end;
  Wurzel  := sqrt(Zahl);
  Zaehler := 3;        
  repeat
    if (Z64 mod Zaehler) = 0 then
    begin
      Result := 'keine Prim';
      Exit;
    end;
    Inc(Zaehler,2);     //nur ungerade teiler prüfen
  until (Zaehler > Wurzel);
  Result := 'Prim';
end;                    

1:
2:
3:
4:
5:

function Prim (Zahl: Real): boolean;
begin
...
Result:= true;
end;                    

1:
2:
3:
4:
5:

  if (Zahl = 2) OR (Zahl = 3) OR (Zahl = 5) then
  begin
    Result := 'Prim';
    Exit;
  end;                    

1:

Inc(Zaehler, 2)                    

1:
2:
3:
4:
5:
6:
7:
8:

var
  Prim: TStringList;
begin
  Prim := TStringList.Create;
  Prim.Add(Primzahl);
  Prim.SaveToFile('Pfad');
  Prim.Free;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

function Prim (Zahl: Real): Boolean;
var
  Zaehler: Integer;
  Wurzel: Double;
  Z64: Int64;
begin
  if (Zahl = 2) OR (Zahl = 3) then
  begin
    Result := True;
    Exit;
  end;
  Wurzel := sqrt(Zahl);
  Zaehler := 3;
  Z64 := Trunc(Zahl);
  repeat
    if (Z64 mod Zaehler) = 0 then
    begin
      Result := False;
      Exit;
    end;
    Inc(Zaehler, 2);
  until Zaehler > Wurzel;
  Result := True;
end;                    

1:
2:
3:
4:
5:
6:
7:

  for X := StrToInt(VonEdit.Text) to StrToInt(BisEdit.Text) do
  begin
    if Prim(X) then
      PrimS.Add(IntToStr(X));
      Application.ProcessMessages;
      PrimLab.Caption := 'Aktuelle Primzahl: ' + IntToStr(X);
  end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

function Prim (Zahl: Real): Boolean;
var
  Zaehler: Integer;
  Wurzel: Double;
  Z64: Int64;
begin
  if (Zahl = 2) OR (Zahl = 3) then
  begin
    Result := True;
    Exit;
  end;
  Wurzel := sqrt(Zahl);
  Zaehler := 2;
  Z64 := Trunc(Zahl);
  repeat
    if (Z64 mod Zaehler) = 0 then
    begin
      Result := False;
      Exit;
    end;
    Inc(Zaehler);//Du musst doch jede Zahl durchgehen, ob sie Teiler ist!!!!! und dann bitte auch von zwei an....dann muss das funzen
  until Zaehler > Wurzel;
  Result := True;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

function prim(zahl:integer):boolean;
var teiler:integer;
    wurzel:extended;
begin
result:=true;
teiler:=3;
if ((zahl mod 2)=0) then  //Zahl gerade
 result:=false
else
  begin
  if (zahl=2) then
    exit
  else
    begin
    while ((teiler<=wurzel) and result) do
      begin
      if ((zahl mod teiler)=0) then
        result:=false;
      inc(zahl,2);
      end;
    end;
end;                    

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:

function Prim (Zahl: Real): Boolean;
var
  Zaehler: Integer;
  Wurzel: Double;
  Z64: Int64;
begin
  Z64 := Trunc(Zahl);
  if (Zahl = 2) OR (Zahl = 3) then
    Exit;
  if (Z64 mod 2 = 0) OR (Zahl = 1) then
  begin
    Result := False;
    Exit;
  end;
  Wurzel := sqrt(Zahl);
  Zaehler := 3;
  repeat
    if (Z64 mod Zaehler) = 0 then
    begin
      Result := False;
      Exit;
    end;
    Inc(Zaehler, 2);
  until Zaehler >= Wurzel;
  Result := True;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

function Prim (Zahl: Integer): Boolean;
var
  Teiler: Integer;
  Wurzel: Double;
begin
  Teiler := 3;
  Wurzel := sqrt(Zahl);
  while ((Teiler <= Wurzel) AND (result)) do
  begin
    if Zahl mod Teiler = 0 then
    begin
      Result := False;
      Break;
    end;
    inc(Teiler, 2);
  end;
end;                    

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:

procedure TMainForm.StartButClick(Sender: TObject);
var
  Start, Ende: Real;
  X, Von, Bis: Integer;
begin
  PrimS := TStringList.Create;
  PrimS.Add('2');
  PrimS.Add('3');

  Von := StrToInt(VonEdit.Text);
  Bis := StrToInt(BisEdit.Text);

  if Von < 4 then
    Von := 4;

  Start := GetTickCount;

  for X := Von to Bis do
  begin
    if odd(X) then
    begin
      if Prim(X) then
      begin
        PrimS.Add(IntToStr(X));
        Application.ProcessMessages;
        PrimLab.Caption := 'Aktuelle Primzahl: ' + IntToStr(X);
      end;
    end;
  end;

  Ende := GetTickCount;
  DauerLab.Caption := 'Diese Überprüfung hat ' + FloatToStr((Ende - Start) / 1000) + ' Sekunden gedauert.';

  PrimS.SaveToFile('test.txt');
  PrimS.Free;
end;                    

1:
2:
3:
4:
5:
6:
7:

  if Von < 4 then
  begin
    Von := 4;
    PrimS.Add('1');
    PrimS.Add('2');
    PrimS.Add('3');
  end;                    

1:
2:

if (zahl<4) then
exit;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

  if Von = 1 then  
  begin  
    Von := 4;  
    PrimS.Add('1');  
    PrimS.Add('2');  
    PrimS.Add('3'); 
  end;

  if Von = 2 then  
  begin  
    Von := 4;  
    PrimS.Add('2');  
    PrimS.Add('3'); 
  end;

  if Von = 3 then  
  begin  
    Von := 4;   
    PrimS.Add('3'); 
  end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

function Prim (Zahl: Integer): Boolean;
var
  Teiler: Integer;
  Wurzel: Double;
begin
  Teiler := 3;
  Wurzel := sqrt(Zahl); 
  result:=true;  //Hier solltest du auf jeden fall vorher result auf true setzten...sonst ist die Beleggung ja dem Zufall überlassene
  while ((Teiler <= Wurzel) AND (result)) do
  begin
    if Zahl mod Teiler = 0 then
    begin
      Result := False;
      Break;
    end;
    inc(Teiler, 2);
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

function prim(i: integer): boolean;
var i2:integer;
begin
i2 := i mod 2;
if i2 > 0 then
begin
result := true;
end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

  while ((Teiler <= Wurzel) AND (Result)) do
  begin
    if Zahl mod StrToInt(PrimS.Strings[Teiler]) = 0 then
    begin
      Result := False;
      Break;
    end;
    inc(Teiler, 2);
  end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

function isPrim(Zahl: Cardinal): Boolean;
var Teiler, MaxTeiler: Cardinal;
begin
  if zahl<2 then begin
    Result:=False;
    Exit;
  end;

  Result:=True;
  if Zahl=2 then Exit;

  MaxTeiler:=Trunc(Sqrt(Zahl));

  for Teiler:=2 to MaxTeiler do
    if Zahl mod Teiler = 0 then begin
      Result:=False;
      Break;
    end;
end;                    

1:
2:
3:
4:
5:
6:
7:

for Teiler := 2 to MaxTeiler do begin
  if Zahl mod Teiler = 0 then begin
    Result := False;
    Break;
  end;
  Inc(Teiler);
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

  while ((Teiler <= Wurzel) AND (Result)) do
  begin
    if Trunc(Zahl / StrToInt(PrimS.Strings[Teiler])) = 0 then
    begin
      Result := False;
      Break;
    end;
    inc(Teiler, 1);
  end;                    

1:
2:
3:
4:
5:

if X = Step then
        begin
          Application.ProcessMessages;
          inc(Step, 10000);
        end;                    

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:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:

Program PrimProj;

{$APPTYPE CONSOLE}

Uses
    SysUtils,
    Classes,
    Forms;

Function MkLang(Zahl, Ziffern: Integer): String;
Var
    Str: String;
    X: Integer;
Begin
    For X := 1 To Ziffern Do
        Str := Str + '0';
    Result := Copy(Str + IntToStr(Zahl), Length(IntToStr(Zahl)) + 1, Ziffern);
End;

Type
  TArrayInt64 = Array[0..0] Of Int64;
  PArrayInt64 = ^TArrayInt64;
Var
  FS: TFileStream;
  Primzahlen: PArrayInt64;
  CurrNum, CurrPrimIdx, MaxPrim, MaxTest: Int64;
  IsPrim, DoTest: Boolean;
  TmpSqrt: Extended;
  Tmp: String;
  STime, ETime: TDateTime;
  PrimCount, PrimMemSize: Integer;

  MS, SS, MM, HH, DD: WORD;
Begin
  MaxPrim := 0;
  While MaxPrim = 0 Do
  Try
    WriteLn('Bis zu welcher Zahl wollen Sie die Primzahlen ermitteln???');
    ReadLn(MaxPrim);
  Except
    MaxPrim := 0;
    Continue;
  End;
  STime := Now;
  GetMem(Primzahlen, 65536);
  PrimMemSize := 65536;
  CurrNum := 2;
  Primzahlen[0] := CurrNum;
  PrimCount := 0;
  Inc(CurrNum);
  Try
    Try
      While CurrNum <= MaxPrim Do
      Begin
        TmpSqrt := CurrNum;
        TmpSqrt := Sqrt(TmpSqrt); //Maximaler Testfaktor
        MaxTest := Round(TmpSqrt);

        IsPrim := true; //Primzahl = ja
        CurrPrimIdx := 0; //Aktuelle Position
        DoTest := CurrPrimIdx <= PrimCount; //Im Bereich???

        If DoTest Then //Wenn ja, ...
        Begin
          IsPrim := (TmpSqrt <> Trunc(TmpSqrt));
          DoTest := IsPrim And (Primzahlen[CurrPrimIdx] <= MaxTest);
        End;

        While DoTest Do
        Begin
          IsPrim := CurrNum Mod Primzahlen[CurrPrimIdx] <> 0;
          Inc(CurrPrimIdx); //Nächste Primzahl testen...
          DoTest := IsPrim And (CurrPrimIdx <= PrimCount); //Noch im Bereich???
          If DoTest Then //Wenn ja, ...
          Begin
            DoTest := Primzahlen[CurrPrimIdx] <= MaxTest;
          End;
        End;

        If IsPrim Then
        Begin
          If PrimCount shl 3 + 8 >= PrimMemSize Then
          Begin
            PrimMemSize := PrimMemSize Shl 1;
            ReallocMem(Primzahlen, PrimMemSize);
          End;
          Inc(PrimCount);
          Primzahlen[PrimCount] := CurrNum;
          If PrimCount And $FFF = 0 Then
            Write(IntToStr(CurrNum) + #9);
        End;
        Inc(CurrNum, 2);
      End;
      ETime := Now;
      WriteLn(#13#10);
      Write('Ermitteln der Primzahlen fertig');
      If STime <> ETime Then
      Begin
        WriteLn(': ' + IntToStr(Round((MaxPrim - 1) / ((ETime - STime)
          * 86400))) + ' geprüfte Zahlen pro Sekunde'#13#10);
        DecodeTime(STime, HH, MM, SS, MS);
        DecodeTime(ETime, DD, MM, SS, HH);
        DD := Trunc(ETime - STime);
        WriteLn('Startzeit: ' + DateTimeToStr(STime) + '.' + MkLang(MS,
          3));
        WriteLn('Endzeit:   ' + DateTimeToStr(ETime) + '.' + MkLang(HH,
          3));
        DecodeTime(ETime - STime, HH, MM, SS, MS);
        WriteLn('----------------------------------');
        WriteLn('Benötigt:  ' + Format('%10d %s.%s.%s.%s', [DD,
          MkLang(HH, 2), MkLang(MM, 2), MkLang(SS, 2), MkLang(MS,
            3)]));
      End
      Else
        WriteLn;
    Except
      On E: Exception Do
      Begin
        WriteLn('Fehler ' + E.ClassName + ': ' + E.Message);
      End;
    End;
  Finally
    WriteLn(#13#10,
      'Bitte warten!!!'#13#10'Die gesammelten Daten der Primzahlen werden gespeichert!!!');
    Try
      FS := TFileStream.Create(ChangeFileExt(Application.ExeName,
        '.prm'),
        fmCreate Or fmShareDenyWrite);
      Try
        FS.Size := 0;
        FS.Write(Primzahlen[0], (PrimCount + 1) * SizeOf(Int64));
        WriteLn('Es wurden ' + IntToStr(FS.Size Div SizeOf(Int64)) +
          ' Primzahlen gespeichert ...');
      Finally
                FS.Free;
            End;
        Except
            On E: Exception Do
                WriteLn('Fehler ' + E.ClassName + ': ' + E.Message);
        End;
        FreeMem(Primzahlen);
        Read(Tmp);
    End;
End.                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

function Prim(Zahl: LongInt): Boolean;
var
  Teiler, Wurzel: LongInt;
begin
  Result := True;
  if (not odd(Zahl)) OR (Zahl <= 5) then
  begin
    if (Zahl <> 2) AND (Zahl <> 3) AND (Zahl <> 5) then
      Result := False;
    Exit;
  end;
  Teiler := 0;
  Wurzel := Trunc(sqrt(Zahl));
  while (Teiler <= Wurzel) AND (Result) do
  begin
    if Zahl mod PrimS[Teiler] = 0 then
      Result := False;
    inc(Teiler);
  end;
end;                    

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:

procedure TMainForm.StartButClick(Sender: TObject);
var
  Start, Ende: Real;
  X, Z, Step, LPrim: Integer;
begin
  try
    Von := StrToInt(VonEdit.Text);
    Bis := StrToInt(BisEdit.Text);

    SetLength(PrimS, Bis+1);
    Step := 10000;
    LPrim := 0;
    Z := 0;

    if (Von >= 0) AND (Bis >= 0) AND (Von < Bis) then
    begin
      Start := GetTickCount;

      for X := Von to Bis do
      begin
        if Prim(X) then
        begin
          PrimS[Z] := X;
          LPrim := X;
          Inc(Z);
        end;
        if X = Step then
        begin
          Application.ProcessMessages;
          PrimLab.Caption := 'Aktuelle Primzahl: ' + IntToStr(LPrim);
          inc(Step, 10000);
        end;
      end;

      Ende := GetTickCount;
      DauerLab.Caption := 'Diese Überprüfung hat ' + FloatToStr((Ende - Start) / 1000) + ' Sekunden gedauert.';
    end
    else
      ShowMessage('Ungültige Eingabe(n)!');
  except
    ShowMessage('Es ist ein Fehler aufgetreten!');
  end;
end;                    

1:

application.OnIdle:=findprim;                    

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:

procedure TForm1.findprim(Sender: TObject; var Done: Boolean);
var
a,b,c:integer;
begin
//repeat
if gefunden<soll then
begin
 b:=floor(sqrt(gefunden)); // Suche wird bis
 for a:=1 to b do          //
  if zutesten-sqr(floor(sqrt(zutesten)))<>0 then
   if (zutesten mod primz[a])= 0
    then begin isprim:=false;break end
    else isprim:=true;
 if isprim=true then
 begin
  gefunden:=gefunden+1;
  primz[gefunden]:=zutesten;
  edit2.text:=inttostr(gefunden);
  edit3.Text:=inttostr(zutesten);

 end;
 zutesten:=zutesten+1;
done:=false;
end;
end;                    

1:
2:
3:
4:
5:
6:

  while (Teiler <= Wurzel) AND (Result) do  
  begin  
    if Zahl mod PrimS[Teiler] = 0 then  
      Result := False;  
    inc(Teiler);  
  end;                    

1:
2:
3:
4:
5:
6:

  while (PrimS[Teiler] <= Wurzel) AND (Result) do  
  begin  
    if Zahl mod PrimS[Teiler] = 0 then  
      Result := False;  
    inc(Teiler);  
  end;                    

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:

var
  PrimS: Array of Cardinal;

function Prim(Zahl: Cardinal): Boolean;
var Wurzel: Cardinal; Teiler: PCardinal;
begin
  Result := True;
  if not odd(Zahl) OR (Zahl <= 5) then
  begin
    if (Zahl <> 2) AND (Zahl <> 3) AND (Zahl <> 5) then
      Result := False;
    Exit;
  end;
  Teiler := @PrimS[0];
  Wurzel := Trunc(sqrt(Zahl));
  while Teiler^ <= Wurzel do
  begin
    if Zahl mod Teiler^ = 0 then begin
      Result := False;
      Break;
    end;
    Inc(Teiler);
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
const
  Von = 0;
  Bis = 1000000;
var
  Start, Ende: Single;
  X, LPrim: Cardinal;
  Z: PCardinal;
begin
  SetLength(PrimS, Bis);
  Z := @PrimS[0];
  LPrim := 0;
  Start := GetTickCount;

  for X := Von to Bis do begin
    if Prim(X) then begin
      Z^ := X;
      Inc(Z);
      LPrim := X;
    end;
    if X mod 50000 = 0 then begin
      Application.ProcessMessages;
      Label1.Caption := 'Aktuelle Primzahl: ' + IntToStr(LPrim);
    end;
  end;

  Ende := GetTickCount;
  Label2.Caption := 'Diese Überprüfung hat ' + FloatToStr((Ende - Start) / 1000) + ' Sekunden gedauert.';
end;                    

1:

SetLength(PrimS, Bis);                    

1:

SetLength(PrimS, Trunc(0.4*Bis+1));                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

Bis zu welcher Zahl wollen Sie die Primzahlen ermitteln???
1000000

[...]

Ermitteln der Primzahlen fertig: 1015227 geprüfte Zahlen pro Sekunde

Startzeit: 28.11.2004 14:46:38.218
Endzeit:   28.11.2004 14:46:39.203
----------------------------------
Benötigt:           0 00.00.00.985                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

Bis zu welcher Zahl wollen Sie die Primzahlen ermitteln???
16777216

[...]

Ermitteln der Primzahlen fertig: 520224 geprüfte Zahlen pro Sekunde

Startzeit: 28.11.2004 14:58:53.734
Endzeit:   28.11.2004 14:59:25.984
----------------------------------
Benötigt:           0 00.00.32.250

Die gesammelten Daten der Primzahlen werden gespeichert!!!
Es wurden 1077871 Primzahlen gespeichert ...                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

function Prim(Zahl: Cardinal): Boolean;
var
  Teiler: PCardinal;
  Wurzel: Cardinal;
begin
  Result := True;    // Result = True
  if not odd(Zahl) OR (Zahl <= 5) then    // Ist die Zahl nich ungerade oder kleiner als 5, dann
  begin
    if (Zahl <> 2) AND (Zahl <> 3) AND (Zahl <> 5) then    // Ist die Zahl nicht 2 und nicht 3 und nicht 5, dann
      Result := False;    // Result = False
    Exit;                 // Exit
  end;
  Teiler := @PrimS[0];    // Teiler = @PrimS[0]
  Wurzel := Trunc(sqrt(Zahl));    // Wurzel aus der Zahl
  while Teiler^ <= Wurzel do    // Solange Teiler^ <= Wurzel ist, mache
  begin    
    if Zahl mod Teiler^ = 0 then    // Ist Zahl / Teiler^ = Rest 0, dann
    begin
      Result := False;    // Result = False
      Break;    // Break
    end;
    Inc(Teiler);    // Teiler erhöhen um 1
  end;
end;                    

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:

procedure TMainForm.StartButClick(Sender: TObject);
var
  Start, Ende: Real;
  Z: PCardinal;
  X, LPrim: Cardinal;
  PrimF: TStringList;
begin
  try
    Von := StrToInt(VonEdit.Text);    // Start
    Bis := StrToInt(BisEdit.Text);    // Endwert

    if Bis > 10 then
      SetLength(PrimS, Trunc(0.4*Bis-(Bis/4)))    // Größe des Array: 0.4*Bis-(Bis/4)
    else
      SetLength(PrimS, 4);

    LPrim := 0;    // Letze Prim = 0
    Z := @PrimS[0];     // Gefundene Prims = 0

    if (Von >= 0) AND (Bis >= 0) AND (Von < Bis) then    // Von >= 0; Bis >= 0; Von < Bis;
    begin
      Start := GetTickCount;    // Start-Zeit

      for X := Von to Bis do    // Schleife: Startwert -> Endwert
      begin
        if Prim(X) then    // Funktion ausführen, wenn Prim dann
        begin
          Z^ := X;    // Prim in Array schreiben
          Inc(Z);    // Z erhöhen um 1
          LPrim := X;    // Letze Prim = X
        end;
        if X mod 20000 = 0 then    // Wenn X : 20.000 = Rest 0, dann
        begin
          Application.ProcessMessages;    // Anwendung aktualisieren
          PrimLab.Caption := 'Aktuelle Primzahl: ' + IntToStr(LPrim);    // Akt. Primzahl anzeigen
        end;
      end;

      Ende := GetTickCount;    // End-Zeit
      DauerLab.Caption := 'Diese Überprüfung hat ' + FloatToStr((Ende - Start) / 1000) + ' Sekunden gedauert.';    // Dauer anzeigen

      PrimLab.Caption := 'Speichern...';    // "Speichern..." anzeigen

      Z := @PrimS[0];    // Z auf 0 stellen
      PrimF := TStringList.Create;    // Stringlist erzeugen

      for X := 0 to Length(PrimS)-1 do    // Von 0 bis Größe des Array
      begin
        if Z^ = 0 then    // Wenn Z^ = 0, dann
          Break;    // Break
        PrimF.Add(IntToStr(Z^));    // Prim in Stringlist schreiben
        Inc(Z);    // Z erhöhen um 1
      end;

      PrimF.SaveToFile('Paket.prim');    // Stringlist speichern
      PrimF.Free;    // Stringlist freigeben

      PrimLab.Caption := 'Aktuelle Primzahl: ' + IntToStr(LPrim);    // Akt. Primzahl anzeigen
    end
    else
      ShowMessage('Ungültige Eingabe(n)!');    // Bei falschen Eingaben, Nachricht anzeigen
  except
    ShowMessage('Es ist ein Fehler aufgetreten!');    // Wenn Fehler auftritt, Nachricht anzeigen
  end;
end;                    

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:

var
  PrimS: TMemoryStream;

function Prim(Zahl: Cardinal): Boolean;
var Teiler, Wurzel: Cardinal;
begin
  Result := True;
  if not odd(Zahl) OR (Zahl <= 5) then
  begin
    if (Zahl <> 2) AND (Zahl <> 3) AND (Zahl <> 5) then
      Result := False;
    Exit;
  end;
  PrimS.Position:=0;
  PrimS.Read(Teiler, SizeOf(Teiler));
  Wurzel := Trunc(sqrt(Zahl));
  while Teiler <= Wurzel do
  begin
    if Zahl mod Teiler = 0 then begin
      Result := False;
      Break;
    end;
    PrimS.Read(Teiler, SizeOf(Teiler));
  end;
  prims.Position:=prims.Size;
end;

procedure TForm1.Button1Click(Sender: TObject);
const
  Von = 0;
  Bis = 15485863; // das ist die 1 millionste Primzahl :-)
var
  Start, Ende: Single;
  X, LPrim: Cardinal;
  PrimF: TStringList;
begin
  PrimS:=TMemoryStream.Create;
  try
    LPrim := 0;
    Start := GetTickCount;
    for X := Von to Bis do begin
      if Prim(X) then begin
        PrimS.Write(X, SizeOf(X));
        LPrim := X;
      end;
      if X mod 50000 = 0 then begin
        Application.ProcessMessages;
        Label1.Caption := 'Aktuelle Primzahl: ' + IntToStr(LPrim);
      end;
    end;
    Ende := GetTickCount;
    Label1.Caption:='Aktuelle Primzahl: ' + IntToStr(LPrim);
    Label2.Caption:='Anzahl der gefundenen Primzahlen: '+ IntToStr(PrimS.Size div 4);
    Label3.Caption:='Diese Überprüfung hat ' + FloatToStr((Ende - Start) / 1000) + ' Sekunden gedauert.';

    PrimF := TStringList.Create;
    PrimS.Position:=0;
    while Prims.Position<>Prims.Size do begin
      PrimS.Read(X, SizeOf(X));
      PrimF.Add(IntToStr(X));
    end;
    PrimF.SaveToFile('Paket.prim');
    PrimF.Free;

  finally
    PrimS.Free;
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

      for X := 0 to Length(PrimS)-1 do    // Von 0 bis Größe des Array
      begin
        Application.ProcessMessages;
        if Z^ = 0 then    // Wenn Z^ = 0, dann
          Break;    // Break
        PrimLab.Caption := 'Speichern... (' + IntToStr(X+1) + ' / ' + IntToStr(Length(PrimS)) + ')';    // "Speichern..." anzeigen
        PrimF.Add(IntToStr(Z^));    // Prim in Stringlist schreiben
        Inc(Z);    // Z erhöhen um 1
      end;                    

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:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:

function IsPrime(N: Cardinal): Boolean; register; 
// test if N is prime, do some small Strong Pseudo Prime test in certain bounds 
// not PIC safe !! 
// very fast, about 1200 clockcycles 
// copyright by Hagen Reddmann, don't remove this line 
asm 
       TEST  EAX,1            // Odd(N) ?? 
       JNZ   @@1 
       CMP   EAX,2            // N == 2 ?? 
       SETE  AL 
       RET 
@@1:   CMP   EAX,73           // N  < 73 ?? 
       JB    @@C 
       JE    @@E              // N == 73 ?? 
       PUSH  ESI 
       PUSH  EDI 
       PUSH  EBX 
       PUSH  EBP 
       PUSH  EAX              // save N as Param for @@5 
       LEA   EBP,[EAX - 1]    // M == N -1, Exponent 
       MOV   ECX,32           // calc remaining Bits of M and shift M' 
       MOV   ESI,EBP 
@@2:   DEC   ECX 
       ADD   ESI,ESI 
       JNC   @@2 
       PUSH  ECX              // save Bits as Param for @@5 
       PUSH  ESI              // save M' as Param for @@5 
       CMP   EAX,08A8D7Fh     // N >= 9080191 ?? 
       JAE   @@3 
// now if (N < 9080191) and SPP(31, N) and SPP(73, N) then N is prime 
       MOV   EAX,31 
       CALL  @@5              // 31^((N-1)(2^s)) mod N 
       JC    @@4 
       MOV   EAX,73           // 73^((N-1)(2^s)) mod N 
       PUSH  OFFSET @@4 
       JMP   @@5 
// now if (N < 4759123141) and SPP(2, N) and SPP(7, N) and SPP(61, N) then N is prime 
@@3:   MOV   EAX,2 
       CALL  @@5 
       JC    @@4 
       MOV   EAX,7 
       CALL  @@5 
       JC    @@4 
       MOV   EAX,61 
       CALL  @@5 
@@4:   SETNC AL 
       ADD   ESP,4 * 3 
       POP   EBP 
       POP   EBX 
       POP   EDI 
       POP   ESI 
       RET 
// do a Strong Pseudo Prime Test 
@@5:   MOV   EBX,[ESP + 12]   // N on stack 
       MOV   ECX,[ESP +  8]   // remaining Bits 
       MOV   ESI,[ESP +  4]   // M' 
       MOV   EDI,EAX          // T = b, temp. Base 
@@6:   DEC   ECX 
       MUL   EAX 
       DIV   EBX 
       MOV   EAX,EDX 
       ADD   ESI,ESI 
       JNC   @@7 
       MUL   EDI 
       DIV   EBX 
       AND   ESI,ESI 
       MOV   EAX,EDX 
@@7:   JNZ   @@6 
       CMP   EAX,1            // b^((N -1)(2^s)) mod N ==  1 mod N ?? 
       JE    @@A 
@@8:   CMP   EAX,EBP          // b^((N -1)(2^s)) mod N == -1 mod N ?? , EBP = N -1 
       JE    @@A 
       DEC   ECX              // second part to 2^s 
       JNG   @@9 
       MUL   EAX 
       DIV   EBX 
       CMP   EDX,1 
       MOV   EAX,EDX 
       JNE   @@8 
@@9:   STC 
@@A:   RET 
@@B:   DB    3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71 
@@C:   MOV   EDX,OFFSET @@B 
       MOV   ECX,18 
@@D:   CMP   AL,[EDX + ECX] 
       JE    @@E 
       DEC   ECX 
       JNL   @@D 
@@E:   SETE  AL 
end;                    

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:
72:

procedure TMainForm.StartButClick(Sender: TObject);
var
  Start, Ende: Real;
  Z: PCardinal;
  X, Y, LPrim: Cardinal;  // Hier
  PrimF: TStringList;
  CountP: String;
begin
  try
    Von := StrToInt(VonEdit.Text);
    Bis := StrToInt(BisEdit.Text);

    if Bis > 10 then
      SetLength(PrimS, Trunc(0.4*Bis-(Bis/4)))
    else
      SetLength(PrimS, 4);

    LPrim := 0;
    Z := @PrimS[0];
    Y := 0;  // Hier

    if (Von >= 0) AND (Bis >= 0) AND (Von < Bis) then
    begin
      Start := GetTickCount;

      for X := Von to Bis do
      begin
        if Prim(X) then
        begin
          Z^ := X;
          Inc(Z);
          Inc(Y);  // Hier
          LPrim := X;
        end;
        if X mod 20000 = 0 then
        begin
          Application.ProcessMessages;
          PrimLab.Caption := 'Aktuelle Primzahl: ' + IntToStr(LPrim);    // Akt. Primzahl anzeigen
        end;
      end;

      Ende := GetTickCount;
      DauerLab.Caption := 'Diese Überprüfung hat ' + FloatToStr((Ende - Start) / 1000) + ' Sekunden gedauert.';

      CountP := IntToStr(Y);
      PrimLab.Caption := 'Speichern... (0 / ' + CountP + ')';

      PrimF := TStringList.Create;

      for X := 0 to Length(PrimS)-1 do
      begin
        if PrimS[X] = 0 then
          Break;
        if X mod 1000 = 0 then   // Hier
        begin
          Application.ProcessMessages;
          PrimLab.Caption := 'Speichern... (' + IntToStr(X+1) + ' / ' + CountP + ')';
        end;
        PrimF.Add(IntToStr(PrimS[X]));
      end;

      PrimF.SaveToFile('Paket.prim');
      PrimF.Free;

      PrimLab.Caption := 'Aktuelle Primzahl: ' + IntToStr(LPrim);
    end
    else
      ShowMessage('Ungültige Eingabe(n)!');
  except
    ShowMessage('Es ist ein Fehler aufgetreten!');
  end;
end;                    

1:
2:
3:
4:
5:
6:

    //MaxTest := Trunc(Sqrt(CurrNum*1.0));
    Asm
        FILD    QWORD PTR [CurrNum]
        FSQRT
        FISTP   QWORD PTR [MaxTest]
    End;                    

1:
2:
3:
4:
5:
6:
7:

    Asm
        FLDCW   WORD PTR [@@TruncCW]
        JMP     @@Skip
        @@TruncCW:
        DW      $1772   //Immer abwärts runden
        @@Skip:
    End;                    

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:

procedure SavePrimes(MaxPrime: Cardinal; const FileName: String = '');    
var
  isPrime: Array of Boolean;
  i, j: Cardinal;
  SL: TStringList;
begin
  SetLength(isPrime, MaxPrime+1);
  FillChar(isPrime[2], Length(isPrime)-2, 1);
  for i:=2 to Trunc(Sqrt(MaxPrime)) do
    if isPrime[i] then begin
      j:=i*2;
      while j<=MaxPrime do begin
        isPrime[j]:=False;
        Inc(j, i);
      end;
    end;

  if FileName<>'' then begin
    SL:=TStringList.Create;
    try
      for i:=2 To MaxPrime do
        if isPrime[i] then
          SL.Add(IntToStr(i));
      SL.SaveToFile(FileName);
    finally
      FreeAndNil(SL);
    end;
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

    FillChar(PrimeGrid, SizeOf(PrimeGrid), #1);
    PrimeGrid[1] := False;
    for CurrPrimeCandidate := 2 to MAX_PRIME do
    begin
      if PrimeGrid[CurrPrimeCandidate] then
      begin
        NotAPrime := CurrPrimeCandidate * 2;
        while NotAPrime <= MAX_PRIME do
        begin
          PrimeGrid[NotAPrime] := False;
          Inc(NotAPrime, CurrPrimeCandidate);
        end;
      end;
    end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

Function IsPrim(zahl : Integer): boolean;
var
i: integer;
begin
  result := true;
  If zahl = 1 then
  begin
    result := false;
    exit;
  end;
  For i := 2 to (zahl div 2) do
  begin
    If ((zahl mod i) = 0) then
    begin
      result := false;
      exit;
    end;
  end;
end;                    

1:

For i := 2 to (zahl div 2) do                    

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:

procedure SavePrimes(MinPrime, MaxPrime: Cardinal; const FileName: String = '');
var
  isPrime: Array of Cardinal; 
  i, j: Cardinal;
  SL: TStringList;
begin
  SetLength(isPrime, MaxPrime div 32);
  FillChar(isPrime[0], Length(isPrime)*SizeOf(Cardinal), MAXBYTE); // alle bits auf 1 setzten
  isPrime[0]:=$FFFFFFFC; // bit 0 und 1 ist keine primzahl

  for i:=2 to Trunc(Sqrt(MaxPrime)) do
    if isPrime[i div 32] shr (i mod 32) and 1=1 then begin
      j:=i*2;
      while j<=MaxPrime do begin
        isPrime[j div 32]:=isPrime[j div 32] and not (1 shl (j mod 32));
        Inc(j, i);
      end;
    end;

  if FileName<>'' then begin
    SL:=TStringList.Create;
    try
      for i:=MinPrime To MaxPrime do
        if isPrime[i div 32] shr (i mod 32) and 1=1 then
          SL.Add(IntToStr(i));
      SL.SaveToFile(FileName);
    finally
      FreeAndNil(SL);
    end;
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

function tform1.Prim(Zahl: LongInt): Boolean;
var
  Teiler, Wurzel: LongInt;
  p1prim:PTprim;
begin
  Result := True;
  p1prim:=startprim;
  if (not odd(Zahl)) OR (Zahl <= 5) then
  begin
    if (Zahl <> 2) AND (Zahl <> 3) AND (Zahl <> 5) then
      Result := False;
    Exit;
  end;
  Wurzel := Trunc(sqrt(Zahl));
  while (p1prim^.prim <= Wurzel) AND (Result) do
  begin
    if Zahl mod p1prim^.prim = 0 then
      Result := False;
    p1prim:=p1prim^.nextprim;
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

 if prim(zutesten) then
 begin
  new(P1prim);
  p1prim^.nextprim:=nil;
  lastprim^.nextprim:=p1prim;
  p1prim^.prim:=zutesten;
  lastprim:=p1prim;
  inc(zutesten)
 end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

procedure TForm1.FormCreate(Sender: TObject);
var
a,b,c:integer;
p1prim:PTprim;
begin
 new(startprim);
 new(P1prim);
 startprim^.prim:=2;
 startprim^.nextprim:=P1prim;
 p1prim^.prim:=3;
 p1prim^.nextprim:=nil;
 lastprim:=p1prim;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
var
p1prim,p2prim:PTprim;
begin
p1prim:=startprim;
while p1prim^.nextprim<>nil do
begin
p2prim:=p1prim;
p1prim:=p1prim^.nextprim;
dispose(p2prim);
end;
dispose(p1prim);
end;                    

1:
2:
3:
4:
5:

 
  PTPrim=^TPrim;
  TPrim =record
   prim:integer;
   nextprim:PTPrim;                    

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:

Program primzahlen;
{$APPTYPE CONSOLE}

uses
  SysUtils;

Const max = 1000000;
Var primzahl    : Array[1..max] Of Integer;
    ergebnis    : Boolean;
    zahln,index : Integer;
    testzahlen  : Array[1..max] Of Integer;
    
Procedure primtest(testzahl : Integer);
Var zaehler : Integer;
Begin
  ergebnis := false;
  If (testzahl<3) Then exit;
  zaehler := 1;
  Repeat
    zaehler := zaehler + 1;
    If (testzahl Mod zaehler) = 0 Then ergebnis := true  
                                  Else ergebnis := false;
  Until (ergebnis) Or (zaehler >= SQRT(testzahl))
End;

Begin
  index := 1;
  For zahln := 2 To max Do
  Begin
    primtest(zahln);
    If Not(ergebnis) Then
    Begin
      primzahl[index] := zahln;
      index := index + 1
    End
  End;
  For zahln := 2 To max Do testzahlen[zahln] := zahln;
  For zahln := 1 To index-1 Do
    Begin
      Write(primzahl[zahln]:8);
      If zahln Mod 5 = 0 Then Writeln
    End;
  Readln
End.                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

while i < bisw do           //Wurzel von bis                                          
begin                                                                 
i := i+i + 2*i*i;             //Das Quadrat von i ausrechnen, hab ich oben erklärt
 while i < bis do                                                 
 begin                                                            
  if Primfeld.bits[i] = false then
  begin
  Primfeld.bits[i] := true;  
  l := l+1;
  end;
  i := i + x;                                                 
 end;                                                             
i := z + 1;                                                           
 while Primfeld.bits[i] = true do                                 
 begin
 i := i+1;                                                           
 end;                                                             
z := i;                                                               
x := i+i+1;                                                           
end;                    

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:

procedure SavePrimes1(MinPrime, MaxPrime: Cardinal; const FileName: String = '');
var                                  //
  i, l, x, z: Cardinal;
  SL: TStringList;
  Primfeld: TBits;
begin
  Primfeld:=TBits.Create;
  Primfeld.Size:=MaxPrime;
  i:=0; l:=0; x:=0; z:=0;
  while i < Trunc(Sqrt(MaxPrime)) do begin          //Wurzel von bis
    i:=i+i + 2*i*i;             //Das Quadrat von i ausrechnen, hab ich oben erklärt
    while i < MaxPrime do begin
      if Primfeld.bits[i] = false then begin
        Primfeld.bits[i] := true;
        l:=l+1;
      end;
      i:=i+x;
    end;
    i:=z+1;
    while Primfeld.bits[i] = true do
      i:=i+1;
    z:=i;
    x:=i+i+1;
  end;

  //
  // Ausgabe
  //

  Primfeld.Free;
end;                    

1:
2:
3:
4:

if Prim = True then
  Prim := 1
else
  Prim := 0;                    

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:

procedure SavePrimes(MinPrime, MaxPrime: Cardinal; const FileName: string = '');
var
  isPrime: array of Cardinal;
  i, j: Cardinal;
  SL: TStringList;
begin
  SetLength(isPrime, MaxPrime shr 5);
  isPrime[0]:=$00000003; // bit 0 und 1 ist keine primzahl

  for i:=2 to Trunc(Sqrt(MaxPrime)) do
    if isPrime[i shr 5] and (1 shl (i mod 32)) = 0 then begin
      j:=i*i;
      while j<=MaxPrime do begin
        isPrime[j shr 5]:=isPrime[j shr 5] or (1 shl (j mod 32));
        Inc(j, i);
      end;
    end;

  if FileName<>'' then begin
    SL:=TStringList.Create;
    try
      for i:=MinPrime To MaxPrime do
        if isPrime[i shr 5] and (1 shl (i mod 32)) = 0 then
          SL.Add(IntToStr(i));
      SL.SaveToFile(FileName);
    finally
      FreeAndNil(SL);
    end;
  end;
end;                    

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:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:

var
  Start:    Single;
  Ende:     Single;
  ZList:    Array of Byte;
  CheckSch: Integer;
  NrCount:  Integer;
  PosCount: Integer;
  Zahl:     Cardinal;
  Max:      Cardinal;
  PrimF:    TStringList;
begin
  if (not (TryStrToInt(VonEdit.Text, Von))) OR
     (not (TryStrToInt(BisEdit.Text, Bis))) OR
     (Von < 0) OR (Bis < 0) OR (Von > Bis) then
  begin
    ShowMessage('Ungültige Eingabe(n)!');
    Exit;
  end;

  Max := (Bis div 2) + 1;
  SetLength(ZList, Max);

  PrimLab.Caption := 'Überprüfe Zahlen...';
  Application.ProcessMessages;

// ************************************************************************** //

  Start := GetTickCount;

  PosCount := 0;
  for CheckSch := Von + 1 to Bis + 1 do
  begin
    if odd(CheckSch) then
    begin
      ZList[PosCount] := 1;
      inc(PosCount);
    end;
  end;

  PosCount := 0;
  for CheckSch := 3 to Trunc(sqrt(Bis)) do
  begin
    if odd(CheckSch) then
    begin
      if ZList[PosCount] = 1 then
      begin
        Zahl    := CheckSch;
        NrCount := ((Zahl * Zahl) - 3) div 2;

        while (NrCount <= Abs(Max)) do
        begin
          if ZList[NrCount] = 1 then
            ZList[NrCount] := 0;
          inc(NrCount, Zahl);
        end;
      end;

      inc(PosCount);
    end;
  end;

  Ende := GetTickCount;
  DauerLab.Caption := 'Diese Überprüfung hat ' +
                      FloatToStr((Ende - Start) / 1000) +
                      ' Sekunden gedauert.';
  Application.ProcessMessages;

// ************************************************************************** //

  PrimF := TStringList.Create;

  if Von < 3 then
    PrimF.Add('2');

  PosCount := 0;
  for CheckSch := 3 to Bis do
  begin
    if odd(CheckSch) then
    begin
      if ZList[PosCount] = 1 then
        PrimF.Add(IntToStr(CheckSch));

      inc(PosCount);
    end;
  end;

  PrimF.SaveToFile('Paket.prim');
  PrimF.Free;

  PrimLab.Caption := 'Fertig. Warte auf Eingabe...';
end;                    

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: