Quick reference: `Math`

Data properties

Math.E: number ^ES1

Euler’s number, base of the natural logarithms, approximately 2.7182818284590452354.
Math.LN10: number ^ES1

The natural logarithm of 10, approximately 2.302585092994046.
Math.LN2: number ^ES1

The natural logarithm of 2, approximately 0.6931471805599453.
Math.LOG10E: number ^ES1

The logarithm of e to base 10, approximately 0.4342944819032518.
Math.LOG2E: number ^ES1

The logarithm of e to base 2, approximately 1.4426950408889634.
Math.PI: number ^ES1

The mathematical constant π, ratio of a circle’s circumference to its diameter, approximately 3.1415926535897932.
Math.SQRT1_2: number ^ES1

The square root of 1/2, approximately 0.7071067811865476.
Math.SQRT2: number ^ES1

The square root of 2, approximately 1.4142135623730951.

Math.cbrt(x: number): number ^ES6

Returns the cube root of x (∛x).
```
> Math.cbrt(8)
2
```
Math.exp(x: number): number ^ES1

Returns e^x^ (e being Euler’s number). The inverse of Math.log().
```
> Math.exp(0)
1
> Math.exp(1) === Math.E
true
```
Math.expm1(x: number): number ^ES6

Returns Math.exp(x)-1. The inverse of Math.log1p(). The result has a higher precision whenever it is a 1 with a small decimal fraction.
Math.log(x: number): number ^ES1

Returns the natural logarithm of x (to base e, Euler’s number). The inverse of Math.exp().
```
> Math.log(1)
0
> Math.log(Math.E)
1
> Math.log(Math.E ** 2)
2
```
Math.log1p(x: number): number ^ES6

Returns Math.log(1 + x). The inverse of Math.expm1(). Enables you to specifiy the parameter with a higher precision whenever it is a 1 with a small fraction.
Math.log10(x: number): number ^ES6

Returns the logarithm of x to base 10. The inverse of 10 ** x.
```
> Math.log10(1)
0
> Math.log10(10)
1
> Math.log10(100)
2
```
Math.log2(x: number): number ^ES6

Returns the logarithm of x to base 2. The inverse of 2 ** x.
```
> Math.log2(1)
0
> Math.log2(2)
1
> Math.log2(4)
2
```
Math.pow(x: number, y: number): number ^ES1

Returns x^y^, x to the power of y. The same as x ** y.
```
> Math.pow(2, 3)
8
> Math.pow(25, 0.5)
5
```
Math.sqrt(x: number): number ^ES1

Returns the square root of x. The inverse of x ** 2.
```
> Math.sqrt(9)
3
```

Math.ceil(x: number): number ^ES1

Returns the smallest (closest to −∞) integer i with x ≤ i.

> Math.ceil(2.1)
3
> Math.ceil(-2.1)
-2
> Math.ceil(2.5)
3
> Math.ceil(-2.5)
-2
> Math.ceil(2.9)
3
> Math.ceil(-2.9)
-2

Math.floor(x: number): number ^ES1

Returns the greatest (closest to +∞) integer i with i ≤ x.

> Math.floor(2.1)
2
> Math.floor(-2.1)
-3
> Math.floor(2.5)
2
> Math.floor(-2.5)
-3
> Math.floor(2.9)
2
> Math.floor(-2.9)
-3

Math.trunc(x: number): number ^ES6

Removes the decimal fraction of x and returns the resulting integer.

> Math.trunc(2.1)
2
> Math.trunc(-2.1)
-2
> Math.trunc(2.5)
2
> Math.trunc(-2.5)
-2
> Math.trunc(2.9)
2
> Math.trunc(-2.9)
-2

All angles are specified in radians. Use the following two functions to convert between degrees and radians.

function toRadians(degrees) {
  return degrees / 180 * Math.PI;
}
function toDegrees(radians) {
  return radians / Math.PI * 180;
}

Math.acos(x: number): number ^ES1

Returns the arc cosine (inverse cosine) of x.
```
> Math.acos(0)
1.5707963267948966
> Math.acos(1)
0
```
Math.acosh(x: number): number ^ES6

Returns the inverse hyperbolic cosine of x.
Math.asin(x: number): number ^ES1

Returns the arc sine (inverse sine) of x.
```
> Math.asin(0)
0
> Math.asin(1)
1.5707963267948966
```
Math.asinh(x: number): number ^ES6

Returns the inverse hyperbolic sine of x.
Math.atan(x: number): number ^ES1

Returns the arc tangent (inverse tangent) of x.
Math.atanh(x: number): number ^ES6

Returns the inverse hyperbolic tangent of x.
Math.atan2(y: number, x: number): number ^ES1

Returns the arc tangent of the quotient y/x.
Math.cos(x: number): number ^ES1

Returns the cosine of x.
```
> Math.cos(0)
1
> Math.cos(Math.PI)
-1
```
Math.cosh(x: number): number ^ES6

Returns the hyperbolic cosine of x.
Math.hypot(...values: number[]): number ^ES6

Returns the square root of the sum of the squares of its arguments (Pythagoras’ theorem):
```
> Math.hypot(3, 4)
5
```
Math.sin(x: number): number ^ES1

Returns the sine of x.
```
> Math.sin(0)
0
> Math.sin(Math.PI / 2)
1
```
Math.sinh(x: number): number ^ES6

Returns the hyperbolic sine of x.
Math.tan(x: number): number ^ES1

Returns the tangent of x.
```
> Math.tan(0)
0
> Math.tan(1)
1.5574077246549023
```
Math.tanh(x: number): number; ^ES6

Returns the hyperbolic tangent of x.

Math.fround(x: number): number ^ES6

Rounds x to a 32-bit floating point value (float). Used by asm.js to tell an engine to internally use a float value (normal numbers are doubles and take up 64 bits).
Math.imul(x: number, y: number): number ^ES6

Multiplies the two 32 bit integers x and y and returns the lower 32 bits of the result. Needed by asm.js: All other basic 32-bit math operations can be simulated by coercing 64-bit results to 32 bits. With multiplication, you may lose bits for results beyond 32 bits.

Math.clz32(x: number): number ^ES6

Counts the leading zero bits in the 32-bit integer x. Used in DSP algorithms.

> Math.clz32(0b01000000000000000000000000000000)
1
> Math.clz32(0b00100000000000000000000000000000)
2
> Math.clz32(2)
30
> Math.clz32(1)
31