From: merch-redmine@...
Date: 2021-07-26T18:36:39+00:00
Subject: [ruby-core:104685] [Ruby master Bug#18018] Float#floor / truncate sometimes result that is too small.

Issue #18018 has been updated by jeremyevans0 (Jeremy Evans).

Status changed from Feedback to Open

marcandre (Marc-Andre Lafortune) wrote in #note-4:
> > marcandre (Marc-Andre Lafortune) wrote:
> > > `g = f.floor(n)`, for `n > 0` must return the highest float that has the correct properties:
> > > * `g` <= `f`
> > > * `g`'s decimal string representation has at most `n` digits
> > 
> > I think these are both true in these cases. 291.4, 291.39, and 219.39999 are all <= 291.4, and the decimal string representation has at most the number of digits specified after the decimal point.
> 
> Maybe you missed "the *highest* float" in my definition? 291.4 is the only float that fits the definition.

I did miss that :). I agree with you that it is reasonable definition.

> A correct algorithm seem to be to rely on `Rational#floor`:
> 
> ```ruby
> class Float
>   def correct_floor(n)
>     Rational(self).floor(n).to_f
>   end
> end
> 
> f = 291.4
> p 6.times.map{|i| f.correct_floor(i)}
> # => [291.0, 291.4, 291.4, 291.4, 291.4, 291.4]
> ```

Which platform are you running on?  All versions of Ruby I tried on OpenBSD/amd64 and Windows x64 gave the following output for this code:

```
[291.0, 291.3, 291.39, 291.399, 291.3999, 291.39999]
```

I think a simpler solution is to increment by 1 before dividing.  If that is too big, then use the previous calculation.  I submitted a pull request for that: https://github.com/ruby/ruby/pull/4681

----------------------------------------
Bug #18018: Float#floor / truncate sometimes result that is too small.
https://bugs.ruby-lang.org/issues/18018#change-93000

* Author: marcandre (Marc-Andre Lafortune)
* Status: Open
* Priority: Normal
* Target version: 3.1
* Backport: 2.6: UNKNOWN, 2.7: UNKNOWN, 3.0: UNKNOWN
----------------------------------------

```ruby
291.4.floor(1) # => 291.4 (ok)
291.4.floor(2) # => 291.39 (not ok)
291.4.floor(3) # => 291.4 (ok)
291.4.floor(4) # => 291.4 (ok)
291.4.floor(5) # => 291.39999 (not ok)
291.4.floor(6) # => 291.4 (ok)
```

`g = f.floor(n)`, for `n > 0` must return the highest float that has the correct properties:
* `g` <= `f`
* `g`'s decimal string representation has at most `n` digits

I'll note that `floor` should be stable, i.e. `f.floor(n).floor(n) == f.floor(n)` for all `f` and `n`.

Same idea for `truncate`, except for negative numbers (where `(-f).truncate(n) == -(f.floor(n))` for positive `f`).

Noticed by Eust�quio Rangel but posted on the mailing list.

Please do not reply that I need to learn how floats work. Note that example given in doc `(0.3/0.1).floor == 2` is not this issue, since `0.3/0.1 #=> 2.9999999999999996`



-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>