Feature #9834
closedFloat#{next_float,prev_float}
Description
I'd like to add Float#next_float and Float#prev_float which
returns next representable floatingpoint number and
previous representable floatingpoint 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 floatingpoint numbers.
For example, they can be used to examine floatingpoint 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 10f #=> 1.9539925233402755e14 # the floatingpoint error.
p(10.0.next_float10) #=> 1.7763568394002505e15 # 1 ulp (units in the last place).
p((10f)/(10.0.next_float10)) #=> 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
Updated by phasis68 (Heesob Park) about 8 years ago
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)
y = y.to_f
if (self.nan?  y.nan?)
Float::NAN
elsif self == y
y
elsif self == 0
num2dbl(1) * (y<=>0.0)
elsif (y > self) == (self > 0)
num2dbl(dbl2num(self) + 1)
else
num2dbl(dbl2num(self)  1)
end
end
def prev_float
nextafter(Float::INFINITY)
end
def next_float
nextafter(Float::INFINITY)
end
end
Updated by akr (Akira Tanaka) about 8 years ago
Thank you for an interesting implementation.
Heesob Park wrote:
if (self==Float::NAN  y==Float::NAN)
This doesn't work. Float#nan? should be used.
elsif self == y r = self
This should be "r = y" to to follow C99's nextafter() behavior.
(It doesn't affect next_float
and prev_float
, though.)
Updated by matz (Yukihiro Matsumoto) about 8 years ago
Accepted.
Matz.
Updated by marcandre (MarcAndre Lafortune) about 8 years ago
Float#next or Float#next_float?
Yukihiro Matsumoto wrote:
Accepted.
Matz.
Updated by matz (Yukihiro Matsumoto) about 8 years ago
 Assignee set to akr (Akira Tanaka)
Float#next_float definitely. Float#next is too short and too simple for this method.
Matz.
Updated by akr (Akira Tanaka) about 8 years ago
 Status changed from Open to Closed
 % Done changed from 0 to 100
Applied in changeset r45982.

configure.in: Check nextafter() availability.

include/ruby/missing.h (nextafter): New optional declaration.

missing/nextafter.c: New file.

numeric.c: Float#next_float and Float#prev_float implemented.
[rubycore:62562] [Feature #9834]