I don’t know if this is an obvious bug, but while running a Python script for varying the parameters of a simulation, I realized the results with delta = 0.29 and delta = 0.58 were missing. On investigation, I noticed that the following Python code:

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

(...)

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

generated identical files for delta = 0.28 and 0.29, same with .57 and .58, the reason being that python returns float(29)/100 as 0.28999999999999998. But that isn’t a systematic error, not in the sense it happens to every integer. So I created the following Python script:

``````import sys

n = int(sys.argv)

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

And I can’t see any pattern in the numbers for which this rounding error happens. Why does this happen with those particular numbers?

Any number that can’t be built from exact powers of two can’t be represented exactly as a floating point number; it needs to be approximated. Sometimes the closest approximation will be less than the actual number.

Its very well known due to the nature of floating point numbers.

If you want to do decimal arithmetic not floating point arithmatic there are libraries to do this.

E.g.,

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

In general decimal is probably going overboard and still will have rounding errors in rare cases when the number does not have a finite decimal representation (for example any fraction where the denominator is not 1 or divisible by 2 or 5 – the factors of the decimal base (10)). For example:

``````>>> 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
``````

So its best to always just round before casting floating points to ints, unless you want a floor function.

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

Another alternative is to use the Fraction class from the fractions library which doesn’t approximate. (It justs keeps adding/subtracting and multiplying the integer numerators and denominators as necessary).