std::modf, std::modff, std::modfl
| Definiert in der Header-Datei <cmath> |
||
| (1) | ||
float modf ( float num, float* iptr ); double modf ( double num, double* iptr ); |
(bis C++23) | |
| constexpr /* gleitkommazahl-Typ */ modf ( /* Gleitkommatyp */ num, |
(seit C++23) | |
| float modff( float num, float* iptr ); |
(2) | (seit C++11) (constexpr seit C++23) |
| long double modfl( long double num, long double* iptr ); |
(3) | (seit C++11) (constexpr seit C++23) |
| Zusätzliche Überladungen (seit C++11) |
||
| Definiert in der Header-Datei <cmath> |
||
| template< class Integer > double modf ( Integer num, double* iptr ); |
(A) | (constexpr seit C++23) |
std::modf für alle cv-unqualifizierten Gleitkommatypen als Typ des Parameters num und des Typs, auf den iptr zeigt, zur Verfügung.(seit C++23)|
A) Zusätzliche Überladungen werden für alle ganzzahligen Typen bereitgestellt, die als double behandelt werden.
|
(seit C++11) |
Inhalt |
[edit] Parameter
| num | - | Gleitkomma- oder Ganzzahlwert |
| iptr | - | Zeiger auf den Gleitkommawert, in dem der Ganzzahlteil gespeichert werden soll |
[edit] Rückgabewert
Wenn keine Fehler auftreten, wird der Nachkommateil von num mit demselben Vorzeichen wie num zurückgegeben. Der Ganzzahlteil wird in den Wert geschrieben, auf den iptr zeigt.
Die Summe aus dem zurückgegebenen Wert und dem Wert, der in *iptr gespeichert ist, ergibt num (unter Berücksichtigung von Rundungen).
[edit] Fehlerbehandlung
Diese Funktion unterliegt keinen Fehlern, die in math_errhandling spezifiziert sind.
Wenn die Implementierung IEEE-Gleitkomma-Arithmetik (IEC 60559) unterstützt,
- Wenn num ±0 ist, wird ±0 zurückgegeben und ±0 wird in *iptr gespeichert.
- Wenn num ±∞ ist, wird ±0 zurückgegeben und ±∞ wird in *iptr gespeichert.
- Wenn num NaN ist, wird NaN zurückgegeben und NaN wird in *iptr gespeichert.
- Der zurückgegebene Wert ist exakt, der aktuelle Rundungsmodus wird ignoriert.
[edit] Hinweise
Diese Funktion verhält sich so, als ob sie wie folgt implementiert wäre:
double modf(double num, double* iptr) { #pragma STDC FENV_ACCESS ON int save_round = std::fegetround(); std::fesetround(FE_TOWARDZERO); *iptr = std::nearbyint(num); std::fesetround(save_round); return std::copysign(std::isinf(num) ? 0.0 : num - (*iptr), num); }
Die zusätzlichen Überladungen müssen nicht exakt wie in (A) angegeben bereitgestellt werden. Sie müssen nur ausreichen, um sicherzustellen, dass für ihr Argument num vom Ganzzahltyp, std::modf(num, iptr) die gleiche Wirkung hat wie std::modf(static_cast<double>(num), iptr).
[edit] Beispiel
Vergleicht verschiedene Gleitkomma-Zerlegungsfunktionen
#include <cmath> #include <iostream> #include <limits> int main() { double f = 123.45; std::cout << "Given the number " << f << " or " << std::hexfloat << f << std::defaultfloat << " in hex,\n"; double f3; double f2 = std::modf(f, &f3); std::cout << "modf() makes " << f3 << " + " << f2 << '\n'; int i; f2 = std::frexp(f, &i); std::cout << "frexp() makes " << f2 << " * 2^" << i << '\n'; i = std::ilogb(f); std::cout << "logb()/ilogb() make " << f / std::scalbn(1.0, i) << " * " << std::numeric_limits<double>::radix << "^" << std::ilogb(f) << '\n'; // special values f2 = std::modf(-0.0, &f3); std::cout << "modf(-0) makes " << f3 << " + " << f2 << '\n'; f2 = std::modf(-INFINITY, &f3); std::cout << "modf(-Inf) makes " << f3 << " + " << f2 << '\n'; }
Mögliche Ausgabe
Given the number 123.45 or 0x1.edccccccccccdp+6 in hex, modf() makes 123 + 0.45 frexp() makes 0.964453 * 2^7 logb()/ilogb() make 1.92891 * 2^6 modf(-0) makes -0 + -0 modf(-Inf) makes -INF + -0
[edit] Siehe auch
| (C++11)(C++11)(C++11) |
nächste ganze Zahl, die nicht größer im Betrag ist als der gegebene Wert (Funktion) |
| C-Dokumentation für modf
| |
