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:

[alzaimar]

Zitat:

Zitat von 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));

Oh bitte nicht :wall: :wall:

Dann ist das Ergebnis u.U. weder True noch False. Lasst doch endlich den Schmarrn mit dem Boolean-Typecasting. Das gibt nur Probleme.

[3_of_8]

Zitat:

Zitat von 1234588

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:

Freepascal ist auch kein Delphi. Und ich würde einfach sagen, ein Vergleich führt zum selben Code, ist aber verständlicher und einfach schöner. Also warum lange casten?

[SirThornberry]

Zitat:

Zitat von alzaimar

Zitat:

Zitat von 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));

Oh bitte nicht :wall: :wall:

Dann ist das Ergebnis u.U. weder True noch False. Lasst doch endlich den Schmarrn mit dem Boolean-Typecasting. Das gibt nur Probleme.

Das gibt nur Probleme wenn man auf True und False prüft. Wenn man auf Wahr und Unwahr prüft gibt das keinerlei Probleme.

[Dax]

Zitat:

Zitat von SirThornberry

Das gibt nur Probleme wenn man auf True und False prüft. Wenn man auf Wahr und Unwahr prüft gibt das keinerlei Probleme.

Zitat:

Zitat von Dax

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.

Zitat:

Zitat von alzaimar

Dann ist das Ergebnis u.U. weder True noch False. Lasst doch endlich den Schmarrn mit dem Boolean-Typecasting. Das gibt nur Probleme.

q.e.d. ;)

Mal ehrlich: wenn es einen sauberen Weg gibt, sollte man ihn auch gehen, und nicht irgend einen dreckigen Seitenpfad, der verspricht, drei Meter kürzer zu sein.

[Namenloser]

Zitat:

Zitat von SirThornberry

Zitat:

Zitat von alzaimar

Zitat:

Zitat von 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));

Oh bitte nicht :wall: :wall:

Dann ist das Ergebnis u.U. weder True noch False. Lasst doch endlich den Schmarrn mit dem Boolean-Typecasting. Das gibt nur Probleme.

Das gibt nur Probleme wenn man auf True und False prüft. Wenn man auf Wahr und Unwahr prüft gibt das keinerlei Probleme.

Richtig. Das ist genau der Grund, wieso man Konstrukte à la

Delphi-Quellcode:

if x = true then

vermeiden sollte. IMO spricht nix gegen den typecast auf Boolean.

[Dax]

NL: Kompiliere bitte mal "a_bool := Boolean(2); b_bool := True; c_bool := a_bool xor b_bool;" und poste die Disassembly. Das würde mich echt mal interessieren, wie Delphi den Bool-Cast umsetzt...

[alzaimar]

Zitat:

Zitat von NamenLozer

Richtig. Das ist genau der Grund, wieso man Konstrukte à la

Delphi-Quellcode:

if x = true then

vermeiden sollte. IMO spricht nix gegen den typecast auf Boolean.

Ach, echt?

Zitat:

Zitat von Mein kleines Testprogramm

1. "If Boolan(2)" funktioniert
2. "If Boolan(2) or False" funktioniert
3. "If Boolan(2)=True" funktioniert NICHT
4. "If Boolan(2) and True" funktioniert NICHT

1 und 2 sind zu erwarten, 3 und 4 jedoch Disaster und Katastrophe in Einem (3 wird wg. 'Äquivalenz' benötigt und ist im Übrigen eine Elementaroperation und hat gefälligst zu funktionieren.

Findest Du das in Ordnung? Du kannst mit gecasteten Booleans einfach nicht arbeiten. Punkt.

[Namenloser]

Okay, jetzt verstehe ich, was du meinst. XOR liefert ein falsches Ergebnis. (@dax)

Bei random(2) ist es aber trotzdem egal, weil eh nur 0 oder 1 herauskommen kann, und ich denke nicht, dass der Wert von True einafch so in der nächsten Delphiversion geändert wird. Wenn man natürlich auf 100%ige Kompatiblität wert legt, ist die IF SCHLEIFE wohl die bessere wahl.

Btw: mir fällt grad noch was ein:

Delphi-Quellcode:

x := boolean(random(2)*ord(True));

Ist allerdings schon ziemlich entwartet, aber ob das wirklich sinnvoll bzw. schneller ist, ist wohl fraglich. (Bei True=1 wird der Compiler die Multiplikation ja hoffentlich eh rausoptimieren).

edit: aber ist schon gut, ihr habt gewonnen :stupid:

[alzaimar]

Zitat:

Zitat von NamenLozer

Okay, jetzt verstehe ich, was du meinst. XOR liefert ein falsches Ergebnis. (@dax)

AND und '=' auch. :warn:

[FAlter]

Hi,

Zitat:

Zitat von NamenLozer

IF SCHLEIFE

:shock:

@alzaimar: Da ist was dran. Ich denke folgendes Beispiel macht das mit =true besser verständlich:

Delphi-Quellcode:

var
  foo, bar: Boolean;

foo := <Funktion aus DLL die -1 (true in anderen Sprachen) zurückgibt>;
bar := <Funktion die 1 (derzeit true in Delphi) zurückgibt>;

if foo = bar then
  blubb; <-- wird nicht ausgeführt

Tja, true <> true, obwohl Äquivalenz vorliegt.

Notfalls würde folgendes helfen, solange feststeht, dass 0 = false:

Delphi-Quellcode:

function equivalent(b1, b2: Boolean): Boolean; inline;
begin
  Result := (b1 = false) = (b2 = false);
end;

Hauptsache, der Compiler optimiert das nicht.

Oder so:

Delphi-Quellcode:

function CorrectBool(b: boolean): boolean; inline;
begin
  Result := b <> false;
end;

Vllt sollte man dieses Thema aufsplitten. Ich sehe es schon kommen, dass es hier um drei Themen geht: Zufallsboolean, Boolean-Werte außerhalb [true, false] und if-ist-keine-schleife.

Mfg
FAlter

[Roachford]

Delphi-Quellcode:

result := odd(random(MaxInt));

[p80286]

Hallo zusammen,

boolean ist ja wohl die Interpretation einer Standardspeichergröße(Byte,Integer,Word....)
Also sollte man nur mit If .. arbeiten. Sobald man dem Compiler ins Handwerk pfuscht, kann' mit der nächsten Version schon in die Hose gehen.

Also bei Boolschen Ergebnissen nur True oder False zurückgeben nie irgendwelche Integer,Words etc. die als Boolean interpretiert werden müssen.

Gruß
K-H

[grenzgaenger]

Zitat:

Zitat von p80286

Hallo zusammen,

boolean ist ja wohl die Interpretation einer Standardspeichergröße(Byte,Integer,Word....)
Also sollte man nur mit If .. arbeiten. Sobald man dem Compiler ins Handwerk pfuscht, kann' mit der nächsten Version schon in die Hose gehen.

Also bei Boolschen Ergebnissen nur True oder False zurückgeben nie irgendwelche Integer,Words etc. die als Boolean interpretiert werden müssen.

Gruß
K-H

der bool ist in aller regel, in der grösse mit der der prozessor am bestern umgehen kann, also in aller regel integer. der bool ist aber nix vom prozesor, sondern eine logische dateneinheit..

wie oben alzi schon erwähnt hat, gibt es verschiedene logische interpretationen... normal ist 0 = false und true nicht false...

aber weshalb willste hier nur mit if arbeiten? eine zuweisung von b = a <> c, kann das CF auch b zuweisen... und so wäre die standardinterpretation in TP vollkommen exact zugewiesen...

[DP-Maintenance]

Dieses Thema wurde von "Daniel G" von "Neuen Beitrag zur Code-Library hinzufügen" nach "Object-Pascal / Delphi-Language" verschoben.
Zu geringer Umfang für die CL, daher zurück ins normale Forum