# Division mit float und double



## waste (31. Jan 2007)

Hallo,

mein Kollege hatte beim Dividieren von 2 double-Werten unter C++ komische Fehler bekommen (Ergebnis war nicht exakt).
Mit einem Lächeln   wollte ich ihm zeigen, das Java damit keine Probleme hat und stand recht blöde da  :shock: , als ich folgendes Programm ausführte:


```
public class Rechnen
{
    public static void main(String[] args)
    {
        System.out.println("1.1d / 0.1d = " +  1.1d / 0.1d);
        System.out.println("1.1f / 0.1f = " +  1.1f / 0.1f);        
        System.out.println("1.1f / 0.1d = " +  1.1f / 0.1d);
        System.out.println("1.1d / 0.1f = " +  1.1d / 0.1f);
        System.out.println("");
        System.out.println("1.2d / 0.1d = " +  1.2d / 0.1d);
        System.out.println("1.2f / 0.1f = " +  1.2f / 0.1f);
        System.out.println("1.2f / 0.1d = " +  1.2f / 0.1d);
        System.out.println("1.2d / 0.1f = " +  1.2d / 0.1f);
        System.out.println("");
        System.out.println("1.0d / 0.5d = " +  1.1d / 0.5d);
        System.out.println("1.0f / 0.5f = " +  1.1f / 0.5f);
        System.out.println("1.0f / 0.5d = " +  1.1f / 0.5d);
        System.out.println("1.0d / 0.5f = " +  1.1d / 0.5f);
    }
}
```

Es dividiert "double durch double", "float durch float" und auch float und double gemischt.
Ich habe immer mal andere Zahlen eingesetzt und als Ausgabe liefert es:


```
1.1d / 0.1d = 11.0
1.1f / 0.1f = 11.0
1.1f / 0.1d = 11.000000238418579
1.1d / 0.1f = 10.99999983608723

1.2d / 0.1d = 11.999999999999998
1.2f / 0.1f = 12.0
1.2f / 0.1d = 12.000000476837158
1.2d / 0.1f = 11.999999821186067

1.0d / 0.5d = 2.2
1.0f / 0.5f = 2.2
1.0f / 0.5d = 2.200000047683716
1.0d / 0.5f = 2.2
```

Wie kommen denn nun diese Zahlen zustande?
Da bin ich mit Kopfrechnen viel näher am Ergebnis als der Computer 

Ne mal im Ernst, kann mir jemand sagen wieso und weshalb und was ich machen kann um solche Sachen zu vermeiden.
Ich meine 2 Kommazahlen zu dividieren ist ja nichts außergewöhnliches...
Ich verstehe es leider nicht  :bahnhof: 

Mir ist nur aufgefallen, dass es bei "float durch float" keine dummen Fehler gab.
Aber das heißt ja nicht, dass es immer so ist.

Und warum ist "float durch float" genauer, wenn doch float nur eine "Gleitkommazahl" darstellt und double sogar eine "doppeltgenaue Gleitkommazahl" ... ist double am Ende zu genau :lol:

Danke für die Erkläungen
waste


----------



## Lim_Dul (31. Jan 2007)

Das hat mit der internen Speicherung der Zahlen zu tun: http://de.wikipedia.org/wiki/Gleitkommazahl

Man kann mit n Bits nun mal nur 2^n verschiedene Zahlen darstellen, daher lässt sich nicht jede Gleitkommazahl mit float oder double darstellen.  Es gibt also Lücken, die Darstellung ist außer in Ausnahmefällen nie genau. Beim rechnen vergrößeren sich diese Fehler naturgemäß, so dass man dann meint, falsche Ergebnisse zu bekommen.
Deshalb sollte man float oder double auch nie mit == vergleichen, weil der false liefern kann, obwohl eigentlich true gemeint ist.

Allerdings kann man in Java auch genau rechnen mittels der Klasse BigDecimal. Man sollte da nur aufpassen, nur den String-Konstruktor zu nehmen.


----------



## waste (1. Feb 2007)

Danke für die Antwort.
Auch der Wiki-Artikel war ein guter Hinweis.


----------

