5.2 Fließkommaarithmetik in Java

Zahlen mit einem Komma nennen sich Gleitkomma-, Fließkomma-, Fließpunkt- oder Bruchzahlen (gebrochene Zahlen). Der Begriff »Gleitkommazahl« kommt daher, dass die Zahl durch das Gleiten (Verschieben) des Dezimalpunkts als Produkt aus einer Zahl und einer Potenz der Zahl 10 dargestellt wird (also 1,23 = 123 * 10^{– 2} ).

Java unterstützt für Fließkommazahlen die Typen float und double, die sich nach der Spezifikation IEEE 754 richten. Diesen Standard des »Institute of Electrical and Electronics Engineers« gibt es seit Mitte der 80er Jahre. Ein float hat die Länge von 32 Bit und ein double die Länge von 64 Bit. Die Rechenoperationen sind im »IEEE Standard for Floating-Point Arithmetic« definiert.

System.out.println( 2345678.88f );   //  2345679.0

5.2.1 Mantisse und Exponent

Intern bestehen Fließkommazahlen aus drei Teilen: einem Vorzeichen, einem ganzzahligen Exponenten und einer Mantisse (engl. mantissa). Während die Mantisse die Genauigkeit bestimmt, gibt der Exponent die Größenordnung der Zahl an.

Die Berechnung für Fließkommazahlen aus den drei Elementen ist im Prinzip wie folgt: Vorzeichen * 2 ^ Exponent * Mantisse, wobei Vorzeichen –1 oder +1 sein kann. Die Mantisse m ist keine Zahl mit beliebigem Wertebereich, sondern normiert mit dem Wertebereich 1 <= m < 2, also eine Fließkommazahl, die mit 1 beginnt und daher auch 1-plus-Form heißt. [Es gibt eine Ausnahme durch denormalisierte Zahlen, aber das spielt für das Verständnis keine Rolle.] Auch der zunächst vorzeichenbehaftete Exponent wird nicht direkt gespeichert, sondern als angepasster Exponent (engl. biased exponent) in der IEEE-kodierten Darstellung abgelegt. Zu unserem Exponenten wird, abhängig von der Genauigkeit, +127 (bei float) und +1023 (bei double) addiert; nach der Berechnung steht in der Darstellung immer eine ganze Zahl. 127 und 1023 nennen sich Bias.

Das Vorzeichen kostet immer ein Bit, und die Anzahl der Bits für Exponent und Mantisse richtet sich nach dem Datentyp.

0·10001111·11100010010000001100101 
0·10000001111·1110001001000000110010011111101111100111011011001001

BigInteger biasedExponent = new BigInteger( "10001111", 2 ); 
BigInteger mantisse = new BigInteger( "11100010010000001100101", 2 ); 
int exponent = (int) Math.pow( 2, biasedExponent.longValue() – 127 ); 
double m = 1. + (mantisse.longValue() / Math.pow( 2, 23 )); 
System.out.println( exponent * m );  // 123456.7890625

Wenn uns beim Wort double im Vergleich zu float ein »doppelte Genauigkeit« über die Lippen kommt, müssen wir mit der Aussage vorsichtig sein, denn double bietet zumindest nach der Anzahl der Bits eine mehr als doppelt so präzise Mantisse. Über die Anzahl der Nachkommastellen sagt das jedoch direkt nichts aus.

double d1 = 0.02d; 
float  f1 = 0.02f; 
System.out.println( d1 == f1 );         // false 
System.out.println( (float) d1 == f1 ); // true 
 
double d2 = 0.02f; 
float  f2 = 0.02f; 
System.out.println( d2 == f2 );         // true

5.2.2 Spezialwerte Unendlich, Null, NaN

Die Datentypen double und float können nicht nur »Standardzahlen« speichern. Java definiert Sonderwerte für eine positive oder negative Null, positives und negatives Unendlich (engl. infinity) und NaN, die Abkürzung für Not a Number.

Unendlich

Der Überlauf führt zu einem positiven oder negativen Unendlich.

System.out.println(  1E300 * 1E20 );    //  Infinity 
System.out.println( –1E300 * 1E20 );    // -Infinity

Für die Werte deklariert die Java-Bibliothek in Double und Float zwei Konstanten; zusammen mit der größten und kleinsten darstellbaren Fließkommazahl sind das:

Das Minimum für double-Werte liegt bei etwa 10^–324 und das Maximum bei etwa 10^308.

Positive, negative Null

Der Vergleichsoperator == unterscheidet die positive Null (+0,0) und die negative Null (–0,0) nicht, und so sind sie gleich (0.0 == –0.0). Damit ist auch 0.0 > –0.0 falsch. Die Bitmaske ist jedoch unterscheidbar, was der Vergleich Double.doubleToLongBits(+0.0) != Double.doubleToLongBits(-0.0) zeigt.

System.out.println( 1E-322 *  0.0001 );  //  0.0 
System.out.println( 1E-322 * –0.0001 );  // –0.0

Es gibt einen weiteren kleinen Unterschied, den wir anhand der Rechnung 1.0 / –0.0 und 1.0 / 0.0 leicht erkennen. Durch den Grenzwert geht das Ergebnis einmal gegen negativ unendlich und einmal gegen positiv unendlich.

NaN

NaN wird als Fehlerindikator für das Ergebnis von undefinierten Rechenoperationen benutzt, etwa 0/0.

System.out.println( Math.sqrt(-4) );     // NaN 
System.out.println( 0.0 / 0.0);          // NaN

NaN ist als Konstante in den Klassen Double und Float deklariert. Die Funktion isNaN() testet, ob eine Zahl NaN ist. Die API-Dokumentation am Beispiel von Double:

public final class java.lang.Double 
extends Number 
implements Comparable<Double>

• public static final double NaN = 0.0 / 0.0;
  Deklaration von NaN bei Double.

• boolean isNaN()
  Liefert true, wenn das aktuelle Double-Objekt NaN ist.

• public static boolean isNaN( double v )
  Liefert true, wenn die übergebene Zahl v NaN ist.

Die Implementierung von isNan(double v) ist einfach: return v != v.

Alles hat seine Ordnung

Außer für den Wert NaN ist auf allen Fließkommazahlen eine totale Ordnung definiert. Das heißt: Sie lassen sich von der kleinsten Zahl bis zur größten aufzählen. Am Rand steht die negative Unendlichkeit, dann folgen die negativen Zahlen, negative Null, positive Null, positive Zahlen und positives Unendlich. Bleibt nur noch die einzige unsortierte Zahl NaN. Alle numerischen Vergleiche <, <=, >, >= mit der Java-NaN liefern false. Der Vergleich mit == ist false, wenn einer der Operanden NaN ist. != verhält sich umgekehrt, ist also true, wenn einer der Operanden NaN ist.

System.out.println( Double.NaN == Double.NaN ); // false 
System.out.println( Double.NaN != Double.NaN ); // true

Ein NaN-Wert auf eine Ganzzahl angepasst, also etwa (int) Double.NaN, gibt 0.

Stille NaNs

Eine Problematik in der Fließkomma-Arithmetik ist, dass keine Ausnahmen die Fehler anzeigen; NaNs solcher Art heißen auch stille NaNs (engl. Quiet NaNs [qNaNs]). Als Entwickler müssen wir also immer selbst schauen, ob das Ergebnis während einer Berechnung korrekt bleibt. Ein durchschnittlicher numerischer Prozessor unterscheidet ein qNaN und ein signaling NaN (sNaN).

Ihr Kommentar