Hallo,

Ich habe ein A_Array[i,0] und ein ValueArray[i*4,0] in das die TabWerte aus A_Array + erste neue Werte (min,max,sum.avr) gespeicher werden sollen. (abc := 0)

Folgender Code dazu:

zusammenfalten · markieren

Delphi-Quellcode:

procedure TMomFiles.WerteBerechnen;
var
    temp, Avr, Mini, Maxi : real;
begin
    if Zeile = 0 then //Erste Zeile als Default übernehmen
    begin
      ValueArray[abc, 0] := TabWert;
      ValueArray[abc+1,0] := TabWert;
      ValueArray[abc+2,0] := TabWert;
      ValueArray[abc+3,0] := (temp)/(Zeile+1);
      if abc < (Spaltenanzahl-1)*4 then abc := abc+4;
    end;

    if Zeile <> 0 then
    begin
    //Minimum
      if (TabWert < ValueArray[abc,0]) then
      ValueArray[abc,0] := TabWert;
    //Maximum
      if (TabWert > ValueArray[abc+1,0]) then
      ValueArray[abc+1,0] := TabWert;
    //Mittelwert
      ValueArray[abc+2,0] := (ValueArray[abc+2,0]+TabWert);
      ValueArray[abc+3,0] := ValueArray[abc+2,0]/(Zeile+1);
      if abc < (Spaltenanzahl-1)*4 then abc := abc+4;
    end;
end;

Minimum, Maximum ist klar und Mittelwert an sich auch. Das Problem ist nur, dass er in
ValueArray[abc+2,0] die Summe der entsprechenden Tabwerte speichern soll für die Mittelwertberechnung.
z.B. 1. Durchlauf: TabWert = 2 -> ValueArray[abc+2,0] = 2
2. Durchlauf: TabWert = 5 -> ValueArray[abc+2,0] = 7 usw.
Aber er schreibt immer nur den neuen Wert hinein, ohne die Summe zu bilden. Was läuft da schief?

EDIT : Ich glaube, es liegt an
Setlength(ValueArray,Spaltenanzahl*4,1); //4 Felder pro Spalte (Min,Max,Value,Avr) Ich habe dieses in der Schleife, wo die Spalten durchlaufen werden und dabei wird dann wohl auch immer das Array neu erstellt?!
Aber wo soll ich damit hin? Schließlich weiß ich doch erst an der Stelle, was 'Spaltenanzahl' ist .

Du schreibst das ja auch an verschiedene Stellen des Arrays...

markieren

Delphi-Quellcode:

Zeile 0:
abc = 0 --> abc + 2 = 2
ValueArray[abc+2,0] := TabWert; --> ValueArray[2, 0] := TabWert;
abc := abc + 4 --> abc = 4

Zeile 1:
abc = 4 --> abc + 2 = 6
ValueArray[abc+2,0] := TabWert; --> ValueArray[6, 0] := ValueArray[6, 0] + TabWert;

Du schreibst also den ersten Wert in ValueArray[2, 0], danach dann schreibst du in ValueArray[6, 0] die Summe von ValueArray[6, 0] und Tabwert, greifst also auf den vorherigen Wert gar nicht zu. Was sollte also auch anderes passieren...

[edit=mkinzler]Code-Tag durch Delphi-Tag ersetzt Mfg, mkinzler[/edit]

Nee, bei jeder neuen Zeile wird abc=0 gesetzt.

zusammenfalten · markieren

Delphi-Quellcode:

z := Zeilenanzahl-1;
            abc := 0;
            begin;
              for s := 0 to Spaltenanzahl-2 do
              begin
                StringArray[s,z] := ZwSpeicher.Strings[s+2];
                Spalte := s;
                Zeile := z;
                TabWert := (StrToFloat(StringArray[s,z]));
                SetLength(ValueArray,Spaltenanzahl*4,1); // 4 Felder pro Spalte (Min, MAx, Sum, Avr)
                WerteBerechnen;
                Temp := (StringArray[s,z]) + ';';
                TestDatei.Write(PChar(Temp)^,Length(Temp));
              end;
             StringArray[Spaltenanzahl-1,z] := ZwSpeicher.Strings[ZwSpeicher.Count-1];
             Spalte := Spaltenanzahl-1;
             Zeile := z;
             TabWert := (StrToFloat(StringArray[Spaltenanzahl-1,z]));
             WerteBerechnen;
             Temp := (StringArray[Spaltenanzahl-1,z]) + #13#10;
             TestDatei.Write(PChar(Temp)^,Length(Temp));
            end;

Und was hat es dann für einen Sinn abc in WerteBerechnen zu erhöhen, wenn das ohnehin immer wieder zurückgesetzt wird?

Und was hat dann abc als globale Variable dort zu suchen? Dann gibt es dafür schließlich Parameter...
Dann kannst du tausendmal einfacher abc direkt an WerteBerechnen übergeben...

Kann es sein, dass einmal eine Zeile leer ist bzw. es einen Zugriffsfehler gibt? Weil du vielleicht drauf zugreifst, wenn gerade die neue Zeile geschrieben wird...

Und ansonsten: wie gesagt, debuggen, das kann dir niemand abnehmen ohne das Projekt zu haben...
Und nur an einem Teil des Quelltextes sieht man eben nicht viel, wenn der so unübersichtlich mit globalen Variablen usw, geschrieben ist.

Zitat:

Und was hat es dann für einen Sinn abc in WerteBerechnen zu erhöhen, wenn das ohnehin immer wieder zurückgesetzt wird?

abc wird ja nur für jede neue Zeile zurückgesetzt. Erhöht wird es aber für jede Spalte. Also der erste Tabwert kommt in die Felder [0,0] - [3,0], der 2. in die Felder [4,0] - [7,0] usw.

Zitat:

Kann es sein, dass einmal eine Zeile leer ist bzw. es einen Zugriffsfehler gibt? Weil du vielleicht drauf zugreifst, wenn gerade die neue Zeile geschrieben wird...

Ist mir nicht bewusst, wo meinst du denn?

Warum glaubst du sagen dir alle, du sollst Ein- und Ausgaben als Parameter/Rückgabewerte deklarieren und mit lokalen arbeiten?
Weil dein Code sonst unverständlich und nicht wartbar ist.
Niemand liest so was gern und Fehlersuche kannst du vergessen.

Du möchtest die Summe für einen bestimmten Bereich?
Dann schreib eine Funktion die genau das macht und nichts anderes:

zusammenfalten · markieren

Delphi-Quellcode:

function TMomFiles.BerechneSumme(const ARect: TRect): Double;
var
  x, y: Integer;
begin
  Result := 0;
  for y := ARect.Top to ARect.Bottom do
    for x := ARect.Left to ARect.Right do
      Result := Result + ValueArray[x, y];
end;

function TMomFiles.BerechneMinimum(const ARect: TRect): Double;
var
  x, y: Integer;
begin
  Result := ValueArray[ARect.Left, ARect.Top];
  for y := ARect.Top to ARect.Bottom do
    for x := ARect.Left to ARect.Right do
      if ValueArray[x, y] < Result then
        Result := ValueArray[x, y];
end;

Für die spezielle Auswertung kannst du dann die Unterfunktionen benutzen.

zusammenfalten · markieren

Delphi-Quellcode:

procedure TMomFiles.Auswertung(const ARect: TRect);
var
  lRect: TRect;
  x: Integer;
begin
  lRect.Top := ARect.Top
  lRect.Bottom := ARect.Bottom;

  for x := ARect.Left to ARect.Right do
  begin
    lRect.Left := x;
    lRect.Right := x;
    ValueArray[x, ARect.Bottom + 1] := BerechneSumm(lRect);
    ValueArray[x, ARect.Bottom + 2] := BerechneMinimum(lRect);
    {...}
  end;
end;