Algoritmos de multiplicación de N dígitos

José Pino

Universidad Nacional de AsunciónFacultad PolitécnicaIngeniería en Informática

Junio 2010

Karatsuba (1960)

• Paradigma Divide y vencerás (se usó por primera vez este término).

• El método fue publicado en 1962, en la revista científica soviética

Proceedings of the USSR Academy of Sciences. El artículo había

sido escrito por Kolmogorov, posiblemente en colaboración con Yuri

Ofman, pero nombraba a "A. Karatsuba y Yu. Ofman" como los

autores. Karatsuba sólo se dio cuenta de la publicación cuando

recibió una copia del artículo por parte de la editorial de la revista.

• Complejidad Θ(nlog3) -> Θ(n1.58)

• Toom-Cook de complejidad Θ(nlog(5)/log(3)), aproximadamente Θ(n1.465).

• En general, Toom-k ejecuta en Θ(c(k) ne), donde e = log(2k − 1) / log(k), ne es el

tiempo de las submultiplicaciones, y c es el tiempo de las multiplicaciones y

sumas constantes.

• El algoritmo de Schönhage–Strassen tiene complejidad Θ(n log n log log n)).

• El algoritmo de Schönhage–Strassen fue el algoritmo asintóticamente más rápido

de multiplicación de 1971 a 2007 cuando un nuevo método, el algoritmo de

Martin Fürer, fue anunciado con complejidad asintótica más baja, de todos

modos, el algoritmo de Fürer actualmente sólo logra una ventaja para los valores

astronómicamente grandes y no se utiliza en la práctica.

Toom-Cook

Schönhage–Strassen

x*y cadenas de n dígitos en base B

para cualquier entero positivo m<n

x = x1Bm+ x0

y = y1Bm + y0

x0 e y0 menores que Bm

x*y = (x1Bm + x0)(y1B

m + y0)

= x1Bmy1B

m + x1Bmy0 + x0y1B

m + x0y0

= x1y1Bm + x1y0B

m + x0y1Bm + x0y0

= (x1y1)Bm + (x1y0 + x0y1)B

m + x0y0

z2 z1 z0

Karatsuba

Multiplicación de x*y

Ejemplo:1234*5678 = 7006652

x y

z1 = x1y0 + x0y1 (original, dos multiplicaciones)

z1 = (x1 + x0)(y1 + y0) − z2 − z0 (uno menos)

z1 = (x1y1 + x1y0 + x0y1 + x0y0) - x1y1 - x0y0 (reemplazando)

= x1y0 + x0y1 (original)

x*y = (x1y1)Bm + (x1y0 + x0y1)Bm + x0y0

Una multiplicación menos

Ejemplo

Multiplicar 1234*5678 base diez B = 10 ; m = 2

x = 12 34 = 12 102 + 34

y = 56 78 = 56 102 + 78

z2 = x1y1 = 12 56 = 672

z0 = x0y0 = 34 78 = 2652

z1 = (x1+x0)(y1+y0) – z2 – z0

=(12 + 34)(56 + 78) − z2 − z0 = 46 134 − 672 − 2652 = 2840

x*y = z2Bm + z1B

m + z0

x*y = z2Bm + z1B

m + z0

x*y = 672Bm + 2840Bm + 2672

x*y = 672.102 + 2840.102 + 2672 = 7006652

1234*5678 = 7006652

Comparación con un algoritmo O(n2)

Toom-Cook (en pasos sencillos)

Multiplicar 123456789 * 987654321

1. Separamos los dígitos en tres partes.

123|456|789

987|654|321

2. Seleccionamos un set de puntos: {-2,-1,0,1,2}

A(x) = 123x2 + 456x + 789

B(x) = 987x2 + 654x + 321

p/ x= -2 A= 369 B= 2961 AB= 1092609

p/ x= -1 A= 456 B= 654 AB= 298224

p/ x= 0 A= 789 B= 321 AB= 253269

p/ x= 1 A= 1368 B= 1962 AB= 2684016

p/ x= 2 A= 2193 B= 5577 AB= 12230361

3. La solución tendrá la siguiente forma:

P(x) = p4x4 + p3x

3 + p2x2 + p1x + p0

4. Sustituimos en la ecuación:

16p4 - 8p3 + 4p2 - 2p1 + p0 = 1092609

p4 - p3 + p2 - p1 + p0 = 298224

p0 = 253269

p4 + p3 + p2 + p1 + p0 = 2684016

16p4 + 8p3 + 4p2 + 2p1 + p0 = 12230361

5. Resolvemos la ecuación:

p4 = 121401

p3 = 530514

p2 = 1116450

p1 = 662382

p0 = 253269

6. Convertimos a número el resultado, haciendo x=100 en P(x).

O más fácil gráficamente; colocamos debajo y corremos a la derecha.

121|401

530|514

1|116|450

662|382

253|269

=======================

121|932|631|112|635|269 eliminamos separadores 121932631112635269

Referencias•

1. http://es.wikipedia.org/wiki/Complejidad_computacional

2. http://es.wikipedia.org/wiki/Algoritmo_de_Karatsuba

3. http://es.wikipedia.org/wiki/Algoritmo_de_multiplicaci%C3%B3n

4. http://es.wikipedia.org/wiki/Algoritmo_de_Booth

5. http://mathworld.wolfram.com/KaratsubaMultiplication.html

6. http://www.ccas.ru/personal/karatsuba/divcen.htm

7. http://156.35.31.178/wiki/index.php/TP:Multiplicaci%C3%B3n_de_e

nteros_grandes_-_Divide_y_vencer%C3%A1s

8. http://www.psicofxp.com/forums/programacion.313/243039-

multiplicar-numeros-muy-grandes.html

9. http://www.worldlingo.com/ma/enwiki/es/Multiplication_algorithm

/1

10. http://www.kriptopolis.org/algoritmo-para-calcular-numeros-

primos-muy-grandes

11. http://arantxa.ii.uam.es/~gonzalo/docencia/aa0506/p2/

12. http://www.algoritmia.net/problems.php?id=18

13. http://www.algoritmia.net/problems.php?id=18&option=solucion

14. http://wapedia.mobi/es/Algoritmo_de_Karatsuba

15. http://www.emezeta.com/articulos/multiplicacion-algoritmo-de-

booth

16. http://es.wikibooks.org/wiki/Algoritmia/Divide_y_vencer%C3%A1s

17. http://www.pijusmagnificus.com/blog/2009/01/06/karatsuba-en-c/

18. http://www.lsi.upc.es/~iea/transpas/3_divide/tsld028.htm

19. http://www.opendomo.com/dlerch/sources/doc/algoritmo_rsa.html

20. http://decsai.ugr.es/~castro/CA/node5.html

21. http://bodrato.it/paperi/

22. http://en.wikipedia.org/wiki/Toom-Cook_multiplication

23. http://markmail.org/message/susnhmws5dizearj

24. http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4837946

25. http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4646474

1. http://futureboy.us/temp/BigInteger.java

2. http://en.wikipedia.org/wiki/Multiplication_algorithm

3. http://en.wikipedia.org/wiki/Fast_Fourier_Transform

4. http://bodrato.it/software/toom.html

5. http://lavica.fesb.hr/cgi-bin/info2html?%28gmp%29Toom-Cook%203-

Way%20Multiplication

6. http://everything2.com/title/Toom-Cook+multiplication

7. http://everything2.com/title/multiplication+using+the+fast+Four

ier+Transform

8. http://cmrubi.blogspot.com/2010/04/volker-strassen.html

9. http://es.wikilingue.com/pt/Algoritmo_de_Strassen

10. http://enciclopediaespana.com/Algoritmo_de_Karatsuba.html

11. http://tripatlas.com/Karatsuba_multiplication

12. http://tripatlas.com/Toom-Cook_multiplication

13. http://tripatlas.com/Fast_Fourier_transform

14. http://java.sun.com/javase/6/docs/api/java/math/BigInteger.html

15. http://stackoverflow.com/questions/2387229/big-o-complexity-of-

the-basic-arithmetic-operations

16. http://en.wikipedia.org/wiki/Sch%C3%B6nhage%E2%80%93Strassen_al

gorithm

17. http://forums.sun.com/thread.jspa?threadID=5296209

18. http://people.cis.ksu.edu/~rhowell/calculator/comparison.html

19. http://www.apfloat.org/

20. http://www.cs.princeton.edu/introcs/78crypto/Karatsuba.java.htm

l

21. http://lavica.fesb.hr/cgi-

bin/info2html?%28gmp%29Multiplication%20Algorithms

22. http://jamesthornton.com/gnu/gmp/gmp_13.html

23. http://www.cs.princeton.edu/introcs/97data/FFT.java.html

24. http://www.lsi.upc.es/~iea/transpas/3_divide/sld028.htm

25. http://en.wikipedia.org/wiki/F%C3%BCrer%27s_algorithm