Dealing with floating points: With numpy python in particular

Question

I wanted values like - 1,1.02,1.04,1.06,1.08 etc... So used numpy in python:

y = [x for x in numpy.arange(1,2,0.02)]

I got the values-

1.0,
1.02,
1.04,
1.0600000000000001,
1.0800000000000001,

I have three questions here:

How do I get exactly values 1,1.02,1.04,1.06,1.08 etc....
Why correct values for 1.02, and 1.04, and not for 1.0600000000000001,
How reliable our programs can be when we can't trust such basic operations in programs that can run into thousands of lines of code, and we do so many calculations in that? How do we cope with such scenario?

There are very similar questions that address problems with floating points in general and numpy library in particular -

Is floating point math broken?

Why Are Floating Point Numbers Inaccurate?

While they address why such a thing happens, here I'm concerned more about how do I deal with such scenario in everyday programming, particularly in numpy python? Hence I've these questions.

Thanks! but what about question 2? How do I get values -- 1.02,1.04,1.06.... if that's exactly what I need? — tired and bored dev, Apr 03 '16 at 00:28
What do you mean by "everyday programming"? Are you running extensive math-intensive calculations in your scripts for an engineering company? Because if you are then you have to take into account the error associated with using a computer to do that i.e. the error of Taylor Polynomials to approximate integrals. — MANA624, Apr 03 '16 at 00:40
Related: [How to set numpy floating point accuracy](http://stackoverflow.com/questions/25181642/how-set-numpy-floating-point-accuracy) — LinkBerest, Apr 03 '16 at 00:43
Yes. I'm working/writing with machine learning algorithms, right now. But as I plan to use it for other engineering problems (mechanical/other), so I'm concerned about such behavior. ... — tired and bored dev, Apr 03 '16 at 00:44
@user1478061 it's an unavoidable part of numerical problems. The solution is not avoiding it, but treating it properly. For instance, you shouldn't check if `x==0.2`, but rather if `abs(x-0.2) — Andras Deak -- Слава Україні, Apr 03 '16 at 00:45
Thank you. Do you have any clues to generate a number series I mentioned there? — tired and bored dev, Apr 03 '16 at 00:50
You did generate the series properly. There are two options: `numpy.arange(1,2,0.02)` or `numpy.linspace(1,2,num=50)`. — roadrunner66, Apr 03 '16 at 02:05
You can use [decimals](https://docs.python.org/2/library/decimal.html). — Jan Christoph Terasa, Apr 03 '16 at 07:34

B. M. · Accepted Answer · 2016-04-03T08:51:05.417

First pitfall : do not confuse accuracy and printing policies.

In your example :

In [6]: [x.as_integer_ratio() for x in arange(1,1.1,0.02)]
Out[6]: 
[(1, 1),
 (2296835809958953, 2251799813685248),
 (1170935903116329, 1125899906842624),
 (2386907802506363, 2251799813685248),
 (607985949695017, 562949953421312),
 (2476979795053773, 2251799813685248)]

shows that only 1 has an exact float representation.

In [7]: ['{:1.18f}'.format(f) for f in arange(1,1.1,.02)]
Out[7]: 
['1.000000000000000000',
 '1.020000000000000018',
 '1.040000000000000036',
 '1.060000000000000053',
 '1.080000000000000071',
 '1.100000000000000089']

shows intern accuracy.

In [8]: arange(1,1.1,.02)
Out[8]: array([ 1.  ,  1.02,  1.04,  1.06,  1.08,  1.1 ])

shows how numpy deals with printing, rounding to at most 6 digits, discarding trailing 0.

In [9]: [f for f in arange(1,1.1,.02)]
Out[9]: [1.0, 1.02, 1.04, 1.0600000000000001, 1.0800000000000001, 1.1000000000000001]

shows how python deals with printing, rounding to at most 16 digits, discarding trailing 0 after first digit.

Some advise for How do I deal with such scenario in everyday programming ?

Furthermore, each operation on floats can deteriorate accuracy.
Natural float64 accuracy is roughly 1e-16, which is sufficient for a lot of applications. Subtract is the most common source of precision loss, as in this example where exact result is 0. :

In [5]: [((1+10**(-exp))-1)/10**(-exp)-1 for exp in range(0,24,4)]
Out[5]: 
[0.0,
 -1.1013412404281553e-13,
 -6.07747097092215e-09,
 8.890058234101161e-05,
 -1.0,
 -1.0]

Hey, thanks for detailed answer. Explanation using method - as_integer_ratio() is really great. I just feel like "welcome to world of floats".. :) — tired and bored dev, Apr 03 '16 at 09:53

Dealing with floating points: With numpy python in particular

1 Answers1