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ß! =) :dancer:

[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

[Corpsman]

Hossa

Also es erfüllt mich voller Freude das es hier so viele Tolle Vorschläge und gedankengänge gibt.

Die Klasse hab ich nicht gemacht , weil ich die Boolean Arrays "Entpackt" im speicher halten will, aus eben genau oben genannten Performance gründen. Auserdem kommen während des Betriebes ständig erweiterungen in Dim 2 ( weil neue Buchstaben )

Zum Speichern finde ich es allerdings schon ein wenig Overkill und wollte deswegen die Gespeicherten Daten Packen.

Mengen Scheiden aus da zu langsam. Ich arbeite extrem viel mit dem Array und ich denke Mengen schaffen nicht die Performance.

Hier meine bisherigen Routinen, da ich allerdings noch keine Laden Funktion habe ist es sozusagen auch noch "Ungetestet".

Delphi-Quellcode:

Procedure SaveDynArr(Const f: TStream; Data: TBoolArray);
Var
  w, h, i, j, k: Integer;
  b: Byte;
Begin
  w := high(Data) + 1;
  h := High(Data[0]) + 1;
  // Zum Glück ist Data immer Rechteckig
  f.write(w, sizeof(w));
  f.write(h, sizeof(h));
  // Da wir die Breite Packen wirds etwas umständlich *g*
  For j := 0 To High(Data[0]) Do Begin // Über alle y - Werte
    For i := 0 To trunc(high(Data) / 8) Do Begin
      b := 0;
      For k := 0 To 7 Do
        // Das Letze Byte mus nicht unbedingt voll sein.
        If (i * 8 + k) <= High(Data) Then
          b := b + ord(Data[i * 8 + k, j]) Shl k;
      f.write(b, sizeof(b));
    End;
  End;
End;

Procedure SaveLetterData;
Var
  f: TFilestream;
  i, j: Integer;
Begin
  f := TFileStream.create(IncludeTrailingBackslash(ExtractFilePath(paramstr(0))) + 'Letters.dat', fmcreate Or fmopenwrite);
  // Wir Speichern Jeden Buchstaben und einfach alles
  For i := 0 To High(MainLetterData) Do Begin
    f.write(i, sizeof(i)); // Als 1. Die Nummer des Buchstabens
    j := High(MainLetterData[i]) + 1; // Dann die Anzahl der Elemente des Buchstabens
    f.write(j, sizeof(j));
    // Dann Alle Datensätze des Jeweiligen Buchstabens
    For j := 0 To High(MainLetterData[i]) Do Begin
      SaveDynArr(f, MainLetterData[i, j]);
    End;
  End;
  f.free;
End;

[alzaimar]

Wieso hältst du die Daten nicht wie gehabt im Speicher und arbeitest damit. Zum Speichern/Laden nimmst du z.B. meine Klasse.

[Corpsman]

Das würde gehn, wenn ich solche Arrays öfter brauchen würde würde ich die Klasse bestimmt machen, hab es nun fertig gemacht und es Funktioniert wunderbar ;).

Hier für alle Neugierigen :

Delphi-Quellcode:

Procedure LoadLetterData;
Var
  f: TFilestream;
  i, j, w, h, k: Integer;
  b: Byte;
Begin
  If Fileexists(IncludeTrailingBackslash(ExtractFilePath(paramstr(0))) + 'Letters.dat') Then Begin
    f := TFileStream.create(IncludeTrailingBackslash(ExtractFilePath(paramstr(0))) + 'Letters.dat', fmopenread);
    // Wir Speichern Jeden Buchstaben und einfach alles
    For i := 0 To High(MainLetterData) Do Begin
      f.read(j, sizeof(j));
      setlength(MainLetterData[i], j);
      // Laden der Datensätze
      For j := 0 To high(MainLetterData[i]) Do Begin
        f.read(w, sizeof(w)); // Breite
        f.read(h, sizeof(H)); // Höhe
        setlength(MainLetterData[i, j], w, h);
        For h := 0 To high(MainLetterData[i, j, 0]) Do Begin
          For w := 0 To trunc(high(MainLetterData[i, j]) / 8) Do Begin
            f.read(b, sizeof(b));
            For k := 0 To 7 Do
              If (w * 8 + k) <= high(MainLetterData[i, j]) Then
                // Das Jeweils Richtige Bit Auslesen
                MainLetterData[i, j, w * 8 + k, h] := ((b Shr k) And 1) = 1;
          End;
        End;
      End;
    End;
    f.free;
  End
  Else Begin
    For i := 0 To High(MainLetterData) Do
      setlength(MainLetterData[i], 0);
  End;
End;

Procedure SaveDynArr(Const f: TStream; Data: TBoolArray);
Var
  w, h, i, j, k: Integer;
  b: Byte;
Begin
  w := high(Data) + 1;
  h := High(Data[0]) + 1;
  // Zum Glück ist Data immer Rechteckig
  f.write(w, sizeof(w));
  f.write(h, sizeof(h));
  // Da wir die Breite Packen wirds etwas umständlich *g*
  For j := 0 To High(Data[0]) Do Begin // Über alle y - Werte
    For i := 0 To trunc(high(Data) / 8) Do Begin
      b := 0;
      For k := 0 To 7 Do
        // Das Letze Byte mus nicht unbedingt voll sein.
        If (i * 8 + k) <= High(Data) Then
          b := b + ord(Data[i * 8 + k, j]) Shl k;
      f.write(b, sizeof(b));
    End;
  End;
End;

Procedure SaveLetterData;
Var
  f: TFilestream;
  i, j: Integer;
Begin
  f := TFileStream.create(IncludeTrailingBackslash(ExtractFilePath(paramstr(0))) + 'Letters.dat', fmcreate Or fmopenwrite);
  // Wir Speichern Jeden Buchstaben und einfach alles
  For i := 0 To High(MainLetterData) Do Begin
    // f.write(i, sizeof(i)); // Als 1. Die Nummer des Buchstabens <-- Redundant
    j := High(MainLetterData[i]) + 1; // Dann die Anzahl der Elemente des Buchstabens
    f.write(j, sizeof(j));
    // Dann Alle Datensätze des Jeweiligen Buchstabens
    For j := 0 To High(MainLetterData[i]) Do Begin
      SaveDynArr(f, MainLetterData[i, j]);
    End;
  End;
  f.free;
End;

[shmia]

Zitat:

Zitat von Dezipaitor

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

Einspruch: TBits gibt's auch auf meinem Delphi 5 Prof.
Ich würde auch dringend zu dieser Klasse raten; das vereinfacht und verschönt den ganzen Sourcecode.

[Corpsman]

Ich hab d5 Prof und bei mir ists net drin ...

[Muetze1]

Zitat:

Zitat von Corpsman

Ich hab d5 Prof und bei mir ists net drin ...

Delphi 5 Enterprise

Das Objekt TBits speichert ein Array boolescher Werte.

Unit

classes

Beschreibung

Mit Hilfe von TBits kann eine theoretisch unbegrenzte Anzahl von booleschen Werten gespeichert werden. Die Kapazität eines TBits-Objekts ist nur durch den verfügbaren Speicher begrenzt. Das Objekt sorgt selbst für die nötige Erweiterung des jeweils belegten Speicherbereichs. Wenn in bestimmten Situationen nicht mehr als 32 boolesche Werte benötigt werden, läßt sich dieselbe Funktionalität mit den logischen Operatoren AND und OR sowie einer 32-Bit-Integer-Variablen erreichen.

Es ist definitiv mit bei, auch bei der Professional, da die Enterprise soweit nur erweiterte Datenbankanbindungspackages hat. Die Classes.pas ist aber definitiv die gleiche. Würde sogar behaupten, dass Delphi 5 Standard auch die TBits Klasse hat.

[Corpsman]

Komisch,

Ich hab in meiner Classes.pas nachgesehn und du hast Recht da steht TBits nur die Hilfe wuste davon nichts ...