Ver el código de «Formato en coma flotante de simple precisión»

El '''formato en coma (o punto) flotante de precisión simple''' es un formato de número de computador u ordenador que ocupa 4 [[byte]]s (32 [[bit]]s) en su memoria y representa un amplio rango dinámico de valores mediante el uso de la [[coma flotante]].

En la norma o estándar [[IEEE coma flotante|IEEE 754-2008]] el formato de 32 bits de base 2 se conoce oficialmente como '''binary32''', aunque se le llamaba '''single''' en la versión previa del estándar IEEE 754-1985. En los equipos más antiguos, se utilizaron diferentes formatos de coma flotante de 4 bytes, como ejemplo, el tipo de datos de precisión simple en el [[lenguaje de programación]] [[GW-BASIC]] era un formato de coma flotante de 32 bits MBF (Formato Binario de [[Microsoft]]).

Uno de los primeros lenguajes de programación en proporcionar [[Tipo de dato|tipos de datos]] de coma flotante de simple y doble precisión fue [[Fortran]]. Antes de la adopción generalizada del estándar IEEE 754-1985, la representación y las propiedades del tipo de datos simple y doble dependían del fabricante del equipo y el modelo de ordenador.

El formato binario en coma flotante de precisión simple se utiliza por abarcar un rango de valores más amplio respecto al formato de [[coma fija]] (del mismo ancho de bits), pero a costa de menor precisión. Un entero con signo de 32 bits puede tener un valor máximo de 2<sup>31</SUP> - 1 = {{Form<!-- Comment -->atnum|2147483647}}, mientras que el valor máximo representable en coma flotante del estándar IEEE 754 es (2-2<sup>−23</sup>) × 2<sup>127</sup> ≈ 3,402823466×10<sup>38</sup>. Todos los números enteros con seis o menos [[Cifras significativas|dígitos decimales significativos]] se pueden convertir a un valor de coma flotante IEEE 754 sin pérdida de precisión, algunos números enteros hasta nueve dígitos decimales significativos pueden convertirse a un valor de coma flotante IEEE 754 sin pérdida de precisión, pero no es posible con los de más de nueve dígitos decimales significativos. Como ejemplo, el número entero de 32 bits {{Formatnum|2147483647}} se convierte en {{Formatnum|2147483650}} aplicando la norma IEEE 754.

El formato de precisión simple se conoce como '''REAL''' en [[Fortran]],<ref>{{Cita web|url=http://scc.ustc.edu.cn/zlsc/sugon/intel/compiler_f/main_for/lref_for/source_files/rfreals.htm|título=REAL Statement|fechaacceso={{fecha|4|3|2017}}|autor=|enlaceautor=|fecha=|idioma=en|sitioweb=scc.ustc.edu.cn|editorial=University of Science and Technology of China|fechaarchivo=24 de febrero de 2021|urlarchivo=https://web.archive.org/web/20210224045812/http://scc.ustc.edu.cn/zlsc/sugon/intel/compiler_f/main_for/lref_for/source_files/rfreals.htm|deadurl=yes}}</ref> '''float''' en [[C (lenguaje de programación)|C]], [[C++]], [[C Sharp|C#]], [[Java (lenguaje de programación)|Java]],<ref>{{Cita web|url=http://java.sun.com/docs/books/tutorial/java/nutsandbolts/datatypes.html|título=Primitive Data Types (The Java™ Tutorials)|fechaacceso={{fecha|4|3|2017}}|autor=|enlaceautor=|fecha=|idioma=en-US|sitioweb=java.sun.com|editorial=Oracle Inc.}}</ref> '''Float''' en [[Haskell]],<ref>{{Cita web|url=https://www.haskell.org/onlinereport/haskell2010/haskellch6.html#x13-1350006.4|título=6 Predefined Types and Classes|fechaacceso={{fecha|4|3|2017}}|autor=|enlaceautor=|fecha=|idioma=en|sitioweb=www.haskell.org|editorial=}}</ref> y, como '''Single''' en Delphi (Pascal), Visual Basic y [[MATLAB]]. Sin embargo, '''float''' en Python, Rubí, PHP, y OCaml y '''single''' en las versiones de [[GNU Octave|Octave]] anteriores a la 3.2 se refieren a números de doble precisión. En la mayoría de las implementaciones de [[PostScript]], la única precisión real es simple.

== Descripción del formato ==
El estándar IEEE 754 especifica que un formato binary32 consta de:<ref>{{Cita web|url=https://www.csee.umbc.edu/~tsimo1/CMSC455/IEEE-754-2008.pdf|título=IEEE Standard for Floating-Point Arithmetic|fechaacceso={{fecha|4|3|2017}}|autor=|enlaceautor=|fecha=|idioma=en|sitioweb=|editorial=IEEE|urlarchivo=https://web.archive.org/web/20161106103513/http://www.csee.umbc.edu/~tsimo1/CMSC455/IEEE-754-2008.pdf|fechaarchivo=6 de noviembre de 2016}}</ref>

* Bits de signo (S): 1 bit.
* Exponente desplazado (E): 8 bits.
* [[Significando]] o Mantisa (T): 24 bits (23 almacenados explícitamente).

Este formato proporciona una precisión de 6 a 9 dígitos decimales significativos. Si una cadena decimal de hasta 6 dígitos decimales significativos se convierte en formato IEEE 754 de precisión simple y luego se convierte de nuevo al mismo número de dígitos decimales significativos, la cadena final debe coincidir con el original y si un número de precisión simple IEEE 754 se convierte en una cadena decimal con al menos 9 dígitos decimales significativos y luego se convierte de nuevo a un número de precisión simple, entonces el número final debe coincidir con el original.<ref name="whyieee">{{cita web|url=http://www.cs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF|título=Lecture Notes on the Status of IEEE Standard 754 for Binary Floating-Point Arithmetic|fechaacceso={{fecha|4|3|2017}}|autor=William Kahan|enlaceautor=|fecha=1 de octubre de 1987|idioma=en|sitioweb=|editorial=}}</ref>

El bit de signo (S) determina el signo del número, que también es el signo de la mantisa o significando. El exponente (E) es, tanto un número entero de 8 bits con signo en el rango de -126 a 127 (expresado en la forma de [[complemento a 2]]) como un entero sin signo (e) de 8 bits comprendido de 0 a 255 que es la forma sesgada aceptada en la definición del formato binary32 de IEEE 754. Si se utiliza el formato de número entero sin signo, el valor del exponente utilizado en la aritmética es el exponente desplazado por un sesgo (E). Para el caso del formato binary32, un valor de exponente desplazado de 127 representa el cero real (es decir, para que 2<sup>e-127</sup> sea uno, "e" debe valer 127). El exponente desplazado (E=e-127) abarca desde −126 hasta +127 ya que los valores de −127 (todos ceros) y 128 (todos unos) son reservados para números especiales.

La mantisa real del formato incluye 23 bits de la fracción a la derecha de la coma binaria y un bit de encabezado implícito (a la izquierda de la coma binaria) con valor de "1" a menos que el exponente se almacene con sus bits en cero. Por lo tanto sólo 23 bits de la mantisa aparecen en el formato de la memoria, pero la precisión total es de 24 bits (equivalente a log<sub>10</sub> (2<sup>24</sup>) dígitos ≈ 7225 decimales). Los bits se establecen como sigue, para este ejemplo concreto:

[[Image:Float example.svg]]

El valor real asumido por un determinado dato en formato binary32 con un exponente sesgado (el número entero sin signo de 8 bits) y una fracción de 23 bits esː

<math>v = (-1)^{b_{31}}\times (1,b_{22}b_{21}...b_{0})_2 \times 2^{e-127}= (-1)^{b_{31}}\times \left(1 + \sum_{i=0}^{22} b_{22-i} 2^{-i} \right)\times 2^{(e-127)}</math>

donde: 
* <math>b_{0}, b_{1}, \ldots, b_{22}</math> (bits de la mantisa o significando)
* <math>b_{31} = 0</math>
* <math>1,b_{22}b_{21}...b_{0} =1 + \sum_{i=1}^{23} b_{23-i} 2^{-i} = 1 + 2^{-2} = 1,25</math>
* <math>2^{(e-127)} = 2^{124-127} = 2^{-3}</math>

por lo tanto:

* <math>v = 1.25 \times 2^{-3} = 0,15625</math>

=== Codificación del exponente ===
El exponente en los números binarios de precisión simple en coma flotante se codifica mediante una representación desplazada en binario, siendo +127 el desplazamiento cero; también conocido como sesgo de exponente en la norma IEEE 754. Los valores del exponente son establecidos asíː

* E<sub>min</sub> = -126
* E<sub>max</sub> = 127
* Sesgo del Exponente = 127
Por lo tanto, con el fin de obtener el verdadero exponente como se define por la representación binaria desplazada, se tiene que restar el desplazamiento de 127 del exponente almacenado lo que equivale a escribirlo en complemento a dos.

Los valores de exponentes expresados en el rango de números en el sistema hexadecimal entre 00<sub>16</sub> y FF<sub>16</sub> se interpretan de forma especial como se indica en la siguiente tablaː

{|class="wikitable" style="text-align:center"
! Exponente !! Significando cero !! Significando no-cero !! Ecuación
|-
| 00<sub>16</sub> || [[cero]], [[cero negativo|−0]] || [[Número subnormal|números denormalizados]] || <math>(-1)^{b_{31}}\times (0,b_{22}b_{21}...b_{0})_2 \times 2^{e-126}</math>
|-
| 01<sub>16</sub> a FE<sub>16</sub> || colspan="2" | valor normalizado || <math>(-1)^{b_{31}}\times (1,b_{22}b_{21}...b_{0})_2 \times 2^{e-127}</math>
|-
|FF<sub>16</sub>
|±[[infinito]]
|[[NaN]] ([[NaN#NaN simple|silencioso]] y [[NaN#NaN se.C3.B1alizados|señalizado]])
|Sin ecuación
|}

El valor mínimo positivo normalizado es de 2 <sup>−126</sup> ≈ 1.18 × 10 <sup>−38</sup> y el valor mínimo positivo denormalizado es 2 <sup>−149</sup> ≈ 1,4 × 10 <sup>−45</sup>.

=== Ejemplos de conversión de números decimales a formato binary32 ===
En general, se acude a la norma IEEE 754 en sí para la conversión estricta (incluyendo el comportamiento de redondeo) de un número real en su equivalente en formato binary32. Para convertir un número real decimal en uno de formato binary32 se debe seguir el siguiente procedimientoː<ref>{{Cita web|url=http://www6.uniovi.es/~antonio/uned/ieee754/ejemplos.html|título=Tutorías UNED - IEEE 754 - Ejemplos|fechaacceso={{fecha|4|3|2017}}|autor=Antonio Bello|enlaceautor=|fecha=|idioma=|sitioweb=|editorial=Universidad de Oviedo|ubicación=Oviedo, España}}</ref>

# Si el número a analizar (N) es positivo, asignar a S=0 y, en caso contrario, S=1. 
# Igualar N a 2<sup>x</sup>.
# Despejar la variable "x", aplicando logaritmos decimales o naturales a ambos lados de la ecuación.
# Tomar como valor aproximado al entero inmediatamente inferior y llamarlo "e".
# Tomar nuevamente el número decimal N e igualarlo a m*2<sup>e</sup>.
# Despejar "m" y quitarle la parte entera que siempre es "1". Este es el bit a la izquierda de la coma binaria que nunca se incluye en el número en como flotante. 
# Tomar la fracción del resultado y convertirla en binario. A este valor llamarlo "T"
# Sumar a "e" el valor de 127 y convertir el resultado a binario llamándolo "E"
# Juntar los resultados de S, E y T que forman parte del número en formato binary32.
La ventaja de este procedimiento es que, en el paso 5, se obtiene de inmediato la mantisa, la cual se convertirá a binario, sin necesidad de convertir la parte entera, la cual siempre será "1". A continuación, se presentan ejemplos de conversión a formato binary32 de números reales decimales mayores que 1 tanto enteros, como con parte fraccionaria y un número pequeño mayor que cero y menor que 1. Con números negativos, la única diferencia en el proceso es la de hacer el bit de signo igual a "1".

==== Número real entero ====
Consideremos el número real entero 63. Aplicando el proceso descrito anteriormente, se obtiene:

<math>63=2^x \Rightarrow x= \frac {\ln 63}{\ln 2} \approx 5,97</math>

Por tanto, el valor "e" será el entero inmediatamente inferior, el cual es 5. Nuevamente usamos 63 aplicando el paso 5 del procedimiento:

<math>63=m \times 2^5 \Rightarrow m= \frac {63}{ 2^5} = 1,96875</math>

Ya que el exponente "e" es 5, se le suma el sesgo de 127 unidades, lo cual da 132<sub>10</sub> equivalente a 10000100<sub>2</sub>. La mantisa real consta de los 5 dígitos a la derecha de la coma (0,96875) la cual se convierte a binario hasta completar los 23 bits del campo T (11111000000000000000000<sub>2</sub>). Uniendo los resultados, se consigue esta expresión:

<math>0-10000100-11111000000000000000000\equiv 427\text{C}0000_{16}</math>

La expresión hexadecimal, como es habitual, se obtiene a agrupando todos los bits en 8 conjuntos de 4 y convirtiendo cada uno en el carácter respectivo. En el caso de un número real con parte fraccionaria, se procede de igual manera, con la diferencia de que el valor decimal de la mantisa será convertido a binario de manera aproximada.

==== Número real grande en notación científica ====
Para números reales muy grandes en notación científica como 7,3491 x 10<sup>22</sup>, es aplicable el procedimiento descritoːjj

<math>7,3491 \times 10^{22}=2^x \Rightarrow x=\frac{\ln 7,3491 \times 10^{22}} {\ln 2} \approx 75,95</math>

Redondeando al entero inferior más próximo, se obtiene e = 75. Ahora se calcula la mantisa:

<math>7,3491 \times 10^{22} = M \times 2^{75} \Rightarrow M = 1,945290573_{10}  </math>

La parte fraccionaria es por tanto 0,945290573 equivalente a 0,11110001111111101001000<sub>2</sub>. Al exponente decimal 75 se le suman 127 unidades para obtener 202=11001010<sub>2</sub>. Uniendo las cadenas numéricas, se logra la siguiente expresión en formato binary32ː

<math>0-11001010-11110001111111101001000_{2}=6578\text{FF}48_{16}  </math>

==== Número pequeño en notación científica ====
Consideremos el número decimal 1023 x 10<sup>−21</sup>. Nuevamente, aplicamos el procedimiento ya conocido. Igualando este número a 2<sup>x</sup>:

<math>1,023 \times 10^{-21}=2^x \Rightarrow x=\frac{\ln 1,023 \times 10^{-21}} {\ln 2} \approx -69,72</math>

El entero próximo inferior de "x" es e=-70. Nuevamente usamos el número a analizar y lo igualamos a m*2<sup>e</sup>:

<math>1,023 \times 10^{-21}=m \times 2^{-70} \Rightarrow m=\frac{1,023 \times 10^{-21}} {2^{-70}} \approx 1,207745228</math>

La parte fraccionaria de m (0,207745228) y se convierte a binario (0,00110101001011101100101<sub>2</sub>) y al exponente e=-70 se le suma 127 y se le convierte a binario obteniéndose 00111001<sub>2</sub>. Uniendo estas cadenas numéricas, se consigue la expresión en binary32:

<math>0-00111001-00110101001011101100101_{2}=\text{1C9A9765}_{16}  </math>

Si el valor para "m" se hubiera redondeado a 1,2077 por ejemplo, habrían existido errores que son inherentes al formato binary32 ya que se pierde precisión aunque se usen menos bits para expresar cantidades decimales.

=== Ejemplos en precisión simple ===
Los ejemplos que siguen son expresiones en hexadecimal y binario de valores en coma flotante que incluyen el signo, el exponente desplazado y la mantisa o significando.
 <math>\begin{array}{lllr}
  \text{3F800000}_{16}  & = & 0-01111111-00000000000000000000000_{2} &=& 1\\
  \text{C0000000}_{16}  & = & 1-10000000-00000000000000000000000_{2} &=& -2
  \end{array}</math>

Los siguientes valores son el máximo y el menor valor finito expresable en formato de coma flotante
 <math>\begin{array}{llll}
  \text{7F7FFFFF}_{16}  & = & 0-11111110-11111111111111111111111_{2} &=& (1-2^{-24}) \times 2^{128} \approx 3,402823466 \times 10^{38}\\
  \text{00800000}_{16}  & = & 0-00000001-00000000000000000000000_{2} &=& 2^{-126} \approx 1,175494351 \times 10^{-38}
  \end{array}</math>

Las siguientes expresiones prueban la existencia de dos tipos de ceros en el formato binary32:
 <math>\begin{array}{lllr}
  \text{00000000}_{16} & = & 0-00000000-00000000000000000000000_{2} & = & +0\\
  \text{80000000}_{16} & = & 1-00000000-00000000000000000000000_{2} & = & -0
  \end{array}</math>

Estas expresiones representan los valores infinitos:
 <math>\begin{array}{lllr}
  \text{7F800000}_{16} &=& 0-11111111-00000000000000000000000_{2} &=& +\infty\\
  \text{FF800000}_{16} &=& 1-11111111-00000000000000000000000_{2} &=& -\infty
  \end{array}</math>

=== Conversión de binary32 a decimal ===
Para este ejemplo de conversión, se comienza con el número hexadecimal 41C80000, el cual es convertido a binario:
: <math>\text{41C80000}_{16} = 0100 \;0001\; 1100\; 1000\; 0000\; 0000\; 0000\; 0000_{2}</math>
La cadena binaria debe ser dividida en tres partes: bit de signo (1 bit), exponente (8bits) y significando (23 bits).
* Bit de signo= 0
* Exponente: 1000 0011<sub>2</sub> = 131
* Significando: 100 1000 0000 0000 0000 0000<sub>2</sub> = 480000<sub>16</sub>
Luego, se añade el bit implícito al significando:
* Significando: '''1'''100 1000 0000 0000 0000 0000<sub>2</sub>
y se decodifica el valor del exponente restándole 127: 131 − 127 = 4

Cada uno de los 24 bits del significando (incluyendo el bit implícito), se multiplica por la potencia de 2 correspondiente:
 <math>\begin{array}{ll}
  \text{bit I} &\times& 2^{0}\\ 
  \text{bit 22} &\times& 2^{-1}\\ 
  \text{bit 21} &\times& 2^{-2}\\ 
  \text{bit 20} &\times& 2^{-3}\\
  \text{bit 19} &\times& 2^{-4}\\
  \text{bit 18} &\times& 2^{-5}\\
  \vdots \\
  \text{bit 0} &\times& 2^{-23}
  \end{array}</math>
En este ejemplo la mantisa o significando tiene tres bits en "1 lógico": bit I (bit implícito, que siempre es "1"), bit 22 y bit 19. Sumando las tres contribuciones de estos bits :
* Significando decodificado: 1 + 0,5 + 0,0625 = 1,5625.
Este significando debe ser multiplicado por la potencia 4 de la base 2 para obtener el resultado final:
: <math>1,5625 \times 2^{4} = 25</math>

=== Límites de precisión sobre números enteros ===
La siguiente tabla indica como son representados los números dentro de los rangos indicados.
{| class="wikitable"
!Rangos de enteros
!Representación de la mantisa
|-
|<math>[-16777216,16777216]</math>
|Exacta
|-
|<math>[-33554432,-16777217]</math>o <math>[16777217,33554432]</math>
|Redondeo a un múltiplo de 2
|-
|<math>[-2^{26},-2^{25}-1]</math> o <math>[2^{25}+1, \ 2^{26}]</math>
|Redondeo a un múltiplo de 4
|-
|<math>[-2^{127},-2^{126}-1]</math> o <math>[2^{126}+1,\ 2^{127}]</math>
|Redondeo a un múltiplo de <math>2^{103}</math>
|-
|<math>[-2^{128}+2^{104},\ -2^{127}-1]</math> o <math>[2^{127}+1,\ 2^{128}-2^{104}]</math>
|Redondeo a un múltiplo de <math>2^{127-23}</math>
|-
|<math>(-\infty,\  -2^{128}]</math> o <math>[2^{128}, \ +\infty)</math>
|Redondeo a Infinito (<math>\pm \ \infty</math>)
|}

=== Optimizaciones ===
El diseño del formato de coma flotante permite varias optimizaciones, resultantes de la fácil generación de una aproximación de un [[logaritmo binario]] desde una vista entera del patrón de bits sin procesar. La aritmética de números enteros y el desplazamiento de bits pueden producir una aproximación a la [[Cálculo de la raíz cuadrada|raíz cuadrada recíproca]] ([[Algoritmo de la raíz cuadrada inversa rápida|raíz cuadrada inversa rápida]]), comúnmente requerida en gráficos computarizados.

== Véase también ==
* [[Estabilidad numérica]]
* [[IEEE coma flotante|IEEE Coma Flotante]]
* [[Tipo de dato elemental]]

== Referencias ==
{{listaref}}

== Enlaces externos ==
* [http://www.zator.com/Cpp/E2_2_4a1.htm Convertidor de formato IEEE 754]
* [https://evanw.github.io/float-toy/ Live floating-point bit pattern editor]
* [http://www.binaryconvert.com/convert_float.html Online converter for IEEE 754 numbers with single precision]
* [http://www.mathworks.com/matlabcentral/fileexchange/23173 C source code to convert between IEEE double, single, and half precision]

{{Control de autoridades}}
[[Categoría:Aritmética computacional]]