JavaScript for impatient programmers (beta)

## 16. `Math`

`Math` is an object with data properties and methods for processing numbers.

You can see it as a poor man’s module. Today, it would probably be created as a module, but it has existed since long before modules.

### 16.1. 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.

### 16.2. Exponents, roots, logarithms

• `Math.cbrt(x: number): number` [ES6]

Returns the cube root of `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()`. Very small numbers (fractions close to 0) are represented with a higher precision. This function returns such values whenever the result of `.exp()` is close to 1.

• `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()`. Very small numbers (fractions close to 0) are represented with a higher precision. This function receives such numbers whenever a parameter to `.log()` is close to 1.

• `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``````

### 16.3. Rounding

Rounding means converting an arbitrary number to an integer (a number without a decimal fraction). Tbl. 15 lists the available functions and what they return for a few representative inputs.

Table 15: Rounding functions of `Math`.
`-2.9` `-2.5` `-2.1` `2.1` `2.5` `2.9`
`Math.floor` `-3` `-3` `-3` `2` `2` `2`
`Math.ceil` `-2` `-2` `-2` `3` `3` `3`
`Math.round` `-3` `-2` `-2` `2` `3` `3`
`Math.trunc` `-2` `-2` `-2` `2` `2` `2`
• `Math.ceil(x: number): number` [ES1]

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

``````> Math.ceil(1.9)
2
> Math.ceil(2.1)
3``````
• `Math.floor(x: number): number` [ES1]

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

``````> Math.floor(1.9)
1
> Math.floor(2.1)
2``````
• `Math.round(x: number): number` [ES1]

Returns the integer that is closest to `x`. If the decimal fraction of `x` is `.5` then `.round()` rounds up (to the integer closer to positive infinity):

``````> Math.round(2.5)
3
> Math.round(-2.5)
-2``````
• `Math.trunc(x: number): number` [ES6]

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

``````> Math.trunc(1.9)
1
> Math.trunc(2.1)
2``````

### 16.4. Trigonometric Functions

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;
}
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 `values` (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`.

### 16.5. asm.js helpers

WebAssembly is a virtual machine based on JavaScript that is supported by most JavaScript engines.

asm.js is a precursor to WebAssembly. It is a subset of JavaScript that produces fast executables if static languages (such as C++) are compiled to it. In a way, it is also a virtual machine, within the confines of JavaScript.

The following two methods help asm.js and have few use cases, otherwise.

• `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.

### 16.6. Various other functions

• `Math.abs(x: number): number` [ES1]

Returns the absolute value of `x`.

``````> Math.abs(3)
3
> Math.abs(-3)
3
> Math.abs(0)
0``````
• `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``````
• `Math.max(...values: number[]): number` [ES1]

Converts `values` to numbers and returns the largest one.

``````> Math.max(3, -5, 24)
24``````
• `Math.min(...values: number[]): number` [ES1]

Converts `values` to numbers and returns the smallest one.

``````> Math.min(3, -5, 24)
-5``````
• `Math.random(): number` [ES1]

Returns a pseudo-random number `n` where 0 ≤ `n` < 1.

Computing a random integer `i` where 0 ≤ `i` < `max`:

``````function getRandomInteger(max) {
return Math.floor(Math.random() * max);
}``````
• `Math.sign(x: number): number` [ES6]

Returns the sign of a number:

``````> Math.sign(-8)
-1
> Math.sign(0)
0
> Math.sign(3)
1``````