4 Zahlen 4.1 Beschränktheit von Rechnerzahlen 4.2 Nichtnegative Ganzzahlen

· Zahlsysteme · Zahlwandlung · BCD-Zahlen · ASCII-Zahlen

4.3 Negative Ganzzahlen

· Komplementzahlen · Stellenkomplement · Zahlenkreis

4.4 Festkommazahlen 4.5 Gleitkommazahlen

· Darstellung · Rechenfehler · Schutzziffern · Neutrales Runden · ANSI/IEEE Standard 754-1985 · Relativer Fehler

Im Alltag kennt man verschiedene Zahlklassen:

Natürliche Zahlen, Ganze Zahlen, Rationale Zahlen, Reelle Zahlen, Komplexe Zahlen.

Rechner bieten oft nur kleine Ausschnitte der obigen Zahlen an, dies führt manchmal zu überraschenden Ergebnissen. So liefern traditionell C/C++ Compiler ab und zu einen negativen Absolutwert einer Ganzzahl:

abs (negative Ganzzahl) < 0. Ein weiteres Beispiel für unerwünschte Nebenwirkungen, die bei Mißachtung der Beschränktheit der Zahlbereiche in Rechnern auftreten können, ist: Am 16. 11. 1989 brach das Michigan Terminal System (MTS) der Universität Newcastle upon Tyne zusammen. Fünf Stunden später kollabierten MTS-Installationen an der Ostküste der USA.

Der Grund: Ein Datumsüberlauf. MTS verwaltete das Datum als Tag seit dem 1. März 1900 in einer 16-Bit-Ganzzahlvariablen, der 16. 11. 1989 ist der 32.768-te Tag seit Zählbeginn.

// Beispiel zu undefiniertem Verhalten in C++ #include <iostream> #include <cstdlib> #include <limits> using namespace std; int main () { cout << "abs (" << (int) numeric_limits<signed char>::min () << ") = " << (int) (signed char) abs (numeric_limits<signed char>::min ()) << endl; cout << "abs (" << numeric_limits<short>::min () << ") = " << (short) abs (numeric_limits<short> ::min ()) << endl; cout << "abs (" << numeric_limits<int>::min () << ") = " << abs (numeric_limits<int>::min ()) << endl; cout << "abs (" << numeric_limits<long>::min () << ") = " << labs (numeric_limits<long>::min ()) << endl; cout << "abs (" << numeric_limits<long long>::min () << ") = " << llabs (numeric_limits<long long> ::min () << endl; }//main /* Mit Visual Studio 2010 oder mit g++ -std=c++0x abs (-128) = -128 abs (-32768) = -32768 abs (-2147483648) = -2147483648 abs (-2147483648) = -2147483648 abs (-9223372036854775808) = -9223372036854775808 */

// // Programmierung als Rätsel? // #include <iostream> #include <locale> int main () { float a = float (0.1); float b = float (0.1); float c = 0; // Ländername mirosoft-spezifisch std::cout.imbue (std::locale("german"));

std::cout << " a = " << a << std::endl; std::cout << " b = " << b << std::endl; std::cout << " a*b = " << a*b << std::endl; c += a*b; c -= a*b; std::cout << std::endl << " c = " << c << std::endl; }//main /* Ausgabe a = 0,1 b = 0,1 a*b = 0,01 c = 4,09782e-010 <== Warum? */

// // Rechnen mit double-Werten // Division durch Null // #include <iostream> using std::cout; using std::endl; int main () { double null = 0.0; double eins = 1.0; double zwei = 2.0; double a = eins / null; double b = zwei / a; cout << "a = " << a << endl; cout << "b = " << b << endl; }//main /* Ausgabe: a = 1.#INF b = 0 */

// // Berechnung von π/2 ? // #include <iostream> #include <iomanip> #include <cmath> using namespace std; int main () { double z = 2.0; for (int i = 1; i < 11; ++i) { z *= z; cout << "z = " << setprecision (6) << setw (12) << z << setw (22) << setprecision (18) << atan (z) << endl; } }//main /* z = 4 1.3258176636680326 z = 16 1.5083775167989393 z = 256 1.5668900966629296 z = 65536 1.5707810680058354 z = 4.29497e+009 1.5707963265620659 z = 1.84467e+019 1.5707963267948966 z = 3.40282e+038 1.5707963267948966 z = 1.15792e+077 1.5707963267948966 z = 1.34078e+154 1.5707963267948966 z = 1.#INF 1.5707963267948966 */

Nichtnegative Ganzzahlen: Dezimalzahl ≡ nichtleere Folge von Dezimalziffern = anan-1 . . . a1a0 (n ≥ 0) Beispiele: 3456 1236713 Wert einer Zahl:

Wert (anan-1 . . . a1a0) = ∑ ∗=

n

0i

ii 10a

Beispiel:

Wert (786) = 7 * 102 + 8 * 101 + 6 Verallgemeinerung: Sei B > 1 eine natürliche Zahl, die Zahlen 0, 1, . . ., B–1 nennt man Ziffern im Zahlsystem mit Basis B. Einer Ziffernfolge anan-1 . . . a0 (n ≥ 0) ordnet man den Zahlwert

∑ ∗=

n

0i

ii Ba

zu. Bemerkung: Charakteristisch für eine Ziffer z im

Zahlsystem mit Basis B ist: 0 ≤ z < B.

Beispiele für Zahlen: Basis 10 (Dezimalsystem): 261 = 2*102 + 6*101 + 1*100 Basis 2 (Dualsystem): 1001 = 1*23 + 0*22 + 0*21 + 1*20 Basis 8 (Oktalsystem): 561 = 5*82 + 6*81 + 1*80 Basis 16 (Sedezimalsystem): 3 14 12 = 3*162 + 14*161 + 12*160 = 100410 Bemerkung: Es ist manchmal üblich, die Basis des

benutzten Zahlsystems als tiefgestellte Zahl der Ziffernfolge anzuhängen.

Konventionell werden die Sedezimalziffern mit Werten größer als 9 durch Buchstaben dargestellt: 10 ≡ a oder A 11 ≡ b oder B 12 ≡ c oder C 13 ≡ d oder D 14 ≡ e oder E 15 ≡ f oder F Die übliche Schreibweise der Sedezimalzahl 3 14 12 ist daher: 3ec oder 3EC

Bemerkung: In C und C++ benutzt man zur Darstellung von Sedezimalzahlen das Präfix 0x oder 0X, somit lautet obige Zahl 0x3ec oder 0X3EC. (Das x in "0x" erinnert an das x in hexadezimal.)

Tabelle kleiner Dualzahlen: 0000 = 0 1000 = 8 0001 = 1 1001 = 9 0010 = 2 1010 = 10 0011 = 3 1011 = 11 0100 = 4 1100 = 12 0101 = 5 1101 = 13 0110 = 6 1110 = 14 0111 = 7 1111 = 15 Rechnen im Dualsystem: Additionstafel:

0 + 0 = 0 0 + 1 = 1

1 + 0 = 1 1 + 1 = 10 Beispiel: 1 0 1 0 1 1 1 1 0 0 + 1 1 1 0 0 1 1 0 1 0 1 1 0 0 1 0 1 0 1 1 0

Multiplikationstafel:

0 * 0 = 0 0 * 1 = 0 1 * 0 = 0 1 * 1 = 1 Beispiel: 1 0 1 0 * 1 1 0 0 0 0 0 1 0 1 0 1 0 1 0 1 1 1 1 0 0 Bemerkung: Subtraktionen und Divisionen haben nicht

immer ein Ergebnis im Bereich der nichtnegativen Ganzzahlen.

Arbeitet man mit Zahlen in verschiedenen Zahlsystemen, dann stellt sich die Aufgabe der Zahlwandlung. Die Ziffern einer Zahl im System mit Basis B gewinnt man durch fortgesetzte Division durch B und Restabspaltung.

Zahl = an*Bn + . . . + a1*B1 + a0 ==> Zahl / B = an*Bn-1 + . . . + a1 Rest a0 ==> a0 ist die gewünschte Ziffer.

Beispiel: Wandlung von 29 in Dualdarstellung

29 / 2 = 14 Rest 1 14 / 2 = 7 Rest 0 7 / 2 = 3 Rest 1

3 / 2 = 1 Rest 1 1 / 2 = 0 Rest 1 damit 2910 = 111012 Den Wert einer Ziffernfolge gewinnt man mittels des Horner-Schemas an*Bn + an-1*Bn-1 + . . . + a0 = ((...((an * B + an-1) * B + an-2)...) * B + a1) * B + a0 Beispiel: 210123 = (((2 * 3 + 1) * 3 + 0) * 3 + 1) * 3 + 2 = (21 * 3 + 1) * 3 + 2 = 19410 Bemerkung: Die Wandlungsrechnungen sind system-

neutral, sie können sowohl im Ursprungs- als auch im Zielsystem durchgeführt werden.

Neben dem Divisionsalgorithmus zur Wandlung existiert auch ein Multiplikationsalgorithmus. Beispiel: Wandlung von 29 in Dualdarstellung. Start: 64 2 * 29 = 58 < 64 ==> 0 2 * 58 = 116 − 64 = 52 ==> 1 2 * 52 = 104 − 64 = 40 ==> 1 2 * 40 = 80 − 64 = 16 ==> 1 2 * 16 = 32 < 64 ==> 0 2 * 32 = 64 − 64 = 0 ==> 1 damit 2910 = 0111012 Bemerkung: Dieser Algorithmus produziert die Bit der

Dualdarstellung von links nach rechts. Gleichzeitig kann man angeben, wie viele Bit in die Dualdarstellung eingehen sollen.

Aus technischen Gründen wird in heutigen Digital-rechnern die Information in Form von Bitketten dar-gestellt; dies bedeutet aber nicht zwangsläufig, daß im Dualsystem gerechnet wird. BCD – Codierung der Dezimalziffern:

Ziffer Code 0 0000 1 0001 2 0010 3 0011 4 0100 5 0101 6 0110 7 0111 8 1000 9 1001 Beispiel: 693 = 011010010011 Bemerkungen:

(i) BCD steht für Binary Coded Decimal. (ii) BCD-Zahlen zeigen das gleiche Rundungsver-

halten wie Alltagsrechnungen, daher sind sie in der Finanzwelt beliebt, z. B. bei der Berechnung des Zinseszins.

Beispiele anderer Codierungen von Dezimalziffern: (a) Stibitzcodierung (auch Exzeß-3 Codierung): Ziffer Code 0 0011 1 0100 2 0101 3 0110 4 0111 5 1000 6 1001 7 1010 8 1011 9 1100 (b) ASCII-Codierung: Ziffer Code 0 48 1 49 2 50 3 51 4 52 5 53 6 54 7 55 8 56 9 57

Sowohl in der Stibitzcodierung als auch in der ASCII-Codierung kann man für arithmetische Operationen das Rechenwerk für Dualzahlen nutzen. Beispiel: Addition zweier Zahlen in ASCII-Codierung

ohne eine Zahlwandlung durchzuführen, die Addition erfolgt im Zahlsystem mit Basis 256.

Addenden Z1: 3826 Z2: 2645 Darstellung als Bytefolge: ASCII-Z1: 51 56 50 54 ASCII-Z2: 50 54 52 53 Summe S: 101 110 102 107 Addition des magischen Werts: 150 150 150 150 252 4 253 1 Subtraktion des Korrekturwerts: 246 0 246 0 6 4 7 1 Addition des Grundversatzes: 48 48 48 48 Ergebnis: 54 52 55 49 Dezimalzahl: 6471

Negative Ganzzahlen: In der Mathematik führt man die negativen Zahlen ein, damit die Subtraktion immer ausführbar ist. Fordert man die "unbeschränkte" Subtraktion für darstellungsbeschränkte Zahlen, dann ergibt sich in natürlicher Weise der Begriff der Komplementzahl. Beispiel: Zahlen mit genau 4 Dezimalziffern Beispielrechnung: 0 0 0 0 – 2 6 1 3 7 3 8 7 Bemerkung: Die Zahl 7387 nennt man das 10–Kom-

plement der Zahl 2613 in der Zahlen-menge der 4–ziffrigen Dezimalzahlen; der Wert von 7387 ist –2613, denn –2613 = 0 – 2613 = 7387.

Verallgemeinerung: Definition: Im Bereich der n-ziffrigen Zahlen im

Zahlsystem mit Basis B nennt man zwei Zahlen a und b Komplementzahlen, falls a + b = Bn gilt.

Man kennt noch einen zweiten Komplementbegriff, das Stellenkomplement. Definition: Im Bereich der n-ziffrigen Zahlen im

Zahlsystem mit Basis B nennt man eine Zahl a = an-1an-2 . . . a0 das Stellenkomplement der Zahl b = bn-1bn-2 . . . b0, falls gilt: ai + bi = B – 1 für alle i mit 0 ≤ i < n.

Bemerkung:

(i) Jede Zahl bis auf 0 hat genau eine Komplement-zahl.

(ii) Das Stellenkomplement bildet man ziffernweise. (iii) Die Komplementzahl läßt sich über das

Stellenkomplement bestimmen, denn: a + b = (Bn – 1) + 1 ==> a = ((Bn – 1) – b) + 1

Verfahren zur Bildung eines Komplements: 1. Bildung des Stellenkomplements. 2. Addition von 1 zum Stellenkomplement.

Beispiel 1: Bildung des Komplements von 3862 im 4-ziffrigen Dezimalsystem:

1. Bildung des Stellenkomplements: 9999 – 3862 6137 2. Addition von 1: 6138 damit Komplement (3862) = 6138 Beispiel 2: Komplementzahlen im Dualsystem Annahme: Zahlbreite = 9 Beispiel einer Dualzahl: 1 0 0 1 0 0 1 0 0 Stellenkomplement: 0 1 1 0 1 1 0 1 1 Addition von 1: 0 1 1 0 1 1 0 1 1

+ 0 0 0 0 0 0 0 0 1 0 1 1 0 1 1 1 0 0 damit Komplement (100100100) = 011011100 Bemerkung: Bei der Bildung der Komplementzahl im

Dualsystem ist die Addition von 1 die aufwendige Operation.

Definition der negativen Ganzzahlen:

Sei B > 1 die Basis, sei n > 1 die Ziffernzahl, eine Zahl an-1an-2 ... a1a0 ist negativ, falls an-1 > ⎣(B–1) / 2⎦ ist, sonst positiv.

Beispiel: B = 2, n = 5 positive Zahlen: 00000 . . . 01111 negative Zahlen: 10000 . . . 11111 Zahlwert: Wert positiver Zahlen:

∑ ∗−

=

1n

0i

ii Ba

Wert negativer Zahlen:

n1n

0i

ii BBa −∑ ∗

−

=

Drei Darstellungsarten für Dualzahlen: Bitfolge Zweier- Einer- Vorzeichen

komplement komplement und Betrag

0111 7 7 7 0110 6 6 6 0101 5 5 5 0100 4 4 4 0011 3 3 3 0010 2 2 2 0001 1 1 1 0000 0 0 0 1111 -1 -0 -7 1110 -2 -1 -6 1101 -3 -2 -5 1100 -4 -3 -4 1011 -5 -4 -3 1010 -6 -5 -2 1001 -7 -6 -1 1000 -8 -7 -0

Der Zahlenkreis: Übertragsgrenze

1100 -4 4 0100

Überlaufgrenze 10001001

-7 -8 7

0111

1010

-6 6

0110

1011 -5 5

0101

-3 3 1101 0011

-2

1110

2

0010 -10 1

1111 00010000

Bemerkung: Die Zahlen im Kreisinnern zeigen die

Wertbelegung bei Benutzung der Zweier-komplementdarstellung für Ganzzahlen.

Positive Festkommazahlen: Beispiel einer Festkommazahl im Dualsystem: 1 0 1 , 1 0 1 1 2 = 1 * 22 + 0 * 21 + 1 * 20 + 1 * 2–1 + 0 * 2–2 + 1 * 2–3 + 1 * 2–4 = 5,687510 Allgemeine Interpretation im B-Zahlsystem: bnbn–1 . . . b1b0 , b–1b–2 . . . b–m

∑ ∑ ∗+∗==

−

−=

−−

n

0i

m

1i

ii

ii BbBb

Bemerkungen: (i) Zur Darstellung von Zahlen mit festem Zahlkomma

verwendet man Ganzzahlen; das Zahlkomma merkt man sich anderswo.

(ii) Die Verwendung von Festkommazahlen erfordert für jede Rechnung eine rechnungsspezifische Kenntnis der auftretenden Zwischenwerte, um eine sinnvolle Wahl zwischen Genauigkeit und Größe des Zahlbereichs treffen zu können.

(iii) Bei Zahlwandlungen werden der Ganzteil und der Bruchteil einer Zahl getrennt gewandelt.

Bei der Wandlung von Festkommazahlen wandelt man getrennt den Vorkommateil und den Nachkommateil. Beispiel zur Wandlung des Nachkommateils. Beispiel: 0,3 0,3 * 2 = 0,6 ==> 0 0,6 * 2 = 1,2 ==> 1 0,2 * 2 = 0,4 ==> 0 0,4 * 2 = 0,8 ==> 0 0,8 * 2 = 1,6 ==> 1 0,6 * 2 = . . . Ab hier wird die Rechnung periodisch, die Periode hat die Länge 4, die Vorperiode hat die Länge 1. Man erhält für die Dezimalzahl D = 0,3 den Dualbruch B = 0,010011001100110011001100110011001 . . . Begrenzt man die Länge von B auf 12 Nachkommastellen erhält man die genäherte Darstellung B = 0,010011001101 Bemerkung: Dieser Algorithmus liefert die Bit der

Dualdarstellung eines echten Dezimalbruchs von links nach rechts.

Gleitkommazahlen: Dezimalzahlen sind oft unübersichtlich, z. B. a = 0,000000000000000000000238 b = 2380000000000000000000000 übersichtlicher ist die Exponentenschreibweise: a = 2,38 ∗ 10−23 b = 2,38 ∗ 10+24 Bei fester Basis (hier: 10) kann man auf die explizite Angabe der Basis verzichten, eine Gleitkommazahl läßt sich dann als Paar ganzer Zahlen (Signifikand, Exponent) darstellen. a = ( 23800, −27 ) b = ( 23800, +20 ) Das Kennzeichen von Zahlen auf Rechnern ist ihre beschränkte Ziffernzahl, daher sind die Ergebnisse arithmetischer Operationen oft nur angenähert oder überhaupt nicht darstellbar. Seien a und b Rechner-Gleitkommazahlen, sei ° eine arithmetische Operation, dann gilt:

Berechnetes (a ° b) = (a ° b) ∗ (1 + err), wobei err eine kleine Zahl ist, deren Absolutbetrag sich aus den benutzten Algorithmen abschätzen läßt.

Für die folgenden Beispiele mögen die Annahmen gelten: Signifikandendarstellung: Vorzeichen, 5 Dezimalziffern Exponentendarstellung: Vorzeichen, 2 Dezimalziffern Das benutzte Rechenwerk verfüge auch nur über 5 Ziffern für den Signifikanden und 2 für den Exponenten, nicht darstellbare niederwertige Ziffern werden abgeschnitten. Beispiel: ( +23456, +7 ) + ( +28282, +4 ) = ( +23456, +7 ) + ( +00028, +7 ) = ( +23484, +7 ) Für Gleitkommazahlen gelten nicht die üblichen algebraischen Gesetze, wie Assoziativgesetze und Distributivgesetze. Hier ein Beispiel für die Nicht-gültigkeit des Assoziativgesetzes der Addition. u = ( +11113, +0 ) v = ( –11111, +0 ) w = ( +00075, –1 ) u + v = ( +00002, +0 ) v + w = ( –11104, +0 ) (u + v) + w = ( +00095, –1 ) u + (v + w) = ( +00009, +0 ) ≠

Bei Gleitkommarechnungen bestimmt das gewählte Rechenverfahren die Größe des Rundungsfehlers, ein Beispiel: a = ( +1, −99) b = ( +2, −89) c = a d = ( +8, −89) y = ( +1, +11) dann

)5−,66666()89,18()89,12(

dycbya

+=−+−+

=+∗+∗

)0+,1()99,1()99,1(

ydc

yba

dycbya

+=−+−+

=+

+=

+∗+∗

Bemerkung: Ein C-Programm lieferte:

Fall 1: 0,6666666666666667 Fall 2: 0,66666666666666666 wobei nur Operanden im Format double benutzt wurden.

Exponentenunterlauf: a = ( +5, −80 ) b = ( +2, +90 ) c := a / b ist nicht darstellbar, ein Näherungswert für c ist ( +0, +0 ) Exponentenüberlauf: a = ( +3, +80 ) b = ( +4, +90 ) c := a ∗ b ist nicht darstellbar. Der beste darstellbare Näherungswert für c wäre: c = ( +99999, +99 ), dieser Näherungswert wird aus ersichtlichen Gründen fast nie verwendet.

Gleitkommazahlen in Binärdarstellung: Beispiele: 101101011 ∗ 2101

,0001011011 ∗ 210001 101,101011 ∗ 21011 Bemerkung: Die Darstellung von Gleitkommazahlen ist

nicht eindeutig. Oft wählt man daher eine feste Position für das Zahlkomma, z. B. nach der ersten Nichtnullziffer. In diesem Fall spricht man von normalisierter Darstellung.

Allgemeine Darstellung bei Signifikandenlänge n und Exponentenlänge m: m21 E...EE

n4321 2B...BBB,B ±∗± Bemerkungen:

(i) Statt 2 wählt man manchmal auch 8 oder 16 als Basis.

(ii) Nach Möglichkeit speichert man nur norma-lisierte Gleitpunktzahlen ab. Im Falle der Basis 2 kann man die Speicherung eines Bit sparen.

(iii) Den Exponenten speichert man oft in der Form einer Charakteristik ab: Charakteristik = Exponent + Versatz.

Schutzziffern: Bei der Durchführung arithmetischer Operationen benutzt man zur Erhöhung der Rechengenauigkeit oft zusätzliche Stellen, sogenannte Schutzziffern. Beispiel: 1,0000 – 0,99999 = 10-5 Berechnung ohne Schutzziffern:

( +00001, +00 ) − ( +99999, −05 ) = ( +10000, −04 ) − ( +09999, −04 ) = ( +00001, −04 ) = 10-4

Berechnung mit einer Schutzziffer:

( +00001 , +00 ) − ( +99999 , −05 ) = ( +10000 0, −05 ) − ( +09999 9, −05 ) = ( + 0000 1, −05 ) = 10-5

Bemerkung: Schutzziffern erlauben die korrekte

Implementation des folgenden Sachver-halts: sind a und b Gleitkommazahlen mit 1/2 ≤ a/b ≤ 2, dann ist die Differenz a − b exakt darstellbar, falls kein Unterlauf eintritt.

Runden: Man kennt drei Grundarten des Rundens: aufrunden, abrunden, zur "nächsten" Zahl runden. Beispiele: 10,8 ==> 11 aufrunden 10,8 ==> 10 abrunden 10,8 ==> 11 runden zur "nächsten" Zahl 10,5 nun existieren zwei Kandidaten als nächste Zahl, nämlich 10 und 11. Um ein sinnvolles Rundungsverfahren im Fall des Rundens zur nächsten Zahl zu finden, betrachtet man ein größeres Intervall: 10,1 bis 10,4 ==> 10 10,5 ==> ? 10,6 bis 10,9 ==> 11 11 11,1 bis 11,4 ==> 11 11,5 ==> ? 11,6 bis 11,9 ==> 12 Um ein neutrales Rundungsverfahren zu erhalten, sollte man die Fälle 10,5 und 11,5 unterschiedlich behandeln. Eine Möglichkeit besteht darin, daß im Falle zweier nächster Zahlen jeweils zur geraden Zahl gerundet wird.

Beispiel zum Rundungsverhalten: Man betrachte ein Zahlsystem mit Basis 10 und Stellenzahl 3. Die Folge x0, x1, x2, . . . sei definiert durch: y = –0,555 x0 = 1,00 x1 = (x0 – y) + y x2 = (x1 – y) + y M xn = (xn–1 – y) + y M Fall 1: Im Zweifelsfall aufrunden: x0 = 1,00 x1 = 1,56 – 0,555 = 1,01 x2 = 1,02 M x845 = 9,45 M xn = 9,45 für n ≥ 845 denn 9,45 + 0,555 = 10,0 und 10,0 – 0,555 = 9,45

Fall 2: Immer zur nächsten geraden Zahl runden: x0 = 1,00 x1 = (1,00 + 0,555) – 0,555 = 1,56 – 0,555 (= 1,005) = 1,00 x2 = 1,00 M xn = 1,00 für n ≥ 0 Fall 3: Immer zur nächsten ungeraden Zahl runden: x0 = 1,00 x1 = (1,00 + 0,555) – 0,555 = 1,55 – 0,555 = 0,995 x2 = (0,995 + 0,555) – 0,555 = 1,55 – 0,555 = 0,995 M xn = 0,995 für n ≥ 1 Bemerkung: In diesem Beispiel liefert Fall 2 das beste

Ergebnis. Im IEEE-Standard wird "Runden zum 'nächsten geraden' Wert" als Normalfall betrachtet.

Bemerkungen zum ANSI/IEEE Standard 754–1985: "IEEE Standard for Binary Floating-Point Arithmetic" Nachdruck in Sigplan Notices 22, 2, pp 9–25 (1987). Anmerkung: Am 12. Juni 2008 wurde ein neuer Standard

IEEE Std 754-2008 verabschiedet. Er umfaßt viele Erweiterungen zum Standard von 1985; die Grundstruktur ist aber gleich geblieben.

(i) Vier Genauigkeitsstufen: single, single extended, double, double extended (ii) Darstellungsformat: Vorzeichen Charakteristik Signifikand, hier für "single precision" 1 Bit 8 Bit 23 Bit

S C V

Normalinterpretation: (–1)V * 1.S * 2C–127 Beispiel:

1 10000101 00110000000000000000000 ≡ –1 * 2133–127 * 1.1875 = – 76 Bemerkung: Die 1 vor dem Binärpunkt wird nicht

gespeichert.

(iii) Sonderformate (nur für "single precision" erläutert) V C S 1 Bit 8 Bit 23 Bit +Null: 0 0 ... 0 00 ... 0 –Null: 1 0 ... 0 00 ... 0 +∞: 0 1 ... 1 00 ... 0 –∞: 1 1 ... 1 00 ... 0 Nichtzahlen (positive und negative) NaN: 0 1 ... 1 11 ... 11 M M 0 1 ... 1 00 ... 01 1 1 ... 1 00 ... 01 M M 1 1 ... 1 11 ... 11 subnormale Zahlen (positive und negative) 0 0 ... 0 11 ... 11 M M 0 0 ... 0 00 ... 01 1 0 ... 0 00 ... 01 M M 1 0 ... 0 11 ... 11

(iv) Größenfestlegung für Formate:

single single extended

double double extended

Genauigkeit in Bit

24 ≥ 32 53 ≥ 64

Größter Exponent

127 ≥1023 1023 ≥ 16383

Kleinster Exponent

–126 ≤ –1022 –1022 ≤ –16382

Versatz 127 nicht spe-zifiziert

1023 nicht spe- zifiziert

Das "single"–Format ist immer zu implementieren. (v) Subnormale Zahlen dienen dazu, einen gleitenden

Übergang zur Null zu erreichen, außerdem bewahren sie die Identität:

x = y <==> x – y = 0 Beispiel: 2–64 * 2–66 = 2–130 2–130 dargestellt als subnormale Zahl

0 00000000 00010000000000000000000

(vi) Runden:

Der IEEE Standard von 1985 kennt vier Rundungsarten:

Runden nach Null, Runden nach +∞, Runden nach –∞, Runden zum nächsten Wert (im Zweifelsfall zum geradzahligen).

Beispiel bei Rechnung mit 4 Bit Genauigkeit: – 5 * 10 = – 50 ==> zu berechnen: – 1.010 * 22 * 1.010 * 23 ==> Signifikandenprodukt: – 01100100 ==> Ausrichten: – 1100 | 1000 Runden nach Null: – 1100 Runden nach +∞: – 1100 Runden nach –∞: – 1101 Runden zum nächsten Wert: – 1100 Ergebnis bei Runden nach Null: –1.100 * 25 = –48 Runden nach +∞: –1.100 * 25 = –48 Runden nach –∞: –1.101 * 25 = –52 Runden zum nächsten Wert: –1.100 * 25 = –48 Die verschiedenen Rundungsarten gestatten die Imple-mentation einer Intervall-Arithmetik.

(vii) Bei der Implementation der Rechenoperationen

erwartet der IEEE Standard drei Hilfsbit: Guard Bit,

Round Bit, Sticky Bit. Erläuternde Beispiele: 6 Bit Genauigkeit, Exponentendifferenz 5: 1.10011 + 0.00001 10001 1.10100

Zur korrekten Rundung des Ergebnisses benötigt man das Wissen, daß jenseits des ersten nicht in der Addition berücksichtigten Bit noch ein weiteres Nichtnullbit existiert (codiert im "sticky bit"). Das korrekte Resultat bei Rundung zum nächsten Wert ist 1.10101.

6 Bit Genauigkeit, Exponentendifferenz 2: 1.11011 + 0.01010 01 10.00101 Ergebnis bei Rundung zum nächsten Wert: 10.0011

6 Bit Genauigkeit, Exponentendifferenz 6: 1.00000 – 0.00000 101110 ==> 1.00000 + 1.11111 010010 0.11111 Gerundetes Resultat ist: 0.111111 (viii) Es wird eine Restfunktion REM für Gleitpunkt-

zahlen definiert durch: x = [ x/y] * y + (x REM y) mit | x/y - [x/y] | ≤ 1/2 Im Konfliktfall wird zur nächsten geraden Ganzzahl gerundet. Der Rest ist immer exakt. Die Restfunktion ist sinnvoll bei der Berechnung trigonometrischer Funktionen. (ix) Für Nichtzahlen und unendlich werden die

Rechenregeln sinnvoll ergänzt, z.B. NaN + Zahl = NaN Zahl / 0 = ± ∞, falls keine "Exception" ausgelöst wird; das Vorzeichen von ∞ ist das algebraisch korrekte.

Relativer Fehler: Man betrachte ein Zahlensystem mit Basis B und Signifikandenlänge p. Satz: Der relative Fehler bei der Ausführung einer

Addition kann bis B − 1 reichen. Beweis: Seien x = 1,000 . . . 000 y = − 0,aaa . . . aaaa mit a = B − 1 p Ziffern exakte Summe = B-p berechnete Summe = B-p+1 relativer Fehler = (B-p+1 − B-p) / B-p = B − 1 Bemerkung: Obiger Satz zeigt, daß bei Gleitkomma-

rechnungen im Dualsystem in der Tendenz die kleinsten relativen Fehler begangen werden.