Automatic Differentiation
 
Loading...
Searching...
No Matches
atanh.hpp
Go to the documentation of this file.
1#ifndef STAN_MATH_PRIM_FUN_ATANH_HPP
2#define STAN_MATH_PRIM_FUN_ATANH_HPP
3
11#include <cmath>
12#include <complex>
13
14namespace stan {
15namespace math {
16
27template <typename T, require_arithmetic_t<T>* = nullptr>
28inline double atanh(T&& x) {
29 if (is_nan(x)) {
30 return x;
31 } else {
32 check_bounded("atanh", "x", x, -1.0, 1.0);
33 return std::atanh(x);
34 }
35}
36
47template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
48inline auto atanh(T&& x) {
49 return std::atanh(x);
50}
51
55struct atanh_fun {
63 template <typename T>
64 static inline auto fun(T&& x) {
65 return atanh(std::forward<T>(x));
66 }
67};
68
79template <typename T, require_ad_container_t<T>* = nullptr>
80inline auto atanh(T&& x) {
81 return apply_scalar_unary<atanh_fun, T>::apply(std::forward<T>(x));
82}
83
94template <typename Container,
95 require_container_bt<std::is_arithmetic, Container>* = nullptr>
96inline auto atanh(Container&& x) {
98 std::forward<Container>(x));
99}
100
101namespace internal {
109template <typename V>
110inline std::complex<V> complex_atanh(const std::complex<V>& z) {
111 std::complex<double> y_d = atanh(value_of_rec(z));
112 V one(1);
113 auto y = 0.5 * (log(one + z) - log(one - z));
114 return copysign(y, y_d);
115}
116} // namespace internal
117
118} // namespace math
119} // namespace stan
120
121#endif
std::complex< V > complex_atanh(const std::complex< V > &z)
Return the hyperbolic arc tangent of the complex argument.
Definition atanh.hpp:110
double copysign(double a, double_d b)
Definition double_d.hpp:329
double value_of_rec(const fvar< T > &v)
Return the value of the specified variable.
bool is_nan(T &&x)
Returns 1 if the input's value is NaN and 0 otherwise.
Definition is_nan.hpp:22
fvar< T > atanh(const fvar< T > &x)
Return inverse hyperbolic tangent of specified value.
Definition atanh.hpp:26
void check_bounded(const char *function, const char *name, const T_y &y, const T_low &low, const T_high &high)
Check if the value is between the low and high values, inclusively.
fvar< T > log(const fvar< T > &x)
Definition log.hpp:18
The lgamma implementation in stan-math is based on either the reentrant safe lgamma_r implementation ...
Base template class for vectorization of unary scalar functions defined by a template class F to a sc...
static auto fun(T &&x)
Return the inverse hyperbolic tangent of the specified argument.
Definition atanh.hpp:64
Structure to wrap atanh() so it can be vectorized.
Definition atanh.hpp:55