# csc

Cosecant function

### Use only in the MuPAD Notebook Interface.

This functionality does not run in MATLAB.

## Syntax

```csc(`x`)
```

## Description

`csc(x)` represents the cosecant function `1/sin(x)`.

Specify the argument `x` in radians, not in degrees. For example, use π to specify an angle of 180o.

All trigonometric functions are defined for complex arguments.

Floating-point values are returned for floating-point arguments. Floating-point intervals are returned for floating-point interval arguments. Unevaluated function calls are returned for most exact arguments.

Translations by integer multiples of π are eliminated from the argument. Further, arguments that are rational multiples of π lead to simplified results; symmetry relations are used to rewrite the result using an argument from the standard interval . Explicit expressions are returned for the following arguments:

.

See Example 2.

The result is rewritten in terms of hyperbolic functions, if the argument is a rational multiple of `I`. See Example 3.

The functions `expand` and `combine` implement the addition theorems for the trigonometric functions. See Example 4.

The trigonometric functions do not respond to properties set via `assume`. Use `simplify` to take such properties into account. See Example 4.

`csc(x)` is immediately rewritten as `1/sin(x)`. To rewrite the cosecant function in terms of other target functions, use `rewrite`. For example, you can rewrite expressions involving the cosecant function in terms of other trigonometric functions and vice versa. See Example 5.

The inverse function is implemented by `arccsc`. See Example 6.

The float attributes are kernel functions, thus, floating-point evaluation is fast.

## Environment Interactions

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

## Examples

### Example 1

Call `csc` with the following exact and symbolic input arguments. The cosecant function is rewritten in terms of the sine function.

`csc(-PI/2), csc(1), csc(5 + I), csc(PI/2), csc(PI/11), csc(PI/8)`

`csc(-x), csc(x + PI), csc(x^2 - 4)`

Floating-point values are computed for floating-point arguments:

`csc(123.4), csc(5.6 + 7.8*I), csc(1.0/10^20)`

Floating-point intervals are computed for interval arguments:

`csc(-3...-1), csc(1/2...3/2), csc(PI/8...7*PI/8)`

For intervals containing discontinuities, the result is a union of intervals:

```csc(-1...1); csc(-PI...0)```

### Example 2

Some special values are implemented:

`csc(PI/10), csc(2*PI/5), csc(123/8*PI), csc(-PI/12)`

Translations by integer multiples of π are eliminated from the argument:

`csc(x + 10*PI), csc(3 - PI), csc(x + PI), csc(2 - 10^100*PI)`

All arguments that are rational multiples of π are transformed to arguments from the interval :

`csc(4/7*PI), csc(-20*PI/9), csc(123/11*PI), csc(-PI/13)`

### Example 3

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

`csc(5*I), csc(5/4*I), csc(-3*I)`

For other complex arguments, use `expand` to rewrite the result:

`csc(5*I + 2*PI/3), csc(PI/4 - 5/4*I), csc(-3*I + PI/2)`

```expand(csc(5*I + 2*PI/3)), expand(csc(5/4*I - PI/4)), expand(csc(-3*I + PI/2))```

### Example 4

The `expand` function implements the addition theorems:

`expand(csc(x + PI/2)), expand(csc(x + y))`

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

`combine(1/(csc(x)*csc(y)), sincos)`

The trigonometric functions do not immediately respond to properties set via `assume`:

```assume(n, Type::Integer): csc((n + 1/2)*PI)```

Use `simplify` to take such properties into account:

`simplify(csc((n + 1/2)*PI))`

```assume(n, Type::Even): csc(n*PI + x), simplify(csc(n*PI + x))```

```y := csc(x + n*PI) + csc(x - n*PI); simplify(y)```

`delete n, y`

### Example 5

`csc(x)` is immediately rewritten as `1/sin(x)`:

`csc(x)`

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

```rewrite(csc(x)*exp(2*I*x), exp); rewrite(csc(x), cot)```

### Example 6

The inverse function is implemented as `arccsc`:

```csc(arccsc(x)), arccsc(csc(x))```

Note that `arccsc(csc(x))` is rewritten as `arcsin(sin(x))` and does not necessarily yield `x` because `arcsin` produces values with real parts in the interval $\left[-\frac{\pi }{2},\frac{\pi }{2}\right]$:

`arccsc(csc(3)), arccsc(csc(1.6 + I))`

### Example 7

`diff`, `float`, `limit`, `series` and other system functions handle expressions involving the trigonometric functions:

`diff(csc(x), x), float(csc(3)*cot(5 + I))`

`limit(1/(x*csc(x)), x = 0)`

`series(csc(x), x = 0)`

## Parameters

 `x`

## Return Values

Arithmetical expression or a floating-point interval

`x`