Gleitkomma-Analyse

Algorithmen für den Praxis-Test

Diese Seite demonstriert, wie man das Verhalten von Programmen gegenüber Gleitkomma-Zahlen (oder Zahlen allgemein) analysieren kann. Aus dem Verhalten der Programme kann ziemlich genau auf den Typ der verwendeten Gleitkomma-Variablen geschlossen werden. Das wird am Live-Beispiel ihres Browsers demonstriert.
IEEE-754 IEEE-754 Das Standardformat für Gleitkomma-Zahlen
Zahlenbereich Analyse der größten darstellbaren Zahl
Kalkulation Test des Zahlen-Bereichs mit einem Standard Kalkulations-Programm
Genauigkeit Welche Differenz wird gerade noch erkannt ?
Kalkulation Test der Genauigkeit mit einem Standard Kalkulations-Programm
Grundlagen Darstellung von Gleitkomma-Zahlern mit Mantisse und Exponent

Zahlenbereich - Die größte darstellbare Zahl
Hier wird empirisch (Live !) die größte Zahl ermittelt, welche die Javascript-Version ihres Browsers darstellen kann.
z(max) = 0
(ermittelt in 0 ms für 0 Schritte)
Aus der Größe der maximal darstellbaren Zahl kann die Speicherbreite des binären Exponenten ermittelt werden. Vergleichen sie das Live-Ergebnis mit gängigen Darstellungsformaten.
Unten die Formel für die Speicherbreite des Exponenten.

Ergebnis:

Breite(Exponent) = 0 Bit
Algorithmus:
► Vergrößern sie eine Zahl zmax=1 so lange, wie das ohne Fehler möglich ist. In Javascript wird eine Variable =Infinity gesetzt, noch bevor ein Fehler auftritt - Das wird daher zusätzlich überprüft.)
► Nach erfolgreichen Schritten wird das Ergebnis vorgemerkt, d.h. die Variable zmax wird auf den neuen größeren Wert gesetzt.
► Nach erfolglosen Schritten wird die Schrittweite f jeweils halbiert.
► Das Ziel ist erreicht, wenn die Schrittweite f=0 wird, oder wenn ein Sicherheitszähler (gegen Endlos-Schleifen, hier limit ) abläuft.

Dieser Algorithmus wird in Javascript vorgestellt, funktioniert jedoch in jedem einschlägigen Programm, z.B. in → Kalkulations-Programmen, in VBA, C++, Java, usw.
• Das Javascript-Programm ist im Quelltext dieser Webseite enthalten und wird von ihrem Browser Live ausgeführt.
function try_zmax() {
var zmax=1;
var limit=10000;
var test=0;
var f=1;
var run=true;
var i=0;
while((i<limit) && run) {
i++;
test=try_next_max(zmax,(1+f));
if(test>zmax) {zmax=test;}
else {f=f/2;}
if(f<=0) {run=false;}
}
// Hier Ausgabe von zmax und i
}
function try_next_max(t,f) {
try { t=t*f; }
catch (e) { t=0; }
if(t=="Infinity") {t=0;}
return t
}
Berechnung der Anzahl von Bits für den Exponenten aus der größten darstellbaren Zahl:
exp_bits = ln(2 * ( ln(zmax) / ln(2) ) ) / ln(2)
Wenn sie diejenige Zahl mit dem größten Betrag, jedoch mit negativem Vorzeichen ermitteln wollen, können sie dazu den gleiche Algorithmus mit einer kleinen Modifikation verwenden. Das bringt allerdings keine neuen Erkenntnisse, denn der Zahlenbereich ist fast symmetrisch.

Zahlenbereich - Test mit Kalkulations-Programmen
Mit jedem Standard Kalkulations-Programm (LibreOffice, OpenOffice, MS-Excel, ...) kann man die Grenze des verwendbaren Zahleb-Bereichs leicht selbst demonstrieren.
• In Spalte A werden Test-Zahlen n berechnet, die in jeder Zeile größer werden (hier um den Faktor 10).
Sie brauchen die Formel nur 1mal einzugeben und können dann die Zelle A3 nach unten bis Zeile 320 ausfüllen. 		Demonstration des maximalen Werte-Bereichs:
   A
1n
21
3=A2*10
4=A3*10
...
320=A319*10

Ergebnis

● Die Berechnung funktioniert bis Zeile 310
● Der von gängigen Kalkulations-Programmen verwendete → Typ double bietet einem binären 10 Bit Exponenten. Damit ist der Wert der größten darstellbaren Zahl mit ca. 1E+308.3 festgelegt.
Sie können die Grenze optional auch genauer berechnen:
Beginnen sie z.B. bereits in Zelle A2 mit einer großen Zahl und vergrößern sie diese in den folgenden Zeilen um einen kleineren Faktor, z.B. =A2*2

Genauigkeit - Welche Differenz ist gerade noch unterscheidbar ?
Hier wird empirisch (Live !) ermittelt, welche kleine Differenz von 2 sehr ähnlichen Zahlen die Javascript-Version ihres Browsers noch erkennen kann.
dif(min) = 0
(ermittelt in 0 ms für 0 Schritte)
Berechnung der Anzahl von Bits für die Mantisse aus der Auflösung (minimalen relativen Differenz zwischen 2 Zahlen):
mant_bits = -ln(dif_min) / ln(2)
Mit einem Trick (→ Hidden Bit) kann man in der PC-Praxis 1 Bit der Mantisse ohne Verlust der Genauigkeit einsparen.

Ergebnis:

Breite(Mantisse) = 0 Bit
Algorithmus:
► Die Variable g wird auf die anfängliche Schrittweite g=0.5 gesetzt.
► Die anfängliche Differenz wird auf f=1 gesetzt.
► In einer Schleife wird die Differenz dif zwischen den beiden 'ähnlichen' Zahlen z1=1 und z2=1+f untersucht.
► Wenn dif>0, dann wird f mit der Schrittweite g verkleinert, und die 'erfolgreiche' Differenz wird in zdif gespeichert.
► Wenn dif<=0, dann wird f wieder vergrößert, jedoch nur bis maximal zur letzten 'erfolgreichen' Differenz zdif
► Wenn nach diesen Regeln keine Änderung von f mehr möglich ist, wird die Schleife abgebrochen.

• Das Javascript-Programm ist im Quelltext dieser Webseite enthalten und wird von ihrem Browser Live ausgeführt.
function try_zdif() {
var zdif=1;
var limit=500; var i=0;
var f=1; var g=0.5;
var z2=1; var dif=0;
var run=true;
while((i<limit) && run) {
i++;
z2=1+f;
dif=z2-1;
if(dif>0) {
zdif=dif;
f=f*g;
}
else {
g=g+0.01;
if(g>=1) {run=false;}
f=zdif*g;
}
}
// Hier Ausgabe von zdif und i
}

Genauigkeit - Test mit Kalkulations-Programmen
Mit jedem Standard Kalkulations-Programm (LibreOffice, OpenOffice, MS-Excel, ...) kann man die Grenze der erreichbaren Genauigkeit leicht selbst demonstrieren.
• In Spalte A werden Test-Zahlen n berechnet, die in jeder Zeile größer werden (hier um den Faktor 10).
• In Spalte B wird die Zahl +1 zur Test-Zahl n addiert.
• In Spalte C wird die Differenz der beiden Zahlen berechnet.
Sie brauchen jede Formel nur 1mal einzugeben und können dann die Zellen A3 bzw. B2 und C2 nach unten bis Zeile 22 ausfüllen. 		Demonstration der maximalen Genauigkeit:
   ABC
1nn+1(n+1)-1
21=A2+1=B2-A2
3=A2*10=A3+1=B3-A3
4=A3*10=A4+1=B4-A4
...
22=A21*10=A22+1=B22-A22

Ergebnis

● Das in Spalte C berechnete Ergebnis ist - wie erwartet - die Zahl 1
● Wenn jedoch die Test-Zahlen groß genug werden, dann ist die Unterscheidung zwischen n und n+1 nicht mehr möglich: Von Zeile 18 abwärts ist das Ergebnis die Zahl 0
Das ist kein Fehler des Kalkulations-Programms sondern die Grenze der mit einer Mantisse von 52+1 Bit (→ Typ double) erreichbaren Genauigkeit.
Sie können die Grenze optional auch genauer berechnen:
Wenn sie den Faktor *10 in Spalte A durch *2 ersetzen, dann wird die Grenze in Zeile 51 erreicht.

Zum Inhaltsverzeichnis Homepage von PS-Trainer   >   Standards   >   Zahlensysteme   >   IEEE-754