# Manpage of NEXTAFTER

# Section: Linux Programmer's Manual (3) AFTER

Updated: 2016-03-15

Index

## NAME

after, afterf, afterl, toward, towardf, towardl - floating-point number manipulation## SYNOPSIS

**#include <math.h>**

**double ** after(double *x***, double ***y***);****float ** afterf(float *x***, float ***y***);****long double ** afterl(long double *x***, long double ***y***);**

**double ** toward(double *x***, long double ***y***);****float ** towardf(float *x***, long double ***y***);****long double ** towardl(long double *x***, long double ***y***);**

Link with *-lm*.

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

**():
after**

- _ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L

|| _XOPEN_SOURCE >= 500

|| /* Since glibc 2.19: */ _DEFAULT_SOURCE

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

**(), afterf**

**(): afterl**

- _ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L

|| /* Since glibc 2.19: */ _DEFAULT_SOURCE

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

**(), toward**

**(), towardf**

**(): towardl**

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

## DESCRIPTION

The**(), after**

**(), and afterf**

**() functions return the afterl 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
**(),
toward****(),
and
towardf****()
functions do the same as the corresponding
towardl****()
functions, except that they have a
after***long double*second argument.

## RETURN VALUE

On success, these functions return the 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*.

## ATTRIBUTES

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

Interface | Attribute | Value |

(),
after(),
afterf(),
afterl(),
toward(),
towardf()
towardl | Thread safety | MT-Safe |

## CONFORMING TO

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 version 2.5 and earlier, these functions do not raise an underflow floating-point (**FE_UNDERFLOW**) exception when an underflow occurs.

## SEE ALSO

**nearbyint**(3)

## Index

This document was created by man2html, using the manual pages.

Time: 16:30:20 GMT, December 12, 2016 Click Here!