Integer division (unsigned) with remainder

The following algorithm, the binary version of the famous long division, will divide N by D, placing the quotient in Q and the remainder in R. In the following pseudo-code, all values are treated as unsigned integers.

if D = 0 then error(DivisionByZeroException) end
Q := 0                  -- Initialize quotient and remainder to zero
R := 0                     
for i := n − 1 .. 0 do  -- Where n is number of bits in N
  R := R << 1           -- Left-shift R by 1 bit
  R(0) := N(i)          -- Set the least-significant bit of R equal to bit i of the numerator
  if R ≥ D then
    R := R − D
    Q(i) := 1
  end
end

Restoring division

Restoring division operates on fixed-point fractional numbers and depends on the assumption 0 < D < N.

The quotient digits q are formed from the digit set {0,1}.

The basic algorithm for binary (radix 2) restoring division is:

R := N
D := D << n            -- R and D need twice the word width of N and Q
for i := n − 1 .. 0 do  -- For example 31..0 for 32 bits
  R := 2 * R − D          -- Trial subtraction from shifted value (multiplication by 2 is a shift in binary representation)
  if R >= 0 then
    q(i) := 1          -- Result-bit 1
  else
    q(i) := 0          -- Result-bit 0
    R := R + D         -- New partial remainder is (restored) shifted value
  end
end

-- Where: N = numerator, D = denominator, n = #bits, R = partial remainder, q(i) = bit #i of quotient

Non-performing restoring division is similar to restoring division except that the value of 2R is saved, so D does not need to be added back in for the case of R < 0.

Non-restoring division

Non-restoring division uses the digit set {−1, 1} for the quotient digits instead of {0, 1}. The algorithm is more complex, but has the advantage when implemented in hardware that there is only one decision and addition/subtraction per quotient bit; there is no restoring step after the subtraction,^[3] which potentially cuts down the numbers of operations by up to half and lets it be executed faster.^[4] The basic algorithm for binary (radix 2) non-restoring division of non-negative numbers is:

R := N
D := D << n            -- R and D need twice the word width of N and Q
for i = n − 1 .. 0 do  -- for example 31..0 for 32 bits
  if R >= 0 then
    q(i) := +1
    R := 2 * R − D
  else
    q(i) := −1
    R := 2 * R + D
  end if
end
 
-- Note: N=numerator, D=denominator, n=#bits, R=partial remainder, q(i)=bit #i of quotient.

Following this algorithm, the quotient is in a non-standard form consisting of digits of −1 and +1. This form needs to be converted to binary to form the final quotient. Example:

Convert the following quotient to the digit set {0,1}:
Start:	${\displaystyle Q=111{\bar {1}}1{\bar {1}}1{\bar {1}}}$
1. Form the positive term:	${\displaystyle P=11101010\,}$
2. Mask the negative term*:	${\displaystyle M=00010101\,}$
3. Subtract: ${\displaystyle P-M}$:	${\displaystyle Q=11010101\,}$
*.( Signed binary notation with ones' complement without two's complement)

If the −1 digits of ${\displaystyle Q}$ are stored as zeros (0) as is common, then ${\displaystyle P}$ is ${\displaystyle Q}$ and computing ${\displaystyle M}$ is trivial: perform a ones' complement (bit by bit complement) on the original ${\displaystyle Q}$.

Q := Q − bit.bnot(Q)      -- Appropriate if −1 digits in Q are represented as zeros as is common.

Finally, quotients computed by this algorithm are always odd, and the remainder in R is in the range −D ≤ R < D. For example, 5 / 2 = 3 R −1. To convert to a positive remainder, do a single restoring step after Q is converted from non-standard form to standard form:

if R < 0 then
  Q := Q − 1
  R := R + D  -- Needed only if the remainder is of interest.
end if

The actual remainder is R >> n. (As with restoring division, the low-order bits of R are used up at the same rate as bits of the quotient Q are produced, and it is common to use a single shift register for both.)

SRT division

SRT division is a popular method for division in many microprocessor implementations.^[5][6] The algorithm is named after D.W. Sweeney of IBM, James E. Robertson of University of Illinois, and K. D. Tocher of Imperial College London. They all developed the algorithm independently at approximately the same time (published in February 1957, September 1958, and January 1958 respectively).^[7][8][9]

SRT division is similar to non-restoring division, but it uses a lookup table based on the dividend and the divisor to determine each quotient digit.

The most significant difference is that a redundant representation is used for the quotient. For example, when implementing radix-4 SRT division, each quotient digit is chosen from five possibilities: { −2, −1, 0, +1, +2 }. Because of this, the choice of a quotient digit need not be perfect; later quotient digits can correct for slight errors. (For example, the quotient digit pairs (0, +2) and (1, −2) are equivalent, since 0×4+2 = 1×4−2.) This tolerance allows quotient digits to be selected using only a few most-significant bits of the dividend and divisor, rather than requiring a full-width subtraction. This simplification in turn allows a radix higher than 2 to be used.

Like non-restoring division, the final steps are a final full-width subtraction to resolve the last quotient bit, and conversion of the quotient to standard binary form.

The Intel Pentium processor's infamous floating-point division bug was caused by an incorrectly coded lookup table. Five of the 1066 entries had been mistakenly omitted.^[10][11]

Newton–Raphson division

Newton–Raphson uses Newton's method to find the reciprocal of ${\displaystyle D}$ and multiply that reciprocal by ${\displaystyle N}$ to find the final quotient ${\displaystyle Q}$.

The steps of Newton–Raphson division are:

1. Calculate an estimate ${\displaystyle X_{0}}$ for the reciprocal ${\displaystyle 1/D}$ of the divisor ${\displaystyle D}$.
2. Compute successively more accurate estimates ${\displaystyle X_{1},X_{2},\ldots ,X_{S}}$ of the reciprocal. This is where one employs the Newton–Raphson method as such.
3. Compute the quotient by multiplying the dividend by the reciprocal of the divisor: ${\displaystyle Q=NX_{S}}$.

In order to apply Newton's method to find the reciprocal of ${\displaystyle D}$, it is necessary to find a function ${\displaystyle f(X)}$ that has a zero at ${\displaystyle X=1/D}$. The obvious such function is ${\displaystyle f(X)=DX-1}$, but the Newton–Raphson iteration for this is unhelpful, since it cannot be computed without already knowing the reciprocal of ${\displaystyle D}$ (moreover it attempts to compute the exact reciprocal in one step, rather than allow for iterative improvements). A function that does work is ${\displaystyle f(X)=(1/X)-D}$, for which the Newton–Raphson iteration gives

$${\displaystyle X_{i+1}=X_{i}-{f(X_{i}) \over f'(X_{i})}=X_{i}-{1/X_{i}-D \over -1/X_{i}^{2}}=X_{i}+X_{i}(1-DX_{i})=X_{i}(2-DX_{i}),}$$

which can be calculated from ${\displaystyle X_{i}}$ using only multiplication and subtraction, or using two fused multiply–adds.

From a computation point of view, the expressions ${\displaystyle X_{i+1}=X_{i}+X_{i}(1-DX_{i})}$ and ${\displaystyle X_{i+1}=X_{i}(2-DX_{i})}$ are not equivalent. To obtain a result with a precision of 2n bits while making use of the second expression, one must compute the product between ${\displaystyle X_{i}}$ and ${\displaystyle (2-DX_{i})}$ with double the given precision of ${\displaystyle X_{i}}$(n bits). In contrast, the product between ${\displaystyle X_{i}}$ and ${\displaystyle (1-DX_{i})}$ need only be computed with a precision of n bits, because the leading n bits (after the binary point) of ${\displaystyle (1-DX_{i})}$ are zeros.

If the error is defined as ${\displaystyle \varepsilon _{i}=1-DX_{i}}$, then:

${\displaystyle {\begin{aligned}\varepsilon _{i+1}&=1-DX_{i+1}\\&=1-D(X_{i}(2-DX_{i}))\\&=1-2DX_{i}+D^{2}X_{i}^{2}\\&=(1-DX_{i})^{2}\\&={\varepsilon _{i}}^{2}.\\\end{aligned}}}$

This squaring of the error at each iteration step – the so-called quadratic convergence of Newton–Raphson's method – has the effect that the number of correct digits in the result roughly doubles for every iteration, a property that becomes extremely valuable when the numbers involved have many digits (e.g. in the large integer domain). But it also means that the initial convergence of the method can be comparatively slow, especially if the initial estimate ${\displaystyle X_{0}}$ is poorly chosen.

For the subproblem of choosing an initial estimate ${\displaystyle X_{0}}$, it is convenient to apply a bit-shift to the divisor D to scale it so that 0.5 ≤ D ≤ 1; by applying the same bit-shift to the numerator N, one ensures the quotient does not change. Then one could use a linear approximation in the form

${\displaystyle X_{0}=T_{1}+T_{2}D\approx {\frac {1}{D}}\,}$

to initialize Newton–Raphson. To minimize the maximum of the absolute value of the error of this approximation on interval ${\displaystyle [0.5,1]}$, one should use

${\displaystyle X_{0}={48 \over 17}-{32 \over 17}D.\,}$

The coefficients of the linear approximation are determined as follows. The absolute value of the error is ${\displaystyle |\varepsilon _{0}|=|1-D(T_{1}+T_{2}D)|}$. The minimum of the maximum absolute value of the error is determined by the Chebyshev equioscillation theorem applied to ${\displaystyle F(D)=1-D(T_{1}+T_{2}D)}$. The local minimum of ${\displaystyle F(D)}$ occurs when ${\displaystyle F'(D)=0}$, which has solution ${\displaystyle D=-T_{1}/(2T_{2})}$. The function at that minimum must be of opposite sign as the function at the endpoints, namely, ${\displaystyle F(1/2)=F(1)=-F(-T_{1}/(2T_{2}))}$. The two equations in the two unknowns have a unique solution ${\displaystyle T_{1}=48/17}$ and ${\displaystyle T_{2}=-32/17}$, and the maximum error is ${\displaystyle F(1)=1/17}$. Using this approximation, the absolute value of the error of the initial value is less than

${\displaystyle \vert \varepsilon _{0}\vert \leq {1 \over 17}\approx 0.059.\,}$

It is possible to generate a polynomial fit of degree larger than 1, computing the coefficients using the Remez algorithm. The trade-off is that the initial guess requires more computational cycles but hopefully in exchange for fewer iterations of Newton–Raphson.

Since for this method the convergence is exactly quadratic, it follows that

${\displaystyle S=\left\lceil \log _{2}{\frac {P+1}{\log _{2}17}}\right\rceil \,}$

steps are enough to calculate the value up to ${\displaystyle P\,}$ binary places. This evaluates to 3 for IEEE single precision and 4 for both double precision and double extended formats.

Express D as M × 2e where 1 ≤ M < 2 (standard floating point representation)
D' := D / 2e+1   // scale between 0.5 and 1, can be performed with bit shift / exponent subtraction
N' := N / 2e+1
X := 48/17 − 32/17 × D'   // precompute constants with same precision as D
repeat ${\displaystyle \left\lceil \log _{2}{\frac {P+1}{\log _{2}17}}\right\rceil \,}$ times   // can be precomputed based on fixed P
    X := X + X × (1 - D' × X) / 2
end
return N' × X

Goldschmidt division

Goldschmidt division^[12] (after Robert Elliott Goldschmidt)^[13] uses an iterative process of repeatedly multiplying both the dividend and divisor by a common factor F_i, chosen such that the divisor converges to 1. This causes the dividend to converge to the sought quotient Q:

${\displaystyle Q={\frac {N}{D}}{\frac {F_{1}}{F_{1}}}{\frac {F_{2}}{F_{2}}}{\frac {F_{\ldots }}{F_{\ldots }}}.}$

The steps for Goldschmidt division are:

1. Generate an estimate for the multiplication factor F_i .
2. Multiply the dividend and divisor by F_i .
3. If the divisor is sufficiently close to 1, return the dividend, otherwise, loop to step 1.

Assuming N/D has been scaled so that 0 < D < 1, each F_i is based on D:

${\displaystyle F_{i+1}=2-D_{i}.}$

Multiplying the dividend and divisor by the factor yields:

${\displaystyle {\frac {N_{i+1}}{D_{i+1}}}={\frac {N_{i}}{D_{i}}}{\frac {F_{i+1}}{F_{i+1}}}.}$

After a sufficient number k of iterations ${\displaystyle Q=N_{k}}$.

The Goldschmidt method is used in AMD Athlon CPUs and later models.^[14][15] It is also known as Anderson Earle Goldschmidt Powers (AEGP) algorithm and is implemented by various IBM processors.^[16][17] Although it converges at the same rate as a Newton–Raphson implementation, one advantage of the Goldschmidt method is that the multiplications in the numerator and in the denominator can be done in parallel.^[17]