Werte aus dynamischen array löschen

[Uwe Raabe]

Zitat:

Zitat von jupiter4065139 (Beitrag 1219213)

Delphi-Quellcode:

            for x:= 0 to bis DO  //bis wird über inputbox gelesen
               Begin
               if arr[stream.position].zeit > 0.1*x  and  arr[stream.position].zeit < 0.2*x then   //die Bedingung sieht eigentlich anders aus, aber so in der art  
                  begin
                     // den Bereich wollte ich jetzt löschen
                        move(arr[stream.position+1], arr[stream.position],  sizeof(arr[0])*(length(arr) -stream.position-1));
                        setlength(arr, length(arr)+1);         
                  end;
              end;

Die echte Bedingung wäre hier aber schon wichtig, da dein Beispiel überhaupt keinen Sinn macht. Welche Werte sollen denn nun genau gelöscht werden. Danach kann man nämlich nur die Strategie für das Löschen festlegen.

[jupiter4065139]

Das mit dem x ist wirklich verwirrend. Ich will einfach einen bestimmten Bereich aus der Zeitreihe entfernen.
D.h. vor den Spannungswerten aus dem Stream soll eine Zeitreihe gesetzt werden (alles innerhalb von stream.position < stream.size)

Delphi-Quellcode:

 time:=time+1/250;

und aus dieser reihe soll der Bereich zwischen

Delphi-Quellcode:

            
               if arr[stream.position].zeit > 0.1  and  arr[stream.position].zeit < 0.2 then   
                 \\löschen
              end;

gelöscht und aufgerückt werden. Natürlich die zugehörigen Spannungswerten aus

Delphi-Quellcode:

arr[stream.position].U

auch.

[jupiter4065139]

Am Besten wäre das ich mir die Daten aus dem Stream in ein dynamisches Array so übergebe, dass das nicht mit fs.position indiziiert ist sondern mit einer Integervariablen. Mit der könnte ich ja dann die einzelnen Zeilen ansprechen. Geht so etwas?

[Jumpy]

Wie wär es denn mit Bauminas Vorschlag, "falsche" Werte gar nicht erst ins Array aufzunehmen?

Delphi-Quellcode:

   while stream.Position < stream.Size do begin
            stream.ReadBuffer(Digit, SizeOf(Digit));
            Spannung:= 10 * digit / 32768;
            time:=time+1/250;

            if not ((time > 0.1*x) and (time < 0.2*x)) then 
              begin
              setlength(arr, High[arr]+2);
              arr[High[arr]].Zeit:=time;
              arr[High[arr]].U:=Spannung;
              end;

[Uwe Raabe]

Ich kann dir leider immer noch nicht ganz folgen, aber trotzdem mal ein Versuch:

Delphi-Quellcode:

    
    StreamSize := Stream.Size;
    SetLength(arr, (StreamSize - Stream.Position) div Sizeof(digit));
    j := 0;
    time := 0;
    while Stream.Position < StreamSize do begin
      Stream.ReadBuffer(digit, SizeOf(digit));
      Spannung := 10 * digit / 32768;
      time := time + 1 / 250;
      inc(j);
      arr[j].Zeit := time;
      arr[j].U := Spannung;
    end;

Das Speichern von Stream.Size in einer lokalen Variablen soll verhindern, daß bei jedem Stream.Size zwei Seek-Anweisungen durchgeführt werden.

Nach der while-Schleife stehen erstmal alle Werte im Array, dessen Größe über Length(arr) abgefragt werden kann (bedenke: der höchste Index ist 1 weniger - alternativ kann man den auch mit High(arr) bekommen).

Wenn du nun einen bestimmten Zeitbereich aus dem Array löschen willst, solltest du ausnutzen, daß die Einträge zeitlich aufeinander folgen. Du musst also nur den Index des ersten und letzten (bzw. den danach) zu löschenden Eintrags finden. Dazu wird das Array einfach durchlaufen:

Delphi-Quellcode:

    idx1 := -1;
    idx2 := -1;
    for I := 0 to Length(arr) - 1 do begin
      if idx1 < 0 then begin
        if arr[I].Zeit > vonZeit then begin
          idx1 := I;
        end;
      end
      else if arr[I].Zeit > bisZeit then begin
        idx2 := I;
        Break;
      end;
    end;
    { idx1 gibt den ersten zu löschenden Eintrag an, idx2 den nach dem letzten zu löschenden }

Jetzt kann der entsprechende Bereich entfernt werden.

Delphi-Quellcode:

    if idx1 >= 0 then begin
      if (idx2 < 0) then begin
        { bis zum Ende löschen }
        SetLength(arr, idx1 - 1);
      end
      else begin
        Move(arr[idx2], arr[idx1], (idx2 - idx1)*Sizeof(arr[0]));
      end;
    end;