## table of contents

NEXTAFTER(3) | Library Functions Manual | NEXTAFTER(3) |

# NAME¶

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

# LIBRARY¶

Math library (*libm*, *-lm*)

# SYNOPSIS¶

#include <math.h>

double nextafter(doublex, doubley);float nextafterf(floatx, floaty);long double nextafterl(long doublex, long doubley);

double nexttoward(doublex, long doubley);float nexttowardf(floatx, long doubley);long double nexttowardl(long doublex, long doubley);

**nextafter**():

_ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L

|| _XOPEN_SOURCE >= 500

|| /* Since glibc 2.19: */ _DEFAULT_SOURCE

|| /* Glibc <= 2.19: */ _BSD_SOURCE || _SVID_SOURCE

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

_ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L

|| /* Since glibc 2.19: */ _DEFAULT_SOURCE

|| /* Glibc <= 2.19: */ _BSD_SOURCE || _SVID_SOURCE

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

_XOPEN_SOURCE >= 600 || _ISOC99_SOURCE

|| _POSIX_C_SOURCE >= 200112L

# DESCRIPTION¶

The **nextafter**(), **nextafterf**(), and
**nextafterl**() 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**(), **nexttowardf**(), and
**nexttowardl**() functions do the same as the corresponding
**nextafter**() functions, except that they have a *long double*
second argument.

# RETURN VALUE¶

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.

# ERRORS¶

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
*errno*is set to**ERANGE**. An overflow floating-point exception (**FE_OVERFLOW**) is raised.- Range error: result is subnormal or underflows
*errno*is set to**ERANGE**. An underflow floating-point exception (**FE_UNDERFLOW**) is raised.

# ATTRIBUTES¶

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

Interface |
Attribute |
Value |

nextafter (), nextafterf (), nextafterl (), nexttoward (), nexttowardf (), nexttowardl () | Thread safety | MT-Safe |

# STANDARDS¶

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

# BUGS¶

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

Before glibc 2.23 these functions did not set *errno*.

# SEE ALSO¶

2022-12-15 | Linux man-pages 6.02 |