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

var  Test: Array of Integer;
     T: Extended;
begin
T := 0;
Setlength(Test, 10);
Showmessage(  IntToStr(Test[ Round(T) ])  );
end;                    

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

var BoolArray: Array of Boolean;

//Array setzten
setlength( BoolArray, 1000000 );
//Bool auslesen
if BoolArray[X] then //...
//Bool setzten
if BoolArray[X] then BoolArray[X] := False; // Die if Abfrage vorher, da es sein kann dass es schon False ist und schreiben wesentlich länger dauert als lesen                    

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:

var BitBoolArray : Array of Byte;
const Size = 8; //Größe des Speichers (SizeOf(Byte)*8)  .. so ist schneller wechsel auf z.B: Integer (32) möglich 
 
//Array setzen
setlength( BitBoolArray , 1000000 div Size +1); //Da ein Byte (8Bit) ja 8 Booleans fasst

//Bool auslesen
if GibBoolean(X) then //...
//Bool setzten
SetzteBool(X, False); //Keine if Abfrage, da schon in SetzteBoolean vorhanden

//einzelnen Funktionen:

Function GibBoolean(Zahl: Integer): Boolean;
var Z, CopyOfFeld: Byte;
begin
CopyOfFeld := BitBoolArray [Zahl div Size];
Result := False;
For Z:=(Size-1) downto (Zahl mod Size) do
  if CopyOfFeld>=power(2, Z) then
    begin
    CopyOfFeld := CopyOfFeld - Round(power(2, Z));
    Result := True;
    end
  else
    Result := False;
end; 


Procedure SetzteBoolean(Zahl: Integer; Wert: Boolean);
begin
if Wert then // Da Boolean <> Boolean ist (False<>False z.B. 255 und 13) frage ich sicherheitshalber einzeln ab und nicht if Wert<>GibBoolean(Zahl)
  begin
  if not GibBoolean(Zahl) then BitBoolArray [Zahl div Size] := BitBoolArray [Zahl div Size] + round(power(2, (Zahl mod Size)));
  end
else
  begin  
  if     GibBoolean(Zahl) then BitBoolArray [Zahl div Size] := BitBoolArray [Zahl div Size] - round(power(2, (Zahl mod Size)));
  end;
end;                    

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

function GibBoolean(Zahl: Integer): Boolean;
var Mask, CopyOfFeld: Byte;
begin
  CopyOfFeld := BitBoolArray [Zahl div Size];
  Mask = 1 shl (Zahl mod Size);
  Result := Boolean(CopyOfFeld and Mask);
end;

procedure SetzeBoolean(Zahl: Integer; Wert: Boolean);
var Mask, Index: Byte;
begin
  Mask = 1 shl (Zahl mod Size);
  Index := Zahl div Size;
  if Wert then
    BitBoolArray[Index] := BitBoolArray [Index] or Mask;
  else
    BitBoolArray[Index] := BitBoolArray [Index] and not Mask;
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:

program unbenannt;
uses
  sysutils;

const
  BITPOS   =  5;//= 1 shl 5 = 32
  BITMASKE = 31;//= 1 shl BITPOS-1;
type
  tBoolSet = set of 0..BITMASKE; // 0.. 1 shl BITPOS-1 ;
  tBoolArr = Array of tBoolSet;
var
  bA : tBoolArr;

function GibBoolean(Zahl: Integer): Boolean;inline;
begin
  result:= (ZAHL AND BITMASKE) in bA[Zahl shr BITPOS];
end;

procedure SetzeBoolean(Zahl: Integer; Wert: Boolean);
begin
  //BitNr = Zahl AND BITMASKE;Index := Zahl SHR BITPOS;
  if Wert then
    include(bA[Zahl SHR BITPOS],Zahl AND BITMASKE)
  else
    exclude(bA[Zahl SHR BITPOS],Zahl AND BITMASKE);
end;


const
  ArrBitSize = 100*1000*1000;
  // Wieviel 32 Bit set werden gebraucht bei 1..32 -> 1; 33..64-> 2.
  ArrSize =(ArrBitSize+BITMASKE) SHR BITPOS;
var
  T1,T0: TDatetime;
  i : LongInt;

BEGIN
  setlength(bA,ArrSize);
  T0 := now;
  // Alle Bit setzen
  For i:= 1 to ArrBitSize do
    SetzeBoolean(i,true);
  // Test ob auch alles richtig war, keiner darf nicht gesetzt sein
  For i:= 1 to ArrBitSize do
    IF NOT(GibBoolean(i)) then
      writeln('Fehler bei: ',i);

  // Alle Bit loeschen
  For i:= 1 to ArrBitSize do
    SetzeBoolean(i,false);
  // Test ob auch alles richtig war, keiner darf gesetzt sein
  For i:= 1 to ArrBitSize do
    IF GibBoolean(i) then
      writeln('Fehler bei: ',i);
  T1 := now;
  Writeln( FormatDateTime('HH:NN:SSS.ZZZ',T1-T0));
  setlength(bA,0);
END.                    

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

type
  BaseofBitBool = Byte;

BitBoolArray: Array of BaseOfBitBool;

const
  Size= SizeOf(BaseOfBitBool)*8;

//Initialisieren mit
 For C:=0 to High(BitBoolArray) do
     BitBoolArray[C] := round(power(2, Size)-1); //geht wesentlich schneller als alle einzeln durchzugehen und auf true zu setzen                    

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                    

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..1000] of 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<1001) and (abstand[z]=0) then
      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;                    

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

var   C,X: Cardinal;
begin
X := 4000000000;
C := 2;
Showmessage( IntToStr(  C*X ) );
end;                    

1:
2:
3:

var x: Cardinal;
begin x := $FFFFFFFF;
end;                    

1:
2:
3:
4:

var x: tBoolSet;
begin
Cardinal(x) := $FFFFFFFF;
end;                    

1:

Lehmer:   WE mit lsumphi32 [s]: 00:00:01.611    PrimePi(12000000000) = 541555851                    

1:

Lehmer:   WE mit lsumphi32 [s]: 00:00:00.779    PrimePi(12000000000) = 541555851                    

1:

Lehmer:   WE mit lsumphi32 [s]: 00:00:33.719    PrimePi(1000000000000) = 37607912018                    

1:
2:
3:
4:

C:\Download>prime_pi64.exe
PrimePi mit MPArith V  (c) 2012 Mathematiker/WE(Gammatester)
     78500   1000027
Lehmer:   WE mit lsumphi32 [s]: 00:00:25.560    PrimePi(120000000000) = 4904759399                    

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

testnum = 12*1000*1000*1000; // [Fehler] prime_pi.dpr(21): Überlauf bei Konvertierung oder arithmetischer Operation
{also:} testnum = 12000000000; // ist dasselbe, gibt kein fehler aus
//und
 Primes1E6 : array[1..NumPrimes1E6+8] of DWord; //funktioniert nicht
DWord = LongWord // DWord existiert in Delphi7 nicht ?° also
 Primes1E6 : array[1..NumPrimes1E6+8] of LongWord;
//und
c := Primes1E6Index(trunc(exp(ln(x)/3.0)+0.5)); //funktioniert nicht, da ln nur mit real zahlen rechnet, x aber int64 ist... also
c := Primes1E6Index(trunc(exp(ln(x/1)/3.0)+0.5)); (ln(x/1); //hier wird automatisch gecastet... sinnlos aber funktioniert^^                    

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:

procedure TMainform.Button1Click(Sender: TObject);
var
  Schleife   : cardinal;  // int64 nicht möglich
  ZahlByte   : byte;
  Zahl       : cardinal;
  FS         : TFileStream;
  DatenBlock : array [0..124999] of byte; // 125.000 Bytes = 1 Mio. Bits bzw. Zahlen
begin
  FS := TFileStream.Create('L:\Primzahlen.PRIM', fmOpenReadWrite or fmCreate);
  try
    for Schleife := 0 to 124999 do
      DatenBlock[Schleife] := $55;
    for Schleife := 1 to 80000 do   // = 10 Mrd. Bytes große Datei (= 80 Mrd. Bits / Zahlen)
      FS.Write(DatenBlock, SizeOf(DatenBlock));
    FS.Position := 0;                    // zurück zum Anfang
    FS.Read(ZahlByte, SizeOf(ZahlByte)); // nur ein Byte lesen
    ZahlByte := ZahlByte xor $03;        // 1 keine Primzahl, 2 = Primzahl
    FS.Position := 0;         // Durch das Lesen wurde der Zeiger verschoben.
    FS.Write(ZahlByte, SizeOf(ZahlByte));
      // Kleiner Test, um das Endian-Problem zu verdeutlichen.
    FS.Position := 10;        // Durch das Schreiben wurde der Zeiger verschoben.
                              // Wird hier willkürlich auf 10 (= 11. Byte) gesetzt.
    Zahl := $12345678;        // Im Hex-Editor mal die Bytes ansehen. (siehe Endian)
    FS.Write(Zahl, SizeOf(Zahl));
  finally
    FS.Free;
  end;
end;                    

1:
2:
3:
4:

For Schleife:=1 to 80000 do
 begin
 //
 end;                    

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

Schleife := 1;
while Schleife <= 80000 do
 begin
 //
 inc(Schleife);
 end;                    

1:

for Schleife := 1 to 80000 do   // = 10 Mrd. Bytes große Datei (= 80 Mrd. Bits / Zahlen)                    

1:

 DatenBlock[Schleife] := $55;                    

1:
2:

For Schleife:=1 to High(DatenBlock) do
 FS.WriteBuffer(DatenBlock[Schleife], SizeOf(DatenBlock[Schleife]); //WriteBuffer oder Write?                    

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

{Type TSavedDataBlocks = record
 Pfad: String; //fester Pfad + '\' + IntToStr(BlockNr);
 Anzahl: Cardinal
end;
var GespBloecke: Array of TSavedDataBlocks;}

setlength(DatenBlock, Gesp[BlockNr].Anzahl);
For Schleife:=High(DatenBlock) downto 1 do // von hinten nach vorn, wie du oben sagtest ist richtig oder?
  FS.ReadBuffer(DatenBlock[Schleife], SizeOf(DatenBlock[Schleife])); //ReadBuffer oder Read ? ich kenns mit Buffer...                    

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:

program LOP;

// Lots Of Primes
// mr_emre_d
// @ entwickler-ecke.de

{$APPTYPE CONSOLE}

uses
  Windows;

type
  TByteBoolean = record
    Value: Byte;
    function GetBit(const Index: Integer): Boolean;
    procedure SetBit(const Index: Integer; const Bit: Boolean);
  end;

  TByteBooleanArray = Array of TByteBoolean;

{$REGION 'TByteBoolean'}

function TByteBoolean.GetBit(const Index: Integer): Boolean;
begin
  Result := Value and (1 shl Index) <> 0;
end;

procedure TByteBoolean.SetBit(const Index: Integer; const Bit: Boolean);
begin
  if Bit then
    Value := Value or (1 shl Index)
  else
    Value := Value and not (1 shl Index);
end;

{$ENDREGION}

(*
** ExtendedSieveOfEratosthenes calculates primenumber in a given range
** the range is specified by [StartingNumber, Primes.Len*2]
** Primes.Len * 2 because the Primes Array only contains odd numbers (since even numbers cant be prime)
*)
procedure ExtendedSieveOfEratosthenes(const FromOffset: UInt64; var Primes: TByteBooleanArray);
var
  ToOffset  : UInt64;
  candidate : UInt64;
  multiples : UInt64;
  index     : Integer;
begin
  candidate := 3;
  ToOffset := FromOffset + Length(Primes) shl 4;
  while candidate < ToOffset do
  begin
    // fast-iterate to the beginning of the sieve
    if candidate < FromOffset then
    begin
      multiples := candidate * Round(FromOffset/candidate);
      if multiples < FromOffset then
        inc(multiples, candidate);
    end else
      multiples := candidate shl 1;

    // if the first multiple is already out of bounds we can stop sieving
    if multiples > ToOffset then break;

    // sieve
    while multiples <= ToOffset do
    begin
      // odd numbers only
      if multiples and 1 = 1 then
      begin
        index := (multiples - FromOffset) shr 1;
        Primes[index shr 3].SetBit(index mod 8, false);
      end;
      inc(multiples, candidate);
    end;

    // ignore even numbers
    inc(candidate, 2);
  end;
end;

var
  Primes: TByteBooleanArray;
  iteration: Integer;
  p, q: Integer;
  From: UInt64;
  Tick: DWORD;
  Duration: DWORD;
  Til: UInt64;
  PrimeCount: UInt64;
  ptr: PDWord;
  cnt4: DWord;

begin
  SetLength(Primes, 1024*1024 shr 4);
  From := 3;
  Til := 1000000000;
  Til := Til * 12;
  iteration := 0;
  PrimeCount := 0;
  Duration := GetTickCount;
  cnt4 := Length(Primes) div 4;
  while From < Til do
  begin
    inc(iteration);
    ptr := @Primes[0];
    for p := 0 to cnt4 do
    begin
      ptr^ := $FFFFFFFF;
      inc(ptr);
    end;
    ExtendedSieveOfEratosthenes(From, Primes);
    for p := 0 to High(Primes) do
      for q := 0 to 7 do
        if Primes[p].GetBit(q) then
        begin
          if (From + (p*8 + q)*2) < Til then
            inc(PrimeCount);
//          Writeln(PrimeCount, '. ', (From + (p*8+q)*2));
        end;
//    Readln;
    if iteration mod 100 = 0 then
      Write('[Iteration #', iteration, '] calculated primes [', From, ', ', From + Length(Primes) shl 1,
        '] (time: ', (GetTickCount-Duration)/1000:6:2, ')'#13);
    inc(From, Length(Primes) shl 4);
  end;
  Duration := GetTickCount - Duration;

  Writeln('Finished, took me ', Duration/1000:8:2, ' seconds... ');
  Writeln('Found ', PrimeCount, ' primes');
  Readln;
end.                    

1:
2:
3:
4:

Hoechste Primzahl 510529
Siebe ab                  0
Gesiebt bis     22801929150      1.000.006.971
real  1m1.053s