# nextafter

## NAME



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


## LIBRARY



           Math library (_libm_ , _-lm_)
    


## SYNOPSIS



           **#include <math.h>**
    
           **double nextafter(double** _x_**, double** _y_**);**
           **float nextafterf(float** _x_**, float** _y_**);**
           **long double nextafterl(long double** _x_**, long double** _y_**);**
    
           **double nexttoward(double** _x_**, long double** _y_**);**
           **float nexttowardf(float** _x_**, long double** _y_**);**
           **long double nexttowardl(long double** _x_**, long double** _y_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **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**(),           │ Thread safety │ MT-Safe │
           │ **nextafterl**(), **nexttoward**(),          │               │         │
           │ **nexttowardf**(), **nexttowardl**()         │               │         │
           └──────────────────────────────────────┴───────────────┴─────────┘
    


## STANDARDS



           C11, 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_.
    


* * *