Delphi 11 kein RandomRange für 64-bits?

[softtouch]

Zitat von Andreas13:

Hallo Softtouch,
Du kannst die Routine System.Mathe.RandomRange(..) einfach abwandeln:

Delphi-Quellcode:

Function RandomRange(Const AFrom, ATo: UInt64): UInt64; Overload;
Begin
  IF AFrom > ATo Then
    Result:= Random(AFrom - ATo) + ATo
  Else
    Result:= Random(ATo - AFrom) + AFrom;
End;

Da das Result von Random eine Extended-Zahl ist, hast Du genug (bis zu 18..19) zufällige Ziffern, was knapp auch für den obersten Bereich von UInt64 (9223372036854775810) ausreichen dürfte.

Grüße, Andreas

[Edit]: Für Deinen Zahlenbereich zwischen 100000 und 9999999999 reicht es alle mal.

Das erzeugt einen range check error, da ato-afrom immer noch mehr als ein integer ist.

[Andreas13]

Sorry, in der Tat. Ich habe es leider nur in der Nähe Deines oberen Breichs

Delphi-Quellcode:

Von:= 9999999999 - 500;
Bis:= 9999999999;

getestet.

Andreas

[Uwe Raabe]

Vielleicht klappt dies besser:

Delphi-Quellcode:

Function RandomRange(Const AFrom, ATo: UInt64): UInt64;
Begin
  Result:= Round(Random*(ATo - AFrom)) + AFrom;
End;

[KodeZwerg]

Vor Jahren irgendwo gefunden. Es leistete gute Dienste.

Delphi-Quellcode:

var
  vLehmerRandSeed64: Int64 = 0;
  vLehmerMultiplierA64: Int64 = 636413622384679305;
  vLehmerAdditiveConstantC64: Int64 = $1;

procedure SingleAdd(const A: LongWord; const B: LongWord; const CarryIn: LongWord; var Sum: LongWord; var CarryOut: LongWord);
var
  Temp: array [0 .. 1] of LongWord;
begin
  UInt64(Temp) := UInt64(A) + UInt64(B) + UInt64(CarryIn);
  Sum := Temp[0];
  CarryOut := Temp[1];
end;

function LehmerRandom64(ParaLehmerModulesM64: int64): int64;
var
  A: array [0 .. 1] of LongWord;
  B: array [0 .. 1] of LongWord;
  C: array [0 .. 3] of LongWord;
  vAindex: LongWord;
  vBindex: LongWord;
  vCindex: LongWord;
  vTransport: array [0 .. 1] of LongWord;
  vTransport1Index: LongWord;
  vTransport2Index: LongWord;
begin
{$RANGECHECKS OFF}
{$OVERFLOWCHECKS OFF}
  vLehmerRandSeed64 := vLehmerRandSeed64 * vLehmerMultiplierA64;
  vLehmerRandSeed64 := vLehmerRandSeed64 + vLehmerAdditiveConstantC64;
  C[0] := 0;
  C[1] := 0;
  C[2] := 0;
  C[3] := 0;
  Int64(A) := ParaLehmerModulesM64;
  Int64(B) := vLehmerRandSeed64;
  for vBindex := 0 to 1 do
  begin
    vTransport[0] := 0;
    vTransport[1] := 0;
    for vAindex := 0 to 1 do
    begin
      vCindex := vAindex + vBindex;
      Uint64(vTransport) := Uint64(A[vAindex]) * Uint64(B[vBindex]);
      for vTransport1Index := vCindex to 4 - 1 do
      begin
        if vTransport[0] = 0 then
          Break;
        SingleAdd(C[vTransport1Index], vTransport[0], 0, C[vTransport1Index], vTransport[0]);
      end;
      for vTransport2Index := vCindex + 1 to 4 - 1 do
      begin
        if vTransport[1] = 0 then
          Break;
        SingleAdd(C[vTransport2Index], vTransport[1], 0, C[vTransport2Index], vTransport[1]);
      end;
    end;
  end;
  Result := Int64(Pointer(@C[2])^);
{$OVERFLOWCHECKS ON}
{$RANGECHECKS ON}
end;

function RandomRange64(const AFrom, ATo: Int64): Int64;
begin
  if AFrom > ATo then
    Result := LehmerRandom64(AFrom - ATo) + ATo
  else
    Result := LehmerRandom64(ATo - AFrom) + AFrom;
end;

Man muss nur im Hinterkopf haben das erst ab dem zweiten Durchlauf die Zahlen variieren.

[softtouch]

Zitat von Uwe Raabe:

Vielleicht klappt dies besser:

Delphi-Quellcode:

Function RandomRange(Const AFrom, ATo: UInt64): UInt64;
Begin
  Result:= Round(Random*(ATo - AFrom)) + AFrom;
End;

Dies scheint soweit die bisher einzige Lösung zu sein, die funktioniert und doch angenehm kurz ist. Ich denke, damit kann ich leben. Danke dafür.

[KodeZwerg]

Zitat von softtouch:

Dies scheint soweit die bisher einzige Lösung zu sein, die auch wirklich funktioniert.

Was bitteschön funktionierte denn bei meinem Post nicht? Danke für Klärung. Hatte es Jahrelang in Betrieb.

[softtouch]

Zitat von KodeZwerg:

Zitat von softtouch:

Dies scheint soweit die bisher einzige Lösung zu sein, die auch wirklich funktioniert.

Was bitteschön funktionierte denn bei meinem Post nicht? Danke für Klärung. Hatte es Jahrelang in Betrieb.

Sorry, habe mich schlecht ausgedrückt. Funktioniert schon, ist mir aber doch ein wenig zu lang.

[Michael II]

Zitat von softtouch:

Zitat von KodeZwerg:

Zitat von softtouch:

Dies scheint soweit die bisher einzige Lösung zu sein, die auch wirklich funktioniert.

Was bitteschön funktionierte denn bei meinem Post nicht? Danke für Klärung. Hatte es Jahrelang in Betrieb.

Sorry, habe mich schlecht ausgedrückt. Funktioniert schon, ist mir aber doch ein wenig zu lang.

Generell gilt doch: Lieber lang und richtig als kurz und falsch .

Du vergleichst hier KodeZwergs Implementierung mit dem Aufruf der Delphi Implementierung (welche - oh Schreck - ebenfalls mehrere Zeilen lang ist).

Ein Blick in die Delphi Implementierung von random würde sich lohnen.
Wie himitsu bereits erwähnt: Die Funktion random liefert 32Bit Zahlen im Bereich [0,1[. random gibt also insgesamt genau 2^32 voneinander verschiedene Werte aus.

D.h. aber auch
Result:= Round(Random*(ATo - AFrom)) + AFrom;
kann nicht mehr als 2^32 voneinander verschiedene Werte zurück liefern.

Oder anders: Bei ATo-AFrom > 2^32 - wie in deinem Fall - liefert die Funktion NICHT alle möglichen Zufallszahlen zurück. => KEIN Pseudozufallsgenerator für deine Aufgabe.

Zur Verwendung von "round". Round rundet bei .5 Werten immer zur nächsten GERADEN Zahl. round hat in purer Mathematik nix verloren.

Ein Beispiel: Wenn ATo-AFrom = $80000000, dann liefert round(random*$80000000) die Werte 0 0 1 2 2 2 3 4 4 4 5 6 6 6 7... zurück. D.h. die Null wird wegen der Verwendung von round doppelt so oft generiert wie eine ungerade Zahl. Gerade Zahlen (>0) werden sogar drei mal so oft generiert wie ungerade.

Wenn du im gleichen "Fahrwasser" wie Delphi es für 32 Bit Zahlen tut Pseudozufallszahlen im UInt64 Bereich erzeugen willst, dann empfehle ich dir:
https://de.wikipedia.org/wiki/Kongruenzgenerator
https://en.wikipedia.org/wiki/Linear_congruential_generator

Eine UIn64 Implementierung könnte so aussehen:

Delphi-Quellcode:

var randseed64 : UInt64;

function mulRange( a, b : UInt64 ) : UInt64;

var ah, al, bh, bl : UInt64;
    ah_x_bh,
    ah_x_bl,
    al_x_bh,
    al_x_bl : UInt64;
    carry : UInt64;

begin
    ah := a shr 32;
    al := UInt32( a );
    bh := b shr 32;
    bl := UInt32(b);

    ah_x_bh  := ah * bh;
    ah_x_bl  := ah * bl;
    al_x_bh  := al * bh;
    al_x_bl  := al * bl;

    carry :=  (uint64(uint32(ah_x_bl)) + uint64((uint32(al_x_bh))
            + (al_x_bl shr 32 ))) shr 32;

    Result :=  ah_x_bh
            + (ah_x_bl shr 32) + (al_x_bh shr 32)
            + carry;
end;


function Random64Proc : UInt64;
// https://de.wikipedia.org/wiki/Kongruenzgenerator
// https://en.wikipedia.org/wiki/Linear_congruential_generator
begin
{$Q-}
{$R-}
  Result := UInt64(RandSeed64) * 6364136223846793005 + 1442695040888963407;
  RandSeed64 := Result;
end;


function random64( ARange : UInt64 ) : UInt64;
begin
  Result := mulRange( Random64Proc, ARange );
end;

Nicht allzu lang getestet. Ich glaube, aber es ist OK so.

Beachte, dass sowohl Delphis random(ARange) wie auch hier random64(ARange) Zahlen im Bereich [0..ARange[ (also ARange NICHT dabei) erzeugen.
(Ähnlich für Delphis RandomRange im 32 Bit Bereich)

Es gibt wesentlich bessere Generatoren, welche auf heutigen Maschinen für die meisten Anwendungen schnell genug sind. TurboMagic kann dir zum Beispiel mit seinem DEC weiter helfen.