Zufallsboolean

[Chemiker]

Zufallsboolean
Folgende Funktion liefert Zufallsboolean.
Es wurde mit BDS 2006 entwickelt.

Delphi-Quellcode:

{*******************************************************************************
  Unit: uZufallsZahlen
  ltz.Ändr.: 13.07.2008
--------------------------------------------------------------------------------
  1.) Name:         function ZufallsBoolean(): boolean;
      ltz.Ändr.:    13.07.2008
      Beschreibung: Gibt zufällig TRUE oder FALSE als Boolean zurück
                    Um den Zufallszahlengenerator zu initialisieren, rufen Sie
                    Randomize einmal auf oder weisen der Variable RandSeed vor
                    dem Aufruf von ZufallsBoolean einen Wert zu.
--------------------------------------------------------------------------------
  2.) Name:         function StrZufallsBoolean(): string;
      ltz.Ändr.:    13.07.2008
      Beschreibung: Gibt zufällig 'TRUE' oder 'FALSE' als String zurück
                    Um den Zufallszahlengenerator zu initialisieren, rufen Sie
                    Randomize einmal auf oder weisen der Variable RandSeed vor
                    dem Aufruf von ZufallsBoolean einen Wert zu.

*******************************************************************************}
unit uZufallsZahlen;

interface

uses SysUtils, Math;


function ZufallsBoolean(): boolean;
function strZufallsBoolean():String;


implementation

function ZufallsBoolean(): boolean;
begin
  Result:= Random(2)=1;   // 1=1 >> TRUE / 0=1 >> FALSE
end;

function StrZufallsBoolean():String;
begin
  Result:= BoolToStr(ZufallsBoolean(),true);
end;


end.

Vielleicht kannst ja jemand brauchen.

Bis bald Chemiker
Edit: function ZufallsBoolean geändert und Dax-Vorschlag übernommen.

[Dax]

Verbesserungsvorschlag:

Delphi-Quellcode:

function ZufallsBoolean: Boolean;
begin
  Result := Random(2) = 1;
end;

function ZufallsBoolean(trueProzent: Double): Boolean;
begin
  Result := Random(100) < trueProzent;
end;

Es ist nett, dass du das zur Verfügung stellst, aber am Ende hat es dann doch nicht den gewissen Mehrwert. ;)

[SirThornberry]

Und da Boolean ja 0 und ungleich 0 ist, kann man sich den Vergleich auf 1 oder 0 auch sparen :-)

Delphi-Quellcode:

result := Boolean(random(2));

[Dax]

Da ist was dran, aber mit dem Vergleich finde ich es schöner :)

edit: Wenn ich mich Recht erinnere, ist Boolean in Delphi sogar 0 oder 1. Ich glaube mich daran zu erinnern, dass Delphi aus dem "not" ein Integer "xor 1" macht - damit wäre "not Boolen(2)" immer noch true.

[3_of_8]

Ja, ein Vergleich ist schöner. Schon allein deshalb, weil bei manchen Boolean-Typen, LongBool z.B., True nicht den Wert 1 hat, sondern $FFFFFFFF.

[Chemiker]

Hallo,

Währe nett, wenn Ihr das vielleicht in die Cod-Lib irgendwie mit aufnehmen könnt, weil ich danach gesucht habe.

@ Dax: Deine Methode habe ich vorher so gehabt, wollte aber Sichersein das auch TRUE und FALSE rauskommt.

Bis bald Chemiker

[Dax]

Es kommt True oder False raus, mit jeweils 50% Chance für n -> unendlich. Random(X) ist definiert als 0 <= Random(X) < X, somit wird aus Random(2) = 1 in 50% der Fälle True. :)

[3_of_8]

Eine andere Möglichkeit wäre noch:

Delphi-Quellcode:

function RandomBoolean: Boolean;
begin
  Result := Random() < 0.5;
end;

Dabei spart man sich die Umwandlung des Zufallswertes (der zwischen 0 und 1 liegt) in einen Integer, was u.U. schneller ist. Aber gut möglich, dass der Compiler das sowieso so optimiert.

[1234588]

Zitat:

Zitat von 3_of_8

Ja, ein Vergleich ist schöner. Schon allein deshalb, weil bei manchen Boolean-Typen, LongBool z.B., True nicht den Wert 1 hat, sondern $FFFFFFFF.

laut dem freepascal ref.pdf dokument ist eine variable des LongBool typs true, wenn sie einen wert hat, der nicht 0 ist. selbiges gilt bei ByteBool und WordBool. auszug aus dem besagten dokument:

Delphi-Quellcode:

Name          Size         Ord(True)
Boolean         1             1
ByteBool        1       Any nonzero value
WordBool        2       Any nonzero value
LongBool        4       Any nonzero value

[Dax]

Soweit ich weiss, ist das genau anders rum. Delphi erzeugt seine Zufallszahlen als einem Integer-Kongruenzgenerator und nutzt für die Periodizität das Überlaufverhalten der Integermultiplikation. Korrigiert mich, wenn ich falsch liege, ich hab schon so lange kein Delphi mehr :mrgreen: