CPP Routine (Schleifen) Übersetzung nach Delphi gesucht

[Möbius]

Hallo zusammen

Ich habe hier eine Programmvorlage in CPP.
Bei einem Codeteil will mir die Übersetzung nach Delphi nicht so recht gelingen.
Irgendwie verstehe ich wohl die CPP Schleifenkonstrukte nicht so recht.
Kann mir bitte jemand helfen dies nach Delphi zu übersetzen.
In den folgenden Kommentarzeilen ist der CPP-Source.
Dann mein Stand der Dinge:

Besten Dank für Eure Hilfe

Delphi-Quellcode:

//  CPP Code
//    for (int i = 0, j = 1; j < n - 1; j++) {
//        for (int k = n >> 1; k > (i ^= k); k >>= 1);
//        if (j < i) {
//            const int32_t x0r = ar[j];
//            const int32_t x0i = ai[j];
//            ar[j] = ar[i];
//            ai[j] = ai[i];
//            ar[i] = x0r;
//            ai[i] = x0i;
//        }
//    }

// Delphi Code
  j := 1;
  while j < (n - 1) do
  begin
    i := 0;
    k := n shr 1;
     while k > (i xor k) do
    begin
      i := i xor k;
      DebugPrint(IntToStr(i));
      if j < i then
      begin
        x0r := OutR[j];
        x0i := OutI[j];
        OutR[j] := OutR[i];
        OutI[j] := OutI[i];
        OutR[i] := x0r;
        OutI[i] := x0i;
      end;
      k := k shr 1;
    end;
    inc(j);
  end;

[himitsu]

Die Initialiaisierung "ErstesStatement;" gehört vor die Schleife, also nicht nur j := 1; , sondern auch das i := 0; .
Dann die Bedingung für das While und zum Schluß die Fortschrittsberechnung am Ende der Schleife.

Aber Beachte auch das ; , bzw. die fehlende { , am Ende der zweiten Schleife.
Diese liegt nicht um das IF drumrum, sondern nur alleine vor dem IF.

[Möbius]

Danke für die Antwort himitsu

Also ich jetzt das i = 0 vor die erste Schelife gestellt.
Unter Berücksichtigung des ; bei der zweiten Schleife läuft diese also "leer".

Folgende Änderung habe ich vorgenommen:

Delphi-Quellcode:

  j := 1;
  I := 0;
  while j < (n - 1) do
  begin
    k := n shr 1;
    while k > (I xor k) do
    begin
      I := I xor k;
      k := k shr 1;
    end;
    if j < I then
    begin
      x0r := OutR[j];
      x0i := OutI[j];
      OutR[j] := OutR[I];
      OutI[j] := OutI[I];
      OutR[I] := x0r;
      OutI[I] := x0i;
    end;
    inc(j);
  end;

Das läuft immer noch nicht.
Besonders das while k > (I xor k) do Statement scheint mir sinnlos.
Wenn I = 0 dann ist das Statement immer falsch da k xor 0 = k ist. Und das ist gleich gross wie k aber nicht kleiner.

Wäre froh um weitere Unterstützung.

[mensch72]

habe den C-Code mal etwas "vereinfacht"... das kannst du nun 1:1 in Delphi umsetzen

int i = 0;
int j = 1;

while(j < (n - 1))

{
int k = n >> 1;

i ^= k;
while(k > i)

{
i ^= k;
k >>= 1;
}

if(j < i)

{
const int32_t x0r = ar[j];
const int32_t x0i = ai[j];

ar[j] = ar[i];
ai[j] = ai[i];
ar[i] = x0r;
ai[i] = x0i;
}

j++;
}

[himitsu]

mit i ^= k; habe ich noch ein Problem, was sich so nicht 1:1 nach Delphi übersetzen lässt.

Es wird bereits in der WHILE-Bedingung ausgeführt also auch dann, wenn es FALSE liefert.

vermutlich müsste man das entweder in eine Funktion mit VAR-Parameter auslagern
oder einmal im While, für den Vergleich, und einmal in der Schleife mit := und auch nochmal nach der Schleife
oder vor der Schleife und nochmal in der Schleife
oder man löst das mit einem Repeat, bzw while True do und drinnen die Abbruchbedingung mit IF und BREAK.

[mensch72]

..."mit i ^= k; habe ich noch ein Problem, was sich so nicht 1:1 nach Delphi übersetzen lässt."...

i := i xor k; (man beachte, das die Zuweisung im org. C-Code Bestandteil des Vergleichsterms war... das bedeutet das geht so in Delphi nicht direkt, deshalb muss die Zuweisung das erste Mal vor der "KopfWhile" gemacht werden, und dann noch jedesmal mit am Ende pro Durchlauf! )

[Blup]

Für die Berechnung von I ist scheint mir eine Funktion mit VAR-Parameter dem Orginal am ähnlichsten.

Delphi-Quellcode:

function CalcI(var i: Integer; k: Integer): Integer; inline;
begin
  i := i xor k;
  result := i;
end;

while k > CalcI(i, k) do
begin
  k := k shr 1;
end;