Zahlen in einer Menge (Set Of) speichern, Verständnisfrage

[stoxx]

Ich habe drei Zahlen, die einen Zustand von 1 bis 8 annehmen können.

Diese Zahlen, die Zustände repräsentieren, sollen in einer Menge gespeichert werden.
In der Implementierung möchte ich anstatt dem Case, das irgendwie mathematisch berechnen.
Wie geht das ?

Delphi-Quellcode:

TMengenElemente =
          ( a1,a2,a3,a4,a5, a6, a7, a8,
            b1,b2,b3,b4,b5, b6, b7, b8,
            c1,c2,c3,c4,c5, c6, c7, c8);

TMenge = set of TMengenElemente;


procedure include_A(var m : TMenge; value : byte);
begin

case Value of
 1 :  include(m, a1);
 2 :  include(m, a2);
 3 :  include(m, a3);
 4 :  include(m, a4);
 5 :  include(m, a5);
 6 :  include(m, a6);
 7 :  include(m, a7);
 8 :  include(m, a8);
end;

end; // von Include_A
//==============================================================================

procedure include_B(var m : TMenge; value : byte);
begin

case value of
 1 :  include(m, b1);
 2 :  include(m, b2);
 3 :  include(m, b3);
 4 :  include(m, b4);
 5 :  include(m, b5);
 6 :  include(m, b6);
 7 :  include(m, b7);
 8 :  include(m, b8);
end;

end; // von Include_B

//==============================================================================


procedure include_C(var m : TMenge; value : byte);
begin

case value of
 1 :  include(m, c1);
 2 :  include(m, c2);
 3 :  include(m, c3);
 4 :  include(m, c4);
 5 :  include(m, c5);
 6 :  include(m, c6);
 7 :  include(m, c7);
 8 :  include(m, c8);
end;

end; // von Include_C


//==============================================================================

procedure Test;
var
  m1, m2 : TMenge;
  a,b,c  : Integer;

begin

m1 := [];
m2 := [];

a := 8;

include_A(m1, a);
include(m2, TMengenElemente(a)); // so geht es natürlich leider nicht !

showmessage(inttostr(Integer(m1)) + ' ; ' + inttostr(Integer(m2)));


end;

[Dax]

Spontan würde ich statt dem Case das hier (zB für A) vorschlagen:Include(m, TMengenElemente(Ord(a1) + Value - 1)); Ist allerdings nicht getestet. Statt Ord könnte/müsste/sollte auch Byte funktionieren..

[stoxx]

Hi Dax !

also das funktioniert wohl, sagst Du mir noch, warum das so funktioniert ?
hab es jetzt so.

Und wie teste ich genauso effizient, ob in der Menge ein Zustand enthalten ist ?

Delphi-Quellcode:

procedure includefast_A(var m : TMenge; Value : byte);
begin
  Include(m, TMengenelemente(Ord(a1) + Value -1) );
end;

procedure includefast_B(var m : TMenge; Value : byte);
begin
  Include(m, TMengenelemente(Ord(b1) + Value -1) );
end;


procedure includefast_C(var m : TMenge; Value : byte);
begin
  Include(m, TMengenelemente(Ord(c1) + Value -1) );
end;

[stoxx]

also eigentlich will ich ja mathematisch ausgedrückt, 3 Merkmalsvektoren, die einen Zustand von 1 bis 8 annehmen können, in einer 4 Byte großen Integerzahl speichern.
Vielleicht gibt es ja sogar noch bessere Lösungen, als das über Mengen zu gestalten ?

[Dax]

Das funktioniert, weil:

a1, a2, ..., c8 nur Aliaswerte für 1, 2, ..., 24 sind. Ein Mengentyp ist so gesehen nur eine Zahlenfolge, deren Elemente Namen haben. Genauso könntest du Konstanten benutzen. Allerdings sind Sets und Enumerations viieel komfortabler zu benutzen

Um genauso effektiv zu testen drehts du den Spiess um:

Delphi-Quellcode:

function ContainsElement(M: TMenge; E: Byte): Boolean;
begin
  Result := TMengenElement(Ord(a1) + E - 1) in M;
end;

Zu deinem Nachfolgebeitrag weiß ich leider nix..

[stoxx]

klar, hast Recht ! .. hätte man auch selber drauf kommen können. Danke Dir nochmal !

[edit]

nur der Form halber, falls es mal jemand liest
a1, a2, ..., c8 sind Aliaswerte für 0, 2, ..., 23

[Khabarakh]

Zitat von stoxx:

also eigentlich will ich ja mathematisch ausgedrückt, 3 Merkmalsvektoren, die einen Zustand von 1 bis 8 annehmen können, in einer 4 Byte großen Integerzahl speichern.
Vielleicht gibt es ja sogar noch bessere Lösungen, als das über Mengen zu gestalten ?

Du könntest die Vektoren direkt in einen Integer speichern, ob das aber geschickter ist, weiß ich nicht.
Da 8 Zustände 3 Bit entsprechen, würden in einen Longint bis zu 10 Vektoren passen.

Beispiel:

Delphi-Quellcode:

type
  TState = 0..7;
  TVectorIndex = 0..2
  
procedure SetState(const AState: TState; const AVectorIndex: TVectorIndex; var AValue: Integer);
begin
  AValue := (AValue and not (7 shl (AVectorIndex * 3)) // alten Wert löschen
            or (AState shl (AVectorIndex * 3)); // neuen einfügen
end;

Hab leider keine Zeit mehr, um zu überprüfen, ob die Prozedur nicht vollkommen falsch ist ^^ .

[edit]Doch noch etwas Zeit, es stimmt wohl soweit:

Delphi-Quellcode:

program Project2;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type
  TState = 0..7;
  TVectorIndex = 0..2;

procedure SetState(const AState: TState; const AVectorIndex: TVectorIndex; var AValue: Integer);
begin
  AValue := (AValue and not (7 shl (AVectorIndex * 3))) // alten Wert löschen
            or (AState shl (AVectorIndex * 3)); // neuen einfügen
end;

var
  Value, i: Integer;
begin
  Value := 1; // 1. Vektor = 1, 2.= 0, 3. = 0
  SetState(6, 1, Value);
  // 1.= 2, 2.= 6, 3.= 0

  // einzelne Bits ausgeben
  for i := 31 downto 0 do
    if Value and (1 shl i) <> 0 then
      Write('1')
    else
      Write('0');
  Readln;

  // Ausgabe: 00000000000000000000000000110001
  //                                 cccbbbaaa
  // aaa = 1. Vektor = 001 = 1
  // bbb = 2. Vektor = 110 = 6
end.