Vergleich der floating-point-0

Wenn foo ist von Typ float, wird der folgende Ausdruck gültig ist/empfohlen wird?

(0.0f == foo * float(0))

Wird es voraussichtlich (mathematischen) Wert unabhängig von foo, die den Wert?

Funktioniert die C++ - standard definiert das Verhalten oder ist es die Umsetzung konkret?

Versuchen Sie, um zu Debuggen.
Mehr interessiert, wenn es eine Garantie standard
Das ist nicht gonna Arbeit.
Angenommen foo ist eine Zahl (Hinweis: Schwimmer ermöglichen, NaN und infinity). Nicht sicher, ob unendlich * 0 ist 0 in die mathematischen Sinn: 5/0 = 5/0 => 5/0*0 = 5?
Mathematisch gesehen, unendlich*0 ist nicht definiert. In IEEE-Arithmetik, es ist NaN.

InformationsquelleAutor CsTamas | 2010-10-12

  1. 3

    Nun, zunächst einmal, es ist nicht wirklich eine Angelegenheit der C++ - standard. Eher was ist Ihre floating-point-Modell standard (wahrscheinlich IEEE).

    Für IEEE-floats, das ist wohl sicher, wie float(0) sollten Sie die gleiche Zahl wie 0.0 f, und das multipliziert mit jeder anderen Zahl sollte auch sein, 0.0 f.

    Was nicht wirklich sicher ist, machen die anderen Gleitkomma-ops (z.B.: addiert und subtrahiert mit nicht ganzen zahlen), und überprüfen Sie Sie gegen 0.0 f.

    Multiplizieren jede endliche IEEE-Wert von null geben wird, null. Wenn foo ist unendlich oder NaN zurück, dann die Multiplikation Ergebnis ist NaN, und das Ergebnis des Vergleichs false.
    Seymour - Guter Punkt. Vielleicht, dass die Linie war gemeint, überprüfen Sie, dass foo für einen gültigen float-Wert.

    InformationsquelleAutor T.E.D.

  2. 2

    NaNs und Unendlichkeiten Schraube, solche Vergleiche, wie andere bereits erwähnt haben.

    Allerdings gibt es eine weitere Falle: in C++ kann man sich nicht auf einen compile-Zeit-Ausdruck der float-Typ-Vergleich gleich dem Ausdruck, der zur Laufzeit ausgewertet.

    Der Grund dafür ist, dass C++ ermöglicht eine erweiterte Präzision für fp-Berechnungen, in der alle, wohl oder übel Weg. Beispiel:

    #include <iostream>

//This provides sufficent obfuscation so that g++ doesn't just inline results.
bool obfuscatedTrue() { return true; }

int main()
{
    using namespace std;

    double const    a   = (obfuscatedTrue()? 3.0 : 0.3);
    double const    b   = (obfuscatedTrue()? 7.0 : 0.7);
    double const    c   = a/b;

    cout << (c == a/b? "OK." : "\"Wrong\" comparision result.") << endl;
}

    Ergebnisse mit einem speziellen compiler:

    C:\test> g++ --version | find "++"
g++ (TDM-2 mingw32) 4.4.1

C:\test> g++ fp_comparision_problem.cpp & a
"Wrong" comparision result.

C:\test> g++ -O fp_comparision_problem.cpp & a
OK.

C:\test> _

    Cheers & hth.,

    – Alf

    Was höhere Präzision haben Sie Angst, dass das Ergebnis foo * float(0) anders sein kann, das Ergebnis der Multiplikation geschieht mit der Präzision der Typ?
    Gibt es irgendeine Nützlichkeit zu ermöglichen Compiler zu produzieren, die Ergebnisse andere als die, welche erzeugt werden würde, die durch die Nötigung die Operanden der Vergleichsoperatoren Ihre compile-Zeit-Typen (z.B. der Möglichkeit someFloat == otherFloat / 3.0f bewertet werden, als wäre es (double)someFloat == (double)otherFloat / 3.0)? Es scheint mir, dass in der überwiegenden Mehrzahl der Fälle, wo die letztere ist "schneller", es würde auch die Ausbeute nutzlose Ergebnisse.
    die asnwer enthält eine vollständige exqample, mit Ausgabe. und so ist die Idee, dass dies etwas ist, dass ich "Angst" , "könnte" passieren, wird angezeigt, um anzugeben, dass Sie nicht die Antwort Lesen. daher schlage ich vor, dass Sie tun.
    Ich weiß nur von einem Weg, ist es nützlich, nämlich für eine Architektur, in der floating-point-Operationen berechnet werden, die asynchron und mit höherer Präzision als die Plattform, die gemeinsame double geben. Das klingt vielleicht esoterisch, aber es ist wie mit normalen PCs funktionieren. Sie waren ursprünglich auf einem trio von "co-Prozessoren": der 8086 Prozessor, oder seine 8088 Inkarnation mit 8-bit-Multiplex-bus; die 8087 "math"-co-Prozessor, die sich asynchron mit floating-point-Operationen; und das 8089 "i/o"-co-Prozessor, welcher AFAIK nie verwendet wurden. Die physische Verpackung hat sich geändert, nicht aber der logische Entwurf.
    Ich jedenfalls erkennen, dass eine solche Freiheit kann den code "schneller"; die ich nicht zu sehen, obwohl, wie der Ausdruck (phaseOfMoon() ? (float)f1 == (float)(f2 / 3.0f) ? (double)f1 == (double)(f2 / 3.0)) werden konnte nützlich für irgendetwas, auch wenn es sein könnte, berechnet als tausend mal so schnell wie (float)f1 == (float)(f2 / 3.0f).

    InformationsquelleAutor Cheers and hth. - Alf

  3. 2

    Ist, soweit ich weiß, wird Es nicht unbedingt, es könnte auch am Ende sehr nahe an 0 ist.

    Ist es im Allgemeinen am besten zu vergleichen, gegen ein epsilon. Ich benutze eine Funktion, wie dies für die Durchführung einer solchen Vergleiche:

    float EpsilonEqual( float a, float b, float epsilon )
{
    return fabsf( a - b ) < epsilon;
}
    Sie haben völlig Recht, seine fabsf 🙂
    IEEE 754 Mandate, -0.0 f == +0.0 f, obwohl die bit-Werte unterschiedlich sind.
    Fair genug. Nicht ablenken von dem Punkt aber. Ich werde den Verweis entfernen, jedoch.

    InformationsquelleAutor Goz

  4. 1

    Mit, dass bestimmte Anweisung, können Sie ziemlich sicher sein, das Ergebnis wird 0 und der Vergleich true - ich glaube nicht, dass der C++ - standard eigentlich vorschreibt, aber keine vernünftige Umsetzung von floating-point-Typen haben 0 wie das funktioniert.

    Jedoch für die meisten anderen Berechnungen, das Ergebnis nicht erwartet werden, genau gleich sein, um ein literal von der mathematisch korrekten Ergebnis:

    Warum nicht meine zahlen, wie 0.1 + 0.2 hinzufügen, bis eine schöne Runde, 0.3,
    stattdessen erhalte ich ein komisches Ergebnis
    0.30000000000000004?

    Weil intern, Computer benutzen, eine
    format (binary floating-point) ,
    nicht exakt eine Zahl darstellen
    wie 0.1, 0.2 oder 0.3 an alle.

    Wenn der code kompiliert wird, oder
    interpretiert, Ihre "0.1" ist bereits
    abgerundet auf die nächste Zahl, in das
    format, die Ergebnisse in einer kleinen
    Rundungsfehler, noch bevor die
    Berechnung passiert.

    Lesen Die Floating-Point-Guide für die ausführlichen Erklärungen und wie zu tun Vergleiche mit den erwarteten Werten richtig.

    InformationsquelleAutor Michael Borgwardt

  5. 0

    Gerade lese ich diesen Artikel in der msdn über die option /fp in VisualStudio
    link-text

    Ausdruck Optimierungen, die
    ungültig für spezielle Werte (NaN,
    +infinity, -infinity, +0, -0), werden nicht zugelassen. Die Optimierungen, x-x =>
    0, x*0 => 0, x-0 => x, x+0 => x und
    0-x => -x sind alle ungültig für verschiedene
    Gründen (siehe IEEE 754 und die C99
    standard).

    Ich vermute, dass der Kommentar hier ist nur bezogen auf die Tatsache, dass x*0 ist NaN, wenn x ist NaN.

    InformationsquelleAutor MarcoH

Schreibe einen Kommentar