# nextafter, nextafterf, nextafterl, nexttoward, nexttowardf, nexttowardl

From cppreference.com
< c‎ | numeric‎ | math

Defined in header `<math.h>` |  |
float nextafterf( float from, float to ); | (1) | (since C99)
double nextafter( double from, double to ); | (2) | (since C99)
long double nextafterl( long double from, long double to ); | (3) | (since C99)
float nexttowardf( float from, long double to ); | (4) | (since C99)
double nexttoward( double from, long double to ); | (5) | (since C99)
long double nexttowardl( long double from, long double to ); | (6) | (since C99)
Defined in header `<tgmath.h>` |  |
#define nextafter(from, to) | (7) | (since C99)
#define nexttoward(from, to) | (8) | (since C99)

1-3) First, converts both arguments to the type of the function, then returns the next representable value of `from` in the direction of `to`. If `from` equals to `to`, `to` is returned.
4-6) First, converts the first argument to the type of the function, then returns the next representable value of `from` in the direction of `to`. If `from` equals to `to`, `to` is returned, converted from long double to the return type of the function without loss of range or precision.
7) Type-generic macro: If any argument has type long double, `nextafterl` is called. Otherwise, if any argument has integer type or has type double, `nextafter` is called. Otherwise, `nextafterf` is called.
8) Type-generic macro: If the argument `from` has type long double, `nexttowardl` is called. Otherwise, if `from` has integer type or the type double, `nexttoward` is called. Otherwise, `nexttowardf` is called.

### Parameters

from, to | - | floating point values

### Return value

If no errors occur, the next representable value of `from` in the direction of `to`. is returned. If `from` equals `to`, then `to` is returned, converted to the type of the function.

If a range error due to overflow occurs, `±HUGE_VAL`, `±HUGE_VALF`, or `±HUGE_VALL` is returned (with the same sign as `from`).

If a range error occurs due to underflow, the correct result is returned.

### Error handling

Errors are reported as specified in math_errhandling.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),

- if `from` is finite, but the expected result is an infinity, raises FE_INEXACT and FE_OVERFLOW
- if `from` does not equal `to` and the result is subnormal or zero, raises FE_INEXACT and FE_UNDERFLOW
- in any case, the returned value is independent of the current rounding mode
- if either `from` or `to` is NaN, NaN is returned

### Notes

POSIX specifies that the overflow and the underflow conditions are range errors (errno may be set).

IEC 60559 recommends that `from` is returned whenever `from==to`. These functions return `to` instead, which makes the behavior around zero consistent: `nextafter(-0.0, +0.0)` returns `+0.0` and `nextafter(+0.0, -0.0)` returns `–0.0`.

### Example

Run this code

    #include <math.h>
    #include <stdio.h>
    #include <float.h>
    #include <fenv.h>

    int main(void)
    {
        float from1 = 0, to1 = nextafterf(from1, 1);
        printf("The next representable float after %.2f is %.20g (%a)\n", from1, to1, to1);

        float from2 = 1, to2 = nextafterf(from2, 2);
        printf("The next representable float after %.2f is %.20f (%a)\n", from2, to2, to2);

        double from3 = nextafter(0.1, 0), to3 = 0.1;
        printf("The number 0.1 lies between two valid doubles:\n"
               "    %.56f (%a)\nand %.55f  (%a)\n", from3, from3, to3, to3);

        // difference between nextafter and nexttoward:
        long double dir = nextafterl(from1, 1); // first subnormal long double
        float x = nextafterf(from1, dir); // first converts dir to float, giving 0
        printf("Using nextafter, next float after %.2f (%a) is %.20g (%a)\n",
               from1, from1, x, x);
        x = nexttowardf(from1, dir);
        printf("Using nexttoward, next float after %.2f (%a) is %.20g (%a)\n",
               from1, from1, x, x);

        // special values
        {
            #pragma STDC FENV_ACCESS ON
            feclearexcept(FE_ALL_EXCEPT);
            double from4 = DBL_MAX, to4 = nextafter(from4, INFINITY);
            printf("The next representable double after %.2g (%a) is %.23f (%a)\n",
                   from4, from4, to4, to4);
            if(fetestexcept(FE_OVERFLOW)) puts("   raised FE_OVERFLOW");
            if(fetestexcept(FE_INEXACT)) puts("   raised FE_INEXACT");
        } // end FENV_ACCESS block

        float from5 = 0.0, to5 = nextafter(from5, -0.0);
        printf("nextafter(+0.0, -0.0) gives %.2g (%a)\n", to5, to5);
    }

Output:

    The next representable float after 0.00 is 1.4012984643248170709e-45 (0x1p-149)
    The next representable float after 1.00 is 1.00000011920928955078 (0x1.000002p+0)
    The number 0.1 lies between two valid doubles:
        0.09999999999999999167332731531132594682276248931884765625 (0x1.9999999999999p-4)
    and 0.1000000000000000055511151231257827021181583404541015625  (0x1.999999999999ap-4)
    Using nextafter, next float after 0.00 (0x0p+0) is 0 (0x0p+0)
    Using nexttoward, next float after 0.00 (0x0p+0) is 1.4012984643248170709e-45 (0x1p-149)
    The next representable double after 1.8e+308 (0x1.fffffffffffffp+1023) is inf (inf)
       raised FE_OVERFLOW
       raised FE_INEXACT
    nextafter(+0.0, -0.0) gives -0 (-0x0p+0)

### References

- C11 standard (ISO/IEC 9899:2011):

  - 7.12.11.3 The nextafter functions (p: 256)

  - 7.12.11.4 The nexttoward functions (p: 257)

  - 7.25 Type-generic math <tgmath.h> (p: 373-375)

  - F.10.8.3 The nextafter functions (p: 529)

  - F.10.8.4 The nexttoward functions (p: 529)

- C99 standard (ISO/IEC 9899:1999):

  - 7.12.11.3 The nextafter functions (p: 237)

  - 7.12.11.4 The nexttoward functions (p: 238)

  - 7.22 Type-generic math <tgmath.h> (p: 335-337)

  - F.9.8.3 The nextafter functions (p: 466)

  - F.9.8.4 The nexttoward functions (p: 466)

### See also

C++ documentation for nextafter

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=c/numeric/math/nextafter&oldid=77359"