## `arcsin, arccos, arctan, arccsc, arcsec, arccot` -- the inverse trigonometric functions

#### Introduction

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

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

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

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

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

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

#### Call(s)

`arcsin(x)`
`arccos(x)`
`arctan(x)`
`arccsc(x)`
`arcsec(x)`
`arccot(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

`sin`, `cos`, `tan`, `csc`, `sec`, `cot`

#### Details

- The angle returned by these functions is measured in radians, not in degrees. E.g., the result PI represents an angle of 180 degrees.
- All inverse trigonometric 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 trigonometric functions return explicit values for arguments that are certain rational multiples of PI. For these values, the inverse functions return an appropriate rational multiple of PI on the main branch defined below. Cf. example 2.
- The result is expressed in terms of hyperbolic functions, if the argument is a rational multiple of `I`. Cf. example 3.
- The inverse trigonometric functions are multi-valued. The MuPAD functions return values on the main branch defined as follows. For any finite complex x:

  y:=arcsin(x) satisfies -PI/2<=Re(y)<=PI/2,

  y:=arccos(x) satisfies 0<=Re(y)<=PI,

  y:=arctan(x) satisfies -PI/2<Re(y)<PI/2,

  y:=arccot(x) satisfies -PI/2<Re(y)<=PI/2.

- For `arcsin` and `arccos`, the branch cuts are the real intervals (-infinity,-1) and (1,infinity).

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

  For `arccsc` and `arcsec`, the branch cut is the real interval (-1,1).

  For `arccot`, the branch cut is the interval [-I,I] on the imaginary axis.

  The values jump when the arguments cross a branch cut. Cf. example 4.

- The functions `arccsc` and `arcsec` immediately rewrite themselves in terms of `arcsin` and `arccos`, returning `arccsc(x)`=`arcsin(1/x)` and `arcsec(x)`=`arccos(1/x)`, respectively.

  Note that MuPAD's `arccot` is defined by `arccot(x)`=`arctan(1/x)`, although `arccot` may return an unevaluated function call and does not rewrite itself in terms of `arctan`. As a consequence of this definition, the real line crosses the branch cut and `arccot` has a jump discontinuity at the origin!

- 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:

    >> arcsin(1), arccos(1/sqrt(2)), arctan(5 + I), arccsc(1/3),
       arcsec(I), arccot(1)

              PI  PI                            PI                 PI
              --, --, arctan(5 + I), arcsin(3), -- + I arcsinh(1), --
              2   4                             2                  4

    >> arcsin(-x), arccos(x + 1), arctan(1/x)

                                                       / 1 \
                      -arcsin(x), arccos(x + 1), arctan| - |
                                                       \ x /

Floating point values are computed for floating point arguments:

    >> arcsin(0.1234), arccos(5.6 + 7.8*I), arccot(1.0/10^20)

              0.1237153458, 0.9506879769 - 2.956002937 I, 1.570796327

#### Example 2

Some special values are implemented:

    >> arcsin(1/sqrt(2)), arccos((5^(1/2) - 1)/4), arctan(3^(1/2) - 2)

                                  PI  2 PI    PI
                                  --, ----, - --
                                  4    5      12

Such simplifications occur for arguments that are trigonometric images of rational multiples of PI:

    >> sin(9/10*PI), arcsin(sin(9/10*PI))

                                   1/2
                                  5           PI
                                  ---- - 1/4, --
                                   4          10

    >> cos(PI/8)/sin(PI/8), arctan(cos(PI/8)/sin(PI/8))

                                  1/2     1/2
                                (2    + 2)     3 PI
                                -------------, ----
                                      1/2 1/2   8
                                (2 - 2   )

#### Example 3

Arguments that are rational multiples of `I` are rewritten in terms of hyperbolic functions:

    >> arcsin(5*I), arccos(5/4*I), arctan(-3*I)

                               PI
                 I arcsinh(5), -- - I arcsinh(5/4), -I arctanh(3)
                               2

For other complex arguments unevaluated function calls without simplifications are returned:

    >> arcsin(1/2^(1/2) + I), arccos(1 -3*I)

                              /  1/2     \
                              | 2        |
                        arcsin| ---- + I |, arccos(1 - 3 I)
                              \  2       /

#### Example 4

The values jump when crossing a branch cut:

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

             1.570796327 + 1.316957897 I, 1.570796327 - 1.316957897 I

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

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

          1.570796327 - 0.6223625037 I, 1.570796327 - 0.6223625037 I,

             1.570796327 + 0.6223625037 I

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

          - 1.570796327 + 0.6223625037 I,

             - 1.570796327 + 0.6223625037 I,

             - 1.570796327 - 0.6223625037 I

#### Example 5

The inverse trigonometric functions can be rewritten in terms of the logarithm function with complex arguments:

    >> rewrite(arcsin(x), ln), rewrite(arctan(x), ln)

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

             1/2 I ln(I x + 1)

#### Example 6

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

    >> diff(arcsin(x^2), x), float(arccos(3)*arctan(5 + I))

                       2 x
                   -----------, - 0.06540673615 + 2.433548516 I
                         4 1/2
                   (1 - x )

    >> limit(arcsin(x^2)/arctan(x^2), x = 0)

                                         1

    >> series(arctan(sin(x)) - arcsin(tan(x)), x = 0, 10)

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

#### Changes

- Further special values and simplifications were implemented. The `series` attributes were improved. Floating point results are now consistent with the branch cuts defined by the logarithmic representation. The new function `arg` replaces the two-argument version of the `arctan` function used in previous MuPAD versions.
- These functions used to be called `asin`,..,`acot` in previous MuPAD versions.

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