![]() |
Single wert ist unterschiedlich obwohl gleich
Versuch 1:
Delphi-Quellcode:
Ich weise diesen wert zu und schicke ihn an meine DLL.
const
SCALE_DEFAULT = 0.68;
Delphi-Quellcode:
gSprFace.GD_SetObjectScale(ID, SCALE_DEFAULT);
In der DLL jedoch kommt dieser wert an "0,68000000715" Wenn ich nun vergleiche
Delphi-Quellcode:
dann wird mir True zurückgegeben logisch der wert aus der DLL ist mehr als 0.68 (Aber er wird zum weg in die DLL verändert) also Falsch!
if (rScale > SCALE_DEFAULT) then
Denn wie man sehen kann habe ich einen anderen übergeben. Versuch 2:
Delphi-Quellcode:
Ich weise nun exakt diesen wert zu (der zur DLL verändert wird) und schicke ihn an meine DLL.
const
SCALE_DEFAULT = 0.68000000715;
Delphi-Quellcode:
gSprFace.GD_SetObjectScale(ID, SCALE_DEFAULT);
In der DLL kommt dieser wert an "0,68000000715" den ich auch übergeben habe. Wenn ich nun vergleiche
Delphi-Quellcode:
if (rScale > SCALE_DEFAULT) then
dann wird mir True zurückgegeben warum wenn beide werte gleich sind ? Zwei Problem treten auf. 1. Schicke ich den ersten wert mit 0.68 dann wird dieser zu 0,68000000715 verändert 2. Schicke ich nun exakt diesen wert zu wird bei der Abfrage ebenfalls true zurück gegeben. Kann ich nicht nachvollziehen. gruss |
AW: Single wert ist unterschiedlich obwohl gleich
Der Wert für 0.68 als Single ist 0.680000007152557373046875. Also ist er in der DLL richtig.
Wie ist rScale deklariert? Der Ausdruck `rScale > SCALE_DEFAULT` wird je nach Compiler als Double oder Extended ausgewertet. Speichere die Differenz mal als Single und schau das Ergbenis an. Wie gesagt: die Auswertung erfolgt mit Double/Extended, hier die Werte für Double
Code:
und für Extended
0.68000000715 -> 0.68000000714999997430965095190913416445255279541015625
0.68 -> 0.68000000000000004884981308350688777863979339599609375
Code:
0.68000000715 -> 0.68000000715000000000524243981558925042918417602777481079102
0.68 -> 0.68000000000000000000650521303491302660404471680521965026855 |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Zitat:
Hatte noch nie so ein Problem. OK habe es selbst herausgefunden. Danke!
Delphi-Quellcode:
Noch nie ein ähnliches Problem gehabt.
const
SCALE_DEFAULT: single = 0.68; gruss |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Delphi-Quellcode:
oder wahrscheinlich besser definiere SCALE_DEFAULT als single
tmpsingle := rScale - SCALE_DEFAULT;
if tmpsingle > 0 then ...
Delphi-Quellcode:
const
SCALE_DEFAULT: single = 0.68; |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Delphi-Quellcode:
gruss
const
SCALE_DEFAULT: single = 0.68; |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
|
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Danke trotzdem. Die kleine Abfrage hat bei mir 35% CPU Auslastung verursacht weil es immer true war. gruss |
AW: Single wert ist unterschiedlich obwohl gleich
Wenn das an einer Stelle wichtig ist, würde ich immer zusätzlich zum Vergleich IsZero benutzen um mit einem genügend kleinen Epsilon die Gleichheit auszuschließen.
|
AW: Single wert ist unterschiedlich obwohl gleich
Single = 7-8 signifikante Dezimalstellen, also im Wost-Case nur 7.
Die erste Signifikante ist von links die erste Nicht-Null. 0.68000000715 Selbst Schuld, wenn du einen Wertebereich haben willst, der nichtmals Ansatzweise in den Datentyp passt. Und selbst wenn, dann sind auch innerhalb der Signifikanten Rundungsfehler möglich, vor allem bei gewissen unendlich langen Werten ala 2/3. Single hat einen 8 Bit-Exponent und eine Mantisse von 23 Bit Länge, inkl. einem virtuellen Bit, wenn der Exponent 0 ist, also 24. 2^24 = 16.777.215 = nicht ganz 8 Dezimalstellen (nur 1. bis 7. können alles von 0 bis 9 sein) |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Nun gut wenn du das sagst ist es wohl so. Zitat:
Und wer erstellt diese? Genau! Delphi. Ich habe übergeben 0.68 und Delphi mach daraus deinen unendlich langen Werten 0.68000000715 lese doch bitte nochmal was ich geschrieben habe. Zitat:
Wie gesagt.. Ich habe 0.68 übergeben und erwarte eigentlich das dieser wert auch berechnet wird. gruss |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Zitat:
Wenn der Exponent 0 ist hat man subnormale Zahlen, und im Gegensatz zu Deiner Behauptung wird das signifikante Bit in dieser Situation gerade nicht versteckt! Normalisierte Zahlen haben immer eine 24-Bit Mantisse bzw. Signifikand (falls Du Deine Info vom deutschen Wikipedia schau mal ins englische oder in den Standard IEEE754_2008 Tabelle 3.2). |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Was ich nicht verstehe.. Warum hier der Compiler von Delphi wieder eine Extrawurst kreiert (Double oder Extended) Definiere ich in C++ die gleiche Const dann gibt es so was nicht. gruss |
AW: Single wert ist unterschiedlich obwohl gleich
Für Gleitkomma-Datentypen verwende ich mittlerweile (fast) immer Funktionen aus der Unit System.Math
IsZero oder Samevalue oder compareValue ist da dein Freund. |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Delphi-32-Bit rechnet intern mit extended. Delphi-64-Bit via SSE immer als double. |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Bleibt unverständlich für mich. Zitat:
Ich habe schon Anwendungen in Sharp, VBNet, Vb6, C++ geschrieben Nirgendwo habe ich je solche Probleme mit Single gehabt. gruss |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Delphi-Quellcode:
{$apptype console}
uses Math; const g: single = 6.67e-11; h: extended = 6.63e-34; begin writeln(iszero(g)); writeln(iszero(h)); writeln(sinh(1e-20)); writeln(sin(1e-20)); end.
Code:
Man kann iszero etc richtig verwenden, aber dann kann man auch gleich seine Kenntnisse in die richtige Formulierung stecken. (Wer weiß schon auswendig, welche Default-Toleranz benutzt wird?)
TRUE
TRUE 0.00000000000000E+0000 1.00000000000000E-0020 |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Je feiner der typ auflöst, also je größer er ist, um so kleiner werden die Problembereiche und so schwerer wird es sie zu treffen. Beim Unwandeln dieser Werte in eine Textdarstellung sollte man niemals mehr als die signifikanten Stellen umwandeln, da alles danach quasi "zufällig" ist und diesen Rundungsfehler potenziert darstellt, je weiter man dahinter schaut. Bei Vergleichen, vor allem Gleich, Kleiner-Gleich und Größer-Gleich, aber auch bei Kleiner und Größer muss man eben auch diese Rundungsfehler mit einbeziehen, was eben IsZero oder CompareValue machen (Delta). Wer unbedingt genaue Werte braucht, muss auch die passenden Typen verwenden, wie z.B. Currency, BCD oder Dergleichen. @gammatester: Wer mit solch kleinen Werten arbeitet, muß eben entweder das Delta anpassen oder eine andere Vergleichsmethode verwenden. |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Delphi-Quellcode:
procedure RenderScale(WinHandle: HWND);
var bDone: BOOL; K, ID: Integer; CountMax: Integer; x, x1, y, y1, w, h: Integer; nScale: Integer; begin bDone := false; CountMax := FaceList.Count - 1; ID := ID_FACE; for K := 0 to CountMax - 1 do begin if (ID <> gnFocusID) then begin rScale := gSprFace.GD_GetObjectScale(ID); if (ID = nHoverID) then begin if (rScale < 1.0) then begin bDone := true; // Wird hier true geschaltet und bleibt True wenn Single wert nicht stimmt. rScale := rScale + SCALE_STEP; if (rScale > 1.0) then begin rScale := 1.0; bDone := false; end; // Flare Animation gSprFace.GD_GetObjectBound(ID, w, h); nScale := (w - round(w * rScale)) div 2; gSprFace.GD_SetObjectVisibility(gnFocusFlare, true); gSprFace.GD_GetObjectXY(ID, x, y); x1 := x + 63 - nScale; y1 := nScale + 10; gSprFace.GD_SetObjectXY(gnFocusFlare, x1, y1); // Weiter mit ID gSprFace.GD_SetObjectScale(ID, rScale); end; end else begin if (rScale > SCALE_DEFAULT) then // stimmt dieser wert nicht dann ist bDone immer true und löst ein Repaint des gesamten Container aus. begin bDone := true; rScale := rScale - SCALE_STEP; if (rScale < SCALE_DEFAULT) then begin rScale := SCALE_DEFAULT; gSprFace.GD_SetObjectVisibility(gnFocusFlare, false); bDone := false; end; gSprFace.GD_SetObjectScale(ID, rScale); end; end; end; dec(ID); end; if (bDone) then gSprFace.GI_UpdateWindow(WinHandle, false); // Hier Problem wenn Single wert nicht stimmt = 35% CPU Auslastung. end; Zitat:
Wie der Compiler das innerhalb berechnet kann mir letztendlich egal sein. Die dort verwendeten Compiler scheinen es richtig zu verstehen, Delphi hingegen nicht! (Extra Wurst halt) ;) gruss |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Im übrigen ist 1e-20 geradezu erschreckend groß im Vergleich zu 1e-300 oder 1e-4000. |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Was zählt ist das ich eine Lösung wenn auch eine für mich unverständliche gefunden habe. Ich bin nicht der Informatiker so wie ihr von daher zählt für mich das Ergebnis nicht das was dahinter steckt. @gammatester Danke nochmal für deine Hilfe und den Anstoß die Lösung zu finden. PS: Interessant ist es aber trotzdem zu lesen. gruss |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Und ein IsZero(Value1) oder SameValue(Value1,Value2) ist m.E. besser zu lesen als jede hingeklatsche Berechnung, die ein Epsilon berücksichtigt. Oder gib mal ein Beispiel, wie du zwei Gleitkommazahlen vergleichst. Man lernt ja nie aus. |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Zitat:
Zitat:
Leider ist es so, daß es keine Patentlösung gibt, und es nicht hilft, Schulbuchformeln zusammenzustellen und manchmal ein iszero etc einzufügen. Hier das schon genannte Beispiel aus Math
Delphi-Quellcode:
Richtiger wäre, if IsZero(X) then Result := x, weil ja für kleine x die Maclaurinreihe für sinh(x) = x +x^3/6 + ... ist. Damit verschenkt man allerdings viel, da iszero hier mit 1e-16 arbeitet. Viel besser und lesbarer ist if abs(x) < 1e-9 then Result := x.
function Sinh(const X: Extended): Extended;
begin if IsZero(X) then Result := 0 else Result := (Exp(X) - Exp(-X)) / 2; end; Auch der Rest ist Katastrophe. Warum soll man Exp zweimal aufrufen? Vielleicht um noch ein paar Rundungsfehler mehr zu machen? Entweder ist x so groß, daß exp(-x) vernachlässigbar ist, oder man benutzt exp(-x) = 1/exp(x). Ganz abgesehen davon, daß diese Schulbuchformel instabil ist da anfällig für katastrophale Auslöschung (sie liefert zB 0.999999996004197E-12 statt 1E-12 für sinh(1e-12)). |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Diese Schreibweise ist natürlich schöner. Bei Integer kein Problem. Aber nicht bei Gleitkommazahlen. |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Zum Vergleich auf 0. Hier ist doch überhaupt kein Problem beim direkten Vergleich, wobei iszero für kleine Werte fehlerhaft ist. Ich kann mich an keine Rechnung errinnern, wo 'zufällig' 0 herrauskommt, normalerweise hat man dann einen Fehler gemacht. Das Problem ist eher andersherum, bei machen Rechnungem würde man 0 erwarten, aber es komment nicht, wie zB 1-10*(1/10) oder cos(Pi/2). Im übrigen will ich Dich von Deiner festgefaßten Meinung nicht abbringen, und sehe die Sache hier als erledigt an. |
AW: Single wert ist unterschiedlich obwohl gleich
|
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Es gibt auch viele die mitlesen. Und wenn du schreibst, dass das direkte Vergleichen zweier Gleitkommazahlen kein Problem ist, dann führst du diese Leute auf's Glatteis. Beispiel:
Delphi-Quellcode:
Hier gibt der direkte Vergleich der Zahlen ein "False"
var
value1: double; value2: double; begin value1 := 1.23; value2 := 1.23; writeln(value1); // 1.23000000000000E+0000 -> Debugger zeigt 1.23 an writeln(value2); // 1.23000000000000E+0000 -> Debugger zeigt 1.23 an writeln(value1 = value2); // True value1 := sqrt(value1); writeln(value1); // 1.11905365064094E+0000 value1 := Sqr(value1); writeln(value1); // 1.23000000000000E+0000 -> Debugger zeigt 1.23 an writeln(value1 = value2); // False -> Aber der Debuger zeigt für Value1 und Value2 den Wert 1.23 an. Suchst du dir halt den Wolf ;-) writeln(samevalue(value1 , value2)); //True value1 := value1-value2; writeln(value1); -2.22044604925031E-0016 // Erst hier fällt auf, dass es einen minimalen (ab der 16. Kommastelle) Unterschied gibt writeln(value1 = 0); // False writeln(IsZero(value1)); // True readln; end. Anderes Beispiel:
Delphi-Quellcode:
Hier gibt der direkte Vergleich "True"
var
value1: double; value2: double; begin value1 := 4; value2 := 4; writeln(value1); // 4.00000000000000E+0000 writeln(value2); // 4.00000000000000E+0000 writeln(value1 = value2); // True value1 := sqrt(value1); writeln(value1); // 2.00000000000000E+0000 value1 := Sqr(value1); writeln(value1); // 4.00000000000000E+0000 writeln(value1 = value2); // True writeln(samevalue(value1 , value2)); //True value1 := value1-value2; writeln(value1); // 0.00000000000000E+0000 writeln(value1 = 0); // True writeln(IsZero(value1)); // True readln; end. Für mich ein inkonsistentes Verhalten, was aber logisch ist wenn man die Internas berücksichtigt. Dennoch ist dieses Verhalten meist nicht gewünscht und mit "SameValue" kann man dies durch berücksichtigen des Epsilon umgehen |
AW: Single wert ist unterschiedlich obwohl gleich
@Luckie
Danke! Ich wusste noch so ungefähr, dass es da so ein Problem gab. Gut, das mal aufzufrischen. |
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Ich will niemanden auf Glatteis führen, und jeder mag iszero/samevalue benutzen. Nur bitte: der direkte Vergleich kann gar kein Problem sein, weil iszero/samevalue genau solche macht:
Delphi-Quellcode:
Wie man sieht, zwei direkte Vergleiche. Ich sage nur, daß jeder das auch flexibler und angemessener direkt machen kann.
if Epsilon = 0 then
Epsilon := ExtendedResolution; Result := Abs(A) <= Epsilon; Zu Deinem Bespiel sqr(sqrt(2)) <> 2 und Luckies 69.82 <> 69.2 + 0.62. Das Problem ist wieder einmal die nicht exakte Darstellbarkeit, hier von sqrt(2) und allen Luckischen Zahlen (und ein C-Compiler-Problem?) Was man sich merken sollte.
Code:
Addiert man nun die beide exakten Singles, so erhält man 69.1999969482421875 + 0.62000000476837158203125 = 69.81999695301055908203125. Das wird nun zum nächsten Single gerundet und ergibt 69.81999969482421875 was genau dem Single-Wert von 69.82 entspricht.
69.2 -> 69.1999969482421875
0.62 -> 0.62000000476837158203125 69.82 -> 69.81999969482421875 Ich weiß, zwar nicht was für einen C-Compiler er benutzt hat, aber alle Delphi/Freepascal-Versionen liefern true als Ausgabe von
Delphi-Quellcode:
{$apptype console}
var a,b,c,d: single; begin a := 69.2; b := 0.62; c := a + b; d := 69.82; writeln(c=d); end. Zitat:
|
AW: Single wert ist unterschiedlich obwohl gleich
Sorry, muß mal noch kurz meinen Senf dazugeben. Der Computer rechnet nicht mit reellen Zahlen, sondern mit rationalen Zahlen. Das Problem ist, daß wegen der begrenzten Stellenzahl nur die wenigsten rationalen Zahlen überhaupt darstellbar sind. Wer mit dem Rechner tatsächlich rechnet im traditionellen Sinn, dem sei The Art of Programming, vol. 1 von Knuth dringend ans Herz gelegt. Leider wird das Thema auch während der Ausbildung nur stiefmütterlich behandelt.
|
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Zitat:
Allerdings muß man beachten, daß die Operationen der Rational-Arithmetik dann nicht mehr in konstanter Zeit abgewickelt werden können, sondern mit Zähler- und Nennerlänge ansteigen, auch wenn Bruchwert sich nur wenig ändert, siehe das Summenbeispiel. Zitat:
|
AW: Single wert ist unterschiedlich obwohl gleich
Ich habe den Eindruck hier gibt es viele Lösungen, und jetzt wird krampfhaft nach dem passenden Problem gesucht :stupid:
|
AW: Single wert ist unterschiedlich obwohl gleich
Zitat:
Das hat nichts mit suchen sondern wissen zu tun zumindest was ihn angeht. gruss |
AW: Single wert ist unterschiedlich obwohl gleich
Also wenn ich es bisher richtig verstanden habe ist die Quintessenz:
Zitat:
Gruß K-H |
Alle Zeitangaben in WEZ +1. Es ist jetzt 00:23 Uhr. |
Powered by vBulletin® Copyright ©2000 - 2025, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz