## `sinh, cosh, tanh, csch, sech, coth` -- the hyperbolic functions

#### Introduction

`sinh(x)` represents the hyperbolic sine function.

`cosh(x)` represents the hyperbolic cosine function.

`tanh(x)` represents the hyperbolic tangent function `sinh(x)/cosh(x)`.

`csch(x)` represents the hyperbolic cosecant function `1/sinh(x)`.

`sech(x)` represents the hyperbolic secant function `1/cosh(x)`.

`coth(x)` represents the hyperbolic cotangent function `cosh(x)/sinh(x)`.

#### Call(s)

`sinh(x)`
`cosh(x)`
`tanh(x)`
`csch(x)`
`sech(x)`
`coth(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

`arcsinh`, `arccosh`, `arctanh`, `arccsch`, `arcsech`, `arccoth`

#### 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.
- Arguments that are integer multiples of I*PI/2 lead to simplified results. If the argument involves a negative numerical factor of `Type::Real`, then symmetry relations are used to make this factor positive. Cf. example 2.
- The special values

  sinh(0)=0, sinh(+/-infinity) = +/-infinity,

  cosh(0)=1, cosh(+/- infinity)=infinity,

  tanh(0)=1, tanh(+/-infinity)= +/-infinity,

  coth(+/-infinity)= +/-infinity

  are implemented.

- The functions `expand` and `combine` implement the addition theorems for the hyperbolic functions. Cf. example 3.
- `sech(x)` and `csch(x)` are rewritten as `1/cosh(x)` and `1/sinh(x)`, respectively. Use `expand` or `rewrite` to rewrite expressions involving `tanh` and `coth` in terms of `sinh` and `cosh`. Cf. example 4.
- The inverse functions are implemented by `arcsin`, `arccos`, `arctan`, `arccsc`, `arcsec`, and `arccot`, respectively. Cf. example 5.
- 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:

    >> sinh(I*PI), cosh(1), tanh(5 + I), csch(PI), sech(1/11), coth(8)

                                          1          1
              0, cosh(1), tanh(5 + I), --------, ----------, coth(8)
                                       sinh(PI)  cosh(1/11)

    >> sinh(x), cosh(x + I*PI), tan(x^2 - 4)

                                                     2
                       sinh(x), cosh(x + I PI), tan(x  - 4)

Floating point values are computed for floating point arguments:

    >> sinh(123.4), cosh(5.6 + 7.8*I), coth(1.0/10^20)

                1.953930316e53, 7.295585032 + 135.0143985 I, 1.0e20

#### Example 2

Simplifications are implemented for arguments that are integer multiples of I*PI/2:

    >> sinh(I*PI/2), cosh(40*I*PI), tanh(-10^100*I*PI),
       coth(-17/2*I*PI)

                                    I, 1, 0, 0

Negative real numerical factors in the argument are rewritten via symmetry relations:

    >> sinh(-5), cosh(-3/2*x), tanh(-x*PI/12), coth(-12/17*x*y*PI)

                          / 3 x \        / x PI \        / 12 x y PI \
            -sinh(5), cosh| --- |, - tanh| ---- |, - coth| --------- |
                          \  2  /        \  12  /        \    17     /

#### Example 3

The `expand` function implements the addition theorems:

    >> expand(sinh(x + PI*I)), expand(cosh(x + y))

                    -sinh(x), cosh(x) cosh(y) + sinh(x) sinh(y)

The `combine` function uses these theorems in the other direction, trying to rewrite products of hyperbolic functions:

    >> combine(sinh(x)*sinh(y), sinhcosh)

                             cosh(x + y)   cosh(x - y)
                             ----------- - -----------
                                  2             2

#### Example 4

Various relations exist between the hyperbolic functions:

    >> csch(x), sech(x)

                                    1        1
                                 -------, -------
                                 sinh(x)  cosh(x)

The function `expand` rewrites all functions in terms of `sinh` and `cosh`:

    >> expand(tanh(x)), expand(coth(x))

                                 sinh(x)  cosh(x)
                                 -------, -------
                                 cosh(x)  sinh(x)

Use `rewrite` to obtain a representation in terms of a specific target function:

    >> rewrite(tanh(x)*exp(2*x), sinhcosh), rewrite(sinh(x), tanh)

                                                          / x \
                                                    2 tanh| - |
                  sinh(x) (cosh(2 x) + sinh(2 x))         \ 2 /
                  -------------------------------, --------------
                              cosh(x)                      / x \2
                                                   1 - tanh| - |
                                                           \ 2 /

    >> rewrite(sinh(x)*coth(y), exp), rewrite(exp(x), coth)

                        2      / exp(x)   exp(-x) \      / x \
                 (exp(y)  + 1) | ------ - ------- |  coth| - | + 1
                               \   2         2    /      \ 2 /
                 ----------------------------------, -------------
                                  2                      / x \
                            exp(y)  - 1              coth| - | - 1
                                                         \ 2 /

#### Example 5

The inverse functions are implemented by `arcsinh`, `arccosh` etc.:

    >> sinh(arcsinh(x)), sinh(arccosh(x)), cosh(arctanh(x))

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

Note that `arcsinh(sinh(x))` does not necessarily yield `x`, because `arcsinh` produces values with imaginary parts in the interval [-PI/2, PI/2]:

    >> arcsinh(sinh(3)), arcsinh(sinh(1.6 + 100*I))

                              3, 1.6 - 0.5309649149 I

#### Example 6

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

    >> diff(sinh(x^2), x), float(sinh(3)*coth(5 + I))

                             2
                   2 x cosh(x ), 10.01749636 - 0.0008270853591 I

    >> limit(x*sinh(x)/tanh(x^2), x = 0)

                                         1

    >> series((tanh(sinh(x)) - sinh(tanh(x)))/sinh(x^7), x = 0, 10)

                                           2
                                       29 x       3
                              - 1/30 + ----- + O(x )
                                        756

#### Changes

- Some special values were implemented. Conversion via `rewrite` was enhanced. Float evaluation of `tanh` and `coth` for large argument was protected against numerical overflow/underflow.

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