1

Captulo 11.

Algoritmos de multiplicacin y divisin.

A continuacin se estudiarn algoritmos para efectuar las operaciones de multiplicacin y
divisin entera. Usualmente estas operaciones estn soportadas por hardware dedicado,
adicional a la unidad aritmtica que efecta las operaciones bsicas de sumar y restar nmeros
con y sin signo. Al estudiar los algoritmos podr advertirse la naturaleza secuencial de stos, en
contraposicin al carcter combinacional de las operaciones de suma y resta.

11.1. Multiplicacin como suma repetitiva.

La operacin de multiplicacin se puede estudiar como la suma repetitiva del multiplicando las
veces que indique el multiplicador.
Por ejemplo la operacin 7*3, en sistema binario puede realizarse segn:
0111*0011 = 0111+0111+0111 = 010101
Si los factores son de N cifras, el producto puede expresarse con 2N dgitos.
Con N=3 en sistema decimal se tiene que con operandos sin signo, el mayor factor es 999, y se
tiene que 999*999= 998.001 requiere 6 cifras.
Si se considera factores positivos, pero con signo, el mayor positivo es 499 y en este caso
tambin se requieren 6 dgitos para el producto: 499*499 = 249.001
Se considera:

Producto = Multiplicando * Multiplicador.

Sean P el producto, R el multiplicando y Q el multiplicador. Se define el multiplicador como el

factor que indica las veces que el multiplicando se ha de tomar como sumando. Y como
multiplicando al factor que ha de ser multiplicado.
Empleando el lenguaje C, puede describirse la idea anterior segn:
/*Algoritmo a.
P y R de largo 2N. Q largo N. Sumador ancho 2N. */
/* Q y R positivos
P=R*Q
*/
for( j = Q; j>0 ; j--)
{
P+=R;
}

Profesor Leopoldo Silva Bijit

18-07-2007

Estructuras de Computadores Digitales

Ntese que P y R deben ser de largo 2N, y el sumador tambin debe ser de largo 2N. En este
algoritmo el nmero de sumas es proporcional a Q, lo cual es demasiado elevado.

11.2. Multiplicacin mediante desplazamientos.

El siguiente algoritmo, corresponde a la multiplicacin manual (con papel y lpiz) en la cual se
va multiplicando las cifras del multiplicando por cada una de las cifras del multiplicador:
0111*0011
0111
0111
0000
0000
0010101
Puede reducirse el nmero de veces que se repite la operacin, notando que, en el sistema
binario, slo debe efectuarse la suma del multiplicando si la cifra correspondiente del
multiplicador es uno; ya que la multiplicacin por cero no cambia el producto parcial.
Entonces en lugar de efectuar todas las sumas del multiplicando (desplazado una posicin hacia
la izquierda) por cada una de las cifras del multiplicador, podra efectuarse:
0111*0011
0111
0111
0010101
La deteccin si debe realizarse o no la suma del multiplicando R, puede lograrse observando
solamente la cifra menos significativa de Q, siempre que despus de realizada la suma, se divida
(en forma entera) el valor de Q. Esto logra un corrimiento hacia la derecha de Q, en una
posicin. Adems el multiplicando debe desplazarse en una posicin hacia la izquierda.
El siguiente algoritmo desarrolla las ideas anteriores, y la suma se realiza a lo ms en N pasos;
es decir una vez por cada cifra de Q.
Ntese que (Q&1), que determina el valor del bit menos significativo de Q, equivale a la
condicin: Q impar.
/*Algoritmo b
P y R de largo 2N. Q largo N. Sumador ancho 2N */
/* Q y R positivos
P=R*Q
*/
for(j=N; j>=0; j--)
{
if(Q&1) P+=R; Q=Q/2; R=R*2;
}
La secuencia anterior destruye los valores originales de Q y R.

Profesor Leopoldo Silva Bijit

18-07-2007

Algoritmos de multiplicacin y divisin

Si reemplazamos la divisin y multiplicacin entera por 2, por funciones que realicen

corrimientos, se tiene el siguiente algoritmo:
/*Algoritmo 1
P y R de largo 2N. Q largo N
/* Q y R positivos
P=R*Q
*/
for(j=N;j>=0;j--)
{
if(Q&1) P+=R;
lls(R); lrs(Q);
}

Sumador ancho 2N. */

Se emplean las funciones lls y lrs, por logical left shift y logical right shift respectivamente.
Como los bits de signo de Q y R siempre sern ceros, pueden efectuarse corrimientos lgicos o
aritmticos.
Ntese que despus de la operacin se destruye el multiplicando original en Q, y el
multiplicador R.
A continuacin veremos una formulacin analtica de los algoritmos:

11.3. Fundamentacin de los algoritmos de multiplicacin.

Sea Q positivo( qn es cero), entonces:
n 1

Q = q 2
i =0

n 1

Q R = R 2 q + R 2 q + ... + R 2 q + ... + R 2
0

qn

qn-1

qn-2

...

q2

q1

n 1

q0

Ntese que ahora los operandos tienen n+1 cifras.

El producto, entonces se forma, mediante las siguientes sumas:
S 0 = 0 + R q0 20
S 1 = S 0 + R q1 21
S 2 = S 1 + R q2 22
S 3 = S 2 + R q3 23
.......
S n-1 = S n-2 + R qn-1 2n-1
S n = S n-1 + R qn 2n
La cifra de Q, en la etapa i-sima, qi slo puede ser cero o uno. Si es uno, el trmino asociado
se suma.
El trmino R 2i es el multiplicador desplazado i posiciones hacia la izquierda.
Esto justifica el algoritmo ya visto, que corresponde a la multiplicacin tradicional, efectuada
con papel y lpiz.
Profesor Leopoldo Silva Bijit

18-07-2007

Estructuras de Computadores Digitales

Si Q es positivo, entonces: qn = 0 si Q est en notacin complemento dos.

El producto es Sn.
Desde un punto de vista formal, puede derivarse una ecuacin de diferencias para la etapa isima, esto con fines de elaborar un algoritmo iterativo, o de naturaleza secuencial:
Las ecuaciones de diferencias, para el algoritmo 1, son:
S 0 = 0 + R q0 20 = 0 + r0 q0
S 1 = S 0 + R q1 21 = S 0 + r0 2 q1
= S 0 + r1 q1
S 2 = S 1 + R q2 22 = S 1 + r1 2 q2
= S 1 + r2 q2
S 3 = S 2 + R q3 23 = S 2 + r2 2 q3
= S 2 + r3 q3
.......
S n-1 = S n-2 + R qn-1 2n-1 = S n-2 + r n-2 2 qn-1 = S n-2 + r n-1 qn-1
S n = S n-1 + R qn 2n = S n-1 + r n-1 2 qn = S n-1 + r n qn
Es decir, para el algoritmo 1, se tienen:
S0 =
0 + r0 q0
r0 = R
S 1 = S 0 + r1 q1
r1 = r0 2
S 2 = S 1 + r2 q2
r2 = r1 2
Algoritmo 1.
S 3 = S 2 + r3 q3
r3 = r2 2
.......
S n-1 = S n-2 + r n-1 qn-1 rn-1 = rn-2 2
S n = S n-1 + r n qn rn = rn-1 2
El producto queda en S n.
Tambin pueden escribirse:
q0 = Q0 &1
Q0
= (Q/20)
q1 = Q1 &1
Q1
= (Q/21) = Q0/2
q2 = Q2 &1
Q2
= (Q/22) = Q1/2
.....
qn = Qn &1
Qn
= (Q/2n) = Qn-1/2
Resumiendo, se tienen las siguientes ecuaciones de diferencias, con sus valores iniciales:
qi = Qi &1
S i = S i-1 + ri qi con S -1 = 0
r i = r i-1 * 2
con r0 = R
Qi = Qi-1/2
con Q0 = Q
Entonces en la etapa i-sima, si qi es 1, se suma al producto parcial anterior S
multiplicador anterior multiplicado por dos (que es r i).

i-1,

el

Como qi toma valores 0 1, las primeras dos ecuaciones pueden escribirse como una
alternativa, usando como condicin lgica qi:
if (Qi &1 ) Si = S i-1 + ri ;
r i = r i-1 * 2; Qi = Qi-1/2 ;
La repeticin de n veces, hasta lograr el producto Sn se logra colocando las ecuaciones
anteriores dentro de un bloque repetitivo for(que debe realizarse n veces); adems esta sentencia
permite aplicar los valores iniciales, queda entonces:
Profesor Leopoldo Silva Bijit

18-07-2007

Algoritmos de multiplicacin y divisin

for(i=0, Q0=Q , r0=R, S0=0; i<n+1; i++){ if (Qi &1 ) S i = S i-1+ ri ; r i = r i-1*2; Qi =Qi-1/2} ;
Si consideramos que dentro del bloque de repeticin de un for, las variables que aparecen a la
izquierda de una asignacin representan la instancia i-sima o actual, y que las que ocurren a la
derecha de un smbolo de asignacin representan las instancias (i-1)-simas, podr escribirse el
conjunto de ecuaciones de diferencias sin los subndices dentro del bloque de acciones del for.
Lo mismo puede aplicarse para los subndices de los valores iniciales. Queda entonces el
algoritmo escrito en lenguaje C, segn:
/*Algoritmo 1
S y R de largo 2(n+1). Q largo n+1
/* Q y R positivos
S=R*Q
*/

Sumador ancho 2(n+1). */

for(i=0, Q = Q , r = R, S = 0; i<n+1; i++){ if (Q &1 ) S = S + r ; r = r *2; Q = Q/2} ;

Las multiplicaciones y divisiones por dos pueden expresarse como corrimientos. Que para el
caso de nmeros positivos con signo, pueden ser lgicos o aritmticos:
r=r*2; Q =Q/2; /* lls(r);lrs(Q); */

11.4. Algoritmo que emplea menores recursos de hardware.

Se desea desarrollar ahora un algoritmo ms eficiente, que emplee menos recursos electrnicos
que el anterior, por lo que consideremos la siguiente multiplicacin:
Estudiemos la multiplicacin binaria de (+26)*(+13) = +338.
Con 6 cifras:
011010 * 001101
S1=000000011010 Q1 = 000110
011010
000000
S2=00000011010 Q2 = 000011
011010
011010
S3=000010000010 Q3 =000001
000000
000000
S4=000101010010 Q4=000000
000101010010
La siguiente elaboracin tiende a optimizar el uso de los recursos de hardware. Se observa que
en cada paso slo se suman 6 cifras, la cifra menos significativa de la suma acumulada no afecta
las sumas posteriores; y puede decirse que es una cifra del producto final.
Es decir, en cada paso se obtiene una cifra del resultado.
Tampoco es necesario correr el multiplicando a la izquierda, si en lugar de esto se desplaza la
suma (el producto parcial) hacia la derecha. De esta forma una de las entradas del sumador
quedar fija con el valor del multiplicando.
Con estas observaciones se requiere un sumador de n+1 bits solamente.

Profesor Leopoldo Silva Bijit

18-07-2007

Estructuras de Computadores Digitales

Por otra parte, en cada paso, queda un espacio por la extrema izquierda de Q, lugar en que se
puede depositar el bit del resultado que se genera en cada paso de la iteracin. Lo cual, como se
ver, ahorra un registro de largo n+1.
Para la obtencin de un algoritmo que implemente las observaciones anteriores, a partir de las
relaciones de recurrencia del algoritmo 1, se proceder formalmente a obtener las ecuaciones de
diferencias que fundamentan el que denominaremos algoritmo 2.
Bsicamente consisten en expresar las sumas parciales en funcin solamente de R, y no de R
multiplicado por una potencia de dos. Para lograr esto se definen a partir de las sumas Si, las
siguientes relaciones en trminos de las variables si.
Se tienen:
S0 = 0
S1 =S0
S2 =S1
S3 =S2
.......
S n-1 = S n-2
S n = S n-1

+ R q0 20
+ R q1 21
+ R q2 22
+ R q3 23

S 0 /20
S 1 /21
S 2 /22
S 3 /23

= 0 /20
= S 0/21
= S 1/22
= S 2/23

+ R qn-1 2n-1
+ R qn 2n

S n-1 /2n-1 = S n-2/2n-1 + R qn-1

S n /2n = S n-1/2n + R qn

+ R q0
+ R q1
+ R q2
+ R q3

= 0
= s0/2
= s1/2
= s2/2

+
+
+
+

R q0
R q1
R q2
R q3

= sn-2/2 + R qn-1
= sn-1/2 + R qn

=
=
=
=

s0
s1
s2
s3

= sn-1
= sn

Ordenando las relaciones anteriores y definiendo la variable x, para dividir por dos despus de
realizada la suma, se obtiene:
s0 = 0
+ R q0 ; x0 = s0/2
s1 = s0/2 + R q1 ; x1 = s1/2
s2 = s1/2 + R q2 ; x2 = s2/2
s3 = s2/2 + R q3 ; x3 = s3/2
.......
sn-1 = sn-2/2 + R qn-1 ; xn-1 = sn-1/2
sn = sn-1/2 + R qn ; xn = sn/2
Si qi es uno se suma R con la suma anterior desplazada en uno hacia la derecha (si-1/2).
Ahora x representa la suma anterior dividida por dos:
s0 = 0
+ R q0 ; x0 = s0/2 Con: x-1 = 0
s1 = x0
+ R q1 ; x1 = s1/2
s2 = x1
+ R q2 ; x2 = s2/2
s3 = x2
+ R q3 ; x3 = s3/2
.......
sn-1 = xn-2 + R qn-1 ; xn-1 = sn-1/2
sn = xn-1 + R qn ; xn = sn/2
Si qi es uno se suma R con la suma anterior desplazada en uno hacia la derecha (xi-1).
Con
qn = 0 para nmero positivo.
Para la etapa i-sima:
qi = Qi &1
si = xi-1 + R qi
Profesor Leopoldo Silva Bijit

con x-1 = 0

18-07-2007

Algoritmos de multiplicacin y divisin

con s0 = 0
xi = si/2
Qi = Qi-1/2
con Q0 = Q
Si qi es uno se suma R con la suma anterior desplazada en uno hacia la derecha (xi-1).
Si qi es cero slo se desplazan hacia la derecha las variables s y Q.
for(i=0, Q0= Q , s0 = 0, x-1= 0; i<n; i++){ if (Qi &1 ) s i = x i-1 + R ; Qi =Qi-1/2; xi = si /2 } ;
Eliminando los subndices:
for(i=0, Q= Q , s = 0, x= 0; i<n; i++){ if (Q &1 ) s = x + R ; Q =Q/2; x = s /2 } ;
Se observa que puede eliminarse la variable auxiliar x, utilizando en su lugar la misma variable
s.
Resulta:
/*Algoritmo 2 s, Q y R de largo n+1.
/* Q y R positivos
Al salir sQ= R * Q

Sumador ancho n+1 */

*/

for(i=0, Q= Q , s = 0; i<n+1; i++){ if (Q &1 ) s = s + R ; Q =Q/2; s = s /2 } ;

No hay problemas de rebalse con nmeros sin signo, ya que R es positivo, y rn siempre es
cero.
Si en cada iteracin se divide por dos el valor de Q, el qi correspondiente siempre queda en la
posicin ms derechista del registro. A la vez van quedando espacios por la izquierda en Q.
Lugar en que se almacena lo que va saliendo por la derecha desde S.
Notar que en la suma final realizada por el for, sn cumple la relacin: S n = 2n sn; es decir, sn es
la parte ms significativa del producto. La parte menos significativa queda en Q.
En MIPS, se tienen dos registros, denominados Hi y Lo que almacenan la parte ms y menos
significativa del producto, respectivamente.
Ntese que:
Q =Q/2; s = s /2
puede escribirse como un desplazamiento lgico a derecha de los registros
concatenados s y Q.
for(i = n, s = 0; i<n+1; i++){ if(Q&1) s+=R;lrs(s,Q); }
Si se consideran registros separados: Si el valor almacenado en s es positivo, su corrimiento
puede ser aritmtico o lgico. Pero el del registro Q debe ser lgico solamente. Y el bit menos
significativo que sale del registro s debe ingresarse en la posicin ms significativa de Q.
La siguiente secuencia ilustra el movimiento del bit menos significativo de s y su posterior
colocacin en el lugar del bit ms significativo de Q, empleando los operadores al bit del
lenguaje C.
temp= s&1; s= s>>1; Q= Q>>1; Q = Q| temp*2n-1;

Profesor Leopoldo Silva Bijit

18-07-2007

Estructuras de Computadores Digitales

La derivacin detallada anterior, permite explicar formalmente la multiplicacin con operandos

con signos, que se ver a continuacin:

11.5. Fundamentacin del Algoritmo de Booth, para operandos con signo.

Q en complemento dos se puede escribir como:
Q = - qn 2n + qn-1 2n-1+ qn-2 2n-2+ ....+q1 21+ q0 20
Y tambin como:
Q = - (qn 2n + qn-1 2n-1+ qn-2 2n-2+ ....+q1 21+ q0 20) + 2(qn-1 2n-1+ q n-2 2n-2+ ....+q1 21+ q0 20 )
Introduciendo el factor 2 en las potencias de los trminos positivos:
Q = - (qn 2n + qn-1 2n-1+ qn-2 2n-2+ ....+q1 21+ q0 20) + (qn-1 2n+ q n-2 2n-1+ ....+q1 22+ q0 21 )
Finalmente, agrupando los factores de las potencias iguales, se logra:
Q = (qn-1 - qn ) 2n+ (qn-2 - qn-1 ) 2n-1+ (qn-3 - qn-2 ) 2n-2+ ....+ (q1 - q2) 22+ (q0 - q1) 21+ (0 - q0) 20
Entonces las relaciones de recurrencia para el algoritmo dos:
s0 = 0
s1 = s0/2
s2 = s1/2
....
sn-1 = sn-2/2
sn = sn-1/2

+ R q0
+ R q1
+ R q2

Algoritmo 2.

+ R qn-1
+ R qn

Pueden transformarse en:

s0 = 0 + R (0 - q0 )
s1 = s0/2 + R (q0 - q1 )
s2 = s1/2 + R (q1 - q2 )
....
sn-1 = sn-2/2 + R (qn-2 - qn-1 )
sn = sn-1/2 + R (qn-1 - qn )

Algoritmo de Booth.

Entonces, resulta el algoritmo de Booth, para la etapa i-sima:

si = si-1/2 + R (qi-1 - qi ) con q-1 = 0 y s-1 = 0
Qi = Qi-1/2
con Q0 = Q
qi = Qi &1
Si qi-1 = qi no se suma R al producto parcial, que es la suma acumulada anteriormente (si-1 ),
desplazada un bit hacia la derecha.
Si qi = 0 y qi-1 = 1 se suma R al producto parcial.
Si qi = 1 y qi-1 = 0 se resta R al producto parcial.
Profesor Leopoldo Silva Bijit

18-07-2007

Algoritmos de multiplicacin y divisin

Es preciso agregar un bit, a la derecha de Q. Para poder comparar, en la etapa i-sima, el ltimo
de Q, qi, con el de la etapa anterior qi-1. Este bit, se inicia en cero, y se denomina qq en el
algoritmo.
Es notable destacar que slo es preciso agregar un flip-flop, para capacitar al hardware del
algoritmo 2 en un dispositivo, para realizar multiplicaciones de operandos con signo.
Como se efectan restas, un producto parcial puede resultar negativo, por esta razn debe
correrse ste a la derecha con extensin del signo. El bit que sale del producto parcial si, debe
ocupar el bit del signo de Q, espacio que queda disponible al mover Q en una posicin hacia a la
derecha.
Por esta razn si Q es otro registro, debe efectuarse un corrimiento lgico (no aritmtico) y
luego escribir, el bit que sale del producto parcial si , en el bit del signo de Q.
/*Alg. 3 S, Q y R de largo n+1.
Sumador ancho n+1 */
/* Q y R con signo
SQ= Q * R
*/
for(i=0, qq=0; i<n+1; i++)
{
if( (Q&1) = =0 && qq = = 1 ) S+=R; /* se suma */
if( (Q&1) = =1 && qq = = 0 ) S-=R;
ars(S,Q,qq)
/*T=S0; ars(S); qq= Q0; lrs(Q); QN-1 = T; */
}
Donde S0 y Q0 son los bits menos significativos de S y Q respectivamente.
Si S, Q y qq fueran concatenados, bastara con ars(S,Q,qq)

11.6. Multiplicacin de enteros sin signo.

El algoritmo para multiplicar enteros positivos debe modificarse ya que en caso de enteros sin
signo puede producirse reserva de salida en el sumador que produce los productos parciales.
Si se considera la siguiente tabla de verdad:
Pn
0
0
0
0
1
1
1
1

Rn
0
0
1
1
0
0
1
1

Cn-1
0
1
0
1
0
1
0
1

Co
0
0
0
1
0
1
1
1

Sn
0
1
1
0
1
0
0
1

Figura 11.1 Multiplicacin enteros unsigned.

Profesor Leopoldo Silva Bijit

18-07-2007

10

Estructuras de Computadores Digitales

R
P

Figura 11.2 Hardware de Multiplicacin.

Donde:
Pn, Rn, y Sn son los bits ms significativos de los registros P, R y del bus de salida S del
sumador.
Cn-1 es la reserva generada en la penltima etapa de sumador.
Co es la reserva de salida.
Observando la reserva de salida, para enteros positivos se tiene que sta es cero. Pero si Pn o Rn
pueden tomar valores iguales a uno, podra producirse una reserva de salida Co igual a uno.
Consideremos un registro de largo 3 y efectuemos la multiplicacin de 7*3, empleando el
algoritmo de papel y lpiz, en binario:
111*011
111
111
000
010101
que equivale a 21 en decimal. Note que con 6 bits para representar el
producto, ste es positivo.
El producto parcial P, se inicia en cero, despus de la primera suma resulta 111. Luego de
efectuado el primer corrimiento, debe realizarse la suma S = P + R:
011
+ 111
1010 que produce reserva de salida.

Profesor Leopoldo Silva Bijit

18-07-2007

Algoritmos de multiplicacin y divisin

11

Entonces al efectuar el corrimiento hacia la derecha de P, la posicin ms significativa, que

queda vacante, debe llenarse con la reserva de salida.
Entonces el algoritmo para multiplicar enteros sin signo, debe efectuar un corrimiento lgico
hacia la derecha de los registros concatenados Co, P y Q.
Es decir:
for (i = 0; i < n+1; i++) if ( Q&1) P += R; lrs(Co, P, Q);
La implementacin electrnica de este algoritmo se realiza mediante un registro de
desplazamiento, y resulta sencilla si se dispone de la generacin de la reserva de salida del
sumador.
El desarrollo en assembler, en mquinas que no tengan la multiplicacin en su repertorio,
tambin es simple si se dispone de un flip-flop que almacene la condicin de reserva de salida
(normalmente se denomina C a este bit, y se lo suele almacenar en la palabra de estado del
procesador PSW).
La simulacin de este algoritmo en C, presenta la dificultad que no se dispone de la reserva de
salida. Si consideramos que P, R, Q y S son enteros sin signo, podemos generar la reserva de
salida, a partir de la tabla de verdad de los bits ms significativos planteada anteriormente.
Se tiene despus de realizada la suma: S = P + R que:
Co = (Pn&Rn)|( S&Pn)||( S&Rn)
Esto considerando como entradas a Pn, Rn y Sn y como salida a Co. Esto puede realizarse ya
que Sn es funcin de Pn,Rn y Cn-1, y tiene incorporada la dependencia con la entrada Cn-1.
C0 Pn Rn
Sn 00
01
0
0
1
1
0
0

11
1
1

10
1
0

El bit ms significativo de Rn, si el largo de palabra es de 16 bits, puede obtenerse segn:

Rn = ( R &( 1<<15)) >> 15
El largo de palabra menos uno, podra definirse como una constante para simplificar la
portabilidad a procesadores con largo de palabra diferente. La expresin anterior marca el bit
ms significativo y lo coloca luego en la posicin menos significativa; luego si el bit ms
significativo de R es uno, Rn toma valor uno, en caso contrario toma valor cero.
Pueden plantearse expresiones similares para Pn y Sn.
Para realizar el corrimiento concatenado de Co, P y Q, mediante el lenguaje C, pueden
emplearse las variables QM y PM para almacenar los bits que deben escribirse en las posiciones
ms significativas de Q y P. Despus de realizada la suma S = P + R;
QM = ( S&1 ) << 15;
PM = Co << 15;
Las que producen un uno en el bit ms significativo de QM y PM, si el bit menos significativo
de la suma (el producto parcial) y la reserva de salida son unos respectivamente.

Profesor Leopoldo Silva Bijit

18-07-2007

12

Estructuras de Computadores Digitales

Luego de los corrimientos lgicos a la derecha en una posicin:

Q >>= 1; S >>= 1;
Se rellenan los espacios vacantes con:
Q |= QM; S |= PM;
Los corrimientos son lgicos si las variables son de tipo unsigned.
Lo planteado anteriormente debe realizarse slo si se efecta la suma; en caso de que no se
requiera efectuarla (si el correspondiente bit de Q es cero) pueden efectuarse los mismos pasos
anteriores, pero con:
QM = ( P & 1) << 15; PM = 0;
El algoritmo completo, para simular la multiplicacin de enteros sin signo:
Se asume un entero de 16 bits, y un entero largo de 32 bits.
#define n 15
long mult(unsigned R, unsigned Q)
{
unsigned P, S;
int i, Rn, Pn, Sn, QM, PM;
long M;
P = 0; Rn = ( R & (1<<n))>>n;
for(i=n; i>=0;i--)
{
if(Q&1)
{S= P + R;
Pn = ( P & (1<<n))>>n; Sn = ( S & (1<<n))>>n;
PM = ((Pn&Rn)|(~Sn&Pn)|(~Sn&Rn))<<n;
QM = (S&1)<<n;
}
else
{ S = P;
PM = 0;
QM = (S&1)<<n;
}
Q>>=1;S>>=1;
Q|=QM; S|=PM; P = S;
}
M= P;M=M<<n+1; return(M|Q);
}
En la ltima lnea se forma una palabra de 32 bits, concatenando P y Q.

11.7. Otros algoritmos para la multiplicacin de nmeros con signo.

Para un nmero N, entero con signo, de largo (n+1):
dn

Profesor Leopoldo Silva Bijit

dn-1

dn-2

...

d2

18-07-2007

d1

d0

Algoritmos de multiplicacin y divisin

13

Su expresin en complemento base es:

NCB = N = N+1 = (bn+1 N ) % bn+1
Se emplea el smbolo , para indicar complemento base.
Extensin con signo a largo 2L de los operandos.
La multiplicacin de dos nmeros Q y R, con signo, de largo L (L es n+1, en las frmulas
anteriores) puede realizarse como una multiplicacin sin signo extendiendo con signo los
operandos a largo 2L.
El resultado correcto de la operacin, en largo 2L, puede comprobarse con las siguientes
relaciones:
Si los nmeros tienen signos distintos. Sea R positivo y Q negativo:
R*Q = R*( b2L Q) = R* b2L - R*Q = (R*Q)
Que es el resultado correcto de la multiplicacin, en largo 2L.
Si ambos son negativos:
R*Q = ( b2L R) * ( b2L Q) = b4L (R+Q)* b2L + R*Q = (R*Q)
Que es el resultado correcto de la multiplicacin, en largo 2L.
La implementacin de este algoritmo requiere un sumador y registros de largo 2L.
Con operandos de largo L.
Estudiemos ahora el caso en que los operandos son de largo L, y el producto de largo 2L.
Se tienen dos casos: Signos iguales y diferentes.
En caso de signos diferentes, el producto es negativo, y puede expresarse en largo 2L, segn:
R*Q = b2L - R*Q = (R*Q)
con Q negativo y R positivo.
Si los operandos tienen igual signo, el resultado correcto, en largo 2L, puede expresarse segn:
+ R*Q
Estudiemos ahora los productos de dos nmeros con signo, siendo los operandos de largo L. Se
tienen cuatro casos:
a) R* Q
= + R*Q
b) R*Q
= R*(bL - Q) = R*bL - R*Q
c) R*Q = Q*(bL - R) = Q*bL - R*Q
d) R*Q = (bL - R) *(bL - Q) = b2L -R*bL -Q*bL +R*Q
Observamos que slo el caso a) entrega un resultado correcto. Pero si despus de realizado el
producto se suman los siguientes trminos a los casos b), c) y d), se tendr el resultado correcto.
Se corrige el caso b) (R>0, Q<0) sumando: b2L - R*bL = bL *( bL- R) = bL*(R )
Si P es el producto parcial final, se corrige con P = P-R si Q<0
Se corrige el caso c) (R<0, Q>0) sumando: b2L - Q*bL = bL *( bL- Q) = bL*(Q )
Es decir, efectuando: P = P Q si R<0

Profesor Leopoldo Silva Bijit

18-07-2007

14

Estructuras de Computadores Digitales

Se corrige el caso d) (R<0, Q<0) sumando: bL*R + bL*Q - b2L

Es decir efectuando: P = P - Q - R
Resumiendo:
R<0
Q<0 Se corrige sumando a P
0
0
0
0
1
-R
1
0
-Q
1
1
-Q - R
Debe notarse que los trminos anteriores influyen en la parte ms significativa del producto, ya
que tienen como factor a bL.
Entonces el algoritmo para multiplicar enteros binarios con signo, efectuando las correcciones,
puede plantearse:
Qo = Q;
for (i = 0; i < n+1; i++) if ( Q&1) P += R; lrs(Co, P, Q);
if (Rn) P -= Qo;
if (Qo) P -= R;
Donde se agrega la variable Qo, ya que la multiplicacin destruye Q.
Ejemplos de productos de enteros sin signo y de los trminos de correccin.
Se consideran operandos de largo 3. En las dos primeras columnas se definen en decimal las
operaciones que se realizarn, sin signo y con signo.
El multiplicador original se denomina Qa(por antes) y despus de realizado el algoritmo de
multiplicacin se denomina Qd(por despus). El producto de enteros sin signo queda en PQd.
El producto sin corregir de enteros con signo tambin queda en PQd. Luego se colocan dos
columnas que interpretan el resultado en decimal, leyendo sin y con signo. Luego se muestra
una columna con el trmino de correccin. Finalmente el producto corregido en binario y en
decimal.
La primera tabla muestra multiplicadores negativos (Qa < 0) y multiplicandos positivos(R>0), y
la forma de corregir el resultado.
Producto
unsigned
1*7=7
1*6=6
1*5=5
1*4=4
........
3*5=15
3*4=12

Producto
Con signo
1*(-1) = -1
1*(-2) = -2
1*(-3) = -3
1*(-4) = -3

Qa

001
001
001
001

111
110
101
100

000
000
000
000

Qd Sin
signo
111
7
110
6
101
5
100
4

3*(-3) = -9
3*(-4) =-12

011
011

101
100

001
001

111
100

15
12

Con
signo
+7
+6
+5
+4

P-R

Qd

111
111
111
111

111
111
111
111

111
110
101
100

Con
Signo
-1
-2
-3
-4

+15
+12

101
101

110
110

111
100

-9
-12

La siguiente tabla muestra multiplicando negativos (R < 0) y multiplicadores positivos

(Q > 0), y la forma de corregir el resultado.
Profesor Leopoldo Silva Bijit

18-07-2007

Algoritmos de multiplicacin y divisin

Producto
unsigned
7*0=0
7*1=7
7*2=14
7*3=21
........
4*2=8
4*3=12

15

Producto
Con signo
(-1)*0 = 0
(-1)*1 = -1
(-1)*2 = -2
(-1)*3 = -3

Qa

111
111
111
111

000
001
010
011

000
000
001
010

Qd Sin
signo
000
0
111
7
110
13
101
21

(-4)*2 = -8
(-4)*3 =-12

100
100

010
011

001
001

000
100

8
12

Con
Signo
+0
+7
+13
+21

P-Q

Qd

000
111
110
101

000
111
111
111

000
111
110
101

Con
Signo
+0
-1
-2
-3

+8
+12

110
101

111
110

000
100

-8
-12

La siguiente tabla muestra multiplicando negativos (R < 0) y multiplicadores negativos

(Q < 0), y la forma de corregir el resultado.
Producto
unsigned
7*7=49
7*6=42
7*5=35
7*4=28
........
4*5=20
4*4=16

Producto
Con signo
-1*-1 = +1
-1*-2 = +2
-1*-3 = +3
-1*-4 = +4

Qa

111
111
111
111

111
110
101
100

110
101
100
011

Qd Sin
signo
001
49
010
42
011
35
100
28

-4*-3= +12
-4*-4=+16

100
100

101
100

010
010

100
000

20
16

Con
Signo
-15
-22
-29
+28

001
001
001
001

+20
+16

100
100

001
010
011
100

P-R
-Q
000
000
000
000

Qd
001
010
011
100

Con
Signo
+1
+2
+3
+4

011
100

001
010

100
000

+12
+16

El algoritmo para multiplicar nmeros con signo positivo, destruye a medida que se realiza la
multiplicacin al operando Q. No as a R que permanece fijo durante la operacin.
En los casos c) y d) debe emplearse Q para corregir (esto cuando el signo de R es negativo). Si
se observan estos casos puede advertirse que el trmino correctivo es el complemento base de Q
sumado al registro que mantiene la parte ms significativa del producto parcial, es decir P. Si el
bit menos significativo de Q, se introduce complementado en la posicin ms significativa del
producto parcial P, al efectuar el desplazamiento combinado de P y Q, se formar despus de L
pasos, P + Q* bL . Slo resta sumar uno al producto parcial para formar el complemento base
del trmino correctivo asociado a Q. No hay que preocuparse por la generacin de una reserva
de salida, producto de esta suma, ya que cuando Q0 vale 1, C0 vale 0(porque Q0 = 0 y P + R no
se efecta).
Electrnicamente hay que agregar un pequeo circuito al registro de desplazamiento a la
derecha formado por P y Q.
Co
P

Profesor Leopoldo Silva Bijit

18-07-2007

16

Estructuras de Computadores Digitales

Ntese que el or exclusivo, de la figura anterior, puede reemplazarse por un or simple. Esto se
debe a que nunca se da la condicin C0 = 1 y Rn Q0 =1.
En los casos b) y d) debe sumarse el complemento base del multiplicador R al producto parcial
final.
Cuando se efecta el primer corrimiento, se suma el complemento uno del ltimo bit de Q con
la reserva de salida (esto es realizado por la compuerta or exclusivo), y queda en la posicin ms
significativa de P. Al terminar los ciclos de la multiplicacin dicho bit ocupar la posicin
menos significativa de P.
Al efectuar el ltimo corrimiento, se realiza la suma del bit ms significativo de Q con la
reserva de salida, y se deja el resultado en la posicin ms significativa de P.
El siguiente segmento ilustra los detalles. Se asumen enteros de 16 bits, Rn y Qn son iguales a
uno si R y Q son negativos respectivamente. Durante la multiplicacin se suma el complemento
uno de Q al producto parcial, si R es negativo.
Despus del lazo de multiplicacin se efectan las correcciones de acuerdo al signo de los
operandos.
P = 0;
Rn = ( R & (1<<n))>>n;
Qn = ( Q & (1<<n))>>n;
for(i=n;i>=0;i--)
{
if(Q&1)
{S= P + R;
Pn = ( P & (1<<n))>>n;
Sn = ( S & (1<<n))>>n;
if(Rn)
/* carry = (Rn&Pn)|(~Sn&Pn)|(~Sn&Rn)*/
PM = ( (Pn)|(~Sn&Pn)|(~Sn) )<<n;
else PM =(~Sn&Pn)<<n; ;
QM = (S&1)<<n;
}
else
{ S = P;
/*carry =0 Rn&( ~Qn)*/
if(Rn) PM=(1<<n);else PM = 0;
QM = (S&1)<<n;
}
Q>>=1;S>>=1;
Q|=QM; S|=PM; P = S;
}
if(Rn) P+=1; /*termina correccin si R<0 , formando complemento dos*/
if(Qn) P-=R;
/* corrige con Q<0 */

Profesor Leopoldo Silva Bijit

18-07-2007

Algoritmos de multiplicacin y divisin

17

11.8. Algoritmos de divisin.

Definiciones:
Dividendo =
Divisor

cuociente

resto
divisor

El dividendo es de largo 2N; el divisor, cuociente y resto de ancho N.

Se requieren 2N para expresar el resultado de una divisin.
Algoritmo 1.
P en largo 2N, Q y R de largo N.
largo 2N.

Dividendo en P, Divisor en R, cuociente en Q. Sumador de

while (P>=R) {P-=R; Q++;}

Algoritmo 2.
P, Q y R de largo N.

Al inicio dividendo en P y Q, divisor en R. Sumador de largo N.

for(j=N ; j>=0; j--)

{
if(P>=R) {P-=R; lls(P,Q); Q++;} else lls(P,Q);
}
Overflow= bit ms significativo de Q.

11.9 En assembler MIPS.

Las operaciones de corrimiento se realizan mucho ms rpido que las multiplicaciones. Se
emplean redes combinacionales para los corrimientos.
Entonces un compilador C, la expresin
la ensamblara, si a est en $s0, segn:

a *= 8
sll

$s0, $s0, 3

El resultado de una multiplicacin, ocupa el doble del tamao de los operandos.

La expresin, en C:
a=b*c
Se compila, suponiendo b en $s2, c en $s3, la parte ms significativa de a en $s0 y la menos
significativa en $s1:
mult $s2, $s3
mfhi $s0
mflo $s1
Existe la operacin multu para enteros sin signo, y sin aviso de overflow.

Profesor Leopoldo Silva Bijit

18-07-2007

18

Estructuras de Computadores Digitales

Las expresiones, con variables de tipo entero, en C:

a = c /d ;
/*divisin entera */
b=c%d;
/*resto divisin entera. Operacin mdulo. */
Con a en $so, b en $s1, c en $s2 y d en $s3, se traduce a :
div
$s2, $s3
#lo = $s2 / $s3
mflo $s0
mfhi $s1
Existe divu para enteros sin signo, sin aviso de overflow.

Profesor Leopoldo Silva Bijit

18-07-2007

hi= $s2 % $s3

Algoritmos de multiplicacin y divisin

19

ndice general.
CAPTULO 11. .......................................................................................................................................... 1
ALGORITMOS DE MULTIPLICACIN Y DIVISIN....................................................................... 1
11.1. MULTIPLICACIN COMO SUMA REPETITIVA. .................................................................................... 1
11.2. MULTIPLICACIN MEDIANTE DESPLAZAMIENTOS. ........................................................................... 2
11.3. FUNDAMENTACIN DE LOS ALGORITMOS DE MULTIPLICACIN........................................................ 3
11.4. ALGORITMO QUE EMPLEA MENORES RECURSOS DE HARDWARE....................................................... 5
11.5. FUNDAMENTACIN DEL ALGORITMO DE BOOTH, PARA OPERANDOS CON SIGNO. ............................ 8
11.6. MULTIPLICACIN DE ENTEROS SIN SIGNO. ....................................................................................... 9
11.7. OTROS ALGORITMOS PARA LA MULTIPLICACIN DE NMEROS CON SIGNO. ................................... 12
Ejemplos de productos de enteros sin signo y de los trminos de correccin................................... 14
11.8. ALGORITMOS DE DIVISIN. ............................................................................................................ 17
11.9 EN ASSEMBLER MIPS. .................................................................................................................... 17
NDICE GENERAL. ................................................................................................................................... 19
NDICE DE FIGURAS................................................................................................................................. 19

ndice de figuras.
FIGURA 11.1 MULTIPLICACIN ENTEROS UNSIGNED..................................................................................... 9
FIGURA 11.2 HARDWARE DE MULTIPLICACIN. ......................................................................................... 10

Profesor Leopoldo Silva Bijit

18-07-2007