Rechnerarithmetik

Ein binärer Addierer führt an jeder Bitposition dieselbe kleine Aufgabe aus. Er kombiniert die beiden Operandenbits mit einem Übertrag von der Position rechts daneben. Die Bedeutung des fertigen Bitmusters ergibt sich erst danach.

Verfolge den Übertrag

Ein Halbaddierer hat zwei Eingänge: Seine Summe ist deren XOR und sein Übertrag deren UND. Ein Volladdierer nimmt außerdem einen Eingangsübertrag entgegen:

Hier bedeutet Multiplikation UND und Addition ODER. Die Summe ist 1 bei einer ungeraden Anzahl von Eingängen mit dem Wert 1; der Übertrag ist 1 bei mindestens zwei. Die Verkettung von Volladdierern ergibt einen Ripple-Carry-Addierer. Nur Bit 0 erhält den anfänglichen Übertrag; jedes spätere Bit erhält den Übertrag, den sein Nachbar erzeugt.

Schreibe für 23 + 45 0001 0111 + 0010 1101. Bei Bit 0 ergibt 1 + 1 die Summe 0 und den Übertrag 1. Bei Bit 1 ergibt 1 + 0 + 1 erneut 0 und den Übertrag 1. Bei Bit 2 ergeben drei Eingänge mit dem Wert 1 die Summe 1 und den Übertrag 1. Weiter nach links ergibt sich 0100 0100, also 68, ohne abschließenden Übertrag.

Ein n-Bit-Ergebnis behält nur die niederwertigen n Bits, sodass die Schaltung die Summe modulo $2^n$ berechnet. Bei 8 Bit ergibt 1111 1100 + 0000 0101 das Ergebnis 0000 0001 und den Ausgangsübertrag 1. Vorzeichenbehaftet gelesen ist das −4 + 5 = 1. Vorzeichenlos gelesen ist es 252 + 5 = 257, dessen niederwertige acht Bits 1 darstellen. Die Schaltung hat sich nicht geändert, wohl aber der zulässige Wertebereich.

Wandle Subtraktion in Addition um

Das Zweierkomplement liefert die Gleichung

Eine Steuerleitung für die Subtraktion verknüpft jedes Bit des zweiten Operanden per XOR mit 1 und invertiert es dadurch; außerdem setzt sie den anfänglichen Eingangsübertrag auf 1. Für die Addition ist diese Leitung 0, sodass der zweite Operand unverändert durchgereicht wird und der anfängliche Übertrag 0 ist.

Um 23 − 45 zu berechnen, invertiere 0010 1101 zu 1101 0010. Addiere 0001 0111 + 1101 0010 + 1, um 1110 1010 mit Ausgangsübertrag 0 zu erhalten. Der vorzeichenbehaftete Wert ist −22. Bliebe der anfängliche Übertrag 0, ergäbe sich −23: Die Invertierung allein liefert eins weniger als den benötigten negativen Wert.

Bei vorzeichenloser Subtraktion bedeutet Ausgangsübertrag 1 keinen Borgübertrag; Ausgangsübertrag 0 bedeutet, dass ein Borgübertrag nötig war. Somit zeigt der Ausgangsübertrag 0 bei 23 − 45 ein vorzeichenloses Ergebnis unter null an. Arm hält diesen Übertrag für den Fall ohne Borgübertrag fest; x86 hält dessen Umkehrung als Borgübertragsflag fest.

Gleiche vor der Operation die Breiten an

RISC-V lb erweitert ein Byte mit dem Vorzeichen, lbu erweitert es mit Nullen, und addi erweitert seinen 12-Bit-Direktoperanden mit dem Vorzeichen. Wähle die Erweiterung anhand der Bedeutung des Operanden, bevor du die Bits an den Addierer weitergibst.

Der kleinste negative vorzeichenbehaftete Wert hat kein positives Gegenstück bei gleicher Breite. Die Negation des 8-Bit-Musters 1000 0000 invertiert es zu 0111 1111 und addiert 1, sodass wieder 1000 0000 entsteht. Das gewünschte +128 benötigt ein breiteres vorzeichenbehaftetes Format.

Überlauf bedeutet, dass das exakte Ergebnis außerhalb des Wertebereichs des Zielformats liegt. Vorzeichenlose n-Bit-Werte reichen von 0 bis einschließlich $2^n-1$; vorzeichenbehaftete Werte im Zweierkomplement reichen von $-2^{n-1}$ bis einschließlich $2^{n-1}-1$. Acht Bits speichern vorzeichenlos 0 bis 255 oder vorzeichenbehaftet −128 bis 127. Dasselbe gespeicherte Ergebnis kann in einer Lesart korrekt sein und in der anderen einen Überlauf darstellen.

Prüfe das richtige Signal

Für vorzeichenbehaftete Addition oder Subtraktion kann die Hardware verwenden:

wobei die beiden Überträge in die Vorzeichenstelle hinein- und aus ihr herausführen. Der Ausgangsübertrag allein beantwortet die vorzeichenlose Frage.

Addiere 107 und 54 mit 8 Bit: 0110 1011 + 0011 0110 ergibt 1010 0001. Ein Übertrag gelangt in Bit 7, aber keiner verlässt es, also ist der Überlauf 1. Der vorzeichenlose Wert 161 ist darstellbar; der vorzeichenbehaftet gelesene Wert −95 entspricht nicht der tatsächlichen Summe 161. Umgekehrt ergibt −4 + 5 den Übertrag 1, aber den vorzeichenbehafteten Überlauf 0. Die Addition von 1000 0000 zu sich selbst ergibt Übertrag 1 und Überlauf 1, sodass beide Lesarten fehlschlagen.

Die Addition unterschiedlicher Vorzeichen kann nicht überlaufen: Die exakte Summe liegt zwischen den Operanden. Für die Subtraktion gilt eine eigene Vorzeichenregel, weil die Subtraktion einer negativen Zahl den ersten Operanden erhöht. Zum Beispiel ist 100 − (−40) für vorzeichenbehaftete 8 Bit zu groß, obwohl beide Eingabewerte darstellbar sind.

Kenne die Wirkung des Befehls

x86 add setzt Carry- und Overflow-Flag. Arm-Operationen, die Flags setzen, wie ADDS, setzen sie ebenfalls; ein gewöhnliches ADD erhält die vorhandenen Flags. MIPS add und addi lösen bei vorzeichenbehaftetem Überlauf einen Trap aus, addu und addiu dagegen nicht. Die RISC-V-Ganzzahladdition schreibt die niederwertigen Bits und hat weder Überlauf-Flags noch einen Trap für arithmetischen Überlauf.

Nach add t0, t1, t2 lautet eine vorzeichenlose RISC-V-Prüfung:

bltu t0, t1, overflow

Eine umgebrochene vorzeichenlose Summe ist kleiner als ein ursprünglicher Operand. Vorzeichenbehaftete Werte benötigen eine andere Prüfung:

slti t3, t2, 0
slt  t4, t0, t1
bne  t3, t4, overflow

Der erste Befehl hält fest, ob der zweite Operand negativ ist. Der zweite hält fest, ob das Ergebnis kleiner als der erste Operand ist. Ohne Überlauf stimmen diese Prüfungen überein: Die Addition eines negativen Werts verringert den Wert, während die Addition eines nicht negativen Werts ihn nicht verringern kann. Eine Abweichung zeigt einen Überlauf an. Bei einem bekanntermaßen positiven Direktoperanden genügt ein vorzeichenbehafteter bedingter Sprung, der prüft, ob die Summe kleiner geworden ist.

Unterscheide Hardware- und Sprachregeln

Die vorzeichenlose Arithmetik von C und C++ bricht modulo $2^n$ um; vorzeichenbehafteter Überlauf ist undefiniertes Verhalten. Java int und long brechen um, während Math.addExact einen Überlauf durch eine Ausnahme meldet. Ganzzahlen in Python wachsen bei Bedarf. Ein Umbruch in der Hardware legt daher nicht fest, was ein C-Programm tun darf.

Umbrechende Additionen und Subtraktionen erhalten ein darstellbares Endergebnis: In der modularen 8-Bit-Arithmetik bricht (100 + 50) − 60 zuerst zu −106 und dann zu 90 um. Diese Überlegung gilt für umbrechende Arithmetik, nicht für vorzeichenbehaftete C-Ausdrücke, die überlaufen.

Sättigung ist eine andere Strategie. Vorzeichenlos mit 8 Bit sättigt 200 + 100 auf 255, statt zu 44 umzubrechen. Das ist für Pixelintensitäten und andere beschränkte Signale nützlich, bei denen der Umbruch eines großen positiven Ergebnisses zu einem kleinen Wert irreführend wäre.

Eine arithmetisch-logische Einheit, kurz ALU, nimmt Operanden und Steuereingaben entgegen und liefert ein Ergebnis sowie Statusausgänge. Sie ist kombinatorisch: Ihre Ausgänge hängen von den aktuellen Eingängen ab. Register halten Operanden und übernehmen Ergebnisse; die ALU selbst speichert nichts.

Baue ein Bit und wiederhole es

Ein 1-Bit-Slice berechnet UND, ODER und eine Volladdierersumme parallel. Ein Multiplexer wählt aus, welches mögliche Ergebnis das Ergebnisbit erreicht. In einer n-Bit-ALU teilen sich alle Slices die Operationssteuerung, während der Ausgangsübertrag jedes Addierers zum Eingangsübertrag des nächsten Slice führt. Logische Operationen arbeiten an jeder Position unabhängig; die Addition hängt von der Übertragskette ab.

Eine Bnegate-Steuerung invertiert den zweiten Operanden und setzt zugleich den Eingangsübertrag von Bit 0. Wird dann der Addierer gewählt, berechnet er eine Subtraktion. Höherwertige Slices erhalten ihren Übertrag vom vorhergehenden Slice, nicht direkt von Bnegate. Würden alle Übertragseingänge auf einen hohen Pegel gesetzt, würden zusätzliche Einsen in die Rechnung eingefügt.

Eine Ainvert-Steuerung kann außerdem den ersten Operanden invertieren. Wird UND bei beiden invertierten Operanden gewählt, entsteht nach dem de morganschen Gesetz NOR:

Wird ODER bei beiden invertierten Operanden gewählt, entsteht NAND. In diesen logischen Gleichungen bezeichnet das Pluszeichen ODER.

Lies ein Steuerwort

Eine klassische Lehrbuch-ALU verwendet die Felder Ainvert, Bnegate und ein Operation-Auswahlfeld mit zwei Bits:

Dies sind die Kodierungen dieses konkreten Entwurfs. Es sind interne Steuersignale, keine RISC-V-Befehlskodierungen.

Für die Eingaben 0101 und 0011 invertiert das Steuerwort 0110 die zweite Eingabe zu 1100 und liefert den anfänglichen Übertrag 1. Der Addierer erzeugt 0010 mit Ausgangsübertrag 1: 5 − 3 = 2, ohne vorzeichenlosen Borgübertrag. Die Wahl von UND für die ursprünglichen Eingaben würde stattdessen 0001 ergeben. Die Eingabewerte können gleich bleiben, während eine Änderung der Steuerung einen anderen Ergebnispfad auswählt.

Der höchstwertige Slice liefert außerdem Informationen über Überlauf und Vergleich. Eine Reduktion aller Ergebnisbits liefert Zero. Diese Statusausgänge ermöglichen dem umgebenden Prozessorsteuerwerk, das arithmetische Ergebnis zu prüfen, ohne ein zweites Ergebnis in voller Breite zu speichern.

Ergänze Verschiebungen neben dem Addierer

Eine vollständige ALU für den RISC-V-Basisbefehlssatz für Ganzzahlen benötigt außerdem XOR, vorzeichenlosen Vergleich und Verschiebungen. Ein Barrel-Shifter verwendet eine Folge von Multiplexerstufen. Jede Stufe reicht ihre Eingabe entweder unverändert durch oder verschiebt sie um eine Zweierpotenz. Ein 32-Bit-Schieber hat Stufen für 1, 2, 4, 8 und 16 Stellen und bewältigt damit in fünf Stufen jede Verschiebung von 0 bis 31.

Um um 13 zu verschieben, wähle die Stufen für 8, 4 und 1. Die gewählten Verschiebungen ergeben zusammen ein Ergebnis. Eine logische Rechtsverschiebung fügt Nullen ein. Eine arithmetische Rechtsverschiebung kopiert das Vorzeichenbit und erhält so das Vorzeichen eines negativen Werts. Daher ergibt 1111 0000 um zwei Stellen nach rechts verschoben logisch 0011 1100 und arithmetisch 1111 1100.

Vergleiche verwenden häufig die Subtraktion. Bei der Gleichheit wird gefragt, ob die Differenz null ist. Bei der Ordnung wird gefragt, ob die mathematische Differenz negativ ist; das erfordert besondere Sorgfalt, wenn eine Subtraktion mit fester Breite überläuft.

Erkenne Gleichheit über alle Bits

Der Zero-Ausgang ist die NOR-Verknüpfung aller Ergebnisbits:

Ein Ergebnisbit ungleich null macht Zero falsch. Die Subtraktion zweier gleicher Bitmuster ergibt null; zwei verschiedene n-Bit-Muster können sich nicht um ein Vielfaches von $2^n$ ungleich null unterscheiden, sodass eine umbrechende Subtraktion keine falsche Gleichheit erzeugt. Eine alternative Gleichheitsschaltung verknüpft entsprechende Operandenbits per XOR und prüft, ob jedes XOR-Ergebnis null ist.

Korrigiere das Vorzeichen für den vorzeichenbehafteten Kleiner-als-Vergleich

RISC-V slt schreibt die ganze Zahl 1 in voller Breite, wenn der erste vorzeichenbehaftete Operand kleiner ist, andernfalls 0. In einer ALU aus Slices berechnet der höchstwertige Slice ein Set-Signal und sendet es an den Less-Eingang von Bit 0 zurück. Alle höherwertigen Ergebnisbits werden auf null gesetzt.

Das korrekte Set-Signal ist

Ohne Überlauf funktioniert das Vorzeichen der Differenz unmittelbar. Bei einem Überlauf ist dieses Vorzeichen gegenüber der tatsächlichen Differenz umgekehrt, sodass XOR mit 1 es korrigiert.

Vergleiche 7 mit −8 in vier Bit. Die Subtraktion 0111 + 0111 + 1 ergibt 1111. Ihr Vorzeichen deutet auf eine negative Differenz hin, aber die exakte Differenz ist 15 und liegt außerhalb des Bereichs von −8 bis 7. Der Überlauf ist 1, also ist das korrigierte Less-Signal 1 XOR 1 = 0. Das slt-Ergebnis ist 0000 und meldet korrekt, dass 7 nicht kleiner als −8 ist.

Nutze den Borgübertrag für den vorzeichenlosen Kleiner-als-Vergleich

Der vorzeichenlose Vergleich nutzt ein anderes Signal:

für eine Subtraktion mit invertiertem zweitem Eingang und anfänglichem Übertrag 1. Ausgangsübertrag 0 bedeutet, dass ein Borgübertrag nötig war, also ist der erste vorzeichenlose Operand kleiner.

Diese Unterscheidung zeigt sich bei slt gegenüber sltu und bei den bedingten Sprüngen blt gegenüber bltu und bge gegenüber bgeu. Weder das Vorzeichen des Ergebnisses allein noch ein allgemeines „Negativ-Flag“ beantwortet beide Fragen.

Wende den Vergleich in Software an

Eine vorzeichenlose Bereichsprüfung kann negative Indizes ebenso zurückweisen wie Indizes ab der Arraylänge:

bgeu x10, x11, IndexOutOfBounds

Hier enthält x10 den vorzeichenbehafteten Index und x11 eine nicht negative Länge, die in den vorzeichenbehafteten Wertebereich passt. Ein negativer Index, vorzeichenlos neu interpretiert, ist mindestens $2^{n-1}$ und überschreitet daher jede solche Länge. Die Bedingung für die Länge ist entscheidend: Sie macht einen einzigen vorzeichenlosen Vergleich ausreichend.

Auch Sprachumwandlungen können die Bedeutung eines Vergleichs ändern. Bei einem 32-Bit-C-unsigned int ist -1 < 0u falsch, weil −1 vor dem Vergleich in 4.294.967.295 umgewandelt wird. Verfolge die Umwandlung, bevor du vom geschriebenen Minuszeichen ausgehst.

Der Übertrag eines Ripple-Carry-Addierers muss der Reihe nach jedes Bit durchlaufen. Die Übertragsvorausberechnung ersetzt dieses sequenzielle Warten durch eine Schaltung, die Überträge aus den Operandenbits und dem anfänglichen Übertrag vorhersagt.

Beschreibe das Übertragsverhalten jedes Bits

Das Übertragserzeugungs- und das Übertragsweiterleitungssignal seien

Dies sind boolesche Ausdrücke: Multiplikation ist UND und Addition ist ODER. Das Übertragserzeugungssignal ist 1, wenn das Bit unabhängig vom Eingangsübertrag einen Übertrag erzeugt. Das Übertragsweiterleitungssignal ist 1, wenn ein Eingangsübertrag weitergeleitet werden kann. Die Rekursionsgleichung lautet

Ein Bit, dessen beide Eingänge 1 sind, erzeugt einen Übertrag; ein Bit mit einem Eingang 1 leitet einen Übertrag weiter; ein Bit, dessen beide Eingänge 0 sind, stoppt ihn. Bei dieser ODER-Definition hat ein übertragserzeugendes Bit auch das Weiterleitungssignal 1, was die Übertragsformel nicht ändert.

Löse die Abhängigkeit auf

Setze für jeden vorherigen Übertrag den entsprechenden Ausdruck ein:

Jeder Ausdruck hängt nun von Signalen ab, die aus den Operanden abgeleitet werden, und vom anfänglichen Übertrag, nicht von einer sequenziellen Kette von Zwischenüberträgen. Sobald die Überträge vorliegen, ist jedes Summenbit weiterhin das XOR seiner beiden Eingänge und des Eingangsübertrags.

Für 1011 + 0110 mit anfänglichem Übertrag 0 lautet das Übertragserzeugungssignal von Bit 0 aufwärts 0, 1, 0, 0 und das Weiterleitungssignal 1, 1, 1, 1. Die Eingangsüberträge der Bits 1 bis 4 sind also 0, 1, 1, 1. Die vier Ergebnisbits sind 0001 mit Ausgangsübertrag 1 und stellen 11 + 6 = 17 dar.

Baue Gruppen statt riesiger Gatter

Ein Vier-Bit-Block hat die Gruppensignale

Sein Ausgangsübertrag ist $G+P{c}_0$. Eine zweite Vorausberechnungsstufe kombiniert diese Blocksignale nach derselben Regel. Vier Vier-Bit-Blöcke und eine Einheit zur Gruppenvorausberechnung ergeben einen 16-Bit-Addierer. Weitere Gruppierungen ermöglichen breitere Entwürfe; Parallel-Präfix-Addierer wie Kogge-Stone ordnen diese Beziehungen zu einem schnellen Netzwerk an.

In einem einfachen Modell für Gatterlaufzeiten kostet Ripple Carry etwa zwei Gatterlaufzeiten pro Bit, also 32 für 16 Bit. Ein zweistufiger Entwurf mit Vorausberechnung kann den letzten Übertrag nach etwa fünf liefern: eine für Bitsignale, zwei für Gruppensignale und zwei für den Gruppenübertrag. Diese Schätzung zählt Logikstufen und setzt die nötigen Gatter voraus; die tatsächliche Verzögerung hängt auch von Gattergröße und Verdrahtung ab. Die Gruppierung tauscht mehr Hardware gegen einen Übertragspfad, dessen Länge ungefähr logarithmisch mit der Breite wächst.

Ein Carry-Select-Addierer setzt Fläche anders ein: Er berechnet einen oberen Block zweimal, einmal für Eingangsübertrag 0 und einmal für Eingangsübertrag 1. Ein Multiplexer wählt das richtige Ergebnis, sobald der Übertrag des unteren Blocks eintrifft.

Manche Addierer definieren das Weiterleitungssignal mit XOR statt mit ODER. Auch das ergibt korrekte Überträge und macht die Summe zu $s_i=p_i\oplus c_i$. Verwende die gewählte Definition durchgehend, wenn du die Gruppenlogik herleitest.

Jedes Bit des binären Multiplikators wählt eine verschobene Kopie des Multiplikanden oder null. Die Addition dieser Teilprodukte ergibt das Ergebnis. Ein n-Bit-Operand mal ein m-Bit-Operand kann n + m Bits benötigen, daher brauchen zwei 32-Bit-Operanden ein vollständiges Produkt mit 64 Bit.

Verfolge das Verschieben und Addieren

Initialisiere für vorzeichenlose n-Bit-Operanden ein 2n-Bit-Produkt mit null. Wiederhole n-mal: Prüfe das niederwertigste Bit des Multiplikators, addiere den aktuellen Multiplikanden, wenn dieses Bit 1 ist, verschiebe den Multiplikanden nach links und den Multiplikator nach rechts. Das Multiplikandenregister muss breit genug sein, um die verschobenen Kopien aufzunehmen.

Für 6 × 5 mit vier Bit ist der Multiplikator 0101:

Das Endprodukt ist 30. Das geprüfte Bit und die Verschieberichtung wirken zusammen: Würde beim Rechtsverschieben des Multiplikators das höchstwertige Bit geprüft, würden Bits mit den falschen Stellenwerten gepaart. Dieser sequenzielle Entwurf benötigt n Schritte, einschließlich der Schritte, deren Multiplikatorbit null ist.

Teile den Registerplatz

Der erste Entwurf nutzt ein 2n-Bit-Multiplikandenregister und einen ebenso breiten Addierer. Ein verbesserter Entwurf hält den Multiplikanden unverändert in n Bits, legt den Multiplikator in die niederwertige Hälfte eines 2n-Bit-Produktregisters und initialisiert die höherwertige Hälfte mit null.

Ist das niederwertigste Bit 1, addiere den Multiplikanden zur höherwertigen Hälfte. Halte den Ausgangsübertrag des Addierers in einem zusätzlichen Bit und verschiebe dann diesen Übertrag und beide Produkthälften gemeinsam nach rechts. Die Multiplikatorbits verlassen das Register rechts, während Produktbits den frei werdenden Platz einnehmen. Geht der Übertrag verloren, werden große Produkte falsch: Bei Vier-Bit-Operanden würde 15 × 15 fälschlich 1 statt 225 ergeben. Bei einem Schritt pro Takt benötigt die einfache 32-Bit-Implementierung etwa 32 Zyklen.

Behalte die Produktbreite im Blick

Ein vorzeichenloses Produkt passt genau dann in n Bits, wenn die oberen n Bits seines vollständigen Produkts null sind. Für 6 × 5 ist das vollständige Ergebnis 0001 1110; wird nur 1110 gespeichert, ergibt das 14. Die Multiplikation selbst war korrekt, aber das schmale Ziel hat einen Teil davon verworfen.

Eine Linksverschiebung um k multipliziert mit $2^k$, wenn das Ergebnis darstellbar ist. Die Multiplikation mit 8 wird zu einer Verschiebung um drei Stellen; für die Multiplikation mit 10 können zwei verschobene Kopien verwendet werden:

(x << 3) + (x << 1)

Die Rechnung lautet $8x+2x=10x$. Für die Verschiebungen und die Addition gelten weiterhin die Regeln für die Breite und die Programmiersprache; diese Umformung erzeugt keine zusätzlichen Ergebnisbits.

Lies die RISC-V-Produkthälften

mul liefert die niederwertigen XLEN Bits, wobei XLEN die Breite der Ganzzahlregister ist. mulhu liefert die höherwertige Hälfte für vorzeichenlose Operanden. Die Befehle für die höherwertige Hälfte bei vorzeichenbehafteten Operanden sind mulh für zwei vorzeichenbehaftete Operanden und mulhsu für einen vorzeichenbehafteten ersten und einen vorzeichenlosen zweiten Operanden.

Software, die das vollständige Produkt benötigt, kann den passenden Befehl für die höherwertige Hälfte und danach mul mit denselben Operanden ausführen. Eine Implementierung kann das Befehlspaar zusammenfassen. Das niederwertige Ergebnis allein zeigt nicht, ob ein vorzeichenloses Produkt hineinpasst; die höherwertige Hälfte liefert diesen Nachweis.

Die vorzeichenbehaftete Multiplikation muss die Vorzeichen der Operanden behandeln, ohne den kleinsten negativen Wert zu verlieren. Schnellere Hardware braucht außerdem eine Möglichkeit, viele Teilprodukte zu reduzieren, ohne jedes Mal auf eine vollständige Addition mit Übertragsweiterleitung zu warten.

Multipliziere Beträge sicher

Ein Ansatz hält die Vorzeichen fest, bildet vorzeichenlose n-Bit-Beträge, multipliziert sie zu einem 2n-Bit-Produkt und negiert das vollständige Produkt, wenn genau ein Operand negativ war. Für −8 mit vier Bit stellen die Betragsbits 1000 vorzeichenlos 8 dar. Sie können nicht als positiver vorzeichenbehafteter Vier-Bit-Wert gelesen werden.

Die niederwertigen n Produktbits sind bei vorzeichenbehafteter und vorzeichenloser Interpretation identisch. 1111 × 0010 ergibt vorzeichenlos 30 (0001 1110) oder vorzeichenbehaftet −2 (1111 1110). Beide niederwertigen Hälften sind 1110; nur die höherwertigen Hälften unterscheiden sich. Deshalb dient ein mul-Befehl beiden Interpretationen.

Verfolge die Entscheidungen des Booth-Algorithmus

Der Booth-Algorithmus arbeitet direkt mit dem Zweierkomplement. Gib dem Akkumulator n + 1 Bits und erweitere den Multiplikanden auf diese Breite mit dem Vorzeichen, sodass sowohl er als auch sein negativer Wert hineinpassen. Initialisiere den Akkumulator mit null, lege den Multiplikator in sein n-Bit-Register und hänge ein zusätzliches, mit null initialisiertes Bit an.

Betrachte das niederwertigste Bit des Multiplikators und das angehängte Bit als Paar:

Verschiebe nach jeder Entscheidung das gesamte Register aus Akkumulator, Multiplikator und Zusatzbit arithmetisch nach rechts. Wiederhole dies n-mal; verwirf das angehängte Bit und das redundante oberste Vorzeichenbit des Akkumulators, um das 2n-Bit-Produkt zu erhalten.

Verwende für 2 × (−3) den Multiplikanden 00010, den Multiplikator 1101 und den Akkumulator 00000. Die Paare sind 10, 01, 10, 11. Nach den jeweiligen Operationen und Verschiebungen lauten Akkumulator und Multiplikator 11111 0110, 00000 1011, 11111 0101 und 11111 1010. Die niederwertigen acht Produktbits 1111 1010 stellen −6 dar.

Eine logische Verschiebung würde oben null einfügen und negative Teilergebnisse verfälschen. Auch das zusätzliche Akkumulatorbit ist wichtig: Die Subtraktion eines kleinsten negativen n-Bit-Multiplikanden benötigt einen positiven Wert, der in n vorzeichenbehafteten Bits nicht verfügbar ist.

Verringere den Aufwand und die Übertragspfade

Die Booth-Rekodierung ersetzt eine Folge von Bits mit dem Wert 1 durch eine Subtraktion an ihrem niederwertigen Ende und eine Addition oberhalb ihres höchstwertigen Endes. Zum Beispiel ist 126 gleich 128 − 2. Wechselnde Bits sparen möglicherweise keinen Aufwand. Booth zur Basis 4 betrachtet zwei Multiplikatorbits pro Schritt und verwendet Ziffern von −2 bis +2, wodurch sich die Anzahl der Teilprodukte verringert.

Ein schneller Multiplizierer bildet Teilprodukte parallel. Ein Carry-Save-Addierer komprimiert drei Wörter zu zwei, ohne Überträge über das Wort weiterzuleiten. Wallace- oder Dadda-Bäume wiederholen diese Reduktion und verwenden anschließend einen letzten Addierer mit Übertragsweiterleitung. Die Reduktion von 32 Zeilen auf zwei benötigt acht Carry-Save-Ebenen. Pipelining erlaubt die gleichzeitige Bearbeitung mehrerer Produkte; dass in jedem Zyklus ein neues angenommen wird, bedeutet nicht, dass jedes in einem Zyklus fertig ist.

Bei einem vorzeichenbehafteten Ergebnis, das auf n Bits verkürzt wird, muss jedes Bit der höherwertigen Hälfte dem Vorzeichenbit der niederwertigen Hälfte entsprechen. −8 × −1 mit vier Bit ergibt das vollständige Produkt 0000 1000. Die höherwertige Hälfte ist null, aber das beibehaltene Vorzeichenbit ist 1, daher passt +8 nicht in das vorzeichenbehaftete Zielformat.

Die Division erzeugt einen Quotienten und einen Rest, die durch folgende Gleichung verbunden sind:

Bei einem vorzeichenlosen Divisor ungleich null ist der Rest nicht negativ und kleiner als der Divisor. Ein n-Bit-Dividend und ein n-Bit-Divisor benötigen einen n-Bit-Quotienten und einen n-Bit-Rest.

Erzeuge den Quotienten Bit für Bit

Lies die Dividendenbits vom höchstwertigen Ende aus. Verdopple den Teilrest, hole das nächste Bit herein und prüfe, ob der Divisor hineinpasst. Ist das der Fall, subtrahiere ihn und schreibe das Quotientenbit 1; andernfalls behalte den Teilrest und schreibe 0.

Bei 0111 dividiert durch 0010 sind die nach dem Herunterholen entstehenden Teilreste 0, 1, 3 und 3. Die ersten beiden sind kleiner als 2, daher sind ihre Quotientenbits 0. Jede 3 erlaubt eine Subtraktion, die den Rest 1 und das Quotientenbit 1 ergibt. Der Quotient ist 0011 und der Rest 0001: 3 × 2 + 1 = 7.

Die restaurierende Division versucht zuerst eine Subtraktion. Ist das Probeergebnis negativ, addiere den Divisor zurück und schreibe 0; andernfalls behalte es und schreibe 1. Erkenne einen Fehlschlag anhand eines Borgübertrags oder einer vorzeichenbehafteten n + 1-Bit-Differenz. Eine n-Bit-Vorzeichenprüfung ist unsicher: 0 − 9 mit vier Bit bricht zu 0111 um, dessen höchstwertiges Bit trotz des Borgübertrags 0 ist.

Kompakte Hardware legt den Dividenden in die niederwertige Hälfte eines 2n-Bit-Registers und den Teilrest in die höherwertige Hälfte. Sie verschiebt bei jedem Schritt nach links und fügt rechts Quotientenbits ein. Am Ende enthält die höherwertige Hälfte den Rest und die niederwertige den Quotienten.

Die nichtrestaurierende Division übernimmt ein negatives Probeergebnis in den nächsten Schritt und addiert dort den Divisor, statt sofort zu restaurieren. Ein abschließend negativer Teilrest benötigt eine letzte Rückaddition. Die SRT-Division wählt mithilfe führender Bits von Divisor und Rest mehrere Quotientenbits pro Schritt; fehlende Einträge in einer solchen Auswahltabelle verursachten 1994 den Pentium-FDIV-Fehler. Die Division bleibt von jedem vorherigen Teilrest abhängig.

Wende vorzeichenbehaftete Division mit Abschneiden an

Dividiere die Beträge, negiere den Quotienten bei unterschiedlichen Vorzeichen und gib einem Rest ungleich null das Vorzeichen des Dividenden.

Diese Ergebnisse schneiden den Quotienten in Richtung null ab und erfüllen die Divisionsgleichung. RISC-V, Java und C seit C99 verwenden diese Regel. Python // rundet stattdessen ab: -7 // 2 ist −4 und -7 % 2 ist 1.

Behandle besondere Eingaben

Die RISC-V-Division durch null liefert einen Quotienten, dessen Bits alle gesetzt sind, und den ursprünglichen Dividenden als Rest. Der vorzeichenbehaftete Überlauffall, der kleinste negative Wert dividiert durch −1, liefert den kleinsten negativen Wert als Quotienten und null als Rest. Keiner der Fälle löst einen Trap aus. x86 löst für beide eine Divisionsfehlerausnahme aus. Software, die Fehler melden muss, prüft zuerst auf null und prüft auch das Operandenpaar für vorzeichenbehafteten Überlauf.

Eine logische Rechtsverschiebung dividiert vorzeichenlose Werte durch Zweierpotenzen und rundet ab. Eine arithmetische Verschiebung rundet auch negative Werte ab: −5 um eine Stelle nach rechts verschoben wird zu −3, während die Division durch 2 mit Abschneiden −2 ergibt. Um das Abschneiden mit einer Verschiebung umzusetzen, addiere vor dem Rechtsverschieben um k zu einer negativen Eingabe $2^k-1$. Verschiebe für −5 und k = 1 den Wert −4, um −2 zu erhalten.

Ein normaler binärer Gleitkommawert hat die Form

Der Signifikand ist der vollständige Wert 1,f; die gespeicherte Mantisse enthält nur f. Die Normalisierung garantiert die führende 1, sodass das Weglassen dieses impliziten Bits ein Bit an Genauigkeit gewinnt.

Lies die drei Felder

IEEE 754-2019 definiert diese Formate. Einfache und doppelte Genauigkeit bezeichnen meist binary32 und binary64. Die gespeicherte Reihenfolge ist Vorzeichen, Exponent, Mantisse. Subtrahiere bei einem normalen Wert den Bias vom vorzeichenlosen Exponentenfeld:

Mantisse bezeichnet den Binärbruch nach dem Komma, nicht dessen als ganze Zahl gelesene Bits. In binary32 kodieren die Exponentenfelder 1 bis 254 die Exponenten −126 bis 127. Die Felder 0 und 255 haben besondere Bedeutungen.

Ein Bias bewirkt, dass größere Exponenten größere vorzeichenlose Felder haben. Bei positiven endlichen Zahlen entspricht die vorzeichenlose Reihenfolge der vollständigen Bitmuster der numerischen Reihenfolge. Negative Werte und NaNs erfordern eine zusätzliche Behandlung.

Kodiere und dekodiere

Um −0,75 zu kodieren, schreibe seinen Betrag als ${\mathrm{0,11}}_2={\mathrm{1,1}}_2\times 2^{-1}$. Das Vorzeichen ist 1 und das Exponentenfeld ist −1 + 127 = 126, also 01111110. Lass die implizite führende 1 weg und fülle die Mantisse mit Nullen auf. Die Felder sind 1 01111110 10000000000000000000000, was 0xBF400000 ergibt. In binary64 ist derselbe Wert 0xBFE8000000000000.

Um 0x41460000 zu dekodieren, zerlege es in 0 10000010 10001100000000000000000. Das Exponentenfeld ist 130, der tatsächliche Exponent also 3. Der Signifikand ist

Die Multiplikation mit 8 ergibt 12,375. Würdest du die implizite 1 in die gespeicherte Mantisse schreiben, änderte sich der Wert; würdest du −1 direkt im Exponentenfeld speichern, ginge die Bias-Regel verloren.

Unterscheide Wertebereich und Genauigkeit

binary32 erreicht ungefähr $\mathrm{3,40}\times {10}^{38}$, mit dem kleinsten positiven normalen Wert $2^{-126}$ und etwa sieben signifikanten Dezimalstellen. binary64 erreicht ungefähr $\mathrm{1,80}\times {10}^{308}$, mit dem kleinsten positiven normalen Wert $2^{-1022}$ und etwa 15–16 signifikanten Stellen. binary16 hat den Höchstwert 65.504, den kleinsten positiven normalen Wert $2^{-14}$, den kleinsten positiven subnormalen Wert $2^{-24}$ und etwa 3,3 signifikante Dezimalstellen.

Die Genauigkeit zählt signifikante Stellen, nicht Stellen nach dem Dezimalkomma. Zum Beispiel speichert binary32 1.234.567,89 als 1.234.567,875.

Innerhalb des binary32-Intervalls von $2^e$ bis unter $2^{e+1}$ haben benachbarte normale Werte den Abstand $2^{e-23}$. Dieser Abstand ist eine ulp, eine Einheit der letzten Stelle. Direkt über 1 ist er $2^{-23}$ und wird häufig Maschinenepsilon genannt. Bei $2^{24}$ wird der Abstand 2, sodass 16.777.217 fehlt, obwohl viel größere Zahlen darstellbar sind. Mehr Exponentenbits erweitern den Bereich der Größenordnungen; mehr Mantissenbits lassen darstellbare Werte bei einer gegebenen Größenordnung dichter beieinanderliegen.

Reservierte Exponentenmuster ermöglichen es IEEE 754, Werte jenseits gewöhnlicher normalisierter Zahlen darzustellen. Ordne die Felder immer ein, bevor du eine Formel für den Wert anwendest.

Erkenne die reservierten Muster

binary32 hat +0 bei 0x00000000 und −0 bei 0x80000000. Sie sind beim Vergleich gleich, aber eine Division kann das Vorzeichen sichtbar machen: 1 dividiert durch +0 ergibt +∞, während 1 dividiert durch −0 −∞ ergibt. Ein winziges negatives Ergebnis, das auf null gerundet wird, wird zu −0.

Positiv unendlich ist 0x7F800000; der größte endliche positive Wert ist 0x7F7FFFFF. Bei Rundung zur nächsten Zahl liefert ein arithmetischer Überlauf einen vorzeichenbehafteten Unendlichkeitswert. Auch die Division eines endlichen Werts ungleich null durch null liefert einen vorzeichenbehafteten Unendlichkeitswert, aber mit einem anderen Ausnahmeflag. Spätere Rechnungen behandeln Unendlich konsistent: Die Addition von 1 zu +∞ lässt +∞ unverändert, die Multiplikation mit −2 ergibt −∞, und der Kehrwert ist +0.

Unterscheide NaN von Unendlich

Operationen wie null dividiert durch null, unendlich minus sich selbst, null mal unendlich und die reelle Quadratwurzel von −1 haben kein aussagekräftiges numerisches Ergebnis. Sie erzeugen NaN, „keine Zahl“, und signalisieren eine ungültige Operation.

NaN ist ungeordnet: Gleichheits- und ordnende Kleiner-als- oder Größer-als-Vergleiche mit NaN sind falsch, während Ungleichheit wahr ist. Insbesondere kann x == NaN NaN nicht erkennen. Verwende isnan(x). Stille NaNs pflanzen sich normalerweise durch Rechnungen fort; signalisierende NaNs lösen bei Verwendung eine ungültige Operation aus. In diesen Binärformaten kennzeichnet das höchstwertige Mantissenbit ein stilles NaN. Das kanonische stille binary32-NaN von RISC-V ist 0x7FC00000.

Nähere dich null schrittweise

Eine subnormale Zahl hat keine implizite 1. Ihr Exponent ist auf den kleinsten normalen Exponenten festgelegt:

Für binary32 ist 0x00000001 gleich $2^{-149}$ und 0x00400000 gleich $2^{-127}$. Für binary64 ist der kleinste positive Wert $2^{-1074}$. Würde man bei einem Exponentenfeld null Exponent minus Bias verwenden, läge man um einen Faktor zwei daneben, selbst bevor eine fälschliche implizite 1 hinzugefügt würde.

Subnormale Zahlen ermöglichen graduellen Unterlauf: Die Genauigkeit nimmt mit schrumpfenden Werten ab, bei festem absolutem Abstand nahe null. Verschiedene endliche Werte eines Formats haben weiterhin eine darstellbare Differenz ungleich null. Flush-to-Zero-Modi verzichten auf diesen Schutz und können auf manchen Prozessoren die Verarbeitung subnormaler Zahlen beschleunigen.

Lies die Ausnahmeflags

IEEE 754 definiert ungültige Operation, Division durch null, Überlauf, Unterlauf und Ungenauigkeit. Die Standardbehandlung liefert ein Ergebnis und hält den Status fest; sie muss die Ausführung nicht stoppen. Ungenauigkeit bedeutet, dass das gerundete Ergebnis vom exakten abweicht.

Bei der Standardbehandlung setzt Unterlauf sowohl einen sehr kleinen als auch einen ungenauen Wert voraus. In binary32 ist $2^{-126}\mathrm{/}2=2^{-127}$ eine exakte subnormale Zahl und löst keinen Unterlauf aus. RISC-V hält NV, DZ, OF, UF und NX in fflags innerhalb von fcsr fest, und Gleitkommaausnahmen lösen keine arithmetischen Traps aus. Ein zurückgegebener Unendlichkeitswert allein zeigt nicht, ob ein Überlauf oder eine Division durch null auftrat; prüfe das Flag.

Die Gleitkommaarithmetik verarbeitet Signifikanden und Exponenten getrennt. Das Endergebnis muss der exakten Operation entsprechen, gerundet auf das Zielformat. Daher müssen die zwischenzeitlichen Bitverschiebungen genug Information für diese letzte Entscheidung erhalten.

Addiere mit einem gemeinsamen Exponenten

Die Addition folgt vier Stufen: Angleichen, Rechnen, Normalisieren, Runden. Vergleiche die Exponenten und verschiebe den Signifikanden des kleineren Operanden um ihre Differenz nach rechts. Addiere bei gleichen Vorzeichen die Beträge; subtrahiere bei unterschiedlichen Vorzeichen die Beträge. Verschiebe das Ergebnis in normalisierte Form und passe seinen Exponenten an. Runde anschließend und normalisiere erneut, falls beim Runden ein Übertrag entsteht.

Verwende Vier-Bit-Signifikanden, um 0,5 + (−0,4375) nachzuvollziehen:

1. Schreibe die Operanden als ${\mathrm{1,000}}_2\times 2^{-1}$ und $-{\mathrm{1,110}}_2\times 2^{-2}$.
2. Gleiche den zweiten zu $-{\mathrm{0,111}}_2\times 2^{-1}$ an.
3. Subtrahiere die Beträge: ${\mathrm{1,000}}_2-{\mathrm{0,111}}_2={\mathrm{0,001}}_2$.
4. Normalisiere zu ${\mathrm{1,000}}_2\times 2^{-4}$, also 0,0625. Es gingen keine Bits ungleich null verloren, daher muss das Ergebnis durch Rundung nicht geändert werden.

Auslöschung kann eine große Linksverschiebung zur Normalisierung nötig machen. Die Hardware nutzt einen Exponentensubtrahierer, einen Schieber zur Exponentenangleichung, einen Signifikandaddierer, einen Zähler führender Nullen sowie Normalisierungs- und Rundungslogik. Gleitkommaaddierer sind häufig über mehrere Zyklen als Pipeline aufgebaut.

Ein Dezimalmodell zeigt, warum zusätzliche Ziffern wichtig sind: Bei vier signifikanten Stellen wird 99,99 + 0,161 zu $\mathrm{9,999}+\mathrm{0,01610}$ auf der Größenordnung ${10}^1$ angeglichen. Das exakte Zwischenergebnis ist 10,01510 auf dieser Größenordnung. Normalisiere zu $\mathrm{1,00151}\times {10}^2$ und runde zu $\mathrm{1,002}\times {10}^2$. Würde der angeglichene Summand zu früh abgeschnitten, ginge Information verloren, die zur Wahl von 100,2 nötig ist.

Multipliziere Größenordnungen und Signifikanden

Multipliziere die Signifikanden, addiere die tatsächlichen Exponenten und verknüpfe die Vorzeichen mit XOR. Subtrahiere bei Feldern mit Bias einmal den Bias:

Dies geschieht vor Anpassungen durch die Normalisierung. Zwei normale Signifikanden ergeben multipliziert einen Wert von 1 bis unter 4, sodass ihr Produkt höchstens eine Rechtsverschiebung zur Normalisierung benötigt. Das Runden kann eine weitere Anpassung nötig machen; auch die Exponentenschranken müssen geprüft werden.

Für 0,5 × (−0,4375) ergeben die binary32-Exponentenfelder 126 + 125 − 127 = 124, also den tatsächlichen Exponenten −3. Das Signifikandprodukt ist ${\mathrm{1,000}}_2\times {\mathrm{1,110}}_2={\mathrm{1,110}}_2$. Das Vorzeichen-XOR ist 1, was $-{\mathrm{1,110}}_2\times 2^{-3}=-\mathrm{0,21875}$ ergibt.

Runde einmal mit verschmolzener Multiplikation und Addition

FMA berechnet a × b + c mit einer Rundung nach dem vollständigen Ausdruck. Getrennte Multiplikation und Addition runden zweimal. Nimm in binary32 $a=1+2^{-23}$, $b=1-2^{-23}$ und c = −1. Ihr exaktes Produkt ist $1-2^{-46}$. Eine separate Multiplikation rundet dies zu 1, sodass die Addition null ergibt. FMA erhält die kleine Produktdifferenz und liefert $-2^{-46}$.

RISC-V F stellt 32 Gleitkommaregister bereit, f0 bis f31; D verbreitert denselben Registersatz für doppelte Genauigkeit. flw/fsw und fld/fsd übertragen Werte. Zu den Rechenbefehlen gehören fadd.s, fmul.s, fdiv.s und fsqrt.s, mit .d-Formen für doppelte Genauigkeit. fmadd.s berechnet eine verschmolzene Multiplikation und Addition. Vergleiche wie flt.s schreiben 0 oder 1 in ein Ganzzahlregister, und fcvt wandelt Formate oder Ganzzahlwerte um.

Ein endliches Format kann nicht jedes exakte Ergebnis speichern. Korrekte Rundung bedeutet, das von der Rundungsrichtung verlangte darstellbare Ergebnis zu wählen, als wäre die Operation zuerst exakt berechnet worden. Grundrechenarten, Quadratwurzel und FMA folgen dieser Regel. Nutzdaten- und Vorzeichenbits von NaNs müssen auf verschiedenen Prozessoren nicht identisch sein.

Wähle eine Rundungsrichtung

Die ersten vier sind für binäre Implementierungen vorgeschrieben; die Rundung zur geraden Endziffer bei Gleichstand ist die Voreinstellung. Die Rundung bei Gleichstand von null weg ist für Dezimalformate vorgeschrieben, und RISC-V bietet sie auch für binäre Operationen. Die Bezeichnungen sind RNE, RUP, RDN, RTZ und RMM; ein Befehl kann einen Modus direkt wählen oder den dynamischen Modus in fcsr verwenden.

Bei Rundung auf ganze Zahlen mit gerader Endziffer bei Gleichstand wird 2,5 zu 2 und 3,5 zu 4. Binär wird bei Vier-Bit-Signifikanden ${\mathrm{1,0011}}_2$ zu ${\mathrm{1,010}}_2$ gerundet und ${\mathrm{1,0101}}_2$ ebenfalls zu ${\mathrm{1,010}}_2$. Das gerade Bit gehört zum beibehaltenen Signifikanden, nicht zum Exponenten oder einer ausgegebenen Dezimalziffer.

Behalte Schutz-, Rundungs- und Sticky-Informationen

Behalte nach der Normalisierung zwei zusätzliche Bits hinter dem Zielsignifikanden: Schutzbit und Rundungsbit. Das Sticky-Bit ist die ODER-Verknüpfung jedes später verworfenen Bits. Es hält fest, ob dieser gesamte Rest null ist.

Bei Rundung zur nächsten Zahl bedeutet Schutzbit 0, dass der Wert unter der Hälfte liegt. Schutzbit 1 mit Rundungs- oder Sticky-Bit 1 bedeutet, dass er über der Hälfte liegt. Schutzbit 1 mit beiden späteren Kennzeichen 0 bedeutet einen exakten Gleichstand. Erhöhe bei Gleichstand den beibehaltenen Signifikanden nur, wenn sein aktuelles niederwertigstes Bit 1 ist.

Für eine Summe von 8 + 0,5625 mit Vier-Bit-Signifikanden ergibt die Exponentenangleichung

Behalte 1.000; das Schutzbit ist 1, das Rundungsbit 0 und das Sticky-Bit 1, weil der verbleibende Rest eine 1 enthält. Der Wert liegt über der Hälfte, erhöhe daher auf ${\mathrm{1,001}}_2\times 2^3=9$. Würde das Sticky-Bit verworfen, entstünde fälschlich ein Gleichstand und 8 würde gewählt.

Ein Sticky-Bit ist ein Nachweis über alle verlorenen Bits, nicht einfach das dritte Bit nach dem beibehaltenen Teil. Sobald beim Verschieben irgendein verlorenes Bit 1 ist, bleibt der Sticky-Zustand für diesen angesammelten Rest 1.

Deute Fehler und Überlauf

Für endliche Ergebnisse innerhalb des Wertebereichs hat die Rundung zur nächsten Zahl einen absoluten Fehler von höchstens einer halben ulp; gerichtete Rundung hat einen Fehler unter einer ulp. Für normale binary32-Ergebnisse ist die übliche relative Schranke bei Rundung zur nächsten Zahl $2^{-24}$; für binary64 ist sie $2^{-53}$. Bei subnormalen Ergebnissen muss der absolute Fehler betrachtet werden, weil ihre relative Genauigkeit abnimmt.

Die Rundungsrichtung steuert auch Überlaufergebnisse. Positiver Überlauf ergibt bei Rundung zur nächsten Zahl oder in Richtung positiv +∞, bei Rundung in Richtung null oder negativ aber den größten endlichen positiven Wert. Negativer Überlauf verhält sich spiegelbildlich.

Für Ganzzahlumwandlungen gelten eigene Regeln. In C schneiden darstellbare Typumwandlungen wie (int)2.7 und (int)-2.7 auf 2 und −2 ab, unabhängig von der aktuellen Gleitkomma-Rundungsrichtung. Prüfe sowohl den Zielwertebereich als auch den verworfenen Bruchteil.

Gleitkommafehler ergeben sich oft direkt aus dem endlichen Abstand darstellbarer Werte. Unterscheide den bereits in gespeicherten Operanden vorhandenen Fehler von der Rundung durch eine Operation und von Informationen, die bei der Umwandlung verloren gehen.

Erkenne Darstellungsfehler

Ein gekürzter Bruch hat genau dann eine endliche Binärentwicklung, wenn sein Nenner eine Zweierpotenz ist. Werte wie 0,5, 0,25 und 0,375 sind exakt. Die Entwicklung von 0,1 wiederholt sich, daher speichert binary32 0x3DCCCCCD, etwa 0,10000000149011612. Auch binary64 speichert eine Näherung.

Folglich ergibt binary64 0.1 + 0.2 den Wert 0,30000000000000004, der sich vom gespeicherten Wert unterscheidet, der 0,3 am nächsten liegt. Ein kurzes ausgegebenes Ergebnis wie 0.1 kann die kürzeste Dezimalzahl sein, die bei Rückumwandlung dieselben gespeicherten Bits ergibt; es belegt keine Exaktheit.

Verwende für näherungsweise endliche Ergebnisse eine passend zum Problem gewählte Toleranz, zum Beispiel

Die absolute Toleranz behandelt Werte nahe null; die relative Toleranz skaliert mit dem Betrag. Die Toleranzen sollten die Rechnung und den akzeptablen Fehler berücksichtigen, nicht nur die Anzahl ausgegebener Stellen.

Achte darauf, wie eine Addition eine kleine Eingabe verliert

Absorption tritt bei Rundung zur nächsten Zahl auf, wenn ein kleiner Summand einen großen Operanden nicht zu seinem nächsten darstellbaren Nachbarwert bewegen kann. In binary32 wird 16.777.216 + 1 wieder zu 16.777.216 gerundet: Die Nachbarwerte haben den Abstand zwei, und bei diesem Gleichstand wird der gerade Signifikand gewählt. Ein float-Zähler, der 1 addiert, kann daher aufhören zu wachsen.

Eine Änderung der Additionsreihenfolge kann das Ergebnis ändern. Bei binary32 mit x = −1,5 × 10³⁸, y = 1,5 × 10³⁸ und z = 1 ergibt (x + y) + z den Wert 1. Aber y + z wird zu y gerundet, sodass x + (y + z) null ergibt. Die Addition ist nicht assoziativ. Parallele Reduktionen können ihre Gruppierung bei Änderung der Threadanzahl ändern, was die letzten Bits beeinflusst.

Auch wiederholtes Runden summiert sich: Die Addition von binary32 0,1 zehn Millionen Mal zu einer binary32-Summe ergibt 1.087.937 statt 1.000.000. Ein breiterer Akkumulator verringert den Rundungsverlust. Werden kleinere Beträge zuerst addiert, können außerdem Beiträge erhalten bleiben, die eine große laufende Summe absorbieren würde.

Unterscheide Auslöschung von ungenauer Subtraktion

Auslöschung entfernt gemeinsame führende Stellen nahezu gleicher Operanden. Die Subtraktion selbst kann exakt sein, während frühere Operandenfehler im Verhältnis zum kleinen Ergebnis groß werden. In binary32 wird 1,0000001 als $1+2^{-23}$ gespeichert. Die Subtraktion von 1 ergibt etwa $\mathrm{1,1920929}\times {10}^{-7}$ statt $\mathrm{1,0}\times {10}^{-7}$, rund 19 % relativen Fehler.

Prüfe Umwandlungen und Formatwahl

binary64 stellt jede 32-Bit-Ganzzahl exakt dar. binary32 tut das nicht: 16.777.217 wird bei Rundung zur geraden Endziffer bei Gleichstand zu 16.777.216 gerundet. Oberhalb von $2^{53}$ fehlen auch in binary64 manche ganzen Zahlen. Die Umwandlung eines Gleitkommawerts in einen kleineren Ganzzahltyp kann dessen Wertebereich vollständig überschreiten.

Beim Erstflug der Ariane 5 im Jahr 1996 führte eine Umwandlung außerhalb des Wertebereichs von einer 64-Bit-Gleitkommazahl in eine vorzeichenbehaftete 16-Bit-Ganzzahl zur Abschaltung der Trägheitsreferenzsysteme und trug zum Verlust der Rakete bei. Beim Patriot-Versagen 1991 in Dhahran summierte sich bei einer abgeschnittenen Festkommanäherung von 0,1 nach etwa 100 Stunden ein Zeitfehler von etwa 0,34 s, wodurch sich das Verfolgungsfenster um etwa 687 m verschob. Dies war ein Festkomma-Darstellungsfehler, keine IEEE-Gleitkommaoperation.

Wähle binary64 für höhere allgemeine Genauigkeit, binary32, wenn sein geringerer Speicherbedarf zur Aufgabe passt, und binary16 oder bfloat16 für geeignete Aufgaben mit geringer Genauigkeit. bfloat16 hat acht Exponenten- und sieben Mantissenbits. Exakte Geldbeträge gehören in ganzzahlige kleinere Währungseinheiten oder einen Dezimaltyp.