3.

6 Multiplicacin

La multiplicacin es una operacin mas complicada que la suma y que la resta. Para
entender como es que el hardware realiza esta operacin, con base en la ALU desarrollada,
daremos un repaso de cmo se realiza esta operacin de manera manual, recordando as los
nombres de los diferentes elementos que intervienen en la operacin. Por ejemplo, si
multiplicamos 1000 por 1001, tenemos:

Multiplicando 1000
Multiplicador x 1001
1000
0000
0000
1000
Producto 1001000

El primer operando se llama multiplicando y el segundo multiplicador. Al resultado final se

le llama producto. El algoritmo bsico estudiado en la primaria, realiza la multiplicacin
entre el multiplicando y un dgito del multiplicador para obtener un resultado parcial, cada
resultado parcial se desplaza un lugar a la derecha. Al final se suman todos los productos
parciales desplazados para obtener el producto final.

Cuando se trata de nmeros binarios, la obtencin de cada producto parcial es inmediata, si

el dgito del multiplicador que se est evaluando es 1, el producto parcial es igual al valor
del multiplicando; y si es un 0, el resultado parcial es 0.

Otra observacin importante es que, sin importar la base numrica en la que se obtenga el
producto, al multiplicar un nmero de n-dgitos con otro de m-dgitos, el resultado puede
llegar a requerir, a lo mas, de n + m dgitos. En el caso de MIPS se multiplicarn dos
registros de 32 bits, de manera que el resultado puede requerir hasta de 64 bits para su
representacin.

Primera versin del Algoritmo y Hardware de la Multiplicacin.

La primera versin de la implementacin se basa en el algoritmo de la primara, el

hardware se muestra en la figura 3.14, el multiplicando debe ubicarse en la mitad izquierda
de un registro de 64 bits, para que se vaya desplazando a la izquierda como ocurra con
cada producto parcial. El multiplicando se va a sumar con el registro del producto (de 64
bits) y el resultado se va a escribir en este ltimo registro. A diferencia del algoritmo de la
primaria, la suma se va a realizar cada vez que el multiplicando se recorra a la izquierda, y
no al final de la obtencin de todos los productos parciales.

El multiplicador estar en un registro de desplazamiento de 32 bits, este registro se

desplazar a la derecha de manera que slo se evale al bit menos significativo. El bloque
encargado de sincronizar a los dems elementos es el Control, este bloque evala al bit
menos significativo del multiplicador y en funcin de ello determina si se sumar al
multiplicando con el producto parcial o si solamente se desplazar a la izquierda; tambin
determina cuando la operacin debe terminar. La actividad de este bloque se describe en el
algoritmo de la figura 3.15, donde se muestra que, debido a que los operandos son de 32
bits, se requiere de 32 iteraciones, y en cada iteracin se realizan 3 pasos.

Fig. 3.14 Hardware de la multiplicacin (primera versin)

Fig. 3.15 Algoritmo para la multiplicacin (primera versin)

Ejemplo: Primer algoritmo de la multiplicacin

Usando nmeros de 4 bits, para reducir espacio, multiplicar 6diez x 3diez. (0110dos x 0011dos).

Respuesta:

Debido a que los nmeros son de 4 bits, el algoritmo requerir de 4 iteraciones,

construiremos una tabla mostrando los diferentes pasos en cada iteracin:

Iteracin Paso Multiplicador Multiplicando Producto

0 Valores iniciales 0011 0000 0110 0000 0000
1: 1 => prod = prod + mcando 0011 0000 0110 0000 0110
1 2: Desp. Mcando. a la izq. 0011 0000 1100 0000 0110
3: Desp. Mdor. a la der. 0001 0000 1100 0000 0110
1: 1 => prod = prod + mcando 0001 0000 1100 0001 0010
2 2: Desp. Mcando. a la izq. 0011 0001 1000 0001 0010
3: Desp. Mdor. a la der. 0000 0001 1000 0001 0010
1: 0 => No operacin 0000 0001 1000 0001 0010
3 2: Desp. Mcando. a la izq. 0000 0011 0000 0001 0010
3: Desp. Mdor. a la der. 0000 0011 0000 0001 0010
1: 0 => No operacin 0000 0011 0000 0001 0010
4 2: Desp. Mcando. a la izq. 0000 0110 0000 0001 0010
3: Desp. Mdor. a la der. 0000 0110 0000 0001 0010

En cada iteracin se subraya al bit a evaluar (multiplicador[0]).

Segunda versin del Algoritmo y Hardware de la Multiplicacin.

Una observacin al hardware de la primera versin es la siguiente: Aunque se suman

registros de 64 bits, en realidad la parte significativa de la suma es de 32 bits, ya que en los
otros 32 se estn sumando 0s. Entonces, es posible reducir la ALU a 32 bits, para ello
mantendremos el multiplicando fijo (en un registro de 32 bits) y en lugar de los
desplazamientos que ste realizaba a la izquierda, se desplazar a la derecha al producto. El
producto se mantiene en un registro de 64 bits, por lo que la suma con el multiplicando, se
har con sus 32 bits mas significativos.

La nueva versin para el hardware se muestra en la figura 3.16, mientras que en la figura
3.17 se muestra la nueva versin para el algoritmo. Se conservan las 32 iteraciones y los 3
pasos en cada iteracin.
 Fig. 3.16 Hardware de la multiplicacin (segunda versin)

Fig. 3.17 Algoritmo para la multiplicacin (segunda versin)

Ejemplo: Segundo algoritmo de la multiplicacin

Con este nuevo algoritmo, repetir la multiplicacin de 0110dos x 0011dos.

Respuesta:

Nuevamente construiremos una tabla con los resultados de cada iteracin:

Iteracin Paso Multiplicador Multiplicando Producto

0 Valores iniciales 0011 0110 0000 0000
1: 1 => prod = prod + mcando 0011 0110 0110 0000
1 2: Desp. Producto a la der. 0011 0110 0011 0000
3: Desp. Mdor. a la der. 0001 0110 0011 0000
1: 1 => prod = prod + mcando 0001 0110 1001 0000
2 2: Desp. Producto a la der. 0011 0110 0100 1000
3: Desp. Mdor. a la der. 0000 0110 0100 1000
1: 0 => No operacin 0000 0110 0100 1000
3 2: Desp. Producto a la der. 0000 0110 0010 0100
3: Desp. Mdor. a la der. 0000 0110 0010 0100
1: 0 => No operacin 0000 0110 0010 0100
4 2: Desp. Producto a la der. 0000 0110 0001 0010
3: Desp. Mdor. a la der. 0000 0110 0001 0010

La segunda versin requiere de una menor cantidad de Hardware. Aunque se tiene la

misma cantidad de pasos, es una versin un poco mas rpida debido a que la suma de datos
de 32 bits es ms rpida que la suma de datos de 64.

Versin final del Algoritmo y Hardware de la Multiplicacin.

En el hardware mostrado en la figura 3.16 pueden notarse que, el registro del multiplicador
y el registro del producto se desplazan a la derecha, y que cuando el algoritmo comienza no
importa lo que haya en la mitad derecha del registro del producto, por que se va a perder. Y
cuando el algoritmo termina, el registro del multiplicador queda con 0s, es decir, su valor se
va perdiendo durante el desarrollo del algoritmo.

De manera que puede obtenerse una versin mejorada del hardware, si al comienzo del
algoritmo se coloca al multiplicador a la mitad derecha del producto. Con ello, adems de
reducir los recursos, da pie a un algoritmo mas rpido, por que en lugar de 2
desplazamientos slo se realizar 1. En la figura 3.18 se muestra la versin final del
hardware para la multiplicacin y en la figura 3.19 se muestra al algoritmo que desarrollar
el control en esta versin final. Puede notarse que en cada iteracin se ha reducido a 2 el
nmero de pasos.

Fig. 3.18 Hardware de la multiplicacin (versin final)

Fig. 3.19 Algoritmo para la multiplicacin (versin final)

Ejemplo: Versin final del algoritmo de la multiplicacin

Repetir la multiplicacin de 0110dos x 0011dos, con el algoritmo de la figura 3.19.

Respuesta:

En este caso la tabla slo cuenta con una columna para el multiplicando y otra para el
producto:

Iteracin Paso Multiplicando Producto

0 Valores iniciales 0110 0000 0011
1: 1 => prod = prod + mcando 0110 0110 0011
1
2: Desp. Producto a la der. 0110 0011 0001
1: 1 => prod = prod + mcando 0110 1001 0001
2
2: Desp. Producto a la der. 0110 0100 1000
1: 0 => No operacin 0110 0100 1000
3
2: Desp. Producto a la der. 0110 0010 0100
1: 0 => No operacin 0110 0010 0100
4
2: Desp. Producto a la der. 0110 0001 0010

Solo el registro del producto se modifica a lo largo del algoritmo, el multiplicando

permanece sin cambios durante todas las iteraciones.

En todas las versiones mostradas para la multiplicacin, no se hace la distincin entre

nmeros con signo o sin signo. Una opcin para hacer estas distinciones podra consistir en
evaluar los signos de los operandos y con ello determinar el signo del resultado (basndose
en las leyes de los signos para la multiplicacin). Luego realizar la multiplicacin con
nmeros positivos y colocar el signo correspondiente al resultado. Este esquema es muy
fcil de entender, aunque algo complicado y lento para implementar. El problema es que el
hardware y software se fundamentaron en un algoritmo en el que nunca se consideraron los
signos de los operandos (por conveniencia, por que es un algoritmo ampliamente
conocido). Existen algunos algoritmos que desde un principio consideran los signos de los
operandos, uno de ellos es el algoritmo de Booth.

3.7 Divisin

La divisin es la operacin complementaria a la multiplicacin, nuevamente realizaremos

una primera aproximacin al hardware y al algoritmo de control, basadas en el algoritmo de
la primaria, luego observaremos que mejoras se le pueden hacer, para alcanzar una versin
final mas eficiente.
Recordemos el algoritmo de la primaria dividiendo 101011 entre 100:

1010 Cociente
Divisor 100 101011 Dividendo
- 100
101
- 100
11 Residuo

Estamos considerando la divisin entera; entonces el resultado va a quedar en dos registros,

en uno de ellos se tendr al cociente y en el otro se tendr al residuo o resto.

Los diferentes componentes de la divisin estn relacionados por:

Dividendo = Divisor x Cociente + Residuo

Nuevamente, solo consideraremos nmeros positivos para simplificar la estructura y

comprensin del algoritmo y hardware de la divisin.

Primera versin del Algoritmo y Hardware de la Divisin.

La divisin se fundamenta en restas, en el algoritmo de la primaria escogemos algunos de

los dgitos de la derecha del dividendo hasta que alcance el divisor en los bits escogidos.
Al hacer la operacin de manera manual, es posible determinar por inspeccin cuantos
dgitos son necesarios para que alcance el divisor en una parte del dividendo. Pero con
hardware, la nica manera para determinar si alcanza un nmero en otro es por medio de
una resta. Si despus de hacer la resta el resultado es mayor o igual que cero,
efectivamente, si alcanz en divisor en una parte del dividendo. Pero si el resultado es
menor que cero, entonces significa que no alcanz el divisor y habr que restablecer el
valor que el dividendo tena antes de la resta.

El divisor se colocar a la izquierda de un registro de 64 bits y en cada iteracin se

desplazar a la derecha, para obtener el mismo resultado que el algoritmo de la primaria. El
dividendo deber estar colocado a la derecha de otro registro de 64 bits para que los
operandos sean del mismo tamao y la resta pueda realizarse. Despus de todas las restas
(32 iteraciones o cuando ya no sea posible restar una vez ms al divisor) en este mismo
registro quedar el residuo.

El cociente se generar a lo largo del algoritmo, en un registro de desplazamiento a la

izquierda se introducir un dgito en cada iteracin. Si el divisor alcanz en el residuo, se
introducir por la izquierda un 1 al cociente y si no, se introducir un 0. Al final del
algoritmo, en este registro estar el cociente.

En la figura 3.20 se muestra el hardware para la divisin y en la figura 3.21 se muestra el

algoritmo que sigue el bloque de control. El algoritmo inicia con una resta y dependiendo
del resultado se determina el valor del bit que se introducir al cociente. Se requiere de 33
iteraciones por que en la primera no se est restando del dividendo, puesto que an no se ha
desplazado al divisor a la derecha.

Fig. 3.20 Hardware para la divisin (primera versin)

Fig. 3.21 Algoritmo para la divisin (primera versin)

Ejemplo: Primer algoritmo de la divisin

Usando nmeros de 4 bits, para reducir espacio, dividir 7diez 2diez. (0111dos x 0010dos).

Respuesta:

Debido a que los nmeros son de 4 bits, el algoritmo requerir de 5 iteraciones,

construiremos una tabla mostrando los diferentes pasos en cada iteracin:

Iteracin Paso Cociente Divisor Residuo

0 Valores iniciales 0000 0010 0000 0000 0111
1: Res. = Res. Div. 0000 0010 0000 1110 0111
1 2b: Res < 0 => +Div, Sll C, C0 = 0 0000 0010 0000 0000 0111
3: Desp. Div. a la der. 0000 0001 0000 0000 0111
1: Res. = Res. Div. 0000 0001 0000 1111 0111
2 2b: Res < 0 => +Div, Sll C, C0 = 0 0000 0001 0000 0000 0111
3: Desp. Div. a la der. 0000 0000 1000 0000 0111
1: Res. = Res. Div. 0000 0000 1000 1111 1111
3 2b: Res < 0 => +Div, Sll C, C0 = 0 0000 0000 1000 0000 0111
3: Desp. Div. a la der. 0000 0000 0100 0000 0111
1: Res. = Res. Div. 0000 0000 0100 0000 0011
4 2a: Res > 0 => Sll C, C0 = 1 0001 0000 0100 0000 0011
3: Desp. Div. a la der. 0001 0000 0010 0000 0011
1: Res. = Res. Div. 0001 0000 0010 0000 0001
5 2a: Res > 0 => Sll C, C0 = 1 0011 0000 0010 0000 0001
3: Desp. Div. a la der. 0011 0000 0001 0000 0001

En cada iteracin se subraya en el residuo al bit mas significativo, por que este bit
determina si se continuar con el paso 2a o con el paso 2b (indica se el resultado de la resta
es mayor o menor que cero).

Segunda versin del Hardware de la Divisin.

Observando a la figura 3.20 y analizando con detalle el desarrollo del algoritmo, puede
notarse que la parte significativa de la resta es de 32 bits, por que en los otros 32 se estn
restando 0s, por lo que la ALU que realiza las restas puede reducirse a 32 bits. Adems, se
consigue el mismo resultado si en lugar de desplazar el divisor a la derecha, ste se
mantiene fijo y se desplaza al registro del residuo a la izquierda.

Debe recordarse que al comienzo del algoritmo, el registro del residuo deber contener al
dividendo en sus 32 bits ms a la derecha.
En la figura 3.22 se muestra la segunda versin del hardware de la divisin; la resta se
realiza entre los 32 bits ms significativos del residuo y el divisor. No se muestra al
algoritmo que sigue el control, por que prcticamente sera el mismo al mostrado en la
figura 3.21, con la nica diferencia que en el paso 3, en lugar de desplazar a la derecha al
divisor, se desplazar a la izquierda al residuo.

Fig. 3.22 Hardware para la divisin (segunda versin)

Versin final del Algoritmo y Hardware de la Divisin.

El hardware mostrado en la figura 3.22 puede mejorarse si se observa que tanto el registro
del cociente y el registro del residuo se desplazan a la izquierda, adems en cada
desplazamiento que realiza el registro del residuo, se introduce un 0 en el bit menos
significativo, de manera que cuando el algoritmo termina, el residuo queda en los 32 bits
ms significativos, mientras que los 32 bits menos significativos quedan llenos de 0s.

Entonces, el hardware puede modificarse de manera que los bits que se introduzcan sean
los que correspondan al cociente, con ello, adems de reducir un poco los recursos de
hardware, produce un algoritmo ms rpido, puesto que en lugar de realizar dos
desplazamientos, slo se realizar 1. Al final del algoritmo, en un registro de 64 bits se
tendr al residuo (en los 32 bits ms significativos) y al cociente (en los 32 bits menos
significativos).

Una observacin importante al algoritmo, es que en la primera iteracin siempre a 0 se le

resta el divisor, y la resta siempre ser menor que 0, esta resta no tiene sentido. Por lo que
es posible mejorarlo si antes de la primera resta se desplaza a la izquierda el residuo, con
ello el nmero de iteraciones se reduce a 32, sin embargo, para compensar este
desplazamiento inicial, al concluir las 32 iteraciones, los 32 bits ms significativos deben
desplazarse una posicin a la derecha, para obtener el resultado correcto.

En las figuras 3.23 y 3.24 se muestra la versin final del hardware y del algoritmo de la
divisin respectivamente.
Fig. 3.23 Hardware para la divisin (versin final)

Fig. 3.24 Algoritmo para la divisin (versin final)

Ejemplo: Versin final del algoritmo de la divisin

Con la versin final del algoritmo, dividir 7diez 2diez. (0111dos x 0010dos).

Respuesta:

Con esta nueva versin slo se requerir de 4 iteraciones y en cada iteracin se realizarn
dos pasos:

Iteracin Paso Divisor Residuo

0 Valores iniciales 0010 0000 0111
Desp. Res. a la izq. 1 0010 0000 1110
2: Res. = Res. Div. 0010 1110 1110
1
3b: Res < 0 => +Div, Sll R, R0 = 0 0010 0001 1100
2: Res. = Res. Div. 0010 1111 1100
2
3b: Res < 0 => +Div, Sll R, R0 = 0 0010 0011 1000
2: Res. = Res. Div. 0010 0001 1000
3
3a: Res > 0 => Sll R, R0 = 1 0010 0011 0001
2: Res. = Res. Div. 0010 0001 0001
4
3a: Res > 0 => Sll R, R0 = 1 0010 0010 0011
Desp. Mitad izq. de Rem. a la der. 0010 0001 0011

Despus de las 4 iteraciones se desplaza a la izquierda la mitad izquierda del registro del
residuo. En los 4 bits menos significativos se tiene al cociente.

El hardware para la multiplicacin es prcticamente el mismo que el hardware para la

divisin, la diferencia estriba en el algoritmo de control. Los registros en los que se ubicar
el resultado (en ambos casos) son conocidos como HI y LO. Al realizar una multiplicacin,
HI contendr la parte alta del producto y LO la parte baja. En el caso de una divisin, HI
quedar con el residuo, mientras que LO contendr al cociente.

3.8 Nmeros y operaciones Punto Flotante

Otros tipos de datos importantes son los nmeros de punto flotante, los cuales son una
aproximacin a los nmeros reales. La mayora de computadoras utilizan al estndar IEEE
754 el cual establece una representacin de 32 bits para nmeros en punto flotante en
simple precisin y 64 bits para nmeros en punto flotante en doble precisin (MIPS no es la
excepcin, tambin emplea ese formato).

El estndar IEEE 754 representa a los nmeros en notacin cientfica normalizada (en base
2). La versin normalizada deja un dgito a la izquierda del punto decimal y los dgitos
restantes se sitan a la derecha; por ejemplo, el nmero: 0.000111, una vez normalizado es
1.11 x 2-4 y el nmero 11000000 al normalizarse queda como: 1.1 x 27, de manera que
cualquier nmero puede ser aproximado con una expresin de la forma:

1.xxxxxxdos x 2yyyyyy

A la cadena xxxxxx se le conoce como mantisa y a la cadena yyyyyy se le conoce como

exponente.

Pero adems, los nmeros en punto flotante pueden ser positivos o negativos, de manera
que en la representacin de un nmero debe considerarse un campo para el signo, un campo
para el exponente y otro para la mantisa. De los 32 bits que se disponen en simple
precisin, la distribucin de los campos es:

31 30 29 28 . . . 24 23 22 21 20 19 . . . 3 2 1 0
signo Exponente Mantisa
1 bit 8 bits 23 bits

Se han dedicado 8 bits para el exponente, lo que significa que se tienen 256 combinaciones,
de las cuales deben considerarse algunas mayores y otras menores que cero, para
representar nmeros muy pequeos y nmeros muy grandes. Sin embargo y debido a que es
ms fcil manipular nmeros sin signo, las combinaciones se conservarn desde el valor 0
hasta el 255, y para obtener el valor representado, al valor del exponente se le restar un
nmero conocido como desplazamiento.

La mantisa corresponde a los dgitos que quedan a la derecha del punto decimal, despus de
la normalizacin. La representacin contiene a un 1 que no se escribe por que todos los
nmeros normalizados lo incluirn.

Entonces, a partir de los 32 bits (conteniendo 1s y 0s), el valor representado corresponder

a:
(-1)signo x 1.mantisa x 2exponente - desplazamiento

El valor del desplazamiento es de 127 para simple precisin, por lo que el nmero ms
cercano al cero se obtiene con una cadena de 32 ceros (correspondera a 1 x 2-127), y esta en
el orden de 10-39. Por convencin, esta combinacin es interpretada como 0.0, puesto que
en simple precisin no es posible encontrar un nmero mas cercano al 0.

El nmero ms alejado del 0, se obtiene con una cadena de 1s (a excepcin del bit de signo,
que puede tener 0). Esta combinacin est en el orden de 1038, que aunque es un nmero
grande, difiere de lo que consideramos como infinito.

Las operaciones en punto flotante pueden producir resultados mas pequeos (bajo flujo) o
resultados mas grandes (sobre flujo), por lo que en ocasiones ser necesario contar con mas
bits para la representacin.
El estndar IEEE 754 incluye una representacin de doble precisin, la cual utiliza 64 bits,
por lo que los tamaos de los campos crecen significativamente:

31 30 29 28 . . . 21 20 19 18 17 . . . 3 2 1 0
signo Exponente Mantisa
1 bit 8 bits 23 bits

31 30 29 28 . . . 3 2 1 0
Mantisa
32 bits

Para el campo del exponente se dispone de 11 bits, mientras que para la mantisa se tienen
52; con ello, el nmero mas cercano al 0 est en el orden de 10-308 y el mas alejado del 0
esta en el orden de 10308.

Para obtener el valor que se est representando, se emplea la misma expresin utilizada en
simple precisin, con la diferencia de que el valor del desplazamiento ser de 1023.

Ejemplo: Conversin de binario a decimal.

Qu nmero decimal representa la palabra?

1 10000001 01000000000....
signo exponente mantisa

Respuesta:

Aplicando directamente la expresin:

(-1)signo x 1.mantisa x 2exponente desplazamiento = (-1)1x1.0100dos x 2129 127

= - 1.01dos x 22 = - 101dos = - 5.0 diez

Ejemplo: Representacin en Punto-Flotante

Cul sera la representacin del 0.75diez en simple precisin?

Respuesta:

El nmero 0.75diez = -3/4 diez = -3/22 diez = -11dos / 22 diez = - 0.11dos

En notacin cientfica normalizada se tendra: - 1.1 x 2-1

Comparando con la expresin: (-1)signo x 1.mantisa x 2exponente 127 se tiene que:

 exponente 127 = -1, de manera que exponente = 127 1 = 126

Por lo tanto, la representacin del 0.75diez es:

1 01111110 1 0 0 0 0 0 0 0 0 0 0 0. . . .
signo exponente mantisa

Suma en punto flotante.

Para entender como sera el algoritmo y hardware para sumar nmeros en punto flotante,
repasaremos como se hara la operacin si se tratase de nmeros decimal. Sumaremos los
nmeros 9.999diez x 101 con 1.610diez x 10-1, suponiendo que slo podemos almacenar
cuatro dgitos decimales en la mantisa y dos en el exponente.

a) Para que la suma sea correcta, primero se deben alinear los nmeros adecuadamente, es
decir, se debe buscar que el exponente sea el mismo para los dos nmeros. Para ello,
desplazaremos el nmero con el exponente mas pequeo para que alcance al del
exponente mas grande:
1.610diez x 10-1 = 0.1610diez x 100 = 0.01610diez x 101

Pero como slo podemos representar 4 dgitos en la mantisa, el nmero anterior se

redondeara a:
0.016diez x 101

b) Ahora es posible sumar las mantisas:

9.999 diez
+ 0.016 diez
10.015 diez
La suma es 10.015 x 101.

c) Este resultado no esta normalizado, por lo que el siguiente paso consistira en

normalizarlo, para obtener: 1.0015 x 102.

d) Finalmente, puesto que solo se pueden almacenar 4 dgitos para la mantisa, el resultado
debe redondearse a 4 dgitos, el redondeo consiste en aproximar al nmero inmediato
superior el penltimo dgito, si el dgito menos significativo es mayor o igual a 5 y en
caso contrario, aproximar al inmediato inferior. Obtenindose como resultado final:

1.002 x 102

En el inciso (c) al normalizar la suma puede ocurrir un error de sobre flujo si el valor del
exponente es mayor al que se puede representar o bajo flujo en caso de que sea menor. El
algoritmo para la suma en punto flotante se muestra en la figura 3.25, en donde se muestra
que despus de un redondeo, puede ser necesaria otra normalizacin. La deteccin del
sobre flujo o bajo flujo depende de la precisin que se este utilizando para la representacin
de los nmeros.

Fig. 3.25 Algoritmo para la suma en punto flotante

Ejemplo: Suma en punto flotante.

Sumar los nmeros 0.5diez y 0.4375 diez en binario, usando el algoritmo de la figura 3.25

Respuesta:

Primero obtendremos la versin binaria normalizada, suponiendo 4 bits de precisin:

0.5diez = 1/2 diez = 1/21diez = 0.1dos = 0.1dos x 20 = 1.000dos x 2-1
- 0.4375diez = - 7/16 diez = - 7/24diez = - 0.0111dos = 0.0111dos x 20 = - 1.110dos x 2-2

Ahora siguiendo el algoritmo:

1) Se desplaza al nmero con exponente mas pequeo (a la derecha), hasta alinearlo con el
exponente mayor:
- 1.110dos x 2-2 = - 0.111dos x 2-1
2) Se suman las mantisas: 1.000dos x 2-1 + (- 0.111dos x 2-1 ) = 0.001dos x 2-1

3) Se normaliza la suma, verificando si existe sobre flujo o bajo flujo:

0.001dos x 2-1 = 0.010dos x 2-2 = 0.100dos x 2-3 = 1.000dos x 2-4

Puesto que 127 > - 4 > - 126, no hay sobre flujo ni bajo flujo (El exponente desplazado
sera 4 + 127 = 123, y est entre 1 y 254).

4) Redondeo de la suma: 1.000dos x 2-4

Ya est redondeada, por lo que el resultado es:

1.000dos x 2-4 = 0.0001000dos = 1/24 diez = 1/16diez = 0.0625diez

Muchas mquinas dedican hardware para ejecutar operaciones de punto flotante tan rpido
como sea posible. En la figura 3.26 se esboza la organizacin bsica del hardware para la
suma en punto flotante.

Multiplicacin en punto flotante

Una vez comprendida la suma, evaluaremos como se realiza la multiplicacin en punto

flotante. Iniciaremos con nmeros decimales en notacin cientfica. Multiplicaremos
1.110diez x 1010 con 9.200diez x 10-5. Supondremos que podemos almacenar solo 4 dgitos en
la mantisa y 2 en el exponente.

a) A diferencia de la suma, calcularemos el exponente del producto sumando los

exponentes de los factores.
Nuevo exponente = 10 + (-5) = 5

Probemos con los exponentes desplazados para asegurarnos que obtenemos el mismo
resultado: 10 + 127 = 137, y 5 + 127 = 122, de manera que:
Nuevo exponente = 137 + 122 = 259

El cual definitivamente es errneo, el problema es que el desplazamiento se realiz dos

veces (una por cada exponente), de manera que el exponente desplazado es:
Nuevo exponente = (137 + 122) - 127 = 259 127 = 132

b) Luego se deben multiplicar las mantisas:

1.110diez
x 9.200diez
0000
0000
2220
9990
10212000diez
 Fig. 3.26 Hardware requerido para la suma en punto flotante

Hay tres dgitos a la derecha de cada factor, de manera que deber haber 6 dgitos a la
derecha del punto decimal del producto: 10.212000diez

Suponiendo que slo se pueden mantener 3 dgitos a la derecha del punto decimal, el
producto resultante sera: 10.212diez x 105

c) Este resultado no esta normalizado, de manera que tenemos que normalizarlo para
obtener: 1.0212diez x 106

Despus de la multiplicacin, el producto puede ser desplazado a la derecha, sumando 1

al exponente, o bien desplazado a la izquierda restndole 1 al exponente. Por lo tanto,
en este paso debe verificarse la presencia de un sobre flujo o bien de un bajo flujo.

d) Puesto que asumimos que la mantisa era de 4 dgitos, se debe redondear al producto, de
manera que: 1.0212diez x 106 es redondeado a 1.021diez x 106

e) El signo del producto depende de los signos de los factores, si son iguales el producto
es positivo y si son diferentes, el producto ser negativo.
 En este caso el resultado es: + 1.021diez x 106

El signo en la suma fue determinado por la suma de las mantisas, pero en el producto el
signo se determina por los signos de los operandos. En la figura 3.27 se muestra el
algoritmo de multiplicacin binaria en punto flotante. En donde se muestra que despus de
la normalizacin, es posible que ocurra un error de sobre flujo o bajo flujo; y despus del
redondeo, es posible que se requiera normalizar nuevamente.

Fig. 3.27 Algoritmo para la multiplicacin en punto flotante

Ejemplo: Producto en punto flotante.

Multiplicar 0.5diez x - 0.4375 diez en binario, usando el algoritmo de la figura 3.27.

Respuesta:

0.5diez = 1.000dos x 2-1

- 0.4375diez = - 1.110dos x 2-2

Siguiendo el algoritmo:

1) Se suman los exponentes: -1 + (-2) = -3

2) Se multiplican las mantisas:

1.000 dos
x 1.110 dos
0000
1000
1000
1000
1110000 dos

El producto es 1.110000 dos x 2-3, pero necesitamos mantenerlo en 4 bits por lo que
obtenemos: 1.110 dos x 2-3

3) El producto esta normalizado y no hay error de sobre flujo o bajo flujo.

4) El redondeo no cambia al producto.

5) Los signos de los operandos son diferentes, de manera que el resultado es:
- 1.110 dos x 2-3

Instrucciones de Punto Flotante en MIPS

MIPS soporta a los formatos del estndar IEEE 754 para simple y doble precisin, con las
instrucciones:

Suma en simple precisin (add.s) y en doble precisin (add.d)

Resta en en simple precisin (sub.s) y en doble precisin (sub.d)
Multiplicacin en simple precisin (mul.s) y en doble precisin (mul.d)
Divisin en simple precisin (div.s) y en doble precisin (div.d)
Comparacin en simple precisin (c.x.s) y en doble precisin (c.x.d), donde x puede ser:
igual (eq), no igual (neq), menor que (lt), menor o igual que (le), mayor que (gt) y
mayor o igual que (ge)
Brinco en punto flotante sobre una condicin verdadera (bclt) y sobre una condicin
falsa (bclf).
La comparacin en punto flotante ajusta un bit a falso o verdadero, dependiendo de la
condicin de la comparacin; y el brinco en punto flotante decide si se realizar o no el
brinco, dependiendo de la condicin.

Los diseadores de MIPS decidieron agregar un conjunto separado de registros de punto

flotante, llamados $f0, $f1, $f2, . . .- usados ya sea para simple o doble precisin. Por lo
tanto, tambin incluyeron instrucciones de carga en punto flotante (lwcl) y almacenamiento
(swcl). Los registros base para las transferencias de datos en punto flotante continan
siendo registros enteros.

El cdigo MIPS para cargar 2 nmeros de punto flotante de simple precisin, desde la
memoria, para sumarlos y almacenar el resultado en memoria es:

lwcl $f4, x($sp)

lwcl $f6, y($sp)
add.s $f2, $f4, $f6
swcl $f2, z($sp)

Un registro en doble precisin en realidad se forma con dos registros consecutivos de

simple precisin, usando el nmero par como el nombre del registro.

TAREA

1. Escribir un programa, en cualquier lenguaje de alto nivel, que siga los pasos de la
versin final del algoritmo de la multiplicacin.

Por simplicidad usar datos de 16 bits, los cuales se debern pedir al usuario para
almacenarse en 2 arreglos. Luego se seguir al algoritmo paso a paso, para dejar el
resultado en un arreglo de 32 bits.

Para mayor claridad en el programa, utilizar funciones para la suma y los

desplazamientos.

2. Construir una tabla donde se muestren los resultados de dividir al 13diez entre el 3diez,
con base en el algoritmo mostrado en la versin final de la divisin.

3. Mostrar la representacin binaria IEEE 754 en simple precisin para los nmeros
10.5diez y 2/3diez. (En el ltimo caso se obtendr una aproximacin).

4. Siguiendo los algoritmos de la suma y multiplicacin en punto flotante, sumar y

multiplicar los nmeros: 6.42 x 101 y 9.51x 102. Tratar a los nmeros en base 10 y
suponer que slo se tiene 4 dgitos para la mantisa (3 a la derecha del punto decimal).