std:: atanh (std::complex)

Calcula el arcotangente hiperbólico complejo de z con cortes de rama fuera del intervalo [−1; +1] a lo largo del eje real.

Parámetros

Valor de retorno

Si no ocurren errores, se devuelve la tangente hiperbólica arco compleja de z , en el rango de una semi-bandera matemáticamente no acotada a lo largo del eje real y en el intervalo [−iπ/2; +iπ/2] a lo largo del eje imaginario.

Manejo de errores y valores especiales

Los errores se reportan de manera consistente con math_errhandling .

Si la implementación admite aritmética de punto flotante IEEE,

• std:: atanh ( std:: conj ( z ) ) == std:: conj ( std:: atanh ( z ) )
• std:: atanh ( - z ) == - std:: atanh ( z )
• Si z es (+0,+0) , el resultado es (+0,+0)
• Si z es (+0,NaN) , el resultado es (+0,NaN)
• Si z es (+1,+0) , el resultado es (+∞,+0) y se genera FE_DIVBYZERO
• Si z es (x,+∞) (para cualquier x finita positiva), el resultado es (+0,π/2)
• Si z es (x,NaN) (para cualquier x finita distinta de cero), el resultado es (NaN,NaN) y puede generarse FE_INVALID
• Si z es (+∞,y) (para cualquier y finita positiva), el resultado es (+0,π/2)
• Si z es (+∞,+∞) , el resultado es (+0,π/2)
• Si z es (+∞,NaN) , el resultado es (+0,NaN)
• Si z es (NaN,y) (para cualquier y finita), el resultado es (NaN,NaN) y puede generarse FE_INVALID
• Si z es (NaN,+∞) , el resultado es (±0,π/2) (el signo de la parte real no está especificado)
• Si z es (NaN,NaN) , el resultado es (NaN,NaN)

Notas

Aunque el estándar de C++ denomina a esta función "tangente hiperbólica arco compleja", las funciones inversas de las funciones hiperbólicas son las funciones de área. Su argumento es el área de un sector hiperbólico, no un arco. El nombre correcto es "tangente hiperbólica inversa compleja", y, menos común, "tangente hiperbólica de área compleja".

La tangente hiperbólica inversa es una función multivaluada y requiere un corte de rama en el plano complejo. El corte de rama se coloca convencionalmente en los segmentos de línea (-∞,-1] y [+1,+∞) del eje real.

Ejemplo

#include <complex>
#include <iostream>
int main()
{
    std::cout << std::fixed;
    std::complex<double> z1(2.0, 0.0);
    std::cout << "atanh" << z1 << " = " << std::atanh(z1) << '\n';
    std::complex<double> z2(2.0, -0.0);
    std::cout << "atanh" << z2 << " (the other side of the cut) = "
              << std::atanh(z2) << '\n';
    // for any z, atanh(z) = atanh(iz) / i
    std::complex<double> z3(1.0, 2.0);
    std::complex<double> i(0.0, 1.0);
    std::cout << "atanh" << z3 << " = " << std::atanh(z3) << '\n'
              << "atan" << z3 * i << " / i = " << std::atan(z3 * i) / i << '\n';
}

atanh(2.000000,0.000000) = (0.549306,1.570796)
atanh(2.000000,-0.000000) (the other side of the cut) = (0.549306,-1.570796)
atanh(1.000000,2.000000) = (0.173287,1.178097)
atan(-2.000000,1.000000) / i = (0.173287,1.178097)

Véase también