Verschachtelte Schleifen - Gesamtfortschritt

[Luckie]

Ich habe zwei verschachtelte Schleife:

Delphi-Quellcode:

for i := 0 to x do
begin
  while j < y do
  begin
    // hier Gesamtfortschritt ermitteln
  end;
end

Wie ermittele ich jetzt in der inneren Schleife den Gesamtfortschritt? Ich stehe da irgendwie auf dem Schlauch. :?

[sirius]

i*y+j
wenn j bei 0 anfängt

[mkinzler]

Wie meinst du das? Wie wird j erhöht?

[Luckie]

j wird immer um eins inkrementiert. Und ich sehe, da gibt es noch eine kleine Hürde, vor der while-Schleife wird die Zählvariable der while-Schleife immer auf null gesetzt:

Delphi-Quellcode:

for i := 0 to x do
begin
  j := 0;  // <-- !!!
  while j < y do
  begin
    j_total := j_total + j
    // hier Gesamtfortschritt ermitteln
  end;
end

Ich denke, da bräuchte ich eine Hilfsvariable: j_total := j_total + j oder so was.

@sirius: Ich bräuchte es in Prozent. :oops:

[sirius]

Naja, dann noch durch y*(x+1) teilen. Aber warum nimmst du eine While-Schleife? Kann es sein, das y hin und wieder schwankt oder j nicht bei 0 anfängt?

Edit: Teil 2 hat sich grad geändert :mrgreen:

[Desmulator]

( i*y+j ) / ( x*y ) * 100 = Prozent
Position Maximum

[Luckie]

Richtig sähe es so aus:

Delphi-Quellcode:

PosTotal := 0;
    for Pass := 0 to FOverWriteCount do
    begin
      // Schreibpuffer füllen
      for i := 0 to Length(Buffer) div SizeOf(TTrippleByte) - 1 do
        if (Pass < Low(Mask)) or (Pass > High(Mask)) then
        begin
          Buffer[i * SizeOf(TTrippleByte)] := Random(256);
          Buffer[i * SizeOf(TTrippleByte) + 1] := Random(256);
          Buffer[i * SizeOf(TTrippleByte) + 1] := Random(256);
        end
        else
          PTrippleByte(@Buffer[i * SizeOf(TTrippleByte)])^ := Mask[Pass];

      // Datei überschreiben
      SetFilePointer(H, 0, nil, FILE_BEGIN);
      Pos := 0;
      while Pos < Sectors do
      begin
        PosTotal := PosTotal + Pos;  // MP
        SendMessage(Parent, FCM_DELFILE_PROG, Trunc((Pass* (Sectors+PosTotal)) / (FOverWriteCount * Sectors) * 100), 0);
        i := Min(Sectors - Pos, Length(Buffer) div Integer(SectorSize));
        if not WriteFile(H, Buffer[0], i * SectorSize, W, nil)
          or (Integer(W) <> i * SectorSize) then
          Exit;
        Inc(Pos, i);
      end;
    end;

Damit wird eine Datei sicher gelöscht durch mehrmaliges Überschreiben mit bestimmten Bitmustern.

[sirius]

Du tust übrgiens FOverwritecount+1 mal die Datei überschreiben.
Und du durchläufst die Whileschleife in i-Schritten, wobei i anfangs konstant bei "length(buffer) div Sectorsize" und im letzten Durchgang meist auf Sectors-Pos fällt.

Damit hat die while-Schleife immer Sectors/(length(buffer) div Sectorsize) Druchläufe (evtl. einen mehr) und die For-Schleife hat FWriteCount+1 Druchläufe. Die musst du nur multiplizieren.

[Luckie]

Ich werde noch mal wahnsinnig:

Delphi-Quellcode:

    PosTotal := 0;
    for Pass := 0 to FPassCount - 1 do
    begin
      if Assigned(OnShredderPass) then
        OnShredderPass(self, Pass + 1, FPassCount);
      // Schreibpuffer füllen
      for i := 0 to Length(Buffer) div SizeOf(TTrippleByte) - 1 do
        if (Pass < Low(Mask)) or (Pass > High(Mask)) then
        begin
          Buffer[i * SizeOf(TTrippleByte)] := Random(256);
          Buffer[i * SizeOf(TTrippleByte) + 1] := Random(256);
          Buffer[i * SizeOf(TTrippleByte) + 1] := Random(256);
        end
        else
          PTrippleByte(@Buffer[i * SizeOf(TTrippleByte)])^ := Mask[Pass];

      // Datei überschreiben
      SetFilePointer(H, 0, nil, FILE_BEGIN);
      Pos := 0;
      while Pos < Sectors do
      begin
        i := Min(Sectors - Pos, Length(Buffer) div Integer(SectorSize));
        if not WriteFile(H, Buffer[0], i * SectorSize, W, nil)
          or (Integer(W) <> i * SectorSize) then
          Exit;
        Inc(Pos, i);

        if Assigned(OnShredderProgress) then
        begin
          PosTotal := PosTotal + Pos; // MP
          p := ((PosTotal / Sectorsize) / (FPassCount * Sectors/(length(buffer)) / Sectorsize) * 100); // !!!
          OnShredderProgress(self, Trunc(p));
        end;
      end;
    end;

Das liefert mindestens um den Faktor 1.000 zu hohe Werte. :wall:

[pszopp]

Zitat:

Zitat von Desmulator

( i*y+j ) / ( x*y ) * 100 = Prozent
Position Maximum

Ich komme auf

(i*y+j) / ((x+1)*y) * 100 = Prozent

[Luckie]

Ich glaube meine Vereinfachung zu Anfang war nicht ganz korrekt, siehe meine folge Postings.

[sirius]

Delphi-Quellcode:

SchritteGesamt:=Sectors div (Length(Buffer) div SectorSize) * FPassCount ;

SchritteAktuell:=Pos div (Length(Buffer) div SectorSize) +
                  Sectors div (Length(Buffer) div SectorSize) * Pass;
Prozent:=trunc((SchritteAktuell/SchritteGesamt) *100);

Funktioniert zumindest in meinem Beispiel:

Delphi-Quellcode:

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ComCtrls, MAth, CommCtrl;

type
  TForm1 = class(TForm)
    ProgressBar1: TProgressBar;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure getmsg(var msg:TMessage);message WM_User;
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

type PContent=^TContent;
     Tcontent=record
       ProgressWnd:hwnd;
       FormWnd:hwnd;
       Sectors:integer;
       SectorSize:integer;
       FPassCount:integer;
       LengthBuffer:integer;
     end;

function test(aParam:PContent):integer;
var i,Pos,Pass:integer;
    Param:TContent;
    Prozent:integer;
    SchritteGesamt,
     Schritte:integer;
begin
  Param:=aParam^;
  dispose(aParam);
  try
    for Pass:=0 to param.FPassCount-1 do
    begin
      Pos:=0;
      while Pos < param.Sectors do
      begin
        i:=Min(param.Sectors - Pos, param.LengthBuffer div param.SectorSize);
        inc(Pos,i);


        SchritteGesamt:=param.Sectors div (param.LengthBuffer div param.SectorSize) * Param.FPassCount ;
        Schritte:=pos div (param.LengthBuffer div param.SectorSize) +
                  param.Sectors div (param.LengthBuffer div param.SectorSize)*Pass;
        Prozent:=trunc((Schritte/SchritteGesamt) *100);

        postmessage(param.ProgressWnd,PBM_SETPOS, Prozent, 0);
        sleep(200);
      end;
    end;
  finally
    postmessage(param.ProgressWnd,PBM_SETPOS, 0, 0);
    postmessage(param.FormWnd,WM_User,0,0);
  end;
end;



procedure TForm1.Button1Click(Sender: TObject);
var temp:cardinal;
    Param:PContent;
begin
  new(Param);
  PAram.ProgressWnd:=progressbar1.Handle;
  Param.FormWnd:=self.handle;
  Param.Sectors:=20;
  Param.SectorSize:=100;
  Param.FPassCount:=4;
  Param.LengthBuffer:=300;
  BeginThread(nil,0,@test,param,0,temp);
  Button1.Enabled:=false;
end;
procedure Tform1.getmsg(var msg:TMessage);
begin
  Button1.Enabled:=true;
end;

end.

[Xong]

Zitat:

Zitat von sirius

Delphi-Quellcode:

SchritteGesamt:=Sectors div (Length(Buffer) div SectorSize) * FPassCount ;

SchritteAktuell:=Pos div (Length(Buffer) div SectorSize) +
                  Sectors div (Length(Buffer) div SectorSize) * Pass;
Prozent:=trunc((SchritteAktuell/SchritteGesamt) *100);

Kann man aber noch vereinfachen:

Delphi-Quellcode:

SchritteGesamt:=Sectors * SectorSize * FPassCount div Length(Buffer);

SchritteAktuell := (SectorSize div Length(Buffer)) * (Pos + Pass*Sectors);

Prozent:=trunc((SchritteAktuell/SchritteGesamt) *100);

Ich hoffe, da ist jetzt kein Fehler drin. :stupid:

[Luckie]

:firejump: So klappt es. :P Danke noch mal an alle.