Die Manipulation und Vergleich von floating-points in java

In Java der Gleitkomma-Arithmetik ist nicht vertreten, genau. Zum Beispiel dieser java-code:

float a = 1.2; 
float b= 3.0;
float c = a * b; 
if(c == 3.6){
    System.out.println("c is 3.6");
} 
else {
    System.out.println("c is not 3.6");
}

Drucke "c ist nicht 3.6".

Ich bin nicht daran interessiert, Präzision jenseits von 3 Dezimalstellen (#.###). Wie kann ich den Umgang mit diesem problem zu vermehren schwimmt und vergleichen Sie zuverlässig?

  • Deklarieren Sie Schwimmer wie: float a = 1.2f; - und Doppelzimmer wie double d = 1.2d; Auch in if-Anweisung: if(c == 3.6f)
  • Als Ergänzung zu @bobah 's Antwort, dem empfehle ich einen Blick auf die Math.ulp() Funktion.
InformationsquelleAutor Praneeth | 2010-05-24
  1. 19

    Es ist eine Allgemeine Regel, dass die floating-point-Zahl sollten nie verglichen werden, wie (a==b), sondern eher wie (Math.abs(a-b) < delta) wo delta ist eine kleine Nummer.

    Eine floating-point-Wert mit festen Anzahl von Ziffern in dezimaler form nicht nötig haben Feste Anzahl von Ziffern in binärer form.

    Zusätzlich für Klarheit:

    Obwohl strenge == Vergleich von floating-point-zahlen hat sehr wenig praktischen Sinn, die strenge < und > Vergleich, im Gegenteil, ist es ein Gültiger Anwendungsfall (Beispiel - Logik-Triggerung, wenn bestimmten Wert überschreitet Schwelle: (val > threshold) && panic();)

    • Empfehle den Vergleich mit einer Toleranz unangebracht Rat, weil es sinkt, falsche Berichte von Ungleichheit auf Kosten der Erhöhung falschen Berichte der Gleichheit, und Sie können nicht wissen, ob das akzeptabel ist eine Anwendung, die Sie wissen nichts über. Die Anwendung möglicherweise "mehr daran interessiert," im Bestreben, die Ungleichheit als Gleichberechtigung oder vielleicht haben andere Spezifikationen es erfüllen muss.
    • Bei der Arbeit mit Fließkomma-zahlen gibt es keine Vorstellung von Identität oder Ungleichheit, und es ist nur eine Vorstellung von der Entfernung. Wenn in der Formel, ich gab die Antwort, die Sie ersetzen < mit > erhalten Sie einen Kriterien für den Vergleich von floating-point-zahlen für die Ungleichheit in Bezug auf die Entfernung. Bitweise Identität von floating-point-zahlen, Darstellung in der computer-Speicher ist nicht von Interesse für die meisten praktischen Anwendungen
    • Dies ist nicht über die bits, die eine Anzahl; es geht um Ihre Werte. Floating-point-Arithmetik bedeutet Gleichheit. Der IEEE-754-standard definiert floating-point-Objekte repräsentieren konkrete zahlen genau, nicht zu vertreten Abständen.
    • Und ein Beispiel aus der Praxis ist?
    • Ein Beispiel aus der Praxis, was?
    • ein real life Beispiel, wenn Sie brauchen, um zu vergleichen, die double-precision-floating-point-zahlen mit == ich weiß nicht (abgesehen vom CPU-Hersteller tests und dergleichen)
    • Sie untersuchen eine gedämpfte Oszillator und unterscheiden wollen, underdamping, overdamping und die kritische Dämpfung. Dies erfordert eine strenge Prüfung, ohne Toleranz. Erlaubt ist eine Toleranz führen würde, um die Quadratwurzel einer negativen Zahl. Jedoch, trotz dieses Beispiel, deine Anfrage ist ein Strohmann. Beratung, nicht zu vergleichen mit einer Toleranz impliziert nicht den Vergleich für die exakte Gleichheit, da gibt es andere Möglichkeiten. Zum Beispiel, eine Möglichkeit ist zu vermeiden, mit einem Vergleich bei allen; nur berichten das beste Ergebnis zur Verfügung, ohne zu versuchen, es zu zwingen, eine quantisierte Ergebnis.
    • Unabhängig von jeder Beispiele, es ist ein grundlegendes problem in der Beratung von Menschen zu vergleichen mit einer Toleranz. Es erhöht die falschen Berichte der Gleichheit, und, weil Sie nicht wissen, die Anwendung, die Sie nicht wissen können, ob dies akzeptabel ist oder ist das ein problem.
    • lassen Sie uns weiter, diese Diskussion im chat
    • Genaue floating-point-Vergleich erfordert tiefgreifendes Verständnis der IEEE754-standard. Ein gutes tutorial dazu ist in randomascii.wordpress.com/2012/02/25/...
    • "einen genauen Vergleich" - ist ein bedeutungsloser Begriff ist, kann nicht quantifiziert werden. Ich glaube, ich weiß, IEEE754 gut, die Antwort, die ich gab genau die Antwort auf die Frage das Thema, es ist kompakt und eindeutig. Dein Kommentar, im Gegenteil, ist so allgemein, dass es fast ein offtopic.

    InformationsquelleAutor bobah
  2. 7

    Wenn Sie interessiert sind in fixed precision zahlen, sollten Sie mit einer festen Genauigkeit Typ wie BigDecimal, nicht inhärent Ungefähre (obwohl hohe Genauigkeit) type wie float. Es gibt zahlreiche ähnliche Fragen auf Stack Overflow, die in diese im detail, in vielen Sprachen.

    InformationsquelleAutor David M
  3. 4

    Ich denke, es hat nichts zu tun mit Java, es kommt auf IEEE 754 floating-point-Zahl. Es ist wegen der der Art von floating-point-Darstellung. Alle Sprachen, die verwenden das IEEE-754-format wird die Begegnung mit dem gleichen problem.

    Wie vorgeschlagen von David oben, verwenden Sie die Methode abs java.lang.Math-Klasse, um den absoluten Wert (Tropfen der positiv - /negativ-Vorzeichen).

    Können Sie dies Lesen: http://en.wikipedia.org/wiki/IEEE_754_revision und auch eine gute numerische Methoden der text-Buch-Adresse das problem ausreichend.

    public static void main(String[] args) {
    float a = 1.2f;
    float b = 3.0f;
    float c = a * b;
        final float PRECISION_LEVEL = 0.001f;
    if(Math.abs(c - 3.6f) < PRECISION_LEVEL) {
        System.out.println("c is 3.6");
    } else {
        System.out.println("c is not 3.6");
    }
}
    InformationsquelleAutor Daniel Baktiar
  4. 3

    Ich bin mit diesem Stück code in unit-tests zu vergleichen, wenn das Ergebnis von 2 verschiedenen Berechnungen sind die gleichen, abgesehen von floating point math Fehler.

    Funktioniert es, indem man die Binär-Repräsentation der Gleitkomma-Zahl. Die meisten die Komplikationsrate ist aufgrund der Tatsache, dass das Zeichen von Gleitkomma-zahlen ist nicht zwei-Komplement. Nach dem Ausgleich, dass es im Grunde kommt es nur noch eine einfache Subtraktion, um die Differenz in ULPs (siehe den Kommentar unten).

    /**
 * Compare two floating points for equality within a margin of error.
 * 
 * This can be used to compensate for inequality caused by accumulated
 * floating point math errors.
 * 
 * The error margin is specified in ULPs (units of least precision).
 * A one-ULP difference means there are no representable floats in between.
 * E.g. 0f and 1.4e-45f are one ULP apart. So are -6.1340704f and -6.13407f.
 * Depending on the number of calculations involved, typically a margin of
 * 1-5 ULPs should be enough.
 * 
 * @param expected The expected value.
 * @param actual The actual value.
 * @param maxUlps The maximum difference in ULPs.
 * @return Whether they are equal or not.
 */
public static boolean compareFloatEquals(float expected, float actual, int maxUlps) {
    int expectedBits = Float.floatToIntBits(expected) < 0 ? 0x80000000 - Float.floatToIntBits(expected) : Float.floatToIntBits(expected);
    int actualBits = Float.floatToIntBits(actual) < 0 ? 0x80000000 - Float.floatToIntBits(actual) : Float.floatToIntBits(actual);
    int difference = expectedBits > actualBits ? expectedBits - actualBits : actualBits - expectedBits;

    return !Float.isNaN(expected) && !Float.isNaN(actual) && difference <= maxUlps;
}

    Hier ist eine version für double precision floats:

    /**
 * Compare two double precision floats for equality within a margin of error.
 * 
 * @param expected The expected value.
 * @param actual The actual value.
 * @param maxUlps The maximum difference in ULPs.
 * @return Whether they are equal or not.
 * @see Utils#compareFloatEquals(float, float, int)
 */
public static boolean compareDoubleEquals(double expected, double actual, long maxUlps) {
    long expectedBits = Double.doubleToLongBits(expected) < 0 ? 0x8000000000000000L - Double.doubleToLongBits(expected) : Double.doubleToLongBits(expected);
    long actualBits = Double.doubleToLongBits(actual) < 0 ? 0x8000000000000000L - Double.doubleToLongBits(actual) : Double.doubleToLongBits(actual);
    long difference = expectedBits > actualBits ? expectedBits - actualBits : actualBits - expectedBits;

    return !Double.isNaN(expected) && !Double.isNaN(actual) && difference <= maxUlps;
}
    • Sie können auch erwägen Float.floatToRawIntBits(), die überprüfung für die NaN am Anfang der Methode. In der Tat floatToIntBits() tut nichts, aber überprüfen Sie das Ergebnis für NaN ersetzt mit vordefinierten integer-Wert von 0x7fc00000. Der Hauptgrund für so etwas ist eine Tatsache, dass floatToIntBits() ruft tatsächlich floatToRawIntBits(), so dass es langsamer zu führen.Der andere Ansatz ist, überprüfen Sie die konvertierte bits für 0x7fc00000, aber Sie brauchen nicht beide Prüfungen.
    InformationsquelleAutor Laurens Holst
  5. 2

    Dies ist eine Schwäche aller floating-point-Darstellungen, und es geschieht, weil einige zahlen, die scheinbar eine Feste Anzahl von Nachkommastellen im Zehnersystem, die eigentlich eine unendliche Anzahl von Dezimalzahlen in das Binär-system. Und so, was Sie denken, ist 1.2 ist tatsächlich so etwas wie 1.199999999997, weil bei der Darstellung in Binär-muss es abhacken der Dezimalstellen nach einer bestimmten Anzahl, und Sie verlieren etwas an Präzision. Dann Multiplikation mit 3 tatsächlich gibt 3.5999999...

    http://docs.python.org/py3k/tutorial/floatingpoint.html <- könnte es besser erklären (auch wenn es für python, es ist ein gemeinsames problem der floating point Darstellung)

    • +1 - alle finite-precision-floating-Zahl-Systeme leiden unter diesem problem. Egal, welche Basis, die Sie wählen, einige rationals nicht exakt dargestellt werden.
    InformationsquelleAutor Andrei Fierbinteanu
  6. 2

    Wie die anderen schrieben:

    Vergleichen Sie schwimmt mit: if (Math.abs(a - b) < delta)

    Schreiben Sie eine schöne Methode dafür:

    public static int compareFloats(float f1, float f2, float delta)
{
    if (Math.abs(f1 - f2) < delta)
    {
         return 0;
    } else
    {
        if (f1 < f2)
        {
            return -1;
        } else {
            return 1;
        }
    }
}

/**
 * Uses <code>0.001f</code> for delta.
 */
public static int compareFloats(float f1, float f2)
{
     return compareFloats(f1, f2, 0.001f);
}

    So, Sie können es verwenden, wie diese:

    if (compareFloats(a * b, 3.6f) == 0)
{
    System.out.println("They are equal");
}
else
{
    System.out.println("They aren't equal");
}
    InformationsquelleAutor Martijn Courteaux
  7. 2

    Es ist ein apache-Klasse für den Vergleich von doubles: org.apache.Unterhaus.math3.util.Präzision

    Es enthält einige interessante Konstanten: SAFE_MIN und EPSILON sind, die die maximal möglichen Abweichungen bei der Durchführung der arithmetischen Operationen.

    Es bietet auch die notwendigen Methoden zu vergleichen, die gleich oder Runde verdoppelt.

    InformationsquelleAutor bvdb
  8. -1

    Vergleichen von zwei floats, f1 und f2 innerhalb der Genauigkeit der #.### ich glaube, Sie würden tun müssen, wie diese:

    ((int) (f1 * 1000 + 0.5)) == ((int) (f2 * 1000 + 0.5))

    f1 * 1000 Aufzüge 3.14159265... zu 3141.59265, + 0.5 Ergebnisse in 3142.09265 und die (int) schneidet die Nachkommastellen, 3142. Das heißt, es beinhaltet 3 Nachkommastellen und rundet die Letzte Ziffer richtig.

    • Der Vergleich mit einem epsilon ist besser: überlegen Sie, was passiert, wenn f1 == 3.1414999999999 und f2 == 3.1415000000001.
    • Scheiße. Ich, obwohl ich es hatte 🙂 sicher. Ich Stimme mit Ihnen überein. Der Vergleich mit einem epsilon ist viel besser. Aber es funktioniert genau vergleichen von zwei floats seinen ersten 3 Nachkommastellen?
    InformationsquelleAutor aioobe
Schreibe einen Kommentar