ELO311

Estructuras de Computadores
Digitales

Algoritmos de Multiplicación y División

Tomás Arredondo Vidal
Este material está basado en:

material de apoyo del texto de David Patterson, John Hennessy,
"Computer Organization & Design", (segunda y tercera edición),
Morgan Kaufmann, CA. 2005

material del curso anterior ELO311 del Prof. Leopoldo Silva

www.wikipedia.org
Algoritmos de Multiplicación y División

A continuación se estudiarán algoritmos para efectuar
las operaciones de multiplicación y división entera.

Usualmente estas operaciones están soportadas por
hardware dedicado, adicional a la unidad aritmética
que efectúa las operaciones básicas de sumar y
restar números con y sin signo.

Al estudiar los algoritmos podrá advertirse la
naturaleza secuencial de éstos, en contraposición al
carácter combinacional de las operaciones de suma y
resta.
Multiplicación como Suma Repetitiva

La operación de multiplicación se puede estudiar
como la suma repetitiva del multiplicando las veces
que indique el multiplicador.

Producto = Multiplicando * Multiplicador
 P: Producto
 R: Multiplicando
 Q: Multiplicador

P=R*Q
Multiplicación como Suma Repetitiva (cont)

Ejemplo: la operación 7*3, en sistema binario puede
realizarse según:
0111*0011 = 0111 + 0111 + 0111 = 010101

Si los factores son de N dígitos, el producto puede
expresarse con 2N dígitos.
 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 también se requieren 6 dígitos
para el producto: 499*499 = 249.001
Multiplicación como Suma Repetitiva (cont)

Empleando el lenguaje C, puede describirse la idea
anterior según:
/* 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;

}

Nótese que P y R deben ser de largo 2N, y el
sumador también debe ser de largo 2N.

En este algoritmo el número de sumas es
proporcional a Q.
Multiplicación Mediante Desplazamientos

El siguiente algoritmo, corresponde a la multiplicación
manual (con papel y lápiz) en la cual se va
multiplicando las cifras del multiplicando por cada una
de las cifras del multiplicador:

Puede reducirse el número de veces que se repite la

operación, notando que, en el sistema binario, sólo
debe efectuarse la suma del multiplicando si la cifra
correspondiente del multiplicador es uno; ya que la
multiplicación por cero no cambia el producto parcial.
Multiplicación Mediante Desplazamientos (cont)

Entonces en lugar de efectuar todas las sumas del
multiplicando (desplazado una posición hacia la
izquierda) por cada una de las cifras del multiplicador,
podría efectuarse:

La detección si debe realizarse o no la suma del

multiplicando R, puede lograrse observando solamente
la cifra menos significativa de Q, siempre que después
de realizada la suma, se divida (en forma entera) el valor
de Q.

Esto se logra con un corrimiento hacia la derecha de Q,
en una posición. Además el multiplicando debe
desplazarse en una posición hacia la izquierda.
Multiplicación Mediante Desplazamientos (cont)

El siguiente algoritmo desarrolla las ideas anteriores, y la
suma se realiza a lo más en N pasos; es decir una vez
por cada cifra de Q.

Nótese que (Q&1), determina el valor del bit menos
significativo del multiplicador Q.
/*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;
}
 Multiplicación Mediante Desplazamientos (cont)

Si reemplazamos la división y multiplicación entera por 2, por
funciones que realicen corrimientos, se tiene el siguiente algoritmo:
/*Algoritmo 1 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;
lls(R); lrs(Q);
}

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 serán ceros, pueden
efectuarse corrimientos lógicos o aritméticos.
 Fundamentos de Algoritmos de Multiplicación

Para analizar los algoritmos, si Q positivo( qn es cero), entonces:

El Algoritmo a, descrito usando ecuaciones de diferencias :

S0 = 0 + R q0 20
S1 = S0 + R q1 21
S2 = S1 + R q2 22
S3 = S2 + R q3 23
.......
Sn-1 = Sn-2 + R qn-1 2n-1
Sn = Sn-1 + R qn 2n

La cifra de Q, en la etapa i-ésima, qi sólo puede ser cero o uno. Si es
uno, el término asociado se suma.
 Fundamentos de Alg. de Multiplicación (cont)

El término R 2i es el multiplicador desplazado i posiciones
hacia la izquierda.

Esto justifica el algoritmo ya visto, que corresponde a la
multiplicación tradicional, efectuada con papel y lápiz.

Si Q está en notación complemento dos y Q es positivo,
entonces: qn = 0.

El producto final queda en Sn.
 Fundamentos de Alg. de Multiplicación (cont)

El Algoritmo 1, expresado por ecuaciones de diferencias:
 Agregando el multiplicador anterior multiplicado por dos (ri)

S0 = 0 + R q0 20 = 0 + r0 q0 , r0 = R
S1 = S0 + R q1 21 = S0 + r1 q1 , r1 = 2 r0
S2 = S1 + R q2 22 = S1 + r2 q2 , r2 = 2 r1
S3 = S2 + R q3 23 = S2 + r3 q3 , r3 = 2 r2
.......
Sn-1 = Sn-2 + R qn-1 2n-1 = Sn-2 + rn-1 qn-1 , rn-1 = 2 rn-2
Sn = Sn-1 + R qn 2n = Sn-1 + rn qn , rn = 2 rn-1

El producto queda en Sn.
 Fundamentos de Alg. de Multiplicación (cont)

También 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:
q i = Qi & 1
Si = Si-1 + riqi con S-1= 0
ri = ri-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 Si-1, el multiplicador anterior multiplicado por dos (que es ri).
 Algoritmos más eficientes

Se desea desarrollar ahora un algoritmo más eficiente, que emplee
menos recursos electrónicos que el anterior:

Estudiemos la multiplicación binaria de (+26)*(+13) = +338

Se observa que en cada paso sólo se suman 6 cifras (bits), la cifra

menos significativa de la suma acumulada no afecta las sumas
posteriores y puede decirse que es una cifra del producto final.

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 (R). Se requiere un sumador de n+1 bits
solamente.
 Algoritmos más eficientes (cont)

A partir de las relaciones de recurrencia del Algoritmo 1, se
procederá a obtener las ecuaciones del Algoritmo 2.

Básicamente consisten en expresar las sumas parciales en
función solamente de R. Se comienza dividiendo por 2i:
S0/20 = 0/20 + Rq0 = 0 + Rq0 = s0
S1/21 = S0/21 + Rq1 = s0/2 + Rq1 = s1
S2/22 = S1/22 + Rq2 = s1/2 + Rq2 = s2
S3/23 = S2/23 + Rq3 = s2/2 + Rq3 = s3
.......
Sn-1/2n-1 = Sn-2/2n-1 + R qn-1 = sn-2/2 + Rqn-1 = sn-1
Sn/2n = Sn-1/2n + R qn = sn-1/2 + Rqn = sn
 Algoritmos más eficientes (cont)

Ordenando las relaciones anteriores y definiendo x, que
representa la suma si dividida por dos:
s0 = 0 + Rq0 , x0 = s0/2 , con x-1 = 0
s1 = x0 + Rq1 , x1 = s1/2
s2 = x1 + Rq2 , x2 = s2/2
s3 = x2 + Rq3 , x3 = s3/2
.......
sn-1 = xn-2 + R qn-1 , xn-1 = sn-1/2
sn = xn-1 + R qn , xn = sn/2
 Algoritmos más eficientes (cont)

Si qi es uno se suma R con la suma anterior desplazada en
uno hacia la derecha (xi-1). Con qn = 0 para número positivo.

Para la etapa i-ésima:
qi = Qi &1
si = xi-1 + R qi con x-1 = 0
xi = si / 2 con s0 = 0
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 sólo se desplazan hacia la derecha las
variables s y Q.
 Algoritmos más eficientes (cont)
/*Algoritmo 2 s, Q y R de largo n+1. Sumador ancho n+1 */
/* Q y R positivos. Al salir sQ= R * Q */
for(i=0, s = 0; i<n+1; i++)
{
if (Q &1 )
s=s+R;
Q = Q/2; s = s /2
}

No hay problemas de rebalse con números sin signo, ya que R es
positivo, y rn siempre es cero.

Q =Q/2; s = s /2 puede escribirse como un desplazamiento lógico a
derecha (lrs).

MIPS almacena este resultado en los registros HI y LO.
 Operandos con Signo: Algoritmos de Booth

A partir de las relaciones de recurrencia del Algoritmo 2, se procederá a
obtener un algoritmo para operandos con signo.

Q en complemento 2 se puede escribir como:
Q = - qn2n + qn-12n-1+ qn-2 2n-2+ ....+q121+ q020

Y también como:
Q = - (qn2n + qn-12n-1+ qn-2 2n-2+ .... + q1211+ q020) + 2(qn-12n-1+ qn-2 2n-2 +
....+q121+ q020 )

Introduciendo el factor 2 en las potencias de los términos positivos:
Q = - (qn2n + qn-12n-1+ qn-2 2n-2+ .... + q1211+ q020) + (qn-12n+ qn-2 2n-1+ ....+
q122 + q021 )

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
 Algoritmos de Booth (cont)

Entonces las relaciones de recurrencia para el algoritmo dos:
s 0 = 0 + R q0 Algoritmo 2.
s1 = s0/2 + R q1
s2 = s1/2 + R q2
....
sn-1 = sn-2/2 + R qn-1
sn = sn-1/2 + R qn

Pueden transformarse en: Algoritmo de Booth
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)
 Algoritmos de Booth (cont)

Entonces, resulta el algoritmo de Booth, para la etapa i:
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 del producto parcial.

Es muy eficiente solo requiere n sumas o restas mas los
corrimientos correspondientes.
 Algoritmos de Booth (cont)

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.

Sólo 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 efectúan restas, un producto parcial puede resultar
negativo, por esta razón debe correrse éste a la derecha con
extensión del signo (usando ars).

El bit que sale del producto parcial si, puede ocupar el bit del
signo de Q, espacio que queda disponible al mover Q en una
posición hacia a la derecha.
 Algoritmos de Booth (cont)
/*Algoritmo 3: Booth 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; /* se resta */
ars(S, Q, qq); /* ars es un right shift aritmetico, qq = Q0 */
}

Resultado va quedando en Q
 Algoritmos de Booth (cont)

Ejemplo: Algoritmo Booth, resultado va quedando en P

R = 2 = 0010, Q = -7 = 1001 (Nota: Para restar R comp 2: -2 = 1110)
R: Multiplicando P:(S, Q, qq)
0010 0000 1001 0 qi=1, qi-1=0, se resta R de S
0010 1110 1001 0 se corre S,Q,qq 1 bit
0010 1111 0100 1 qi=0, qi-1=1, se suma R a S
0010 0001 0100 1 se corre S,Q,qq 1 bit
0010 0000 1010 0 qi=0, qi-1=0, hacer nada
0010 0000 1010 0 se corre S,Q,qq 1 bit
0010 0000 0101 0 qi=1, qi-1=0, se resta R de S
0010 1110 0101 0 se corre S,Q,qq 1 bit
0010 1111 0010 1

Resultado: P = multiplicando * multiplicador = R * Q = -14 = 1111 0010
 Multiplicación 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. S P = R*Q

Si se considera la siguiente tabla

de verdad:
 Pn, Rn, y Sn son los bits más
significativos de los registros P, R y
del bus de salida S del sumador.
 Cn-1 es la reserva generada en la
penúltima etapa de sumador.
 Co es la reserva de salida.
 La reserva de salida, para enteros
positivos es cero.
 Pero si Pn o Rn pueden tomar valores
iguales a uno, podría producirse una
reserva de salida Co igual a uno.
 Multiplicación de Enteros sin signo (cont)

Consideremos un registro de largo 3 y multipliquemos P=R*Q

Para P=7*3, con 6 bits para el producto este es positivo:

El producto parcial P, se inicia en cero, después de la primera
suma P contiene 111.

Luego de efectuado el primer corrimiento de P, debe realizarse la suma
S = P + R:

Que produce reserva de salida:

Entonces al efectuar el corrimiento hacia la derecha de P, la posición

más significativa, que queda vacante, debe llenarse con la reserva de
salida.

Entonces el algoritmo para multiplicar enteros sin signo, debe efectuar
un corrimiento lógico hacia la derecha de los registros concatenados
Co, P y Q.
 Multiplicación de Enteros sin signo (cont)

En C:
for (i = 0; i < n+1; i++)
{
if ( Q&1)
P += R;
lrs(Co, P, Q);
}

La implementación electrónica de este algoritmo se realiza
mediante un registro de desplazamiento, y resulta sencilla
si se dispone de la generación de la reserva de salida del
sumador.
 Algoritmos de División

Algunas definiciones:

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

requieren 2N para expresar el resultado de una división.

Algoritmo 1:

P de largo 2N, Q y R de largo N.
Parámetros: el dividendo en P, divisor en R.
Resultados: el cuociente en Q, resto en P.
while (P >= R)
{
P-=R; Q++;
}
 Algoritmos de División (cont)

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 más significativo de Q.
 Algoritmos de Multiplicación en MIPS

Las operaciones de corrimiento se realizan mucho más rápido que las
multiplicaciones. Dado que se emplean redes combinacionales para los
corrimientos.

Entonces un compilador C, la expresión a = a * 8 la ensamblaría, si a está
en $s0, según:
sll $s0, $s0, 3

Recordar que el resultado de una multiplicación, ocupa el doble del
tamaño de los operandos.

La expresión, en C: a = b * c

Se compila, suponiendo b en $s2, c en $s3. El resultado se obtiene como
la parte más significativa de a en $s0 y la menos significativa en $s1:
mult $s2, $s3
mfhi $s0
mflo $s1