Error de redondeo de Python con números flotantes

Question

No sé si esto es un error obvio, pero al ejecutar un script Python para variar los parámetros de una simulación, me di cuenta de que faltaban los resultados con delta = 0.29 y delta = 0.58. En la investigación, me di cuenta de que el siguiente código Python:

for i_delta in range(0, 101, 1): 
    delta = float(i_delta)/100 

    (...) 

filename = 'foo' + str(int(delta * 100)) + '.dat' 

genera archivos idénticos para delta = 0,28 y 0,29, lo mismo con 0,57 y 0,58, siendo la razón que vuelve pitón flotador (29)/100 como ,28999999999999998 . Pero eso no es un error sistemático, no en el sentido en que le sucede a cada entero. Así que creé la siguiente secuencia de comandos de Python:

import sys 

n = int(sys.argv[1]) 

for i in range(0, n + 1): 
    a = int(100 * (float(i)/100)) 
    if i != a: print i, a 

Y no puedo ver ningún patrón en los números para los que ocurre este error de redondeo. ¿Por qué sucede esto con esos números particulares?

Answer 1

Cualquier número que no se pueda generar con las potencias exactas de dos no se puede representar exactamente como un número de coma flotante; necesita ser aproximado. A veces, la aproximación más cercana será menor que el número real.

Lea What Every Computer Scientist Should Know About Floating-Point Arithmetic.

Answer 2

Es muy conocido debido a la naturaleza de floating point numbers.

Si desea hacer aritmética decimal no aritmética de coma flotante hay libraries para hacer esto.

Eg,

>>> from decimal import Decimal 
>>> Decimal(29)/Decimal(100) 
Decimal('0.29') 
>>> Decimal('0.29')*100 
Decimal('29') 
>>> int(Decimal('29')) 
29 

En decimal general es, probablemente, va por la borda y todavía tendrá errores de redondeo en casos raros cuando el número no tiene una representación decimal finito (por ejemplo, cualquier fracción donde el denominador no es 1 o divisible por 2 o 5 - los factores de la base decimal (10)). Por ejemplo:

>>> s = Decimal(7) 
>>> Decimal(1)/s/s/s/s/s/s/s*s*s*s*s*s*s*s 
Decimal('0.9999999999999999999999999996') 
>>> int(Decimal('0.9999999999999999999999999996')) 
0 

así que es mejor siempre a la vuelta antes de emitir puntos flotantes de enteros, a menos que desee una función piso.

>>> int(1.9999) 
1 
>>> int(round(1.999)) 
2 

Otra alternativa es utilizar la clase Fracción de la biblioteca fractions que no aproximada. (Justs sigue agregando/restando y multiplicando los numeradores y denominadores enteros según sea necesario).