## `arcsinh, arccosh, arctanh, arccsch, arcsech, arccoth` -- the inverse hyperbolic functions

#### Introduction

`arcsinh(x)` represents the inverse of the sine function.

`arccosh(x)` represents the inverse of the cosine function.

`arctanh(x)` represents the inverse of the tangent function.

`arccsch(x)` represents the inverse of the cosecant function.

`arcsech(x)` represents the inverse of the secant function.

`arccoth(x)` represents the inverse of the cotangent function.

#### Call(s)

`arcsinh(x)`
`arccosh(x)`
`arctanh(x)`
`arccsch(x)`
`arcsech(x)`
`arccoth(x)`

#### Parameters

`x` | - | an arithmetical expression

#### Returns

an arithmetical expression.

### Overloadable:

`x`

#### Side Effects

When called with a floating point argument, the functions are sensitive to the environment variable `DIGITS` which determines the numerical working precision.

#### Related Functions

`sinh`, `cosh`, `tanh`, `csch`, `sech`, `coth`

#### Details

- Theses functions are defined for complex arguments.
- Floating point values are returned for floating point arguments. Unevaluated function calls are returned for most exact arguments.
- The following special values are implemented:

  `arcsinh`(0)=0, `arccosh`(0)=I*PI/2, `arccosh`(1)=0,

  `arctanh`(0)=0, `arccosh`(0)=I*PI/2.

- The inverse hyperbolic functions are multi-valued. The MuPAD implementations return values on the main branch defined as follows: for any finite complex x

  y:=arcsinh(x) satisfies -PI/2<=Im(y)<=PI/2,

  y:=arccosh(x) satisfies -PI<Im(y)<=PI,

  y:=arctanh(x) satisfies -PI/2<Im(y)<PI/2,

  y:=arccoth(x) satisfies -PI/2<Im(y)<=PI/2.

- The inverse hyperbolic functions are implemented according to the following relations to the logarithm function:

  `arcsinh(x) = ln(x + sqrt(x^2 + 1))`,

  `arccosh(x) = ln(x + sqrt(x^2 - 1))`,

  `arctanh(x) = (ln(1 + x) - ln(1 - x))/2`,

  `arccsch(x) = arcsinh(1/x)`,

  `arcsech(x) = arccosh(1/x)`,

  `arccoth(x) = arctanh(1/x)`.

  Cf. example 2.

- Consequently, these functions have the following branch cuts:

  For `arcsinh`, the branch cuts are the intervals (-I*infinity,-I) and (I,I*infinity) on the imaginary axis.

  For `arccosh`, the branch cuts are the real interval (-infinity,1) and the imaginary axis.

  For `arctanh`, the branch cuts are the real intervals (-infinity,-1] and [1,infinity).

  For `arccsch`, the branch cut is the interval (-I,I) on the imaginary axis.

  For `arcsech`, the branch cuts are the real intervals (-infinity,0) and (1,infinity) together with the imaginary axis.

  For `arccoth`, the branch cut is the real interval [-1,1].

  The values jump when the argument crosses a branch cut. Cf. example 3.

- The functions `arccsch` and `arcsech` immediately rewrite themselves, returning `arccsch(x)`=`arcsinh(1/x)` and `arcsech(x)`=`arccosh(1/x)`, respectively. MuPAD's `arccoth` is defined by `arccoth(x)`=`arctanh(1/x)`. However, it does not rewrite itself automatically in terms of `arctanh`.
- The float attributes are kernel functions, i.e., floating point evaluation is fast.

#### Example 1

We demonstrate some calls with exact and symbolic input data:

    >> arcsinh(1), arccosh(1/sqrt(2)), arctanh(5 + I), arccsch(1/3),
       arcsech(I), arccoth(2)

                             /  1/2 \
                             | 2    |
          arcsinh(1), arccosh| ---- |, arctanh(5 + I), arcsinh(3),
                             \  2   /

             arccosh(- I), arccoth(2)

    >> arcsinh(-x), arccosh(x + 1), arctanh(1/x)

                                                         / 1 \
                     -arcsinh(x), arccosh(x + 1), arctanh| - |
                                                         \ x /

Floating point values are computed for floating point arguments:

    >> arcsinh(0.1234), arccosh(5.6 + 7.8*I), arccoth(1.0/10^20)

            0.1230889466, 2.956002937 + 0.9506879769 I, - 1.570796327 I

#### Example 2

The inverse hyperbolic functions can be rewritten in terms of the logarithm function:

    >> rewrite(arcsinh(x), ln), rewrite(arctanh(x), ln)

                             2     1/2   ln(x + 1)   ln(1 - x)
                    ln(x + (x  + 1)   ), --------- - ---------
                                             2           2

#### Example 3

The values jump when crossing a branch cut:

    >> arctanh(2.0 + I/10^10), arctanh(2.0 - I/10^10)

            0.5493061443 + 1.570796327 I, 0.5493061443 - 1.570796327 I

On the branch cut, the values of `arctanh` coincide with the limit ``from below'' for real arguments x>1. The values coincide with the limit ``from above'' for real x<-1:

    >> arctanh(1.2), arctanh(1.2 - I/10^10), arctanh(1.2 + I/10^10)

          1.198947636 - 1.570796327 I, 1.198947636 - 1.570796327 I,

             1.198947636 + 1.570796327 I

    >> arctanh(-1.2), arctanh(-1.2 + I/10^10), arctanh(-1.2 - I/10^10)

          - 1.198947636 + 1.570796327 I, - 1.198947636 + 1.570796327 I,

             - 1.198947636 - 1.570796327 I

#### Example 4

Various system functions such as `diff`, `float`, `limit`, or `series` handle expressions involving the inverse hyperbolic functions:

    >> diff(arcsinh(x^2), x), float(arccosh(3)*arctanh(5 + I))

                         2 x
                     -----------, 0.3427241326 + 2.698556745 I
                       4     1/2
                     (x  + 1)

    >> limit(arcsinh(x)/arctanh(x), x = 0)

                                         1

    >> series(arctanh(sinh(x)) - arcsinh(tanh(x)), x = 0, 10)

                                     7      9
                             3   83 x    4 x       10
                            x  + ----- - ---- + O(x  )
                                  120    189

#### Changes

- The `series` attributes were improved. Floating point results are now consistent with the branch cuts defined by the logarithmic representation.
- These functions used to be called `asinh`,..,`acoth` in previous MuPAD versions.

Do you have questions or comments?
Copyright © SciFace Software GmbH & Co. KG 2000