1.4 Maschinengenauigkeit, Rundungsfehler und Stellenauslöschung
Dezimalzahlen werden im Computer als Dualzahlen dargestellt, d. h. im Binärsystem. Die Darstellung ist nach dem Standard IEEE-754 genormt.
Abbildung 1.7 Darstellung einer doppelt genauen Gleitpunktzahl
Dem Vorzeichenbit V folgen ein Exponent mit 11 Bit und eine Mantisse mit 52 Bit. Mit dieser Norm lassen sich Gleitpunktzahlen in der Größenordnung von etwa 2,2 × 10–308 bis 1,8 × 10308 darstellen.
Zwei etwa gleich große Zahlen können noch addiert werden:
>>> 1e300+1e300
2e+300
Wenn der Wertebereich überschritten wird, kommt es zu einem Überlauf:
>>> 1e308+1e308
inf
Ein Überlauf wird durch die Bitsequenz inf gekennzeichnet.
Wenn der Wertebereich unterschritten wird, kommt es zu einem Unterlauf, und es wird mit 0 weitergerechnet.
Wenn sich die Zahlen jedoch um gewisse Größenordnungen unterscheiden, wird bei der Addition die kleinere Zahl einfach ignoriert:
>>> h=1e-9
>>> h+1
1.000000001
>>> h=1e-16
>>> h+1
1.0
Der Dialog zeigt, dass eine Zahl, die gleich oder kleiner als 10–16 ist, bei der Addition ignoriert wird. Weil die Anzahl der Binärstellen im Speicher begrenzt ist, werden alle Nachkommastellen abgeschnitten, die nicht mehr in den Speicherbereich »passen«. Behalten Sie das im Hinterkopf, und prüfen Sie Berechnungen, bei denen Sie Gleitkommazahlen stark unterschiedlicher Größenordnungen miteinander verrechnen. In den meisten praktischen Anwendungsfällen muss man nicht mit so großen oder so kleinen Zahlen arbeiten, dass diese Ungenauigkeit des Computers zu einem Problem wird.
1.4.1 Maschinengenauigkeit
Die kleinste darstellbare Zahl wird als Maschinengenauigkeit ε bezeichnet. Mit Listing 1.2 kann ε berechnet werden:
#maschinengenauigkeit.py
EPS=1.
while (1.0+EPS)!=1.0:
EPS=EPS/2.0
print(EPS)
1.1102230246251565e-16 #Ausgabe
Listing 1.2 Maschinengenauigkeit ermitteln
Die while-Schleife wird so lange durchlaufen, bis der Python-Interpreter in Zeile 03 zwischen 1.0 + EPS und 1.0 keinen Unterschied mehr erkennen kann. Wenn das der Fall ist, gibt er den Wert für EPS aus.
Mit der Funktion finfo() aus dem Modul NumPy erhalten Sie ausführlichere Informationen:
#np_finfo.py
import numpy as np
EPS = np.finfo(np.float64)
print(EPS)
Ausgabe
Machine parameters for float64
---------------------------------------------------------------
precision = 15 resolution = 1.0000000000000001e-15
machep = -52 eps = 2.2204460492503131e-16
negep = -53 epsneg = 1.1102230246251565e-16
minexp = -1022 tiny = 2.2250738585072014e-308
maxexp = 1024 max = 1.7976931348623157e+308
nexp = 11 min = -max
…
---------------------------------------------------------------
Nach IEEE-754 hat die Maschinengenauigkeit den Wert EPS = 1,11 × 10–16. Sie kann auch aus der Anzahl der Bits (plus Vorzeichenbit) der Mantisse berechnet werden:
1.4.2 Rundungsfehler
Bei Berechnungen, die eine bestimmte Anzahl von Nachkommastellen verlangen, entstehen immer Rundungsfehler. Wenn Sie z. B. das Produkt
berechnen und auf zwei Nachkommastellen runden, dann entsteht ein Rundungsfehler von 0,22 – 0,2178 = 0,0022. Die vom Computer erzeugten Rundungsfehler sind zwar wesentlich kleiner, sie dürfen aber ab einer bestimmten Anzahl der Rechenoperationen nicht mehr vernachlässigt werden.
Da die Anzahl der Bits, die die reellen Zahlen im Computer repräsentieren sollen, begrenzt ist, können reelle Zahlen immer nur näherungsweise als Maschinenzahlen im Computer dargestellt werden. Jede Repräsentation einer reellen Zahl durch eine Maschinenzahl ist also systembedingt immer fehlerbehaftet.
Zu diesem systembedingten Fehler addieren sich Fehler, die durch das Runden von Zwischenergebnissen entstehen. Wird die Rechnung mit Zwischenergebnissen weiter fortgesetzt, so werden die Rundungsfehler weiter durch die Rechnung getragen. Wenn auf n + 1 Stellen genau gerechnet wird, dann wird das Zwischenergebnis auf n Stellen gerundet. Da jedes einzelne Zwischenergebnis gerundet wird, addieren sich die Rundungsfehler zu einem Gesamtfehler [Knorrenschild: 4]. Rundungsfehler vergrößern sich also mit der Anzahl der Rechenoperationen.
Zusätzlich entstehen bei der Ausführung von Algorithmen noch sogenannte Verfahrensfehler. Das sind alle diejenigen Fehler, die durch ein numerisches Rechenverfahren (Algorithmus) verursacht werden. Beispielsweise kann bei der numerischen Integration die Fläche unter einer Kurve durch Rechtecke, Trapeze oder Parabelbögen (das Simpson-Verfahren) angenähert werden. Die Gesamtfläche wird innerhalb einer Schleife durch n-maliges Aufsummieren berechnet. Es ist leicht einsichtig, dass das Simpson-Verfahren kleinere Verfahrensfehler verursacht. Der Nachteil der Rechtecksummen kann aber in gewissen Grenzen durch eine Verkleinerung der Schrittweite h kompensiert werden. Dann erhöht sich aber auch die Anzahl der Rechenoperationen, und der Anteil der Rundungsfehler steigt. Es muss also für die Anzahl der Rechenoperationen ein Optimum existieren, das im Schnittpunkt beider Kurven liegt.
Abbildung 1.8 zeigt den Zusammenhang zwischen Rundungs- und Verfahrensfehlern.
Abbildung 1.8 Zusammenhang zwischen Rundungs- und Verfahrensfehlern
In Abschnitt 9.4 wird für die numerische Differenziation gezeigt, wie die optimale Schrittweite h ermittelt werden kann.
1.4.3 Stellenauslöschung
Wenn wir mit unserem Taschenrechner oder gedanklich folgende Subtraktion durchführen:
dann erhalten wir das richtige Ergebnis. Führen wir aber diese Operation in der Python-Konsole aus, erhalten wir ein hiervon abweichendes Ergebnis:
>>> 1.001e-12-1e-12
1.0000000000000967e-15
Dieses Phänomen tritt bei der Subtraktion von zwei fast gleich großen Zahlen auf. Es wird als Stellenauslöschung oder kurz als Auslöschung bezeichnet. Bei der Entwicklung von Algorithmen sollte diese Fehlerquelle berücksichtigt werden.
Fazit
Ein Computer kann aufgrund der beschränkten Stellenzahl nicht alle Zahlen exakt darstellen.
Außerdem kann er die gewünschten Berechnungen nicht exakt ausführen.
Der Vergleichsoperator == sollte nicht im Zusammenhang mit Gleitpunktzahlen verwendet werden.
Das Thema Fehleranalyse wird in Kapitel 8, »Nullstellen berechnen«, Kapitel 9, »Numerische Differenziation«, und Kapitel 11, »Numerische Integration«, nochmals aufgegriffen. Es kann aber im Rahmen dieses Buches nicht so ausführlich behandelt werden, wie es sich vielleicht einige Leser wünschen würden. Wenn Sie sich tiefer in die Problematik der Fehleranalyse einarbeiten möchten, empfehle ich folgende Lehrbücher zur numerischen Mathematik: [Knorrenschild], [Richter] und [Meister].