Speichereffizientes Speichern von Boolean Array's

[Corpsman]

Hallo alle miteinander ,

ich hab hier ein kleines Speicherproblem

also ich habe mir foglende Variable gebaut:

Delphi-Quellcode:

Type

  TBoolArray = Array Of Array Of Boolean;

Var
  MainLetterData: Array[0..25 + 10] Of Array Of TBoolArray;

Wie man sehen kann ist das ein 4 Dim Array bei dem 3 Dims Dynamisch sind.

Nun will ich dieses Monster Speichern und auch wieder Laden können.

Das Problem ist
Normalerweise wäre ich hergegangen und hätte die Dimension gespeichert und dann eben Zeile für Zeile

Das Problem ist aber wenn man Hergeht und ein Boolean Speichert braucht der ja jeder Bool ein Byte

Und dann ist mein Array 8 Mal Größer als eigentlich.

Weis mir nun jemand wie ich mittels Delphi Spezial Operationen das Array so speichern das der immer 8 Boolean zu einem Byte zusammenfasst ?

ACHTUNG !!

Wie man das von Hand macht weis ich, aber das ist mir eigentlich zu auffwendig, es geht hier also um die "Elegante" Lösung.

Mittels 1, 2 Befehlen.

Das man sich die Bytes zusammenshiften kann und das dann speichern kann ist Klar.

[Xong]

Anders geht´s aber nicht. Schreibe dir am besten eine Klasse, die das Gewünschte kapselt.

LG,
Xong

[Corpsman]

*würg*

damit sind alle Hoffnungen weg.

THX

[Xong]

Hey!
Da beginnt doch erst der Spaß! =)

[Muetze1]

TBits und TObjectList für die zweite Dimension

[Dezipaitor]

TBits gibt es erst seit Delphi6. Corpsman arbeitet aber mit Delphi5.

Zudem gibt TBits keine Möglichkeit die Daten gepackt zu bekommen.

[alzaimar]

Eigentlich ist das nicht so aufwändig. Du verwendest eben kein TBoolArray sondern eine Klasse, die das wie oben packt.

Delphi-Quellcode:

Type
  TByteArray = Array Of Byte;
  T4DimBoolArray = Class
  private
    fDim1, fDim2, fDim3, fDim4: Integer;
    fBytes: Array Of Byte;
    Function GetValue(i, j, k, l: Integer): Boolean;
    Procedure SetValue(i, j, k, l: Integer; Const Value: Boolean);
  public
    Constructor Create(dim1, dim2, dim3, dim4: Integer);
    Property Value[i, j, k, l: Integer]: Boolean read GetValue write SetValue;
    Property Bytes: TByteArray read fBytes;
  End;

Constructor T4DimBoolArray.Create(dim1, dim2, dim3, dim4: Integer);
Begin
  fDim1 := dim1;
  fDim2 := dim2;
  fDim3 := dim3;
  fDim4 := dim4;
  SetLength(fBytes, fDim1 * fDim2 * fDim3 * fDim4);
End;

Function T4DimBoolArray.GetValue(i, j, k, l: Integer): Boolean;
Var
  b: Integer;

Begin
  b := ((i * fDim1 + j) * fDim2 + k) * fDim3 + l;
  result := fBytes[b Div 8] And (1 Shl b Mod 8) <> 0;
End;

Procedure T4DimBoolArray.SetValue(i, j, k, l: Integer; Const Value: Boolean);
Var
  b, b1, b2: Integer;
  m: Byte;
Begin
  b := ((i * fDim1 + j) * fDim2 + k) * fDim3 + l;
  b1 := b Div 8;
  m := 1 Shl b Mod 8;
  If Value Then
    fBytes[b1] := fBytes Or m
  Else
    fBytes[b1] := fBytes And Not m;
End;

Ungetestet.

[OldGrumpy]

Die Kernfrage bei dem ganzen sollte man aber nicht ausser Acht lassen: Macht es überhaupt Sinn? Mit heutigen Rechnern ist es in den allermeisten Fällen so, dass man sich einen geringen Platzvorteil (der heutzutage kaum noch ins Gewicht fällt) mit einem sehr viel größeren Performancenachteil erkauft. Sowas macht IMHO keinen Sinn. Ich habe in einem Projekt gerade erst aus genau diesem Grunde einen ganzen Stapel Arithmetik gegen Lookup-Tables ausgetauscht. Hauptspeichermehrbedarf schlappe 6 MB, dafür aber ein extremer Performancezuwachs von über 300% in den zeitkritischen Teilen.

[Apollonius]

Wenn man es vernünftig anstellt, hat man keinen Performance-Nachteil. In TBits wird die Abfrage z.B. mit der Anweisung bt erledigt, was extrem schnell sein sollte.

[Hawkeye219]

Hallo Corpsman,

neben der von alzaimar vorgestellten Abbildung auf ein eindimensionales Array könntest du auch über die Verwendung von Mengen nachdenken, falls dich die Beschränkungen von Delphi (max. 256 Elemente pro Menge) nicht daran hindern:

Delphi-Quellcode:

type
  TFlag = 0..25 + 10;
var
  Flag  : TFlag;
  Bytes : Integer;
  i, j  : Integer;
  Data  : array of array of array of set of TFlag;
begin
  SetLength (Data, 10, 20, 30);

  Flag := 4;

  // Setzen eines Flags
  Include (Data[0, 0, 0], Flag);

  // Löschen eines Flags
  Exclude (Data[0, 0, 0], Flag);

  // Abfragen eines Flags
  if (Flag in Data[0, 0, 0]) then ;

  with TFileStream.Create('data.bin', fmCreate) do
    try
      Bytes := Length(Data[0, 0]) * SizeOf(Data[0, 0, 0]);

      for i := 0 to High(Data) do
        for j := 0 to High(Data[i]) do
          Write (Data[i, j, 0], Bytes);
    finally
      Free;
    end;
end;

Den Code zum Speichern darfst du nur als einfaches Beispiel verstehen. In der Praxis wirst du die Dimension des Arrays speichern müssen, um die Daten wieder einlesen zu können.

Gruß Hawkeye