Namespaces
Variants

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

    From es.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
    Definido en el encabezado <cmath>
    (1)
    float log ( float num ) ;

    double log ( double num ) ;

    long double log ( long double num ) ;
    		(hasta C++23)
    /*floating-point-type*/
    log ( /*floating-point-type*/ num ) ;
    		(desde C++23)
    (constexpr desde C++26)
    float logf ( float num ) ;
    		(2) (desde C++11)
    (constexpr desde C++26)
    long double logl ( long double num ) ;
    		(3) (desde C++11)
    (constexpr desde C++26)
    Sobrecarga SIMD (desde C++26)
    Definido en el encabezado <simd>
    template < /*math-floating-point*/ V >

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

    log ( const V & v_num ) ;
    		(S) (desde C++26)
    Definido en el encabezado <cmath>
    template < class Integer >
    double log ( Integer num ) ;
    		(A) (constexpr desde C++26)
    1-3) Calcula el logaritmo natural (base- e ) de num . La biblioteca proporciona sobrecargas de std::log para todos los tipos de punto flotante sin calificación cv como el tipo del parámetro. (since C++23)
    S) La sobrecarga SIMD realiza un std::log elemento por elemento en v_num .
    (Ver math-floating-point y deduced-simd-t para sus definiciones.)
    		(desde C++26)
    A) Se proporcionan sobrecargas adicionales para todos los tipos enteros, los cuales son tratados como double .
    		(since C++11)

    Contenidos

    Parámetros

    num - valor de punto flotante o entero

    Valor de retorno

    Si no ocurren errores, se devuelve el logaritmo natural (base- e ) de num ( ln(num) o log e (num) ).

    Si ocurre un error de dominio, se devuelve un valor definido por la implementación (NaN donde esté soportado).

    Si ocurre un error de polo, -HUGE_VAL , -HUGE_VALF , o -HUGE_VALL es devuelto.

    Manejo de errores

    Los errores se reportan como se especifica en math_errhandling .

    Error de dominio ocurre si num es menor que cero.

    Puede ocurrir un error de polo si num es cero.

    Si la implementación soporta aritmética de punto flotante IEEE (IEC 60559),

    • Si el argumento es ±0, se devuelve -∞ y FE_DIVBYZERO se activa.
    • Si el argumento es 1, se devuelve +0.
    • Si el argumento es negativo, se devuelve NaN y FE_INVALID se activa.
    • Si el argumento es +∞, se devuelve +∞.
    • Si el argumento es NaN, se devuelve NaN.

    Notas

    Las sobrecargas adicionales no requieren ser proporcionadas exactamente como (A) . Solo necesitan ser suficientes para garantizar que para su argumento num de tipo entero, std :: log ( num ) tenga el mismo efecto que std :: log ( static_cast < double > ( num ) ) .

    Ejemplo

    Ejecutar este código 
    #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'
              << "logaritmo en base 5 de 125 = " << std::log(125) / std::log(5) << '\n';
    // valores especiales
    std::cout << "log(1) = " << std::log(1) << '\n'
              << "log(+Inf) = " << std::log(INFINITY) << '\n';
    // manejo de errores
    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 activada\n";
}

    Salida posible: 

    log(1) = 0
logaritmo en base 5 de 125 = 3
log(1) = 0
log(+Inf) = inf
log(0) = -inf
    errno == ERANGE: Resultado numérico fuera de rango
    FE_DIVBYZERO activada

    Véase también

    (C++11) (C++11)
    		calcula el logaritmo común (base 10 ) ( log 10 (x) )
    (función)
    (C++11) (C++11) (C++11)
    		logaritmo en base 2 del número dado ( log 2 (x) )
    (función)
    (C++11) (C++11) (C++11)
    		logaritmo natural (en base e ) de 1 más el número dado ( ln(1+x) )
    (función)
    (C++11) (C++11)
    		devuelve e elevado a la potencia dada ( e x )
    (función)
    		logaritmo natural complejo con cortes de rama a lo largo del eje real negativo
    (plantilla de función)
    		aplica la función std::log a cada elemento del valarray
    (plantilla de función)
    Documentación C para log