Algoritmos de multiplicación y división.

Capítulo 11. 1 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. 11.1. 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. Por 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 cifras, 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 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 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;

2 Estructuras de Computadores Digitales 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, lo cual es demasiado elevado. 11.2. 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: 0111*0011 0111 0111 0000 0000 0010101 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. 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: 0111*0011 0111 0111 0010101 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 logra un corrimiento hacia la derecha de Q, en una posición. Además el multiplicando debe desplazarse en una posición hacia la izquierda. 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), que determina el valor del bit menos significativo de Q, equivale a la condición: 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.

Algoritmos de multiplicación y división 3 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. Nótese que después de la operación se destruye el multiplicando original en Q, y el multiplicador R. A continuación veremos una formulación analítica de los algoritmos: 11.3. Fundamentación de los algoritmos de multiplicación. Sea Q positivo( q n es cero), entonces: n 1 q i i 0 i 2 Q = = 0 1 i Q R = R 2 q + R 2 q +... + R 2 q +... + R 0 1 i 2 n 1 q n 1 q n q n-1 q n-2... q 2 q 1 q 0 Nótese 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 sólo puede ser cero o uno. Si es uno, el término asociado se suma. El término R 2 i 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.

4 Estructuras de Computadores Digitales Si Q es positivo, entonces: q n = 0 si Q está en notación complemento dos. El producto es S n. Desde un punto de vista formal, puede derivarse una ecuación 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. También 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 condición lógica 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 repetición 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); además esta sentencia permite aplicar los valores iniciales, queda entonces:

Algoritmos de multiplicación y división 5 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 repetición de un for, las variables que aparecen a la izquierda de una asignación representan la instancia i-ésima o actual, y que las que ocurren a la derecha de un símbolo de asignación representan las instancias (i-1)-ésimas, podrá escribirse el conjunto de ecuaciones de diferencias sin los subíndices dentro del bloque de acciones del for. Lo mismo puede aplicarse para los subíndices de los valores iniciales. Queda entonces el algoritmo escrito en lenguaje C, según: /*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 números positivos con signo, pueden ser lógicos o aritméticos: 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 más eficiente, que emplee menos recursos electrónicos que el anterior, por lo que consideremos la siguiente multiplicación: Estudiemos la multiplicación binaria de (+26)*(+13) = +338. Con 6 cifras: 011010 * 001101 011010 S1=000000011010 Q1 = 000110 000000 011010 S2=00000011010 Q2 = 000011 011010 000000 000000 000101010010 S3=000010000010 Q3 =000001 S4=000101010010 Q4=000000 La siguiente elaboración tiende a optimizar el uso de los recursos de hardware. Se observa que en cada paso sólo 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.

6 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 iteración. Lo cual, como se verá, ahorra un registro de largo n+1. Para la obtención 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. Básicamente consisten en expresar las sumas parciales en función 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 términos 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 después 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 número positivo. Para la etapa i-ésima: q i = Q i &1 s i = x i-1 + R q i con x -1 = 0

Algoritmos de multiplicación y división 7 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 sólo 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 subíndices: 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 números sin signo, ya que R es positivo, y r n siempre es cero. Si en cada iteración se divide por dos el valor de Q, el q i correspondiente siempre queda en la posición más 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 relación: S n = 2 n s n ; es decir, s n es la parte más significativa del producto. La parte menos significativa queda en Q. En MIPS, se tienen dos registros, denominados Hi y Lo que almacenan la parte más y menos significativa del producto, respectivamente. Nótese que: Q =Q/2; s = s /2 puede escribirse como un desplazamiento lógico 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 aritmético o lógico. Pero el del registro Q debe ser lógico solamente. Y el bit menos significativo que sale del registro s debe ingresarse en la posición más significativa de Q. La siguiente secuencia ilustra el movimiento del bit menos significativo de s y su posterior colocación en el lugar del bit más 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 ;

8 Estructuras de Computadores Digitales La derivación detallada anterior, permite explicar formalmente la multiplicación con operandos con signos, que se verá a continuación: 11.5. Fundamentación 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 también 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 términos 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: 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 ) Algoritmo de Booth. 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.

Algoritmos de multiplicación y división 9 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 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. 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 posición hacia a la derecha. Por esta razón si Q es otro registro, debe efectuarse un corrimiento lógico (no aritmético) 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, bastaría con ars(s,q,qq) 11.6. 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. Si se considera la siguiente tabla de verdad: 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.1 Multiplicación enteros unsigned.

10 Estructuras de Computadores Digitales Q R P Figura 11.2 Hardware de Multiplicación. Donde: 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. 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, podría producirse una reserva de salida Co igual a uno. Consideremos un registro de largo 3 y efectuemos la multiplicación de 7*3, empleando el algoritmo de papel y lápiz, 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, después 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.

Algoritmos de multiplicación y división 11 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. Es decir: 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. El desarrollo en assembler, en máquinas que no tengan la multiplicación en su repertorio, también es simple si se dispone de un flip-flop que almacene la condición 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 simulación 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 más significativos planteada anteriormente. Se tiene después 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 función 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 más significativo de Rn, si el largo de palabra es de 16 bits, puede obtenerse según: Rn = ( R &( 1<<15)) >> 15 El largo de palabra menos uno, podría definirse como una constante para simplificar la portabilidad a procesadores con largo de palabra diferente. La expresión anterior marca el bit más significativo y lo coloca luego en la posición menos significativa; luego si el bit más 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 más significativas de Q y P. Después de realizada la suma S = P + R; QM = ( S&1 ) << 15; PM = Co << 15; Las que producen un uno en el bit más significativo de QM y PM, si el bit menos significativo de la suma (el producto parcial) y la reserva de salida son unos respectivamente.

12 Estructuras de Computadores Digitales Luego de los corrimientos lógicos a la derecha en una posición: Q >>= 1; S >>= 1; Se rellenan los espacios vacantes con: Q = QM; S = PM; Los corrimientos son lógicos si las variables son de tipo unsigned. Lo planteado anteriormente debe realizarse sólo si se efectúa 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 multiplicación 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 línea se forma una palabra de 32 bits, concatenando P y Q. 11.7. Otros algoritmos para la multiplicación de números con signo. Para un número N, entero con signo, de largo (n+1): d n d n-1 d n-2... d 2 d 1 d 0

Algoritmos de multiplicación y división 13 Su expresión en complemento base es: N CB = N = N+1 = (b n+1 N ) % b n+1 Se emplea el símbolo, para indicar complemento base. Extensión con signo a largo 2L de los operandos. La multiplicación de dos números Q y R, con signo, de largo L (L es n+1, en las fórmulas anteriores) puede realizarse como una multiplicación sin signo extendiendo con signo los operandos a largo 2L. El resultado correcto de la operación, en largo 2L, puede comprobarse con las siguientes relaciones: Si los números 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 multiplicación, 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 multiplicación, en largo 2L. La implementación 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, según: 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 según: + R*Q Estudiemos ahora los productos de dos números 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 sólo el caso a) entrega un resultado correcto. Pero si después de realizado el producto se suman los siguientes términos 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

14 Estructuras de Computadores Digitales 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 términos anteriores influyen en la parte más 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 multiplicación destruye Q. Ejemplos de productos de enteros sin signo y de los términos de corrección. Se consideran operandos de largo 3. En las dos primeras columnas se definen en decimal las operaciones que se realizarán, sin signo y con signo. El multiplicador original se denomina Qa(por antes) y después de realizado el algoritmo de multiplicación se denomina Qd(por después). El producto de enteros sin signo queda en PQd. El producto sin corregir de enteros con signo también 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 término de corrección. 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.

Algoritmos de multiplicación y división 15 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 números con signo positivo, destruye a medida que se realiza la multiplicación al operando Q. No así a R que permanece fijo durante la operación. 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 término correctivo es el complemento base de Q sumado al registro que mantiene la parte más significativa del producto parcial, es decir P. Si el bit menos significativo de Q, se introduce complementado en la posición más significativa del producto parcial P, al efectuar el desplazamiento combinado de P y Q, se formará después de L pasos, P + Q* b L. Sólo resta sumar uno al producto parcial para formar el complemento base del término correctivo asociado a Q. No hay que preocuparse por la generación 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 efectúa). Electrónicamente hay que agregar un pequeño circuito al registro de desplazamiento a la derecha formado por P y Q. Co P Q R

16 Estructuras de Computadores Digitales Nótese que el or exclusivo, de la figura anterior, puede reemplazarse por un or simple. Esto se debe a que nunca se da la condición 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 efectúa 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 posición más significativa de P. Al terminar los ciclos de la multiplicación dicho bit ocupará la posición menos significativa de P. Al efectuar el último corrimiento, se realiza la suma del bit más significativo de Q con la reserva de salida, y se deja el resultado en la posición más 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 multiplicación se suma el complemento uno de Q al producto parcial, si R es negativo. Después del lazo de multiplicación se efectúan 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 corrección si R<0, formando complemento dos*/ if(qn) P-=R; /* corrige con Q<0 */

Algoritmos de multiplicación y división 17 11.8. Algoritmos de división. 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 división. 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 más significativo de Q. 11.9 En assembler MIPS. Las operaciones de corrimiento se realizan mucho más rápido que las multiplicaciones. Se emplean redes combinacionales para los corrimientos. Entonces un compilador C, la expresión a *= 8 la ensamblaría, si a está en $s0, según: sll $s0, $s0, 3 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, la parte más significativa de a en $s0 y la menos significativa en $s1: mult $s2, $s3 mfhi $s0 mflo $s1 Existe la operación multu para enteros sin signo, y sin aviso de overflow.

18 Estructuras de Computadores Digitales Las expresiones, con variables de tipo entero, en C: a = c /d ; /*división entera */ b = c % d ; /*resto división entera. Operación módulo. */ 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.

Algoritmos de multiplicación y división 19 Índice general. CAPÍTULO 11.... 1 ALGORITMOS DE MULTIPLICACIÓN Y DIVISIÓN... 1 11.1. MULTIPLICACIÓN COMO SUMA REPETITIVA.... 1 11.2. MULTIPLICACIÓN MEDIANTE DESPLAZAMIENTOS.... 2 11.3. FUNDAMENTACIÓN DE LOS ALGORITMOS DE MULTIPLICACIÓN... 3 11.4. ALGORITMO QUE EMPLEA MENORES RECURSOS DE HARDWARE... 5 11.5. FUNDAMENTACIÓN DEL ALGORITMO DE BOOTH, PARA OPERANDOS CON SIGNO.... 8 11.6. MULTIPLICACIÓN DE ENTEROS SIN SIGNO.... 9 11.7. OTROS ALGORITMOS PARA LA MULTIPLICACIÓN DE NÚMEROS CON SIGNO.... 12 Ejemplos de productos de enteros sin signo y de los términos de corrección... 14 11.8. ALGORITMOS DE DIVISIÓN... 17 11.9 EN ASSEMBLER MIPS.... 17 ÍNDICE GENERAL.... 19 ÍNDICE DE FIGURAS... 19 Índice de figuras. FIGURA 11.1 MULTIPLICACIÓN ENTEROS UNSIGNED... 9 FIGURA 11.2 HARDWARE DE MULTIPLICACIÓN.... 10