std::tanh(std::complex)

Calcula la tangente hiperbólica compleja de un valor complejo z.

[editar] Parámetros

[editar] Valor de retorno

Si no se producen errores, se devuelve la tangente hiperbólica compleja de z.

[editar] 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,

• std::tanh(std::conj(z)) == std::conj(std::tanh(z)).
• std::tanh(-z) == -std::tanh(z).
• Si z es (+0,+0), el resultado es (+0,+0).
• Si z es (x,+∞) (para cualquier^[1] x finita), el resultado es (NaN,NaN) y se genera FE_INVALID.
• Si z es (x,NaN) (para cualquier^[2] x finita), el resultado es (NaN,NaN) y se puede generar FE_INVALID.
• Si z es (+∞,y) (para cualquier y finita positiva), el resultado es (1,+0).
• Si z es (+∞,+∞), el resultado es (1,±0) (el signo de la parte imaginaria no está especificado).
• Si z es (+∞,NaN), el resultado es (1,±0) (el signo de la parte imaginaria no está especificado).
• Si z es (NaN,+0), el resultado es (NaN,+0).
• Si z es (NaN,y) (para cualquier y distinta de cero), el resultado es (NaN,NaN) y se puede generar FE_INVALID.
• Si z es (NaN,NaN), el resultado es (NaN,NaN).

1. ↑ De acuerdo con C11 DR471, esto solo es cierto para una x distinta de cero. Si z es (0,∞), el resultado deberá ser (0,NaN)
2. ↑ De acuerdo con C11 DR471, esto solo es cierto para una x distinta de cero. Si z es (0,NaN), el resultado deberá ser (0,NaN)

[editar] Notas

La tangente hiperbólica es una función analítica en el plano complejo y no tiene puntos de ramificación. Es periódica con respecto a la componente imaginaria, con período πi, y tiene polos del primer orden a lo largo de la línea imaginaria, en las coordenadas (0, π(1/2 + n)). Sin embargo, ninguna representación común de punto flotante es capaz de representar π/2 exactamente, y es por esto que no hay un valor del argumento para el que ocurre un error de polo.

[editar] Ejemplo

#include <iostream>
#include <cmath>
#include <complex>
 
int main()
{
    std::cout << std::fixed;
    std::complex<double> z(1, 0); // se comporta como real tanh a lo largo de la línea real
    std::cout << "tanh" << z << " = " << std::tanh(z)
              << " (tanh(1) = " << std::tanh(1) << ")\n";
 
    std::complex<double> z2(0, 1); // se comporta como tangent a lo largo de la línea imaginaria
    std::cout << "tanh" << z2 << " = " << std::tanh(z2)
              << " ( tan(1) = " << std::tan(1) << ")\n";
}

tanh(1.000000,0.000000) = (0.761594,0.000000) (tanh(1) = 0.761594)
tanh(0.000000,1.000000) = (0.000000,1.557408) ( tan(1) = 1.557408)

[editar] Véase también