Man Linux: Main Page and Category List

## NAME

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

```

## 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(): _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE >= 500 ||
_ISOC99_SOURCE; or cc -std=c99
nextafterf(), nextafterl(): _BSD_SOURCE || _SVID_SOURCE ||
_XOPEN_SOURCE >= 600 || _ISOC99_SOURCE; or cc -std=c99
nexttoward(), nexttowardf(), nexttowardl(): _XOPEN_SOURCE >= 600 ||
_ISOC99_SOURCE; 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.

```

## RETURNVALUE

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

```

## CONFORMINGTO

```       C99,  POSIX.1-2001.   This  function  is  defined  in  IEC 559 (and the
appendix 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  (FE_UNDERFLOW)  exception  when an underflow
occurs.

```

```       nearbyint(3)
```       This page is part of release 3.24 of the Linux  man-pages  project.   A