Formato de punto flotante de precisión simple

Formato de número de computadora de 32 bits

El formato de punto flotante de precisión simple (a veces llamado FP32 o float32 ) es un formato de número de computadora , que generalmente ocupa 32 bits en la memoria de la computadora ; representa un amplio rango dinámico de valores numéricos mediante el uso de un punto de base flotante .

Una variable de punto flotante puede representar un rango más amplio de números que una variable de punto fijo del mismo ancho de bits a costa de la precisión. Una variable entera de 32 bits con signo tiene un valor máximo de 2 ³¹ − 1 = 2.147.483.647, mientras que una variable de punto flotante de base 2 de 32 bits IEEE 754 tiene un valor máximo de (2 − 2 ⁻²³ ) × 2 ¹²⁷ ≈ 3,4028235 × 10 ³⁸ . Todos los números enteros con 7 o menos dígitos decimales, y cualquier 2 ⁿ para un número entero −149 ≤ n ≤ 127, se pueden convertir exactamente en un valor de punto flotante de precisión simple IEEE 754.

En el estándar IEEE 754 , el formato base 2 de 32 bits se conoce oficialmente como binary32 ; en IEEE 754-1985 se lo llamó single . IEEE 754 especifica tipos de punto flotante adicionales, como la precisión doble base 2 de 64 bits y, más recientemente, las representaciones base 10.

Uno de los primeros lenguajes de programación que proporcionó tipos de datos de punto flotante de precisión simple y doble fue Fortran . Antes de la adopción generalizada de IEEE 754-1985, la representación y las propiedades de los tipos de datos de punto flotante dependían del fabricante y el modelo de la computadora, y de las decisiones tomadas por los diseñadores del lenguaje de programación. Por ejemplo, el tipo de datos de precisión simple de GW-BASIC era el formato de punto flotante MBF de 32 bits .

La precisión simple se denomina REAL en Fortran ; ^[1] SINGLE-FLOAT en Common Lisp ; ^[2] float en C , C++ , C# y Java ; ^[3] Float en Haskell ^[4] y Swift ; ^[5] y Single en Object Pascal ( Delphi ), Visual Basic y MATLAB . Sin embargo, float en Python , Ruby , PHP y OCaml y single en versiones de Octave anteriores a 3.2 se refieren a números de precisión doble . En la mayoría de las implementaciones de PostScript y algunos sistemas integrados , la única precisión admitida es single.

Estándar IEEE 754: binary32

El estándar IEEE 754 especifica que un binary32 tiene:

• Bit de signo : 1 bit
• Ancho del exponente : 8 bits
• Precisión significativa : 24 bits (23 almacenados explícitamente)

Esto proporciona una precisión de entre 6 y 9 dígitos decimales significativos . Si una cadena decimal con un máximo de 6 dígitos significativos se convierte al formato de precisión simple IEEE 754, lo que da como resultado un número normal , y luego se convierte nuevamente a una cadena decimal con el mismo número de dígitos, el resultado final debe coincidir con la cadena original. Si un número de precisión simple IEEE 754 se convierte a una cadena decimal con al menos 9 dígitos significativos y luego se convierte nuevamente a una representación de precisión simple, el resultado final debe coincidir con el número original. ^[6]

El bit de signo determina el signo del número, que es también el signo de la mantisa. El campo de exponente es un entero sin signo de 8 bits de 0 a 255, en forma sesgada : un valor de 127 representa el exponente real cero. Los exponentes van de −126 a +127 (es decir, de 1 a 254 en el campo de exponente), porque los valores de exponente sesgados 0 (todos 0) y 255 (todos 1) están reservados para números especiales ( números subnormales , ceros con signo , infinitos y NaN ).

El verdadero significado de los números normales incluye 23 bits fraccionarios a la derecha del punto binario y un bit inicial implícito (a la izquierda del punto binario) con valor 1. Los números subnormales y los ceros (que son los números de punto flotante más pequeños en magnitud que el número normal menos positivo) se representan con el valor de exponente sesgado 0, lo que le da al bit inicial implícito el valor 0. Por lo tanto, solo 23 bits fraccionarios del significado aparecen en el formato de memoria, pero la precisión total es de 24 bits (equivalente a log ₁₀ (2 ²⁴ ) ≈ 7,225 dígitos decimales).

Los bits se distribuyen de la siguiente manera:

El valor real asumido por un dato binario de 32 bits dado con un signo dado , exponente sesgado e (el entero sin signo de 8 bits) y una fracción de 23 bits es

${\displaystyle (-1)^{b_{31}}\times 2^{(b_{30}b_{29}\dots b_{23})_{2}-127}\times (1.b_{22}b_{21}\dots b_{0})_{2}}$,

que produce

${\displaystyle {\text{value}}=(-1)^{\text{sign}}\times 2^{(E-127)}\times \left(1+\sum _{i=1}^{23}b_{23-i}2^{-i}\right).}$

En este ejemplo:

• ${\displaystyle {\text{sign}}=b_{31}=0}$,
• ${\displaystyle (-1)^{\text{sign}}=(-1)^{0}=+1\in \{-1,+1\}}$,
• ${\displaystyle E=(b_{30}b_{29}\dots b_{23})_{2}=\sum _{i=0}^{7}b_{23+i}2^{+i}=124\in \{1,\ldots ,(2^{8}-1)-1\}=\{1,\ldots ,254\}}$,
• ${\displaystyle 2^{(E-127)}=2^{124-127}=2^{-3}\in \{2^{-126},\ldots ,2^{127}\}}$,
• ${\displaystyle 1.b_{22}b_{21}...b_{0}=1+\sum _{i=1}^{23}b_{23-i}2^{-i}=1+1\cdot 2^{-2}=1.25\in \{1,1+2^{-23},\ldots ,2-2^{-23}\}\subset [1;2-2^{-23}]\subset [1;2)}$.

de este modo:

• ${\displaystyle {\text{value}}=(+1)\times 2^{-3}\times 1.25=+0.15625}$.

Nota:

• ${\displaystyle 1+2^{-23}\approx 1.000\,000\,119}$,
• ${\displaystyle 2-2^{-23}\approx 1.999\,999\,881}$,
• ${\displaystyle 2^{-126}\approx 1.175\,494\,35\times 10^{-38}}$,
• ${\displaystyle 2^{+127}\approx 1.701\,411\,83\times 10^{+38}}$.

Codificación de exponentes

El exponente de punto flotante binario de precisión simple se codifica utilizando una representación binaria de desplazamiento , donde el desplazamiento cero es 127; también conocido como sesgo de exponente en el estándar IEEE 754.

• E _mín = 01 _H −7F _H = −126
• Emáx = FE _H −7F _{H =} 127
• Sesgo del exponente = 7F _H = 127

Por lo tanto, para obtener el verdadero exponente tal como lo define la representación binaria de desplazamiento, el desplazamiento de 127 debe restarse del exponente almacenado.

Los exponentes almacenados 00 _H y FF _H se interpretan de manera especial.

El valor normal positivo mínimo es y el valor positivo mínimo (subnormal) es . ${\displaystyle 2^{-126}\approx 1.18\times 10^{-38}}$ ${\displaystyle 2^{-149}\approx 1.4\times 10^{-45}}$

Convertir decimal a binario32

En general, consulte el estándar IEEE 754 para la conversión estricta (incluido el comportamiento de redondeo) de un número real en su formato binario32 equivalente.

Aquí podemos mostrar cómo convertir un número real base 10 a un formato binario32 IEEE 754 utilizando el siguiente esquema:

• Considere un número real con una parte entera y una parte fraccionaria como 12.375
• Convertir y normalizar la parte entera a binaria
• Convierta la parte fraccionaria utilizando la siguiente técnica como se muestra aquí
• Agregue los dos resultados y ajústelos para producir una conversión final adecuada.

Conversión de la parte fraccionaria: Considere 0,375, la parte fraccionaria de 12,375. Para convertirlo en una fracción binaria, multiplique la fracción por 2, tome la parte entera y repita con la nueva fracción por 2 hasta que se encuentre una fracción de cero o hasta que se alcance el límite de precisión que es de 23 dígitos fraccionarios para el formato IEEE 754 binary32.

${\displaystyle 0.375\times 2=0.750=0+0.750\Rightarrow b_{-1}=0}$, la parte entera representa el dígito de la fracción binaria. Vuelva a multiplicar 0,750 por 2 para continuar.

${\displaystyle 0.750\times 2=1.500=1+0.500\Rightarrow b_{-2}=1}$

${\displaystyle 0.500\times 2=1.000=1+0.000\Rightarrow b_{-3}=1}$, fracción = 0,011, terminar

Vemos que se puede representar exactamente en binario como . No todas las fracciones decimales se pueden representar en una fracción binaria de dígitos finitos. Por ejemplo, el decimal 0,1 no se puede representar en binario de forma exacta, solo aproximada. Por lo tanto: ${\displaystyle (0.375)_{10}}$ ${\displaystyle (0.011)_{2}}$

${\displaystyle (12.375)_{10}=(12)_{10}+(0.375)_{10}=(1100)_{2}+(0.011)_{2}=(1100.011)_{2}}$

Dado que el formato IEEE 754 binary32 requiere que los valores reales se representen en formato (ver Número normalizado , Número desnormalizado ), 1100.011 se desplaza a la derecha 3 dígitos para convertirse en ${\displaystyle (1.x_{1}x_{2}...x_{23})_{2}\times 2^{e}}$ ${\displaystyle (1.100011)_{2}\times 2^{3}}$

Finalmente podemos ver que: ${\displaystyle (12.375)_{10}=(1.100011)_{2}\times 2^{3}}$

De lo cual deducimos:

• El exponente es 3 (y en la forma sesgada es por lo tanto ) ${\displaystyle (127+3)_{10}=(130)_{10}=(1000\ 0010)_{2}}$
• La fracción es 100011 (mirando a la derecha del punto binario)

A partir de estos podemos formar la representación resultante en formato binario IEEE 754 de 32 bits de 12.375:

${\displaystyle (12.375)_{10}=(0\ 10000010\ 10001100000000000000000)_{2}=(41460000)_{16}}$

Nota: considere convertir 68.123 al formato IEEE 754 binary32: utilizando el procedimiento anterior espera obtener con los últimos 4 bits siendo 1001. Sin embargo, debido al comportamiento de redondeo predeterminado del formato IEEE 754, lo que obtiene es , cuyos últimos 4 bits son 1010. ${\displaystyle ({\text{42883EF9}})_{16}}$ ${\displaystyle ({\text{42883EFA}})_{16}}$

Ejemplo 1: Consideremos el decimal 1. Podemos ver que: ${\displaystyle (1)_{10}=(1.0)_{2}\times 2^{0}}$

De lo cual deducimos:

• El exponente es 0 (y en la forma sesgada es por lo tanto ${\displaystyle (127+0)_{10}=(127)_{10}=(0111\ 1111)_{2}}$
• La fracción es 0 (mirando a la derecha del punto binario en 1.0 es todo ) ${\displaystyle 0=000...0}$

A partir de estos podemos formar la representación resultante en formato binario IEEE 754 de 32 bits del número real 1:

${\displaystyle (1)_{10}=(0\ 01111111\ 00000000000000000000000)_{2}=({\text{3F800000}})_{16}}$

Ejemplo 2: Consideremos un valor de 0,25. Podemos ver que: ${\displaystyle (0.25)_{10}=(1.0)_{2}\times 2^{-2}}$

De lo cual deducimos:

• El exponente es −2 (y en la forma sesgada es ) ${\displaystyle (127+(-2))_{10}=(125)_{10}=(0111\ 1101)_{2}}$
• La fracción es 0 (mirando a la derecha del punto binario en 1.0 son todos ceros)

A partir de estos podemos formar la representación resultante en formato binario IEEE 754 de 32 bits del número real 0,25:

${\displaystyle (0.25)_{10}=(0\ 01111101\ 00000000000000000000000)_{2}=({\text{3E800000}})_{16}}$

Ejemplo 3: Consideremos un valor de 0,375. Vimos que ${\displaystyle 0.375={(0.011)_{2}}={(1.1)_{2}}\times 2^{-2}}$

Por lo tanto, después de determinar una representación de 0,375, podemos proceder como se indica anteriormente: ${\displaystyle {(1.1)_{2}}\times 2^{-2}}$

• El exponente es −2 (y en la forma sesgada es ) ${\displaystyle (127+(-2))_{10}=(125)_{10}=(0111\ 1101)_{2}}$
• La fracción es 1 (mirando a la derecha del punto binario en 1.1 hay un solo ) ${\displaystyle 1=x_{1}}$

A partir de estos podemos formar la representación resultante en formato binario IEEE 754 de 32 bits del número real 0,375:

${\displaystyle (0.375)_{10}=(0\ 01111101\ 10000000000000000000000)_{2}=({\text{3EC00000}})_{16}}$

Convertir binary32 a decimal

Si el valor binario32, 41C80000 en este ejemplo, está en hexadecimal, primero lo convertimos a binario:

${\displaystyle {\text{41C8 0000}}_{16}=0100\ 0001\ 1100\ 1000\ 0000\ 0000\ 0000\ 0000_{2}}$

Luego lo dividimos en tres partes: bit de signo, exponente y significando.

• Bit de signo: ${\displaystyle 0_{2}}$
• Exponente: ${\displaystyle 1000\ 0011_{2}=83_{16}=131_{10}}$
• Significativo: ${\displaystyle 100\ 1000\ 0000\ 0000\ 0000\ 0000_{2}=480000_{16}}$

Luego agregamos el bit 24 implícito al significado:

• Significativo: ${\displaystyle \mathbf {1} 100\ 1000\ 0000\ 0000\ 0000\ 0000_{2}={\text{C80000}}_{16}}$

y decodificamos el valor del exponente restando 127:

• Exponente crudo: ${\displaystyle 83_{16}=131_{10}}$
• Exponente decodificado: ${\displaystyle 131-127=4}$

Cada uno de los 24 bits del significando (incluido el bit 24 implícito), del bit 23 al bit 0, representa un valor, comenzando en 1 y mitades para cada bit, de la siguiente manera:

bit 23 = 1bit 22 = 0,5bit 21 = 0,25bit 20 = 0,125bit 19 = 0,0625bit 18 = 0,03125bit 17 = 0,015625..bit 6 = 0,00000762939453125bit 5 = 0,000003814697265625bit 4 = 0,0000019073486328125bit 3 = 0,00000095367431640625bit 2 = 0,000000476837158203125bit 1 = 0,0000002384185791015625bit 0 = 0,00000011920928955078125

En este ejemplo, el significando tiene tres bits establecidos: bit 23, bit 22 y bit 19. Ahora podemos decodificar el significando sumando los valores representados por estos bits.

• Significado decodificado: ${\displaystyle 1+0.5+0.0625=1.5625={\text{C80000}}/2^{23}}$

Luego necesitamos multiplicar por la base, 2, elevado al exponente, para obtener el resultado final:

${\displaystyle 1.5625\times 2^{4}=25}$

De este modo

${\displaystyle {\text{41C8 0000}}=25}$

Esto es equivalente a:

${\displaystyle n=(-1)^{s}\times (1+m*2^{-23})\times 2^{x-127}}$

donde s es el bit de signo, x es el exponente y m es el significando.

Limitaciones de precisión en valores decimales (entre 1 y 16777216)

• Decimales entre 1 y 2: intervalo fijo 2 ⁻²³ (1+2 ⁻²³ es el siguiente número flotante más grande después de 1)
• Decimales entre 2 y 4: intervalo fijo 2 ⁻²²
• Decimales entre 4 y 8: intervalo fijo 2 ⁻²¹
• ...
• Decimales entre 2 ⁿ y 2 ⁿ⁺¹ : intervalo fijo 2 ^n-23
• ...
• Decimales entre 2 ²² = 4194304 y 2 ²³ = 8388608: intervalo fijo 2 ⁻¹ = 0,5
• Decimales entre 2 ²³ = 8388608 y 2 ²⁴ = 16777216: intervalo fijo 2 ⁰ = 1

Limitaciones de precisión en valores enteros

• Los números enteros entre 0 y 16777216 se pueden representar con exactitud (también se aplica a los números enteros negativos entre −16777216 y 0)
• Los números enteros entre 2 ²⁴ = 16777216 y 2 ²⁵ = 33554432 se redondean a un múltiplo de 2 (número par)
• Los números enteros entre ^2,25 y 2,26 ^se redondean a un múltiplo de 4
• ...
• Los números enteros entre 2 ⁿ y 2 ⁿ⁺¹ se redondean a un múltiplo de 2 ^n-23
• ...
• Los números enteros entre 2 ¹²⁷ y 2 ¹²⁸ se redondean a un múltiplo de 2 ¹⁰⁴
• Los números enteros mayores o iguales a 2 ¹²⁸ se redondean al "infinito".

Casos notables de precisión simple

Estos ejemplos se dan en representación de bits , en hexadecimal y binario , del valor de punto flotante. Esto incluye el signo, el exponente (sesgado) y la mantisa.

0 00000000 00000000000000000000001 2 = 0000 0001 16 = 2 −126 × 2 −23 = 2 −149 ≈ 1.4012984643 × 10 −45 (número subnormal positivo más pequeño)

0 00000000 11111111111111111111111 2 = 007f ffff 16 = 2 −126 × (1 − 2 −23 ) ≈ 1,1754942107 ×10 −38 (número subnormal más grande)

0 00000001 00000000000000000000000 2 = 0080 0000 16 = 2 −126 ≈ 1,1754943508 × 10 −38 (número normal positivo más pequeño)

0 11111110 111111111111111111111111 2 = 7f7f ffff 16 = 2 127 × (2 − 2 −23 ) ≈ 3,4028234664 × 10 38 (número normal más grande)

0 01111110 11111111111111111111111 2 = 3f7f ffff 16 = 1 − 2 −24 ≈ 0,999999940395355225 (número mayor menor que uno)

0 01111111 000000000000000000000000 2 = 3f80 0000 16 = 1 (uno)

0 01111111 000000000000000000000001 2 = 3f80 0001 16 = 1 + 2 −23 ≈ 1.00000011920928955 (número más pequeño mayor que uno)

1 10000000 000000000000000000000000 2 = c000 0000 16 = −20 00000000 000000000000000000000000 2 = 0000 0000 16 = 01 00000000 000000000000000000000000 2 = 8000 0000 16 = −0 0 11111111 000000000000000000000000 2 = 7f80 0000 16 = infinito1 11111111 000000000000000000000000 2 = ff80 0000 16 = −infinito 0 10000000 10010010000111111011011 2 = 4049 0fdb 16 ≈ 3,14159274101257324 ≈ π ( pi )0 01111101 01010101010101010101011 2 = 3eaa aaab 16 ≈ 0.333333343267440796 ≈ 1/3 x 11111111 100000000000000000000001 2 = ffc0 0001 16 = qNaN (en procesadores x86 y ARM)x 11111111 000000000000000000000001 2 = ff80 0001 16 = sNaN (en procesadores x86 y ARM)

De manera predeterminada, 1/3 se redondea hacia arriba, en lugar de hacia abajo como la precisión doble , debido al número par de bits en la mantisa. Los bits de 1/3 más allá del punto de redondeo son 1010...que es más de 1/2 de una unidad en el último lugar .

Las codificaciones de qNaN y sNaN no están especificadas en IEEE 754 y se implementan de manera diferente en distintos procesadores. Los procesadores de la familia x86 y de la familia ARM utilizan el bit más significativo del campo de significando para indicar un NaN silencioso. Los procesadores PA-RISC utilizan el bit para indicar un NaN de señalización.

Optimizaciones

El diseño del formato de punto flotante permite varias optimizaciones, que resultan de la fácil generación de una aproximación de logaritmo de base 2 a partir de una vista entera del patrón de bits sin procesar. La aritmética de enteros y el desplazamiento de bits pueden producir una aproximación a la raíz cuadrada recíproca ( raíz cuadrada inversa rápida ), que se requiere comúnmente en gráficos de computadora .

Véase también

• IEEE 754
• ISO/IEC 10967 , aritmética independiente del lenguaje
• Tipo de datos primitivo
• Estabilidad numérica
• Notación científica

Referencias

1. "Declaración REAL". scc.ustc.edu.cn . Archivado desde el original el 24 de febrero de 2021 . Consultado el 28 de febrero de 2013 .
2. "CLHS: Tipo SHORT-FLOAT, SINGLE-FLOAT, DOUBLE-FLOAT..." www.lispworks.com .
3. "Tipos de datos primitivos". Documentación de Java .
4. "6 tipos y clases predefinidos". haskell.org . 20 de julio de 2010.
5. "Float". Documentación para desarrolladores de Apple .
6. William Kahan (1 de octubre de 1997). "Lecture Notes on the Status of IEEE Standard 754 for Binary Floating-Point Arithmetic" (PDF) . pág. 4. Archivado desde el original (PDF) el 8 de febrero de 2012.

Enlaces externos

• Editor de patrones de bits de punto flotante en vivo
• Calculadora en línea
• Conversor en línea de números IEEE 754 con precisión simple
• Código fuente C para convertir entre precisión IEEE doble, simple y media