Search
```It seems nextafter doesn't work with DMD v1.023 on Win on real type, this is my implementation, it may be slow, but it seem to work (but lastbit_wrt_half must be changed if real changes its bit representation):

/******************************************
Calculates the next representable value after x in the direction of y.

If y > x, the result will be the next largest floating-point value;
if y < x, the result will be the next smallest value.
If x == y, the result is y.

The FE_INEXACT and FE_OVERFLOW exceptions will be raised if x is finite and
the function result is infinite. The FE_INEXACT and FE_UNDERFLOW
exceptions will be raised if the function value is subnormal, and x is
not equal to y.
*/
Tyx nextNum(Tyx, Tyy)(Tyx x, Tyy y) {
static if (is(Tyx == float))
return nextafterf(x, y);
else static if (is(Tyx == double))
return nextafter(x, y);
else static if (is(Tyx == real)) {
const real lastbit_wrt_half = 5.42101086242752217e-20L;
int exponent;
real mantissa = frexp(x, exponent);
if (y > x)
return ldexp(mantissa + lastbit_wrt_half, exponent);
else
return ldexp(mantissa - lastbit_wrt_half, exponent);
} else
static assert(0, "nextNum(): x must be float, double or real.");
}

unittest { // Tests of nextNum()
float f = 0.5;
double d = 0.5;
real r = 0.5;

float largef = 1000.0;
double larged = 1000.0;
real larger = 1000.0;

float smallf = 0.1;
double smalld = 0.1;
real smallr = 0.1;

f = nextNum(f, larger);
assert(format("%.20e", f) == "5.00000059604644775390e-01");
f = nextNum(f, larger);
assert(format("%.20e", f) == "5.00000119209289550780e-01");
f = 0.5;
f = nextNum(f, smallf);
assert(format("%.20e", f) == "4.99999970197677612300e-01");

d = nextNum(d, larged);
assert(format("%.20e", d) == "5.00000000000000111020e-01");
d = nextNum(d, larged);
assert(format("%.20e", d) == "5.00000000000000222040e-01");
d = 0.5;
d = nextNum(d, smalld);
assert(format("%.20e", d) == "4.99999999999999944480e-01");

r = nextNum(r, larger);
assert(format("%.19e", r) == "5.0000000000000000004e-01");
r = nextNum(r, larger);
assert(format("%.19e", r) == "5.0000000000000000008e-01");
r = 0.5;
r = nextNum(r, smallr);
assert(format("%.19e", r) == "4.9999999999999999995e-01");

assert(format("%.19e", nextNum(-3.0, -5.0)) == "-3.0000000000000004440e+00");
assert(format("%.19e", nextNum(-3.0, 5.0)) == "-2.9999999999999995559e+00");
} // End tests of nextNum()

The starting point was: http://mail.python.org/pipermail/python-list/2001-August/099152.html

Bye,
bearophile
```