# `nextafter`, `nextafterf`, `nextafterl`, `_nextafter`, `_nextafterf`, `nexttoward`, `nexttowardf`, `nexttowardl`

Returns the next representable floating-point value.

## Syntax

``````double nextafter( double x, double y );
float nextafterf( float x, float y );
long double nextafterl( long double x, long double y );

double _nextafter( double x, double y );
float _nextafterf( float x, float y ); /* x64 only */

#define nextafter(X, Y) // Requires C11 or higher

double nexttoward( double x, long double y );
float nexttowardf( float x, long double y );
long double nexttowardl( long double x, long double y );

#define nexttoward(X, Y) // Requires C11 or higher

float nextafter( float x, float y ); /* C++ only, requires <cmath> */
long double nextafter( long double x, long double y ); /* C++ only, requires <cmath> */

float nexttoward( float x, long double y ); /* C++ only, requires <cmath> */
long double nexttoward( long double x, long double y ); /* C++ only, requires <cmath> */
``````

### Parameters

`x`
The floating-point value to start from.

`y`
The floating-point value to go towards.

## Return value

Returns the next representable floating-point value of the return type after `x` in the direction of `y`. If `x` and `y` are equal, the function returns `y`, converted to the return type, with no exception triggered. If `x` isn't equal to `y`, and the result is a denormal or zero, the `FE_UNDERFLOW` and `FE_INEXACT` floating-point exception states are set, and the correct result is returned. If either `x` or `y` is a NAN, then the return value is one of the input NANs. If `x` is finite and the result is infinite or not representable in the type, a correctly signed infinity or NAN is returned, the `FE_OVERFLOW` and `FE_INEXACT` floating-point exception states are set, and `errno` is set to `ERANGE`.

## Remarks

The `nextafter` and `nexttoward` function families are equivalent, except for the parameter type of `y`. If `x` and `y` are equal, the value returned is `y` converted to the return type.

Because C++ allows overloading, if you include `<cmath>` you can call overloads of `nextafter` and `nexttoward` that return `float` and `long double` types. In a C program, unless you're using the `<tgmath.h>` macro to call this function, `nextafter` and `nexttoward` always return `double`.

If you use the `nextafter` or `nexttoward`macro from `<tgmath.h>`, the type of the argument determines which version of the function is selected. See Type-generic math for details.

The `_nextafter` and `_nextafterf` functions are Microsoft-specific. The `_nextafterf` function is only available when compiling for x64.

By default, this function's global state is scoped to the application. To change this behavior, see Global state in the CRT.

## Requirements

`nextafter`, `nextafterf`, `nextafterl`, `_nextafterf`, `nexttoward`, `nexttowardf`, `nexttowardl` `<math.h>` `<math.h>` or `<cmath>`
`_nextafter` `<float.h>` `<float.h>` or `<cfloat>`
`nextafter` macro, `nexttoward` macro `<tgmath.h>`