Boolean-Werte addieren?

[PeterPanino]

Kann man Boolean-Werte eigentlich addieren? Und zwar so, dass aus der Summe ersichtlich ist, wie viele True- und wie viele False-Werte enthalten sind?

[mkinzler]

Da würde ich nicht von Addition reden. da wird man eher Zählen müssen

[Gentleman]

True entspricht 1 und false entspricht 0, wenn du also bei true immer mit 1 addierst, erhälst du die Anzahl der true-Werte. Dann müsstest du noch die Gesamtanzahl kennen, also mit true und false und daraus lässt sich dann ja alles weitere berechnen.

[monta]

//ok, ich war zu langsam

[Luckie]

Genau genommen ist False als null definiert und true als alles andere. Wenn jetzt eine Funktion 258 als wahr zurückgibt ...

[Reinhard Kern]

Zitat:

Zitat von Luckie

Genau genommen ist False als null definiert und true als alles andere. Wenn jetzt eine Funktion 258 als wahr zurückgibt ...

Noch genauer genommen ist auf boolean die DeMorgansche Arithmetik anzuwenden, aber da kommt nicht das raus, was der Fragesteller sucht - da sind auch die Ergebnisse boolean.

Gruss Reinhard

[SirThornberry]

Zitat:

Zitat von Luckie

Genau genommen ist False als null definiert und true als alles andere. Wenn jetzt eine Funktion 258 als wahr zurückgibt ...

Bei False stimme ich dir zu bei True nicht. Denn True ist als 1 definiert bei Delphi. True ist also immer 1 wahr ist alles ungleich 0

[Cyf]

Jaein, also ein Integer(true) wird sicher immer 1 sein, aber Delphi hat bei WinApi-Funktionen durchaus schonmal einen Boolean als Rückgabe, die Funktion gibt aber -1 zurück.

[Reinhard Kern]

Zitat:

Zitat von Cyf

Jaein, also ein Integer(true) wird sicher immer 1 sein, aber Delphi hat bei WinApi-Funktionen durchaus schonmal einen Boolean als Rückgabe, die Funktion gibt aber -1 zurück.

Hallo,

das ist bei bitweiser Logik auch konsequent, da not 1 = $FFFF ist bei einem word usw. Genaugenommen sind das aber 16/32/... boolsche Operationen.

Gruss Reinhard

[quendolineDD]

Das resultiert aber in der Verwendung von BOOLEAN und BOOL, welche sich eben in dem unterscheiden.

Delphi-Quellcode:

var
  a : BOOLEAN;
  b : BOOL;
  c ,
  d : INTEGER;
begin
  a := TRUE;
  b := TRUE;

  c := INTEGER(a);
  d := INTEGER(b);
end;

Geht mal Schritt für Schritt darüber und schaut euch an was herauskommt. Die Variable a, welche BOOLEAN deklariert ist, enhält INT 1. Aber b, welche als BOOL deklariert ist enthält INT -1.

Edit:

Um also nochmal zu der Frage des Threaderstellers zurückzukommen. Inkrementiere einfach eine Variable so oft, wie ein Wahrheitswert auftritt. Willst du noch die Gesamtzahl aller Werte wissen, so inkrementiere stets noch eine zweite Variable mit.

Delphi-Quellcode:

var
  BoolVal : BOOLEAN;
  TrueVals,
  SumVals : INTEGER;
{...}
if BoolVal then inc(TrueVals);
inc(SumVals);

[SirTwist]

Zitat:

Zitat von PeterPanino

Kann man Boolean-Werte eigentlich addieren? Und zwar so, dass aus der Summe ersichtlich ist, wie viele True- und wie viele False-Werte enthalten sind?

Hi,

ungetestet, aber wie wäre es mit einem

Delphi-Quellcode:

var
  summe: array[Boolean] of Integer;

Und dann benutzt du für deine einzelnen boolschen Ausdrücke

Delphi-Quellcode:

Inc(summe[boolausdruck]);

Gruß,
SirTwist

[Namenloser]

Ich denke, es bleibt nichts anderes übrig, als stures Zählen.

Delphi-Quellcode:

function AddBooleanValues(Values: array of boolean): integer;
var
  i: integer;
begin
  result := 0;
  for i := 0 to high(Values) do
    if Values[i] then inc(result);
end;

Es kann entweder ein Boolean-Array übergeben werden oder sowas.

[WInfo]

Moin, Moin,

z. B. mit der Klasse im beiliegenden Testprogramm.

Delphi-Quellcode:

PROGRAM Project1;
{$APPTYPE CONSOLE}

USES
  SysUtils,
  Windows;

TYPE
  TAddBool = CLASS
  strict private
    fAddArray: ARRAY [0..1] OF integer;
  public
    PROCEDURE Clear;
    PROCEDURE add(abool: boolean);
    PROCEDURE print;
  END;

{$region 'TAddBool'}
  PROCEDURE TAddBool.add(abool: boolean);
  BEGIN
    Inc(fAddArray[integer(not (aBool = False))]);
  END;
  PROCEDURE TAddBool.Clear;
  BEGIN
    ZeroMemory(@fAddArray, sizeof(fAddArray));
  END;
  PROCEDURE TAddBool.print;
  BEGIN
    writeln('True: ', fAddArray[1]);
    writeln('False: ', fAddArray[0]);
  END;
{$endregion}

VAR
  AddBool: tAddBool;
BEGIN
  AddBool := tAddbool.Create;
  TRY
    addbool.add(True);
    addbool.add(False);
    addbool.add(True);
    addbool.print;
    readln;
  FINALLY
    addbool.Free;
  END;
END.

[omata]

Man kann auch den Ordinalwert eines Boolean bilden und um im Beispiel zu bleiben...

Delphi-Quellcode:

function AddBooleanValues(Values: array of boolean): integer;
var
  i: integer;
begin
  result := 0;
  for i := 0 to high(Values) do
    result:=result + ord(Values[i]);
end;

[Namenloser]

Zitat:

Zitat von WInfo

Moin, Moin,

z. B. mit der Klasse im beiliegenden Testprogramm.

Delphi-Quellcode:

...

Vielleicht solltest du lieber einen Service schreiben und per COM darauf zugreifen :mrgreen:

@omata: Das ist halt riskant.

[omata]

Zitat:

Zitat von NamenLozer

@omata: Das ist halt riskant.

Warum sollte das riskant sein? Der Ordinalwert von True und False wird sich niemals ändern. Wieso auch?

[3_of_8]

Weniger riskant als eher grauenhafter Stil. Idealerweise soll Code wie Prosa lesbar sein, man liest ihn, und versteht sofort, was gemeint ist. Das hier ist weniger Prosa-Stil, sondern eher Gesetzestext-Stil. :mrgreen:

[omata]

@3_of_8: das werde ich mir merken.

[3_of_8]

Im Übrigen: Der Ordinalwert von True als LongBool, wie es glaube ich bei manchen C-Versionen genutzt wird, oder zumindest, und vor allem, wie es Windows in einigen Bibliotheksfunktionen nutzt, ist $FFFFFFFF. Wenn du deinen Code also mit LongBools machst, bekommst du am Ende die Anzahl der True-Werte negativ heraus. ;)

True ist eben nicht wirklich als Boolean(1) definiert, sondern als alles, was nicht False ist, und False ist Boolean(0).

[omata]

Oh man, Leute ihr habt es immer noch begriffen. Naja egal, ich bin dann mal wieder weg.

[quendolineDD]

omata, aus einem einfachen Grund:

Delphi-Quellcode:

var
  b : BOOLEAN;
  i : INTEGER;
begin
  b := BOOLEAN(2);
  i := ORD(BOOLEAN(b));
end;

Das klappt dann für jedwegen Boolean'schen Ausdruck, eben auf der Prämisse das FALSE = 0 und TRUE <> 0.
b ist in diesem Fall TRUE, da <> 0. Das könnte in deiner Berechnung erhebliche Fehler erzeugen ...

Desweiteren wollte der Threadersteller lediglich die Anzahl aller Ausdrücke und eben die Anzahl aller wahren Ausdrücke wissen.

Und alle hier geposteten Funktionen und Prozeduren sind meiner Meinung nach etwas Overhead für die eigentlich gestellte Frage.

Delphi-Quellcode:

if BoolVar then INC(TrueVals);
INC(SumVals);

[Hawkeye219]

Hallo,

die Routine von omata funktioniert auch für ByteBool, WordBool und LongBool (=BOOL). Die notwendige Anpassung der Werte an den gewählten Elementtyp Boolean übernimmt der Delphi-Compiler. Die Routine darf also davon ausgehen, dass der Ordinalwert der Elemente entweder 0 oder 1 ist, so wie es auch in der Hilfedatei dokumentiert ist. Ärger gibt es nur dann, wenn man (mutwillig) als Boolean verkleidete Byte-Werte übergibt. Aber das wäre so, als würde man einen Texteditor eine ausführbare Datei laden lassen. Dafür ist der in der Regel nicht ausgelegt...

Gruß Hawkeye

[Cyf]

Ich denke ein simples Inc(n) in einer Schleife, die alle Bools überprüft (also <> 0) ist trotzdem schöner und kommt dann auch mit allem zurecht (und nebenbei ist es auchnoch unwesentlich kleiner im Code).
Aber die Diskussionm ob man Boolean jetzt sicher als 1 annehmen darf oder nichtm gabs hier schon ein paar mal.