std::scalbn, std::scalbnf, std::scalbnl, std::scalbln, std::scalblnf, std::scalblnl
| Definiert in der Header-Datei <cmath> |
||
| int exponent |
||
| (1) | ||
float scalbn ( float num, int exp ); double scalbn ( double num, int exp ); |
(seit C++11) (bis C++23) |
|
| constexpr /* gleitkommazahl-Typ */ scalbn ( /* Gleitkomma-Typ */ num, int exp ); |
(seit C++23) | |
| float scalbnf( float num, int exp ); |
(2) | (seit C++11) (constexpr seit C++23) |
| long double scalbnl( long double num, int exp ); |
(3) | (seit C++11) (constexpr seit C++23) |
| long exponent |
||
| (4) | ||
float scalbln ( float num, long exp ); double scalbln ( double num, long exp ); |
(seit C++11) (bis C++23) |
|
| constexpr /* gleitkommazahl-Typ */ scalbln ( /* Gleitkomma-Typ */ num, long exp ); |
(seit C++23) | |
| float scalblnf( float num, long exp ); |
(5) | (seit C++11) (constexpr seit C++23) |
| long double scalblnl( long double num, long exp ); |
(6) | (seit C++11) (constexpr seit C++23) |
| Definiert in der Header-Datei <cmath> |
||
| template< class Integer > double scalbn( Integer num, int exp ); |
(A) | (seit C++11) (constexpr seit C++23) |
| template< class Integer > double scalbln( Integer num, long exp ); |
(B) | (seit C++11) (constexpr seit C++23) |
std::scalbn und std::scalbln für alle cv-unqualifizierten Gleitkommatypen als Typ des Parameters num bereit.(seit C++23)Inhalt |
[edit] Parameter
| num | - | Gleitkomma- oder Ganzzahlwert |
| exp | - | ganzzahliger Wert |
[edit] Rückgabewert
Wenn keine Fehler auftreten, wird num multipliziert mit FLT_RADIX zur Potenz von exp (num×FLT_RADIXexp
) zurückgegeben.
Wenn ein Bereichsfehler aufgrund von Überlauf auftritt, wird ±HUGE_VAL, ±HUGE_VALF oder ±HUGE_VALL zurückgegeben.
Wenn ein Bereichsfehler aufgrund von Unterlauf auftritt, wird das korrekte Ergebnis (nach Rundung) zurückgegeben.
[edit] Fehlerbehandlung
Fehler werden wie in math_errhandling beschrieben gemeldet.
Wenn die Implementierung IEEE-Gleitkomma-Arithmetik (IEC 60559) unterstützt,
- Sofern kein Bereichsfehler auftritt, wird FE_INEXACT niemals ausgelöst (das Ergebnis ist exakt).
- Sofern kein Bereichsfehler auftritt, wird der aktuelle Rundungsmodus ignoriert.
- Wenn num ±0 ist, wird es unverändert zurückgegeben.
- Wenn num ±∞ ist, wird es unverändert zurückgegeben.
- Wenn exp 0 ist, dann wird num unverändert zurückgegeben.
- Wenn num NaN ist, wird NaN zurückgegeben.
[edit] Hinweise
Auf binären Systemen (bei denen FLT_RADIX 2 ist), ist std::scalbn äquivalent zu std::ldexp.
Obwohl std::scalbn und std::scalbln so spezifiziert sind, dass sie die Operation effizient durchführen, sind sie auf vielen Implementierungen weniger effizient als Multiplikation oder Division mit einer Zweierpotenz mittels arithmetischer Operatoren.
Der Funktionsname steht für "new scalb", wobei scalb eine ältere, nicht-standardmäßige Funktion war, deren zweites Argument einen Gleitkommatyp hatte.
Die Funktion std::scalbln wird bereitgestellt, da der Faktor, der zur Skalierung vom kleinsten positiven Gleitkommawert zum größten endlichen benötigt wird, größer als 32767 sein kann, dem standardmäßig garantierten INT_MAX. Insbesondere für die 80-Bit long double beträgt der Faktor 32828.
Die GNU-Implementierung setzt unabhängig von math_errhandling errno nicht.
Die zusätzlichen Überladungen müssen nicht exakt wie in (A,B) angegeben bereitgestellt werden. Sie müssen nur ausreichen, um sicherzustellen, dass für ihr Argument num vom ganzzahligen Typ
- std::scalbn(num, exp) denselben Effekt hat wie std::scalbn(static_cast<double>(num), exp).
- std::scalbln(num, exp) hat denselben Effekt wie std::scalbln(static_cast<double>(num), exp).
[edit] Beispiel
#include <cerrno> #include <cfenv> #include <cmath> #include <cstring> #include <iostream> // #pragma STDC FENV_ACCESS ON int main() { std::cout << "scalbn(7, -4) = " << std::scalbn(7, -4) << '\n' << "scalbn(1, -1074) = " << std::scalbn(1, -1074) << " (minimum positive subnormal double)\n" << "scalbn(nextafter(1,0), 1024) = " << std::scalbn(std::nextafter(1,0), 1024) << " (largest finite double)\n"; // special values std::cout << "scalbn(-0, 10) = " << std::scalbn(-0.0, 10) << '\n' << "scalbn(-Inf, -1) = " << std::scalbn(-INFINITY, -1) << '\n'; // error handling errno = 0; std::feclearexcept(FE_ALL_EXCEPT); std::cout << "scalbn(1, 1024) = " << std::scalbn(1, 1024) << '\n'; if (errno == ERANGE) std::cout << " errno == ERANGE: " << std::strerror(errno) << '\n'; if (std::fetestexcept(FE_OVERFLOW)) std::cout << " FE_OVERFLOW raised\n"; }
Mögliche Ausgabe
scalbn(7, -4) = 0.4375
scalbn(1, -1074) = 4.94066e-324 (minimum positive subnormal double)
scalbn(nextafter(1,0), 1024) = 1.79769e+308 (largest finite double)
scalbn(-0, 10) = -0
scalbn(-Inf, -1) = -inf
scalbn(1, 1024) = inf
errno == ERANGE: Numerical result out of range
FE_OVERFLOW raised[edit] Siehe auch
| (C++11)(C++11) |
zerlegt eine Zahl in Signifikand und Basis-2-Exponent (Funktion) |
| (C++11)(C++11) |
multipliziert eine Zahl mit 2 hoch einer ganzzahligen Potenz (Funktion) |
| C-Dokumentation für scalbn
| |
