Zufallszahl ermiteln

[Nicodius]

FormCreate--> ranodmize;

Aktionsaufruf-->random(maxwert)

[eroe]

Zitat von sakura:

Zitat von Ultimator:

Es ist zwar besser wenn man es nur einmal aufruft, aber es ist nicht soo Hammer-schlimm, wenn man es öfters macht.

Sicher Es geht a) auf die Performance und b) mindert es die Qualität der Zufallszahlen.

In älteren Delphi Versionen, auf Linux und auf älteren Windows Versionen kannst Du mit folgendem Konstrukt schnell mal 1000 gleiche Zahlen erreichen.

(code) Deswegen, Randomize nur einmal aufrufen.

......

ehrlich ? nach welchem schema werden die "pseudo"-zufallszahlen denn in delphi erstellt ? ich mein wenn das stimmt was du sagst, dann können sie doch gar nich 100% zufällig sein oder ?

PS: soll keine anzweiflung deiner these sein, mich wunderts nur ein wenig

[Sharky]

Zitat von eroe:

....ehrlich ? nach welchem schema werden die "pseudo"-zufallszahlen denn in delphi erstellt ? ich mein wenn das stimmt was du sagst, dann können sie doch gar nich 100% zufällig sein oder ?....

Ein wichtiger Aspekt bei der Initialisierung durch Randomize ist die Systemzeit. Und bei den heutigen Systemen ist eine Schleife von 0 bis 999 halt schneller durchlaufen als sich der relevante Teil der Zeit ändert. Darum sollte Randomize nur einmal (beim Start des Programmes) aufgerufen werden. Sonst wird das "Zufallssystem" immer wieder auf den selben Startwert gesetzt.

Und JA: ECHTE Zufallszahlen werden mit Delphi (kann das über haupt ein normaler PC?) nicht erzeugt.

[sakura]

Zitat von eroe:

ehrlich ? nach welchem schema werden die "pseudo"-zufallszahlen denn in delphi erstellt ? ich mein wenn das stimmt was du sagst, dann können sie doch gar nich 100% zufällig sein oder ?

Wie der Name "Pseudo-" schon sagt, sind diese nicht echt. Delphi berechnet diese. Der relavante Teil ist in Delphi 7 wie folgend (ändert sich von Version zu Version)

Delphi-Quellcode:

procedure       _RandInt;
asm
{     ->EAX     Range   }
{     <-EAX     Result  }
        PUSH    EBX
{$IFDEF PIC}
        PUSH    EAX
        CALL    GetGOT
        MOV     EBX,EAX
        POP     EAX
        MOV     ECX,[EBX].OFFSET RandSeed
        IMUL    EDX,[ECX],08088405H
        INC     EDX
        MOV     [ECX],EDX
{$ELSE}
        XOR     EBX, EBX
        IMUL    EDX,[EBX].RandSeed,08088405H
        INC     EDX
        MOV     [EBX].RandSeed,EDX
{$ENDIF}
        MUL     EDX
        MOV     EAX,EDX
        POP     EBX
end;

procedure       _RandExt;
const two2neg32: double = ((1.0/$10000) / $10000);  // 2^-32
asm
{       FUNCTION _RandExt: Extended;    }

        PUSH    EBX
{$IFDEF PIC}
        CALL    GetGOT
        MOV     EBX,EAX
        MOV     ECX,[EBX].OFFSET RandSeed
        IMUL    EDX,[ECX],08088405H
        INC     EDX
        MOV     [ECX],EDX
{$ELSE}
        XOR     EBX, EBX
        IMUL    EDX,[EBX].RandSeed,08088405H
        INC     EDX
        MOV     [EBX].RandSeed,EDX
{$ENDIF}

        FLD     [EBX].two2neg32
        PUSH    0
        PUSH    EDX
        FILD    qword ptr [ESP]
        ADD     ESP,8
        FMULP   ST(1), ST(0)
        POP     EBX
end;

......

[sakura]

Zitat von Sharky:

Ein wichtiger Aspekt bei der Initialisierung durch Randomize ist die Systemzeit.

Nicht unbedingt, in Delphi 7 wird der Performance-Counter genutzt, und der ist schnell genug

Delphi-Quellcode:

procedure       Randomize;
{$IFDEF LINUX}
begin
  RandSeed := _time(nil);
end;
{$ENDIF}
{$IFDEF MSWINDOWS}
var
  Counter: Int64;
begin
  if QueryPerformanceCounter(Counter) then
    RandSeed := Counter
  else
    RandSeed := GetTickCount;
end;
{$ENDIF}

......

[eroe]

Delphi-Quellcode:

procedure       _RandInt;
asm
{     ->EAX     Range   }
{     <-EAX     Result  }
        PUSH    EBX
{$IFDEF PIC}
        PUSH    EAX
        CALL    GetGOT
        MOV     EBX,EAX
        POP     EAX
        MOV     ECX,[EBX].OFFSET RandSeed
        IMUL    EDX,[ECX],08088405H
        INC     EDX
        MOV     [ECX],EDX
{$ELSE}
        XOR     EBX, EBX
        IMUL    EDX,[EBX].RandSeed,08088405H
        INC     EDX
        MOV     [EBX].RandSeed,EDX
{$ENDIF}
        MUL     EDX
        MOV     EAX,EDX
        POP     EBX
end;

procedure       _RandExt;
const two2neg32: double = ((1.0/$10000) / $10000);  // 2^-32
asm
{       FUNCTION _RandExt: Extended;    }

        PUSH    EBX
{$IFDEF PIC}
        CALL    GetGOT
        MOV     EBX,EAX
        MOV     ECX,[EBX].OFFSET RandSeed
        IMUL    EDX,[ECX],08088405H
        INC     EDX
        MOV     [ECX],EDX
{$ELSE}
        XOR     EBX, EBX
        IMUL    EDX,[EBX].RandSeed,08088405H
        INC     EDX
        MOV     [EBX].RandSeed,EDX
{$ENDIF}

        FLD     [EBX].two2neg32
        PUSH    0
        PUSH    EDX
        FILD    qword ptr [ESP]
        ADD     ESP,8
        FMULP   ST(1), ST(0)
        POP     EBX
end;

ACH KLAR !! jetz wo dus sagst
aber danke schonmal für die erläuterung, hätt ich nich gedacht ..

@ Sharky .. naja, das sie nich 100 % zufall sind war relativ klar, aber ich hätt nich erwartet das sie von so nem unsicheren faktor wie systemzeit abhängen, zumindest nimmer heutzutage ..

[ajz]

Zitat von Sharky:

Zitat von eroe:

....ehrlich ? nach welchem schema werden die "pseudo"-zufallszahlen denn in delphi erstellt ? ich mein wenn das stimmt was du sagst, dann können sie doch gar nich 100% zufällig sein oder ?....

Ein wichtiger Aspekt bei der Initialisierung durch Randomize ist die Systemzeit. Und bei den heutigen Systemen ist eine Schleife von 0 bis 999 halt schneller durchlaufen als sich der relevante Teil der Zeit ändert. Darum sollte Randomize nur einmal (beim Start des Programmes) aufgerufen werden. Sonst wird das "Zufallssystem" immer wieder auf den selben Startwert gesetzt.

Und JA: ECHTE Zufallszahlen werden mit Delphi (kann das über haupt ein normaler PC?) nicht erzeugt.

ein normaler pc kann das nicht,
aber ein normaler pc, der in irgendeiner weise mit einer stereoanlage oder einer soundkarte verbunden ist,
mit dem kann man echte zufallszahlen aus dem rauschen der (sound-) chips machen/berechnen.

Line out mit Line in verbinden, rauschen der eigenen soundkarte oder stereoanlage aufnehmen und
die frequenzen des rauschens als grundlage für die berechnung einer zufallszahl nehmen.
d.h. würde das randomize() von delphi nicht mit der systemzeit
sondern mit irgendeinem rauschen von einem soundchip initialisiert, wären die zufallszahlen um einiges
zufälliger...

mfg

[negaH]

Zitat:

ch mein wenn das stimmt was du sagst, dann können sie doch gar nich 100% zufällig sein oder ?

Korrekt, es sind Pseudo-Zufalls-Zahlen, und die sind 100% nicht zufällig, haben aber meistens zu 100% die Statistischen Eigenschaften von Zufall. Umschrieben heist das, die Farbe ist Blau aber eben kein echtes Blau, hat aber die exakt gleichen Eigenschaften wie das echte Blau (eben bläulich). Wenn man also nicht weis das das Pseudo-Blau kein echtes Blau ist dann wird es sehr schwierig das Pseudo-Blau vom echten Blau zu unterscheiden Der Vorteil ist aber das mit dem gleichen Mischungsverhältnis der Zutaten eben immer exakt das gleiche Pseudo-Blau erzeugt werden kann. In unserem Falle ist es gerade eine perfekte und vorzügliche Eigenschaft von Random() das sie mit dem gleichen Zufalls-Seed immer den gleichen Pseudo-Zufall erzeugt. Erst dadurch wird es möglich immer wiederkehrend zufällige Ereignisse zu reproduzieren. Bei echtem Zufall geht dies eben nicht.

Gruß Hagen

[negaH]

Übrigens, warte mal Donnerstag ab, dem Männertag, dann kennst du den Unterschied zwischen Blau und Pseudo-Blau

Gruß Hagen

[p0w3r5tr34m3r]

kannst auch einfach die unit MATH einbinden und dann randomrange(0,100) machen

so long,
Powerstreamer