tanh

tanh(x: array, /) → array

Calculates an implementation-dependent approximation to the hyperbolic tangent for each element x_i of the input array x.

The mathematical definition of the hyperbolic tangent is

\[\begin{split}\begin{align} \operatorname{tanh}(x) &= \frac{\operatorname{sinh}(x)}{\operatorname{cosh}(x)} \\ &= \frac{e^x - e^{-x}}{e^x + e^{-x}} \end{align}\end{split}\]

where \(\operatorname{sinh}(x)\) is the hyperbolic sine and \(\operatorname{cosh}(x)\) is the hyperbolic cosine.

Note

The hyperbolic tangent is an analytical function on the complex plane and has no branch cuts. The function is periodic, with period \(\pi j\), with respect to the imaginary component and has first order poles along the imaginary line at coordinates \((0, \pi (\frac{1}{2} + n))\). However, IEEE 754 binary floating-point representation cannot represent \(\pi / 2\) exactly, and, thus, no argument value is possible such that a pole error occurs.

Parameters:

x (array) – input array whose elements each represent a hyperbolic angle. Should have a floating-point data type.

Returns:

out (array) – an array containing the hyperbolic tangent of each element in x. The returned array must have a floating-point data type determined by Type Promotion Rules.

Notes

Special cases

Note

For all operands, tanh(-x) must equal -tanh(x).

For real-valued floating-point operands,

  • If x_i is NaN, the result is NaN.

  • If x_i is +0, the result is +0.

  • If x_i is -0, the result is -0.

  • If x_i is +infinity, the result is +1.

  • If x_i is -infinity, the result is -1.

For complex floating-point operands, let a = real(x_i), b = imag(x_i), and

Note

For complex floating-point operands, tanh(conj(x)) must equal conj(tanh(x)).

  • If a is +0 and b is +0, the result is +0 + 0j.

  • If a is a nonzero finite number and b is +infinity, the result is NaN + NaN j.

  • If a is +0 and b is +infinity, the result is +0 + NaN j.

  • If a is a nonzero finite number and b is NaN, the result is NaN + NaN j.

  • If a is +0 and b is NaN, the result is +0 + NaN j.

  • If a is +infinity and b is a positive (i.e., greater than 0) finite number, the result is 1 + 0j.

  • If a is +infinity and b is +infinity, the result is 1 + 0j (sign of the imaginary component is unspecified).

  • If a is +infinity and b is NaN, the result is 1 + 0j (sign of the imaginary component is unspecified).

  • If a is NaN and b is +0, the result is NaN + 0j.

  • If a is NaN and b is a nonzero number, the result is NaN + NaN j.

  • If a is NaN and b is NaN, the result is NaN + NaN j.

Warning

For historical reasons stemming from the C standard, array libraries may not return the expected result when a is +0 and b is either +infinity or NaN. The result should be +0 + NaN j in both cases; however, for libraries compiled against older C versions, the result may be NaN + NaN j.

Array libraries are not required to patch these older C versions, and, thus, users are advised that results may vary across array library implementations for these special cases.

Changed in version 2022.12: Added complex data type support.