Diferencias

Muestra las diferencias entre dos versiones de la página.

--- punto_flotante [2020/03/25 03:35] – [Representación de Punto Flotante] charly
+++ punto_flotante [2021/11/09 16:58] (actual) – editor externo 127.0.0.1
@@ Línea 58: / Línea 58: @@
 Notar que el número debe tener un solo dígito distinto de cero en la parte entera. Esto implica que el cero no es un número normalizado, sino que tiene una representación especial.
-Por ejemplo el número no normalizado 101012 es igual al valor normalizado 1,0101 × 2<sup>4</sup>.
+Por ejemplo el número no normalizado 10101 es igual al valor normalizado 1,0101 × 2<sup>4</sup>.
 Consideraremos mantisa solamente a los dígitos binarios de la parte fraccionaria del número normalizado, asumiendo que la parte entera siempre vale 1.
@@ Línea 66: / Línea 66: @@
   * El exponente se almacena como un número entero en **exceso-n**. La representación exceso-n permite almacenar números enteros como valores positivos, sumando una constante al valor original. En el caso de **precisión simple**, el exponente se almacena en **exceso-127** (es decir, se le suma 127 y se almacena como un número binario positivo).
   * En la mantisa se almacenan solamente los dígitos de la parte fraccionaria del número normalizado
+Normalmente al operar con este tipo de datos estamos trabajando con números normalizados.
+=== Valores especiales ===
+Dado que la representación de punto flotante usa una cantidad acotada de bits, es imposible que pueda representar todos los números reales.
+En caso de que un número tenga demasiados dígitos significativos para ser representado exactamente, se utilizará la representación de punto flotante más cercana (Hay distintas formas de redondeo).
+Las operaciones que produzcan valores demasiado grandes (overflow) se representan con el valor **infinito**. En caso de que el resultado sea demasiado pequeño (underflow), el resultado será un **número desnormalizado**, o directamente cero.
+Además hay operaciones cuyo resultado no está definido o no es un número real, por ejemplo: {{:sqrt-1.png?nolink|}}, 1/0, ln(-1). Estos casos estarán representados por el valor **NaN** (Not a Number).
+|Valor PF|Exponente|Mantisa|
+|+/- cero|Exponente formado solo por ceros |Mantisa solo contiene ceros|
+|Números desnormalizados|Exponente formado solo por ceros|Mantisa distinta de cero|
+|+/- infinito|Exponente formado solo por unos|Mantisa solo contiene ceros|
+|NaN|Exponente formado solo por unos|Mantisa distinta de cero|
+De aquí surge que los exponentes formados solo por ceros y solo por unos no pueden utilizarse para representar números normalizados. En precisión simple, el menor exponente posible será -126 y el mayor 127.
+Otra particularidad es que hay dos maneras de representar el cero, dependiendo del bit de signo: +0 y -0.
+==== Codificación de un número en  Punto Flotante de precisión Simple ====
+De acuerdo con lo anterior, un número de punto flotante de precisión simple se codifica en 32 bits siguiendo el siguiente esquema:
+|signo (1 bit)|exponente (8 bits)|mantisa normalizada (23 bits)|
+Veamos cómo codificar un número cualquiera en Punto Flotante de precisión simple, por ejemplo: **534,5**.
+  - En primer lugar debemos expresarlo como un número binario normalizado. Aplicando divisiones sucesivas y multiplicaciones sucesivas por 2 obtenemos que
+,5<sub>10</sub> = 1000010110,1<sub>2</sub>
+  - Como la parte entera es mayor a 1, debemos normalizarlo. En este caso alcanza con dividirlo 9 veces por 2 para que solo quede un uno en la parte entera. Luego 534,510 = 1000010110,1<sub>2</sub> = 1,0000101101<sub>2</sub> × 2<sup>9</sup>. Notar que si efectuamos el producto obtendremos el número original.
+  - Como el número es positivo, el bit de signo será s = 0.
+  - Codificamos el exponente 9 en **exceso-127**: 9 + 127 = 136 = 10001000<sub>2</sub>
+  - Finalmente en los 23 bits de la mantisa se almacenan los dígitos de la parte fraccionaria, completando con ceros a la derecha en caso de que sean menos de 23. La representación binaria en punto flotante de 32 bits quedará así:
+{{:pf.png?nolink&250|}}
+Dado que la representación de PF de 32 bits ocupa 4 bytes, es frecuente expresar el contenido de estos 4 bytes de manera más compacta en hexadecimal, de la misma manera que se visualiza el contenido de la memoria en hexadecimal.
+En este caso los bits
+''0100 0100 0000 0101 1010 0000 0000 0000''
+se pueden expresar en hexadecimal de la siguiente manera:
+''44 05 A0 00''
+==== Decodificar un número de Punto Flotante de precisión simple ====
+Suponiendo que obtenemos de la memoria 4 bytes que contienen un número real representado en punto flotante de precisión simple, podemos extraer el número que contiene siguiendo los pasos inversos.
+Si el contenido de estos cuatro bytes expresado en hexadecimal es
+''BE 40 00 00''
+Debemos pasarlo a binario para poder extraer el signo, el exponente y la mantisa:
+''1011 1110 0100 0000 0000 0000 0000 0000''
+  - Separando las partes quedará {{:pf2.png?nolink&300|}}\\
+  - Como s=1, vemos que el número es **negativo**.\\ <color #ffffff>.</color>
+  - Como el exponente está codificado en exceso 127, podemos restarle 127 para obtener el exponente real:\\
+    - 01111100<sub>2</sub> = 64 + 32 + 16 + 8 + 4 = 124
+    - e = 124 - 127 = **-3**\\ <color #ffffff>.</color>
+  - Podemos expresar el número binario normalizado reemplazando cada una de las partes\\
+    - f = (s) 1,m × 2<sup>e</sup> = -1,10000000000000000000000<sub>2</sub> × 2<sup>-3</sup>
+    - Desnormalizándolo queda: f = **-0,0011<sub>2</sub>**\\ <color #ffffff>.</color>
+  - Finalmente el valor del número de punto flotante expresado en decimal será\\ f = -0,0011<sub>2</sub> = -(1/8 + 1/16) = -(0,125 + 0,0625) = **-0,1875<sub>10</sub>**
+==== Consideraciones sobre la operación con números de punto flotante ====
+Al tratarse de una representación finita de un conjunto infinito, hay que tener en cuenta que tanto la representación de números como las operaciones de punto flotante involucran un error en la mayoría de los casos.
+Esto puede provocar situaciones como la siguiente, por ejemplo en Python:
+    >>> 0.1 + 0.1 + 0.1 == 0.3
+    False
+{{youtube>W8GBE6sdVuQ?large}}
+Notar que la representación binaria de 0,1 requiere infinitos dígitos, por lo que el valor representado como ''0.1'' no es exactamente 0,1. Podemos ver la diferencia si mostramos el valor ''0.1'' con una cantidad grande de dígitos en la parte fraccionaria:
+    >>> '{0:.20g}'.format(0.1)
+    '0.10000000000000000555'
+Esto sugiere que en muchos casos será un error comparar números de punto flotante usando la igualdad.
+Además del error involucrado en la representación, cada operación de punto flotante introduce un error que es inevitable. Hay situaciones donde el orden en que se realicen las operaciones puede amplificar o disminuir el error. Por ejemplo restar dos números muy parecidos puede cancelar dígitos significativos magnificando el error.
+----
+{{youtube>eBkJilWMYvU?large}}
+**Normalización  en decimal**
+----
+{{youtube>ijBLqXhq9RY?large}}
+**Punto Flotante**
+==== Referencias ====
+  * Tanenbaum - Apéndice B
+ --- //[[charlylh@gmail.com|Carlos López Holtmann]]//
+~~NOCACHE~~
+({{counter|total}})

× iphelper toolbox

you see this when javscript or css is not working correct

Untested

Wiki Sistemas

Diferencias

Input