Defined in header `<math.h>` | ||
---|---|---|

float nextafterf( float from, float to ); | (1) | (since C99) |

double nextafter( double from, double to ); | (2) | (since C99) |

long double nextafterl( long double from, long double to ); | (3) | (since C99) |

float nexttowardf( float from, long double to ); | (4) | (since C99) |

double nexttoward( double from, long double to ); | (5) | (since C99) |

long double nexttowardl( long double from, long double 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 of

`from`

in the direction of `to`

. If `from`

equals to `to`

, `to`

is returned.
4-6) First, converts the first argument to the type of the function, then returns the next representable value of

`from`

in the direction of `to`

. 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.
7) Type-generic macro: If any argument has type

`long double`

, `nextafterl`

is called. Otherwise, if any argument has integer type or has type `double`

, `nextafter`

is called. Otherwise, `nextafterf`

is called.
8) Type-generic macro: If the argument

`from`

has type `long double`

, `nexttowardl`

is called. Otherwise, if `from`

has integer type or the type `double`

, `nexttoward`

is called. Otherwise, `nexttowardf`

is called.from, to | - | floating point values |

If no errors occur, the next representable value of `from`

in the direction of `to`

. is returned. If `from`

equals `to`

, then `to`

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 as `from`

).

If a range error occurs due to underflow, the correct result is returned.

Errors are reported as specified in math_errhandling.

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

- if
`from`

is finite, but the expected result is an infinity, raises`FE_INEXACT`

and`FE_OVERFLOW`

- if
`from`

does not equal`to`

and the result is subnormal or zero, raises`FE_INEXACT`

and`FE_UNDERFLOW`

- in any case, the returned value is independent of the current rounding mode
- if either
`from`

or`to`

is NaN, NaN is returned

POSIX specifies that the overflow and the underflow conditions are range errors (errno may be set).

IEC 60559 recommends that `from`

is returned whenever `from==to`

. These functions return `to`

instead, which makes the behavior around zero consistent: `nextafter(-0.0, +0.0)`

returns `+0.0`

and `nextafter(+0.0, -0.0)`

returns `–0.0`

.

#include <math.h> #include <stdio.h> #include <float.h> #include <fenv.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: long double dir = nextafterl(from1, 1); // first subnormal long double float x = nextafterf(from1, dir); // first converts dir to float, giving 0 printf("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 ON feclearexcept(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_INEXACT nextafter(+0.0, -0.0) gives -0 (-0x0p+0)

- 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)

© cppreference.com

Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.

http://en.cppreference.com/w/c/numeric/math/nexttoward