std::acosh(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> acosh(const complex<T>& z );		(desde C++11)

Calcula el arco coseno hiperbólico complejo de un valor complejo z con puntos de ramificación en los valores menores que 1 a lo largo del eje real.

Parámetros

z

-

El valor complejo.

Valor de retorno

Si no se producen errores, se devuelve el arco coseno hiperbólico complejode z, en el rango de una media franja de valores no negativos a lo largo del eje real y en el intervalo [−iπ; +iπ] 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::acosh(std::conj(z))==std::conj(std::acosh(z)).
• Si z es (±0,+0), el resultado es (+0,π/2).
• Si z es (x,+∞) (para cualquier x finita), el resultado es (+∞,π/2).
• Si z es (x,NaN) (para cualquierx finita), el resultado es (NaN,NaN) y se puede generar 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 (±∞,NaN), el resultado es (+∞,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 (+∞,NaN).
• Si z es (NaN,NaN), el resultado es (NaN,NaN).

Notas

Aunque el estándar de C++ denomina esta a función "arco coseno hiperbólico 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 "coseno hiperbólico complejo inverso", y, menos común, "coseno hiperbólico complejo de área".

El coseno hiperbólico inverso 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 el segmento de línea (-∞,+1) del eje real.

La definición matemática del valor principal del coseno hiperbólico inverso es acosh z = ln(z + √z+1√z-1).

Para cualquier z, acosh(z) =

√z-1

√1-z

acos(z), o simplemente i acos(z) en la mitad superior del plano complejo.

Ejemplo

Ejecuta este código

#include <iostream>#include <complex>   int main(){std::cout<<std::fixed;std::complex<double> z1(0.5, 0);std::cout<<"acosh"<< z1 <<" = "<<std::acosh(z1)<<'\n';   std::complex<double> z2(0.5, -0.0);std::cout<<"acosh"<< z2 <<" (el otro lado de la ramificación) = "<<std::acosh(z2)<<'\n';   // en el medio plano superior, acosh = i acos std::complex<double> z3(1, 1), i(0, 1);std::cout<<"acosh"<< z3 <<" = "<<std::acosh(z3)<<'\n'<<"i*acos"<< z3 <<" = "<< i*std::acos(z3)<<'\n';}

Salida:

acosh(0.500000,0.000000) = (0.000000,-1.047198) acosh(0.500000,-0.000000) (el otro lado de la ramificación) = (0.000000,1.047198) acosh(1.000000,1.000000) = (1.061275,0.904557) i*acos(1.000000,1.000000) = (1.061275,0.904557)

Véase también

acos(std::complex) (C++11)	Calcula el arco coseno de un número complejo (\({\small\arccos{z} }\)arccos(z)). (plantilla de funció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)
atanh(std::complex) (C++11)	Calcula el área de la tangente hiperbólica de un número complejo (\({\small\operatorname{artanh}{z} }\)artanh(z)). (plantilla de función)
cosh(std::complex)	Calcula el coseno hiperbólico de un número complejo (\({\small\cosh{z} }\)cosh(z)). (plantilla de función)
acoshacoshfacoshl (C++11)(C++11)(C++11)	Calcula el coseno hiperbólico inverso (\({\small\operatorname{arcosh}{x} }\)arcosh(x)) (función)
Documentación de C para cacosh