System.Frac / System.Int / Math.SimpleRoundTo - komische Ergebnisse

[Uwe Raabe]

Vermutlich lässt sich 9.0 nicht exakt im erforderlichen Type (Single, Double, Extended) unterbringen und es wird intern als 8.9999xxx dargestellt. Damit wird Trunc(9.0) zu 8 und Frac(9.0) zu 0.9999xxx,was wiederum als 1.0 angezeigt wird.

[Bodenseematze]

Zitat von Incocnito:

Probier mal das Ganze mit dem Datentyp Currency.

Ich dachte ursprünglich, der Typ wäre explizit für Ausgaben monetärer Art, d.h. fest mit zwei Nachkommastellen gedacht - als ich mir das jetzt mal kurz angeschaut habe, habe ich gesehen, dass ich mich irre

Muss ich mir mal genauer anschauen - Danke für den Tipp!

Zitat von Uwe Raabe:

Vermutlich lässt sich 9.0 nicht exakt im erforderlichen Type (Single, Double, Extended) unterbringen und es wird intern als 8.9999xxx dargestellt.

Das könnte natürlich sein - wäre aber für meinen Anwendungsfall natürlich blöd, da das dann die Rundung wieder verfälscht.

Ich glaube langsam wirklich, ich bleibe bei meinem Hack - der funktioniert nämlich ziemlich gut
(ist aber natürlich wg. der Rumkonvertierererei von und nach String ziemlich langsam - spielt bei mir aber keine große Rolle)

[himitsu]

Im Grunde liegt es wohl eher an Rundungsfehlern bei der Verwendung von Fließkommazahlen.

eine 0,9 könnte genau 0,9000000000 sein, aber wenn sich das nicht genau darstellen lässt oder es bei der Berechnung nicht ganz genau rauskommt,
könnte es quasi 0,899999999999 aber auch 0,9000000000001 sein. (vereinfachtes Beispiel, damit man sieht, was ich meine)

Und dann liefert es nachfolgend eben auch andere Werte,
z.B. bei Trunc oder Int(0,899999999999 * 10) eben 8 anstatt 9.

https://de.wikipedia.org/wiki/Gleitkommazahl
https://de.wikipedia.org/wiki/Doppelte_Genauigkeit
https://de.wikipedia.org/wiki/IEEE_754
...




Bei mir geht's und es sind wirklich ganz genau 0,000000. (aber muß eben nicht)

Double und Extended

Code:

type MyFloat = Double;  //Extended;

procedure TForm25.FormCreate(Sender: TObject);
procedure DebugLog(Val: MyFloat);
  begin
    var S := string.Create(' ', SizeOf(Val) * 2);
    BinToHex(@Val, PChar(S), Length(S));  // Val.Bytes[i] for 0..9

    { knallt beim zweiten Durchlauf
    S := S + ' / '  + Val.ToString
           + ' / s' + Val.Sign.ToString
           +   ' e' + Val.Exp.ToString
           +   ' f' + Val.Frac.ToString;
           + ' / e' + Val.Exponent.ToString
           +   ' f' + Val.Fraction.ToString
           +   ' m' + Val.Mantissa.ToString
    }

    S := S + ' / '  + Val.ToString;
    S := S + ' / s' + Val.Sign.ToString;
    S := S +   ' e' + Val.Exp.ToString;
    S := S +   ' f' + Val.Frac.ToString;
    S := S + ' / e' + Val.Exponent.ToString;
    try S := S + ' f' + Val.Fraction.ToString;  except  S := S + ' peng';  end;  // k.A. was es gegen 1/3 hat
    try S := S + ' m' + Val.Mantissa.ToString;  except  S := S + ' peng';  end;

    OutputDebugString(PChar(S));
  end;
var
  Val, Frac, Frac2: MyFloat;
begin
  Val   := 22.649;              DebugLog(Val);    // A01A2FDD24A63640 / 22,649 / s0 e1027 f1871527120149152 / e4 f1,4155625      m6375126747519648
  Val   := Val * 100;           DebugLog(Val);    // CDCCCCCCCCB1A140 / 2264,9 / s0 e1034 f476968144129229 / e11 f1,105908203125 m4980567771499725
  Val   := System.Int(Val);     DebugLog(Val);    // 0000000000B0A140 / 2264   / s0 e1034 f474989023199232 / e11 f1,10546875     m4978588650569728
  Frac  := System.Frac(Val);    DebugLog(Frac);   // 0000000000000000 / 0 / s0 e0 f0 / e0 f0 m0
  Frac2 := Frac * 10.0;         DebugLog(Frac2);  // 0000000000000000 / 0 / s0 e0 f0 / e0 f0 m0
  Frac2 := System.Int(Frac2);   DebugLog(Frac2);  // 0000000000000000 / 0 / s0 e0 f0 / e0 f0 m0
  // auch komisch:
  Frac2 := Frac * 10.0;         DebugLog(Frac2);  // 0000000000000000 / 0 / s0 e0 f0 / e0 f0 m0
  Frac2 := System.Frac(Frac2);  DebugLog(Frac2);  // 0000000000000000 / 0 / s0 e0 f0 / e0 f0 m0

  Val   := 1 / 3;               DebugLog(Val);    // 555555555555D53F / 0,333333333333333 / s0 e1021 f1501199875790165 / e-2 peng peng
  Val   := 1 / 5;               DebugLog(Val);    // 9A9999999999C93F / 0,2               / s0 e1020 f2702159776422298 / e-3 f1,6 m7205759403792794
end;

[freimatz]

Zitat von Bodenseematze:

Das könnte natürlich sein - wäre aber für meinen Anwendungsfall natürlich blöd, da das dann die Rundung wieder verfälscht.

Was wäre denn der Anwendungsfall? Ich kann mir gerade nichts vorstellen wo man nur die Nachkommstellen braucht. Vielleicht kann man den Anwendungsfall auch ganz anders lösen.

[Andreas13]

Zitat von Bodenseematze:

Zitat von Andreas13:

AMath.pas ersetzt komplett Delphi’s System.Math.pas und verbessert zahlreiche Fehler und Unzulänglichkeiten.

Das ist nicht so ganz richtig - es fehlen z.B. CompareValue, SimpleRoundTo und auch der "Typ" TRoundToRange - damit braucht man die System Math-Unit leider immer noch.

Fehlende und von Dir benötige Routinen kannst Du aus System.Math.pas rauskopieren...

Zitat von Bodenseematze:

Außerdem kommt auch bei dieser beim Aufruf

Code:

AMath.Frac( 9.0 )

als Ergebnis

Code:

1.0

Wieso? Ich verstehe das nicht

"Mein" Delphi liefert den korrekten Wert: AMath.Frac(9.0) = 0.00000000000000E+0000

Zitat von Bodenseematze:

Ich habe die Enterprise-Version von Delphi7 - da ist ja der Quellcode dabei, aber ich finde den Code von Frac() dort nicht...
(nur in der von SynopseRTL gepatchten Version - und dort steht "{$IFDEF NEWRTL}" drüber, was erst ab Delphi
2005 definiert ist...)

Frac(..) ist in System.pas deklariert:

Delphi-Quellcode:

function Frac(const X: Extended): Extended;
begin
  Result := X - Int(X);
end;

[Andreas13]

Zitat von Bodenseematze:

val := 22.65;
val := Math.SimpleRoundTo( 22.65, -1 ); // erwartet hätte ich 22.7 als Ergebnis, ich bekomme aber 22.6 - warum???

Das kann ich leider nicht nachvollziehen: Wenn ich aus System.Math.pas SimpleRoundTo(..) direkt in mein Projekt kopiere

Delphi-Quellcode:

function SimpleRoundTo(const AValue: Extended; const ADigit: TRoundToRange = -2): Extended;
var
  LFactor: Extended;
begin
  LFactor := IntPower(10.0, ADigit);
  if AValue < 0 then
    Result := Int((AValue / LFactor) - 0.5) * LFactor
  else
    Result := Int((AValue / LFactor) + 0.5) * LFactor;
end;

erhalte ich in beiden Fällen den exakt gerundeten Wert:

Delphi-Quellcode:

System.Math.SimpleRoundTo(22.65, -1 ) =  2.27000000000000E+0001
SimpleRoundTo(22.65, -1 ) =  2.27000000000000E+0001 // lokale Kopie

[Andreas13]

Versuche mal das obige Beispiel ganz ohne Math.pas mit diesem Code:

Delphi-Quellcode:

function SimpleRoundTo(const AValue: Extended; const ADigit: TRoundToRange = -2): Extended;
var
  LFactor: Extended;
begin
  LFactor := AMath.IntPower(10.0, ADigit);
  if AValue < 0 then
    Result := AMath.Int((AValue / LFactor) - 0.5) * LFactor
  else
    Result := AMath.Int((AValue / LFactor) + 0.5) * LFactor;
end;

[Andreas13]

Es könnte natürlich auch sein, daß bei Dir die Rundungsart des Prozessors verstellt/falsch eingestellt ist. Bitte folgenden Code mal testen:

Delphi-Quellcode:

VAR 
  MyRoundingMode   : TRoundingMode;
  MyRoundingModeStr: String;

...

  MyRoundingMode:= GetRoundMode;

  Case MyRoundingMode Of  
    rmNearest:  MyRoundingModeStr:= 'rmNearest';

    rmUp:       MyRoundingModeStr:= 'rmUp';

    rmDown:     MyRoundingModeStr:= 'rmDown';

    rmTruncate: MyRoundingModeStr:= 'rmTruncate';
  End;

WriteLn('MyRoundingMode = ', MyRoundingModeStr);

Es sollte rmNearest rauskommen! Das sollte eigentlich die Standard-Einstellung sein.
Falls nicht, kanns Du SetRoundMode(rmNearest); verwenden.

[jaenicke]

Bei mir kommen unter Delphi 7 jedenfalls die erwarteten Ergebnisse heraus.

[Bodenseematze]

Zitat von Andreas13:

Es könnte natürlich auch sein, daß bei Dir die Rundungsart des Prozessors verstellt/falsch eingestellt ist.

Du meintest TFPURoundingMode in AMath?

Da kommt bei mir "rmNearest" zurück

Ich bin meinen Code und v.a. meine Logging-Ausgaben nochmal durchgegangen - da war so einiges falsch.
Durch die Ausgaben z.B. mit %f oder %.4f kamen einige bereits gerundete Ergebnisse zurück.
Zudem war an manchen Stellen meine Ausgabe nicht synchron mit der tatsächlichen Berechnung (z.B. * 10 im Wert, im Text aber ohne * 10).

Ich habe das jetzt alles mal korrigiert - der Wert, um den es dann ging war tatsächlich 22.648888888888 -> auf zwei Nachkommastellen dann ein Frac von 0.88888889 * 10 = 8.88888889 und hier ist Int() dann tatsächlich 8.00000

Ich habe allerdings immer noch den Fall, dass (angezeigt) aus Frac(9.0000000000) (1.00000000) wird - aber nur, wenn ich es innerhalb der Berechnung mit einer Variablen ausgebe.
Wenn ich von Hand (als fest kodiert), den Wert 9.00000000 an die Frac-Routinen gebe, kommt korrekt 0.0 raus.
Trotz allem sehr seltsam (0.00000001 oder so als Ergebnis würde ich ja noch verstehen, aber 1.00000000?)

Zitat von Andreas13:

Versuche mal das obige Beispiel ganz ohne Math.pas mit diesem Code:

Der Code funktioniert perfekt - auch in den Fällen, in denen Math.SimpleRoundTo das falsche Ergebnis liefert!

Zitat von jaenicke:

Bei mir kommen unter Delphi 7 jedenfalls die erwarteten Ergebnisse heraus.

Wie oben gesagt, das hängt tatsächlich von den berechneten Werten ab - mit manuellen, hart kodierten Werten kommen bei mir (meistens ) auch die erwarteten Ergebnisse zurück.

Wie dem auch sei - ich bin aktuell ganz zufrieden mit meinen Lösungen und Danke Euch allen für Eure Hilfestellungen!