Zufals-Boolean erzeugen

[ManuMF]

Hallo,

gibt es eine einfache Möglichkeit, in Delphi einen Zufalls-Boolean zu erzeugen?
Ich wüsste da nur

Delphi-Quellcode:

Boolean := not StrToBool(IntToStr(Random(2)));

was aber nicht so gut wäre, u.a. wegen der "Ungenauigkeit" ;-) des Zufallsgenerators bei kleinen Zahlen.

Vorstellen könnte ich mir auch etwas in der Richtung

Delphi-Quellcode:

if (Random(1001) > 500) then
  Boolean := true
else
  Boolean := false;

aber ich suche nach einer "vorgefertigten" Lösung.

Danke,
ManuMF

[faux]

Zitat:

Zitat von ManuMF

Gibt es eine einfache Möglichkeit, in Delphi einen Zufalls-Boolean zu erzeugen?
(...)
was aber nicht so gut wäre, u.a. wegen der "Ungenauigkeit" ;-) des Zufallsgenerators bei kleinen Zahlen.

Du solltest dir bewusst sein, dass es sowieso keine Zufallszahlen geben kann, sondern nur "Pseudozufallszahlen"... ;)
Was erhältst du denn bei denen Möglichkeiten als Resultat?

Hier habe ich was gefunden, was vielleicht interessant sein könnte (auch wenn es zu aufwendig ist):
http://www.thomas-fahle.de/pub/perl/...llszahlen.html

[Nikolas]

Was meinst du mit 'Ungenauigkeit bei kleinen Zahlen' ?

[ManuMF]

Zitat:

Zitat von faux

Du solltest dir bewusst sein, dass es sowieso keine Zufallszahlen geben kann, sondern nur "Pseudozufallszahlen"... ;)

Das ist mir klar. Im Unterricht sollte wir mal ein Programm schreiben, in das man die Anzahl der Würfe eines Würfels eingibt und dann anzeigt, wie oft eine Augenzahl vorkommt. Erst ab ~100 Würfen wird's zufällig ;-)
Ich hab's mal in den Anhang gepackt (Interessanterweise schießt sich das Programm selbnst ab, wenn man eine Zahl wie 100, 1000 oder so eingibt. Bei 101, 1001 nicht...)

@Toxman: Probier's mal mit dem Programm im Anhang aus...

[Nikolas]

Ich sehe nichts besonderes in dem Programm. Erwartest du, dass nach 12 Würfen überall eine 2 steht? Wenn du einen richtigen Würfel nimmst, wirst du ähnliche Ergebnisse bekommen.

[ManuMF]

Es geht mir ja um den Boolean. Bei nur 2 Zahlen für Random könnte bei 10 Durchläufen 9 mal Nein und 1 mal Ja rauskommen. Aber das will ich ja nicht.

[KLS]

is doch ganz einfach

Delphi-Quellcode:

var
  zufallsboolean : boolean;
begin
  randomize;  //einmaliger aufruf!
  zufallsboolean := bool(random(2));
end;

[Sergej]

Zitat:

Zitat von ManuMF

Es geht mir ja um den Boolean. Bei nur 2 Zahlen für Random könnte bei 10 Durchläufen 9 mal Nein und 1 mal Ja rauskommen. Aber das will ich ja nicht.

Und warum soll das deiner Meinung nach nicht zufällig sein? Es ist so zufällig wie ein Computer eben sein kann...
Beim nächsten Durchlauf könnte es auch 10011110101...sein.

Greetz Sergej

[faux]

Zum Anhang:

Bei mir fehlen die Balken, bei hohen Zahlen... :?

[Nikolas]

Zitat:

Es geht mir ja um den Boolean. Bei nur 2 Zahlen für Random könnte bei 10 Durchläufen 9 mal Nein und 1 mal Ja rauskommen. Aber das will ich ja nicht.

Das hat doch aber nichts mit den zwei Zahlen zu tun. Was willst du denn genau? Du wirst keine gute Funktion finden, bei der nicht obiger Fall eintreten kann.
So was ist eben 'zufall'. Du kannst auch einen Würfel nehmen und 10 Mal hintereinander eine 6 Würfeln.

[ManuMF]

Es stimmt schon, diese "Extremlösungen" sind doch zufällig. Ich wollte halt eine "gleichmäßige" Lösung haben.
Dann muss Random erst mal reichen... ;-)

Gruß,
ManuMF

P.S.: Ursprünglich wollte ich ja nur wissen, ob es in Delphi so was wie "function RandomBool;" gibt.

[Sergej]

Zitat:

Zitat von ManuMF

Es stimmt schon, diese "Extremlösungen" sind doch zufällig. Ich wollte halt eine "gleichmäßige" Lösung haben.
Dann muss Random erst mal reichen... ;-)

Gruß,
ManuMF

Ich glaube da liegt dein Denkfehler. Die Verteilung _ist_ gleichmäßig, nur wirst du sie bei i < 1000 Durchläufen wohl nicht erkennen.

Greetz Sergej

[Nikolas]

Wenn du eine 'gleichmäßige' Lösung haben willst, musst du dir ein Array of Boolean nehmen, eine hälfte auf true, die andere auf false setzen und das Array dann mischen. So bekommst du vielleicht das, was du haben willst.

[Sergej]

Zitat:

Zitat von Toxman

Wenn du eine 'gleichmäßige' Lösung haben willst, musst du dir ein Array of Boolean nehmen, eine hälfte auf true, die andere auf false setzen und das Array dann mischen. So bekommst du vielleicht das, was du haben willst.

:) Und mit welchem 'zufälligen' Algorithmus willst du das Array mischen? Da kannst du auch gleich Random (oder was entsprechendes Eigenes) nehmen...


Greetz Sergej

[Nikolas]

Zitat:

Da kannst du auch gleich Random (oder was entsprechendes Eigenes) nehmen...

Nicht ganz. Mit dem Array kann ich garantieren, dass True und False immer gleich häufig auftreten, dass kann ich bei Random nicht.

[Sergej]

Mit Random treten sie aber auch gleichmäßig auf. Außerdem kann es bei deiner Lösung durchaus genauso vorkommen, dass man 10 mal hintereinander true bekommt oder?

Greetz Sergej

[BenjaminH]

10 mal hintereinander True kann schon passieren, aber in der Gesamtheit ist es garantiert so, dass es gleichviele True wie False innerhalb des Arrays gibt.

[Olli]

Erklärt mir mal jemand, warum man dann nicht gleich Modulo (von 2) von einer normalen Pseudozufallszahl nimmt und 0 oder 1 in einen Boolean castet?

[BenjaminH]

Naja, da hast du Zufall, d.h. es kann sein, dass du bei 1000 Zufallszahlen 510 Ungerade und 490 Gerade hast und dann eben auch 510 False und 490 True.
Kleines Beispiel:

Delphi-Quellcode:

Var B:Array [1..1000] of Boolean;
i:Integer;

for i:=1 to 500 do
   B[i]:=True;
for i:=501 to 1000 do
   B[i]:=False;

Jetzt muss man dass noch durchmischen irgendwie...
Ihr werdet mir doch jetzt alle zustimmen, dass in diesem Array dann auf jeden Fall 500 True und 500 False sind, diese aber in einer "zufälligen" Reihenfolge vermischt.

Grüße Benjamin

[BlackJack]

warum nicht einfach so:

Delphi-Quellcode:

var Bool: Boolean;
begin
Bool := Random(2) = 1;
end;

?

oder noch besser mit ner Wahrscheinlichkeit:

Delphi-Quellcode:

var Bool: Boolean; 
    p: Double;
begin
p := 0.25; //nur ein Beispiel, aber p sollte  0 <= p < 1 sein.
Bool := Random < p;
end;

bei diesem Code wird mit einer Wahrscheinlichkeit von 25% "Bool" True enthalten. (beim ersten Code sinds 50%)

und wieso sollte der zufallsgenerator erst ab 100 würfen funktionieren? weil erst ab 100 würfen alle zahlen gleich oft vorkommen, aber bei meinetwegen bei 10 nicht? that's zufall, baby! ;)

[alzaimar]

@Olli:Ob ich nun

Delphi-Quellcode:

bRand := Boolean (Random (2))

nehme, oder

Delphi-Quellcode:

bRand := Boolean (Random (10000) mod 5000)

ist, zumindest beim Delphi-Randomgenerator, auch mathematisch ein und die selbe Sosse.

@BenjaminH: Stimmt, aber ist das Zufall? Nein! Denn Du hast vorher bestimmt, wie das Ergebnis sein soll: Wenn Du Dir die ersten 999 Ergebnisse anschaust, weist Du 100%ig, wie das 1000ste aussieht. Da kann man dann von Zufall nun wahrlich nicht mehr sprechen. Du wirst also mit deinem Verfahren keine 1000 Zufallsbooleans erzeugen, sondern maximal 999. Im Regelfall sogar weniger.

Bei Zufallszahlen kann man eben nicht vorhersagen, wie oft welche Zahl kommt. Man weiss nur, das 'am Ende des Tages', also in der Tendenz, die Wahrscheinlichtkeit am höchsten ist, das die Zahlen gleichverteilt sind. Ob nun 'zufällig' die 10000000 Zahlen 1 sind, weiss man nicht, aber es könnte sein und wäre natürlich legitim.

Hört auf, Euch den Zufall so hinzubiegen, wie ihr ihn gerne hättet. Nehmt dann lieber Permutationen.

[Jelly]

Zitat:

Zitat von Sergej

Außerdem kann es bei deiner Lösung durchaus genauso vorkommen, dass man 10 mal hintereinander true bekommt oder?

Das stimmt so nicht, dass das genauso vorkommen kann wie 5 mal true und 5 mal falsch.

Die Wahrscheinlichkeit, dass beim ersten Wurf TRUE rauskommt, beträgt 1:2
Die Wahrscheinlichkeit, dass beim zweiten Wurf UND beim ersten TRUE rauskommt, beträgt 1:(1:2), also 1:4=1:2^2

10 mal hintereinander TRUE zu erhalten hat also eine Wahrscheinlichkeit von 1:2^10, also 1:1024

Die Wahrscheinlichkeit hingegen, 5 mal TRUE und 5 mal FALSE rauszubekommen beträgt 1:2.

Noch ne andere Anmerkung... Das Erstellen eines Arrays, anschliessendes Mischen, und wieder Ausspucken der Werte hat nun aber mal rein gar nichts mehr mit Wahrscheinlichkeit zu tun, da damit garantiert wird, dass 5 mal true und 5 mal FALSE bei rauskommt. Das Problem ist also damit bestimmt, und hat nichts mehr mit random zu tun.

[Sergej]

Zitat:

Zitat von Jelly

Zitat:

Zitat von Sergej

Außerdem kann es bei deiner Lösung durchaus genauso vorkommen, dass man 10 mal hintereinander true bekommt oder?

Das stimmt so nicht, dass das genauso vorkommen kann wie 5 mal true und 5 mal falsch.

Die Wahrscheinlichkeit, dass beim ersten Wurf TRUE rauskommt, beträgt 1:2
Die Wahrscheinlichkeit, dass beim zweiten Wurf UND beim ersten TRUE rauskommt, beträgt 1:(1:2), also 1:4=1:2^2

10 mal hintereinander TRUE zu erhalten hat also eine Wahrscheinlichkeit von 1:2^10, also 1:1024

Die Wahrscheinlichkeit hingegen, 5 mal TRUE und 5 mal FALSE rauszubekommen beträgt 1:2.

Noch ne andere Anmerkung... Das Erstellen eines Arrays, anschliessendes Mischen, und wieder Ausspucken der Werte hat nun aber mal rein gar nichts mehr mit Wahrscheinlichkeit zu tun, da damit garantiert wird, dass 5 mal true und 5 mal FALSE bei rauskommt. Das Problem ist also damit bestimmt, und hat nichts mehr mit random zu tun.

;-)

Also mit "genauso" meinte ich auf keinen Fall "genauso oft". Ich wollte damit nur darauf hinweisen, dass es durchaus möglich ist.


Greetz Sergej

[Jelly]

Zitat:

Zitat von Sergej

Ich wollte damit nur darauf hinweisen, dass es durchaus möglich ist.

Das stimmt natürlich. :zwinker:

[Sergej]

[Ein wenig OT]

@Jelly: Es ist doch von der Wahrscheinlichkeit her völlig egal welchen der folgenden Fälle ich habe:

0 0 0 0 0 0
1 0 0 0 0 0
1 1 0 0 0 0
.
.
.

Die W. liegt bei jedem 'Wurf' bei 0.5, sowohl für 1 also auch für 0. Das bedeutet aber wiederum, dass die W. für einen bestimmtenes Ergebnis bei (1/2)^n liegt...oder?

Lasse mich gerne belehren :)

[Edit] Formulierung verdeutlicht


Greetz Sergej

[Jelly]

Zitat:

Zitat von Sergej

Es ist doch von der Wahrscheinlichkeit her völlig egal welchen der folgenden Fälle ich habe:

0 0 0 0 0 0
1 0 0 0 0 0
1 1 0 0 0 0
.
.
.

Das stimmt so schon. Bei deinem Bsp. von 6 Würfen musst du dann aber auch so deine Tabelle woweiterbauen, und alle Möglickeiten betrachten. Bei 6 Würfen kriegst du somit 2^6 unterschiedliche Kombinationen von möglichen Reihenfolgen. Und von diesen 2^6 Möglichkeiten trifft nun mal eben nur eine einzige zu, wo lauter EINSEN stehen. Also ist die Wahrscheinlichkeit, 6 mal TRUE zu erhalten 1:2^6.

Zitat:

Zitat von Sergej

Die W. liegt bei jedem 'Wurf' bei 0.5, sowohl für 1 also auch für 0. Das bedeutet aber wiederum, dass die W. für einen bestimmtenes Ergebnis bei (1/2)^n liegt...oder?

Fast. Was Du hierbei nicht berücksichtigst, ist der Fakt, dass es im Grunde egal ist ob deine ersten 3 Würfe TRUE ergeben, und deine letzten 3 FALSE, oder eben umgekehrt... Ich verdeutliche es mal am Bsp. von 4 Würfen. Hier gibt es 2^4 Kombinationen, und zwar diese hier:

Code:

0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111

In dieser Liste spielen 2 Kombinationen eine gesonderte Rolle und entsprechen deiner Vorstellung von (1/2)^n. Nämlich 0000 und 1111. Für beide gilt eine Wahrscheinlichkeit von 1:16=1:2^4 diese Kombination zu erhalten.

Die Wahrscheinlichkeit jedoch 2 mal 0 und 2 mal1 zu erhalten, ist dabei grösser, da es ja egal ist ob du 0011, 1100, 0101, 1010 usw. hast, um 2 mal 0 und 2 mal 1 zu erhalten... Zähle aus der obigen Liste alle Kombinationen von 2 mal 0 und 2 mal 1, so sind das diese:

Code:

0011
0101
0110
1001
1010
1100

Die Gesamtwahrscheinlichkeit 2 mal 0 und 2 mal 1 zu erhalten beträgt demnach 6:16=3:8, also 37,5%

Das kann man aber auch ausrechnen. Googeln nach Permutationen sollte das zu was führen.

[Sergej]

Ahhh...ich erkenne meinen Denkfehler :shock: Die Reihenfolge wird ja nicht berücksichtigt...Danke für die Erklärung :)


Greetz Sergej

[dizzy]

Ähm, Leute... jetzt mal ganz pragmatisch, ohne Ausschweife in Theorien über Zufall etc. (Auch wenn ich das ebenso interessant finde):
Die Variante mit einem zu gleichen Teilen gefüllten gemischten Array scheint mir doch sehr nach dem auszusehen, was der Fragesteller haben will!? Da hilft auch langes Lamentieren nix :P.

Und um an der Fachsimpelei anzuknüpfen: Auch bei dieser Variante ist sehr wohl Zufall enthalten. Nicht was das Verhältnis der Vorkommen der Werte angeht, aber durchaus (ja nach verwendetem Mischalgo) in der Reihenfolge der Vorkommen. Ob nun das letzte Vorkommen mit Kenntniss aller vorigen determiniert ist, ist doch völlig unerheblich. Mit geeigneter Mischmethode ist das letzte Vorkommen genauso mit einer Wahrscheinlichkeit von 1:2 true (bzw. false) wie es an jeder anderen Stelle auch wäre (wenn das Array 1:1 true:false gefüllt ist).

Ich glaube nicht dass der Fragesteller ausdiskutieren wollte ob er nun (pseudo-)echten Zufall haben möchte / brauchen kann, sondern ganz einfach eine Lösung zu seinem Problem sucht. Diese wäre ein solches Array denke ich ;)


Eine RandomBool-Funktion gibt es in Delphi nicht, allerdings stehen im Thread verteilt nun mehrere Wege das zu erreichen. Und wenn es nun unbedingt als Funktion sein soll... verpack es in eine :zwinker:. Die Bedingung nach N Ziehungen aber je N/2 true und false zu erhalten garantiert diese Herangehensweise jedoch nicht. Dazu wäre es eben im Vorfeld nötig zu wissen wie viele Ziehungen letztlich gemacht werden sollen, und sich der Möglichkeit des Arrays zu bedienen.
Ohne Kenntnis über die Gesamtzahl der Ziehungen ließe sich das nur noch näherungsweise erzwingen, in dem man jedes Mal mitprotokolliert in welchem Verhältnis true/false aufgetreten sind, und die nächste Ziehung mit einer entprechend gegengerichteten Wahrscheinlichkeit durchzuführen. (Wie dies gemacht werden kann steht auch schon im Thread.) Bei dieser Variante ist es ebenfalls nicht garantiert ein 1:1 herauszubekommen, allerdings ließe sich so erreichen dass der "Zufall" schon früher als nach 1000 Ziehungen eine Ausgewogenheit erreicht. Wenn man die Wahrscheinlichkeit extrem setzt, so erhält man jedoch irgendwann ein alternierendes System bei dem lediglich true/false/true/false/... erzeugt wird -> also voll deterministisch. D.h. mit dieser Variante lässt sich der (Pseudo-)Zufall quasi stufenlos in eine deterministische Folge wandeln, die zwar frühe Ausgewogenheit immer wahrscheinlicher macht, aber eben den "Zufall" unwahrscheinlicher :stupid:


Und nu geh ich schlafen :)
Gruss,
Fabian

[himitsu]

Ihr könnte ja bei dem gefüllten Array bleiben, auch wenn der 1000ste Wert nchtvorhersehbar sein soll.

Man nehme einfach euer Array mit den 1000 Werten und fülle es per "Zufall" sagen wir mal mit 450 bis 550 True's (den Rest natürlich dann mit False).
Und danach wird das Array dann ebenfalls durchgemischt.

Da jetzt aber keine 500 mal True und False im Array vorhanden sind, sonder eine "zufällige" Anzahl derer, ist der 1000ste Wert nicht mehr "vorhersehbar".

Und da sich die Anzahl der "zufälligen" True's ebenfalls um die 500 bewegt, ergibt das auf dir 1000 gerechner fast eine gleichmäßige Verteilung.

[Jelly]

Zitat:

Zitat von dizzy

Ich glaube nicht dass der Fragesteller ausdiskutieren wollte ob er nun (pseudo-)echten Zufall haben möchte / brauchen kann, sondern ganz einfach eine Lösung zu seinem Problem sucht. Diese wäre ein solches Array denke ich ;)

Ich will nicht fachsimpeln, sondern einfach nur mal kurz erklären was Wahrscheinlichkeitsrechnung ist, und man nicht einfach mal so sich ne Methode überlegen kann, damit die zufälligen Werte dann doch besser in irgendein Muster passen. Ausserdem:

Zitat:

Zitat von ManuF

Das ist mir klar. Im Unterricht sollte wir mal ein Programm schreiben, in das man die Anzahl der Würfe eines Würfels eingibt und dann anzeigt, wie oft eine Augenzahl vorkommt.

Wenn man wirklich eine nach einem bestimmten Muster verteilte Zufallszahl erhalten will, z.B. bei Zahlen zwischen 1..10 sollen mit einer Wahrscheinlichkeit von 0,1% nur die 1 kommen, so muss man in die Monte Carlo Methode eintauchen, die eine Zufallszahl anders abbilden kann. Aber ich will nicht schon wieder zu weit ausholen. Meine Aussage ist einfach, dass man nicht einfach beliebig an der Erstellung der Zufallszahlen rumspielen darf. Das ist Manipulation. Da kommen nicht nur Las Vegas Kasino Inhaber in der Knast, da wird auch der Informatiklehrer seine Augen verdrehen, und die Arbeit entsprechend benoten.

[tigerman33]

Eine andere Variante, wenn man das Array umgehen will (obwohl das ja auch eine gute Lösung ist) wäre auch folgendes:

Delphi-Quellcode:

ABool := random <= (f - n) / (s - m)

Dabei ist f die Anzahl an trues die man erreichen will, s die Spanne in der das erreicht werden soll (in eurem Beispiel 1000). n und m sind Zählervariablen, in denen die Anzahl an schon erreichten trues bzw. die schon verstrichene Spanne gespeichert wird.

Beispiel: Im 20. von 1000 Würfen, es ist schon 3 mal true gewürfelt worden und soll insgesamt 500 mal true geben:#

ABool := random <= (500 - 3) / (1000 - 19)

[negaH]

Was ist mit

Delphi-Quellcode:

Result := Odd(Random(100));

Gruß Hagen

[Nikolas]

Zitat:

Result := Odd(Random(100));

Es geht schon nicht mehr darum, einen zufälligen Boolean zu bekommen, sondern Möglichkeiten zu garantieren (!) dass True und False gleich oft erscheinen.

// Hast du eigentlich einen Bot, der meldet, wenn in einem Thread eines der Wörter 'Zufallalgorhytmus' oder 'Veschlüsselung' auftaucht? :mrgreen:

[negaH]

Ja und ? Das macht exakt mein Vorschlag, denn der PRNG muß als guter RNG garantieren das er auf lange Sicht gerade und ungerade Zahlen gleichmäßig verteilt.

Davon abgesehen, eine Garantie das man bei 1000 zufällig erzeugten Booleans exakt 50% jeweils TRUE oder FALSE sind kann es bei Zufall eben nicht geben. Dies wäre nämlich nicht mehr zufällig, also ein Widerspruch insich. Entweder will man es zufällig oder nicht.
Eine Folge von 1000 erzeugten TRUE Werten ist zwar sehr unwahrscheinlich aber denoch ein möglicher und gültiger Output eines Zufallsgenerators.

Gruß Hagen

[negaH]

Es besteht aber die Möglichkeit eine solche "Zufallssequenz" ganz einfach zu erzeugen.

Delphi-Quellcode:

var
  LastValue: Boolean;
  LastValid: Boolean := False;

function RandomBoolean: Boolean;
begin
  if not LastValid then
    LastValue := Odd(Ramdom(2));
  Result := LastValue;  
  LastValue := not LastValue;
  LastValid := not LastValid;
end;

Diese Funktion erzeugt Tuples aus TRUE/FALSE bzw FALSE/TRUE Werten zufällig. Ruft man sie also mit geradzahliger Anzahl auf so ist garantiert das 50% TRUE/FALSE sind. Der maximale Abstand zwischen zwei TRUE bzw FALSE Werten beträgt 2.

Aus dieser kleinen Funkton lässt sich sehr einfach mathematisch ableiten das wenn man längere uniforme Abstände erreichen möchte sich die WorstCase-Gleichverteilung immer weiter von 50% entfernen muß. Und bei "echt" zufälligen Sequenzen die mathematisch mögliche WorstCase-Gleichverteilung exakt einer unendlich langen Sequenz sein muß. Heist auch eine unendlich lange Sequenz aus lauter TRUE oder FALSE Werten ist eine wahrscheinlich mögliche zufällige Sequenz.

Gruß Hagen

[negaH]

Zitat:

Zitat von alzaimar

@Olli:Ob ich nun

Delphi-Quellcode:

bRand := Boolean (Random (2))

nehme, oder

Delphi-Quellcode:

bRand := Boolean (Random (10000) mod 5000)

ist, zumindest beim Delphi-Randomgenerator, auch mathematisch ein und die selbe Sosse.

Nein ist es nicht. Beide Lösungen sind schlichtweg falsch da der direkte Cast eines Integers nach Boolean syntaktisch absolut undefiniert ist.

PASCAL konforme Lösungen wären:

Delphi-Quellcode:

begin
  Result := Odd(Random(2));

  Result := Random(2) <> 0;
  
  Result := Random(2) = 0;

  Result := Random(1000) >= 500;
end;


const
  Boolean: array[0..1] of Boolean = (False, True);
begin
  Result := Boolean[Random(2]);
end;

alles andere ist Quatsch mit Sosse.

Gruß Hagen

[Jelly]

Zitat:

Zitat von negaH

eine Garantie das man bei 1000 zufällig erzeugten Booleans exakt 50% jeweils TRUE oder FALSE sind kann es bei Zufall eben nicht geben. Dies wäre nämlich nicht mehr zufällig, also ein Widerspruch insich.

Das freut mich zu hören, denn auf mich hört ja keiner :mrgreen:

[alzaimar]

Zitat:

Zitat von negaH

Zitat:

Zitat von alzaimar

@Olli:Ob ich nun

Delphi-Quellcode:

bRand := Boolean (Random (2))

nehme, oder

Delphi-Quellcode:

bRand := Boolean (Random (10000) mod 5000)

ist, zumindest beim Delphi-Randomgenerator, auch mathematisch ein und die selbe Sosse.

Nein ist es nicht. Beide Lösungen sind schlichtweg falsch da der direkte Cast eines Integers nach Boolean syntaktisch absolut undefiniert ist.

Klappt aber (bis auf das ... mod 5000, was mod 2 heissen sollte) wunderbar und liefert unter Delphi gleichverteilte Boolsche Werte. :mrgreen:

Prinzipiell hast Du aber Recht, denn das Typecasting Bool-->Integer ist von System zu System unterschiedlich implementiert.

Aber bitte, in Zukunft mit Mass kritisieren und vorher vielleicht das eine oder Andere ausprobieren.

Unabhängig davon hört in dem Thread sowieso keiner auf den Anderen. Ich hatte schon vorher das Paradoxon mit den 'garantiert gleichverteilten 1000 Zufallszahlen' erklärt, aber das wurde ignoriert. Na nun, egal.

[negaH]

@alzaimar:

ich weis das dies funktioniert. Aber nur weil der Compiler einen Boolean als

FALSE = 0
TRUE <> 0

ansieht, was aber nicht offiziell dokumentiert ist. Der Compiler kann diese Logik benutzen weil auf Intel CPUs die Anfrage auf == 0 oder <> 0 über die Prozessorflags und deren Auswertung per Bedingte Sprünge so easy ist. Würde der Borland Compiler aber zb. auf ARM Kernen laufen so ginge dies eben nicht mehr.
Offiziell ist ein Boolean aber als

FALSE = 0
TRUE = 1

definiert. Was aber keine plausible Begründung für (Integer mod 2) in [0,1] in Boolean sein darf, da sich diese Definition jederzeit ändern könnte.

Angenommen folgender Code:

Delphi-Quellcode:

function BooleanToString1(Value: Boolean): String;
const
  sBoolean: array[Boolean] of String = ('FALSE', 'TRUE');
begin
  Result := sBoolean[Value];
end;

function BooleanToString2(Value: Boolean): String;
const
  sBoolean: array[Boolean] of String = ('FALSE', 'TRUE');
begin
  Result := sBoolean[Value <> False];
end;

procedure Test;
var
  S: String;
begin
  S := BooleanToString1(Boolean(2));
  WriteLn(S);

end;

//  und

begin
  if Boolean(2) then
  begin
    WriteLn('test');
  end;
end;

probier ihn aus.
Man muß dann schon BooleanToString2() benutzen um falsche TypCast zu eliminieren und den Code Bulletproof zu machen, was aber im Grunde nur duch die ungültigen TypCast zb. anderer Programmierer verursacht wurde.
Im zweiten Beispiel sieht man das der Compiler den Bytewert 2 einfach auf <> 0 abfragt und dieses über die Möglichkeiten der Intel CPUs als gültiges TRUE akzeptiert.

Das heist: solche ungültigen TypCast nach Boolean funktionieren innerhalb von Anfragen immer sauber, auf Grund der spezifischen Umsetzung in den Machinencode der Intel CPUs. Sie führen aber bei bestimmten PASCAL/Delphi konformen Sourcen, wie in BooleanToString1() gesehen, zu unvorhersehbarem Verhalten des Programmes. Dies wird dann zu Zugriffsverletzungen führen, obwohl der Code in BooleanToString1() absolut astreiner Delphi Source ist.

Wir alle können uns nun sicher vorstellen wie der Programmierer von BooleanToString1() stundenlang in seinem Sourcecode nach der Ursache dieser Zugriffsverletzungen suchen wird.

Gruß Hagen

[negaH]

Zitat:

Ich hatte schon vorher das Paradoxon mit den 'garantiert gleichverteilten 1000 Zufallszahlen' erklärt, aber das wurde ignoriert. Na nun, egal.

Und weil dieser Hinweis essentiell richtig ist, und das nun schon von 3-4 Leuten mit anderen Worten gesagt wurde, habe ich's eben ein 5'tes mal wiederholt. Vielleicht wird es ja dann noch deutlicher ;)

Aber, selbst wenn der Poster der Frage kein Intresse mehr an der Lösung dieser Frage hat, so ist die Wahrscheinlichkeit denoch sehr groß das später andere Antwortsuchende über diese Thread stolpern, und eben davon lernen. Soll heisen: die momentane "Ignoranz" muß man einfach akzeptieren und mit der Hoffnung vorlieb nehmen das Andere sich ihr Wissen rausziehen werden. Sieh es positiv :)

Gruß Hagen