Suche Container-Klasse zur ERstellung eines Index

[0KommaNix]

Hallo Uwe,

Zitat von Uwe Raabe:

So wie du es beschreibst ist der Index-Record genauso groß wie der Daten-Record. Wenn du den Index komplett im Speicher halten kannst, dann kannst du auch direkt die Daten in den Speicher laden und sortieren.

Zwar haben die beiden Records die selbe Größe von 16Bit, aber im Index soll pro Kachel nur ein Record gespeichert werden. In meinen Beispiel ergibt sich also ein Größenverhältnis von 1 zu 4096.

Zitat von Uwe Raabe:

TDataRecord enthält faktisch zwei Double (8 Byte) (was das packed schon mal überflüssig macht).

Ja, ich weiss . Ich verwende packed für alles, was das Programm verlässt. Kostet nichts und soll darauf hinweisen, dass es Systemübergreifend kompatible sein soll.

Zitat von Uwe Raabe:

Somit hat ein TDataRecord eine Größe von 16 Byte, was bei 10.000.000 Datensätzen weniger als 160 MB ergibt - sollte also problemlos alles in den Speicher passen.

Da hast du recht. Ich überschätze bestimmt den Zeitbedarf. Allerdings ist der Dateigröße nach oben hin keine Grenze gesetzt.

Zitat von Uwe Raabe:

Speichert man die TDataRecords in einem TArray<TDataRecord> und baut sich einen IComparer<TDataRecord>, der auf den Time-Anteil prüft, kann man die TArray-Methoden Sort und BinarySearch verwenden um den exakten bzw. nächst-höheren Time-Eintrag zu finden.

Das will ich probieren! Leider kenne ich mich mit Generics nicht so gut aus. Kannst du mir bitte die Deklaration einer Implementationsklasse für IComparer<TDataRecord> zeigen?

[0KommaNix]

Zitat von 0KommaNix:

Leider kenne ich mich mit Generics nicht so gut aus. Kannst du mir bitte die Deklaration einer Implementationsklasse für IComparer<TDataRecord> zeigen?

Ok, beim ersten Schreck vor Generics, hab ich Angst bekommen. War dann doch leichter als gedacht. Schreibe nun ein Test für TArray<TDataRecord>.
Danke Uwe!

[Uwe Raabe]

Ich weiß zwar noch nicht wie der Index dann aufgebaut werden soll, aber hier mal ein paar Ansätze:

Delphi-Quellcode:

type
  TTimeRecord<T> = record
    Time: TDateTime;
    Value: T;
  end;

type
  TDataRecord = TTimeRecord<Double>;
  TDataArray = TArray<TDataRecord>;

  TIndexRecord = TTimeRecord<Int64>;
  TIndexArray = TArray<TIndexRecord>;

function MakeIndexRecordComparer: IComparer<TIndexRecord>;
begin
  Result := TComparer<TIndexRecord>.Construct(
    function(const Left, Right: TIndexRecord): Integer
    begin
      Result := CompareDateTime(Left.Time, Right.Time);
    end
    );
end;

var 
  FIndex: TIndexArray;

procedure SortIndex;
begin
  TArray.Sort<TIndexRecord>(FIndexArray, MakeIndexRecordComparer);
end;

function FindIndexValue(const ATime: TDateTime; out AIndex: Int64): Boolean;
var
  foundIndex: NativeInt;
begin
  var item: TIndexRecord;
  item.Time := ATime;
  Result := TArray.BinarySearch<TIndexRecord>(FIndexArray, item, foundIndex, MakeIndexRecordComparer);
  { falls bei nicht gefunden der kleinere Record verwendet werden soll }
//  if not Result then
//    Dec(foundIndex);
  if not Result and (foundIndex < 0) then begin
    AIndex := -1;
    Exit;
  end;
  AIndex := FIndexArray[foundIndex].Value;
end;

[0KommaNix]

Uwe, ich kann meine Begeisterung kaum Ausdruck verleihen - Ich freue mich wie Rumpelstilzchen!
SortIndex werde ich nicht brauchen, weil es ein Fehler wäre, wenn es einen Rücksprung bei der Aufnahmezeit gibt. Dann wäre eine Reparatur der Daten nötig. Das muss ich nur erkennen und den Anwender entscheiden lassen.

Zwischenzeitlich hatte ich einen einfachen Testfall geschrieben, bei dem ich für 1024*1024*1024 Daten-Records jede 4096 Records große Kachel einlese und in den Index stecke. Das ist zwar noch zu langsam, aber nach deiner Vorlage ist es sehr einfach einen kleineren Index aufzubauen und zwischen den Stützstellen einfach linear zu interpolieren, so wie oben angedacht. Das wird so schnell, dass ich mir ein Speichern und Laden sparen kann.

Vielen, vielen Dank!