Gleitkommazahlen verstehen (Teil 0)

Hallo Khabrovites. Ich habe das Thema Gleitkommaregister schon lange geliebt. Ich war immer besorgt darüber, wie die Ausgabe auf dem Bildschirm usw. Ich erinnere mich, dass ich vor langer Zeit an der Universität meine Klasse von Gleitkommazahlen mit 512 Bit implementiert habe. Das einzige, was ich in keiner Weise realisieren konnte, war die Ausgabe auf dem Bildschirm.

Sobald ich Freizeit hatte, nahm ich die alte auf. Ich habe mir ein Notizbuch besorgt und los geht's. Ich wollte selbst an alles denken und nur gelegentlich auf den IEEE 754-Standard schauen.
Und das ist es, was daraus wurde. Für Interessierte bitte ich um Katze.

Um diesen Artikel zu beherrschen, müssen Sie Folgendes wissen: Was ist ein bisschen, ein binäres System, Arithmetik auf der Ebene des Wissens über negative Grade. Der Artikel hat keinen Einfluss auf die technischen Details der Implementierung auf Prozessorebene sowie auf normalisierte und denormalisierte Zahlen. Es wird mehr Wert darauf gelegt, eine Zahl in eine binäre Form umzuwandeln und umgekehrt sowie zu erklären, wie Gleitkommazahlen im Allgemeinen in Form von Bits gespeichert werden.

Gleitkommazahlen sind ein sehr leistungsfähiges Werkzeug, das Sie korrekt verwenden müssen. Sie sind nicht so alltäglich wie ganzzahlige Register, aber sie sind auch nicht so komplex, wenn sie intelligent und langsam durchdrungen werden.

Im heutigen Artikel werde ich 32-Bit-Register als Beispiel verwenden. Zahlen mit doppelter Genauigkeit (64-Bit) funktionieren genau nach der gleichen Logik.

Lassen Sie uns zunächst darüber sprechen, wie Gleitkommazahlen gespeichert werden. Die ältesten 31 Bits sind signifikant. Ein einzelnes bedeutet, dass die Zahl negativ ist und Null das Gegenteil ist. Als nächstes kommen 8 Bits des Exponenten. Diese 8 Bits sind die übliche vorzeichenlose Nummer. Und ganz am Ende sind 23 Bits der Mantisse. Der Einfachheit halber bezeichnen wir das Vorzeichen als S, den Exponenten als E und die Mantisse seltsamerweise als M.

Wir bekommen die allgemeine Formel $$$(- 1) ^ s \ times M \ times 2 ^ {E-127}$

Die Mantisse wird als ein implizites Einzelbit betrachtet. Das heißt, die Mantisse wird 24 Bit sein, aber da das höchste 23. Bit immer eins ist, können Sie es nicht aufschreiben. Diese „Einschränkung“ gibt uns die Einzigartigkeit, eine beliebige Zahl darzustellen.

Mantisse ist eine gewöhnliche Binärzahl, aber im Gegensatz zu ganzen Zahlen ist das höchstwertige Bit 2 ^ 0 Grad und dann in abnehmenden Graden. Hier bietet sich der Aussteller an. Abhängig von seinem Wert nimmt die Leistung des hohen Bits zwei zu oder ab. Das ist das ganze Genie dieser Idee.

Versuchen wir dies anhand eines guten Beispiels zu zeigen:

Stellen Sie sich die Zahl 3.625 in binärer Form vor. Zuerst teilen wir diese Zahl in Zweierpotenzen. $$$3.625 = 2 + 1 + 0.5 + 0.125 = 1 \ mal 2 ^ 1 + 1 \ mal 2 ^ 0 + 1 \ mal 2 ^ {-1} + 0 \ mal 2 ^ {-2} + 1 \ mal 2 ^ { -3}$

Der Grad der älteren zwei ist gleich eins. E - 127 = 1. E = 128.

0 1.000.000 1.101.000.000.000.000.000.000

Das ist alles unsere Nummer.

Versuchen wir es auch in die entgegengesetzte Richtung. Angenommen, wir haben 32 Bit, beliebige 32 Bit.

0 10000100 (1) 11011100101000000000000

Das gleiche implizite Bit höherer Ordnung ist in Klammern angegeben.

Berechnen Sie zunächst den Exponenten. E = 132. Dementsprechend ist der Grad der beiden Älteren gleich 5. Insgesamt haben wir die folgende Zahl:
$$$2 ^ 5 + 2 ^ 4 + 2 ^ 3 + 2 ^ 1 + 2 ^ 0 + 2 ^ {-1} + 2 ^ {-4} + 2 ^ {-6} =$
$$$= 32 + 16 + 8 + 2 + 1 + 0,5 + 0,0625 + 0,015625 = 59,578125$

Es ist leicht zu erraten, dass wir nur einen Bereich von 24 Grad zwei speichern können. Wenn sich zwei Zahlen exponentiell um mehr als 24 unterscheiden, bleibt die Zahl beim Hinzufügen gleich der größeren unter ihnen.

Für eine bequeme Konvertierung habe ich ein kleines Programm in C hochgeladen.

#include <stdio.h> union IntFloat { unsigned int integerValue; float floatValue; }; void printBits(unsigned int x) { int i; for (i = 31; i >= 0; i--) { if ((x & ((unsigned int)1 << i)) != 0) { printf("1"); } else { printf("0"); } if (i == 31) { printf(" "); } if (i == 23) { printf(" "); } } printf("\n"); } int main() { union IntFloat b0; b0.floatValue = 59.578125; printBits(b0.integerValue); b0.integerValue = 0b01000010011011100101000000000000; printf("%f\n", b0.floatValue); return 0; } 

Der Gitterschritt ist die minimale Differenz zwischen zwei benachbarten Gleitkommazahlen. Wenn wir die Folge von Bits einer solchen Zahl als reguläre Ganzzahl darstellen, unterscheidet sich die benachbarte Gleitkommazahl in Bits als Ganzzahl pro Einheit.

Es kann anders ausgedrückt werden. Zwei benachbarte Gleitkommazahlen unterscheiden sich um 2 ^ (E - 127 - 23). Das heißt, um eine Differenz, die dem Wert des niedrigstwertigen Bits entspricht.

Als Beweis können Sie main im Code ändern und erneut kompilieren.

 union IntFloat b0, b1, b2; b0.floatValue = 59.578125F; b1.integerValue = b0.integerValue + 1; b2.floatValue = b1.floatValue - b0.floatValue; printBits(b0.integerValue); printBits(b1.integerValue); printBits(b2.integerValue); printf("%f\n", b0.floatValue); printf("%f\n", b1.floatValue); printf("%f\n", b2.floatValue); short exp1 = 0b10000100; short exp2 =0b01101101; /*  ,       */ b0.integerValue = 0b01000010011111111111111111111111; b1.integerValue = b0.integerValue + 1; b2.floatValue = b1.floatValue - b0.floatValue; printBits(b0.integerValue); printBits(b1.integerValue); printBits(b2.integerValue); printf("%f\n", b0.floatValue); printf("%f\n", b1.floatValue); printf("%f\n", b2.floatValue); /*   */ printf("%d %d\n", exp1, exp2); 

Ich denke für heute kann man abrunden, sonst fällt es zu lange aus. Das nächste Mal schreibe ich über das Hinzufügen von Gleitkommazahlen und den Verlust der Genauigkeit beim Runden.

PS: Ich verstehe, dass ich das Thema denormalisierte Zahlen usw. nicht angesprochen habe. Ich wollte den Artikel einfach nicht sehr viel laden, und diese Informationen sind fast zu Beginn leicht im IEEE 754-Standard zu finden.