nextafter, nextafterf, nextafterl, nexttoward, nexttowardf, nexttowardl
Von cppreference.com
| Definiert in Header <math.h> |
||
| float nextafterf( float from, float to ); |
(1) | (seit C99) |
| double nextafter( double from, double to ); |
(2) | (seit C99) |
| long double nextafterl( long double from, long double to ); |
(3) | (seit C99) |
| float nexttowardf( float from, long double to ); |
(4) | (seit C99) |
| double nexttoward( double from, long double to ); |
(5) | (seit C99) |
| long double nexttowardl( long double from, long double to ); |
(6) | (seit C99) |
| Definiert in Header <tgmath.h> |
||
| #define nextafter(from, to) |
(7) | (seit C99) |
| #define nexttoward(from, to) |
(8) | (seit C99) |
1-3) Zuerst werden beide Argumente in den Typ der Funktion konvertiert, dann wird der nächst darstellbare Wert von from in Richtung von to zurückgegeben. Wenn from gleich to ist, wird to zurückgegeben.
4-6) Zuerst wird das erste Argument in den Typ der Funktion konvertiert, dann wird der nächst darstellbare Wert von from in Richtung von to zurückgegeben. Wenn from gleich to ist, wird to zurückgegeben, konvertiert von long double in den Rückgabetyp der Funktion ohne Verlust von Wertebereich oder Genauigkeit.
7) Typ-generische Makro: Wenn ein Argument vom Typ long double ist, wird
nextafterl aufgerufen. Andernfalls, wenn ein Argument vom ganzzahligen Typ oder vom Typ double ist, wird nextafter aufgerufen. Andernfalls wird nextafterf aufgerufen.8) Typ-generische Makro: Wenn das Argument from vom Typ long double ist, wird
nexttowardl aufgerufen. Andernfalls, wenn from vom ganzzahligen Typ oder vom Typ double ist, wird nexttoward aufgerufen. Andernfalls wird nexttowardf aufgerufen.Inhalt |
[edit] Parameter
| from, to | - | Gleitkommazahlen |
[edit] Rückgabewert
Wenn keine Fehler auftreten, wird der nächst darstellbare Wert von from in Richtung von to zurückgegeben. Wenn from gleich to ist, wird to zurückgegeben, konvertiert in den Typ der Funktion.
Wenn ein Bereichsfehler aufgrund von Überlauf auftritt, wird ±HUGE_VAL, ±HUGE_VALF oder ±HUGE_VALL zurückgegeben (mit demselben Vorzeichen wie from).
Wenn ein Bereichsfehler aufgrund von Unterlauf auftritt, wird das korrekte Ergebnis zurückgegeben.
[edit] Fehlerbehandlung
Fehler werden wie in math_errhandling angegeben gemeldet.
Wenn die Implementierung IEEE-Gleitkomma-Arithmetik (IEC 60559) unterstützt,
- Wenn from endlich ist, das erwartete Ergebnis aber eine Unendlichkeit ist, werden FE_INEXACT und FE_OVERFLOW ausgelöst.
- Wenn from nicht gleich
toist und das Ergebnis subnormal oder Null ist, werden FE_INEXACT und FE_UNDERFLOW ausgelöst. - in jedem Fall ist der zurückgegebene Wert unabhängig vom aktuellen Rundungsmodus
- Wenn from oder
toNaN ist, wird NaN zurückgegeben.
[edit] Hinweise
POSIX spezifiziert, dass die Überlauf- und Unterlaufbedingungen Bereichsfehler sind (errno kann gesetzt werden).
IEC 60559 empfiehlt, dass from zurückgegeben wird, wenn from == to ist. Diese Funktionen geben stattdessen to zurück, was das Verhalten um Null konsistent macht: nextafter(-0.0, +0.0) gibt +0.0 zurück und nextafter(+0.0, -0.0) gibt -0.0 zurück.
nextafter wird typischerweise durch Manipulation der IEEE-Darstellung implementiert (glibc musl).
[edit] Beispiel
Führen Sie diesen Code aus
#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: 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); }
Ausgabe
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)[edit] Referenzen
- 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 Typ-generische Mathematik <tgmath.h> (S. 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 Typ-generische Mathematik <tgmath.h> (S. 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 Typ-generische Mathematik <tgmath.h> (S. 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 Typ-generische Mathematik <tgmath.h> (S. 335-337)
- F.9.8.3 The nextafter functions (p: 466)
- F.9.8.4 The nexttoward functions (p: 466)
[edit] Siehe auch
| C++-Dokumentation für nextafter
|
