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 Dezimalzahlen in 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 DEzimalzahlen intern als Ganzzahl dargestellt werden. Ergibt die Umrechnung der Dezimalzahl 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 Dezimalzahl 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 Dezimalzahl 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>

Ein weiterer Grund warum eine Dezimalzahl uU nicht exakt dargestellt werden kann liegt daran, dass die binäre Darstellung nicht mehr vollständig in den dafür vorgesehenen Platz abgebildet werden kann und hier fängt es an kompliziert zu werden. Eine binäre Gleitkommazahl wird in einem 32 Bit (single precision) bzw. 64 Bit (double precision) Format definiert. Die 32 Bit der single precision teilt sich auf in 1 Bit für das Vorzeichen, 8 Bit für den Exponenten und 23 Bit für die Mantisse. Die Anordnung der Bits hängt dabei von der jeweiligen Bytereihenfolge (little/big endian) ab.

Erläutern wir dieses System mal anhand der Dezimalzahl >><fc #008000>18,4</fc><< an:

**1) Errechnung des Bias**

 >>Bias = (2<sup>(r-1)</sup>)-1<< wobei >>r<< die Anzahl der Bits im Exponenten der Gleitkommazahl (in unserem Fall sind 8 Bit für den Exponenten vorgesehen) darstellt. Was folgendes ergibt:

''<fc #008000>Bias = (2<sup>(8-1)</sup>)-1 = (2<sup>7</sup>)-1 = 128-1 = 127</fc>''

**2) Umrechnung der Dezimalzahl in eine duale Festkommazahl ohne Vorzeichen:**

<code|18,4>

 18/2 = 9 Rest 0 (least significant Bit)
  9/2 = 4 Rest 1
  4/2 = 2 Rest 0
  2/2 = 1 Rest 0
  1/2 = 0 Rest 1 (most significant bit)
      = 10010

0,4*2 = 0,8 -0   (most significant bit)
0,8*2 = 1,6 -1
0,6*2 = 1,2 -1
0,2*2 = 0,4 -0
0,4*2 = 0,8 -0
0,8*2 = 1,6 -1   (least significant bit)
      *
      *
      *
      = 0,011001100110011...
     
 18,4 = 10010,011001100110011...</code>