# Float equality

**URL:** <https://www.ruby-forum.com/t/float-equality/151902>\
**Category:** Ruby\
**Created:** [October 27, 2008, 5:51pm UTC](https://www.ruby-forum.com/t/float-equality/151902 "2008-10-27T17:51:45Z")\
**Posts on this page:** 14\
**Page:** 1

<div class="post-metadata">

**Author:** ![guille\_lists](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/g/c89c15/32.png) [@guille\_lists](https://www.ruby-forum.com/u/guille_lists)\
**Post date:** [October 27, 2008, 5:51pm UTC](https://www.ruby-forum.com/t/float-equality/151902/1 "2008-10-27T17:51:45Z")

</div>

Hi,

sorry if this is a very naive question (I’m new to ruby), but I  
haven’t found an explication yet. When comparing to floats in ruby I  
came across this:

> > a = 0.1  
> > =\> 0.1
> 
> > b = 1 - 0.9  
> > =\> 0.1
> 
> > a == b  
> > =\> false
> 
> > a \> b  
> > =\> true
> 
> > a \< b  
> > =\> false
> 
> > a \<=\> b  
> > =\> 1

I’m a bit lost here, shouldn’t (0.1) and (1 - 0.9) be equals regarding  
the == operator? I also found that for example 0.3 == (0.2 + 0.1)  
returns false, etc.

guille

PD: I’m using ruby 1.8.6 (2008-03-03 patchlevel 114)  
[universal-darwin9.0]

---

<div class="post-metadata">

**Author:** ![guille\_lists](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/g/c89c15/32.png) [@guille\_lists](https://www.ruby-forum.com/u/guille_lists)\
**Post date:** [October 27, 2008, 6:10pm UTC](https://www.ruby-forum.com/t/float-equality/151902/2 "2008-10-27T18:10:38Z")

</div>

On Mon, Oct 27, 2008 at 11:50 AM, guille lists [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid)  
wrote:

> > > a == b  
> > > returns false, etc.  
> > > Most people will point you to this:  
> > > [Floating-point arithmetic - Wikipedia](http://en.wikipedia.org/wiki/Floating_point_arithmetic)

There are several ways around it (using BigDecimal, Rational, Integers,  
etc.)

Totally off-topic, but has any one figured out exactly why 1/9  
(0.111…) plus 8/9 (0.888…) is 1 instead of 0.999… 🙂

Todd

---

<div class="post-metadata">

**Author:** ![guille\_lists](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/g/c89c15/32.png) [@guille\_lists](https://www.ruby-forum.com/u/guille_lists)\
**Post date:** [October 27, 2008, 6:10pm UTC](https://www.ruby-forum.com/t/float-equality/151902/3 "2008-10-27T18:10:46Z")

</div>

guille lists wrote:

> I’m a bit lost here, shouldn’t (0.1) and (1 - 0.9) be equals regarding  
> the == operator?

Nope. Floating-point is always inexact. This is a computer thing, not  
a Ruby thing. The issue applies to all languages everywhere which use  
floating point.

Here you can see the two values are slightly different:

irb(main):001:0\> 1 - 0.9 == 0.1  
=\> false  
irb(main):002:0\> [1 - 0.9].pack(“D”)  
=\> “\230\231\231\231\231\231\271?”  
irb(main):003:0\> [0.1].pack(“D”)  
=\> “\232\231\231\231\231\231\271?”

---

<div class="post-metadata">

**Author:** ![guille\_lists](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/g/c89c15/32.png) [@guille\_lists](https://www.ruby-forum.com/u/guille_lists)\
**Post date:** [October 27, 2008, 6:16pm UTC](https://www.ruby-forum.com/t/float-equality/151902/4 "2008-10-27T18:16:29Z")

</div>

guille lists wrote:

> I’m a bit lost here, shouldn’t (0.1) and (1 - 0.9) be equals regarding  
> the == operator?

No. The result of 1 - 0.9 using floating point math is not actually 0.1.  
In  
irb it is displayed as 0.1, but that’s only because Float#inspect  
rounds.  
Using printf you can see that the result of 1-0.9 actually is  
0.09999lots:

> > printf “%.30f”, 1-0.9  
> > 0.099999999999999977795539507497  
> > 0.1 itself isn’t actually 0.1 either - it’s  
> > 0.100000000000000005551115123126…  
> > Because of this you should not check two floats for equality (usually  
> > you want  
> > to check for a delta or not use floats at all). This is so because of  
> > the  
> > inherent inaccuracy of floating point maths. See this for more  
> > information:  
> > [http://docs.sun.com/source/806-3568/ncg\_goldberg.html](http://docs.sun.com/source/806-3568/ncg_goldberg.html)

HTH,  
Sebastian

---

<div class="post-metadata">

**Author:** ![guille\_lists](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/g/c89c15/32.png) [@guille\_lists](https://www.ruby-forum.com/u/guille_lists)\
**Post date:** [October 27, 2008, 8:32pm UTC](https://www.ruby-forum.com/t/float-equality/151902/5 "2008-10-27T20:32:16Z")

</div>

Thanks a lot for the answers and references, and sorry for not having  
check deeper on google  
([http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/9655](http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/9655)).

So I guess that if one wants to work for example with float numbers in  
the range [0,1], the best way to do it is by normalising from an  
integer interval depending on the precision you want, say [0,100] for  
two decimal digits precision, and so on. Is there any other better  
approach? Does the use of BigDecimal impose a severe penalty on  
performance?

guille

---

<div class="post-metadata">

**Author:** ![guille\_lists](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/g/c89c15/32.png) [@guille\_lists](https://www.ruby-forum.com/u/guille_lists)\
**Post date:** [October 27, 2008, 8:48pm UTC](https://www.ruby-forum.com/t/float-equality/151902/6 "2008-10-27T20:48:40Z")

</div>

Matthew M. wrote:

> > Totally off-topic, but has any one figured out exactly why 1/9  
> > (0.111…) plus 8/9 (0.888…) is 1 instead of 0.999… 🙂
> 
> Ummm… because 1/9 + 8/9 == (1 + 8)/9 == 9/9 == 1 ?
> 
> And… because 0.999… == 1?
> 
> ```
> x = 0.999...
> 
> ```
> 
> 10x = 9.999…  
> (10x - x) = 9.999… - 0.999…  
> 9x = 9  
> x = 1

While your answer is correct, you cannot subtract infinities as shown  
in your proof. Look at this:

```
  x == 1 - 1 + 1 - 1 + 1 - 1 + 1 - ...
  x == 1 - 1 + 1 - 1 + 1 - 1 + ...

```

* * *

```
 2x == 1 + 0 + 0 + 0 + 0 + 0 + 0 + ...
  x == 0.5

```

Does x == 0.5? No, because x was never a number in the first place  
because the given series does not converge. Your proof appears to  
work because you’ve already assumed 0.99999… converges, but that is  
what you are trying to prove.

P.S. Euler thought the answer was x == 0.5.

---

<div class="post-metadata">

**Author:** ![guille\_lists](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/g/c89c15/32.png) [@guille\_lists](https://www.ruby-forum.com/u/guille_lists)\
**Post date:** [October 27, 2008, 9:12pm UTC](https://www.ruby-forum.com/t/float-equality/151902/7 "2008-10-27T21:12:08Z")

</div>

On Mon, Oct 27, 2008 at 11:09 AM, Todd B. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid)  
wrote:

> Totally off-topic, but has any one figured out exactly why 1/9  
> (0.111…) plus 8/9 (0.888…) is 1 instead of 0.999… 🙂

I figured it out once, but I can’t remember precisely how it worked.

TwP

---

<div class="post-metadata">

**Author:** ![guille\_lists](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/g/c89c15/32.png) [@guille\_lists](https://www.ruby-forum.com/u/guille_lists)\
**Post date:** [October 27, 2008, 6:52pm UTC](https://www.ruby-forum.com/t/float-equality/151902/8 "2008-10-27T18:52:55Z")

</div>

> Totally off-topic, but has any one figured out exactly why 1/9  
> (0.111…) plus 8/9 (0.888…) is 1 instead of 0.999… 🙂

Ummm… because 1/9 + 8/9 == (1 + 8)/9 == 9/9 == 1 ?

And… because 0.999… == 1?

```
x = 0.999...

```

10x = 9.999…  
(10x - x) = 9.999… - 0.999…  
9x = 9  
x = 1

---

<div class="post-metadata">

**Author:** ![guille\_lists](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/g/c89c15/32.png) [@guille\_lists](https://www.ruby-forum.com/u/guille_lists)\
**Post date:** [October 27, 2008, 9:14pm UTC](https://www.ruby-forum.com/t/float-equality/151902/9 "2008-10-27T21:14:30Z")

</div>

-------- Original-Nachricht --------

> Datum: Tue, 28 Oct 2008 04:31:06 +0900  
> Von: “guille lists” [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid)  
> An: removed\_email\_address@domain.invalid  
> Betreff: Re: float equality

> guille

Dear guille,

you could use some approximate equality check:

class Float  
def approx\_equal?(other,threshold)  
if (self-other).abs\<threshold # “\<” not exact either 😉  
return true  
else  
return false  
end  
end  
end

a=0.1  
b=1.0-0.9  
threshold=10\*\*(-5)

p a.approx\_equal?(b,threshold)

Best regards,

Axel

---

<div class="post-metadata">

**Author:** ![guille\_lists](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/g/c89c15/32.png) [@guille\_lists](https://www.ruby-forum.com/u/guille_lists)\
**Post date:** [October 27, 2008, 9:31pm UTC](https://www.ruby-forum.com/t/float-equality/151902/10 "2008-10-27T21:31:35Z")

</div>

Mathematically 1.(0) is the same thing as 0.(9). Computers simply  
represent this to whatever precision they can.

---

<div class="post-metadata">

**Author:** ![guille\_lists](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/g/c89c15/32.png) [@guille\_lists](https://www.ruby-forum.com/u/guille_lists)\
**Post date:** [October 27, 2008, 9:58pm UTC](https://www.ruby-forum.com/t/float-equality/151902/11 "2008-10-27T21:58:03Z")

</div>

On Oct 27, 2008, at 2:48 PM, The Higgs bozo wrote:

> > (10x - x) = 9.999… - 0.999…  
> > x == 0.5
> 
> Does x == 0.5? No, because x was never a number in the first place  
> because the given series does not converge. Your proof appears to  
> work because you’ve already assumed 0.99999… converges, but that is  
> what you are trying to prove.

But 0.999… does converge, while 1 - 1 + 1 - 1 +… does not.

---

<div class="post-metadata">

**Author:** ![guille\_lists](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/g/c89c15/32.png) [@guille\_lists](https://www.ruby-forum.com/u/guille_lists)\
**Post date:** [October 27, 2008, 10:02pm UTC](https://www.ruby-forum.com/t/float-equality/151902/12 "2008-10-27T22:02:48Z")

</div>

> > ```
> > x == 1 - 1 + 1 - 1 + 1 - 1 + ...
> > 
> > ```
> 
> But 0.999… does converge, while 1 - 1 + 1 - 1 +… does not.  
> On re-reading, I see that you weren’t so much questioning whether  
> 0.999… converges, but that my proof uses circular reasoning. Yeah, I  
> suppose that’s correct.

Still, 0.999… does converge and is 1. Nyah! 😛 I just don’t  
remember the better proof I once knew.

---

<div class="post-metadata">

**Author:** ![guille\_lists](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/g/c89c15/32.png) [@guille\_lists](https://www.ruby-forum.com/u/guille_lists)\
**Post date:** [October 28, 2008, 3:50am UTC](https://www.ruby-forum.com/t/float-equality/151902/13 "2008-10-28T03:50:30Z")

</div>

The Higgs bozo wrote:

> guille lists wrote:
> 
> > I’m a bit lost here, shouldn’t (0.1) and (1 - 0.9) be equals regarding  
> > the == operator?
> 
> Nope. Floating-point is always inexact.

What you mean is that binary floating point inexactly represents decimal  
fractions.

> This is a computer thing, not  
> a Ruby thing. The issue applies to all languages everywhere which use  
> floating point.

…binary floating point.

---

<div class="post-metadata">

**Author:** ![guille\_lists](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/g/c89c15/32.png) [@guille\_lists](https://www.ruby-forum.com/u/guille_lists)\
**Post date:** [October 27, 2008, 9:41pm UTC](https://www.ruby-forum.com/t/float-equality/151902/14 "2008-10-27T21:41:34Z")

</div>

On Oct 27, 2008, at 2:29 PM, Bilyk, Alex wrote:

> Mathematically 1.(0) is the same thing as 0.(9). Computers simply  
> represent this to whatever precision they can.

Hmmm … my humor is a little to obtuse today. I was hoping the word  
“precisely” would cause a mental link to the word “precision” which is  
what this problem is all about – precision and computer  
representations of floating point values.

Alas. I’ll stick with my day job of writing software.

Blessings,  
TwP