std::atanh(std::complex)

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca numérica

Funciones matemáticas comunes
Funciones matemáticas especiales(C++17)
Constantes matemáticas(C++20)
Algoritmos básicos de álgebra lineal(C++26)
Entorno de punto flotante(C++11)
Números complejos
Arrays numéricos
Generación de números pseudoaleatorios
Operaciones de factores
gcd (C++17)
lcm (C++17)
Interpolaciones
midpoint (C++20)
lerp (C++20)
Saturación aritmética
add_sat (C++26) sub_sat (C++26) saturate_cast (C++26)	mul_sat (C++26) div_sat (C++26)
Operaciones numéricas genéricas
iota (C++11)
ranges::iota (C++23)
accumulate
inner_product
adjacent_difference
partial_sum
reduce (C++17)
transform_reduce (C++17)
inclusive_scan (C++17)
exclusive_scan (C++17)
transform_inclusive_scan (C++17)
transform_exclusive_scan (C++17)
Operaciones de bits
bit_cast (C++20)
byteswap (C++23)
has_single_bit (C++20)
bit_ceil (C++20)
bit_floor (C++20)
bit_width (C++20)
rotl (C++20)
rotr (C++20)
countl_zero (C++20)
countl_one (C++20)
countr_zero (C++20)
countr_one (C++20)
popcount (C++20)
endian (C++20)

 

std::complex

Funciones miembro
complex::complex
complex::operator=
complex::real
complex::imag
complex::operator+=complex::operator-=complex::operator*=complex::operator/=
Funciones no miembro
operator+operator- operator+operator-operator*operator/ operator==operator!= (hasta C++20) operator<<operator>>	real imag abs arg norm conj proj (C++11) polar operator""ioperator""ifoperator""il (C++14)(C++14)(C++14)
Funciones exponenciales
exp
log
log10
Funciones de potencias
pow
sqrt
Funciones trigonométricas
sin cos tan	asin (C++11) acos (C++11) atan (C++11)
Funciones hiperbólicas
sinh cosh tanh	asinh (C++11) acosh (C++11) atanh (C++11)

 

Definido en el archivo de encabezado <complex>
template<class T > complex<T> atanh(const complex<T>& z );		(desde C++11)

Calcula la arco tangente hiperbólica compleja de z con puntos de ramificación fuera del intervalo [−1; +1] a lo largo del eje real.

Parámetros

z

-

El valor complejo.

Valor de retorno

Si no se producen errores, se devuelve la arco tangente hiperbólica compleja de z, en el rango de una media franja matemáticamente ilimitada 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 informan de acuerdo con math_errhandling.

Si la implementación es compatible con la 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 produce 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 se puede generar 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 se puede generar 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 esta a función "arco tangente hiperbólica 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 "arco tangente compleja inversa", y, menos común, "tangente hiperbólica compleja de área".

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

La definición matemática del valor principal de la tangente hiperbólica inversa es atanh z =

ln(1+z)-ln(1-z)

2

.

Para cualquier z, atanh(z) =

atan(iz)

i

.

Ejemplo

Ejecuta este código

#include <iostream>#include <complex>   int main(){std::cout<<std::fixed;std::complex<double> z1(2, 0);std::cout<<"atanh"<< z1 <<" = "<<std::atanh(z1)<<'\n';   std::complex<double> z2(2, -0.0);std::cout<<"atanh"<< z2 <<" (el otro lado de la ramificación) = "<<std::atanh(z2)<<'\n';   // for any z, atanh(z) = atanh(iz)/istd::complex<double> z3(1,2);std::complex<double> i(0,1);std::cout<<"atanh"<< z3 <<" = "<<std::atanh(z3)<<'\n'<<"atan"<< z3*i <<"/i = "<<std::atan(z3*i)/i <<'\n';}

Salida:

atanh(2.000000,0.000000) = (0.549306,1.570796) atanh(2.000000,-0.000000) (el otro lado de la ramificación) = (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

asinh(std::complex) (C++11)	Calcula el área del seno hiperbólico de un número complejo (\({\small\operatorname{arsinh}{z} }\)arsinh(z)). (plantilla de función)
acosh(std::complex) (C++11)	Calcula el área del coseno hiperbólico de un número complejo (\({\small\operatorname{arcosh}{z} }\)arcosh(z)). (plantilla de función)
tanh(std::complex)	Calcula tangente hiperbólica de un número complejo (\({\small\tanh{z} }\)tanh(z)). (plantilla de función)
atanhatanhfatanhl (C++11)(C++11)(C++11)	Calcula la tangente hiperbólica inversa (\({\small\operatorname{artanh}{x} }\)artanh(x)) (función)
Documentación de C para catanh