Gleitkommazahlen [prontosystems.org]

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
[[:it|{{ :xeon.png?40|}}]]
=====Gleitkommazahlen=====
Bislang dachte ich, dass alles was können ist Rechnen und das obendrein noch richtig schnell aber nachdem ich jetzt angefangen habe eine Programmiersprache zu lernen (C) musste ich feststellen, dass das so nicht stimmt und war zugegebenermaßen völlig überrascht, wie oft sich ein Computer tatsächlich verrechnet. Ein Wunder, dass die Dinger nicht ständig abstürzen.

Das Problem über das ich gestolpert bin, sind Berechnungen mit Gleitkommazahlen, auch Float genannt. Fragt man nun einen Computer ob >><fc #008000>0,1 + 0,1 + 0,1</fc><< gleich >><fc #008000>0,3</fc><< oder >><fc #008000>1,1 * 1,1</fc><< gleich >><fc #008000>1,21</fc><< ist, sagt er Nein. Klingt komisch, ist aber so:

<code c|float_1.c>#include <stdio.h>

int main( void ) { 
  printf( "%d\n", 1.1 * 1.1       == 1.21 );
  printf( "%d\n", 0.1 + 0.1 + 0.1 == 0.3  );
}</code>

Dieses Programm vergleicht mit dem Vergleichsoperator >><fc #008000>==</fc><< ob die Gleichungen in der printf() Funktion wahr oder falsch sind, wobei eine >><fc #008000>1</fc><< als Rückgabe die Gleichung als >><fc #008000>wahr</fc><<, bzw. eine >><fc #008000>0</fc><< die Gleichung als >><fc #008000>falsch</fc><< identifiziert:

<xterm>$ <fc #008000>./float_1</fc> 
0
0</xterm>

Da hat mein Weltbild schon angefangen zu wanken aber was ist dabei schlief gelaufen? Schauen wir uns mal an, was dann die og Rechnungen für ein Ergebnis liefern:

<code c|float_2.c>#include <stdio.h>

float f = 0.1 + 0.1 + 0.1;
float e = 1.1 * 1.1;
int main( void ) { 
  printf( "%.9f\n", f );
  printf( "%.9f\n", e );
}</code>

Dieser Code gibt die Summen in der Variablendeklaration mit neun Nachkommastellen aus:

<xterm>$ <fc #008000>./float_2</fc> 
0.300000012
1.210000038</xterm>

Das erklärt zumindest mal das überraschende Ergebnis der Vergleichsoperation im ersten Programm aber befriedigend ist erst mal nicht. Das Ganze geht sogar noch einen Schritt weiter, lassen wir den Rechner mal nicht rechnen, sondern uns nur die interne Darstellung der beiden Zahlen >><fc #008000>0,1</fc><< und >><fc #008000>1,1</fc><< ausgeben:

<code c|float_3.c>#include <stdio.h>

float f = 0.1;
float e = 1.1;
int main( void ) {
  printf( "%.9f\n", f );
  printf( "%.9f\n", e );
}</code>
<xterm>$ <fc #008000>./float_3</fc> 
0.100000001
1.100000024</xterm>

Ich fand, dass schreit nach einer Erklärung und ich habe dieses Thema in der Newsgroup >><fc #008000>de.comp.lang.c</fc><< zur Diskussion gestellt. Also warum ist das so? Die kurze Antwort ist: Das liegt an der Art, wie intern Gleitkommazahlen dargestellt werden. Die lange Antwort aber ist gar nicht so leicht zu verstehen und beim ersten Überfliegen der Erklärung dachte ich, dass schon ein paar Semester Mathematik nötig wären, um das in letzter Konsequenz zu verstehen.

Kurz gefasst kann man festhalten, dass Gleitkommazahlen intern als Ganzzahl dargestellt werden. Ergibt die Umrechnung der Gleitkommazahl keine Ganzzahl, ist sie nicht exakt als Binärzahl darstellbar und es kommt zu oben gezeigten Umrechnungsfehlern. Nehmen wir unser og Beispiel >><fc #008000>0,1</fc><< und rechnen das mal in eine Ganzzahl um. Es wird zuerst die Anzahl der Nachkommastellen als Exponent zur Basis 2 errechnet. >><fc #008000>0,1</fc><< hat eine Nachkommastelle -> >><fc #008000>2<sup>1</sup> = 2</fc><<. Nun wird die Gleitkommazahl mit diesem ermittelten Wert multipliziert und wenn das Ergebnis dieser Multiplikation keine ganze Zahl ergibt, kommt es zu dem oben gezeigten Effekt -> >><fc #008000>0,1 * 2 = 0,2</fc><<. 

Schauen wir mal wie es mit >><fc #008000>1,1</fc><< ausschaut: >><fc #008000>2<sup>1</sup> * 1,1 = 1,21</fc><<, was auch keine ganze zahl ergibt. Schauen wir uns mal eine Gleitkommazahl an, bei der das aber funktioniert: >><fc #008000>1.998046875</fc><< hat neun Nachkommastellen, was >><fc #008000>2<sup>9</sup> = 512</fc><< ergibt, multipliziert man nun >><fc #008000>1.998046875</fc><< mit >><fc #008000>512</fc><< hat man das Ergebnis >><fc #008000>1023</fc><<. Das ist eine ganze Zahl und wird dementsprechend korrekt dargestellt:

<code c|float_4.c>#include <stdio.h>

float f =1.998046875;
int main( void ) {
  printf( "%.70f\n", f );
}</code>
<xterm>$ <fc #008000>./float_4</fc> 
<fc #800000>1.998046875</fc><fc #000080>0000000000000000000000000000000000000000000000000000000000000</fc></xterm>