Is this a float-bug or naive comprehension?

Hello all,

This is my first mail into the mailing list, so please be kind with any
errors, and please point them out so we can learn from them :slight_smile:

Last night I was messing with some simple arithmetic operations in irb,
and
notice a funny thing: when I made subtractions (did not tested any other
operation) I did not got the expected results…

It seems that the result of floating-point subtraction is not correct…
as
if it had some residual value left in some deep decimal position…
This happens in both ruby 1.8.7 (2011-06-30 patchlevel 352) [i686-linux]
and
ruby 1.9.2p180 (2011-02-18 revision 30909) [i686-linux]

I’m I missing something?
Or is it that the results are in fact incorrect and a bug should be
reported?
If so, should I report the bug into "http://redmine.ruby-lang.org/
", or where?

Thanks in advance, Zipizap

$ ruby -v
ruby 1.8.7 (2011-06-30 patchlevel 352) [i686-linux]*
*
$ irb
ruby-1.8.7-p352 :001 > 2.45 - 1.45
=> 1.0

The last result is ok

ruby-1.8.7-p352 :002 > (0…10).map {|x| (x+0.9) - (x+0.7)}
=> [0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.200000000000001,
0.200000000000001]

The last results should all be 0.20 and they not only are different

from
0.20 but they are also ?!?different between themselves?!?

See the following “uniq” filter

This also happens in Ruby 1.9.2

ruby-1.8.7-p352 :003 > (0…10).map {|x| (x+0.9) - (x+0.7)}.uniq
=> [0.2, 0.2, 0.2, 0.2, 0.200000000000001]

$ ruby -v
ruby 1.9.2p180 (2011-02-18 revision 30909) [i686-linux]

$ irb
ruby-1.9.2-p180 :002 > 2.45 - 1.45
=> 1.0000000000000002

ruby-1.9.2-p180 :005 > (0…10).map {|x| (x+0.9) - (x+0.7)}
=> [0.20000000000000007, 0.19999999999999996, 0.19999999999999973,
0.19999999999999973, 0.20000000000000018, 0.20000000000000018,
0.20000000000000018, 0.20000000000000018, 0.20000000000000107,
0.20000000000000107]

ruby-1.9.2-p180 :006 > (0…10).map {|x| (x+0.9) - (x+0.7)}.uniq
=> [0.20000000000000007, 0.19999999999999996, 0.19999999999999973,
0.20000000000000018, 0.20000000000000107]

This is how floating point math works. If you want exact values use
decimals.

On Mon, Jul 18, 2011 at 10:15 AM, ZipiZap zap [email protected]
wrote:

if it had some residual value left in some deep decimal position…
Thanks in advance, Zipizap

=> [0.2, 0.2, 0.2, 0.2, 0.200000000000001]

ruby-1.9.2-p180 :005 > (0…10).map {|x| (x+0.9) - (x+0.7)}
=> [0.20000000000000007, 0.19999999999999996, 0.19999999999999973,
0.19999999999999973, 0.20000000000000018, 0.20000000000000018,
0.20000000000000018, 0.20000000000000018, 0.20000000000000107,
0.20000000000000107]

ruby-1.9.2-p180 :006 > (0…10).map {|x| (x+0.9) - (x+0.7)}.uniq
=> [0.20000000000000007, 0.19999999999999996, 0.19999999999999973,
0.20000000000000018, 0.20000000000000107]

–

*Samuel K.
*E [email protected]

On 18 July 2011 16:19, Samuel K. [email protected] wrote:

This is how floating point math works. If you want exact values use
decimals.
Floating-point arithmetic - Wikipedia

Thanks Samuel for the tip about decimals

I’ve then found an old discussion in the ruby forums about float and
decimals - see Ruby 1.9+ , floats, and decimal - Ruby - Ruby-Forum