floating point - array - ¿Por qué 0.1+0.2== 0.3 en D?

dynamic array mql4

Question

assert(0.1 + 0.2 != 0.3); // shall be true

es mi verificación favorita de que un idioma usa aritmética nativa de coma flotante.

C ++

#include <cstdio>

int main()
{
   printf("%d/n", (0.1 + 0.2 != 0.3));
   return 0;
}

Salida:

1

http://ideone.com/ErBMd

Pitón

print(0.1 + 0.2 != 0.3)

Salida:

True

http://ideone.com/TuKsd

Otros ejemplos

• Java: http://ideone.com/EPO6X
• C #: http://ideone.com/s14tV

¿Por qué esto no es cierto para D? Como entiende, D usa números de coma flotante nativos. ¿Es esto un error? ¿Usan alguna representación numérica específica? ¿Algo más? Bastante confuso

re

import std.stdio;

void main()
{
   writeln(0.1 + 0.2 != 0.3);
}

Salida:

false

http://ideone.com/mX6zF

ACTUALIZAR

Gracias a LukeH . Este es un efecto de Floating Point Constant Folding descrito there .

Código:

import std.stdio;

void main()
{
   writeln(0.1 + 0.2 != 0.3); // constant folding is done in real precision

   auto a = 0.1;
   auto b = 0.2;
   writeln(a + b != 0.3);     // standard calculation in double precision
}

Salida:

false
true

http://ideone.com/z6ZLk

Answer 1

De acuerdo con mi interpretación de la especificación del lenguaje D , la aritmética de coma flotante en x86 usaría 80 bits de precisión internamente, en lugar de solo 64 bits.

Sin embargo, habría que verificar que eso sea suficiente para explicar el resultado que observas.

Answer 2

Probablemente esté siendo optimizado para (0.3! = 0.3). Lo cual es obviamente falso. Verifique la configuración de optimización, asegúrese de que estén apagados y vuelva a intentarlo.

Answer 3

_{(La respuesta de Flynn es la respuesta correcta. Esta aborda el problema de manera más general).}

Usted parece estar asumiendo, OP, que la imprecisión del punto flotante en su código es determinista y predeciblemente errónea (en cierto modo, su enfoque es el polo opuesto al de las personas que aún no entienden el punto flotante).

Aunque (como lo señala Ben) la imprecisión del punto flotante es determinista, desde el punto de vista de su código, si no está siendo muy deliberado sobre lo que está sucediendo con sus valores en cada paso, este no será el caso. Cualquier cantidad de factores podría llevar a 0.1 + 0.2 == 0.3 tener éxito, la optimización en tiempo de compilación es una, los valores ajustados para esos literales son otros.

Confíe aquí ni en el éxito ni en el fracaso; no confíe en la igualdad de punto flotante de ninguna manera .