Formato de coma flotante de doble precisión - Double-precision floating-point format

El formato de punto flotante de doble precisión (a veces llamado FP64 o float64 ) es un formato de número de computadora , que generalmente ocupa 64 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 .

El punto flotante se utiliza para representar valores fraccionarios, o cuando se necesita un rango más amplio que el que proporciona el punto fijo (del mismo ancho de bits), incluso si se paga precisión. Se puede elegir la precisión doble cuando el rango o la precisión de la precisión simple sean insuficientes.

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

Uno de los primeros lenguajes de programación en proporcionar 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 implementadores del lenguaje de programación. Por ejemplo, el tipo de datos de doble precisión de GW-BASIC era el formato de coma flotante MBF de 64 bits .

Formato de coma flotante binario de doble precisión IEEE 754: binary64

El punto flotante binario de doble precisión es un formato de uso común en las PC, debido a su rango más amplio que el punto flotante de precisión simple, a pesar de su rendimiento y costo de ancho de banda. Se conoce comúnmente simplemente como doble . El estándar IEEE 754 especifica que un binary64 tiene:

Bit de signo : 1 bit
Exponente : 11 bits
Precisión significativa : 53 bits (52 almacenados explícitamente)

El bit de signo determina el signo del número (incluso cuando este número es cero, que está firmado ).

El campo de exponente es un entero sin signo de 11 bits de 0 a 2047, en forma sesgada : un valor de exponente de 1023 representa el cero real. Los exponentes van de −1022 a +1023 porque los exponentes de −1023 (todos 0) y +1024 (todos 1) están reservados para números especiales.

La precisión de significación de 53 bits proporciona una precisión de 15 a 17 dígitos decimales significativos (2 ⁻⁵³ ≈ 1,11 × 10 ⁻¹⁶ ). Si una cadena decimal con un máximo de 15 dígitos significativos se convierte a una representación de doble precisión IEEE 754 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 doble precisión IEEE 754 se convierte en una cadena decimal con al menos 17 dígitos significativos y luego se vuelve a convertir a una representación de doble precisión, el resultado final debe coincidir con el número original.

El formato se escribe con el significado que tiene un bit entero implícito de valor 1 (excepto para datos especiales, consulte la codificación del exponente a continuación). Con los 52 bits del significado de la fracción (F) apareciendo en el formato de memoria, la precisión total es por lo tanto de 53 bits (aproximadamente 16 dígitos decimales, 53 log ₁₀ (2) ≈ 15.955). Los bits se distribuyen de la siguiente manera:

El valor real asumido por un dato de precisión doble de 64 bits dado con un exponente sesgado dado y una fracción de 52 bits es ${\ Displaystyle e}$

{\ displaystyle (-1) ^ {\ text {sign}} (1.b_ {51} b_ {50} ... b_ {0}) _ {2} \ times 2 ^ {e-1023}}

o

{\ displaystyle (-1) ^ {\ text {sign}} \ left (1+ \ sum _ {i = 1} ^ {52} b_ {52-i} 2 ^ {- i} \ right) \ times 2 ^ {e-1023}}

Entre 2 ⁵² = 4,503,599,627,370,496 y 2 ⁵³ = 9,007,199,254,740,992 los números representables son exactamente los enteros. Para el siguiente rango, de 2 ⁵³ a 2 ⁵⁴ , todo se multiplica por 2, por lo que los números representables son los pares, etc. A la inversa, para el rango anterior de 2 ⁵¹ a 2 ⁵² , el espaciado es 0.5, etc.

El espaciado como fracción de los números en el rango de 2 ⁿ a 2 ^{n +1} es 2 ^{n −52} . El error de redondeo relativo máximo cuando se redondea un número al representable más cercano (la máquina épsilon ) es por lo tanto 2 ⁻⁵³ .

El ancho de 11 bits del exponente permite la representación de números entre 10 ⁻³⁰⁸ y 10 ³⁰⁸ , con precisión total de 15-17 dígitos decimales. Al comprometer la precisión, la representación subnormal permite valores aún más pequeños, hasta aproximadamente 5 × 10 ⁻³²⁴ .

Codificación de exponentes

El exponente de coma flotante binario de doble precisión se codifica utilizando una representación binaria de compensación , siendo la compensación de cero 1023; también conocido como sesgo de exponente en el estándar IEEE 754. Ejemplos de tales representaciones serían:

e = = = 1: `00000000001₂001₁₆`	${\ Displaystyle 2 ^ {1-1023} = 2 ^ {- 1022}}$	(exponente más pequeño para números normales )
e = = = 1023: `01111111111₂3ff₁₆`	${\ Displaystyle 2 ^ {1023-1023} = 2 ^ {0}}$	(compensación cero)
e = = = 1029: `10000000101₂405₁₆`	${\ Displaystyle 2 ^ {1029-1023} = 2 ^ {6}}$
e = = = 2046: `11111111110₂7fe₁₆`	${\ Displaystyle 2 ^ {2046-1023} = 2 ^ {1023}}$	(exponente más alto)

Los exponentes y tienen un significado especial: 000₁₆7ff₁₆

00000000000₂= se utiliza para representar un cero con signo (si F = 0) y subnormales (si F ≠ 0); y000₁₆
11111111111₂= se usa para representar ∞ (si F = 0) y NaNs (si F ≠ 0),7ff₁₆

donde F es la parte fraccionaria del significando . Todos los patrones de bits son codificaciones válidas.

Excepto por las excepciones anteriores, todo el número de doble precisión se describe mediante:

{\ displaystyle (-1) ^ {\ text {signo}} \ times 2 ^ {e-1023} \ times 1. {\ text {fracción}}}

En el caso de subnormales ( e = 0), el número de doble precisión se describe mediante:

{\ displaystyle (-1) ^ {\ text {sign}} \ times 2 ^ {1-1023} \ times 0. {\ text {fracción}} = (- 1) ^ {\ text {sign}} \ times 2 ^ {- 1022} \ times 0. {\ Text {fracción}}}

Endianidad

Aunque los omnipresentes procesadores x86 de hoy utilizan almacenamiento little-endian para todos los tipos de datos (enteros, punto flotante), hay una serie de arquitecturas de hardware donde los números de punto flotante se representan en forma de big-endian mientras que los enteros se representan en little- forma endian. Hay procesadores ARM que tienen representación de punto flotante mitad little-endian, mitad big-endian para números de doble precisión: ambas palabras de 32 bits se almacenan en registros de enteros como little-endian, pero el más significativo primero. Debido a que ha habido muchos formatos de punto flotante sin representación estándar de " red " para ellos, el estándar XDR usa big-endian IEEE 754 como su representación. Por lo tanto, puede parecer extraño que el estándar de punto flotante IEEE 754 extendido no especifique endianness. En teoría, esto significa que incluso los datos de punto flotante IEEE estándar escritos por una máquina podrían no ser legibles por otra. Sin embargo, en las computadoras estándar modernas (es decir, que implementan IEEE 754), en la práctica se puede asumir con seguridad que el endianness es el mismo para los números de punto flotante que para los enteros, lo que hace que la conversión sea sencilla independientemente del tipo de datos. ( Sin embargo, los sistemas integrados pequeños que utilizan formatos especiales de punto flotante pueden ser otro asunto).

El punto flotante VAX almacena palabras little-endian de 16 bits en orden big-endian.

Ejemplos de doble precisión

0 01111111111 00000000000000000000000000000000000000000000000000000000 ₂ ≙ 3FF0 0000 0000 0000 ₁₆ ≙ +2 ⁰ × 1 = 1

0 01111111111 0000000000000000000000000000000000000000000000000001 ₂ ≙ 3FF0 0000 0000 0001 ₁₆ ≙ +2 ⁰ × (1 + 2 ⁻⁵² ) ≈ 1.0000000000000002, el número más pequeño> 1

0 01111111111 00000000000000000000000000000000000000000000000000000010 ₂ ≙ 3FF0 0000 0000 0002 ₁₆ ≙ +2 ⁰ × (1 + 2 ⁻⁵¹ ) ≈ 1.0000000000000004

0 10000000000 00000000000000000000000000000000000000000000000000000000 ₂ ≙ 4000 0000 0000 0000 ₁₆ ≙ +2 ¹ × 1 = 2

1 10000000000 0000000000000000000000000000000000000000000000000000 ₂ ≙ C000 0000 0000 0000 ₁₆ ≙ −2 ¹ × 1 = −2

0 10000000000 1000000000000000000000000000000000000000000000000000 ₂ ≙ 4008 0000 0000 0000 ₁₆ ≙ +2 ¹ × 1,1 ₂ = 11 ₂ = 3

0 10000000001 00000000000000000000000000000000000000000000000000000000 ₂ ≙ 4010 0000 0000 0000 ₁₆ ≙ +2 ² × 1 = 100 ₂ = 4

0 10000000001 0100000000000000000000000000000000000000000000000000 ₂ ≙ 4014 0000 0000 0000 ₁₆ ≙ +2 ² × 1.01 ₂ = 101 ₂ = 5

0 10000000001 1000000000000000000000000000000000000000000000000000 ₂ ≙ 4018 0000 0000 0000 ₁₆ ≙ +2 ² × 1,1 ₂ = 110 ₂ = 6

0 10000000011 01110000000000000000000000000000000000000000000000000000 ₂ ≙ 4037 0000 0000 0000 ₁₆ ≙ +2 ⁴ × 1.0111 ₂ = 10111 ₂ = 23

0 01111111000 1000000000000000000000000000000000000000000000000000 ₂ ≙ 3F88 0000 0000 0000 ₁₆ ≙ +2 ⁻⁷ × 1,1 ₂ = 0,00000011 ₂ = 0,01171875 (3/256)

0 00000000000 0000000000000000000000000000000000000000000000000001 ₂ ≙ 0000 0000 0000 0001 ₁₆ ≙ +2 ⁻¹⁰²² × 2 ⁻⁵² = 2 ⁻¹⁰⁷⁴ ≈ 4.9406564584124654 × 10 ⁻³²⁴ (Mínimo doble positivo subnormal)

0 00000000000 1111111111111111111111111111111111111111111111111111 ₂ ≙ 000F FFFF FFFF FFFF ₁₆ ≙ +2 ⁻¹⁰²² × ( ^1-2⁻⁵² ) ≈ 2.2250738585072009 × 10 ⁻³⁰⁸ (Max. Doble subnormal)

0 00000000001 00000000000000000000000000000000000000000000000000000000 ₂ ≙ 0010 0000 0000 0000 ₁₆ ≙ +2 ⁻¹⁰²² × 1 ≈ 2.2250738585072014 × 10 ⁻³⁰⁸ (Mín. Normal positivo doble)

0 11111111110 1111111111111111111111111111111111111111111111111111 ₂ ≙ 7FEF FFFF FFFF FFFF ₁₆ ≙ +2 ¹⁰²³ × (1 + ( 1-2 ⁻⁵² )) ≈ 1.7976931348623157 × 10 ³⁰⁸ (Max. Doble)

0 00000000000 0000000000000000000000000000000000000000000000000000 ₂ ≙ 0000 0000 0000 0000 ₁₆ ≙ +0

1 00000000000 0000000000000000000000000000000000000000000000000000 ₂ ≙ 8000 0000 0000 0000 ₁₆ ≙ −0

0 11111111111 00000000000000000000000000000000000000000000000000000000 ₂ ≙ 7FF0 0000 0000 0000 ₁₆ ≙ + ∞ (infinito positivo)

1 11111111111 00000000000000000000000000000000000000000000000000000000 ₂ ≙ FFF0 0000 0000 0000 ₁₆ ≙ −∞ (infinito negativo)

0 11111111111 0000000000000000000000000000000000000000000000000001 ₂ ≙ 7FF0 0000 0000 0001 ₁₆ ≙ NaN (sNaN en la mayoría de los procesadores, como x86 y ARM)

0 11111111111 1000000000000000000000000000000000000000000000000001 ₂ ≙ 7FF8 0000 0000 0001 ₁₆ ≙ NaN (qNaN en la mayoría de los procesadores, como x86 y ARM)

0 11111111111 11111111111111111111111111111111111111111111111111 ₂ ≙ 7FFF FFFF FFFF FFFF ₁₆ ≙ NaN (una codificación alternativa de NaN)

0 01111111101 0101010101010101010101010101010101010101010101010101 ₂ = 3FD5 5555 5555 5555 ₁₆ ≙ 2 ^-2 × (1 + 2 ^-2 + 2 ^-4 + ... + 2 ^-52 ) ≈ ¹ / ₃

0 10000000000 1001001000011111101101010100010001000010110100011000 ₂ = 4009 21FB 5444 2D18 ₁₆ ≈ pi

Las codificaciones de qNaN y sNaN no se especifican completamente en IEEE 754 y dependen del procesador. La mayoría de los procesadores, como los procesadores de la familia x86 y la familia ARM , utilizan el bit más significativo del campo significativo para indicar un NaN silencioso; esto es lo que recomienda IEEE 754. Los procesadores PA-RISC usan el bit para indicar una señalización NaN.

Por defecto, ¹ / ₃ rondas abajo, en lugar de arriba como de precisión simple , debido al número impar de bits en la mantisa.

Con más detalle:

Given the hexadecimal representation 3FD5 5555 5555 5555₁₆,
  Sign = 0
  Exponent = 3FD₁₆ = 1021
  Exponent Bias = 1023 (constant value; see above)
  Fraction = 5 5555 5555 5555₁₆
  Value = 2^{(Exponent − Exponent Bias)} × 1.Fraction – Note that Fraction must not be converted to decimal here
        = 2⁻² × (15 5555 5555 5555₁₆ × 2⁻⁵²)
        = 2⁻⁵⁴ × 15 5555 5555 5555₁₆
        = 0.333333333333333314829616256247390992939472198486328125
        ≈ 1/3

Velocidad de ejecución con aritmética de doble precisión

El uso de variables de punto flotante de doble precisión y funciones matemáticas (por ejemplo, sin, cos, atan2, log, exp y sqrt) es más lento que trabajar con sus contrapartes de precisión simple. Un área de la informática donde este es un problema particular es el código paralelo que se ejecuta en GPU. Por ejemplo, cuando se usa la plataforma CUDA de NVIDIA , los cálculos con doble precisión toman, según el hardware, aproximadamente de 2 a 32 veces más tiempo en completarse en comparación con los que se realizan con precisión simple .

Limitaciones de precisión en valores enteros

Los números enteros de −2 ⁵³ a 2 ⁵³ (−9,007,199,254,740,992 a 9,007,199,254,740,992) se pueden representar exactamente
Enteros entre 2 ⁵³ y 2 ⁵⁴ = 18,014,398,509,481,984 redondeados a un múltiplo de 2 (número par)
Enteros entre 2 ⁵⁴ y 2 ⁵⁵ = 36,028,797,018,963,968 redondeados a un múltiplo de 4

Implementaciones

Los dobles se implementan en muchos lenguajes de programación de diferentes formas, como las siguientes. En procesadores con solo precisión dinámica, como x86 sin SSE2 (o cuando no se usa SSE2, por motivos de compatibilidad) y con precisión extendida que se usa de forma predeterminada, el software puede tener dificultades para cumplir con algunos requisitos.

C y C ++

C y C ++ ofrecen una amplia variedad de tipos aritméticos . Los estándares no requieren doble precisión (excepto por el anexo opcional F de C99 , que cubre la aritmética IEEE 754), pero en la mayoría de los sistemas, el doubletipo corresponde a doble precisión. Sin embargo, en x86 de 32 bits con precisión extendida de forma predeterminada, algunos compiladores pueden no cumplir con el estándar C o la aritmética puede sufrir un doble redondeo .

Fortran

Fortran proporciona varios tipos enteros y reales, y el tipo de 64 bits real64, accesible a través del módulo intrínseco de Fortran iso_fortran_env, corresponde a doble precisión.

Lisp común

Common Lisp proporciona los tipos SHORT-FLOAT, SINGLE-FLOAT, DOUBLE-FLOAT y LONG-FLOAT. La mayoría de las implementaciones proporcionan SINGLE-FLOATs y DOUBLE-FLOATs con los otros tipos de sinónimos apropiados. Common Lisp proporciona excepciones para detectar subdesbordamientos y desbordamientos de punto flotante, y la excepción de punto flotante inexacto, según IEEE 754. No se describen infinitos ni NaN en el estándar ANSI, sin embargo, varias implementaciones los proporcionan como extensiones.

Java

En Java antes de la versión 1.2, todas las implementaciones tenían que ser compatibles con IEEE 754. La versión 1.2 permitió que las implementaciones brindaran precisión adicional en los cálculos intermedios para plataformas como x87 . Por lo tanto, se introdujo un modificador rigidfp para hacer cumplir los cálculos estrictos de IEEE 754. El punto flotante estricto se ha restaurado en Java 17.

JavaScript

Según lo especificado por el estándar ECMAScript , toda la aritmética en JavaScript se realizará utilizando aritmética de punto flotante de doble precisión.

Ver también

IEEE 754 , estándar IEEE para aritmética de punto flotante

Languages

In other projects