Generic class <T> , wie füge ich konkrete Daten ein ?

[bernhard_LA]

wenn ich meine records in Klassen konvertiere und dann Constraints verwende kann ich kompilieren, ich hoffe ich habe Eure Inputs im sample code unten richtig umgesetzt.


mein Problem mit dieser Lösung:
ich möchte doch alle 3 Klassen TClusterDataX in meiner TKMeans class verarbeiten und erst wenn ich eine konkrete Klasse verwende mich für den Datentypen entscheiden müssen. Muss ich dann die TClusterDataX voneinander erben lassen?

Delphi-Quellcode:

  /// <summary>
  /// here it is just a simple pixel but can be more in future
  /// </summary>
  TClusterData3 = class
    DrawingColor: TColor;
    x, y: Integer;
    chrlabel : char;
    // ...
    // ..
    // .
  end;

  /// <summary>
  /// a bit different pixeldefinition
  /// </summary>
  TClusterData2 = class
    BWColor: Byte;
    x, y: Integer;
    // tbd.
    // ...
    // ..
    // .
  end;

  TClusterData = class
    DrawingColor: TColor;
    x, y: Integer;
  end;


type
  [B]TKMeans<T: TClusterData> = class[/B]
  private

  private
    FClusteredData: TClusterList<T>;

    FRawData: TRawData<T>;

    FNumClusters: Integer;

    FDistanceMetric: TDistanceMetricfunction<T>;

    FCentroidfct: TCentroidfunction<T>;

    FMaxIterations: Integer;

  public
    constructor Create(NumClusters: Integer;
      DistanceMetric: TDistanceMetricfunction<T>;
      Centroidfct: TCentroidfunction<T>; MaxIterations: Integer = 10);

    procedure LoadData(SoureBitMap: TBitmap); overload;

    function FindNewClusterCentroids: Boolean;

    procedure GroupData2NearestCluster;

    procedure SaveData(OutBitMap: TBitmap);
  end;

[jaenicke]

Ja, denn das sagt der Constraint aus. Dass der Typ als Elterntyp TClusterData haben muss.

Ich glaube aber nicht, dass du das brauchst. Da du im Konstruktor die vorgeschlagenen Berechnungsfunktionen übergibst, wäre es hier auch möglich, dass du den Constraint weglässt und einfach Records verwendest. Denn deine generische Klasse muss ja dann die Details des Typen gar nicht mehr kennen und eine Einschränkung ist somit nicht notwendig. Die ergibt sich dann daraus, dass der Nutzer der Klasse passende Funktionen bereitstellen muss. Allerdings werden Records beim Zugriff immer kopiert, weshalb die Performance nicht optimal ist. Das könnte man mit Pointern verbessern.

Bei Verwendung von Klassen kannst du dir die Berechnungsfunktionen sparen. Dann leitet du von einer gemeinsamen Klasse ab, die im Constraint steht. Das heißt dort definierte Funktionen kann die generische Klasse dann einfach aufrufen. In den abgeleiteten Clusterklassen überschreibt du die dann einfach mit speziellen Funktionen zu dem jeweiligen Typ.

[bernhard_LA]

Generic List TList<CLass> vs. TList<Records> bei meinen Versuchen liegt TList<Rec> deutlich vor der Class Variante , in Bezug auf Speed und Speicherverbrauch,
sehe ich hier was falsch?

Delphi-Quellcode:

type

  /// <summary>
  /// here it is just a simple pixel but can be more in future
  /// </summary>
  TClusterData3 = class
    DrawingColor: TColor;
    x, y: Integer;
    chrlabel : char;
    // ...
    // ..
    // .
  end;


  TClusterData3REC = record
    DrawingColor: TColor;
    x, y: Integer;
    chrlabel : char;
    // ...
    // ..
    // .
  end;



  /// <summary>
  /// a bit different pixeldefinition
  /// </summary>
  TClusterData2 = class
    BWColor: Byte;
    x, y: Integer;
    // tbd.
    // ...
    // ..
    // .
  end;

  TClusterData = class
    DrawingColor: TColor;
    x, y: Integer;
  end;

  /// <summary>
  /// here it can be just a simple pixel, in general  we store the  complete morginal data inside this  list
  /// </summary>
  TRawData<T> = class(TList<T>)
  end;






procedure TForm1.CornerButton_list_classClick(Sender: TObject);
var
      rawdata_class :  TRawData<TClusterData3>;
      i : Integer;
      newclass : TClusterData3;

begin

     StatusbarLabel.Text := ' Create Elements';

     AProfiler.Start;

     rawdata_class:=TRawData<TClusterData3>.Create;

     for I := 0 to (16000*16000) do
       begin
          newclass :=TClusterData3.Create;

          newclass.x := random(1000);
          newclass.y := random(1000);
          newclass.DrawingColor := 20000 ;

          rawdata_class.Add(newclass);
       end;

      AProfiler.Stop;

      StatusbarLabel.Text := 'DONE  CLASS: ' + AProfiler.GetElapsedTime(total_time) ;

       rawdata_class.Free;
end;

procedure TForm1.CornerButton_list_recClick(Sender: TObject);
var   rawdata_rec :  TRawData<TClusterData3REC>;
      i : Integer;
      newrec : TClusterData3REC;

begin

     StatusbarLabel.Text := ' Create Elements';

     AProfiler.Start;

     rawdata_rec:=TRawData<TClusterData3REC>.Create;

     for I := 0 to (16000*16000) do
       begin
          newrec.x := random(1000);
          newrec.y := random(1000);
          newrec.DrawingColor := 20000 ;

          rawdata_rec.Add(newrec);
       end;

      AProfiler.Stop;

      StatusbarLabel.Text := 'DONE  REC: ' + AProfiler.GetElapsedTime(total_time) ;

      rawdata_rec.Free;
end;

[freimatz]

Was Speed betrifft halte ich das für sehr plausibel. Bei Speicherverbrauch würde ich sagen hängt davon ab wie viel Speicher der record benötigt und ob das gerade so in einen Block passt.
Wenn Dir das wichtig ist, würde ich noch TArray<> anschauen.

[jaenicke]

Das kommt schon hin, denn die Erzeugung einer Klasse beinhaltet ja mehr als nur die Speicherreservierung und enthält z.B. auch in TObject Daten, die auch im Speicher landen.

Bei der Verwendung hat eine Klasse dann wieder Vorteile bei der Geschwindigkeit, da diese als Referenz verwendet wird, während der Record aus der Liste kopiert wird. Das kannst du aber wie gesagt durch die Verwendung von Pointern auf die Records umgehen, sprich indem du selbst den Speicher reservierst und freigibst, so dass in der Liste nur die Pointer auf die Records liegen.

[himitsu]

Wird aber "oft" die Liste geändert (die hat ja intern auch nur ein TArray<T>),
dann muß da bei Objekten nur eine kurze Liste aus Zeigern umkopiert werden, während es bei den Records die kompletten Daten sind.

Vor allem bei sehr großen Listen und/oder Records kann das negative Auswirkungen haben.

[bernhard_LA]

wenn ich aus Speicherbedarf und Performance Gründen bei Records bleiben möchte bzw. auch muss ...
gibt es keine Option meine Klassse generisch zu lassen (dh. ohne Informationen über die Art der Daten die ich verarbeite) und das Feld FRawData: TArray<T>; mit Daten über eine Klassenfunktion zu befüllen ?

Delphi-Quellcode:

 

TKMeans<T> = class
  private

  private
    FClusteredData: TClusterList<T>;

    FRawData: TArray<T>;

    FNumClusters: Integer;

    FDistanceMetric: TDistanceMetricfunction<T>;

    FCentroidfct: TCentroidfunction<T>;

    FMaxIterations: Integer;

  public
    constructor Create(NumClusters: Integer;
      DistanceMetric: TDistanceMetricfunction<T>;
      Centroidfct: TCentroidfunction<T>; MaxIterations: Integer = 10);

    procedure LoadData(SoureBitMap: TBitmap); overload;

    function FindNewClusterCentroids: Boolean;

    procedure GroupData2NearestCluster;

    procedure SaveData(OutBitMap: TBitmap);
  end;

Der Code um zu Klasse zu verwenden sieht aktuell so aus:

Delphi-Quellcode:

 

 function DistanceMetric(const A, B: TClusterDataREC): Double;
  begin
    Result := Sqrt(Sqr(A.x - B.x) + Sqr(A.y - B.y));
  end;

// Define a centroid function that returns the TClusterData3 object with the average coordinates of all elements in the cluster
  function Centroidfct(const A: TClusterDataREC): Cardinal;
  begin
    Result := Round((A.DrawingColor and $FF) + ((A.DrawingColor shr 8) and $FF)
      + ((A.DrawingColor shr 16) and $FF)) div 3;
  end;



procedure TForm1.CornerButton1Click(Sender: TObject);
var
  MyKMeans: TKMeans<TClusterDataREC>;

begin

  MyKMeans := TKMeans<TClusterDataREC>.Create(5, DistanceMetric,
    Centroidfct, 10);
  try
     ///  hoer kommt dann noch was ...
  finally
    MyKMeans.Free;
  end;
end;

Müsste ich die Loaddata Funktion der Klasse procedure TKMeans<T>.LoadData(SoureBitMap: TBitmap); auch als Parameter an die create Funktion meiner Klasse übergeben ? Wie würdet Ihr dies Implementieren , was ist hier ein besserer Ansatz ?
ach ja , Loaddata kann natürlich wieder von allen möglichen Daten laden müssen ( Bitmaps, csv - Files, Datenbanken, ......)

[TiGü]

Zitat von bernhard_LA:

wenn ich aus Speicherbedarf und Performance Gründen bei Records bleiben möchte bzw. auch muss ...
gibt es keine Option meine Klassse generisch zu lassen (dh. ohne Informationen über die Art der Daten die ich verarbeite) und das Feld FRawData: TArray<T>; mit Daten über eine Klassenfunktion zu befüllen ?

Delphi-Quellcode:

 

TKMeans<T> = class
  private

  private
    FClusteredData: TClusterList<T>;

    FRawData: TArray<T>;

Zum lesen des internen Arrays der Clusterliste (array of T) müsstest du einen direkten Zugriff haben.
Ungefähr sowas wie FClusteredData.List.
Siehe: https://docwiki.embarcadero.com/Libr...ons.TList.List
Man kann darüber auch iterieren und sich den RangeCheck in TList.GetItem sparen.
Auch brauchst du dann wahrscheinlich keine Doppelung mit FRawData.

Zum Bulk befüllen müsste es diverse AddRange-Methoden geben:
https://docwiki.embarcadero.com/Libr...TList.AddRange