NEXTAFTER(3) Linux Programmer's Manual NEXTAFTER(3)

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

SYNOPSIS
       #include 

       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);

       Link with -lm.

   Feature Test Macro Requirements for glibc (see featuretestmacros(7)):

       nextafter():
           BSDSOURCE || SVIDSOURCE || XOPENSOURCE >= 500 ||
           XOPENSOURCE && XOPENSOURCEEXTENDED || ISOC99SOURCE ||
           POSIXCSOURCE >= 200112L;
           or cc -std=c99
       nextafterf(), nextafterl():
           BSDSOURCE || SVIDSOURCE || XOPENSOURCE >= 600 ||
           ISOC99SOURCE || POSIXCSOURCE >= 200112L;
           or cc -std=c99
       nexttoward(), nexttowardf(), nexttowardl():
           XOPENSOURCE >= 600 || ISOC99SOURCE ||
           POSIXCSOURCE >= 200112L;
           or cc -std=c99

DESCRIPTION
       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.

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  HUGEVAL, HUGEVALF, or HUGEVALL, respec‐
       tively, with the correct mathematical sign.

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

ERRORS
       See matherror(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 (FEOVERFLOW) is raised.

       Range error: result is subnormal or underflows
              An underflow floating-point exception (FEUNDERFLOW) is raised.

       These functions do not set errno.

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() │               │         │
       └─────────────────────────────┴───────────────┴─────────┘
CONFORMING TO
       C99, POSIX.1-2001.  This function is defined in IEC 559 (and the appen‐
       dix with recommended functions in IEEE 754/IEEE 854).

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

SEE ALSO
       nearbyint(3)

COLOPHON
       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/.



GNU                               2010-09-20                      NEXTAFTER(3)