std::log(std::complex) - cppreference.com

Calcula el logaritmo natural complejo (base e) de un valor complejo z con un punto de ramificación a lo largo del eje real negativo.

Parámetros

Valor de retorno

Si no se producen errores, se devuelve el logaritmo natural complejo de z, en el rango de una franja en el intervalo [−iπ, +iπ] a lo largo del eje imaginario y matemáticamente ilimitado a lo largo el eje real.

Manejo de errores y valores especiales

Los errores se informan de acuerdo con math_errhandling.

Si la implementación es compatible con la aritmética de punto flotante IEEE,

• La función es continua sobre el punto de ramificación teniendo en cuenta el signo de la parte imaginaria.
• std::log(std::conj(z)) == std::conj(std::log(z)).
• Si z es (-0,+0), el resultado es (-∞,π) y se produce FE_DIVBYZERO.
• Si z es (+0,+0), el resultado es (-∞,+0) y se produce FE_DIVBYZERO.
• Si z es (x,+∞) (para cualquier x finita), el resultado es (+∞,π/2).
• Si z es (x,NaN) (para cualquier x finita), el resultado es (NaN,NaN) y puede producirse FE_INVALID.
• Si z es (-∞,y) (para cualquier y finita positiva), el resultado es (+∞,π).
• Si z es (+∞,y) (para cualquier y finita positiva), el resultado es (+∞,+0).
• Si z es (-∞,+∞), el resultado es (+∞,3π/4).
• Si z es (+∞,+∞), el resultado es (+∞,π/4).
• Si z es (±∞,NaN), el resultado es (+∞,NaN).
• Si z es (NaN,y) (para cualquier y finita), el resultado es (NaN,NaN) y puede producirse FE_INVALID.
• Si z es (NaN,+∞), el resultado es (+∞,NaN).
• Si z es (NaN,NaN), el resultado es (NaN,NaN).

Notas

El logaritmo natural de un número complejo z con componentes de coordenadas polares (r,θ) es igual a ln r + i(θ+2nπ), con el valor principal ln r + iθ.

La semántica de esta función pretende ser consistente con la función C clog.

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

Ejemplo

#include <iostream>
#include <cmath>
#include <complex>

int main()
{
    std::complex<double> z{0, 1}; // r = 1, θ = pi/2
    std::cout << "2*log" << z << " = " << 2.*std::log(z) << '\n';

    std::complex<double> z2{sqrt(2)/2, sqrt(2)/2}; // r = 1, θ = pi/4
    std::cout << "4*log" << z2 << " = " << 4.*std::log(z2) << '\n';

    std::complex<double> z3{-1, 0}; // r = 1, θ = pi
    std::cout << "log" << z3 << " = " << std::log(z3) << '\n';
    std::complex<double> z4{-1, -0.0}; // el otro lado de la ramificación
    std::cout << "log" << z4 << " (el otro lado de la ramificación) = " << std::log(z4) << '\n';
}

2*log(0,1) = (0,3.14159)
4*log(0.707107,0.707107) = (0,3.14159)
log(-1,0) = (0,3.14159)
log(-1,-0) (el otro lado de la ramificación) = (0,-3.14159)

Véase también