Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      nextafter, nextafterf, nextafterl, nexttoward, nexttowardf, nexttowardl

      From cppreference.com
      <c‎ |numeric‎ |math
       
       
       
      Common mathematical functions
      Functions
      Basic operations
      (C99)
      (C99)
      (C99)
      (C99)(C99)(C99)(C23)
      Maximum/minimum operations
      (C99)
      (C99)
      Exponential functions
      (C23)
      (C99)
      (C99)
      (C23)
      (C23)

      (C99)
      (C99)(C23)
      (C23)
      (C23)
      Power functions
      (C99)
      (C23)
      (C23)

      (C99)
      (C23)
      (C23)
      Trigonometric and hyperbolic functions
      (C23)
      (C23)
      (C23)
      (C23)
      (C99)
      (C99)
      (C99)
      Nearest integer floating-point
      (C99)(C99)(C99)
      (C23)(C23)(C23)(C23)
      Floating-point manipulation
      (C99)(C99)
      (C99)(C23)
      (C99)
      nextafternexttoward
      (C99)(C99)
      (C23)(C23)
      Narrowing operations
      (C23)
      (C23)
      (C23)
      (C23)
      (C23)
      (C23)
      Quantum and quantum exponent
      Decimal re-encoding functions
      Total order and payload functions
      Classification
      Error and gamma functions
      (C99)
      (C99)
      (C99)
      (C99)
      Types
      Macro constants
      Special floating-point values
      (C99)(C23)
      Arguments and return values
      Error handling
      Fast operation indicators
       
      Defined in header<math.h>
      float       nextafterf(float from,float to);
      (1)(since C99)
      double      nextafter(double from,double to);
      (2)(since C99)
      longdouble nextafterl(longdouble from,longdouble to);
      (3)(since C99)
      float       nexttowardf(float from,longdouble to);
      (4)(since C99)
      double      nexttoward(double from,longdouble to);
      (5)(since C99)
      longdouble nexttowardl(longdouble from,longdouble to);
      (6)(since C99)
      Defined in header<tgmath.h>
      #define nextafter(from, to)
      (7)(since C99)
      #define nexttoward(from, to)
      (8)(since C99)
      1-3) First, converts both arguments to the type of the function, then returns the next representable value offrom in the direction ofto. Iffrom equals toto,to is returned.
      4-6) First, converts the first argument to the type of the function, then returns the next representable value offrom in the direction ofto. Iffrom equals toto,to is returned, converted fromlongdouble to the return type of the function without loss of range or precision.
      7) Type-generic macro: If any argument has typelongdouble,nextafterl is called. Otherwise, if any argument has integer type or has typedouble,nextafter is called. Otherwise,nextafterf is called.
      8) Type-generic macro: If the argumentfrom has typelongdouble,nexttowardl is called. Otherwise, iffrom has integer type or the typedouble,nexttoward is called. Otherwise,nexttowardf is called.

      Contents

      [edit]Parameters

      from, to - floating-point values

      [edit]Return value

      If no errors occur, the next representable value offrom in the direction ofto. is returned. Iffrom equalsto, thento is returned, converted to the type of the function.

      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.

      [edit]Error handling

      Errors are reported as specified inmath_errhandling.

      If the implementation supports IEEE floating-point arithmetic (IEC 60559),

      • iffrom is finite, but the expected result is an infinity, raisesFE_INEXACT andFE_OVERFLOW.
      • iffrom does not equalto and the result is subnormal or zero, raisesFE_INEXACT andFE_UNDERFLOW.
      • in any case, the returned value is independent of the current rounding mode
      • if eitherfrom orto is NaN, NaN is returned.

      [edit]Notes

      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:nextafter(-0.0, +0.0) returns+0.0 andnextafter(+0.0, -0.0) returns-0.0.

      nextafter is typically implemented by manipulation of IEEE representation (glibcmusl).

      [edit]Example

      Run this code
      #include <fenv.h>#include <float.h>#include <math.h>#include <stdio.h> int main(void){float from1=0, to1= nextafterf(from1,1);printf("The next representable float after %.2f is %.20g (%a)\n", from1, to1, to1); float from2=1, to2= nextafterf(from2,2);printf("The next representable float after %.2f is %.20f (%a)\n", from2, to2, to2); double from3= nextafter(0.1,0), to3=0.1;printf("The number 0.1 lies between two valid doubles:\n""    %.56f (%a)\nand %.55f  (%a)\n", from3, from3, to3, to3); // difference between nextafter and nexttoward:longdouble dir= nextafterl(from1,1);// first subnormal long doublefloat x= nextafterf(from1, dir);// first converts dir to float, giving 0printf("Using nextafter, next float after %.2f (%a) is %.20g (%a)\n",           from1, from1, x, x);    x= nexttowardf(from1, dir);printf("Using nexttoward, next float after %.2f (%a) is %.20g (%a)\n",           from1, from1, x, x); // special values{#pragma STDC FENV_ACCESS ONfeclearexcept(FE_ALL_EXCEPT);double from4=DBL_MAX, to4= nextafter(from4, INFINITY);printf("The next representable double after %.2g (%a) is %.23f (%a)\n",               from4, from4, to4, to4);if(fetestexcept(FE_OVERFLOW))puts("   raised FE_OVERFLOW");if(fetestexcept(FE_INEXACT))puts("   raised FE_INEXACT");}// end FENV_ACCESS block float from5=0.0, to5= nextafter(from5,-0.0);printf("nextafter(+0.0, -0.0) gives %.2g (%a)\n", to5, to5);}

      Output:

      The next representable float after 0.00 is 1.4012984643248170709e-45 (0x1p-149)The next representable float after 1.00 is 1.00000011920928955078 (0x1.000002p+0)The number 0.1 lies between two valid doubles:    0.09999999999999999167332731531132594682276248931884765625 (0x1.9999999999999p-4)and 0.1000000000000000055511151231257827021181583404541015625  (0x1.999999999999ap-4)Using nextafter, next float after 0.00 (0x0p+0) is 0 (0x0p+0)Using nexttoward, next float after 0.00 (0x0p+0) is 1.4012984643248170709e-45 (0x1p-149)The next representable double after 1.8e+308 (0x1.fffffffffffffp+1023) is inf (inf)   raised FE_OVERFLOW   raised FE_INEXACTnextafter(+0.0, -0.0) gives -0 (-0x0p+0)

      [edit]References

      • C23 standard (ISO/IEC 9899:2024):
      • 7.12.11.3 The nextafter functions (p: TBD)
      • 7.12.11.4 The nexttoward functions (p: TBD)
      • 7.25 Type-generic math <tgmath.h> (p: TBD)
      • F.10.8.3 The nextafter functions (p: TBD)
      • F.10.8.4 The nexttoward functions (p: TBD)
      • C17 standard (ISO/IEC 9899:2018):
      • 7.12.11.3 The nextafter functions (p: 187)
      • 7.12.11.4 The nexttoward functions (p: 187)
      • 7.25 Type-generic math <tgmath.h> (p: 272-273)
      • F.10.8.3 The nextafter functions (p: 386)
      • F.10.8.4 The nexttoward functions (p: 386)
      • C11 standard (ISO/IEC 9899:2011):
      • 7.12.11.3 The nextafter functions (p: 256)
      • 7.12.11.4 The nexttoward functions (p: 257)
      • 7.25 Type-generic math <tgmath.h> (p: 373-375)
      • F.10.8.3 The nextafter functions (p: 529)
      • F.10.8.4 The nexttoward functions (p: 529)
      • C99 standard (ISO/IEC 9899:1999):
      • 7.12.11.3 The nextafter functions (p: 237)
      • 7.12.11.4 The nexttoward functions (p: 238)
      • 7.22 Type-generic math <tgmath.h> (p: 335-337)
      • F.9.8.3 The nextafter functions (p: 466)
      • F.9.8.4 The nexttoward functions (p: 466)

      [edit]See also

      C++ documentation fornextafter
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=c/numeric/math/nextafter&oldid=172054"

      [8]ページ先頭

      ©2009-2025 Movatter.jp