Mehrdimensionales Array an anderes anhängen

[Takeo]

Hallo liebe Community,

ich habe ein Problem mit meinen Arrays. Benutze Delphi XE2.

Und zwar:
Ich habe mehrere csv Dateien von einer Messreihe (wird jede Woche eine neue erstellt). Nun möchte ich mehrere von diesen in ein Array einlesen, damit ich daraus Graphen erstellen kann. Was ich bisher hab ist eine Funktion, die mittels einem Streamreader eine Datei in ein Array schreiben kann, aber halt immer nur eine Datei und nicht mehrere, also müsste ich irgendwie das Array als Art Hilfsarray verwenden und jedesmal an mein großes Array anhängen. In einem anderen Thread hab ich gefunden, dass man mit Move oder Copy ein Array anhängen kann, aber ich weiß nicht, wie ich das mit mehrdimensionalen Arrays mach wegen Setlength und so.

Die Spaltenanzahl bleibt jedes mal ja gleich, aber die länge ja nicht. Geht dann so etwas:

Delphi-Quellcode:

setlength(großesArray, length(großesArray) + length(Hilfsarray), length(Hilfsarray[0]))

?

Und wie kopier ich dann das mehrdimensionale Array in das andere?
Und was passiert, wenn das große Array am Anfang noch leer ist, also gar keine Länge gesetzt ist?

Grüße Takeo

[Medium]

Warum schreibst du nicht gleich in das große Array? Wenn du dessen Länge nach einem Füll-Vorgang nachträglich erhöhst bleiben die Daten von zuvor erhalten.

Bei gewissen Mengen könnte sich hier aber auch schon der Einsatz einer embedded DB lohnen, wie Firebird. Arrays haben den Nachteil, dass sie gerne komplett am Stück im Speicher sein wollen. Große Größen kann Windows aber ggf. wegen der Speicherfragmentierung nicht mehr zusammen hängen liefern, so dass dann eine weitere Vergrößerung potenziell auf den Out of Memory Hammer läuft. Bei einer DB hättest du den ganzen Komfort von Queries und den Funktionen des DBMS, und müsstest zu keinem Zeitpunkt mehr alle Daten gleichzeitig in deinem Programm vorhalten. Würde man das auf eine richtige DB aufweiten, wäre ein dauerhaft verfügbares Langzeitarchiv auch denkbar.

[Takeo]

Ich wollte das Datei einlesen in eine eigene, allgemeingültige Funktion packen, da ich später mehrere Messreihen und somit mehrere "große Arrays" habe. Also wäre es besser ich sag "führe die Funktion aus und hänge das Ergebnis an dieses Array".

Hmm mit DBs hab ich mich bisher noch nicht beschäftigt. Ist das schwierig die einzubinden und würde das dann trotzdem mit nur einer "Exe" funktionieren? Mein Programm muss später relativ mobil sein.

[Perlsau]

Zitat:

Zitat von Takeo (Beitrag 1268721)

Hmm mit DBs hab ich mich bisher noch nicht beschäftigt. Ist das schwierig die einzubinden und würde das dann trotzdem mit nur einer "Exe" funktionieren? Mein Programm muss später relativ mobil sein.

Mit einer Firebird-Embedded-DB ist eine Anwendung mobil. Einzige Voraussetzung: Man muß sie von einem Speichermedium, das RW zuläßt, starten. Mit anderen Worten: von CD oder DVD geht nicht, da das Programm ja in die Datenbank schreiben will, von einem USB-Stick dagegen schon.

Den Umgang mit Datenbanken muß man sich natürlich erst erarbeiten.

[Jumpy]

Die Frage scheint mir auch zu sein, wie du die Daten anschließend brauchst um deine Graphen zu zeichnen und ob du die Daten nachher in irgendweiner Form dauerhaft speichern willst oder ob das nicht wichtig ist, da du ja immer noch die CSVs hast.

Weitere Möglichkeiten wären (z.B. wenn nicht dauerhaft gespeichert werden muss) eine "In-Memory-Table" z.B. mit einem TClientDataset.
Oder erst alle Dateien zusammenpacken (z.B. in einer Stringlist) und dass dann in StreamForm in dein Array schreiben.

[himitsu]

Es gibt noch CDs? :stupid:

Aber in diesem Fall könnte man die DB ja einfach in ein Benutzterverzeichnis kopieren und dort verwenden.
Ist dann zwar nicht mehr portabel, aber "relativ mobil" schon und es startet zumindestens noch.

[Bjoerk]

Du könntest dir auch überlegen eine eigene Liste zu schreiben die die gewünschten Funktionalitäten hat. Die kann ja intern mit deinem Array arbeiten?

Delphi-Quellcode:

  TFloatPoint = record
    X, Y: double;
    procedure Clear;
  end;

  TFloatPoints = class
  private
    FItems: array of TFloatPoint;
    function GetItems(Index: integer): TFloatPoint;
    procedure SetItems(Index: integer; const Value: TFloatPoint);
  public
    function Count: integer;
    function Add(const Value: TFloatPoint): integer;
    procedure Insert(const Index: integer; const Value: TFloatPoint);
    procedure Delete(const Index: integer);
    procedure AddPoints(Value: TFloatPoints);
    procedure Assign(Value: TFloatPoints);
    procedure LoadFromFile(const FileName: string);
    procedure SaveToFile(const FileName: string);
    procedure Draw(const Canvas: TCanvas; const ppMM: double);
    procedure Clear;
    property Items[Index: integer]: TFloatPoint read GetItems write SetItems; default;
    destructor Destroy; override;
  end;

[Takeo]

Zitat:

Zitat von Jumpy (Beitrag 1268727)

Die Frage scheint mir auch zu sein, wie du die Daten anschließend brauchst um deine Graphen zu zeichnen und ob du die Daten nachher in irgendweiner Form dauerhaft speichern willst oder ob das nicht wichtig ist, da du ja immer noch die CSVs hast.

Ich brauch die Daten schon als Art Array, weil ich habe ein anderes Array in dem Informationen über die Daten stehen (weil das Gerät, welches die csvs erstellt nur die Daten reinklatscht und keine Überschriften vergeben kann). In dem anderen Array steht der Name der Datenreihe und eine Indexnummer, mit dieser Indexnummer wollte ich dann die passende Spalte für den Graphen auswählen. Da die erste Spalte immer der Zeitstempel ist kann dann der Graph z.B. aus x-Achse = Spalte 1 und Y-Achse gleich Spalte "Indexnummer" gebastelt werden.

Dauerhaft speichern brauch ich nicht, es reicht wenn man nen Screenshot von dem Graphen macht, die Daten bleiben ja als csv erhalten.

Oder ist auch möglich die csv schon als direkter Ansatz für die Datenreihe zu benutzen?

[Jumpy]

Es ist schon wichtig und noch nicht ganz klar geworden, was denn nun deine Funktion die den Graphen zeichnen soll braucht (ein Array, eine Liste, eine Liste Punkte,...).

Davon jetzt mal ab, kannst du doch deine Einleseroutine nun erheblich beschleunigen, indem du nur die zwei Spalten ausliest/speicherst die du brauchst. Irgendwo in der DP hier hab ich mal eine Klasse gesehen, um CSVs einzulesen, die auch mit Streams gearbeitet hat. Von aussen konnte man dann durch die Zeilen iterieren und sagen: "Gib mir den Wert in Spalte X" usw.
Vielleicht suchst du mal danach.

Edit:
Ich glaube das wars: CSV-Reader

[Takeo]

Ich arbeite mit TeeChart und benötige für einen Graphen 2 Listen mit den Werten von x und y der Punkte.

Diese 2 Listen sollen aber einfach 2 Spalten eines Arrays sein. Das Einlesen der CSV-Dateien läuft bereits und es kommt auch als Array raus, allerdings wie gesagt immer nur von einer Datei.

Jeweils nur die passende Spalte einlesen würde mir auch nicht viel bringen, da der User über eine ChecklistBox Graphen hinzufügen oder entfernen können soll und ich somit sowieso am Besten alle Werte lade.

PS: um nochmal auf das eigentliche Threadthema zu kommen: Kann ich mein großes Array mit Länge "null" definieren, dass bei der "length" Abfrage kein Fehler kommt, sondern anfangs der Wert 0 und dann zur aktuellen Länge immer die Länge des eingelesenen Arrays hinzufügen und dieses dann über Schleifen an das große Array anhängen?

Ich möchte mich jetzt auch nicht lang in embedded DBs einlesen und alles, da ich nicht mehr so viel Zeit habe und ich erstmal eine einfache Lösung haben möchte, die später immernoch optimiert werden kann.

[mkinzler]

TeeChart funktioniert aus direkt mit Datenbanken

[Jumpy]

Length(array) liefert 0 bei einem leeren Array, wo SetLength noch nicht benutzt wurde. Somit geht ungefähr sowas:

Delphi-Quellcode:

OldLength:=Length(MyArray);
SetLength(MyArray,OldLength+ZeilenInCSV);
for i:=0 to ZeilenInCSV-1 do
  MyArray[OldLength+i]:=CSV.Zeile[i].Spalte[3].Value;

[Takeo]

Zitat:

Zitat von mkinzler (Beitrag 1268748)

TeeChart funktioniert aus direkt mit Datenbanken

Ja das hab ich auch gesehen, aber jetzt ist halt die Frage, ob es so einfach ist das als Datenbank zu machen, wenn man bisher noch nie damit gearbeitet hat? Oder gibt es irgendwo ein einfaches Tutorial, welches zeigt, wie man ne Datenbank anlegt, Daten hinzufügt und das ganze noch embedded macht?

Zitat:

Zitat von Jumpy (Beitrag 1268749)

Length(array) liefert 0 bei einem leeren Array, wo SetLength noch nicht benutzt wurde. Somit geht ungefähr sowas:

Delphi-Quellcode:

OldLength:=Length(MyArray);
SetLength(MyArray,OldLength+ZeilenInCSV);
for i:=0 to ZeilenInCSV-1 do
  MyArray[OldLength+i]:=CSV.Zeile[i].Spalte[3].Value;

Ok das ist doch schonmal gut. Und wenn mein Array mehrdimensional ist? Gibt length(MyArray) die Zeilen oder die Spaltenzahl zurück?

[Medium]

Bei Mehrdimensionalen Arrays gibt Length() immer die Länge der aktuellen Dimension im Argument zurück. (Mit Zeilen/Spalten haben Arrays übrigens nichts zu tun, das ist nur deine Interpretation ;))

Delphi-Quellcode:

var
  MyArray: array of array of Integer;
begin
  foo := Length(MyArray); // Länge der 1. Dimension
  foo := Length(MyArray[0]); // Länge der 2. Dimension
end;

Man muss es also so sehen, dass ein zweidimensionales Array im Grunde ein eindimensionales Array von weiteren eindimensionalen Arrays ist. Wenn man alle "sekundären" Arrays gleich lang macht (was man mit SetLength(MyArray, x, y) tut), dann reicht es die Länge eines der Elemente vom primären Array zu erfragen um die Länge aller sekundären zu erhalten.

Man kann aber auch sowas machen:

Delphi-Quellcode:

var
  MyArray: array of array of Integer;
begin
  SetLength(MyArray, 3);
  SetLength(MyArray[0], 2);
  SetLength(MyArray[1], 8);
  SetLength(MyArray[2], 7);
end;

Dann hat man quasi eine Tabelle, bei der jede Spalte eine unterschiedliche Anzahl von Zeilen hat (oder umgekehrt, je nach dem wie man es interpretiert eben). Dann müsste man für jedes primäre Array einzeln die Länge seines jeweiligen sekundären Arrays ermitteln. (In praktischem Einsatz sehe ich sowas aber sehr selten. Aber es wäre möglich!) Und man ist natürlich nicht auf nur 2 Dimensionen beschränkt. Da kann man echt witzige Dinge mit machen.

[Takeo]

Ok dann sind es halt die Dimensionen ;)
Ich ging halt davon aus, dass man ein zweidimensionales Array (was ich ja benötige) wie eine Art Matrix oder, wie du es auch einmal nanntest, Tabelle auffassen kann, da wird ja von Reihen und Spalten gesprochen.

Es wäre also sinnvoll die Anzahl der "Zeilen" (die Zeitwerte) in die 1. Dimension zu legen, also die variable Länge und in die 2. Dimension die Anzahl der "Spalten" (die verschiedenen Messreihen), die nur einmal gesetzt werden muss und beim anhängen immer gleich bleibt?

Delphi-Quellcode:

Hilfsarray := Getfile(Filepath); //fülle das Hilfsarray mit Hilfe einer Funktion, welche ein Array zurückgibt, mit den Werten  der CSV Datei
Oldlength := length(MyArray);
Setlength(MyArray, Oldlength + length(Hilfsarray), length(Hilfsarray[0]));

for i := 0 to length(Hilfsarray)-1 do begin
  for j := 0 to length(Hilfsarray[0])-1 do MyArray[Oldlength + i, j] := Hilfsarray[i,j];
end;

das müsste ja dann gehen, oder? Kann es grad leider nicht testen, da ich meine VM mit Delphi nicht zur Hand habe.

[Dejan Vu]

Noch prüfen, ob die Spaltenanzahlen kompatibel sind, aber ansonsten sollte das so passen.

[Bjoerk]

Mach aus der Getfile besser eine procedure.