Download Números.

1
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) }
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}
d i ∈ Db
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
Considerando la siguiente interpretación para el valor del número:
Profesor Leopoldo Silva Bijit
18-07-2007
2
Estructuras de Computadores Digitales
i =n
N = ± ∑ di bi
i =− m
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:
(b-1) (b-1) (b-1)
...
Profesor Leopoldo Silva Bijit
(b-1) (b-1) (b-1) (b-1) (b-1) (b-1)
18-07-2007
...
(b-1) (b-1)
Números
3
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:
n +1
b
n+1
b
−m
−b
No es representable
Cero
b
b
n +1
−m
(b
n +1
2
−m
−b )
2
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.
Profesor Leopoldo Silva Bijit
18-07-2007
4
Estructuras de Computadores Digitales
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:
N=
n
∑d b
i =− m
i
i
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.
000
111
001
110
010
101
011
100
Figura 9.2 Secuencias binarias de tres dígitos.
Profesor Leopoldo Silva Bijit
18-07-2007
Números
5
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.
A
A
α
S
β
α+β
B
B
S
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.
Profesor Leopoldo Silva Bijit
18-07-2007
6
Estructuras de Computadores Digitales
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:
n
N = ∑d i b
i
i =0
(b n+1 - 1) >= N >= 0
El rango de representación es el intervalo:
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
d-(m-2)
d-(m-1)
Una fracción pura, con signo puede representarse:
ds
d-1
d-2
...
Con ds como bit del signo.
Profesor Leopoldo Silva Bijit
18-07-2007
Números
7
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 =
n
∑d b
con dn < b/2
i
i =−m
i
Para números negativos: N = − ⎛⎜ n +1 −
b
⎝
n
⎞ con dn >= b/2
∑ d b ⎟⎠
i=−m
i
i
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:
N CB = b
n +1
−
n
∑d b
i=−m
i
i
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.
Profesor Leopoldo Silva Bijit
18-07-2007
8
Estructuras de Computadores Digitales
0
−m
−b
b
−m
positivo menor
el menos negativo
positivo mayor
+ (b
−
b
n +1
2
n +1
2
−m
−b )
el más negativo
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).
N
N
θ
θ
-N
N
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.
Profesor Leopoldo Silva Bijit
18-07-2007
Números
9
Un número negativo en complemento base se anota, en representación interna:
N =b
n +1
− N
En general, el complemento base de un número puede anotarse:
N = (b
n +1
n +1
− N ) mod(b )
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)
B2
B1
A
A
θ
θ
-B1
-B2
-A
A
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.
Profesor Leopoldo Silva Bijit
18-07-2007
10
Estructuras de Computadores Digitales
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:
n
N
C2
Positivos
∑d 2
=
i =0
i
d
i
⎛ n +1 n
i⎞
− ⎜2 − ∑ di 2 ⎟
i =0
⎝
⎠
n
con
=0
Negativos con
d
n
=1
Y también, modificando los límites de la sumatoria, para números negativos:
n −1
N
C2
Positivos
∑d 2
=
i =0
d
i
n −1
−2
+ ∑di 2
dn-1
dn-2
n
dn
i
i
n
con
=0
Negativos con
d
n
=1
i =0
...
d2
d1
d0
Para largo de palabra de 32 bits, un número con signo se representa, en forma externa, según:
-d31*231 + d30*230 + d29*229+ .... +d1*21+ d0*20
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.
Profesor Leopoldo Silva Bijit
18-07-2007
Números
Nótese que:
11
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.
O también: -(1000-994) = -6
994 ≅ -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
Profesor Leopoldo Silva Bijit
18-07-2007
12
Estructuras de Computadores Digitales
9.3.2. Complemento base disminuida.
Se interpretan, en forma externa, según:
n
N CBD =
∑d b
i
Positivos con
i
i =− m
n
⎛ n +1
i⎞
−m
− ⎜ (b − b ) − ∑ d i b ⎟
i=− m
⎝
⎠
Negativos con
d
d
n
〈
b
2
≥
b
2
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: ( b
n +1
−m
−b )−
i=n
∑db
i
i
.
i =− n
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.
+0
-0
b
−m
+ (b
2
n +1
− (b
2
n +1
−b
−m
−m
−b )
)
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.
Profesor Leopoldo Silva Bijit
18-07-2007
Números
13
n
N C1 =
∑d 2
Positivos con
n
⎛ n +1
i⎞
− ⎜ (2 − 1) − ∑ d i 2 ⎟
i =0
⎝
⎠
Negativos con
i =0
dn
dn-1
i
d
n
=0
i
dn-2
...
d2
d1
d
n
=1
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
desplazado en la unidad, en contra del reloj, respecto del complemento base.
está
N
∼N
N
1
θ
θ
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.
Profesor Leopoldo Silva Bijit
18-07-2007
14
Estructuras de Computadores Digitales
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:
n+1
n
∑d b − ( b
N
polarizado
enteros
=
i
i =0
i
2
Positivos con
− 1)
d
n +1
⎛ n +1 n
i⎞
− ⎜ b − ∑ d i b ⎟ − ( b − 1)
2
i =0
⎝
⎠
n
≥
b
2
Negativos con
d
n
<
b
2
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.
n +1
− (b
2
Más negativo
− 1)
Polarizado
-1
Más positivo
Cero
+1
Cero
-1
+1
Entero
complement
o
Más negativo
con complemento
Más positivo
Figura 9.9 Números polarizados.
Profesor Leopoldo Silva Bijit
18-07-2007
Números
15
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
-128
-127
...
-1
0
+1
....
+127
C2
C1
Polarizado en +127
Representación interna
10000000
10000001
10000000
00000000
11111111
00000000
00000001
....
01111111
11111110
00000000
00000001
....
01111111
01111110
01111111
10000000
.....
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
N
SM
=
Profesor Leopoldo Silva Bijit
N=
n−1
∑d b
i =− m
i
i
− (N )
Positivos
d
n
=0
Negativos con
18-07-2007
con
d
n
=1
16
Estructuras de Computadores Digitales
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.
( ....a3 a2 a1 a0, a-1 a-2 a-3....) b = ( ...A3 A2 A1 A0, A-1 A-2 A-3 ....)bk
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:
= (1*2 3 +0*2 2 + 1*2 1 + 0*2 0 ) 2 4*1 + (0* 2 3 + 0*2 2 +1*2 1 +0*2 0 ) 2 4*0
Profesor Leopoldo Silva Bijit
18-07-2007
Números
17
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:
Binario
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
Hexadecimal
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
Octal
0
1
2
3
4
5
6
7
Binario
000
001
010
011
100
101
110
111
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).
Profesor Leopoldo Silva Bijit
18-07-2007
18
Estructuras de Computadores Digitales
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.
( ....a3 a2 a1 a0, a-1 a-2 a-3....)2 = (
...A3 A2 A1 A0, 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)2j
Donde puede emplearse la siguiente tabla para convertir las cifras decimales a secuencias
binarias:
Binario
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
Decimal
0
1
2
3
4
5
6
7
8
9
Byte ASCII
0x30
0x31
0x32
0x33
0x34
0x35
0x36
0x37
0x38
0x39
ASCII Binario
00110000
00110001
00110010
00110011
00110100
00110101
00110101
00110111
00111000
00111001
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]
Profesor Leopoldo Silva Bijit
18-07-2007
Números
19
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;
/* salta espacios y tabs */
while (*s == ' ' || *s == '\t') s++;
/* asume signo positivo */
a = 0; sign = 0;
/* si es negativo coloca signo*/
if(*s = = '-') {sign++; s++; }
/* calcula número
*/
while (isdigit(*s)) a = a*10 + (*s++ - '0');
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
Profesor Leopoldo Silva Bijit
18-07-2007
20
Estructuras de Computadores Digitales
li
$t7, 10
# base de decimales
skpblk: lb
beq
beq
beq
j
isblk: addiu
j
esneg: li
$t0, 0($a0)
$t0, $t1, isblk
$t0, $t2, isblk
$t0, $t3, esneg
isdigit
$a0, $a0,1
skpblk
$s1, 1
# t0 = *s
# es espacio
# es tab
# es signo menos
while: addiu
lb
isdigit: slt
slt
and
beq
bne
sub
j
espos: move
fuera: lw
lw
lw
addiu
jr
toint: addi
mult
mflo
add
j
$a0, $a0, 1
# próxima cifra
$t0, 0($a0)
# ascii en t0.
$t1, $t0, $t5
# c<0x3a
$t2, $t4, $t0
# 0x29<c
$t1, $t1, $t2
# ve si es cifra decimal
$t1, $t6, toint
# es dígito
$s1, $t6, espos
$v0, $zero, $s0 # v0 = -a
fuera
$v0, $s0
# v0 = +a
$s0, 0($sp)
#restaura s0
$s1, 4($sp)
#restaura s1
$ra, 8($sp)
$sp, $sp, 12
$ra
#y retorna.
$t0, $t0, -0x30
# convierte cifra decimal a binario.
$s0, $t7
# a*10
$t1
$s0, $t1, $t0
# a = a*10 + A[j-1]
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);
}
Profesor Leopoldo Silva Bijit
18-07-2007
Números
21
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:
(-1)S*1.M2*2Ee
Profesor Leopoldo Silva Bijit
18-07-2007
22
Estructuras de Computadores Digitales
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
Con –127 = Ee y M2 ==0 Ei=0
Con –127 < Ee <=127
Con Ee =-128 y M2 ==0 Ei= -1
Con Ee =-128 y M2 !=0 Ei= -1
se tiene
se tiene
se tiene
se tiene
se tiene
N = (-1)S*0.M2*2-126
N = (-1)S*0.0
N = (-1)S*1.M2*2Ee
N = (-1)S * ∞
N = NaN
Números sub-normales.
Cero(con signo).
Números normales.
Infinito(con signo).
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
Profesor Leopoldo Silva Bijit
18-07-2007
Números
23
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
#define FLT_DIG
15
6
#define DBL_MANT_DIG
#define FLT_MANT_DIG
/*dígitos decimales de un double */
/*dígitos decimales de un float */
53
24
/* bits de la mantisa de un double */
/* 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
Entonces: S=1, ya que el signo es negativo.
Profesor Leopoldo Silva Bijit
18-07-2007
24
Estructuras de Computadores Digitales
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.
Convertir a representación externa (el mínimo espacio entre dos representables):
Profesor Leopoldo Silva Bijit
18-07-2007
Números
25
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.
mensaje2:
x:
.data
.asciiz "\nEntre un número real = "
.float 0.0
.text
.globl main
main:
li
la
syscall
li
syscall
s.s
$v0,4
$a0,mensaje2
$v0,6
#read float en f0
$f0,x
#store single en $f0 en variable estática x.
#macro que emplea swc1
#argumento en $f12
#print float
mov.s $f12,$f0
li
$v0,2
syscall
j
main
Profesor Leopoldo Silva Bijit
18-07-2007
26
Estructuras de Computadores Digitales
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.
Profesor Leopoldo Silva Bijit
18-07-2007
Números
27
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)
#Se emplean después de comparaciones en punto flotante
Profesor Leopoldo Silva Bijit
18-07-2007
28
Estructuras de Computadores Digitales
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
li
syscall
la
li
syscall
$f12, $f4
$v0,2
#argumento en $f12
#print float
$a0, newline
$v0,4
#argumento en $a0
#print string
mul.s
la
swc1
$f4, $f0, $f2
$t0, z2
$f4, 0($t0)
# f4 = x * y
# t0 = &z2
# *t0 = f4 z2 = x * y
mov.s
li
syscall
la
li
syscall
$f12, $f4
$v0, 2
# argumento en $f12
# print float
$a0, newline
$v0, 4
# argumento en $a0
# print string
Profesor Leopoldo Silva Bijit
18-07-2007
Números
29
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
swc1 $f8, 0($t0)
# *t0 = f8
Profesor Leopoldo Silva Bijit
18-07-2007
30
Estructuras de Computadores Digitales
mov.s $f12, $f8
li
$v0, 2
syscall
#argumento en $f12
#print float
li
$v0, 10
syscall
#exit
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
Profesor Leopoldo Silva Bijit
18-07-2007
Números
31
l.d
mul.d
sub.d
s.d
mov.d
li
syscall
$f4, farh
$f6, $f4, $f0
$f8, $f6, $f2
$f8, celsius
$f12, $f8
$v0, 3
li
$v0, 10
syscall
# f6 = farh * ctef1
# f8 = farh * ctef1 - ctef2
#argumento en $f12
#print double
#exit
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).
Profesor Leopoldo Silva Bijit
18-07-2007
32
Estructuras de Computadores Digitales
Í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. ................................................................................................................................33
Profesor Leopoldo Silva Bijit
18-07-2007
Números
33
Índice de figuras.
FIGURA 9.1 NÚMEROS EN COMA FIJA, EN MÓDULO BN+1 ................................................................................ 3
FIGURA 9.2 SECUENCIAS BINARIAS DE TRES DÍGITOS.................................................................................... 4
FIGURA 9.3 NÚMEROS BINARIOS EN SUMADOR. ............................................................................................ 5
FIGURA 9.4 NÚMEROS COMPLEMENTO BASE................................................................................................. 8
FIGURA 9.5 NÚMEROS COMPLEMENTO BASE................................................................................................. 8
FIGURA 9.6 RESTAS EN COMPLEMENTO BASE. .............................................................................................. 9
FIGURA 9.7 NÚMEROS COMPLEMENTO BASE DISMINUIDA........................................................................... 12
FIGURA 9.8 NÚMEROS EN COMPLEMENTO BASE Y BASE DISMINUIDA.......................................................... 13
FIGURA 9.9 NÚMEROS POLARIZADOS.......................................................................................................... 14
Profesor Leopoldo Silva Bijit
18-07-2007