# Mathematical Functions #

This library provides basic mathematical functions. It provides all its functions and constants inside the table [`math`]{#pdf-math}. Functions with the annotation "`integer/float`" give integer results for integer arguments and float results for non-integer arguments. The rounding functions `math.ceil`, `math.floor`, and `math.modf` return an integer when the result fits in the range of an integer, or a float otherwise.

## `math.abs (x)`#

Returns the maximum value between `x` and `-x`. (integer/float)

## `math.acos (x)`#

Returns the arc cosine of `x` (in radians).

## `math.asin (x)`#

Returns the arc sine of `x` (in radians).

## `math.atan (y [, x])`#

Returns the arc tangent of `y/x` (in radians), but uses the signs of both arguments to find the quadrant of the result. It also handles correctly the case of `x` being zero.

The default value for `x` is 1, so that the call `math.atan(y)` returns the arc tangent of `y`.

## `math.ceil (x)`#

Returns the smallest integral value greater than or equal to `x`.

## `math.cos (x)`#

Returns the cosine of `x` (assumed to be in radians).

## `math.deg (x)`#

Converts the angle `x` from radians to degrees.

## `math.exp (x)`#

Returns the value e^x^ (where `e` is the base of natural logarithms).

## `math.floor (x)`#

Returns the largest integral value less than or equal to `x`.

## `math.fmod (x, y)`#

Returns the remainder of the division of `x` by `y` that rounds the quotient towards zero. (integer/float)

## `math.huge`#

The float value `HUGE_VAL`, a value greater than any other numeric value.

## `math.log (x [, base])`#

Returns the logarithm of `x` in the given base. The default for `base` is e (so that the function returns the natural logarithm of `x`).

## `math.max (x, ···)`#

Returns the argument with the maximum value, according to the Lua operator `<`.

## `math.maxinteger`#

An integer with the maximum value for an integer.

## `math.min (x, ···)`#

Returns the argument with the minimum value, according to the Lua operator `<`.

## `math.mininteger`#

An integer with the minimum value for an integer.

## `math.modf (x)`#

Returns the integral part of `x` and the fractional part of `x`. Its second result is always a float.

The value of π.

## `math.rad (x)`#

Converts the angle `x` from degrees to radians.

## `math.random ([m [, n]])`#

When called without arguments, returns a pseudo-random float with uniform distribution in the range [0,1). When called with two integers `m` and `n`, `math.random` returns a pseudo-random integer with uniform distribution in the range [m, n]. The call `math.random(n)`, for a positive `n`, is equivalent to `math.random(1,n)`. The call `math.random(0)` produces an integer with all bits (pseudo)random.

This function uses the `xoshiro256**` algorithm to produce pseudo-random 64-bit integers, which are the results of calls with argument 0. Other results (ranges and floats) are unbiased extracted from these integers.

Lua initializes its pseudo-random generator with the equivalent of a call to `math.randomseed` with no arguments, so that `math.random` should generate different sequences of results each time the program runs.

## `math.randomseed ([x [, y]])`#

When called with at least one argument, the integer parameters `x` and `y` are joined into a 128-bit seed that is used to reinitialize the pseudo-random generator; equal seeds produce equal sequences of numbers. The default for `y` is zero.

When called with no arguments, Lua generates a seed with a weak attempt for randomness.

This function returns the two seed components that were effectively used, so that setting them again repeats the sequence.

To ensure a required level of randomness to the initial state (or contrarily, to have a deterministic sequence, for instance when debugging a program), you should call `math.randomseed` with explicit arguments.

## `math.sin (x)`#

Returns the sine of `x` (assumed to be in radians).

## `math.sqrt (x)`#

Returns the square root of `x`. (You can also use the expression `x^0.5` to compute this value.)

## `math.tan (x)`#

Returns the tangent of `x` (assumed to be in radians).

## `math.tointeger (x)`#

If the value `x` is convertible to an integer, returns that integer. Otherwise, returns fail.

## `math.type (x)`#

Returns "`integer`" if `x` is an integer, "`float`" if it is a float, or fail if `x` is not a number.

## `math.ult (m, n)`#

Returns a boolean, true if and only if integer `m` is below integer `n` when they are compared as unsigned integers.