Umgang mit Genauigkeitsprobleme in Gleitkommazahlen

Question

ich mich gefragt, ob es einen Weg gibt ein Genauigkeitsproblem zu überwinden, die das Ergebnis meiner Maschine interne Darstellung von Gleitkommazahlen zu sein scheint:

Aus Gründen der das Problem Klarheit wird wie folgt zusammengefasst:

// str is "4.600"; atof(str) is 4.5999999999999996 
double mw = atof(str) 

// The variables used in the columns calculation below are: 
// 
//     mw = 4.5999999999999996 
//     p = 0.2 
//     g = 0.2 
//     h = 1 (integer) 

int columns = (int) ((mw - (h * 11 * p))/((h * 11 * p) + g)) + 1; 

Vor einer ganzen Zahl zu Gießen des Ergebnis der Berechnung ist Spalten geben 1,9999999999999996; so nah und doch so weit vom gewünschten Ergebnis von 2.0 entfernt.

Alle Vorschläge sehr willkommen.

Answer 1

Eine sehr einfache und effektive Art und Weise eine Gleitkommazahl in eine ganze Zahl abzurunden:

int rounded = (int)(f + 0.5); 

Hinweis: das funktioniert nur, wenn f immer positiv ist. (Danke j zufälliger Hacker)

Answer 2

Verwenden Dezimalzahlen: decNumber++

Answer 3

du paper lesen kann zu finden, was Sie suchen.

Sie können den absoluten Wert des Ergebnisses erhalten, wie here gesehen:

x = 0.2; 
y = 0.3; 
equal = (Math.abs(x - y) < 0.000001) 

Answer 4

Wenn Sie es noch nicht gelesen haben, der Titel this paper wirklich korrekt ist. Bitte lesen Sie es, um mehr über die Grundlagen der Gleitkommaarithmetik auf modernen Computern zu erfahren, einige Fallstricke und Erklärungen, warum sie sich so verhalten, wie sie es tun.

Answer 5

Wenn Sie Gleitkommaarithmetik verwenden, ist strikte Gleichheit fast bedeutungslos. Normalerweise möchten Sie mit einer Reihe von akzeptablen Werten vergleichen.

Beachten Sie, dass einige Werte nicht genau wie Fließkomma-Vlues dargestellt werden können.

Siehe What Every Computer Scientist Should Know About Floating-Point Arithmetic und Comparing floating point numbers.

Answer 6

Es gibt kein Accuracy-Problem.

Das Ergebnis (1.9999999999999996) unterschied sich vom mathematischen Ergebnis (2) um 1E-16. Das ist ziemlich genau, wenn man Ihre Eingabe "4.600" berücksichtigt.

Sie haben natürlich ein Rundungsproblem. Die Standardrundung in C++ ist abgeschnitten; Sie wollen etwas ähnliches wie Kips Lösung. Details hängen von Ihrer genauen Domain ab, erwarten Sie round(-x)== - round(x)?

Answer 7

Wenn die Genauigkeit wirklich wichtig ist, sollten Sie die Verwendung von Gleitkommazahlen mit doppelter Genauigkeit anstelle von Fließkommazahlen in Betracht ziehen. Obwohl es von Ihrer Frage scheint, dass Sie bereits sind. Sie haben jedoch weiterhin ein Problem mit der Überprüfung bestimmter Werte. Sie müssen Code entlang der Linien von (vorausgesetzt, Sie Ihren Wert gegen Null-Kontrolle):

if (abs(value) < epsilon) 
{ 
    // Do Stuff 
} 

wo „epsilon“ etwas klein, aber nicht den Wert Null.

Answer 8

Auf Computern sind Fließkommazahlen niemals exakt.Sie sind immer nur eine enge Annäherung. (1e-16 ist in der Nähe.)

Manchmal gibt es versteckte Bits, die Sie nicht sehen. Manchmal gelten Grundregeln der Algebra nicht mehr: a * b! = B * a. Manchmal zeigt ein Vergleich eines Registers mit der Erinnerung diese feinen Unterschiede auf. Oder mit einem mathematischen Coprozessor gegen eine Fließkomma-Laufzeitbibliothek. (Ich habe lange diese waayyy tooo getan.)

C99 definiert: (Look in math.h)

double round(double x); 
float roundf(float x); 
long double roundl(long double x); 

.

Oder Sie können Ihre eigene Rolle:

template<class TYPE> inline int ROUND(const TYPE & x) 
{ return int((x > 0) ? (x + 0.5) : (x - 0.5)); } 

Für Gleitkomma-Äquivalenz, versuchen:

template<class TYPE> inline TYPE ABS(const TYPE & t) 
{ return t>=0 ? t : - t; } 

template<class TYPE> inline bool FLOAT_EQUIVALENT(
    const TYPE & x, const TYPE & y, const TYPE & epsilon) 
{ return ABS(x-y) < epsilon; }