JavaScript for impatient programmers
Please support this book: buy it or donate

16 Math

Math is an object with data properties and methods for processing numbers. You can see it as a poor man’s module: It was created long before JavaScript had 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 ex (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. Therefore, this function returns more precise values whenever .exp() returns values 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. Therefore, you can provide this function with a more precise argument whenever the argument for .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 xy, 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). The following functions implement different approaches to rounding.

• Math.ceil(x: number): number [ES1]

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

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

Returns the largest (closest to +∞) integer i with ix.

> Math.floor(2.1)
2
> Math.floor(2.9)
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.4)
2
> Math.round(2.5)
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.9)
2

Tbl. 12 shows the results of the rounding functions for a few representative inputs.

Table 12: Rounding functions of Math. Note how things change with negative numbers because “larger” always means “closer to positive infinity”.
-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

16.4 Trigonometric Functions

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

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