Effizienter binär-output eines (word)-streams

[Sinspin]

Was du machen kannst ist einen Typen mit mehr als einem Zustand zu verwenden:

Delphi-Quellcode:

type
  TDual = packed record
  case byte of
  0 : (a : word);
  1 : (b: record hi,lo : byte;end);
  end;

Dann hast Du zur gleichen Zeit Zugriff darauf als Word und als Bytes. Das ganze als Array anlegen und nach Möglichkeit blockweise lesen und schreiben. Das spart Zeit beim Zugriff.

[Uwe Raabe]

Warum das Rad neu erfinden, wenn es doch schon in SysUtils existiert?

Delphi-Quellcode:

{ Type conversion records }

  WordRec = packed record
    case Integer of
      0: (Lo, Hi: Byte);
      1: (Bytes: array [0..1] of Byte);
  end;

  LongRec = packed record
    case Integer of
      0: (Lo, Hi: Word);
      1: (Words: array [0..1] of Word);
      2: (Bytes: array [0..3] of Byte);
  end;

  Int64Rec = packed record
    case Integer of
      0: (Lo, Hi: Cardinal);
      1: (Cardinals: array [0..1] of Cardinal);
      2: (Words: array [0..3] of Word);
      3: (Bytes: array [0..7] of Byte);
  end;

[Sinspin]

Nur das WordRec keinen Zugriff als Word erlaubt, nur als Bytes. Und dann sinnloserweise auch noch auf zwei Arten.

[Uwe Raabe]

Zitat von Sinspin:

Nur das WordRec keinen Zugriff als Word erlaubt, nur als Bytes. Und dann sinnloserweise auch noch auf zwei Arten.

Diese Records sind ja nicht als Typ in einer Typdeklaration gedacht, sondern als Cast auf eine Variable mit Word-Größe. Insofern wäre ein Zugriff auf Word innerhalb WordRec (analog in den anderen records) irgendwie obsolet.

Delphi-Quellcode:

var
  MyCharArray: array[0..15] of WideChar;
begin
  ...
  cntHighUnicode := 0;
  for I := Low(MyCharArray) to High(MyCharArray) do
    if WordRec(MyCharArray[0]).Hi <> 0 then
      Inc(cntHighUnicode);
  ...
end;

Der zugegeben redundante Zugriff auf die Einzelbytes ist wohl eher der Konsistenz mit den anderen record Typen geschuldet.

[Sequitar]

Hm danke für eure Ideen. Allerdings bin ich mir beim durchlesen nicht mehr sicher, ob ich mein problem richig dargestellt habe.(u.a @BerndS)
Also sagen wir ich habe als output die list<word>, welche ich in den output stream schreiben möchte. Natürlich geht das erst mal intuitiv ungefähr so:
Nur vom prinzip her - ohne auf Schönheit zu achten.

Delphi-Quellcode:

//..
from i:=list.lo to list.hi do 
begin
var x:word:=list[i]
stream.write{oder streamwriter().write}(x,wordsize);
end;

dann habe ich am ende einen output stream der groesse list.count*wordsize.
Meine Frage wäre: Geht das kürzer, z.b wenn ich ungefähr weiss, dass die meisten werte werte >high(byte) sein werden? Ich meine, vielleicht geht's ja auch gar nicht.


Gut, was mir jetzt noch einfällt - den könnte ich - zum Beispiel - noch mal durch eine Lauflängen-Kompression schicken (müsste ich mal probieren, ob das was bringt, bei vielen wiederholungen vielleicht), oder durch einen Huffman-Tree oder so ähnlich, damit ich am ende eine art bit-stream habe.

Bevor ich das anfange, wäre ich allerdings an möglichkeiten interessiert, die es mir erlauben, eine Ausgabefolge von word-werten reversibel(!) in eine effizientere Form zu bringen

[Uwe Raabe]

Zitat von Sequitar:

Bevor ich das anfange, wäre ich allerdings an möglichkeiten interessiert, die es mir erlauben, eine Ausgabefolge von word-werten reversibel(!) in eine effizientere Form zu bringen

Aber das ist doch genau das, wofür Kompressionsalgorithmen da sind. Welchen du da nimmst must du schon selbst entscheiden. Suchst du Bordmittel wirst du vielleicht in System.ZLib fündig.

[BerndS]

Wenn die Reihenfolge egal wäre könntest du den Stream teilen in Werte <=255 und Werte > 255.
Aber das bringt im Gegensatz zu einer Kompression nur minimale Einsparung.
Die Frage ist noch, ob die Werte mehrfach vorhanden sein können.

So richtig verstehen kann ich dein Problem nicht oder willst du auf Disketten schreiben.