Namespaces
Variants

std:: ldexp, std:: ldexpf, std:: ldexpl

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
ldexp
(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>
(1)
float ldexp ( float num, int exp ) ;

double ldexp ( double num, int exp ) ;

long double ldexp ( long double num, int exp ) ;
(bis C++23)
constexpr /* floating-point-type */
ldexp ( /* floating-point-type */ num, int exp ) ;
(seit C++23)
float ldexpf ( float num, int exp ) ;
(2) (seit C++11)
(constexpr seit C++23)
long double ldexpl ( long double num, int exp ) ;
(3) (seit C++11)
(constexpr seit C++23)
Definiert im Header <cmath>
template < class Integer >
double ldexp ( Integer num, int exp ) ;
(A) (seit C++11)
(constexpr seit C++23)
1-3) Multipliziert einen Gleitkommawert num mit der Zahl 2 hoch exp . Die Bibliothek stellt Überladungen von std::ldexp für alle cv-unqualifizierten Gleitkommatypen als Typ des Parameters num bereit. (since C++23)
A) Zusätzliche Überladungen werden für alle Ganzzahltypen bereitgestellt, die als double behandelt werden.
(since C++11)

Inhaltsverzeichnis

Parameter

num - Gleitkomma- oder Ganzzahlwert
exp - Ganzzahlwert

Rückgabewert

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

Wenn ein Bereichsfehler aufgrund von Überlauf 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), entspricht std::ldexp der Funktion std::scalbn .

Die Funktion std::ldexp ("Lade Exponent"), zusammen mit ihrem Gegenstück, std::frexp , kann verwendet werden, um die Darstellung einer Fließkommazahl zu manipulieren, ohne direkte Bit-Manipulationen durchzuführen.

In vielen Implementierungen ist std::ldexp weniger effizient als Multiplikation oder Division mit einer Zweierpotenz durch arithmetische Operatoren.

Die zusätzlichen Überladungen müssen nicht exakt wie (A) bereitgestellt werden. Sie müssen lediglich sicherstellen, dass für ihr Argument num vom Ganzzahltyp std :: ldexp ( num, exp ) die gleiche Wirkung hat wie std :: ldexp ( static_cast < double > ( num ) , exp ) .

Für die Potenzierung von 2 mit einem Gleitkommaexponenten kann std::exp2 verwendet werden.

Beispiel

Diesen Code ausführen 
#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    std::cout
        << "ldexp(5, 3) = 5 * 8 = " << std::ldexp(5, 3) << '\n'
        << "ldexp(7, -4) = 7 / 16 = " << std::ldexp(7, -4) << '\n'
        << "ldexp(1, -1074) = " << std::ldexp(1, -1074)
        << " (minimum positive subnormal float64_t)\n"
        << "ldexp(nextafter(1,0), 1024) = "
        << std::ldexp(std::nextafter(1,0), 1024)
        << " (largest finite float64_t)\n";
    // special values
    std::cout << "ldexp(-0, 10) = " << std::ldexp(-0.0, 10) << '\n'
              << "ldexp(-Inf, -1) = " << std::ldexp(-INFINITY, -1) << '\n';
    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    errno = 0;
    const double inf = std::ldexp(1, 1024);
    const bool is_range_error = errno == ERANGE;
    std::cout << "ldexp(1, 1024) = " << inf << '\n';
    if (is_range_error)
        std::cout << "    errno == ERANGE: " << std::strerror(ERANGE) << '\n';
    if (std::fetestexcept(FE_OVERFLOW))
        std::cout << "    FE_OVERFLOW raised\n";
}

Mögliche Ausgabe: 

ldexp(5, 3) = 5 * 8 = 40
ldexp(7, -4) = 7 / 16 = 0.4375
ldexp(1, -1074) = 4.94066e-324 (minimum positive subnormal float64_t)
ldexp(nextafter(1,0), 1024) = 1.79769e+308 (largest finite float64_t)
ldexp(-0, 10) = -0
ldexp(-Inf, -1) = -inf
ldexp(1, 1024) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised

Siehe auch

(C++11) (C++11)
zerlegt eine Zahl in Signifikand und Basis- 2 -Exponent
(Funktion)
(C++11) (C++11) (C++11) (C++11) (C++11) (C++11)
multipliziert eine Zahl mit FLT_RADIX potenziert mit einem Exponenten
(Funktion)
(C++11) (C++11) (C++11)
gibt 2 potenziert mit dem gegebenen Exponenten zurück ( 2 x )
(Funktion)
C-Dokumentation für ldexp