Namespaces
Variants

std:: log10, std:: log10f, std:: log10l

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

double log10 ( double num ) ;

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

log10 ( const V & v_num ) ;
(S) (depuis C++26)
Défini dans l'en-tête <cmath>
template < class Integer >
double log10 ( Integer num ) ;
(A) (constexpr depuis C++26)
1-3) Calcule le logarithme décimal (base 10 ) de num . La bibliothèque fournit des surcharges de std::log10 pour tous les types à virgule flottante non qualifiés cv comme type du paramètre. (depuis C++23)
S) La surcharge SIMD effectue un std::log10 é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 décimal (base- 10 ) de num ( log 10 (num) ou lg(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 tenues d'être fournies exactement comme (A) . Elles doivent seulement être suffisantes pour garantir que pour leur argument num de type entier, std :: log10 ( num ) ait le même effet que std :: log10 ( 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 << "log10(1000) = " << std::log10(1000) << '\n'
              << "log10(0.001) = " << std::log10(0.001) << '\n'
              << "logarithme en base 5 de 125 = "
              << std::log10(125) / std::log10(5) << '\n';
    // valeurs spéciales
    std::cout << "log10(1) = " << std::log10(1) << '\n'
              << "log10(+Inf) = " << std::log10(INFINITY) << '\n';
    // gestion des erreurs
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "log10(0) = " << std::log10(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 : 

log10(1000) = 3
log10(0.001) = -3
logarithme en base 5 de 125 = 3
log10(1) = 0
log10(+Inf) = inf
log10(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) (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)
logarithme décimal complexe avec les coupures de branche le long de l'axe réel négatif
(modèle de fonction)
applique la fonction std::log10 à chaque élément du valarray
(modèle de fonction)
Documentation C pour log10