SYNOPSIS

DESCRIPTION

RETURN VALUE

ERRORS

ATTRIBUTES

CONFORMING TO

BUGS

SEE ALSO

COLOPHON

nextafter, nextafterf, nextafterl, nexttoward, nexttowardf, nexttowardl − floating-point number manipulation

**#include
<math.h>**

**double
nextafter(double** *x***, double** *y***);
float nextafterf(float**

long double nextafterl(long double

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

long double nexttowardl(long double

Link with
*−lm*.

Feature Test
Macro Requirements for glibc (see
**feature_test_macros**(7)):

**nextafter**():

_BSD_SOURCE || _SVID_SOURCE ||
_XOPEN_SOURCE >= 500 ||
_XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED ||
_ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L;

or *cc -std=c99*

**nextafterf**(),
**nextafterl**():

_BSD_SOURCE || _SVID_SOURCE ||
_XOPEN_SOURCE >= 600 || _ISOC99_SOURCE ||
_POSIX_C_SOURCE >= 200112L;

or *cc -std=c99*

**nexttoward**(),
**nexttowardf**(), **nexttowardl**():

_XOPEN_SOURCE >= 600
|| _ISOC99_SOURCE ||
_POSIX_C_SOURCE >= 200112L;

or *cc -std=c99*

The
**nextafter**() functions return the next representable
floating-point value following *x* in the direction of
*y*. If *y* is less than *x*, these functions
will return the largest representable number less than
*x*.

If *x*
equals *y*, the functions return *y*.

The
**nexttoward**() functions do the same as the
**nextafter**() functions, except that they have a
*long double* second argument.

On success,
these functions return the next representable floating-point
value after *x* in the direction of *y*.

If *x*
equals *y*, then *y* (cast to the same type as
*x*) is returned.

If *x* or
*y* is a NaN, a NaN is returned.

If *x* is
finite, and the result would overflow, a range error occurs,
and the functions return **HUGE_VAL**, **HUGE_VALF**,
or **HUGE_VALL**, respectively, with the correct
mathematical sign.

If *x* is
not equal to *y*, and the correct function result would
be subnormal, zero, or underflow, a range error occurs, and
either the correct value (if it can be represented), or 0.0,
is returned.

See
**math_error**(7) for information on how to determine
whether an error has occurred when calling these
functions.

The following
errors can occur:

Range error: result overflow

An overflow floating-point
exception (**FE_OVERFLOW**) is raised.

Range error: result is subnormal or underflows

An underflow floating-point
exception (**FE_UNDERFLOW**) is raised.

These functions
do not set *errno*.

For an
explanation of the terms used in this section, see
**attributes**(7).

C99, POSIX.1-2001. This function is defined in IEC 559 (and the appendix with recommended functions in IEEE 754/IEEE 854).

In glibc
version 2.5 and earlier, these functions do not raise an
underflow floating-point (**FE_UNDERFLOW**) exception
when an underflow occurs.

**nearbyint**(3)

This page is
part of release 3.53 of the Linux *man-pages* project.
A description of the project, and information about
reporting bugs, can be found at
http://www.kernel.org/doc/man−pages/.