Kürzung eines bool'schen Ausdruckes

[mirage228]

Hallo!

Ich habe eine function, die folgender maßen aussieht:

Delphi-Quellcode:

function TMainForm.CanFormat(Document: Integer): Booolean;
begin
  if IsIndexValid(Document) then
  begin
    if Dokumente[Document].EditorMode then
     { SynEdit speichert als TXT! }
      Result := False else
    Result := not Dokumente[Document].PlainText;
  end else Result := True; 
end;

Diesen habe ich versucht so zu "kürzen":

Delphi-Quellcode:

function TMainForm.CanFormat(Document: Integer): Booolean;
begin
  Result := not ((not (IsIndexValid(Document)) or ((Dokumente[Document].EditorMode) or (not (not Dokumente[Document].EditorMode) and (not Dokumente[Document].PlainText)))));
end;

Auf den Blick scheint er zu funktionieren, aber ich bin mir nicht sicher, ob der Ausdruck bei allen Konditionen das gleiche Ergebnis, wie der Original Ausdruck hat.

Könnt ihr euch den unteren Ausdruck kurz anschauen und mir sagen, ob ich in korrekt umgeschrieben habe?
Hat es überhaupt Sinn, den obigen Ausdruck soweit zu kürzen?

Danke,
mirage228

[XeRo]

Zitat von mirage228:

Hat es überhaupt Sinn, den obigen Ausdruck soweit zu kürzen?

wenn du dich selbst nicht mehr auskennst

Zitat von mirage228:

...aber ich bin mir nicht sicher, ob der Ausdruck bei allen Konditionen das gleiche Ergebnis, wie der Original Ausdruck hat.

dann nicht....

[fkerber]

Hi!

Ich hätte den oberen gelassen wie er war.
Bei Version 2 blickst weder du gewschweige denn ein anderer Programmierer durch.
Außerdem glaube ich nicht, dass du viele Vorteile hast so.

Ciao fkerber

[d3g]

Wenn du zusammenfassen willst, dann hätte ich es so gemacht:

Code:

p := isIndexValid(Document)
q := Dokumente[Document].EditorMode
r := Dokumente[Document].PlainText

p   q   Result
--------------
f   f   t
f   t   t
t   f   not r
t   t   f

((not p) and (not q)) or ((not p) and q)
= (not p) and ((not q) or q)
= (not p) and t
= (not p)

Folglich:

Delphi-Quellcode:

if (p and (not q)) then
  Result := not r
else
  Result := not p;
// bzw.
if (isIndexValid(Document) and (not Dokumente[Document].EditorMode)) then
  Result := not Dokumente[Document].PlainText
else
  Result := not isIndexValid(Document);

Wenn's dann noch weiter verkürzt werden soll, kann man's auch vollständig machen:

Code:

p   q   r   Result
------------------
f   f   f   t
f   f   t   t
f   t   f   t
f   t   t   t
t   f   f   t
t   f   t   f
t   t   f   f
t   t   t   f

Um's kürzer zu machen, beziehe ich schon mal das Ergebnis von vorher mit ein.

Code:

(not p) or (p and (not q) and (not r))

Das heißt:

Delphi-Quellcode:

Result := (not p) or (p and (not q) and (not r));
// bzw.
Result := (not isIndexValid(Document) or (isIndexValid(Document) and (not Dokumente[Document].EditorMode) and (not Dokumente[Document].PlainText));

Die Sinnhaftigkeit der vollständigen "Optimierung" sei mal dahingestellt. Übrigens könnte es gut sein, dass ich Fehler gemacht habe (auch dumme), ich bin nicht besonders wach im Moment.

[edit]Ein (Tipp-)Fehler weniger.[/edit]

[mirage228]

Hi,

danke erstmal für eure Antworten!

Wenn ich den Code nachher selbst nicht verstehe, hat es keinen Sinn, einen zu komplizierten Ausdruck hinzuschreiben.

So wie es d3g hier beschrieben hat, ist es wirklich sehr einleuchtend

DieVorgehensweise finde ich sehr gut - da habe ich mal wieder was dazugelernt.
Soweit ich getestet habe, ist der optimierter Ausdruck durchaus korrekt und auch leserlicher als meiner.

Ich denke, ich werde den Ausdruck von dir verwenden.

Vielen Dank nochmal

mfG
mirage228