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

x array[0..63] of byte=
(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,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);                    

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

type
Tt=record 
  z:array[1..6]; 
end;

const zwischenwerte=array of array of Tt                    

1:
2:
3:
4:

type
Tt=record 
  z:array[1..6] of byte; 
end;                    

1:

const zwischenwerte=array[0..63] of array[0..63] of Tt                    

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

Ttl_zwischen = record
  zwischen:array of byte;
end;

y_zahl = record
  y:array[0..63] of Ttl_zwischen;
end;
zw_felder:array[0..63] of y_zahl;                    

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:

for j:=0 to 63 do begin
    for x:=0 to 63 do begin
       if x<>j then begin
         if x>j then begin
           g:=x;  //groessere Zahl
           n:=j;  //kleinere zahl
         end else begin
           n:=x;  //kleinere zahl
           g:=j;  //groessere zahl
         end;
         if (g-n)<>1 then begin
           if (g-n)<>8 then begin
             if (g-n) mod 8 <> 0 then begin
               m:=1;
               repeat
                 setlength(zw_felder[x].y[j].zwischen,m);
                 zw_felder[x].y[j].zwischen[m-1]:=(n+m);
                 inc(m);
                 if (n+m)=g then m:=101; //raus
               until m>100;
             end else begin
               m:=1;
               repeat
                 setlength(zw_felder[x].y[j].zwischen,m);
                 zw_felder[x].y[j].zwischen[m-1]:=(n+(m*8));
                 inc(m);
                 if (n+(m*8))=g then m:=101;
               until m>100;
             end;
           end;
         end;
       end;
    end;
  end;

  if high(zw_felder[0].y[8].zwischen)<>-1 then
  for n:=0 to high(zw_felder[0].y[8].zwischen) do begin
    st1:=st1+' ';
    st1:=st1+inttostr(zw_felder[0].y[8].zwischen[n]);
  end;
  label1.Caption:=st1;                    

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:

procedure TForm1.cmd_1Click(Sender: TObject);
var
  i, n, x, t: ShortInt;
  p: Integer;
  freq: Int64;
  startTime: Int64;
  endTime: Int64;
begin
  QueryPerformanceFrequency(freq);
  QueryPerformanceCounter(startTime);

  n := 1;   // Zugrichtung ist Turmzug nach rechts

  for p := 1 to 100000000 do
  begin

    x := 0;   // Startfeld ab der gezogen wird.


    while (x < 8) do
    begin
     
      t := x;              // Damit die CPU wenigstens minimal etwas zu machen hat
//      mem_1.Lines.Add(t.tostring) ;     
      inc(x, n);           // auf der Feld wird der Zugfaktor addiert
    end;
   
  end;

  QueryPerformanceCounter(endTime);

  mem_1.Lines.Add('Die Routine benötigte etwa ' + IntToStr((endTime - startTime)
    * 1000 div freq) + 'ms');

end;




procedure TForm1.cmd_2Click(Sender: TObject);
var
  i, n, x, t : ShortInt;
  p: Integer;
  freq: Int64;
  startTime: Int64;
  endTime: Int64;
  a : Array[0..63, 0..63] of Array of Shortint;
begin

  // Initialisierung des Zugfeldarray ausserhalb der Schleife,
  // da es ja bei der initialisierung des Programms einmalig erzeugt wird.
  t := 8;
  SetLength(a[0,7],t);
  for i := 0 to 7 do
    a[0,7][i] := i;      // Das Zielfeld wird in das Array geschrieben


  QueryPerformanceFrequency(freq);
  QueryPerformanceCounter(startTime);

   x := 0;
   n := 7;


  for p := 1 to 100000000 do
  begin
    for i := 0 to Length(a[x,n])-1 do
    begin
      t := a[x,n][i];   // damit was passiert, wie bei obigem Beispiel auch.
                        //  bei beiden Routinen sollte jeweils das identische zurück nach t geschrieben werden
//                        mem_1.Lines.Add(t.tostring)
    end;
  end;

  QueryPerformanceCounter(endTime);

  mem_1.Lines.Add('Die Routine benötigte etwa ' + IntToStr((endTime - startTime)
    * 1000 div freq) + 'ms');

end;                    

1:

setlength()                    

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:

procedure TForm1.Button2Click(Sender: TObject);
var
  i, n, x, t : ShortInt;
  p: Integer;
  freq: Int64;
  startTime: Int64;
  endTime: Int64;
  a : Array[0..63, 0..63] of Array of Shortint;
  b: array[0..63, 0..63,0..7] of shortint;
begin

  // Initialisierung des Zugfeldarray ausserhalb der Schleife,
  // da es ja bei der initialisierung des Programms einmalig erzeugt wird.
  t := 8;
  //SetLength(a[0,7],t);
  for i := 0 to 7 do
    //a[0,7][i] := i;      // Das Zielfeld wird in das Array geschrieben
    b[0,7][i]:=i;

  QueryPerformanceFrequency(freq);
  QueryPerformanceCounter(startTime);

   x := 0;
   n := 7;


  for p := 1 to 100000000 do
  begin
    for i := 0 to Length(a[x,n])-1 do
    begin
      t := a[x,n][i];   // damit was passiert, wie bei obigem Beispiel auch.
                        //  bei beiden Routinen sollte jeweils das identische zurück nach t geschrieben werden
//                        mem_1.Lines.Add(t.tostring)
    end;
  end;

  QueryPerformanceCounter(endTime);

  memo1.Lines.Add('Die Routine benötigte etwa ' + IntToStr((endTime - startTime)
    * 1000 div freq) + 'ms');

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:

procedure TForm1.Button2Click(Sender: TObject);
var
  i, n, x, t : ShortInt;
  p: Integer;
  freq: Int64;
  startTime: Int64;
  endTime: Int64;
  a : Array[0..63, 0..63] of Array of Shortint;
  b: array[0..63, 0..63,0..7] of shortint;
begin

  // Initialisierung des Zugfeldarray ausserhalb der Schleife,
  // da es ja bei der initialisierung des Programms einmalig erzeugt wird.
  t := 8;
  //SetLength(a[0,7],t);
  for i := 0 to 7 do
    //a[0,7][i] := i;      // Das Zielfeld wird in das Array geschrieben
    b[0,7][i]:=i;

  QueryPerformanceFrequency(freq);
  QueryPerformanceCounter(startTime);

   x := 0;
   n := 7;


  for p := 1 to 100000000 do
  begin
    for i := 0 to Length(b[x,n])-1 do
    begin
      t := b[x,n][i];   // damit was passiert, wie bei obigem Beispiel auch.
                        //  bei beiden Routinen sollte jeweils das identische zurück nach t geschrieben werden
//                        mem_1.Lines.Add(t.tostring)
    end;
  end;

  QueryPerformanceCounter(endTime);

  memo1.Lines.Add('Die Routine benötigte etwa ' + IntToStr((endTime - startTime)
    * 1000 div freq) + 'ms');

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:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, math;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Label1: TLabel;
    Label2: TLabel;
    Memo1: TMemo;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
 
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}


procedure TForm1.Button1Click(Sender: TObject);
  var
  p:cardinal;
  maske,wk:int64;
  freq: Int64;
  startTime: Int64;
  endTime: Int64;


  {function Bittest (TestZahl : int64;Bitnr: byte):boolean;
  begin
    Result := (testzahl and (Int64(1) shl bitnr)) <> 0;
  end;}


  procedure BitSet(var TestZahl : int64;Bitnr: byte);
  var bitmaske:int64;
  begin
    //TestZahl := testzahl OR (1 shl BitNr);
    bitmaske := Int64(1) shl bitnr;
    testzahl:= bitmaske or testzahl;
  end;

begin
  wK:=0;
  QueryPerformanceFrequency(freq);
  QueryPerformanceCounter(startTime);
  for p:=1 to 10000000 do begin
  maske:=0;
                (* erstelle Maske *)
  bitset(maske,0); //von
  bitset(maske,3);//nach
  (* Ziehe *)
  wK:=wK xor maske;
  (* zurueck*)
  wk:=wK xor maske;
  end;

  QueryPerformanceCounter(endTime);

  memo1.Lines.Add('Die Routine benötigte etwa ' + IntToStr((endTime - startTime)
    * 1000 div freq) + 'ms');

end;

procedure TForm1.Button2Click(Sender: TObject);
var
  a:array[1..64] of byte;
  p:cardinal;
  freq: Int64;
  startTime: Int64;
  endTime: Int64;
begin
  QueryPerformanceFrequency(freq);
  QueryPerformanceCounter(startTime);
  for p:=1 to 10000000 do begin
    (* ziehen *)
    a[1]:=10;
    a[2]:=0;
    (* zurueck *)
    a[2]:=0;
    a[1]:=10;
  end;

  QueryPerformanceCounter(endTime);

  memo1.Lines.Add('Die Routine benötigte etwa ' + IntToStr((endTime - startTime)
    * 1000 div freq) + 'ms');

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:

function Bittest (TestZahl : int64;Bitnr: byte):boolean;
//var
//  Bitmaske : int64;
begin
  {Bitmaske := 1 shl BitNr;
  result := TestZahl AND BitMaske <> 0;}
  //result := int64(1) AND BitMaske <> 0;
  //result := testzahl AND (1 shl BitNr) <> 0;
  Result := (testzahl and (Int64(1) shl bitnr)) <> 0;
  //result := int64(1) shl bitnr;
end;


function sK_im_schach:boolean;
  var a,b,c,d:byte;
      h,schach:boolean;
  begin
    schach:=false;
    for a:=0 to 63 do begin
      if schach=false then
      if bittest(sk,a) then begin
        for b:=1 to 4 do begin
          if schach=false then
          if t_anz[b,a]<>0 then begin
            for c:=1 to t_anz[b,a] do begin
              (* eigener Stein im Weg *)
              h:=true;
              if bittest(st,t_wege[b,a].zahlen[c]) then begin
                h:=false;
              end;
              if h then begin
                if bittest(wk,t_wege[b,a].zahlen[c]) then begin
                  h:=false;
                end;
                if h then begin
                  if bittest(wt,t_wege[b,a].zahlen[c]) then begin
                    schach:=true;
                    h:=false;
                  end;
                end;
              end;
              if h=false then break;
            end;
          end;
        end;
      end;
    end;
    if schach then result:=true else result:=false;
  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 TForm1.magische_zahlen;
var testz,t,magic,erg,i:int64;

begin
  testz:=0;
  bitset(testz,50);
  bitset(testz,43);
  bitset(testz,36);
  bitset(testz,29);
  bitset(testz,22);
  bitboard(testz);
  label1.Caption:=inttostr(low(testz))+' '+inttostr(high(testz));
  update;
  t:=testz;
  for i:= low(testz) to high(testz) do begin}
    if t*i >= low(testz) then if t*i <= high(testz) then begin
    erg:=t*i;
    if bittest(erg,59) then if bittest(erg,60) then if bittest(erg,61) then if bittest(erg,62) then
    if bittest(erg,63) then begin
      bitclear(t,50);
      if not bittest(erg,59) then if bittest(erg,60) then if bittest(erg,61) then if bittest(erg,62) then
      if bittest(erg,63) then begin
        bitset(t,50);
        bitclear(t,43);
        if bittest(erg,59) then if not bittest(erg,60) then if bittest(erg,61) then if bittest(erg,62) then
        if bittest(erg,63) then begin
          bitset(t,43);
          bitclear(t,36);
          if bittest(erg,59) then if bittest(erg,60) then if not bittest(erg,61) then if bittest(erg,62) then
          if bittest(erg,63) then begin
            bitset(t,36);
            bitclear(t,29);
            if bittest(erg,59) then if bittest(erg,60) then if bittest(erg,61) then if not bittest(erg,62) then
            if bittest(erg,63) then begin
              bitset(t,29);
              bitclear(t,22);
              if bittest(erg,59) then if bittest(erg,60) then if bittest(erg,61) then if bittest(erg,62) then
              if not bittest(erg,63) then begin
                //Zahl gefunden
                magic:=i;
                beep;
                break;
              end;
            end;
          end;
        end;
      end;

    end;
    end;
  end;
  beep;

  {magic:=0;
  bitset(magic,9);
  bitset(magic,17);
  bitset(magic,25);
  bitset(magic,33);
  bitset(magic,41);}

  {erg:=testz*magic;
  bitboard(erg);}
  label1.caption:=inttostr(magic);

end;                    

1:
2:
3:

for i:= low(testz) to high(testz) do begin}
    if t*i >= low(testz) then if t*i <= high(testz) then begin
    erg:=t*i;