Aufzählungstyp-Variablen vergleichen

[Codehunter]

Moin!

Ich steh mal wieder auf dem Schlauch. Wenn ich zwei Aufzählungstyp-Variablen habe und mit möglichst wenig Codegeschwurbel feststellen will, ob alle Elemente aus Variable A in Variable B enthalten sind, wie stelle ich das an?

Delphi-Quellcode:

type
  TFeld = (A, B, C, D, E, F, G, H, I, J, K);
  TFelder = set of TFeld;

var
  FPflichtfelder: TFelder = [A, B, C, D];
  FVar1: TFelder = [A, C, E];
  FVar2: TFelder = [A, B, C, D, E]; 

  function Pruefe(Var1, Var2: TFelder): Boolean;
  begin
    // Hier mit einem Einzeiler machbar ?
  end;

begin
  if Pruefe(FVar1, FPflichtfelder) then {...} // -> FALSE
  if Pruefe(FVar2, FPflichtfelder) then {...} // -> TRUE
end;

[Bbommel]

Etwa so?
Mit der entscheidenden einen Zeile. :-)

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils;

type
  TFeld = (A, B, C, D, E, F, G, H, I, J, K);
  TFelder = set of TFeld;

var
  FPflichtfelder: TFelder = [A, B, C, D];
  FVar1: TFelder = [A, C, E];
  FVar2: TFelder = [A, B, C, D, E];

function Pruefe(Var1, Var2: TFelder): Boolean;
begin
  Result:=(Var1*Var2)=Var1;
end;

begin
  try
    if Pruefe(FPflichtfelder,FVar1) then
      writeln('alles drin')
    else
      writeln('da fehlt was');
    if Pruefe(FPflichtfelder,FVar2) then
      writeln('alles drin')
    else
      writeln('da fehlt was');
    readln;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

Jetzt so implementiert, wie du es beschrieben hast in deinem Text (also var1 muss komplett in var2 enthalten sein), das heißt, die Pflichtfelder müssten dann der erste Parameter sein - genau anders herum als in deinem Codebeispiel.

Oder habe ich jetzt zu einfach gedacht? :-)

[DeddyH]

Wenn ich mich nicht irre:

Delphi-Quellcode:

if VarA * VarB = VarA then ...

[Der schöne Günther]

Delphi-Quellcode:

procedure p();
type
   TItem = (a, b, c);
   TSet = set of TItem;
var
   setA, setB, setC: TSet;
begin
   setA := [a, b];
   setB := [a, b, c];

   if (setA <= setB) then
      ShowMessage('A ist Teilmenge von B')
   else
      ShowMessage('A ist KEINE Teilmenge von B')

end;

[himitsu]

Mathematik:

Delphi-Quellcode:

x in A  // EIN Wert ist in A drin
A * [x] <> []   // EIN Wert ist in A drin
A * [x] = [x]   // NUR dieser Wert ist in A drin (wie IN)

A = B  // beides sind gleich
A * B = B  // alles von B ist in A drin
A * B = []  // nichts von B ist in A drin
A * B <> []  // irgendwas von B ist in A drin
A - B <> []  // nichts außer etwas von B in A drin

Die Vergleichsoperatoren sind etwas gewöhnungsbedürftig, aber zumindestens funktionieren sie richtig, wenn sie funktionieren.

Delphi-Quellcode:

setA := [a, b, c];
setB := [d];
if setA <= setB then

setB ist ordinal und binär größer, aber der Vergleich stimmt, also es ist False.

Delphi-Quellcode:

if setA <= setB then

entspricht

Delphi-Quellcode:

if not (setA > setB) then

, aber < und > gibt es nicht. ([DCC Fehler] E2008 Inkompatible Typen - im XE)
Nur warum < und > nicht gehen, erschließt sich mir nicht, denn "ist Teilmenge und/aber nicht gleich" gibt es doch wohl.

[Codehunter]

Ich danke euch allen! Besonders Himitsu für die Erläuterungen zu den Grundlagen.

Ich denke ich habe gedanklich den Fehler gemacht, die Sets wie eine Variable vom Typ Byte zu behandeln. Speichertechnisch ist es wohl so, das Handling dagegen unterscheidet sich grundlegend.

[himitsu]

Mathematisch und nur mit

Delphi-Quellcode:

=

Delphi-Quellcode:

<>

Delphi-Quellcode:

*

Delphi-Quellcode:

+

und

Delphi-Quellcode:

-

kann man problemlos sich alles binär und bitweise betrachten. (mehrere boolsche Operationen)

Delphi-Quellcode:

(x in A) and (y in A) and (z in A)

=

Delphi-Quellcode:

A * [x..z] = [x..z]

Delphi-Quellcode:

(x in A) or (y in A) or (z in A)

=

Delphi-Quellcode:

A * [x..z] <> []

Bei

Delphi-Quellcode:

<>

die Ergebnisse der einzelnen Bits/Werte mit ODER und bei

Delphi-Quellcode:

=

mit UND verbinden.



Nur die

Delphi-Quellcode:

<=

und

Delphi-Quellcode:

=>

muß man hierbei "logisch" betrachten, oder man muß sie sich anders vorstellen

Delphi-Quellcode:

A <= B

=

Delphi-Quellcode:

A - B = []