Namespaces
Variants

std:: scalbn, std:: scalbnf, std:: scalbnl, std:: scalbln, std:: scalblnf, std:: scalblnl

From cppreference.net
C++
Numerics library
Common mathematical functions
Nearest integer floating point operations
(C++11)
(C++11)
(C++11) (C++11) (C++11)
Floating point manipulation functions
scalbn scalbln
(C++11) (C++11)
(C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Definiert im Header <cmath>
int exponent
(1)
float scalbn ( float num, int exp ) ;

double scalbn ( double num, int exp ) ;

long double scalbn ( long double num, int exp ) ;
(seit C++11)
(bis C++23)
constexpr /* Gleitkommatyp */
scalbn ( /* Gleitkommatyp */ 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 ) ;

long double scalbln ( long double num, long exp ) ;
(seit C++11)
(bis C++23)
constexpr /* floating-point-type */
scalbln ( /* floating-point-type */ 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 im Header <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)
1-6) Multipliziert einen Fließkommawert num mit FLT_RADIX hoch exp . Die Bibliothek stellt Überladungen von std::scalbn und std::scalbln für alle cv-unqualifizierten Fließkommatypen als Typ des Parameters num bereit. (seit C++23)
A,B) Zusätzliche Überladungen werden für alle Ganzzahltypen bereitgestellt, die als double behandelt werden.

Inhaltsverzeichnis

Parameter

num - Fließkomma- oder Ganzzahlwert
exp - Ganzzahlwert

Rückgabewert

Wenn keine Fehler auftreten, num multipliziert mit FLT_RADIX hoch exp ( num×FLT_RADIX exp
) zurückgegeben.

Wenn ein Bereichsfehler aufgrund von Überlaufs auftritt, ±HUGE_VAL , ±HUGE_VALF , oder ±HUGE_VALL wird zurückgegeben.

Wenn ein Bereichsfehler aufgrund von Unterlauf auftritt, wird das korrekte Ergebnis (nach Rundung) zurückgegeben.

Fehlerbehandlung

Fehler werden gemeldet, wie in math_errhandling spezifiziert.

Wenn die Implementierung IEEE-Gleitkommaarithmetik (IEC 60559) unterstützt,

  • Sofern kein Bereichsfehler auftritt, FE_INEXACT wird niemals ausgelöst (das Ergebnis ist exakt).
  • Sofern kein Bereichsfehler auftritt, der aktuelle Rundungsmodus wird 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.

Hinweise

Auf binären Systemen (wo FLT_RADIX gleich 2 ist), ist std::scalbn äquivalent zu std::ldexp .

Obwohl std::scalbn und std::scalbln spezifiziert sind, um die Operation effizient durchzuführen, sind sie in vielen Implementierungen weniger effizient als Multiplikation oder Division mit einer Zweierpotenz unter Verwendung arithmetischer Operatoren.

Der Funktionsname steht für "new scalb", wobei scalb eine ältere nicht-standardisierte Funktion war, deren zweites Argument einen Fließkommatyp hatte.

Die std::scalbln -Funktion wird bereitgestellt, weil der erforderliche Faktor zur Skalierung vom kleinsten positiven Gleitkommawert zum größten endlichen Wert größer als 32767 sein kann, der standardmäßig garantierte INT_MAX -Wert. Insbesondere für den 80-Bit- long double beträgt der Faktor 32828.

Die GNU-Implementierung setzt errno unabhängig von math_errhandling nicht.

Die zusätzlichen Überladungen müssen nicht exakt als (A,B) bereitgestellt werden. Sie müssen lediglich ausreichen, um sicherzustellen, dass für ihr Argument num vom Ganzzahltyp:

  • std :: scalbn ( num, exp ) hat denselben Effekt wie std :: scalbn ( static_cast < double > ( num ) , exp ) .
  • std :: scalbln ( num, exp ) hat denselben Effekt wie std :: scalbln ( static_cast < double > ( num ) , exp ) .

Beispiel

Diesen Code ausführen 
#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)
              << " (kleinste positive subnormale Double-Zahl)\n"
              << "scalbn(nextafter(1,0), 1024) = "
              << std::scalbn(std::nextafter(1,0), 1024)
              << " (größte endliche Double-Zahl)\n";
    // spezielle Werte
    std::cout << "scalbn(-0, 10) = " << std::scalbn(-0.0, 10) << '\n'
              << "scalbn(-Inf, -1) = " << std::scalbn(-INFINITY, -1) << '\n';
    // Fehlerbehandlung
    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 ausgelöst\n";
}

Mögliche Ausgabe: 

scalbn(7, -4) = 0.4375
scalbn(1, -1074) = 4.94066e-324 (kleinste positive subnormale Double-Zahl)
scalbn(nextafter(1,0), 1024) = 1.79769e+308 (größte endliche Double-Zahl)
scalbn(-0, 10) = -0
scalbn(-Inf, -1) = -inf
scalbn(1, 1024) = inf
    errno == ERANGE: Numerisches Ergebnis außerhalb des gültigen Bereichs
    FE_OVERFLOW ausgelöst

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 potenziert mit einer ganzzahligen Potenz
(Funktion)
C-Dokumentation für scalbn