```Issue #9192 has been updated by vatsu (Gustavo Sales).

marcandre (Marc-Andre Lafortune) wrote:
> duerst (Martin DÃ¼rst) wrote:
> > ...
> > But simply converting BigDecimal to Float may not make sense in general. Imagine a BigDecimal with much higher precision, like
> > BigDecimal('706.06059999999999'), and some corresponding floats. We may want to actually say that the BigDecimal is bigger or smaller than the float created from the same string, because the float looses precision.
> > Currently, I get
> >    706.06059999999999 <=> BigDecimal('706.06059999999999') #=>  0
> >    BigDecimal('706.06059999999999') <=> 706.0605999999999  #=> -1
> > which is of course inconsistent. We should in any case make sure that
> >    (a <=> b) + (b <=> a)
> > is always 0 wherever the comparison makes sense.
>
> Agreed.
>
> The float we write as 706.0606 represents a small range of real values that includes the real number 706.06059999999999. So the first result is correct:
>
>     706.0606 <=> BigDecimal('706.06059999999999') #=>  0, ok
>
> The only strange effect is that we can get:
>
>     a == x # => true
>     b == x # => true
>     a == b # => false
>
> when x is a Float and a or b are higher precision numerics.
> This can be explained because the first two comparison involve floats and thus dealing with approximate values.

I don't think it's a good idea to convert to float. We, programmers, have to know how numbers are stored in memory and we also know how to deal with different number's precision.  My only concern is about making comparison between any 2 Numeric subclasses consistent. In that sense, I agree with @duerst.  But, it is just my opinion as ruby programmer that is starting to try to help on ruby-core.

----------------------------------------
Bug #9192: Inconsistent comparison between Float and BigDecimal
https://bugs.ruby-lang.org/issues/9192#change-43416

Author: vatsu (Gustavo Sales)
Status: Assigned
Priority: Normal
Assignee: mrkn (Kenta Murata)
Category: ext
Target version:
ruby -v:  2.0.0p353 (2013-11-22 revision 43784) [x86_64-darwin11.4.2]
Backport: 1.9.3: UNKNOWN, 2.0.0: UNKNOWN

I was checking a possible inconsistency on ActiveModel and I found situations where comparing BigDecimal to Float differs to comparing Float to BigDecimal.

I have create a simple ruby script to exemplify the problem. The script is attach to this issue and output is as follows:

Instance number 706.05
###########
Instance number 706.06
Inconsistence:
0.70606E3 > 706.06
706.06 < 0.70606E3
=========
Inconsistence:
0.70606E3 <= 706.06
706.06 >= 0.70606E3
=========
###########
Instance number 706.07
Inconsistence:
0.70607E3 < 706.07
706.07 > 0.70607E3
=========
Inconsistence:
0.70607E3 >= 706.07
706.07 <= 0.70607E3
=========
###########
Instance number 706.08
###########

--
http://bugs.ruby-lang.org/
```