[ruby-core:22639] Re: suggestions for float

2009/3/3 Brent Roman <[e-mail]>:
>
> OK. =C2=A0I apologize in advance. =C2=A0Soapbox on...
>
> I, for one, like Ruby's current approach to numeric type conversions.
> There is an automatic promotion from Fixnum to Bignum to prevent =C2=A0ov=
erflow.
> (a nice feature borrowed from SmallTalk)
>
> However, as others have pointed out, there is no analogous promotion betw=
een
> discrete, countable Integer types and Floats. =C2=A0This is because all F=
loats
> are *approximations* of abstract, continuous Real numbers.
>
> Floats are imprecise by design. =C2=A0They are intended to represent meas=
ured
> quantities, not countable objects. =C2=A0Any real valued measurement is l=
ikely to
> have more error in its underlying physics than the 8-byte binary floating
> point format Ruby uses to approximate that value.
>
> Floats should not be used for counting *anything* discrete. =C2=A0Not pen=
nies,
> not array elements, not machine states. =C2=A0(ok, maybe pennies if you a=
re
> dealing with current stock prices :-)
>
> Sure, they can approximate 1.0 fairly well. =C2=A0But, 1.1 is an inexact
> repeating binary fraction.
>
> A variant of the float to string conversion that tries to preserve all th=
e
> binary information would certainly be useful, but not as the default to_s
> method. =C2=A0That is, unless you think that:
>
> irb> =C2=A02.1 - 3.0
> -0.8999999999999999
>
> would not be "surprising"! =C2=A0(well, at least annoying)
>
> Then, of course, there remains the question of efficiency. =C2=A0Many sim=
ple
> iterative numerical algorithms will cause BigDecimal and Rational numbers=
 to
> balloon in bytes required as they struggle to maintain perfect accuracy.
> And, as they become bigger in memory, they will also become slower. =C2=
=A0Think
> of numerical integration, for example, =C2=A0or most any sort of successi=
ve
> approximation, in general.
>
> But, theoretical niceties aside, most plain folks are surprised when thei=
r
> fancy computer says:
>
> =C2=A0 2.1 - 3.0 =C2=A0!=3D -0.9
>
> What would fix this problem while still preserving efficiency and keep us
> numerical nerds happy?
>
One possible fix is something like this:

class Float
  alias :plus :+
  alias :minus :-
  def +(a)
    self.plus(a).to_s.to_f
  end
  def -(a)
    self.minus(a).to_s.to_f
  end
end

irb> 2.1 - 3.0 =3D=3D -0.9
=3D> true

Regards,

Park Heesob