```Issue #18018 has been updated by marcandre (Marc-Andre Lafortune).

jeremyevans0 (Jeremy Evans) wrote in #note-3:
> This issue also goes the other direction:
> =

> ```
> f =3D 291.39999999999997
> ```

Well, that `f` *is* the same float (291.4), I don't understand your point, =
sorry.

> marcandre (Marc-Andre Lafortune) wrote:
> > `g =3D f.floor(n)`, for `n > 0` must return the highest float that has =
the correct properties:
> > * `g` <=3D `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 <=3D 291.4, and the decimal string representation has at most the n=
umber 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.

> @marcandre If you still think this is a bug, could you explain why, and i=
deally the algorithm that should be used instead?

I still think it is a bug.

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 =3D 291.4
p 6.times.map{|i| f.correct_floor(i)}
# =3D> [291.0, 291.4, 291.4, 291.4, 291.4, 291.4]
```

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

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

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

`g =3D f.floor(n)`, for `n > 0` must return the highest float that has the =
correct properties:
* `g` <=3D `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) =3D=3D f=
.floor(n)` for all `f` and `n`.

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

Noticed by Eust=E1quio 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 =3D=3D 2` is not this issue, since `0.3/0.1 =
#=3D> 2.9999999999999996`

-- =

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

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