```Phil Tomson wrote:

> Constuction with Strings is not currently supported, but that's a
> thought.  Practically speaking, I'm not sure how big of a problem this
> is, I doubt I'd really need to have a FixedPt number with more
> precision than Ruby has.
>
> I did some experimenting in irb to find out where the cutoff is:
>
> irb(main):027:0> x = 9.0000000000001
> => 9.0000000000001
> irb(main):028:0> x = 9.00000000000001
> => 9.00000000000001
> irb(main):029:0> x = 9.000000000000001
> => 9.0
>
> It happens at 15 digits to the right of the decimal point.  (When you
> go the other way by increasing the size of the number you automatically
> convert to a Bignum - however we don't have a 'Smallnum' equivilent when the
> numbers get very small.)

BigDecimal would work, but does AFAIK not automatically take care of the
precision that would be needed to avoid data loss. Keeping numbers
around as Rational and converting to a BigDecimal on output might work
in that cases.

> That would be about 50 fractional bits in a
> binary fixed point number - practically speaking, you usually (where
> 'usually' probably covers 99.999% of the cases ) don't need that kind of
> precision in a hardware implementation of an algorithm.

Ah, I'm not sure how frequently such accurate numbers are used (I'm not
experienced at hardware design), but it might still be worth
considering. After all 1.1 will not be accurately presented (the first
error occurs at the 15th digit) either.

> [...]
>
> I implemented a model of a Support Vector Machine (kind of like a
> Perceptron, a type of artificial neuron) using FixedPt and an exp(-x)
> lookup table and came up with the following results:
>
> 1) I needed 9 fractional bits at a minimum.
> 2) The value of x for which exp(-x) = 0.0 was -12.25.
> 3) The number of entries in the exp(-x) lookup table was 128 (7 bits of
> address) which was surprisingly small.

Thank you for the detailed description of the process where this library
would be involved. It was very interesting for me -- always nice to see
where Ruby can be used in the real world where you might not have
expected it to be at first. Perhaps this is an interesting enough use
case for it to be added to the RealWorldRuby page of the rubygarden.org
Wiki? If you can name the company you are doing this for then even
better. :)

Anyway, I think you are likely right in that this will rarely be much of
a problem -- but having the possibility in the next release (there will
be one anyway, won't there? ;)) might still be a good thing -- even if
just getting users in the habit of being careful with Floats. Yours will
probably know anyway, but allowing for such a style consistently through
all libraries should keep confusion low.

```