Namespaces
Variants

std:: log2, std:: log2f, std:: log2l

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)
(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
Défini dans l'en-tête <cmath>
(1)
float log2 ( float num ) ;

double log2 ( double num ) ;

long double log2 ( long double num ) ;
(jusqu'à C++23)
/*floating-point-type*/
log2 ( /*floating-point-type*/ num ) ;
(depuis C++23)
(constexpr depuis C++26)
float log2f ( float num ) ;
(2) (depuis C++11)
(constexpr depuis C++26)
long double log2l ( long double num ) ;
(3) (depuis C++11)
(constexpr depuis C++26)
Surcharge SIMD (depuis C++26)
Défini dans l'en-tête <simd>
template < /*math-floating-point*/ V >

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

log2 ( const V & v_num ) ;
(S) (depuis C++26)
Défini dans l'en-tête <cmath>
template < class Integer >
double log2 ( Integer num ) ;
(A) (constexpr depuis C++26)
1-3) Calcule le logarithme binaire (base- 2 ) de num . La bibliothèque fournit des surcharges de std::log2 pour tous les types à virgule flottante non qualifiés cv comme type du paramètre. (depuis C++23)
S) La surcharge SIMD effectue un calcul std::log2 élément par élément sur v_num .
(Voir math-floating-point et deduced-simd-t pour leurs définitions.)
(depuis C++26)
A) Des surcharges supplémentaires sont fournies pour tous les types entiers, qui sont traités comme double .
(depuis C++11)

Table des matières

Paramètres

num - valeur à virgule flottante ou entière

Valeur de retour

Si aucune erreur ne se produit, le logarithme en base 2 de num ( log 2 (num) ou lb(num) ) est retourné.

Si une erreur de domaine se produit, une valeur définie par l'implémentation est retournée (NaN là où supporté).

Si une erreur de pôle se produit, -HUGE_VAL , -HUGE_VALF , ou -HUGE_VALL est retourné.

Gestion des erreurs

Les erreurs sont signalées comme spécifié dans math_errhandling .

Une erreur de domaine se produit si num est inférieur à zéro.

Une erreur de pôle peut se produire si num est nul.

Si l'implémentation prend en charge l'arithmétique à virgule flottante IEEE (IEC 60559),

  • Si l'argument est ±0, -∞ est retourné et FE_DIVBYZERO est déclenché.
  • Si l'argument est 1, +0 est retourné.
  • Si l'argument est négatif, NaN est retourné et FE_INVALID est déclenché.
  • Si l'argument est +∞, +∞ est retourné.
  • Si l'argument est NaN, NaN est retourné.

Notes

Pour un entier num , le logarithme binaire peut être interprété comme l'indice de base zéro du bit le plus significatif à 1 dans l'entrée.

Les surcharges supplémentaires ne sont pas requises d'être fournies exactement comme (A) . Elles doivent seulement être suffisantes pour garantir que pour leur argument num de type entier, std :: log2 ( num ) ait le même effet que std :: log2 ( static_cast < double > ( num ) ) .

Exemple

Exécuter ce code 
#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    std::cout << "log2(65536) = " << std::log2(65536) << '\n'
              << "log2(0.125) = " << std::log2(0.125) << '\n'
              << "log2(0x020f) = " << std::log2(0x020f)
              << " (le bit le plus élevé est en position 9)\n"
              << "logarithme en base 5 de 125 = "
              << std::log2(125) / std::log2(5) << '\n';
    // valeurs spéciales
    std::cout << "log2(1) = " << std::log2(1) << '\n'
              << "log2(+Inf) = " << std::log2(INFINITY) << '\n';
    // gestion des erreurs
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "log2(0) = " << std::log2(0) << '\n';
    if (errno == ERANGE)
        std::cout << "    errno == ERANGE: " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    FE_DIVBYZERO déclenchée\n";
}

Sortie possible : 

log2(65536) = 16
log2(0.125) = -3
log2(0x020f) = 9.04166 (le bit le plus élevé est en position 9)
logarithme en base 5 de 125 = 3
log2(1) = 0
log2(+Inf) = inf
log2(0) = -inf
    errno == ERANGE: Résultat numérique hors limites
    FE_DIVBYZERO déclenchée

Voir aussi

(C++11) (C++11)
calcule le logarithme naturel (base e ) ( ln(x) )
(fonction)
(C++11) (C++11)
calcule le logarithme décimal (base 10 ) ( log 10 (x) )
(fonction)
(C++11) (C++11) (C++11)
logarithme naturel (base e ) de 1 plus le nombre donné ( ln(1+x) )
(fonction)
(C++11) (C++11) (C++11)
retourne 2 élevé à la puissance donnée ( 2 x )
(fonction)
Documentation C pour log2