Skip to content

Instantly share code, notes, and snippets.

@rauschma
Created June 16, 2018 12:52
Show Gist options
  • Save rauschma/fa21795493fcf0dc5211dcc6b1fa3073 to your computer and use it in GitHub Desktop.
Save rauschma/fa21795493fcf0dc5211dcc6b1fa3073 to your computer and use it in GitHub Desktop.

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

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

    > 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

@MaxArt2501
Copy link

MaxArt2501 commented Jun 16, 2018

Typo describing Math.pow and .exp there.
May I suggest a little polyfill script for all ES6 functions and constants (basically, it's for IE)?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment