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 numérico 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 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 dígitos decimales o menos, 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-2008 , el formato base-2 de 32 bits se denomina oficialmente binario32 ; se llamó single en IEEE 754-1985 . IEEE 754 especifica tipos de punto flotante adicionales, como representaciones de doble precisión en base 2 de 64 bits y, más recientemente, representaciones en 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 del 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# , 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 doble precisión . En la mayoría de las implementaciones de PostScript y en algunos sistemas integrados , la única precisión admitida es simple.

Estándar IEEE 754: binario32

El estándar IEEE 754 especifica que un binario32 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 6 a 9 dígitos decimales significativos . Si una cadena decimal con como máximo 6 dígitos significativos se convierte al formato de precisión simple IEEE 754, dando un número normal, y luego se vuelve a convertir 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 en una cadena decimal con al menos 9 dígitos significativos y luego se vuelve a convertir 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 también es el signo del significado. El exponente es un entero sin signo de 8 bits de 0 a 255, en forma sesgada : un valor de exponente de 127 representa el cero real. Los exponentes varían de −126 a +127 porque los exponentes de −127 (todos 0) y +128 (todos 1) están reservados para números especiales.

El verdadero significado incluye 23 bits de fracción a la derecha del punto binario y un bit inicial implícito (a la izquierda del punto binario) con valor 1, a menos que el exponente se almacene solo con ceros. Así, sólo aparecen 23 bits de fracción del significado 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 binario32 de 32 bits determinado con un signo dado , un 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}}$,

cuyos rendimientos

${\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 binario de punto flotante de precisión simple se codifica utilizando una representación binaria con desplazamiento , siendo el desplazamiento cero 127; También conocido como sesgo de exponente en el estándar IEEE 754.

• E _mín = 01 _H −7F _H = −126
• E _máx = FE _H −7F _H = 127
• Sesgo exponencial = 7F _H = 127

Por lo tanto, para obtener el exponente verdadero definido por 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 forma 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 propio estándar IEEE 754 para conocer la conversión estricta (incluido el comportamiento de redondeo) de un número real a su formato binario32 equivalente.

Aquí podemos mostrar cómo convertir un número real de base 10 a un formato binario 32 IEEE 754 usando el siguiente esquema:

• Considere un número real con un número entero y una parte fraccionaria como 12,375
• Convertir y normalizar la parte entera a binaria
• Convierta la parte fraccionaria usando la siguiente técnica como se muestra aquí
• Sume 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 encontrar una fracción de cero o hasta alcanzar el límite de precisión, que es 23 dígitos de fracción para el formato binario 32 IEEE 754. .

${\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, sólo de forma 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 binario 32 IEEE 754 requiere que los valores reales se representen en formato (consulte Número normalizado , Número desnormalizado ), 1100.011 se desplaza 3 dígitos hacia la derecha para convertirse ${\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 que deducimos:

• El exponente es 3 (y en la forma sesgada, por lo tanto, es ${\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 binario32 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 binario32 IEEE 754: utilizando el procedimiento anterior, espera obtener que los últimos 4 bits sean 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: Considere el decimal 1. Podemos ver que: ${\displaystyle (1)_{10}=(1.0)_{2}\times 2^{0}}$

De lo que deducimos:

• El exponente es 0 (y en la forma sesgada, por lo tanto, es ${\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 binario32 IEEE 754 de 32 bits del número real 1:

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

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

De lo que 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 hay todos ceros)

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

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

Ejemplo 3: Considere un valor de 0,375. Vimos eso ${\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 arriba: ${\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 es un solo ) ${\displaystyle 1=x_{1}}$

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

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

Convertir binario32 a decimal

Si el valor de 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 significado.

• 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 decodificar el valor del exponente restando 127:

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

Cada uno de los 24 bits del significado (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

El significado en este ejemplo tiene tres bits configurados: bit 23, bit 22 y bit 19. Ahora podemos decodificar el significado sumando los valores representados por estos bits.

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

Luego necesitamos multiplicar con la base, 2, a la potencia del exponente, para obtener el resultado final:

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

De este modo

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

Esto equivale 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 significado.

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

• Decimales entre 1 y 2: intervalo fijo 2 ⁻²³ (1+2 ⁻²³ es el siguiente 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 exactamente (también se aplica a los números enteros negativos entre −16777216 y 0)
• Números enteros entre 2 ²⁴ =16777216 y 2 ²⁵ =33554432 redondeados a múltiplo de 2 (número par)
• Los números enteros entre 2 ²⁵ y 2 ²⁶ se redondean a múltiplos 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 múltiplos 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 el significado.

0 00000000 000000000000000000000001 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 (mayor número subnormal)

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

0 11111110 11111111111111111111111 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 00000000000000000000001 2 = 3f80 0001 16 = 1 + 2 −23 ≈ 1.00000011920928955 (número menor 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 00000000000000000000000 2 = 7f80 0000 16 = infinito1 11111111 00000000000000000000000 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 forma predeterminada, 1/3 se redondea hacia arriba, en lugar de hacia abajo como la doble precisión , debido al número par de bits en el significado. Los bits de 1/3 más allá del punto de redondeo son 1010...los que están más de 1/2 de una unidad en el último lugar .

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

Optimizaciones

El diseño del formato de punto flotante permite varias optimizaciones, como resultado 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 ), comúnmente requerida en gráficos por computadora .

Ver también

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

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 FLOTADOR CORTO, FLOTADOR SIMPLE, FLOTADOR DOBLE ..."
3. "Tipos de datos primitivos". Documentación de Java .
4. "6 tipos y clases predefinidos". haskell.org . 20 de julio de 2010.
5. "Flotar". Documentación para desarrolladores de Apple .
6. William Kahan (1 de octubre de 1997). "Notas de la conferencia sobre el estado del estándar IEEE 754 para aritmética binaria de coma flotante" (PDF) . pag. 4.

enlaces externos

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