Issue #9834 has been updated by Heesob Park.


Here is a pure ruby implementation of `Float#{next_float,prev_float}` (adopted from http://golang.org/src/pkg/math/nextafter.go)

~~~
class Float
        def dbl2num(dbl)
          [dbl].pack('d').unpack('Q')[0]
        end

        def num2dbl(num)
          [num].pack('Q').unpack('d')[0]
        end
        
        def nextafter(y)
          if (self==Float::NAN || y==Float::NAN)
            r = Float::NAN
          elsif self == y
            r = self
          elsif self == 0
            r = num2dbl(1) * (y<=>0.0)
          elsif (y > self) == (self > 0)
            r = num2dbl(dbl2num(self) + 1)
          else
            r = num2dbl(dbl2num(self) - 1)
          end
          r
        end

        def prev_float
          nextafter(-Float::INFINITY)
        end
        
        def next_float
          nextafter(Float::INFINITY)
        end
end
~~~


----------------------------------------
Feature #9834: Float#{next_float,prev_float}
https://bugs.ruby-lang.org/issues/9834#change-46711

* Author: Akira Tanaka
* Status: Open
* Priority: Normal
* Assignee: 
* Category: 
* Target version: 
----------------------------------------
I'd like to add Float#next_float and Float#prev_float which
returns next representable floating-point number and
previous representable floating-point number.

```
p 3.0.next_float #=> 3.0000000000000004
p 3.0.prev_float #=> 2.9999999999999996
```

These methods can be useful to examine the behavior of floating-point numbers.

For example, they can be used to examine floating-point error in 0.1 + 0.1 + ... + 0.1.

```
f = 0.0
100.times { f += 0.1 }
p f                            #=> 9.99999999999998       # should be 10.0 in the ideal world.
p 10-f                         #=> 1.9539925233402755e-14 # the floating-point error.
p(10.0.next_float-10)          #=> 1.7763568394002505e-15 # 1 ulp (units in the last place).
p((10-f)/(10.0.next_float-10)) #=> 11.0                   # the error is 11 ulp.
p "%a" % f                     #=> "0x1.3fffffffffff5p+3" # the last hex digit is 5.  16 - 5 = 11 ulp.
```

The methods are implemented using nextafter() function described in
IEEE 754 (Appendix), C99 and POSIX.
It seems the function is pretty portable on Unix variants.

However I implemented missing/nextafter.c for environments which don't have the function.

Any idea?


---Files--------------------------------
next_float-and-prev_float.patch (11.9 KB)


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