std:: asinh (std::complex)

Calcula el arco seno hiperbólico complejo de un valor complejo z con cortes de rama fuera del intervalo [−i; +i] a lo largo del eje imaginario.

Parámetros

Valor de retorno

Si no ocurren errores, se devuelve el arco seno hiperbólico complejo de z , en el rango de una franja 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:: asinh ( std:: conj ( z ) ) == std:: conj ( std:: asinh ( z ) )
• std:: asinh ( - z ) == - std:: asinh ( z )
• Si z es (+0,+0) , el resultado es (+0,+0)
• Si z es (x,+∞) (para cualquier x finito positivo), el resultado es (+∞,π/2)
• Si z es (x,NaN) (para cualquier x finito), el resultado es (NaN,NaN) y puede generarse FE_INVALID
• Si z es (+∞,y) (para cualquier y finito positivo), el resultado es (+∞,+0)
• Si z es (+∞,+∞) , el resultado es (+∞,π/4)
• Si z es (+∞,NaN) , el resultado es (+∞,NaN)
• Si z es (NaN,+0) , el resultado es (NaN,+0)
• Si z es (NaN,y) (para cualquier y finito distinto de cero), el resultado es (NaN,NaN) y puede generarse FE_INVALID
• Si z es (NaN,+∞) , el resultado es (±∞,NaN) (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 "seno hiperbólico arco complejo", 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 "seno hiperbólico inverso complejo", y, menos común, "seno hiperbólico de área complejo".

El seno hiperbólico inverso 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 (- i ∞,- i ) y ( i , i ∞) del eje imaginario.

La definición matemática del valor principal del seno hiperbólico inverso es asinh z = ln(z + √ 1+z 2
) .

Ejemplo

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

asinh(0.000000,-2.000000) = (1.316958,-1.570796)
asinh(-0.000000,-2.000000) (the other side of the cut) = (-1.316958,-1.570796)
asinh(1.000000,2.000000) = (1.469352,1.063440)
asin(-2.000000,1.000000) / i = (1.469352,1.063440)

Véase también