Karatsuba algorithm
From Wikipedia, the free encyclopedia
The Karatsuba algorithm is an efficient procedure for multiplying large numbers that was discovered by Anatolii Alexeevitch Karatsuba in 1960 and published in 1962 [1] [2]. It reduces the multiplication of two n-digit numbers to at most 
single-digit multiplications. It is therefore faster than the classical algorithm, which requires n2 single-digit products. If n = 210 = 1024, in particular, the exact counts are 310 = 59,049 and (210)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. The name 'divide and conquer' was first used for this method[citation needed].
Contents |
[edit] History
The standard procedure for multiplication of two n-digit numbers requires a number of elementary operations proportional to n2, or Θ(n2) in the big-O notation. In 1952, Andrey Kolmogorov conjectured that the classical algorithm was asymptotically optimal, meaning that any algorithm for that task would require Ω(n2) elementary operations.
In Autumn 1960, Kolmogorov organized a seminar on mathematical problems in cybernetics at the Moscow State University, where he stated the Ω(n2) conjecture and other problems in the complexity of computation. Within a week, Karatsuba, then a 25-year-old student, found a divide and conquer algorithm that multiplies two n-digit numbers in 
elementary steps, thus disproving the conjecture. Kolmogorov was very upset about the discovery; he communicated it at the next meeting of the seminar, which was then terminated [2].
The method was published in 1962, in the Proceedings of the USSR Academy of Sciences [1]. The article had been written by Kolmogorov, possibly in collaboration with Yuri Ofman, but listed "A. Karatsuba and Yu. Ofman" as the authors. Karatsuba only became aware of the paper when he received the reprints from the publisher [2].
[edit] Algorithm
[edit] The basic step
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 = x1Bm + x0
- y = y1Bm + y0
where x0 and y0 are less than Bm. The product is then
- xy = (x1Bm + x0)(y1Bm + y0)
- = z2 B2m + z1 Bm + z0
where
- z2 = x1y1
- z1 = x1y0 + x0y1
- z0 = x0y0
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 z2 = x1y1
- Let z0 = x0y0
- Let z1 = (x1 + x0)(y1 + y0) − z2 − z0
since
- z1 = (x1y1 + x1y0 + x0y1 + x0y0) - x1y1 - x0y0 = x1y0 + x0y1
[edit] Example
Say we want to compute the product of 1234 and 5678. We choose B = 10 and m = 2. We have
- 12 34 = 12 × 102 + 34
- 56 78 = 56 × 102 + 78
- z2 = 12 × 56 = 672
- z0 = 34 × 78 = 2652
- z1 = (12 + 34)(56 + 78) − z2 − z0 = 46 × 134 − 672 − 2652 = 2840
- result = z2 × 102×2 + z1 × 102 + z0 = 672 × 10000 + 2840 × 100 + 2652 = 7006652
[edit] Recursive application
If n is four or more, the three multiplications in Karatsuba's basic step involve operands with less than n digits. Therefore, those products can be computed by recursive calls of the Karatsuba algorithm. The recursion can be applied until the numbers are so small that they can (or must) be computed directly.
In a computer with a full 32-bit by 32-bit multiplier, for example, one could choose B = 231 = 2,147,483,648 or B = 109 = 1,000,000,000, and store each digit as a separate 32-bit binary word. Then the sums x1 + x0 and y1 + y0 will not need an extra carry-over digit (as in carry-save adder), and the Karatsuba recursion can be applied until the numbers are only 1 digit long.
[edit] Efficiency analysis
Karatsuba's basic step works for any base B and any m, but the recursive algorithm is most efficient when m is equal to n/2, rounded up. In particular, if n is 2k, for some integer k, and the recursion stops only when n is 1, then the number of single-digit multiplications is 3k, which is nc where c = log23.
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 
.
Since the additions, subtractions, and digit shifts (multiplications by powers of B) in Karatsuba's basic step take time proportional to n, their cost 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(
n/2
) + cn + d
for some constants c and d. For this recurrence relation, the master theorem gives the asymptotic bound t(n) = Θ(nlog(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 the multiplicands are 2320 ≈ 2 × 1096 or more [1][2]
[edit] Notes
[edit] References
- Karacuba A. A. Berechnungen und die Kompliziertheit von Beziehungen (German). Elektron. Informationsverarb. Kybernetik, 11, 603–606 (1975).
- 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
