71 votos

¿Por qué 0.1 + 0,2 == 0,3 en D?

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

mi favorito es el de comprobar que un idioma se utiliza nativo de aritmética de punto flotante.

C++

#include <cstdio>

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

Salida:

1

http://ideone.com/ErBMd

Python

print(0.1 + 0.2 != 0.3)

Salida:

True

http://ideone.com/TuKsd

Otros ejemplos

¿Por qué esto no es cierto para los D? Como entender D utiliza nativo de números de punto flotante. Es esto un error? ¿Usan algún número específico de representación? Algo más? Bastante confuso.

D

import std.stdio;

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

Salida:

false

http://ideone.com/mX6zF

ACTUALIZACIÓN

Gracias a LukeH. Este es un efecto de Punto Flotante de doblado de Constantes descritas allí.

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

53voto

(Flynn la respuesta es la respuesta correcta. Este aborda el problema de manera más general.)


Usted parece estar suponiendo, OP, que la de punto flotante de inexactitud en el código es determinista y predecible mal (en una forma, su enfoque es el polo opuesto de la de la gente que no entiende de punto flotante).

Aunque (como señala Ben) de punto flotante inexactitud es determinista, desde el punto de vista de su código, si no están siendo muy deliberado acerca de lo que está sucediendo a sus valores en cada paso, este no será el caso. Cualquier número de factores que podrían provocar 0.1 + 0.2 == 0.3 de éxito, en tiempo de compilación optimización de ser uno, se ajustan los valores de los literales de ser otro.

Confían ni en el éxito ni en el fracaso; no dependen de punto flotante de igualdad , de cualquier manera.

47voto

Flynn1179 Puntos 6900

Probablemente está siendo optimizado para (0.3! = 0,3). Lo cual es obviamente falsa. Compruebe los ajustes de optimización, asegúrese de que están apagados y vuelva a intentarlo.

5voto

Jean Hominal Puntos 7001

Según mi interpretación de la Especificación del lenguaje D, punto flotante aritmética x 86 usaría 80 bits de precisión internamente, en lugar de sólo 64 bits.

Uno tendría que ver sin embargo que eso es suficiente para explicar el resultado que observe.

Iteramos.com

Iteramos es una comunidad de desarrolladores que busca expandir el conocimiento de la programación mas allá del inglés.
Tenemos una gran cantidad de contenido, y también puedes hacer tus propias preguntas o resolver las de los demás.

Powered by:

X