std::nextafter, std::nexttoward - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::nextafter, std::nexttoward

From cppreference.com
< cpp‎ | numeric‎ | math

Defined in header `<cmath>` |  |
float nextafter( float from, float to ); | (1) | (since C++11)
double nextafter( double from, double to ); | (2) | (since C++11)
long double nextafter( long double from, long double to ); | (3) | (since C++11)
Promoted nextafter( Arithmetic from, Arithmetic to ); | (4) | (since C++11)
float nexttoward( float from, long double to ); | (5) | (since C++11)
double nexttoward( double from, long double to ); | (6) | (since C++11)
long double nexttoward( long double from, long double to ); | (7) | (since C++11)
double nexttoward( Integral from, long double to ); | (8) | (since C++11)

Returns the next representable value of `from` in the direction of `to`. If `from` equals to `to`, `to` is returned.

1-3) If `from` equals to `to`, `to` is returned.
5-7) If `from` equals to `to`, `to` is returned, converted from long double to the return type of the function without loss of range or precision.
4,8) If any argument has integral type, it is cast to double. If any other argument is long double, then the return type is long double, otherwise it is double

If `from` is finite, but the result of `nextafter` or `nexttoward` is infinite, range error occurs and FE_OVERFLOW and FE_INEXACT may be raised.

If the result is subnormal or zero and `from != to`, raises FE_UNDERFLOW and FE_INEXACT.

In any case, the returned value is independent of the current rounding mode.

### [edit] Parameters

from, to | - | floating point values

### [edit] Return value

the next representable value of `from` in the direction of `to`.

### [edit] Example

Run this code

    #include <cmath>
    #include <iostream>
    #include <iomanip>

    int main()
    {
        std::cout << "0.1 lies between the doubles " << std::setprecision(100) << '\n'
                  << 0.1 << '\n' << " and\n"
                  << std::nextafter(0.1, 0) << '\n';
    }

Output:

    0.1 lies between the doubles
    0.1000000000000000055511151231257827021181583404541015625
     and
    0.09999999999999999167332731531132594682276248931884765625

### [edit] See also

C documentation for nextafter

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/numeric/math/nextafter&oldid=69253"