Karatsuba algorithm

The Karatsuba multiplication algorithm, a technique for quickly multiplying large numbers, was discovered by Anatolii Alexeevich Karatsuba in 1960 and published in the joint paper with Yu. Ofman in 1962. It reduces the multiplication of two n-digit numbers to ${\displaystyle n^{\log _{2}3}\approx n^{1.585}}$ single-digit multiplications. This makes it faster than the classical algorithm, which requires n² single-digit products. If n = 2¹⁰ = 1024, for example, the counts are 3¹⁰ = 59,049 and (2¹⁰)² = 1,048,576, respectively.

The Toom-Cook algorithm is a faster generalization of Karatsuba's. For sufficiently large n, Karatsuba's algorithm is beaten by the Schönhage-Strassen algorithm.

The Karatsuba algorithm is a notable example of the divide and conquer paradigm, specifically of binary splitting.

Algorithm

The basic step of Karatsuba's algorithm is a formula that allows us to compute the product of two large numbers x and y using three multiplications of smaller numbers, each with about half as many digits as x or y, plus some additions and digit shifts.

Let x and y be represented as n-digit strings in some base B. For any positive integer m less than n, one can split the two given numbers as follows

x = x₁B^m + x₀

y = y₁B^m + y₀

where x₀ and y₀ are less than B^m. The product is then

xy = (x₁B^m + x₀)(y₁B^m + y₀)

= z₂ B^2m + z₁ B^m + z₀

where

z₂ = x₁y₁

z₁ = x₁y₀ + x₀y₁

z₀ = x₀y₀

These formulas require four multiplications. Karatsuba observed that we can compute xy in only three multiplications, at the cost of a few extra additions:

Let z₂ = x₁y₁

Let z₀ = x₀y₀

Let z₁ = (x₁ + x₀)(y₁ + y₀) - z₂ - z₀

since

z₁ = (x₁y₁ + x₁y₀ + x₀y₁ + x₀y₀) - x₁y₁ - x₀y₀ = x₁y₀ + x₀y₁

To compute these three products of m-digit numbers, we can recursively employ Karatsuba multiplication again, until the numbers become so small that their product can be computed directly. One typically chooses B so that this condition is verified when the numbers are 1 digit each. In a computer with a full 32-bit by 32-bit multiplier, for example, one could choose B = 2³² or B = 10⁹, and store each digit as a separate 32-bit binary word.

Example

Say we want to compute the product of 1234 and 5678. We choose B = 10 and m = 2. We have

12 34 = 12 × 10² + 34

56 78 = 56 × 10² + 78

z₂ = 12 × 56 = 672

z₀ = 34 × 78 = 2652

z₁ = (12 + 34)(56 + 78) - z₂ - z₀ = 46 × 134 - 672 - 2652 = 2840

result = z₂ × 10^2×2 + z₁ × 10² + z₀ = 672 0000 + 2840 00 + 2652 = 7006652

Efficiency analysis

Karatsuba's basic step works for any base B and any m, but the recursive algorithm is most efficient when, and m is equal to n/2, rounded up. In particular, if n is 2^k, for some integer k, and the recursion stops only when n is 1, then the number of single-digit multiplications is 3^k, which is n^c where c = log₂3.

Since one can extend any inputs with zero digits until their length is a power of two, it follows that the number of elementary multiplications, for any n, is at most ${\displaystyle 3^{\lceil \log _{2}n\rceil }\leq 3n^{\log _{2}3}}$ .

Since the additions, subtractions, and digit shifts (multiplications by powers of B) in Karasuba's basic step take time proportional to n, their cost of all becomes negligible as n increases. More precisely, if t(n) denotes the total number of elementary operations that the algorithm performs when multiplying two n-digit numbers, then we can write

t(n) = 3 t(${\displaystyle \lceil }$ n/2${\displaystyle \rceil }$ ) + cn + d

for some constants c and d. For this recurrence relation, the master theorem gives the asymptotic bound t(n) = Θ(n^{log(3)/log(2)}).

It follows that, for sufficiently large n, Karatsuba's algorithm will perform fewer shifts and single-digit additions than longhand multiplication, even though its basic step uses more additions and shifts than the straightforward formula. For small values of n, however, the extra shift and add operations may make it run slower than the longhand method. The point of positive return depends on the computer platform and context. As a rule of thumb, Karatsuba is usually faster when n is 10 or more [1][2]

References

• A. Karatsuba and Yu Ofman, Multiplication of Many-Digital Numbers by Automatic Computers. Doklady Akad. Nauk SSSR, Vol. 145 (1962), pp. 293–294. Translation in Physics-Doklady, 7 (1963), pp. 595–596.
• Karacuba A. A. Berechnungen und die Kompliziertheit von Beziehungen (German). Elektron. Informationsverarb. Kybernetik, 11, 603–606 (1975).
• Karatsuba A. A. The complexity of computations. Proc. Steklov Inst. Math., 211, 169–183 (1995); translation from Trudy Mat. Inst. Steklova, 211, 186–202 (1995).
• Knuth D.E. The art of computer programming. v.2. Addison-Wesley Publ.Co., 724 pp., Reading (1969).
• Karatsuba Multiplication on MathWorld
• Bernstein, D. J., "Multidigit multiplication for mathematicians". Covers Karatsuba and many other multiplication algorithms.
• Karatsuba Multiplication on Fast Algorithms and the FEE
• Karatsuba Multiplication using Squares of a Difference

External links

• Karatsuba multiplication Algorithm - Web Based Calculator (GPL)