Namespaces
Variants

std:: log, std:: logf, std:: logl

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 log ( float num ) ;

double log ( double num ) ;

long double log ( long double num ) ;
(jusqu'à C++23)
/*floating-point-type*/
log ( /*floating-point-type*/ num ) ;
(depuis C++23)
(constexpr depuis C++26)
float logf ( float num ) ;
(2) (depuis C++11)
(constexpr depuis C++26)
long double logl ( 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 >

log ( const V & v_num ) ;
(S) (depuis C++26)
Défini dans l'en-tête <cmath>
template < class Integer >
double log ( Integer num ) ;
(A) (constexpr depuis C++26)
1-3) Calcule le logarithme naturel (base e ) de num . La bibliothèque fournit des surcharges de std::log 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::log é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 .
(since 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 naturel (base- e ) de num ( ln(num) ou log e (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

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 :: log ( num ) ait le même effet que std :: log ( 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 << "log(1) = " << std::log(1) << '\n'
              << "logarithme en base 5 de 125 = " << std::log(125) / std::log(5) << '\n';
    // valeurs spéciales
    std::cout << "log(1) = " << std::log(1) << '\n'
              << "log(+Inf) = " << std::log(INFINITY) << '\n';
    // gestion des erreurs
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "log(0) = " << std::log(0) << '\n';
    if (errno == ERANGE)
        std::cout << "    errno == ERANGE: " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    FE_DIVBYZERO levée\n";
}

Sortie possible : 

log(1) = 0
logarithme en base 5 de 125 = 3
log(1) = 0
log(+Inf) = inf
log(0) = -inf
    errno == ERANGE: Résultat numérique hors limites
    FE_DIVBYZERO levée

Voir aussi

(C++11) (C++11)
calcule le logarithme commun (base 10 ) ( log 10 (x) )
(fonction)
(C++11) (C++11) (C++11)
logarithme en base 2 du nombre donné ( log 2 (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)
renvoie e élevé à la puissance donnée ( e x )
(fonction)
logarithme naturel complexe avec les coupures de branche le long de l'axe réel négatif
(modèle de fonction)
applique la fonction std::log à chaque élément du valarray
(modèle de fonction)
Documentation C pour log