布斯乘法Booth's multiplication algorithm from wikipedia

Booth‘s multiplication algorithm is a multiplication algorithm that multiplies two signed binary numbers in two‘s complement notation. The algorithm was invented by Andrew Donald Booth in 1950 while doing research on crystallography at Birkbeck College in Bloomsbury, London.^[1] Booth‘s algorithm is of interest in the study of computer architecture.

Booth的乘法算法是一种将两个有符号的二进制数乘以2的补码表示法的乘法算法。该算法是由发明安德鲁·唐纳德·布斯，在做研究，1950年晶体在伯克贝克学院在布卢姆斯伯里，伦敦。^[1] Booth的算法在计算机体系结构的研究中很有用。

The algorithm[edit]

Booth‘s algorithm examines adjacent pairs of bits of the ‘N‘-bit multiplier Y in signed two‘s complement representation, including an implicit bit below the least significant bit, y₋₁ = 0. For each bit y_i, for i running from 0 to N − 1, the bits y_i and y_i−1 are considered. Where these two bits are equal, the product accumulator P is left unchanged. Where y_i = 0 and y_i−1 = 1, the multiplicand times 2ⁱ is added to P; and where y_i = 1 and y_i−1 = 0, the multiplicand times 2ⁱ is subtracted from P. The final value of P is the signed product.

The representations of the multiplicand and product are not specified; typically, these are both also in two‘s complement representation, like the multiplier, but any number system that supports addition and subtraction will work as well. As stated here, the order of the steps is not determined. Typically, it proceeds from LSB to MSB, starting at i = 0; the multiplication by 2ⁱ is then typically replaced by incremental shifting of the P accumulator to the right between steps; low bits can be shifted out, and subsequent additions and subtractions can then be done just on the highest N bits of P.^[2] There are many variations and optimizations on these details.....

The algorithm is often described as converting strings of 1s in the multiplier to a high-order +1 and a low-order −1 at the ends of the string. When a string runs through the MSB, there is no high-order +1, and the net effect is interpretation as a negative of the appropriate value.

布斯算法检查相邻的对位的“N‘位乘法器的ý登入二的补码表示法，包括下面的一个隐式的位至少显著位，ÿ _-1 = 0。对于每个比特ÿ _我，为我从0运行N -1，考虑比特y _i和y _i -1。在这两位相等的情况下，乘积累加器P保持不变。其中y _i = 0和 y _i -1= 1，被乘数2 ⁱ加到P上；在y _i = 1且y _i-1 = 0的情况下，被乘数2 ⁱ从P中减去。P的最终值为签名产品。

没有指定被乘数和乘积的表示；通常，它们也都用二进制补码表示，例如乘法器，但是任何支持加法和减法的数字系统也将起作用。如此处所述，步骤的顺序不确定。通常，它从LSB到MSB，从i = 0开始；然后通常将乘以2 ⁱ的乘积替换为P累加器在各步之间向右移动；可以移出低位，然后可以仅对P的最高N位进行后续的加法和减法。^[2] 这些细节有很多变化和优化。

该算法通常被描述为将乘法器中的1的字符串转换为字符串末尾的高阶+1和低阶-1。当字符串穿过MSB时，没有高阶+1，并且净效应被解释为适当值的负数。

A typical implementation[edit]

A Walther WSR160 arithmometer from 1960. Each turn of the crank handle adds (up) or subtracts (down) the operand set to the top register from the value in the accumulator register at the bottom. Shifting the adder left or right multiplies the effect by ten.

Booth‘s algorithm can be implemented by repeatedly adding (with ordinary unsigned binary addition) one of two predetermined values A and S to a product P, then performing a rightward arithmetic shift on P. Let m and r be the multiplicand and multiplier, respectively; and let x and y represent the number of bits in m and r.

1. Determine the values of A and S, and the initial value of P. All of these numbers should have a length equal to (x + y + 1).
   1. A: Fill the most significant (leftmost) bits with the value of m. Fill the remaining (y + 1) bits with zeros.
   2. S: Fill the most significant bits with the value of (−m) in two‘s complement notation. Fill the remaining (y + 1) bits with zeros.
   3. P: Fill the most significant x bits with zeros. To the right of this, append the value of r. Fill the least significant (rightmost) bit with a zero.
2. Determine the two least significant (rightmost) bits of P.
   1. If they are 01, find the value of P + A. Ignore any overflow.
   2. If they are 10, find the value of P + S. Ignore any overflow.
   3. If they are 00, do nothing. Use P directly in the next step.
   4. If they are 11, do nothing. Use P directly in the next step.
3. Arithmetically shift the value obtained in the 2nd step by a single place to the right. Let P now equal this new value.
4. Repeat steps 2 and 3 until they have been done y times.
5. Drop the least significant (rightmost) bit from P. This is the product of m and r.

布斯算法可通过以下方式实现：将两个预定值A和S之一（用普通的无符号二进制加法）重复加到乘积P上，然后对P进行向右的算术移位。令m和r分别为被乘数和乘数；令x和y表示m和r中的位数。

1. 确定A和S的值以及P的初始值。所有这些数字的长度应等于（x  +  y  + 1）。
   1. 答：将m的值填充到最高有效（最左边）位。 用零填充其余的（y + 1）位。
   2. S：用二进制补码表示的（-m）值填充最高有效位。 用零填充其余的（y + 1）位。
   3. P：用零填充最高有效的x位。在此右边，添加r的值。用零填充最低有效（最右边）位。
2. 确定P的两个最低有效（最右边）位。
   1. 如果它们是01，则找到P  +  A的值。忽略任何溢出。
   2. 如果它们是10，则找到P  +  S的值。忽略任何溢出。
   3. 如果它们是00，则什么也不做。在下一步中直接使用P。
   4. 如果它们是11，则什么都不做。在下一步中直接使用P。
3. 算术地将在第二步中获得的值向右移一个位置。现在让P等于这个新值。
4. 重复步骤2和3，直到完成y次。
5. 从P删除最低有效（最右边）位。这是m和r的乘积。

Example[edit]

Find 3 × (−4), with m = 3 and r = −4, and x = 4 and y = 4:

• m = 0011, -m = 1101, r = 1100
• A = 0011 0000 0
• S = 1101 0000 0
• P = 0000 1100 0
• Perform the loop four times:
  1. P = 0000 1100 0. The last two bits are 00.
     • P = 0000 0110 0. Arithmetic right shift.
  2. P = 0000 0110 0. The last two bits are 00.
     • P = 0000 0011 0. Arithmetic right shift.
  3. P = 0000 0011 0. The last two bits are 10.
     • P = 1101 0011 0. P = P + S.
     • P = 1110 1001 1. Arithmetic right shift.
  4. P = 1110 1001 1. The last two bits are 11.
     • P = 1111 0100 1. Arithmetic right shift.
• The product is 1111 0100, which is −12.

The above-mentioned technique is inadequate when the multiplicand is the most negative number that can be represented (e.g. if the multiplicand has 4 bits then this value is −8). One possible correction to this problem is to add one more bit to the left of A, S and P. This then follows the implementation described above, with modifications in determining the bits of A and S; e.g., the value of m, originally assigned to the first x bits of A, will be assigned to the first x+1 bits of A. Below, the improved technique is demonstrated by multiplying −8 by 2 using 4 bits for the multiplicand and the multiplier:

• A = 1 1000 0000 0
• S = 0 1000 0000 0
• P = 0 0000 0010 0
• Perform the loop four times:
  1. P = 0 0000 0010 0. The last two bits are 00.
     • P = 0 0000 0001 0. Right shift.
  2. P = 0 0000 0001 0. The last two bits are 10.
     • P = 0 1000 0001 0. P = P + S.
     • P = 0 0100 0000 1. Right shift.
  3. P = 0 0100 0000 1. The last two bits are 01.
     • P = 1 1100 0000 1. P = P + A.
     • P = 1 1110 0000 0. Right shift.
  4. P = 1 1110 0000 0. The last two bits are 00.
     • P = 1 1111 0000 0. Right shift.
• The product is 11110000 (after discarding the first and the last bit) which is −16.

求3×（−4），m = 3且r = −4，x = 4且y = 4：

• m = 0011，-m = 1101，r = 1100
• A = 0011 0000 0
• S = 1101 0000 0
• P = 0000 1100 0
• 循环执行四次：
  1. P = 0000 110 0 0。最后两位是00。
     • P = 0000 01100。算术右移。
  2. P = 0000 011 0 0。最后两位是00。
     • P = 0000 00110。算术右移。
  3. P = 0000 001 1 0。最后两位是10。
     • P = 1101 00110。P= P +S。
     • P = 1110 1001 1.算术右移。
  4. P ＝ 1110 100 1 1。最后两位是11。
     • P = 1111 0100 1.算术右移。
• 乘积是1111 0100，即-12。

当被乘数是可以表示的最负数时（例如，如果被乘数有4位，则该值为-8），上述技术是不够的。对这个问题的一种可能的纠正方法是在A，S和P的左边再增加一位。然后，按照上面描述的实现方法，对A和S的位进行修改。例如，最初分配给A 的前x位的m值将分配给A的前x +1位。下面，通过对乘数和4使用4位将-8乘以2来演示改进的技术。乘数：

• A = 1 1000 0000 0
• S = 0 1000 0000 0
• P = 0 0000 0010 0
• 循环执行四次：
  1. P = 0 0000 001 0 0。最后两位是00。
     • P = 0 0000 00010。右移。
  2. P = 0 0000 000 1 0。最后两位是10。
     • P = 0 1000 00010。P= P +S。
     • P = 0 0100 0000 1.右移。
  3. P = 0 0100 000 0 1。最后两位是01。
     • P = 1 1100 0000 1. P = P +A。
     • P = 1 1110 00000。右移。
  4. P = 1 1110 000 0 0。最后两位是00。
     • P = 1 1111 00000。右移。
• 乘积为11110000（在丢弃第一位和最后一位后）为-16。

How it works[edit]

Consider a positive multiplier consisting of a block of 1s surrounded by 0s. For example, 00111110. The product is given by:

{\displaystyle M\times \,^{\prime \prime }0\;0\;1\;1\;1\;1\;1\;0\,^{\prime \prime }=M\times (2^{5}+2^{4}+2^{3}+2^{2}+2^{1})=M\times 62}

where M is the multiplicand. The number of operations can be reduced to two by rewriting the same as

{\displaystyle M\times \,^{\prime \prime }0\;1\;0\;0\;0\;0{\mbox{-1}}\;0\,^{\prime \prime }=M\times (2^{6}-2^{1})=M\times 62.}

In fact, it can be shown that any sequence of 1s in a binary number can be broken into the difference of two binary numbers:

{\displaystyle (\ldots 0\overbrace {1\ldots 1} ^{n}0\ldots )_{2}\equiv (\ldots 1\overbrace {0\ldots 0} ^{n}0\ldots )_{2}-(\ldots 0\overbrace {0\ldots 1} ^{n}0\ldots )_{2}.}

Hence, the multiplication can actually be replaced by the string of ones in the original number by simpler operations, adding the multiplier, shifting the partial product thus formed by appropriate places, and then finally subtracting the multiplier. It is making use of the fact that it is not necessary to do anything but shift while dealing with 0s in a binary multiplier, and is similar to using the mathematical property that 99 = 100 − 1 while multiplying by 99.

This scheme can be extended to any number of blocks of 1s in a multiplier (including the case of a single 1 in a block). Thus,

{\displaystyle M\times \,^{\prime \prime }0\;0\;1\;1\;1\;0\;1\;0\,^{\prime \prime }=M\times (2^{5}+2^{4}+2^{3}+2^{1})=M\times 58}

{\displaystyle M\times \,^{\prime \prime }0\;1\;0\;0{\mbox{-1}}\;1{\mbox{-1}}\;0\,^{\prime \prime }=M\times (2^{6}-2^{3}+2^{2}-2^{1})=M\times 58.}

Booth‘s algorithm follows this old scheme by performing an addition when it encounters the first digit of a block of ones (0 1) and a subtraction when it encounters the end of the block (1 0). This works for a negative multiplier as well. When the ones in a multiplier are grouped into long blocks, Booth‘s algorithm performs fewer additions and subtractions than the normal multiplication algorithm.

布斯乘法Booth's multiplication algorithm from wikipedia

原文地址：https://www.cnblogs.com/LinQingYang/p/11728930.html