Se estudiarán números representados por una cantidad finita de dígitos o cifras.

Capítulo 9.

Números.

Un número es un ente que permite representar simbólicamente las veces que la unidad está presente en la cantidad observada o medida.

Se estudiarán números representados por una cantidad finita de dígitos o cifras. Un dígito o cifra es un símbolo o carácter que representa a una cantidad entera.

Entonces un número es una secuencia de dígitos. En sistemas posicionales y ponderados, la posición que ocupa un dígito, en la secuencia, representa las veces que está presente la potencia de la base numérica correspondiente.

Sea b la base numérica y di un elemento perteneciente al conjunto Db de los dígitos del sistema. Db está formado por b símbolos, con valores consecutivos, en los que está incluido el cero.

Db = { 0, 1, 2, ... , (b-1) } d i ∈ Db Ejemplos: D 2 = { 0, 1} D 8 = {0, 1, 2, 3, 4, 5, 6, 7} D 10 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} D 16 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F}

9.1. Tipos de números.

9.1.1. Números en punto fijo. Coma fija en nuestro país.

En punto fijo se asume una determinada cantidad de cifras enteras y fraccionarias, pero la posición de la coma o punto decimal siempre se ubica en el mismo lugar.

La representación externa es la secuencia de dígitos siguiente, donde el signo suele ser el símbolo + o -; y se emplea el símbolo coma para separar la parte entera de la fraccionaria:

± d n d n-1 d n-2 ....d 2d 1 d 0,d -1 d -2 d -3 ...d –(m-1) d –m

i n i i i m

N

d b

= =−

= ±

∑

El rango de la representación aumenta si aumenta n. La precisión del número aumenta si aumenta m.

La siguiente es una representación interna en un registro de largo finito de (n + 1 + m) posiciones. La posición del punto es virtual, no se emplea un símbolo para representarlo. Se emplean m cifras para la parte fraccionaria. Se suele emplear un dígito para representar el signo del número.

dn dn-1 dn-2 ... d2 d1 d0 d-1 d-2 d-3 ... d-(m-1) d-m

En la representación interna, que es lo que se deposita en la memoria del computador, sólo se emplean dígitos, y será necesario establecer convenios para representar números con signo. Los bits son bits nada más. Su significado numérico depende de la representación que se emplee.

9.1.2. Aritmética modular.

Consideremos algunos conceptos sobre aritmética modular. Si el módulo es bn+1 . Se tienen: bn+1 mod bn+1 = 0

(bn+1 + b-m) mod bn+1 = b –m En C, el operador mod tiene el símbolo % asociado.

Las reglas de asociatividad y distributividad deben ser cuidadosamente aplicadas en una aritmética modular.

Ya que, por ejemplo, si ( a + b ) no es representable, entonces: ( a + b ) - c puede ser diferente de a + ( b – c ) .

Los números pueden disponerse en un círculo; similar a los números en un reloj, que emplea aritmética módulo 12.

Secuencias de dígitos en un sistema módulo bn+1.

Se consideran, a continuación, secuencias de dígitos representados en un sistema módulo bn+1, con m cifras fraccionarias y (n+1) cifras para la parte entera.

El número bn+1 no es representable.

El anterior a éste, sería el mayor representable, y es: (bn+1 - b –m) Con representación:

Sea cero la secuencia formada por todos los dígitos iguales a 0.

0 0 0 ... 0 0 0 0 0 0 ... 0 0 El número más pequeño siguiente a la secuencia cero es: b –m

Con representación:

0 0 0 ... 0 0 0 0 0 0 ... 0 1 El diametralmente opuesto al cero será: (b n+1)/2. Valor que se obtiene dividiendo por dos el máximo.

Con representación:

b/2 0 0 ... 0 0 0 0 0 0 ... 0 0 Esto se cumple para base par. Las bases de los sistemas númericos que se emplean generalmente son pares.

Entonces las secuencias de dígitos, en coma fija y módulo bn+1, podrían representarse ordenados ascendentemente siguiendo el contorno de una circunferencia, según el sentido del reloj:

Figura 9.1 Números en coma fija, en módulo bn+1

Es importante destacar, que todas las secuencias de dígitos que pueden representarse, en el sistema módulo bn+1, se ubican sobre el círculo, ordenadas según el reloj.

Se han destacado aquellas secuencias de dígitos, descritas antes: la del menor y mayor representable, la de cero y la diametralmente opuesta al cero.

Los valores que estas secuencias numéricas representan dependen del sistema que se emplee para asociarles valores.

b

n 1+

b

−m

b

b

n+1

−

−m 2 1

b

n+

Cero

No es representable ) 2 ( 1

b

b

m n − + −

Para números de punto fijo, sin signo, con (n+1) cifras enteras y m fraccionarias: la relación de orden, queda establecida por el valor de la suma siguiente:

En este caso dn es la cifra más significativa del entero sin signo (unsigned int en el lenguaje C). Como se verá más adelante, las secuencias de dígitos para las distintas representaciones de números con signo, son las mismas que para este caso, sólo difieren las interpretaciones de los valores asociados a las secuencias de dígitos.

Los sistemas numéricos empleados son en base dos, enteros con signo y sin signo.

Para efectuar operaciones aritméticas, en hardware, se emplea un sumador binario, al cual se le agregan redes combinacionales para ampliar sus capacidades; ya sea para realizar restas, o comparaciones, o para detectar propiedades del resultado. Con la misma unidad aritmética, empleada para enteros, pueden tratarse fraccionarios puros, con y sin signo.

Un sumador binario realiza la suma de los operandos de entrada (provenientes de registros o de una palabra de la memoria), ambos de largo l y genera un resultado del mismo largo. De este modo el sumador binario opera con las reglas del álgebra modular.

En el resultado, que se define de largo l, no se considera el bit de reserva que genera la última etapa del sumador; esto es así ya que normalmente se desea depositar el resultado en un registro o en una celda de la memoria, que son de largo l. La detección de si el resultado (de largo l) es incorrecto (en caso de tener reserva de salida y operandos interpretados como enteros sin signo) o correcto asumiendo aritmética modular (que se emplea en la aritmética de direcciones) se deja para las redes combinacionales asociadas al sumador.

Ejemplos:

a) Con m = 0, n = 2 y b = 2, podremos representar 8(22+1) secuencias binarias de tres dígitos. La secuencia cero se expresa según 000, el diametralmente opuesto al cero es: 100. El siguiente al cero es: 001; y el anterior es 111.

Figura 9.2 Secuencias binarias de tres dígitos. 001 000 010 011 111 110 101 100

b

d

i n m i i

N

∑

− =

=

Las secuencias de dígitos binarios quedan separadas en (360/8) grados.

Siguiendo el orden del reloj, el sucesor se obtiene sumando uno (en el sumador binario de largo 3) a cualquier número; y el antecesor, restando uno.

Puede observarse que la mitad de los números comienzan con cero; la otra mitad con uno. El diametralmente opuesto, se logra sumando 100(en el sumador binario de largo 3).

Si se aumenta el largo (de la palabra) en uno se duplica el número de puntos. A medida que el largo aumenta, se tornan más densos los puntos que representan las secuencias de dígitos sobre el círculo; para 32 bits de largo, se tienen más de cuatro mil millones de puntos.

Entonces los números pueden visualizarse como puntos sobre la circunferencia.

De esta forma la suma de dos números A y B, con resultado S, empleando un sumador binario, puede visualizarse como una suma de ángulos, según reloj, en el círculo.

Figura 9.3 Números binarios en sumador.

Si debido a las dimensiones de los números A y B, el rayo asociado a S sobrepasa los 360 grados, habrá reserva de salida, y el valor de S será menor que el menor de los operandos. La posición que ocupa S, es correcta, de acuerdo al álgebra modular, ya que si un número sobrepasa al módulo, se le resta el módulo, dejándolo menor que éste.

b) Con m=0, n=2 y b=10, la secuencia asociada al cero es 000, su diametralmente opuesta es 500. La mayor representable es 999 y la menor representable es 001.

c) Con m=1, n=1 y b=8, la secuencia asociada al cero es 00,0. Su diametralmente opuesta es 40,0; la anterior es 77,7 y la siguiente es 00,1. A S B A B α β S α+β

9.2. Enteros sin signo.

Se emplea m=0. Se asume fija, en la extrema derecha, la posición de la coma decimal: dn dn-1 dn-2 ... d2 d1 d0

Y se interpreta el valor del número, según:

b

d

i n i i

N

∑

=

=

0

El rango de representación es el intervalo: (b n+1 - 1) >= N >= 0

El número bn+1 no es representable. Las operaciones aritméticas con estos números deben proveer alguna indicación cuando ocurra un error de representación.

Corresponde al tipo unsigned int en el lenguaje C. Ejemplos:

Con n=2 y b=2.

La suma de 111 con 001 no es representable en registro de largo 3. La suma de 111 con 111 puede representarse, en largo 4, según: 1110 La resta de 010 con 100 tampoco es representable en largo 3.

El producto de 111 por 111 puede representarse, en registro de largo 6, según: 110001

Con largo de palabra de 32 bits, el mayor número entero representable es: 4.294.967.295, que expresado en hexadecimal es: 0xffffffff

Una fracción pura, sin signo puede representarse:

d-1 d-2 d-3 ... d-(m-1) d-m Una fracción pura, con signo puede representarse:

ds d-1 d-2 ... d-(m-2) d-(m-1) Con ds como bit del signo.

9.3. Números con signo.

9.3.1. Complemento base.

El valor decimal equivalente de la secuencia de dígitos queda dada por: Para números positivos: n

_d

_b

i

m i i N

∑

− = = con dn < b/2

Para números negativos: _⎟ ⎠ ⎞ ⎜ ⎝ ⎛ ₋ − =

∑

− = +

b

d

b

i n m i i n N 1 con dn >= b/2

Se define la representación interna de un número en complemento base, mediante la siguiente expresión, que se evalúa en aritmética módulo bn+1:

b

d

b

i n m i i n CB N

∑

− = + ₋ = 1

Notar que para números positivos, la representación es similar a enteros sin signo, excepto que la cifra más significativa debe ser menor que b/2. (cero con b=2).

Para números negativos, en forma interna (en el registro), se escribe la secuencia representada por NCB.

Entonces la suma de las representaciones internas de un número y su complemento base dan como resultado el módulo. El complemento base de un número es lo que le falta para ser igual al módulo.

Nótese que con la interpretación, para los números negativos, la secuencia opuesta diametralmente al cero es el mayor número negativo representable.

Los valores asociados a las secuencias de dígitos que representan números con signo, en complemento base, se ilustran en el siguiente diagrama.

Figura 9.4 Números complemento base.

Existe sólo una representación para el cero, y el rango de los positivos y negativos representables es asimétrico.

En el círculo, que representa el álgebra modular, la suma de un número y su complemento base es igual al módulo.

El complemento base de un número es el simétrico respecto al eje vertical (excepto para el caso del número más negativo).

Figura 9.5 Números complemento base.

Los números en el primer y cuarto cuadrante trigonométricos son positivos (excepto el más negativo).

Los números positivos aumentan según reloj; por lo tanto los negativos disminuyen en contra del reloj, partiendo del menos negativo, que está adyacente al cero.

b

−m

b

−m

−

2 1

b

n+ −

0

)

2

(

1

b

b

m n − +

−

+

positivo mayor positivo menor el más negativo el menos negativo N θ θ N N -N

Un número negativo en complemento base se anota, en representación interna:

N

N

=

_b

n+1

−

En general, el complemento base de un número puede anotarse:

)

mod(

)

(

_b

n 1

N

_b

n 1

N

=

+

−

+

Y puede verificarse que el complemento del complemento de un número es el mismo número (sea positivo o negativo, exceptuando al más negativo que no tiene complemento).

La suma de los ángulos asociados, de dos números positivos, que exceda los 180 grados da como resultado un número negativo.

La suma de los ángulos asociados, de dos números negativos, que no exceda los (360+180) grados da como resultado un número positivo.

Las condiciones anteriores permitirán diseñar la red combinacional que detecta rebalse, en números con signo, como se verá más adelante.

Para efectuar electrónicamente la resta entre dos números se procede a sumar el primer operando con el complemento base del substraendo.

A - B = A + complemento base de (B)

Figura 9.6 Restas en complemento base.

En el diagrama el complemento base de B1 es un número más negativo que A, su ángulo en sentido contra reloj es mayor que el complemento base de A; y el número positivo B2 es menor que A, por lo que tiene menor ángulo que el número positivo A.

A θ θ A B1 B2 A -A -B2 -B1

Entonces (A - B2) resulta positivo; la suma de los ángulos sobrepasa los 360 grados(que corresponde al módulo). Sobrepasar al módulo, implica reserva de salida del sumador, como puede verificarse: A - B2 = A + ( b n+1 – B2) = b n+1 + (A - B2) > b n+1

Dadas las relaciones anteriores, (A – B1) es negativo. La suma de los ángulos no sobrepasa al módulo; el resultado es negativo y no hay reserva de salida.

A – B1 = A + (b n+1 –B1) = b n+1 - (B1 – A) = Complemento base de (B1 – A ) < b n+1 9.3.2. Complemento a dos.

Para enteros, con m=0 y base =2 se tiene complemento a dos:

2

0 i n i i

d

∑

= Positivos con 0 =

d

n

=

N

C 2

⎟

⎠

⎞

⎜

⎝

⎛

₋

−

∑

= +

2

2

0 1 n i i i n

d

Negativos con

d

n=1

Y también, modificando los límites de la sumatoria, para números negativos:

2

1 0 i n i i

d

∑

− = Positivos con 0 =

d

n

=

N

C2

2

2

1 0 i n i i n

d

∑

−

− =

+

Negativos con

d

n=1 dn dn-1 dn-2 ... d2 d1 d0

Para largo de palabra de 32 bits, un número con signo se representa, en forma externa, según: -d31*2 31 + d30*2 30 + d29*2 29 + .... +d1*2 1 + d0*2 0

El mayor positivo, con d31 = 0 y el resto de los dígitos iguales a uno, es: +2.147.483.647 que equivale a 0x7fffffff = 231 – 1

El mayor negativo, con d31 = 1 y el resto de los dígitos iguales a cero, es: - 2.147.483.648 que equivale a 0x80000000 = - 231

El dígito d31 se denomina bit de signo.

Los ceros que preceden a un número positivo no tienen significación. Los unos que preceden a un número negativo no tienen significación.

Nótese que:

N

=

N

= b n+1 – ( b n+1 – N) Ejemplos:

a) Con n=3, +5 se representa internamente según: 0101 -5 se representa internamente según: 1011 Ya que: 10000- 0101 = 1011

Con 2 3+1= 10000

Usando la segunda interpretación: 1011 puede interpretarse externamente como:

-2 3 + 3 = -5 b) Con n=6, +5 se representa según: 0000101

-5 se representa según: 1111011 Ya que: 2 6+1 - 0000101 = 1111011 Usando la segunda interpretación 1111011 representa al número: -64 + 59 = -5

Nótese que aumentar el largo del registro se rellenan las nuevas posiciones con el bit del signo. Esto se denomina extensión del signo.

Las instrucciones que cargan una media palabra o un byte desde la memoria, rellenan con el bit del signo las posiciones más significativas de la palabra (16 en caso de medias palabras y 24 en caso de bytes).

c) La operación: 30 –36, calculando en decimal es –6. Puede operarse en complemento a 10.

En registro de largo 3, -36 se expresa en complemento a 10, según: Se tiene n=2, entonces: 10 n+1 = 1000. Y por lo tanto: 1000-36=964 El valor +30 es equivalente a 030 en largo 3.

Se realiza la resta, mediante sumas: 030 - 036 = 030 + 964 = 994 994 es número negativo, ya que la cifra más significativa es mayor que 5. 994 ≅ -1000 +994 = -6 O también: -(1000-994) = -6 También puede interpretarse como una resta con préstamo (borrow): 30 + (1000 –36) = 1030 –36 = 994 que tiene valor igual a –6.

d) Con registro de largo 7 bits(n=6). En este sistema pueden representarse números entre 1000000 (-64 10) y 0111111 (+63 10).

Realizar la operación 30 - 36 en binario.

Entonces: 3010 = 0011110 3610 = 0100100 y -3610 = 1011100 Realizando la suma binaria: 0011110

1011100

1111010 = -610

9.3.2. Complemento base disminuida. Se interpretan, en forma externa, según:

b

d

i n m i i

∑

− = Positivos con

2

b

d

n

〈

=

N

CBD

⎟

⎠

⎞

⎜

⎝

⎛

₋

₋

−

∑

− = − +

b

d

b

b

n i m i i m n

)

(

1 Negativos con

2

b

d

n

≥

Notar que para números positivos la representación es igual que en complemento base (y que en enteros sin signo); y que la interpretación del valor de los negativos difiere en un término, que es el menor positivo representable: b -m .

En representación interna, para números negativos se anota la secuencia asociada a la cantidad entre paréntesis, es decir:

(

1

)

i n n m i i i n

b

b

d b

= + − =−

−

−

∑

_.

Los valores asociados a las secuencias de dígitos, que representan números con signo, en complemento base disminuida, se ilustran en el siguiente diagrama.

Figura 9.7 Números complemento base disminuida.

Tiene rango simétrico, y dos representaciones para el valor cero. Lo cual dificulta la realización de comparaciones en hardware.

Complemento a uno.

Para enteros, con base dos, se tiene la representación complemento a uno.

b

−m ) 2 ( 1

b

b

m n − + − −

+0

)

2

(

1

b

b

m n − +

−

+

-0

2

0 i n i i

d

∑

= Positivos con

_d

_n =0

=

N

C1

⎟

⎠

⎞

⎜

⎝

⎛

₋

₋

−

∑

= +

2

2

(

0 1

)

1

i n i i n

d

Negativos con

d

n =1 dn dn-1 dn-2 ... d2 d1 d0 Con n=2, +3 se representa según: 011

-3 se representa según: 100

Ya que: 2 n+1 –1 = 111, al restar a este número el positivo 011, resulta 100.

Se puede generalizar esta operación, y plantear que para obtener el complemento uno de un

número basta efectuar la negación bit a bit, o cambiar los unos por ceros, y los ceros por unos.

El complemento del complemento da el número. El c1 de 100 es 011. Observando las definiciones de las representaciones, puede escribirse: NCB = NCBD + b

–m

Y también, para enteros, en base dos: NC2 = NC1 + 1

Fórmula con que usualmente se calcula números en complemento a dos.

En un círculo que representa enteros, un número en complemento base disminuida está desplazado en la unidad, en contra del reloj, respecto del complemento base.

Figura 9.8 Números en complemento base y base disminuida.

Desde los años 65, del siglo pasado, se emplea representación complemento base para los números enteros con signo. Se exponen otros sistemas de representación de números con signo solamente con fines históricos.

N θ θ N ∼N 1

9.3.3. Números polarizados.

Se emplea en el exponente de un número en punto flotante.

Se desea tener un rango simétrico para los números. Si nos basamos en la representación complemento base deseamos que el número más negativo (que tenga complemento base) sea representado por una secuencia de puros ceros. Para esto a la representación en complemento base se le suma una polarización.

Para el caso de enteros, en representación externa:

)

1

2

(

1 0

−

−

+ =

∑

d

b

b

n i n i i Positivos con

2

b

d

n

≥

=

N

polarizado enteros

(

₂

1

)

1 0 1

−

−

⎟

⎠

⎞

⎜

⎝

⎛

₋

−

+ = +

∑

_d

_b

b

b

n i n i i n Negativos con

2

b

d

n

<

Los valores asociados a las secuencias de dígitos, que representan números con signo, en enteros polarizados en representación interna, se ilustran en los siguientes diagramas.

Figura 9.9 Números polarizados. Cero ) 1 2 ( 1 − − +

b

n Más positivo Más negativo -1 +1 Polarizado Cero Más positivo Más negativo con complemento -1 ₊₁ Entero complement o

Es similar a complemento base, pero se le suma una polarización de (b n+1)/2 -1, lo cual produce que el máximo número negativo se representa ahora como una secuencia de puros 0s.

dn dn-1 dn-2 ... d2 d1 d0 Se tiene, para base dos:

Npolarizado interna = Npolarizado externa + (2 n

–1)

Con n=7, la polarización es 127. (Se usa en el exponente de flotantes en simple precisión). Con n=10 la polarización es 1023. (Se usa en el exponente de flotantes en doble precisión). Ejemplo:

a) Para n=7. (b n+1)/2 –1 = 128 –1 = 127 =100000002-000000012= 011111112 b) Entonces para un exponente de –1 en representación externa, se tiene:

Ni = Ne +127 = -1 + 127 = 126 = 01111110 2

c) Para Ni = 011010002 = 104 , se tiene Ne= Ni – 127 = 104 –127 = -23 = 111010012 d) Un resumen con algunos valores.

Número con signo Valor externo C2 C1 Polarizado en +127 Representación interna -128 10000000 - -127 10000001 10000000 00000000 ... -1 11111111 11111110 01111110 0 00000000 00000000 01111111 +1 00000001 00000001 10000000 .... .... .... ... +127 01111111 01111111 11111110

Nótese que se cumple: NCB + Polarización = Npolarizado interno

Como se verá más adelante la secuencia de ocho unos, se emplea para representar números especiales en punto flotante.

9.3.4. Signo-magnitud

b

d

i n m i i

N

∑

− − =

=

1 Positivos con

_d

_n =0

=

N

SM

( )

N

−

Negativos con

_d

_n=1

Tiene dos ceros, rango simétrico.

9.3.5. Algunas observaciones sobre números en assembler. Observación a las comparaciones con signo y sin signo.

slti $t2, $zero, 1 # 0<1 deja t2 = 1 slti $t2, $zero, -1 # 0<-1 deja t2 = 0 sltiu $t2, $zero, 1 # 0<1 deja t2 = 1 sltiu $t2, $zero, -1 # 0<0xffff deja t2 = 1

-1 unsigned se interpreta com 0xFFFF en un campo de 16 bits. Para efectuar la comparación el campo de 16 bits se extiende a 32 con extensión de signo.

El campo inmediato de 16 bit, cuando representa números con signo permite escribir números entre: -32.768 = -2 15 y +32.767 = + (2 15 – 1)

9.4. Relación entre números en base b y base b

k

.

Si b es dos, con k = 3 se tiene número octal, si k = 4 se tiene hexadecimal.

Sean dos secuencias de dígitos que representan números equivalentes en base b y base b k.

( ....a

3

a

2

a

1

a

0

, a

-1

a

-2

a

-3

....)

b

= ( ...A

3

A

2

A

1

A

0

, A

-1

A

-2

A

-3

....)

b k

Si los números son equivalentes se cumple, que tienen iguales valores decimales, es decir:

Σ a

j

b

j

= Σ A

j

b

kj

Agrupando k cifras del sistema en base b, puede expresarse la primera suma , mediante:

Σ a

j

b

j

_{= Σ ( a}

kj +k –1

b

k-1

+...+a

kj

b

0

)b

kj

Entonces se cumple que cualquier dígito del sistema de base b k, puede representarse según la secuencia de k dígitos en base b:

A

j

= ( a

kj +k –1

...a

kj

)

b Lo que resta es convertir el número en base b, a base b k. Ejemplo:

Se tiene un número binario, y su equivalente decimal es: 101000102 = 1*2

7

+0*2 6 + 1*2 5 + 0*2 4 + 0* 2 3 + 0*2 2 +1*2 1 +0*2 0 Se forman grupos de 4 cifras:

Se representan los grupos entre paréntesis por número binarios: = (1010) 2 2

4*1

+ (0010) 2 2 4*0

Los números binarios se expresan en hexadecimal:

= (A 16) 2 4*1 + (216) 2 4*0 = (A 16) 161 + (216) 160 = A2 16

Entonces para convertir un número en base b a base bk, basta leer en hexadecimal cada grupo de cuatro cifras binarias. La conversión de hexadecimal a binario consiste en reemplazar cada cifra hexadecimal por el grupo equivalente de cuatro cifras binarias.

Esto permite leer o escribir de manera compacta una larga secuencia binaria. Las conversiones de binario a octal, y viceversa se realizan de manera similar. Para esto puede usarse la tabla:

9.5. Conversión de números decimales a binarios.

La representación de los números en forma externa al computador son secuencias de cifras decimales; pero los computadores almacenan y operan con números representados por secuencias de cifras binarias.

La conversión entre estas dos representaciones es un proceso frecuente, al ingresar datos (debe convertirse a binario el número decimal) y al emitir resultados(debe convertirse el número binario a una secuencia decimal equivalente).

Binario Hexadecimal Octal Binario

0000 0 0 000 0001 1 1 001 0010 2 2 010 0011 3 3 011 0100 4 4 100 0101 5 5 101 0110 6 6 110 0111 7 7 111 1000 8 1001 9 1010 A 1011 B 1100 C 1101 D 1110 E 1111 F

Con más detalle, la representación externa es una secuencia de caracteres ASCII, donde cada número decimal se representa por un byte. Los cuatro bits menos significativos son la representación binaria del dígito decimal.

Se desea desarrollar un algoritmo para efectuar la conversión, pero con las operaciones en binario, para que pueda ser desarrollado por un procesador.

Sean dos secuencias de dígitos que representan números equivalentes en base 2 y base 10.

( ....a

3

a

2

a

1

a

0

, a

-1

a

-2

a

-3

....)

2

= ( ...A

3

A

2

A

1

A

0

, A

-1

A

-2

A

-3

....)

10 Si los números son equivalentes se cumple que tienen iguales valores decimales, es decir:

Σ a

j

2

j

_{= Σ A}

j

10

j

Si se reemplazan las cifras decimales por sus equivalentes binarios, se tendrá:

Σ a

j

b

j

_{= Σ ( A}

j

)

2

(1010)

2 j

Donde puede emplearse la siguiente tabla para convertir las cifras decimales a secuencias binarias:

Si es una cifra decimal, su equivalente ASCII está entre 0x30 y 0x39.

Si al byte que representa la cifra decimal se le resta 0x30, se obtiene la secuencia binaria que lo representa.

Si al char que representa la cifra decimal se le resta ‘0’, el char asociado al dígito decimal 0, se obtiene la secuencia binaria del dígito decimal.

Ejemplo.

Convertir 98 a binario.

98 = 10012*10102 + 10002 = 10110102 + 10002 = 11000102

Para cinco cifras decimales se tendrá el siguiente equivalente binario: A[4]*(1010)4 + A[3]*(1010)3 + A[2]*(1010)2 + A[1]*(1010)1 + A[0]

Binario Decimal Byte ASCII ASCII Binario

0000 0 0x30 00110000 0001 1 0x31 00110001 0010 2 0x32 00110010 0011 3 0x33 00110011 0100 4 0x34 00110100 0101 5 0x35 00110101 0110 6 0x36 00110101 0111 7 0x37 00110111 1000 8 0x38 00111000 1001 9 0x39 00111001

La suma anterior puede escribirse del modo siguiente:

(((A[4]*(1010)+ A[3])*(1010)+ A[2])*(1010)+ A[1])*(1010)+ A[0] El algoritmo de conversión, para N cifras decimales, puede plantearse:

for (j=N-1, num=A[j]; j>0; j--) num = num*1010 +A[j-1]; 9.5.1. Conversión de secuencias de caracteres a un entero.

De representación externa a interna.

La función atoi (ASCII to integer) convierte la secuencia de caracteres decimales a un número entero con signo. Efectúa las operaciones en decimal.

El argumento s apunta a un string con la secuencia de dígitos decimales.

#define isdigit(c) ( ((unsigned char)(c)>=’0’ ) && ((unsigned char)(c)<=’9’ )) /*macro que determina si la cifra es dígito decimal */

int atoi(register const char * s)

{register int a; register unsigned char sign;

while (*s == ' ' || *s == '\t') s++; /* salta espacios y tabs */ a = 0; sign = 0; /* asume signo positivo */ if(*s = = '-') {sign++; s++; } /* si es negativo coloca signo*/ while (isdigit(*s)) a = a*10 + (*s++ - '0'); /* calcula número */ if(sign) return (-a);

return (a);

}

La siguiente rutina en assembler MIPS implementa atoi. #**************************************

# v0 =atoi($a0); #

#**************************************

#Convierte string de cifras decimales en a0 a int en binario en v0. atoi: addiu $sp, $sp,-12 #crea espacio del frame de12 bytes.

sw $s0, 0($sp) #salva s0 sw $s1, 4($sp) #salva s1

sw $ra, 8($sp) #salva dirección de retorno # Inicia locales y define temporales.

li $s0, 0 # a

li $s1, 0 # sign

li $t1, ' '

li $t2, '\t' # tabulador 0x09

li $t3,'-' # signo menos

li $t4, 0x29 # uno menor que menor cifra decimal li $t5, 0x3a # uno mayor que mayor cifra decimal li $t6, 1 # para comparar con uno

li $t7, 10 # base de decimales skpblk: lb $t0, 0($a0) # t0 = *s

beq $t0, $t1, isblk # es espacio beq $t0, $t2, isblk # es tab

beq $t0, $t3, esneg # es signo menos j isdigit

isblk: addiu $a0, $a0,1 j skpblk esneg: li $s1, 1

while: addiu $a0, $a0, 1 # próxima cifra lb $t0, 0($a0) # ascii en t0. isdigit: slt $t1, $t0, $t5 # c<0x3a

slt $t2, $t4, $t0 # 0x29<c

and $t1, $t1, $t2 # ve si es cifra decimal beq $t1, $t6, toint # es dígito

bne $s1, $t6, espos sub $v0, $zero, $s0 # v0 = -a j fuera espos: move $v0, $s0 # v0 = +a fuera: lw $s0, 0($sp) #restaura s0 lw $s1, 4($sp) #restaura s1 lw $ra, 8($sp) addiu $sp, $sp, 12 jr $ra #y retorna.

toint: addi $t0, $t0, -0x30 # convierte cifra decimal a binario. mult $s0, $t7 # a*10

mflo $t1

add $s0, $t1, $t0 # a = a*10 + A[j-1] j while

La función xtoi permite convertir secuencias de caracteres hexadecimales a un entero binario. int xtoi(register const char * s)

{char sign, c; unsigned val; sign = 0;

val = 0;

while(isspace(*s) ) s++;

if(*s == '-') {sign++; s++;} else if(*s == '+') s++; while(isxdigit(c = *s++)) {

if(isupper(c) ) c = tolower(c); if(isdigit(c))c -= '0'; else c -= 'a' - 10; val *= 16; val += (unsigned char)c; }

if(sign) return (-val); else return (val); }

9.5.2. Conversión de enteros a secuencias de caracteres. De representación interna a externa.

La función itoa, convierte un entero, representado internamente en binario, a un string. void itoa(int n, char s[])

{ int i=0, sign = 0;

if (n < 0) { sign=1; n = -n;}

do { s[i++] = n % 10 + ‘0’; } while ( (n /=10) >0 ); if (sign==1) s[i++] = ‘-‘;

s[i] = ‘\0’; }

Básicamente el algoritmo es el inverso de atoi, debe observarse que se obtienen primero las unidades, luego las decenas, y así sucesivamente; y finalmente el signo menos si el número es positivo. La variable i, al final contiene el largo del string, incluido el signo.

El siguiente segmento invierte el orden del string: char c; int j;

for ( j=i-1, i=0; i<j; i++,j--) {c= s[i]; s[i]=s[j]; s[j] = c;}

9.6. Números en Punto Flotante.

Se denominan así a las representaciones internas al procesador que modelan a los números reales. En forma externa, se representan como números con coma ( 3.1415926 con punto), o bien en notación científica 0.12 10-5 (con un simple dígito a la izquierda del punto decimal). Se dice que el número está normalizado si el dígito a la izquierda no es cero; en el ejemplo anterior: 1.2 10-6 . En el caso de computadores, se emplea números en sistema binario, y con un número finito de dígitos.

Existe un compromiso entre los bits dedicados al exponente y los que representan la mantisa(o cifras significativas del número). El compromiso es entre el rango de representación y la exactitud de la representación. Por otro lado, debido a la forma de accesar la memoria, los números deben ser una o más palabras de la memoria.

9.6.1. Norma IEEE 754.

Estudiaremos números de punto flotante de acuerdo a la norma IEEE 754. El estándar que se impuso a las diferentes formas que se intentaron históricamente.

En forma externa, un número flotante normalizado, se interpreta:

La mantisa siempre comienza en 1, y M representa un fraccionario puro sin signo. Ee es el exponente representado en forma externa.

En forma interna, ocupando 32 bits, se tiene el número punto flotante precisión simple(en C es el tipo float):

Donde S = 0 representa números positivos, S=1 representa números negativos. Signo Exponente Mantisa normalizada simple

1 8 23

Después del signo, se coloca primero el exponente, para poder comparar números. Ya que a mayor exponente, mayor es el número.

También se tiene el tipo double, el que en forma interna, se representa: Signo Exponente Mantisa normalizada doble

1 11 20+32

Ocupa dos palabras consecutivas, o se requieren dos registros.

El exponente Ei, en forma interna, se representa como número polarizado con signo. Para 8 bits: -127 <= Ee <= +127 con Ei = Ee + 127

Para 11 bits: -1023 <= Ee <= +1023 con Ei = Ee + 1023

Esta notación también favorece la comparación. Los exponentes quedan ordenados de más negativos a más positivos, en forma ascendente. (el exponente menor es la secuencia de puros ceros).

La norma IEEE 754 contempla: números normales, sub-normales, representaciones para el cero y el infinito, y para números inválidos (NaN, not a number).

Con –127 = Ee y M2 !=0 Ei=0 se tiene N = (-1)S*0.M2*2-126 Números sub-normales. Con –127 = Ee y M2 ==0 Ei=0 se tiene N = (-1)S*0.0 Cero(con signo). Con –127 < Ee <=127 se tiene N = (-1)S*1.M2*2Ee Números normales. Con Ee =-128 y M2 ==0 Ei= -1 se tiene N = (-1)

S _{* ∞ Infinito(con signo).} Con Ee =-128 y M2 !=0 Ei= -1 se tiene N = NaN Número inválido. Rango de representación. (precisión simple)

Si el número a representar es menor que el menor representable, se dice que existe underflow (vaciamiento).

El menor representable es un número no normalizado.

La representación interna para el menor positivo es: 0x00000001

S = 0, Ei = 0, M = 000000000000000000000012 Como M es diferente de cero y Ei es cero, se tendrá un número sub-normal, que se interpreta según: N = (-1)S*0.M2*2-126

+ 0.000000000000000000000012 *2-126 = 2-126-23 = 1.401298464324817e-45 Entonces se tiene vaciamiento para |N| < (-1)S*2-149 ≈ 1,40130 10-45

Si el número a representar es mayor que el mayor representable se dice que existe overflow (rebalse).

El positivo mayor representable tiene: cero en el signo, el mayor exponente positivo (+127), y la mayor mantisa (ésta es el uno implícito, con puros unos en los bits dedicados a la mantisa; estos unos representan un valor menor que uno, y con el uno implícito se obtiene el dos como cota superior aproximada).

0x7f7fffff = + 1.111111111111111111111112 *2127 = 3.4028234663852886e+38 Rebalse para |N| > (-1)S*(2- 2-23)*2127 ≈ 3,402823 1038

Para obtener las cifras decimales: 2127 = 10x , que implica: x = 127 log 2 = 127 * 0,30103 ≈ 38.

Nótese que no pueden representarse números muy pequeños, ni números muy grandes. La representación interna de +0.0, por convenio es una secuencia de puros ceros.

En doble precisión, con 11 bits, en decimal el exponente mayor es aproximadamente 308; el menor –308.

Constantes.

Se incluyen algunas definiciones de constantes relacionadas con números en punto flotante que se encuentran en el archivo float.h de la biblioteca de C.

#define FLT_RADIX 2 #define FLT_ROUNDS 1 #define FLT_GUARD 1 #define FLT_NORMALIZE 1

#define DBL_DIG 15 /*dígitos decimales de un double */ #define FLT_DIG 6 /*dígitos decimales de un float */ #define DBL_MANT_DIG 53 /* bits de la mantisa de un double */ #define FLT_MANT_DIG 24 /* bits de la mantisa de un double */ #define DBL_EPSILON 2.2204460492503131E-16

/* el mínimo espacio entre dos números doubles representables */ #define FLT_EPSILON 1.19209290E-07F

/* el mínimo espacio entre dos números float representables. Equivale a 2-23 */ /* menores positivos normales */

#define DBL_MIN 2.2250738585072014E-308 /* módulo double menor*/ #define FLT_MIN 1.17549435E-38F /* módulo float menor. Note la F.*/ Ejemplos.

a) Convertir N= –0,75 a representación interna. -0,75 10 = -( 0.5 +0.25) 10 = -( 2

-1

+ 2-2 ) 10 = -0.11 2 y normalizado: -1.1 * 2 –1

M = 100 0000 0000 0000 0000 0000; debe recordarse que el primer uno no se coloca en la representación interna de la mantisa. Esta es una fracción pura.

Ee= -1

Ei = Ee + 127 = -1 + 127 = 12610 = 0111 11102

Resulta N = 1011 1111 0100 0000 0000 0000 0000 00002 = 0xBF400000

La conversión no es tan simple, si el número no puede descomponerse en sumas de potencias negativas de dos, menores que 23. O si el número es irracional, o si es una fracción periódica. En estos casos se aplica divisiones sucesivas.

La representación de N= 1/3 en precisión simple

+ 1.010101010101010101010102 *2-2 = 0.3333333134651184

Existe un error por truncamiento, ya que no es posible expresar en forma exacta con 23 bits para la mantisa.

En doble precisión, se tiene más cifras en la mantisa, pero aún existe truncamiento.

+ 1.0101010101010101010101010101010101010101010100011001 *2-2 = 0.33333333333333

b) Convertir a representación externa:

0 01101000 101 0101 0100 0011 0100 0010 S = 0, implica signo positivo.

Ei = 0x68 = 104 , implica Ee = 104 – 127 = -23

M= 2-1 +2 –3 +2-5 +2 –7 + 2 –9 + 2 –14 +2 –15 +2 –17 +2 -22 = 0.666115

La secuencia representa a: + 1.666115 * 2 –23 ≈0,000000198616385..≈ 1,986164E-7 c) Convertir a representación externa (el menor normal representable. FLT_MIN):

0 00000001 000 0000 0000 0000 0000 0000 S = 0, implica signo positivo.

Ei = 0x01 = 1 , implica Ee = 1 – 127 = -126 M = 000 0000 0000 0000 0000 0000 La secuencia representa a: + 1.000000000000000000000002 *2 -126 = 1.1754943508222875e-38

d) El menor número sub-normal, representado en forma interna en hexadecimal, es 0x00000001.

S = 0, implica signo positivo.

Ei = 0x00 = 0 , implica Ee = 0 – 127 = -127 Implica número sub-normal M = 0.000000000000000000000012 Entonces:

+ 0.000000000000000000000012 *2 -126

= 1.401298464324817e-45 (sub-normal) e) El cero, se representa, según:

0 00000000 000 0000 0000 0000 0000 0000 f) El valor asociado a la constante FLT_EPSILON.

0 01101000 000 0000 0000 0000 0000 0000 S = 0, implica signo positivo.

Ei = 0x68 = 104 , implica Ee = 104 – 127 = -23 M = 0

La secuencia representa a:

+ 1.000000000000000000000002 *2-23 ≈ 1.1920928955078125e-7 ≈0,000000119 La mantisa no normalizada equivale a: .000 0000 0000 0000 0000 00012

Esto muestra porque los flotantes de precisión simple permiten representar números decimales con seis cifras decimales significativas, ya que dos números adyacentes difieren en FLT_EPSILON.

g) El mayor sub-normal positivo es:

+ 0.11111111111111111111111 *2-126 = 1.1754942106924411e-38 Llamados al sistema en SPIM para leer y escribir flotantes.

El siguiente programa ilustra los llamados al sistema para leer y escribir un número en punto flotante en la consola de SPIM. Los números pueden ingresarse con punto decimal, con y sin exponente decimal. En forma similar a la sintaxis de C (1.75 con punto decimal, y empleando notación exponencial 0.5e-3. Debe ser e minúscula).

El programa permite experimentar con la conversión de números punto flotante, en representación externa decimal, a representación interna formato IEEE 754, con apoyo del simulador. Estas operaciones son tediosas de realizar con papel y lápiz.

.data

mensaje2: .asciiz "\nEntre un número real = " x: .float 0.0 .text .globl main main: li $v0,4 la $a0,mensaje2 syscall li $v0,6 #read float en f0 syscall

s.s $f0,x #store single en $f0 en variable estática x.

#macro que emplea swc1

mov.s $f12,$f0 #argumento en $f12

li $v0,2 #print float

syscall j main

Las operaciones en punto flotante requieren de algoritmos especiales y de un hardware dedicado (desde 1990 se emplea un coprocesador integrado al procesador en el mismo chip, con registros independientes, y que puede comunicar los resultados a la memoria).

Simulador de representación y operaciones con números.

Existe en la red un simulador de algoritmos aritméticos para computadores, en la siguiente dirección:

http://www.ecs.umass.edu/ece/koren/arith/simulator/

En el simulador se pueden visualizar las representaciones internas y externas de números en complemento base y flotantes, en las operaciones aritméticas (sumar, restar, multiplicar, dividir).

9.6.2. Algunas operaciones aritméticas en punto flotante. Suma.

Se describe la operación para sumar dos números en punto flotante.

Primero se desplaza la mantisa del número menor hacia la derecha hasta que su exponente sea igual al del número mayor. Esto puede hacer que se pierdan cifras de representación.

Luego se suman las mantisas. El resultado puede no quedar normalizado.

Se normaliza el número variando el exponente, y debe verificarse que no ocurra rebalse o vaciamiento de éste.

Después de la normalización, puede ser necesario redondear la mantisa al número de bits de la representación.

Podría ser que al redondear, el número se desnormalice, en ese caso debe repetirse el paso de normalización.

Lo usual es dedicar hardware especial para implementar el algoritmo anterior. En caso de no tenerlo, la solución es implementar una biblioteca, en base a las operaciones de la unidad aritmética entera, que realice el algoritmo anterior. En este caso, obviamente la realización de una simple suma de flotantes requiere la ejecución de varias instrucciones, alargando el tiempo de ejecución de los programas que empleen números reales.

Multiplicación.

La operación de multiplicación en punto flotante, puede describirse según:

Primero se suman los exponentes. En esto debe considerarse que los exponentes están polarizados; por lo tanto debe restarse la polarización para obtener el exponente correcto. En decimal: si un exponente es 5(polarizado en 127 es 5 + 127= 132) y el otro exponente es -7(polarizado en 127 es -7 + 127= 120), la suma de los exponentes resulta 132+120 = 252, que no es el exponente correcto. Debe realizarse: 252-127 = 125 (que equivale a -2).

Luego se multiplican las mantisas.

Se normaliza el resultado, corriéndolo a la derecha e incrementando el exponente. Verificando si se produce rebalse.

Redondear la mantisa, verificando que el resultado esté normalizado; en caso de no estarlo repetir el proceso de normalización.

Finalmente debe colocarse el signo.

La aritmética de punto flotante tiene un alto grado de elaboración, una de las refinaciones es el redondeo, esto cobra especial importancia en este sistema numérico que en sí es una aproximación del número real. Se emplean bits adicionales denominados de guarda y redondeo en los cálculos intermedios.

El algoritmo de división, es bastante más complejo, y produce una operación más lenta. Para acelerarla en algunos diseños se genera el recíproco; en otros se intenta obtener varios bits de la división en un solo paso. Un pequeño error en la implementación de este algoritmo causó una pérdida millonaria a la empresa Intel, en el diseño del procesador PENTIUM.

La norma IEEE 754, tiene símbolos especiales para representar más y menos infinito, y lo que denomina NAN (not a number) que ocurre en la división de cero por cero, o en una resta de infinito menos infinito. También se tratan números no normalizados que permiten extender el rango de representación.

Más detalles sobre los temas anteriores pueden encontrarse en el texto guía.

Las operaciones en punto flotante requieren de algoritmos especiales y de un hardware dedicado (tradicionalmente como un coprocesador, con registros independientes, que puede comunicar los resultados a la memoria)

9.6.3. Instrucciones MIPS en punto flotante.

En el caso del MIPS, el coprocesador de punto flotante es el número 1.

Existen 32 registros de punto flotante de 32 bits cada uno. Para manipular doubles se emplean registros pares; el par más el impar siguiente forman el espacio para el doble. Más adelante se desarrollan ejemplos en assembler para la manipulación de flotantes.

A continuación se ilustran algunas instrucciones de movimiento de datos, (en el manual del programador figura el repertorio completo de instrucciones y macro instrucciones para tratar con números reales).

lwcz Reg, 0($t2) #Load Word Coprocessor

#Load the word at address into register Reg of coprocessor z (0..3). swcz Reg, 0($t2) #Store Word Coprocessor

#Store the word from register Reg of coprocessor z at address.

mfcz CpuSrc, CPdest #Move CPdest From Coprocessor z

#Move the contents of coprocessor z 's register CPdest to CPU register CpuSrc.

mtcz CpuSrc, CPdest #Move To Coprocessor z

#Move the contents of CPU register CpuSrc to coprocessor z 's register CPdest. bczt label #Branch to label if Coprocessor z flag is set (True) bczf label #Branch to label if Coprocessor z flag not set (False)

Ejemplos de programación assembler con flotantes. Suma de dos números.

El siguiente segmento en C, produce la suma de dos números en punto flotante. #include <stdio.h>

float x = 1.1; float y = 2.2; float z1, z2; int main (void)

{ z1 = x + y; printf("%f\n",z1); z2 = x * y; printf("%f\n",z2); return(0); }

Se traslada al siguiente código assembler: .data

x: .float 1.1 #Variables en segmento de datos y: .float 2.2 # 0.22e+1 en notación científica. z1: .float 0.0 z2: .float 0.0 newline: .asciiz "\n" .text .globl main main: la $t0, x # t0 = &x

lwc1 $f0, 0($t0) # f0 = x (lectura desde memoria)

la $t0, y lwc1 $f2, 0($t0) # f2 = y add.s $f4, $f0, $f2 # f4 = x + y la $t0, z1 # t0 = &z1 swc1 $f4, 0($t0) # *t0 = f4 z1 = x + y (escritura en memoria) mov.s $f12, $f4 #argumento en $f12 li $v0,2 #print float syscall

la $a0, newline #argumento en $a0

li $v0,4 #print string syscall mul.s $f4, $f0, $f2 # f4 = x * y la $t0, z2 # t0 = &z2 swc1 $f4, 0($t0) # *t0 = f4 z2 = x * y mov.s $f12, $f4 # argumento en $f12 li $v0, 2 # print float syscall

la $a0, newline # argumento en $a0

li $v0, 4 # print string

li $v0, 10 # exit Retorno al monitor. syscall

Notar que se emplean registros pares para flotantes en simple precisión.

El llamado número 10 al sistema retorna a la primera instrucción del trap handler, que opera como un monitor( o sistema operativo primitivo).

Conversión.

El siguiente segmento en C, convierte de grados Farhenheit a Celsius. #include <stdio.h>

#define ctef1 5.0/9.0 #define ctef2 ctef1*32.0

/* celsius = (5/9)*(farh -32) = ctef1*farh-ctef2 */ float farh= 100.0;

float celsius;

int main (void)

{ celsius = ctef1*farh-ctef2;

printf("%f\n",celsius); return(0);

}

Se emplean constantes con órdenes #define del preprocesador.

El ensamblador MIPS, del simulador SPIM, no permite el uso de constantes. Se almacenarán las constantes en la zona estática de datos.

.data

ctef1: .float 0.55555556 #5/9 redondeado a 8 cifras ctef2: .float 17.777778 #(5/9)*32 redondeado a 8 cifras. farh: .float 100.0 #

celsius: .float 0.0

#El valor de celsius, con calculadora Windows, es 37.77777777777777777777778 .text .globl main main: la $t0, ctef1 # t0 = &ctef1 lwc1 $f0, 0($t0) # f0 = *t0 la $t0, ctef2 lwc1 $f2, 0($t0) # f2 = ctef2 la $t0, farh lwc1 $f4, 0($t0) # f4 = farh mul.s $f6, $f4, $f0 # f6 = farh * ctef1 sub.s $f8, $f6, $f2 # f8 = farh * ctef1 - ctef2 la $t0, celsius # t0 = &celsius

mov.s $f12, $f8 #argumento en $f12 li $v0, 2 #print float syscall li $v0, 10 #exit syscall La secuencia: la $t0, ctef1 # t0 = &ctef1 lwc1 $f0, 0($t0) # f0 = *t0

Puede reemplazarse por la macro instrucción: l.s $f0,ctef1 La secuencia:

la $t0, celsius # t0 = &celsius swc1 $f8, 0($t0) # *t0 = f8

Puede reemplazarse por la macro instrucción: s.s $f8,celsius Empleo de doble precisión.

Para emplear aritmética de punto flotante en doble precisión, se estudia el siguiente ejemplo: #include <stdio.h>

#define ctef1 5.0/9.0 #define ctef2 ctef1*32.0

/* celsius = (5/9)*(farh -32) = ctef1*farh-ctef2 */ double farh= 100.0;

double celsius;

int main (void)

{ celsius = ctef1*farh-ctef2;

printf("%2.17f\n",celsius); return(0);

}

Note la especificación de dos cifras enteras y 17 decimales en el argumento de control de printf. Al ejecutar este programa en C, podrá advertirse los valores de las últimas cifras.

Al pasar a assembler, note el número de cifras para especificar, con la mayor precisión que es posible las constantes dobles (16 cifras decimales, redondeadas)

.data ctef1: .double 0.5555555555555556#5 #5/9 ctef2: .double 17.777777777777778#7 #(5/9)*32 farh: .double 100.0 # celsius: .double 0.0 #37.77777777777777777777778 .text .globl main main: l.d $f0, ctef1 #macro l.d $f2, ctef2

l.d $f4, farh

mul.d $f6, $f4, $f0 # f6 = farh * ctef1 sub.d $f8, $f6, $f2 # f8 = farh * ctef1 - ctef2

s.d $f8, celsius mov.d $f12, $f8 #argumento en $f12 li $v0, 3 #print double syscall li $v0, 10 #exit syscall

La macro instrucción: l.d $f0, ctef1 se expande en la secuencia:

la $t0, ctef1

lwc1 $f0, 0($t0)

lwc1 $f1, 4($t0)

Note cómo se emplea el par de registros $f0, $f1 para almacenar el flotante doble precisión. Es similar la macro instrucción s.d (por store double).

Índice general.

CAPÍTULO 9. ...1

NÚMEROS...1

9.1.TIPOS DE NÚMEROS. ...1

9.1.1. Números en punto fijo. ...1

9.1.2. Aritmética modular. ...2

Ejemplos: ...4

9.2.ENTEROS SIN SIGNO...6

Ejemplos: ...6

9.3.NÚMEROS CON SIGNO...7

9.3.1. Complemento base. ...7

9.3.2. Complemento a dos...10

Ejemplos: ...11

9.3.2. Complemento base disminuida. ...12

Complemento a uno. ...12

9.3.3. Números polarizados. ...14

Ejemplo:...15

9.3.4. Signo-magnitud ...15

9.3.5. Algunas observaciones sobre números en assembler. ...16

9.4.RELACIÓN ENTRE NÚMEROS EN BASE B Y BASE B K. ...16

9.5.CONVERSIÓN DE NÚMEROS DECIMALES A BINARIOS...17

Ejemplo. ...18

9.5.1. Conversión de secuencias de caracteres a un entero...19

9.5.2. Conversión de enteros a secuencias de caracteres. ...21

9.6.NÚMEROS EN PUNTO FLOTANTE. ...21

9.6.1. Norma IEEE 754...21

Rango de representación. (precisión simple)...22

Constantes...23

Ejemplos. ...23

Llamados al sistema en SPIM para leer y escribir flotantes. ...25

Simulador de representación y operaciones con números. ...26

9.6.2. Algunas operaciones aritméticas en punto flotante. ...26

Suma. ...26

Multiplicación. ...26

9.6.3. Instrucciones MIPS en punto flotante. ...27

Ejemplos de programación assembler con flotantes...28

Suma de dos números...28

Conversión. ...29

Empleo de doble precisión. ...30

ÍNDICE GENERAL. ...32

Índice de figuras.

FIGURA 9.1NÚMEROS EN COMA FIJA, EN MÓDULO BN+1... 3

FIGURA 9.2SECUENCIAS BINARIAS DE TRES DÍGITOS... 4

FIGURA 9.3NÚMEROS BINARIOS EN SUMADOR. ... 5

FIGURA 9.4NÚMEROS COMPLEMENTO BASE... 8

FIGURA 9.5NÚMEROS COMPLEMENTO BASE... 8

FIGURA 9.6RESTAS EN COMPLEMENTO BASE. ... 9

FIGURA 9.7NÚMEROS COMPLEMENTO BASE DISMINUIDA... 12

FIGURA 9.8NÚMEROS EN COMPLEMENTO BASE Y BASE DISMINUIDA... 13