Booth-Algorithmus

Der Booth-Algorithmus ist ein Algorithmus für die Multiplikation zweier Zahlen in Zweierkomplement-Darstellung. Er wurde 1951 von Andrew Donald Booth bei Arbeiten zur Kristallographie am Birkbeck College entwickelt.

• Sei x die Bitanzahl des Multiplikanden und y die Bitanzahl des Multiplikators.
• Zeichne ein dreireihiges Raster mit x + y + 1 {\displaystyle x+y+1} Spalten. Bezeichne die Zeilen mit A (Addition), S (Subtraktion) und P (Produkt).
• Notiere die ersten x Bits jeder Zeile folgendermaßen:
  • A: Multiplikand
  • S: negierter Multiplikand (im Zweierkomplement)
  • P: Nullen
• Die nächsten y Bits jeder Zeile sind folgendermaßen zu füllen:
  • A: Nullen
  • S: Nullen
  • P: Multiplikator
• Die letzte Spalte wird mit Nullen aufgefüllt.
• Führe folgende beide Schritte y-mal durch:
  1. Sind die letzten beiden Bits von P
     • 00 oder 11: Tue nichts
     • 01 P = P + A {\displaystyle P=P+A} . Ignoriere jeglichen Überlauf.
     • 10 P = P + S {\displaystyle P=P+S} . Ignoriere jeglichen Überlauf.
  2. Schiebe das Produkt arithmetisch um eine Position nach rechts.
• In den vorderen x + y {\displaystyle x+y} Bits steht nun das Produkt (das letzte Bit wird ignoriert).

Man macht sich zunutze, dass sich jede Zahl b als Differenz zweier Zahlen c und d darstellen lässt:

Sei  b = c − d {\displaystyle {\mbox{Sei }}b=c-d}

Dann lässt sich jede beliebige Multiplikation von b mit einem Faktor a folgendermaßen umformen:

a ⋅ b = a ⋅ ( c − d ) = a ⋅ c − a ⋅ d {\displaystyle a\cdot b=a\cdot (c-d)=a\cdot c-a\cdot d}

Vorteile gegenüber der "Papier und Bleistift"-Methode bietet dieses Verfahren bei Zahlen, die in der Binärdarstellung lange gleichwertige Bitketten aufweisen. Diese werden beim Booth-Verfahren „übersprungen“. Darauf basierend erlaubt das Booth-Verfahren auch eine effiziente Multiplikation für Binärzahlen im Zweierkomplement, d. h. der Algorithmus hat den Vorteil, dass man die Vorzeichen der beiden Faktoren nicht beachten muss.

Will man 30 10 = 00011110 2 {\displaystyle 30_{10}=00011110_{2}} mit einer Zahl X multiplizieren, benötigte man bei der traditionellen Methode drei Additionen: 10 2 ⋅ X + 100 2 ⋅ X + 1000 2 ⋅ X + 10000 2 ⋅ X {\displaystyle 10_{2}\cdot X+100_{2}\cdot X+1000_{2}\cdot X+10000_{2}\cdot X} . Das Booth-Verfahren hingegen braucht nur eine: 100000 2 ⋅ X − 10 2 ⋅ X {\displaystyle 100000_{2}\cdot X-10_{2}\cdot X} .

Die Subtraktion lässt sich im Zweierkomplement wie eine Addition rechnen, die Multiplikation mit einem Vielfachen von 2 entspricht nur einer Verschiebung der Stellen nach links (Shift-Operation). Somit dient das Verfahren einer effizienten Multiplikation in Computern.

Der Booth-Algorithmus bietet eine effiziente Möglichkeit, zu einer Zahl die entsprechend zu benutzende Kodierung zu ermitteln. Man geht dabei von rechts nach links durch die Binärzahl. Wechselt die Binärstelle von der letzten zur aktuellen Position von 0 nach 1, wird eine −1, bei einem Wechsel von 1 nach 0 eine +1 und bei keinem Wechsel eine 0 gesetzt. Im ersten Schritt wird sich an die Zahl rechts eine 0 dazu gedacht.

Multipliziere 44 10 = ( 00101100 ) 2 {\displaystyle 44_{10}=(00101100)_{2}} und 17 10 = ( 00010001 ) 2 {\displaystyle 17_{10}=(00010001)_{2}}

Schritt 1	0	1	0	1	1	0	0	0
							0
Schritt 2	0	1	0	1	1	0	0	0
						0	0
Schritt 3	0	1	0	1	1	0	0	0
					-1	0	0
Schritt 4	0	1	0	1	1	0	0	0
				0	−1	0	0
Schritt 5	0	1	0	1	1	0	0	0
			+1	0	−1	0	0
Schritt 6	0	1	0	1	1	0	0	0
		-1	+1	0	−1	0	0
Schritt 7	0	1	0	1	1	0	0	0
	+1	−1	+1	0	−1	0	0

Formal: Dem mittels Booth zu kodierenden Operand Y = ( y n − 1 , … , y 0 ) {\displaystyle Y=(y_{n-1},\dots ,y_{0})} füge man eine weitere "Stelle" y − 1 {\displaystyle y_{-1}} an, die auf Null gesetzt wird. Die weiteren Stellen y ′ i , i ∈ { 0 , … , n − 1 } {\displaystyle {y'}_{i},i\in \left\{0,\dots ,n-1\right\}} des neuen Y ′ := ( y n − 1 ′ , … , y 0 ′ , y − 1 ) {\displaystyle Y':=(y'_{n-1},\dots ,y'_{0},y_{-1})} werden wie folgt berechnet: y ′ i = y i − 1 − y i   ∀ i ∈ { 0 , … , n − 1 } {\displaystyle {y'}_{i}=y_{i-1}-y_{i}\ \forall i\in \{0,\dots ,n-1\}} .

									0	0	0	1	0	0	0	1	2. Faktor
x									0	+1	−1	+1	0	−1	0	0	Kodierung des 1. Faktors
+		0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	keine Addition
+		0	0	0	0	0	0	0	0	0	0	0	0	0	0		keine Addition
+		1	1	1	1	1	1	1	1	0	1	1	1	1			2er-Komplement (2. Faktor)
+		0	0	0	0	0	0	0	0	0	0	0	0				keine Addition
+		0	0	0	0	0	0	1	0	0	0	1					2. Faktor
+		1	1	1	1	1	0	1	1	1	1						2er-Komplement (2. Faktor)
+		0	0	0	0	1	0	0	0	1							2. Faktor
+		0	0	0	0	0	0	0	0								keine Addition
1	0	0	0	0	0	0	1	0	1	1	1	0	1	1	0	0	Ergebnis ohne Überlauf

Statt mit 0100000, 0001000 und 0000100 zu multiplizieren und die Ergebnisse zu addieren, wird nun also mit 1000000, 0100000, 0010000 und 0000100 multipliziert und entsprechend die Ergebnisse addiert bzw. subtrahiert.

Wie man am Beispiel sieht, kann sich die Anzahl der Additionen auch erhöhen (im Beispiel von 3 auf 4), was ja aber gerade nicht erwünscht ist. Im statistischen Durchschnitt werden im Booth-Verfahren genauso viele Additionen gebraucht wie ohne Booth-Verfahren. Der Vorteil liegt aber darin, dass in der Informatik keine Gleichverteilung von Zahlen vorliegt. Vielmehr gibt es häufig Zahlen mit vielen Nullen und durch das Zweierkomplement bei negativen Zahlen häufig viele Einsen am Anfang. Nur durch diese Tatsache hat das Booth-Verfahren Vorteile gegenüber einer normalen Multiplikation.

Die Erweiterung des Booth-Verfahrens ist das Bit-Pair-Verfahren, bei dem immer zwei Stellen zusammengefasst werden.

• APEXC-Computer

• The work of Professor Andrew D. Booth, Department of Computer Science and Information Systems, Birkbeck College (engl.)

• automatisches Ausrechnen einer Booth-Multiplikation