Namespaces
Variants

std:: logb, std:: logbf, std:: logbl

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
(C++11) (C++11)
(C++11)
logb
(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 logb ( float num ) ;

double logb ( double num ) ;

long double logb ( long double num ) ;
(bis C++23)
constexpr /*floating-point-type*/
logb ( /*floating-point-type*/ num ) ;
(seit C++23)
float logbf ( float num ) ;
(2) (seit C++11)
(constexpr seit C++23)
long double logbl ( long double num ) ;
(3) (seit C++11)
(constexpr seit C++23)
SIMD-Überladung (seit C++26)
Definiert im Header <simd>
template < /*math-floating-point*/ V >

constexpr /*deduced-simd-t*/ < V >

logb ( const V & v_num ) ;
(S) (seit C++26)
Definiert im Header <cmath>
template < class Integer >
double logb ( Integer num ) ;
(A) (constexpr seit C++23)
1-3) Extrahiert den Wert des unvoreingenommenen radix-unabhängigen Exponenten aus dem Gleitkomma-Argument num und gibt ihn als Gleitkommawert zurück. Die Bibliothek stellt Überladungen von std::logb für alle cv-unqualifizierten Gleitkommatypen als Typ des Parameters bereit. (since C++23)
S) Die SIMD-Überladung führt eine elementweise std::logb auf v_num aus.
(Siehe math-floating-point und deduced-simd-t für deren Definitionen.)
(seit C++26)
A) Zusätzliche Überladungen werden für alle Ganzzahltypen bereitgestellt, die als double behandelt werden.
(since C++11)

Formal ist der unverzerrte Exponent der vorzeichenbehaftete ganzzahlige Teil von log r |num| (von dieser Funktion als Fließkommawert zurückgegeben), für nicht-null num , wobei r gleich std:: numeric_limits < T > :: radix ist und T der Fließkommatyp von num ist. Wenn num subnormal ist, wird es so behandelt, als wäre es normalisiert.

Inhaltsverzeichnis

Parameter

num - Gleitkomma- oder Ganzzahlwert

Rückgabewert

Wenn keine Fehler auftreten, wird der unverzerrte Exponent von num als vorzeichenbehafteter Gleitkommawert zurückgegeben.

Wenn ein Domänenfehler auftritt, wird ein implementierungsdefinierter Wert zurückgegeben.

Wenn ein Polfehler auftritt, -HUGE_VAL , -HUGE_VALF , oder -HUGE_VALL wird zurückgegeben.

Fehlerbehandlung

Fehler werden gemeldet, wie in math_errhandling spezifiziert.

Ein Domänen- oder Wertebereichsfehler kann auftreten, wenn num null ist.

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

  • Wenn num ±0 ist, wird -∞ zurückgegeben und FE_DIVBYZERO ausgelöst.
  • Wenn num ±∞ ist, wird +∞ zurückgegeben.
  • Wenn num NaN ist, wird NaN zurückgegeben.
  • In allen anderen Fällen ist das Ergebnis exakt ( FE_INEXACT wird nie ausgelöst) und der aktuelle Rundungsmodus wird ignoriert.

Hinweise

POSIX erfordert dass ein Polfehler auftritt, wenn num ±0 ist.

Der von std::logb zurückgegebene Exponentenwert ist immer um 1 kleiner als der von std::frexp zurückgegebene Exponent aufgrund der unterschiedlichen Normalisierungsanforderungen: Für den Exponenten e , der von std::logb zurückgegeben wird, liegt |num*r -e
| zwischen 1 und r (typischerweise zwischen 1 und 2 ), aber für den Exponenten e , der von std::frexp zurückgegeben wird, liegt |num*2 -e
| zwischen 0.5 und 1 .

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 :: logb ( num ) die gleiche Wirkung hat wie std :: logb ( static_cast < double > ( num ) ) .

Beispiel

Vergleicht verschiedene Gleitkomma-Zerlegungsfunktionen:

Diesen Code ausführen 
#include <cfenv>
#include <cmath>
#include <iostream>
#include <limits>
// #pragma STDC FENV_ACCESS ON
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';
    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "logb(0) = " << std::logb(0) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    FE_DIVBYZERO raised\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
logb(0) = -Inf
    FE_DIVBYZERO raised

Siehe auch

(C++11) (C++11)
zerlegt eine Zahl in Signifikand und Basis- 2 -Exponent
(Funktion)
(C++11) (C++11) (C++11)
extrahiert den Exponenten einer Zahl
(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-Dokumentation für logb