comportamiento de punto flotante extraño en un programa Java

Question

En mi programa que tiene una matriz con 25 valores dobles 0,04 Cuando trato de resumir estos valores en un bucle consigo siguientes resultados:

0.0 + 0.04 = 0.04 
0.04 + 0.04 = 0.08 
0.08 + 0.04 = 0.12 
0.12 + 0.04 = 0.16 
0.16 + 0.04 = 0.2 
0.2 + 0.04 = 0.24000000000000002 
0.24000000000000002 + 0.04 = 0.28 
0.28 + 0.04 = 0.32 
0.32 + 0.04 = 0.36 
0.36 + 0.04 = 0.39999999999999997 
0.39999999999999997 + 0.04 = 0.43999999999999995 
0.43999999999999995 + 0.04 = 0.4799999999999999 
0.4799999999999999 + 0.04 = 0.5199999999999999 
0.5199999999999999 + 0.04 = 0.5599999999999999 
0.5599999999999999 + 0.04 = 0.6 
0.6 + 0.04 = 0.64 
0.64 + 0.04 = 0.68 
0.68 + 0.04 = 0.7200000000000001 
0.7200000000000001 + 0.04 = 0.7600000000000001 
0.7600000000000001 + 0.04 = 0.8000000000000002 
0.8000000000000002 + 0.04 = 0.8400000000000002 
0.8400000000000002 + 0.04 = 0.8800000000000002 
0.8800000000000002 + 0.04 = 0.9200000000000003 
0.9200000000000003 + 0.04 = 0.9600000000000003 

¿Por qué en la tierra ¿podría pasar eso?

Answer 1

El almacenamiento más común para los valores de punto flotante en lenguajes de programación - IEEE singles and doubles - no tiene representaciones exactas para la mayoría de las fracciones decimales.

La razón es que se almacenan los valores en formato de punto flotante binario, en lugar del formato de coma flotante decimal. Los únicos valores fraccionarios que pueden representarse exactamente son aquellos que son sumas de potencias negativas de dos. Números como:

• 0,5 (2^-1)
• 0,125 (2^-3)
• 0,625 (2^-1 + 2^-3)

Etc.

lo que está viendo es el hecho de que las representaciones de números como 0,96 no son exactamente representable, porque no se pueden expresar como una suma de potencias negativas de dos. Por lo tanto, cuando se imprimen con total precisión como una fracción decimal, no coincidirán con el valor original.

Answer 2

Véase también "What Every Computer Scientist Should Know About Floating Point"

Answer 3

Otras respuestas mencionan por qué, pero no la forma de evitarlo.

hay varias soluciones:

• Escala: si todos los números son múltiplos de 0,01 (por ejemplo), se multiplica todo por 100 y el uso de aritmética de enteros (que es exacta).
• tipo numérico: si su lenguaje tiene un tipo numérico (como un tipo numeric en SQL), que se puede utilizar.
• racionales de precisión arbitraria: use una biblioteca bignum como GMP, que permite representar estos números como el cociente de dos números enteros.
• decimal de coma flotante: si tiene un punto decimal como el que flota en IEEE-754r, que se puede utilizar.

Answer 4

Es posible que desee comprobar la clase java BigDecimal como una alternativa a los flotadores y los dobles.