rauschma/quickref-math.md

## quickref-math.md

      
    Raw
  

              quickref-math.md
            
          
    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.


Exponents, roots, logarithms


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


Rounding


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.round(x: number): number ^ES1
Returns the integer that is closest to x. If two integers are equally close, the greater integer is returned.
> Math.round(2.1)
2
> Math.round(-2.1)
-2
> Math.round(2.5)
3
> Math.round(-2.5)
-2
> Math.round(2.9)
3
> Math.round(-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


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;
}
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.


asm.js helpers


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.


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


Sources


Wikipedia
TypeScript’s built-in typings
MDN web docs for JavaScript
ECMAScript language specification