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.