Int64-Variablen im Verhältnis auf Integer-Variablen laden

[Helmi]

Hallo,

ich hab folgende Ausgangssituation:

3 Variablen:

Delphi-Quellcode:

PB_Max     : Int64;
PB_Min     : Integer;
PB_Position: Int64;

Die Variablen "PB_Max" und "PB_Position" können den
kompletten Wertebereich von Int64 verwenden.
Die Variable "PB_Min" ist immer 0;

Nun möcht ich diese Variablen auf eine Progressbar
ausgeben.

Also so:

Delphi-Quellcode:

with Progressbar do
  begin
    Max      := PB_Max;
    Min      := PB_Min;
    Position := PB_Position;
  end;

das das jetzt nicht geht - ist mir klar.

Mein Problem ist, dass die Properties "Max", "Min",
und "Position" der Progressbar Integers sind.

Wie kann ich nun die Int64-Variablen "runterbrechen"
damit ich Integer-Werte bekomme, aber noch im gleichen
Verhältnis wie bei den Int64-Werten.

(Btw.: Früher hatte ich nur Integer-Werte.)

[cruiser]

Wie wäre es PB_Position und PB_Max div high(Integer) oder div MaxInt zu rechnen?

also

Delphi-Quellcode:

with Progressbar do
  begin
    Max      := PB_Max div high(Integer);
    //Min      := PB_Min; << kannsu auch weglassen, wenn es 0 bleibt
    Position := PB_Position div high(Integer);
  end;

[1234588]

ich weiß ja nicht wie es bei der komponente ist, aber ->

http://msdn2.microsoft.com/en-us/library/bb760816(VS.85).aspx

Zitat:

Because the range and current position values are expressed as unsigned integers, the highest possible range or current position value is 65,535

[thkerkmann]

Hi

in SysUtils findet man den

Delphi-Quellcode:

  Int64Rec = packed record
    case Integer of
      0: (Lo, Hi: Cardinal);
      1: (Cardinals: array [0..1] of Cardinal);
      2: (Words: array [0..3] of Word);
      3: (Bytes: array [0..7] of Byte);
  end;

und du könntest dir dann den Hi Cardinal herauspicken für PB_Max und PB_Pos.

Also

Delphi-Quellcode:

  intmax = Int64Rec(PB_max).Cardinals[1];
  intpos = Int64Rec(PB_pos).Cardinals[1];

Dann wird nix gerechnet.

Gruss

[Dax]

Ich schlage vor:

Delphi-Quellcode:

with Progressbar do
  begin
    Max      := 1000;
    Min      := PB_Min;
    Position := Round(PB_Position / PB_Max * 1000);
  end;

Eine Genauigkeit von 0,1% dürfte für GUI-Apps ausreichen :)

[bitsetter]

Zitat:

Zitat von Dax

Eine Genauigkeit von 0,1% dürfte für GUI-Apps ausreichen :)

So wie du die Klammer bei Round() setzt wird es wohl eher total ungenau sein. :stupid:

Nehmen wir mal an

Delphi-Quellcode:

PB_Max:= 8000;
   PB_Position:= 6000;

Zitat:

Zitat von Dax

Delphi-Quellcode:

Position := Round(PB_Position / PB_Max) * 1000

macht Round(0,75) ist gleich 1 * 1000 = 1000 und 750 wäre richtig gewesen.

[Dax]

Zitat:

Zitat von bitsetter

So wie du die Klammer bei Round() setzt wird es wohl eher total ungenau sein. :stupid:

Örk, verklammert :stupid: Wird behoben :)

[Luckie]

Gib den Wert in Prozent an, dann kommst du locker mit Integer aus.

[himitsu]

etwas in Richtung Prozent ist wirklich am einfachsten


z.B. (ohne Gleitkommaoperationen ... da die Dateien wohl meist unter 2 EB (ExaByte) groß sind, also vollkommend ausreichend)

Zitat:

Min := 0;
Max := 1000;

Position := PB_Max * 1000 div PB_Position;

und falls es auf eine Möglichst hohe und schnell errechenbare Genauigkeit hinausgehen soll, dann kann man auch die werte auf den Interger runterskalieren.

Delphi-Quellcode:

PB_Div := PB_Max div High(Integer);
Min := 0;
Max := PB_Max div PB_Div;

Position := PB_Position div PB_Div;

am aller einfachsten wäre es zwar, wenn man nur die oberen 32 Bit ala thkerkmann verwendet, aber da hat man kleine Problemchen bei kleineren Werten (wo nur die unteren 32 Bit belegt sind)