Bewahren Sie Präzision mit Double in Java

Wie andere erwähnt haben, werden Sie wahrscheinlich wollen, verwenden Sie die BigDecimal Klasse, wenn Sie wollen, um eine genaue Darstellung 11.4.

Nun, eine kleine Erklärung, warum dies geschieht:

Den float und double primitiven Typen in Java sind Gleitkomma zahlen, wo die Zahl gespeichert ist, als eine binäre Darstellung für einen Bruchteil und einem Exponenten.

Genauer gesagt, eine double-precision-floating-point-Wert wie die double Typ ist ein 64-bit-Wert, wobei:

• 1 bit kennzeichnet das Vorzeichen (positiv oder negativ).
• 11 bits für den Exponenten.
• 52 bits für die signifikanten Ziffern (Nachkomma-Teil als binary).

Diese Teile werden kombiniert, um zu produzieren ein double Darstellung eines Werts.

(Quelle: Wikipedia: Doppelter Genauigkeit)

Für eine detaillierte Beschreibung, wie floating-point-Werte behandelt werden, die in Java finden Sie in der Abschnitt 4.2.3: Floating-Point-Typen, Formate und Werte der Java Language Specification.

Den bytecharintlong Arten sind fixed-point zahlen, die genaue representions von zahlen. Im Gegensatz zu fixed-point-zahlen, Gleitkomma-zahlen wird einige Male (sicher davon ausgehen, dass "die meiste Zeit") nicht in der Lage sein, um eine genaue Darstellung einer Zahl. Dies ist der Grund, warum Sie am Ende mit 11.399999999999 als Ergebnis 5.6 + 5.8.

Wenn die eine Wert das genau ist, wie 1.5 oder 150.1005, werden Sie wollen, um die Verwendung eines fixed-point-Typen, die in der Lage sein zu vertreten, die Zahl genau.

Wie bereits erwähnt, schon mehrmals, Java hat eine BigDecimal Klasse, die Handhabung sehr große zahlen und sehr kleine zahlen.

Aus der Java-API-Referenz für die BigDecimal Klasse:

Unveränderlich,
eine beliebige Präzision signed decimal
zahlen. Eine BigDecimal-besteht aus einem
beliebiger Genauigkeit integer unskalierten
Wert-und eine 32-bit-integer-Skalierung. Wenn
null oder positiv ist, ist die Skala der
Anzahl der Ziffern rechts von der
dezimal-Punkt. Wenn negativ ist, ist die
unskalierte Wert der Zahl ist
mit zehn multipliziert, um die Kraft des
negation der Skala. Der Wert von
die Anzahl vertreten durch die
BigDecimal ist daher (unscaledValue
× 10^-Skala).

Es wurde viele Fragen auf Stack Overflow im Zusammenhang mit der Angelegenheit von floating-point-zahlen und seine Präzision. Hier ist eine Liste von Fragen, die von Interesse sein können:

• Warum sehe ich ein double-Variablen initialisiert, die auf einen Wert wie von 21,4 als 21.399999618530273?
• So drucken Sie richtig große zahlen in C++
• Wie ist floating point gespeichert? Wenn spielt es eine Rolle?
• Verwenden Sie Float oder Decimal-Daten für die Buchhaltung-Dollar-Betrag?

Wenn Sie wirklich wollen, um sich nach unten zu der nitty gritty details von floating-point-zahlen, werfen Sie einen Blick auf Was Jeder Computer Scientist Should Know About Floating-Point Arithmetic.

InformationsquelleAutor der Antwort coobird

Wenn Sie nur wollen, um Prozess-Werte als Bruchteile, die Sie erstellen können, einen Bruchteil der Klasse die hat einen Zähler und Nenner Feld.

Write-Methoden für das hinzufügen, subtrahieren, multiplizieren und dividieren sowie eine Methode toDouble. Auf diese Weise können Sie vermeiden, schwimmt während der Berechnungen.

EDIT: Schnelle Umsetzung,

public class Fraction {

private int numerator;
private int denominator;

public Fraction(int n, int d){
    numerator = n;
    denominator = d;
}

public double toDouble(){
    return ((double)numerator)/((double)denominator);
}


public static Fraction add(Fraction a, Fraction b){
    if(a.denominator != b.denominator){
        double aTop = b.denominator * a.numerator;
        double bTop = a.denominator * b.numerator;
        return new Fraction(aTop + bTop, a.denominator * b.denominator);
    }
    else{
        return new Fraction(a.numerator + b.numerator, a.denominator);
    }
}

public static Fraction divide(Fraction a, Fraction b){
    return new Fraction(a.numerator * b.denominator, a.denominator * b.numerator);
}

public static Fraction multiply(Fraction a, Fraction b){
    return new Fraction(a.numerator * b.numerator, a.denominator * b.denominator);
}

public static Fraction subtract(Fraction a, Fraction b){
    if(a.denominator != b.denominator){
        double aTop = b.denominator * a.numerator;
        double bTop = a.denominator * b.numerator;
        return new Fraction(aTop-bTop, a.denominator*b.denominator);
    }
    else{
        return new Fraction(a.numerator - b.numerator, a.denominator);
    }
}

}

InformationsquelleAutor der Antwort Viral Shah

Möchten Sie vielleicht zu suchen in der Verwendung von java ist java.math.BigDecimal Klasse, wenn Sie wirklich brauchen, präzisionsberechnungen. Hier ist ein guter Artikel von Oracle/Sun auf der Fall ist für BigDecimal. Sie können zwar niemals 1/3 als jemand erwähnt, Sie kann die macht haben, zu entscheiden, genau, wie präzise Sie wollen das Ergebnis zu sein. setScale() ist dein Freund.. 🙂

Ok, denn ich habe viel zu viel Zeit auf meinen Händen im moment ist hier ein code-Beispiel, das bezieht sich auf deine Frage:

import java.math.BigDecimal;
/**
 * Created by a wonderful programmer known as:
 * Vincent Stoessel
 * [email protected]
 * on Mar 17, 2010 at  11:05:16 PM
 */
public class BigUp {

    public static void main(String[] args) {
        BigDecimal first, second, result ;
        first = new BigDecimal("33.33333333333333")  ;
        second = new BigDecimal("100") ;
        result = first.divide(second);
        System.out.println("result is " + result);
       //will print : result is 0.3333333333333333


    }
}

und plug meine neue Lieblings-Sprache Groovy, hier ist ein genauerer Beispiel für die gleiche Sache:

import java.math.BigDecimal

def  first =   new BigDecimal("33.33333333333333")
def second = new BigDecimal("100")


println "result is " + first/second   //will print: result is 0.33333333333333

InformationsquelleAutor der Antwort Vinny

Ziemlich sicher, dass Sie könnte es geschafft haben, in einer Linie drei Beispiel. 🙂

Wenn Sie möchten, genauen Präzision, BigDecimal verwenden. Andernfalls können int-Werte multipliziert mit 10 ^ was Präzision, die Sie wollen.

InformationsquelleAutor der Antwort Dustin

Können Sie nicht, weil 7.3 nicht haben eine endliche Darstellung in Binär. Die nächstgelegene Sie bekommen können 2054767329987789/2**48 = 7.3+1/1407374883553280.

Werfen Sie einen Blick auf http://docs.python.org/tutorial/floatingpoint.html für eine weitere Erklärung. (Es ist auf der Python-website, aber Java und C++ haben das gleiche "problem".)

Die Lösung hängt davon ab, was genau dein problem ist:

• Wenn es ist, dass Sie einfach nicht sehen, wie all diese Geräusche Ziffern, dann korrigieren Sie Ihren Text formatieren. Anzeigen nicht mehr als 15 signifikanten Ziffern (oder 7 für float).
• Wenn es ist, dass die Ungenauigkeit Ihrer zahlen ist, brechen die Dinge wie "wenn" - Anweisungen, dann sollten Sie schreiben, wenn (abs(x - 7.3) < TOLERANZ) anstelle von if (x == 7.3).
• Wenn Sie arbeiten, mit Geld, was Sie wahrscheinlich wirklich wollen, ist ein dezimal-Punkt. Das speichern einer ganzzahligen Anzahl von Cent oder was auch immer die kleinste Einheit der Währung ist.
• (SEHR UNWAHRSCHEINLICH), Wenn Sie mehr als 53 bits (15-16 signifikante stellen) der Präzision, dann mit einem high-precision-floating-point-Typ, wie BigDecimal.

InformationsquelleAutor der Antwort dan04

Verwendung von java.math.BigDecimal

Doubles sind binäre Fraktionen intern, so dass Sie manchmal nicht darstellen Dezimalbrüche um die genauen dezimal.

InformationsquelleAutor der Antwort Kevin Crowell

Computer speichern zahlen in Binär und kann nicht wirklich zahlen wie 33.333333333 oder 100.0 genau. Dies ist eines der schwierigen Dinge über die Verwendung von doubles. Sie haben gerade mal um die Antwort, Ehe er es an einen Benutzer. Zum Glück in den meisten Anwendungen, die Sie nicht benötigen, dass viele Dezimalstellen gerundet, wie auch immer.

InformationsquelleAutor der Antwort Jay Askren

Verdoppelt werden Annäherungen der Dezimalzahlen in Ihre Java-Quellcode. Sehen Sie die Folge der Diskrepanz zwischen der Doppel - (was ist ein Binär codierter Wert) und Ihre Quelle (das ist dezimal codiert).

Java produziert die nächste binäre Annäherung. Sie können die java.text.DecimalFormat anzeigen, um eine besser aussehende decimal-Wert.

InformationsquelleAutor der Antwort S.Lott

Check-out BigDecimal, es behandelt Probleme im Umgang mit Gleitkomma-Arithmetik so.

Wird der neue Aufruf würde wie folgt Aussehen:

term[number].coefficient.add(co);

Verwenden, setScale (), um die Anzahl der Dezimalstelle Genauigkeit verwendet werden.

InformationsquelleAutor der Antwort Dark Castle

Wenn Sie haben keine andere Wahl, als mit double-Werte verwenden Sie den folgenden code.

public static double sumDouble(double value1, double value2) {
    double sum = 0.0;
    String value1Str = Double.toString(value1);
    int decimalIndex = value1Str.indexOf(".");
    int value1Precision = 0;
    if (decimalIndex != -1) {
        value1Precision = (value1Str.length() - 1) - decimalIndex;
    }

    String value2Str = Double.toString(value2);
    decimalIndex = value2Str.indexOf(".");
    int value2Precision = 0;
    if (decimalIndex != -1) {
        value2Precision = (value2Str.length() - 1) - decimalIndex;
    }

    int maxPrecision = value1Precision > value2Precision ? value1Precision : value2Precision;
    sum = value1 + value2;
    String s = String.format("%." + maxPrecision + "f", sum);
    sum = Double.parseDouble(s);
    return sum;
}

InformationsquelleAutor der Antwort user5734382