| Common mathematical functions | |||||||||||||||||||||||||||||||
| Mathematical special functions(C++17) | |||||||||||||||||||||||||||||||
| Mathematical constants(C++20) | |||||||||||||||||||||||||||||||
| Basic linear algebra algorithms(C++26) | |||||||||||||||||||||||||||||||
| Data-parallel types (SIMD)(C++26) | |||||||||||||||||||||||||||||||
| Floating-point environment(C++11) | |||||||||||||||||||||||||||||||
| Complex numbers | |||||||||||||||||||||||||||||||
Numeric array (valarray) | |||||||||||||||||||||||||||||||
| Pseudo-random number generation | |||||||||||||||||||||||||||||||
| Bit manipulation(C++20) | |||||||||||||||||||||||||||||||
| Saturation arithmetic(C++26) | |||||||||||||||||||||||||||||||
| Factor operations | |||||||||||||||||||||||||||||||
|
| ||||||||||||||||||||||||||||||
| Interpolations | |||||||||||||||||||||||||||||||
|
| ||||||||||||||||||||||||||||||
| Generic numeric operations | |||||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||||
| C-style checked integer arithmetic | |||||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||||
| Nearest integer floating point operations | |||||||||||||||||||||||||||||||||||||||||
|
| ||||||||||||||||||||||||||||||||||||||||
| Floating point manipulation functions | |||||||||||||||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||||||||||||||
| Classification and comparison | |||||||||||||||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||||||||||||||
| Types | |||||||||||||||||||||||||||||||||||||||||
| Macro constants | |||||||||||||||||||||||||||||||||||||||||
|
| ||||||||||||||||||||||||||||||||||||||||
Defined in header <cmath> | ||
| (1) | ||
float nextafter(float from,float to); double nextafter(double from,double to); | (since C++11) (until C++23) | |
constexpr/* floating-point-type */ nextafter(/* floating-point-type */ from, | (since C++23) | |
float nextafterf(float from,float to); | (2) | (since C++11) (constexpr since C++23) |
longdouble nextafterl(longdouble from,longdouble to); | (3) | (since C++11) (constexpr since C++23) |
| (4) | ||
float nexttoward(float from,longdouble to); double nexttoward(double from,longdouble to); | (since C++11) (until C++23) | |
constexpr/* floating-point-type */ nexttoward(/* floating-point-type */ from, | (since C++23) | |
float nexttowardf(float from,longdouble to); | (5) | (since C++11) (constexpr since C++23) |
longdouble nexttowardl(longdouble from,longdouble to); | (6) | (since C++11) (constexpr since C++23) |
Defined in header <cmath> | ||
template<class Arithmetic1,class Arithmetic2> /* common-floating-point-type */ | (A) | (since C++11) (constexpr since C++23) |
template<class Integer> double nexttoward( Integer from,longdouble to); | (B) | (since C++11) (constexpr since C++23) |
Returns the next representable value offrom in the direction ofto.
std::nextafter for all cv-unqualified floating-point types as the type of the parametersfrom andto.(since C++23)The library provides overloads of | (since C++23) |
std::nextafter overloads are provided for all other combinations of arithmetic types.std::nexttoward overloads are provided for all integer types, which are treated asdouble.Contents |
| from, to | - | floating-point or integer values |
If no errors occur, the next representable value offrom in the direction ofto. is returned. Iffrom equalsto, thento is returned.
If a range error due to overflow occurs,±HUGE_VAL,±HUGE_VALF, or±HUGE_VALL is returned (with the same sign asfrom).
If a range error occurs due to underflow, the correct result is returned.
Errors are reported as specified inmath_errhandling.
If the implementation supports IEEE floating-point arithmetic (IEC 60559),
POSIX specifies that the overflow and the underflow conditions are range errors (errno may be set).
IEC 60559 recommends thatfrom is returned wheneverfrom== to. These functions returnto instead, which makes the behavior around zero consistent:std::nextafter(-0.0,+0.0) returns+0.0 andstd::nextafter(+0.0,-0.0) returns-0.0.
std::nextafter is typically implemented by manipulation of IEEE representation (glibc,musl).
The additional std::nextafter overloads are not required to be provided exactly as(A). They only need to be sufficient to ensure that for their first argumentnum1 and second argumentnum2:
| (until C++23) |
Ifnum1 andnum2 have arithmetic types, thenstd::nextafter(num1, num2) has the same effect asstd::nextafter(static_cast</*common-floating-point-type*/>(num1), If no such floating-point type with the greatest rank and subrank exists, thenoverload resolution does not result in a usable candidate from the overloads provided. | (since C++23) |
The additionalstd::nexttoward overloads are not required to be provided exactly as(B). They only need to be sufficient to ensure that for their argumentnum of integer type,std::nexttoward(num) has the same effect asstd::nexttoward(static_cast<double>(num)).
#include <cfenv>#include <cfloat>#include <cmath>#include <concepts>#include <iomanip>#include <iostream> int main(){float from1=0, to1= std::nextafter(from1,1.f);std::cout<<"The next representable float after "<<std::setprecision(20)<< from1<<" is "<< to1<<std::hexfloat<<" ("<< to1<<")\n"<<std::defaultfloat; float from2=1, to2= std::nextafter(from2,2.f);std::cout<<"The next representable float after "<< from2<<" is "<< to2<<std::hexfloat<<" ("<< to2<<")\n"<<std::defaultfloat; double from3= std::nextafter(0.1,0), to3=0.1;std::cout<<"The number 0.1 lies between two valid doubles:\n"<<std::setprecision(56)<<" "<< from3<<std::hexfloat<<" ("<< from3<<')'<<std::defaultfloat<<"\nand "<< to3<<std::hexfloat<<" ("<< to3<<")\n"<<std::defaultfloat<<std::setprecision(20); std::cout<<"\nDifference between nextafter and nexttoward:\n";longdouble dir= std::nextafter(from1, 1.0L);// first subnormal long doublefloat x= std::nextafter(from1, dir);// first converts dir to float, giving 0std::cout<<"With nextafter, next float after "<< from1<<" is "<< x<<'\n'; x= std::nexttoward(from1, dir);std::cout<<"With nexttoward, next float after "<< from1<<" is "<< x<<'\n'; std::cout<<"\nSpecial values:\n";{// #pragma STDC FENV_ACCESS ONstd::feclearexcept(FE_ALL_EXCEPT);double from4=DBL_MAX, to4= std::nextafter(from4,INFINITY);std::cout<<"The next representable double after "<<std::setprecision(6)<< from4<<std::hexfloat<<" ("<< from4<<')'<<std::defaultfloat<<" is "<< to4<<std::hexfloat<<" ("<< to4<<")\n"<<std::defaultfloat; if(std::fetestexcept(FE_OVERFLOW))std::cout<<" raised FE_OVERFLOW\n";if(std::fetestexcept(FE_INEXACT))std::cout<<" raised FE_INEXACT\n";}// end FENV_ACCESS block float from5=0.0, to5= std::nextafter(from5,-0.0);std::cout<<"std::nextafter(+0.0, -0.0) gives "<<std::fixed<< to5<<'\n'; auto precision_loss_demo=[]<std::floating_point Fp>(constauto rem,const Fp start){std::cout<< rem;for(Fp from= start, to, Δ;(Δ=(to= std::nextafter(from,+INFINITY))- from)< Fp(10.0); from*= Fp(10.0))std::cout<<"nextafter("<<std::scientific<<std::setprecision(0)<< from<<", INF) gives "<<std::fixed<<std::setprecision(6)<< to<<"; Δ = "<< Δ<<'\n';}; precision_loss_demo("\nPrecision loss demo for float:\n",10.0f); precision_loss_demo("\nPrecision loss demo for double:\n",10.0e9); precision_loss_demo("\nPrecision loss demo for long double:\n", 10.0e17L);}
Output:
The next representable float after 0 is 1.4012984643248170709e-45 (0x1p-149)The next representable float after 1 is 1.0000001192092895508 (0x1.000002p+0)The number 0.1 lies between two valid doubles: 0.09999999999999999167332731531132594682276248931884765625 (0x1.9999999999999p-4)and 0.1000000000000000055511151231257827021181583404541015625 (0x1.999999999999ap-4) Difference between nextafter and nexttoward:With nextafter, next float after 0 is 0With nexttoward, next float after 0 is 1.4012984643248170709e-45 Special values:The next representable double after 1.79769e+308 (0x1.fffffffffffffp+1023) is inf (inf) raised FE_OVERFLOW raised FE_INEXACTstd::nextafter(+0.0, -0.0) gives -0.000000 Precision loss demo for float:nextafter(1e+01, INF) gives 10.000001; Δ = 0.000001nextafter(1e+02, INF) gives 100.000008; Δ = 0.000008nextafter(1e+03, INF) gives 1000.000061; Δ = 0.000061nextafter(1e+04, INF) gives 10000.000977; Δ = 0.000977nextafter(1e+05, INF) gives 100000.007812; Δ = 0.007812nextafter(1e+06, INF) gives 1000000.062500; Δ = 0.062500nextafter(1e+07, INF) gives 10000001.000000; Δ = 1.000000nextafter(1e+08, INF) gives 100000008.000000; Δ = 8.000000 Precision loss demo for double:nextafter(1e+10, INF) gives 10000000000.000002; Δ = 0.000002nextafter(1e+11, INF) gives 100000000000.000015; Δ = 0.000015nextafter(1e+12, INF) gives 1000000000000.000122; Δ = 0.000122nextafter(1e+13, INF) gives 10000000000000.001953; Δ = 0.001953nextafter(1e+14, INF) gives 100000000000000.015625; Δ = 0.015625nextafter(1e+15, INF) gives 1000000000000000.125000; Δ = 0.125000nextafter(1e+16, INF) gives 10000000000000002.000000; Δ = 2.000000 Precision loss demo for long double:nextafter(1e+18, INF) gives 1000000000000000000.062500; Δ = 0.062500nextafter(1e+19, INF) gives 10000000000000000001.000000; Δ = 1.000000nextafter(1e+20, INF) gives 100000000000000000008.000000; Δ = 8.000000
C documentation fornextafter |
