Algoritmos para Multi y Dividir

1
Profesor Leopoldo Silva Bijit 18-07-2007

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;
}
2 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 */
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.

Algoritmos de multiplicacin y divisin 3
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 Sumador ancho 2N. */
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 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( q
n
es cero), entonces:
2
1
0
i
n
i
i
q
Q =
=

q q q q
n
n
i
i
R R R R R Q
1
1
1
1
0
0
2 2 2 2
... ...

+ + + + + =

q
n
q
n-1
q
n-2
... q
2
q
1
q
0

Ntese que ahora los operandos tienen n+1 cifras.

El producto, entonces se forma, mediante las siguientes sumas:
S
0
= 0 + R q
0
2
0

S
1
= S
0
+ R q
1
2
1

S
2
= S
1
+ R q
2
2
2

S
3
= S
2
+ R q
3
2
3

.......
S
n-1
= S
n-2
+ R q
n-1
2
n-1

S
n
= S
n-1
+ R q
n
2
n

La cifra de Q, en la etapa i-sima, q
i
slo puede

ser cero o uno. Si es uno, el trmino asociado
se suma.

El trmino R 2
i
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.
Si Q es positivo, entonces: q
n
= 0 si Q est en notacin complemento dos.
El producto es S
n
.

Desde un punto de vista formal, puede derivarse una ecuacin de diferencias para la etapa i-
sima, 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 q
0
2
0
= 0 + r
0
q
0

S
1
= S
0
+ R q
1
2
1
= S
0
+ r
0
2

q
1
= S
0
+ r
1

q
1

S
2
= S
1
+ R q
2
2
2
= S
1
+ r
1
2

q
2
= S
1
+ r
2

q
2

S
3
= S
2
+ R q
3
2
3
= S
2
+ r
2
2

q
3
= S
2
+ r
3

q
3

.......
S
n-1
= S
n-2
+ R q
n-1
2
n-1
= S
n-2
+ r
n-2
2 q
n-1
= S
n-2
+ r
n-1

q
n-1
S
n
= S
n-1
+ R q
n
2
n
= S
n-1
+ r
n-1
2 q
n
= S
n-1
+ r
n

q
n

Es decir, para el algoritmo 1, se tienen:
S
0
= 0 + r
0
q
0
r
0
= R

S
1
= S
0
+ r
1

q
1
r
1
= r
0

2
S
2
= S
1
+ r
2

q
2
r
2
= r
1

2 Algoritmo 1.
S
3
= S
2
+ r
3

q
3
r
3
= r
2

2
.......
S
n-1
= S
n-2
+ r
n-1

q
n-1
r
n-1
= r
n-2

2
S
n
= S
n-1
+ r
n

q
n
r
n
= r
n-1

2 El producto queda en S
n
.

Tambin pueden escribirse:
q
0
= Q
0
&1 Q
0
= (Q/2
0
)
q
1
= Q
1
&1 Q
1
= (Q/2
1
) = Q
0
/2
q
2
= Q
2
&1 Q
2
= (Q/2
2
) = Q
1
/2
.....
q
n
= Q
n
&1 Q
n
= (Q/2
n
) = Q
n-1
/2

Resumiendo, se tienen las siguientes ecuaciones de diferencias, con sus valores iniciales:
q
i
= Q
i
&1
S
i
= S
i-1
+ r
i

q
i
con S
-1
= 0
r
i
= r
i-1
* 2 con r
0
= R
Q
i
= Q
i-1
/2 con Q
0
= Q

Entonces en la etapa i-sima, si q
i
es 1, se suma al producto parcial anterior S
i-1
, el
multiplicador anterior multiplicado por dos (que es r
i
).

Como q
i
toma valores 0 1, las primeras dos ecuaciones pueden escribirse como una
alternativa, usando como condicin lgica q
i
:
if (Q
i
&1

) S
i
= S
i-1
+ r
i

;
r
i
= r
i-1
* 2; Q
i
= Q
i-1
/2 ;
La repeticin de n veces, hasta lograr el producto S
n
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:

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

) S
i
= S
i-1
+ r
i

; r
i
= r
i-1
*2; Q
i
=Q
i-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 Sumador ancho 2(n+1). */
/* Q y R positivos S = R * Q */

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
011010
000000
011010
011010
000000
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.

S1=000000011010 Q1 = 000110
S2=00000011010 Q2 = 000011
S3=000010000010 Q3 =000001
S4=000101010010 Q4=000000
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 S
i
, las
siguientes relaciones en trminos de las variables s
i
.

Se tienen:
S
0
= 0 + R q
0
2
0
S
0
/2
0
= 0 /2
0
+ R q
0
= 0 + R q
0
= s
0

S
1
= S
0
+ R q
1
2
1
S
1
/2
1
= S
0
/2
1
+ R q
1
= s
0
/2 + R q
1
= s
1

S
2
= S
1
+ R q
2
2
2
S
2
/2
2
= S
1
/2
2
+ R q
2
= s
1
/2 + R q
2
= s
2

S
3
= S
2
+ R q
3
2
3
S
3
/2
3
= S
2
/2
3
+ R q
3
= s
2
/2 + R q
3
= s
3

.......
S
n-1
= S
n-2
+ R q
n-1
2
n-1
S
n-1
/2
n-1
= S
n-2
/2
n-1
+ R q
n-1
= s
n-2
/2 + R q
n-1
= s
n-1
S
n
= S
n-1
+ R q
n
2
n
S
n
/2
n
= S
n-1
/2
n
+ R q
n
= s
n-1
/2 + R q
n
= s
n

Ordenando las relaciones anteriores y definiendo la variable x, para dividir por dos despus de
realizada la suma, se obtiene:
s
0
= 0 + R q
0
; x
0
= s
0
/2
s
1
= s
0
/2 + R q
1
; x
1
= s
1
/2
s
2
= s
1
/2 + R q
2
; x
2
= s
2
/2
s
3
= s
2
/2 + R q
3
; x
3
= s
3
/2
.......
s
n-1
= s
n-2
/2 + R q
n-1
; x
n-1
= s
n-1
/2
s
n
= s
n-1
/2 + R q
n
; x
n
= s
n
/2
Si q
i
es uno se suma R con la suma anterior desplazada en uno hacia la derecha (s
i-1
/2).

Ahora x representa la suma anterior dividida por dos:
s
0
= 0 + R q
0
; x
0
= s
0
/2 Con: x
-1
= 0
s
1
= x
0
+ R q
1
; x
1
= s
1
/2
s
2
= x
1
+ R q
2
; x
2
= s
2
/2
s
3
= x
2
+ R q
3
; x
3
= s
3
/2
.......
s
n-1
= x
n-2
+ R q
n-1
; x
n-1
= s
n-1
/2
s
n
= x
n-1
+ R q
n
; x
n
= s
n
/2
Si q
i
es uno se suma R con la suma anterior desplazada en uno hacia la derecha (x
i-1
).
Con q
n
= 0 para nmero positivo.

Para la etapa i-sima:
q
i
= Q
i
&1
s
i
=

x
i-1
+ R q
i
con x
-1
= 0
x
i
= s
i
/2 con s
0
= 0
Q
i
= Q
i-1
/2 con Q
0
= Q
Si q
i
es uno se suma R con la suma anterior desplazada en uno hacia la derecha (x
i-1
).
Si q
i
es cero slo se desplazan hacia la derecha las variables s y Q.

for(i=0, Q
0
= Q , s
0
= 0, x
-1
= 0; i<n; i++){ if (Q
i
&1

) s
i
= x
i-1
+ R

; Q
i
=Q
i-1
/2; x
i
= s
i
/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. Sumador ancho n+1 */
/* Q y R positivos Al salir sQ= R * Q */

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 r
n
siempre es
cero.
Si en cada iteracin se divide por dos el valor de Q, el q
i
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, s
n
cumple la relacin: S
n
= 2
n
s
n
; es decir, s
n
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*2
n-1
;

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 = - q
n
2
n
+ q
n-1
2
n-1
+ q
n-2
2
n-2
+ ....+q
1
2
1
+ q
0
2
0

Y tambin como:

Q = - (q
n
2
n
+ q
n-1
2
n-1
+ q
n-2
2
n-2
+ ....+q
1
2
1
+ q
0
2
0
) + 2(q
n-1
2
n-1
+ q
n-2
2
n-2
+ ....+q
1
2
1
+ q
0
2
0
)

Introduciendo el factor 2 en las potencias de los trminos positivos:

Q = - (q
n
2
n
+ q
n-1
2
n-1
+ q
n-2
2
n-2
+ ....+q
1
2
1
+ q
0
2
0
) + (q
n-1
2
n
+ q
n-2
2
n-1
+ ....+q
1
2
2
+ q
0
2
1
)

Finalmente, agrupando los factores de las potencias iguales, se logra:

Q = (q
n-1
- q
n
)

2
n
+ (q
n-2
- q
n-1
)

2
n-1
+ (q
n-3
- q
n-2
)

2
n-2
+ ....+ (q
1
- q
2
)

2
2
+ (q
0
- q
1
)

2
1
+ (0

- q
0
)

2
0

Entonces las relaciones de recurrencia para el algoritmo dos:

s
0
= 0 + R q
0
Algoritmo 2.
s
1
= s
0
/2 + R q
1

s
2
= s
1
/2 + R q
2

....
s
n-1
= s
n-2
/2 + R q
n-1

s
n
= s
n-1
/2 + R q
n

Pueden transformarse en: Algoritmo de Booth.
s
0
= 0 + R (0

- q
0
)

s
1
= s
0
/2 + R (q
0
- q
1
)

s
2
= s
1
/2 + R (q
1
- q
2
)

....
s
n-1
= s
n-2
/2 + R (q
n-2
- q
n-1
)
s
n
= s
n-1
/2 + R (q
n-1
- q
n
)

Entonces, resulta el algoritmo de Booth, para la etapa i-sima:
s
i
= s
i-1
/2 + R (q
i-1
- q
i
) con q
-1
= 0 y s
-1
= 0
Q
i
= Q
i-1
/2 con Q
0
= Q
q
i
= Q
i
&1

Si q
i-1
= q
i
no se suma R al producto parcial, que es la suma acumulada anteriormente (s
i-1
),
desplazada un bit hacia la derecha.
Si q
i
= 0 y q
i-1
= 1 se suma R al producto parcial.
Si q
i
= 1 y q
i-1
= 0 se resta R al producto parcial.

Es preciso agregar un bit, a la derecha de Q. Para poder comparar, en la etapa i-sima, el ltimo
de Q, q
i
, con el de la etapa anterior q
i-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 s
i
, 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 s
i
, 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=S
0
; ars(S); qq= Q
0
; lrs(Q); Q
N-1
= T; */
}
Donde S
0
y Q
0
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:

Figura 11.1 Multiplicacin enteros unsigned.

Pn Rn Cn-1 Co Sn
0 0 0 0 0
0 0 1 0 1
0 1 0 0 1
0 1 1 1 0
1 0 0 0 1
1 0 1 1 0
1 1 0 1 0
1 1 1 1 1

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.

P
R
Q
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 11 10
0 0 1 1 1
1 0 0 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.

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):

d
n
d
n-1
d
n-2
... d
2
d
1
d
0

Su expresin en complemento base es:
N
CB
= N = N+1 = (b
n+1
N ) % b
n+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*( b
2L
Q) = R* b
2L
- R*Q = (R*Q)
Que es el resultado correcto de la multiplicacin, en largo 2L.

Si ambos son negativos:
R*Q = ( b
2L
R) * ( b
2L
Q) = b
4L
(R+Q)* b
2L
+ 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 = b
2L
- 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*(b
L
- Q) = R*b
L
- R*Q
c) R*Q = Q*(b
L
- R) = Q*b
L
- R*Q
d) R*Q = (b
L
- R) *(b
L
- Q) = b
2L
-R*b
L
-Q*b
L
+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: b
2L
- R*b
L
= b
L
*( b
L
- R) = b
L
*(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: b
2L
- Q*b
L
= b
L
*( b
L
- Q) = b
L
*(Q )
Es decir, efectuando: P = P Q si R<0

Se corrige el caso d) (R<0, Q<0) sumando: b
L
*R + b
L
*Q - b
2L

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 b
L
.
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
Producto
Con signo
R Qa P Qd Sin
signo
Con
signo
R P-R Qd Con
Signo
1*7=7 1*(-1) = -1 001 111 000 111 7 +7 111 111 111 -1
1*6=6 1*(-2) = -2 001 110 000 110 6 +6 111 111 110 -2
1*5=5 1*(-3) = -3 001 101 000 101 5 +5 111 111 101 -3
1*4=4 1*(-4) = -3 001 100 000 100 4 +4 111 111 100 -4
........
3*5=15 3*(-3) = -9 011 101 001 111 15 +15 101 110 111 -9
3*4=12 3*(-4) =-12 011 100 001 100 12 +12 101 110 100 -12

La siguiente tabla muestra multiplicando negativos (R < 0) y multiplicadores positivos
(Q > 0), y la forma de corregir el resultado.

Producto
unsigned
Producto
Con signo
R Qa P Qd Sin
signo
Con
Signo
Q P-Q Qd Con
Signo
7*0=0 (-1)*0 = 0 111 000 000 000 0 +0 000 000 000 +0
7*1=7 (-1)*1 = -1 111 001 000 111 7 +7 111 111 111 -1
7*2=14 (-1)*2 = -2 111 010 001 110 13 +13 110 111 110 -2
7*3=21 (-1)*3 = -3 111 011 010 101 21 +21 101 111 101 -3
........
4*2=8 (-4)*2 = -8 100 010 001 000 8 +8 110 111 000 -8
4*3=12 (-4)*3 =-12 100 011 001 100 12 +12 101 110 100 -12

La siguiente tabla muestra multiplicando negativos (R < 0) y multiplicadores negativos
(Q < 0), y la forma de corregir el resultado.

Producto
unsigned
Producto
Con signo
R Qa P Qd Sin
signo
Con
Signo
R Q P-R
-Q
Qd Con
Signo
7*7=49 -1*-1 = +1 111 111 110 001 49 -15 001 001 000 001 +1
7*6=42 -1*-2 = +2 111 110 101 010 42 -22 001 010 000 010 +2
7*5=35 -1*-3 = +3 111 101 100 011 35 -29 001 011 000 011 +3
7*4=28 -1*-4 = +4 111 100 011 100 28 +28 001 100 000 100 +4
........
4*5=20 -4*-3= +12 100 101 010 100 20 +20 100 011 001 100 +12
4*4=16 -4*-4=+16 100 100 010 000 16 +16 100 100 010 000 +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* b
L
. 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 Q
0
vale 1, C
0
vale 0(porque Q
0
= 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.

R Q P
Co
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 C
0
= 1 y R
n
Q
0
=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 */
11.8. Algoritmos de divisin.
Definiciones:
Dividendo = cuociente + resto
Divisor 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. Dividendo en P, Divisor en R, cuociente en Q. Sumador de
largo 2N.

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 a *= 8
la ensamblara, si a est en $s0, segn:
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.

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 hi= $s2 % $s3
mflo $s0
mfhi $s1

Existe divu para enteros sin signo, sin aviso de overflow.

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

Algoritmos para Multi y Dividir

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Algoritmos para Multi y Dividir

Uploaded by

Copyright:

Available Formats

1

Profesor Leopoldo Silva Bijit 18-07-2007

You might also like