JavaScript Math Methods and Constants You don't Know Existed
Tags: javascript, beginners, tutorial, webdev
Published: 2020-01-07 03:34:52

**Subscribe to my email list now at http://jauyeung.net/subscribe/**

**Follow me on Twitter at https://twitter.com/AuMayeung**

**Many more articles at https://medium.com/@hohanga**

In JavaScript, the `Math` object is a built-in object that lets us do various mathematical operations.

It’s a non-function object with mathematical constants and functions to calculate various quantities. It only works with variables with the number type, and it doesn’t work with `BigInt` data.

The `Math` object isn’t a constructor. All the methods are static. We can refer to the members with the dot notation like `Math.PI` to get the value of Pi, or call the cosine function with `Math.cos(x)`.

Constants are defined with full precision allowing for real numbers in JavaScript.

* * *

Constants
=========

The `Math` object has the following constants:

Math.E
------

Euler's constant and the base of natural logarithms, approximately 2.718281828459045.

Math.LN2
--------

Natural logarithm of 2, approximately 0.6931471805599453.

Math.LN10
---------

Natural logarithm of 10, approximately 2.302585092994046.

Math.LOG2E
----------

Base 2 logarithm of E, approximately 1.4426950408889634.

Math.LOG10E
-----------

Base 10 logarithm of E, approximately 0.4342944819032518.

Math.PI
-------

The ratio of the circumference of a circle to its diameter, approximately 3.141592653589793.

Math.SQRT1_2
-------------

The square root of 1/2, approximately 0.7071067811865476.

Math.SQRT2
----------

The square root of 2, approximately 1.4142135623730951.

* * *

Methods
=======

The `Math` object has many methods, like trigonometric functions, power functions, and logarithmic functions.

The trigonometric functions like `sin()`, `cos()`, `tan()`, `asin()`, `acos()`, `atan()`, `atan2()` expect angles in radians as arguments and also return angles in radians.

To convert radians to degrees, divide by `(Math.PI / 180)`, and multiply by this to convert the other way.

The precision of the results are browser-dependent because each browser engine implements floating-point calculations differently. This means that different browsers may return different results for the same function.

Math.abs(x)
-----------

Returns the absolute value of a number. For example, we can use it as follows:

```javascript
Math.abs(2) // returns 2  
Math.abs(-2) // returns 2
```

Math.acos(x)
------------

Returns the inverse cosine of a number. For example, we can use it as follows:

```
Math.acos(1) // returns 0  
Math.acos(-1) // returns Math.PI
```

Math.acosh(x)
-------------

Returns the inverse hyperbolic cosine of a number. For example, we can use it as follows:

```javascript
Math.acosh(1) // returns 0
```

Math.asin(x)
------------

Returns the inverse sine of a number. For example, we can use it as follows:

```javascript
Math.asin(1) // returns 1.5707963267948966  
Math.asin(0) // returns 0
```

Math.asinh(x)
-------------

Returns the inverse hyperbolic sine of a number. For example, we can use it as follows:

```javascript
Math.asin(1) // returns 0.881373587019543  
Math.asin(0) // returns 0
```

Math.atan(x)
------------

Returns the inverse tangent of a number. For example, we can use it as follows:

```javascript
Math.atan(1) // returns 0.7853981633974483  
Math.atan(0) // returns 0
```

Math.atanh(x)
-------------

Returns the inverse hyperbolic tangent of a number. For example, we can use it as follows:

```javascript
Math.atanh(1) // returns Infinity  
Math.atanh(0) // returns 0
```

Math.atan2(y, x)
----------------

Returns the inverse tangent of the quotient of its arguments. 

The `atan2` function returns angles in the range between -&pi;/2 and &pi;/2.

For example, we can use it as follows:

```javascript
Math.atan2(1, 1) // returns 0.7853981633974483  
Math.atan2(1, Math.SQRT2) // returns 0.9553166181245093
```

Math.cbrt(x)
------------

Returns the cube root of a number. For example, we can use it as follows:

```javascript
Math.cbrt(3) // returns 1.4422495703074083
```

Math.ceil(x)
------------

Returns the smallest integer greater than or equal to a number. For example, we can use it as follows:

```javascript
Math.ceil(1.5) // returns 2
```

Math.clz32(x)
-------------

Returns the number of leading zeroes of a 32-bit integer when `x` is converted to binary. For example, if we write:

```javascript
Math.clz32(1)
```

We get 31 because the 1s digit is 1 and the other 31 digits before it are all 0. And if we write:

```javascript
Math.clz32(2)
```

We get 30 because the 1s digit is 0, the 2s digit is 1, and the other 30 digits before it are all 0.

Math.cos(x)
-----------

Returns the cosine of a number. For example, we can use it as follows:

```javascript
Math.cos(0) // returns 1
```

Math.cosh(x)
------------

Returns the hyperbolic cosine of a number. For example, we can use it as follows:

```javascript
Math.cosh(0) // returns 1
```

Math.exp(x)
-----------

Returns `e` to the power of `x`, where `x` is the argument, and `e` is Euler's constant which is approximately 2.718281828459045, and it’s the base of the natural logarithm. We can use it as in the following code:

```javascript
Math.exp(10) // returns 22026.465794806718
```

Math.expm1(x)
-------------

Returns `Math.exp(x)` with 1 subtracted from it. For example, we can use it as in the following code:

```javascript
Math.expm1(1) // returns 1.718281828459045
```

Math.floor(x)
-------------

Returns the largest integer less than or equal to a number. For example, we can use it as in the following code:

```javascript
Math.floor(1.1) // returns 1
```

Math.fround(x)
--------------

Returns the nearest single-precision float representation of a number.

A single-precision number has 32 bits, with the first bit used for the sign, the next 8 bits used for the exponent, and the remaining 23 bits are the fractional parts of the logarithm, also called the mantissa.

For example, we can use it as in the following code:

```
Math.fround(1.2) // returns 1.2000000476837158
```

Math.hypot(a,b,c,…)
-------------------

Returns the square root of the sum of squares of its arguments. It takes an infinite number of arguments. For example, we can use it as follows:

```javascript
Math.hypot(1,2)  // returns 2.23606797749979  
Math.hypot(1,2,3,4,5)  // returns 7.416198487095663
```

Math.imul(x, y)
---------------

Returns the result of 32-bit integer multiplication. It rounds off decimals to the nearest integer before performing the multiplication. For example, we can use it as follows:

```javascript
Math.imul(1,2) // returns 2  
Math.imul(3,4.1) // returns 12
```

Math.log(x)
-----------

Returns the natural logarithm (log with base `e`, also ln) of a number. For example, we can use it as the following code:

```javascript
Math.log(Math.E) // returns 1  
Math.log(1) // returns 0
```

Math.log1p(x)
-------------

Returns the natural logarithm (log with base `e`, also ln) of `1 + x` for a number x. For example, we can use it like the following code:

```javascript
Math.log1p(Math.E - 1) // returns 1  
Math.log1p(1) // returns 0.6931471805599453
```

Math.log10(x)
-------------

Returns the base 10 logarithm of a number. For example, we can use it like the following code:

```javascript
Math.log10(1) // returns 0  
Math.log10(10) // returns 1
```

Math.log2(x)
------------

Returns the base 2 logarithm of a number. For example, we can use it like the following code:

```javascript
Math.log2(2) // returns 0  
Math.log2(10) // returns 3.321928094887362
```

Math.max(a,b,…)
---------------

Returns the largest of zero or more numbers. If nothing is passed in, `-Infinity` is returned. For example, we can use it like the following code:

```javascript
Math.max(1, 2) // returns 2  
Math.max(1,2,3,4,5) // returns 5  
Math.max() // returns -Infinity
```

Math.min(a,b,…)
---------------

Returns the smallest of zero or more numbers. If nothing is passed in, `Infinity` is returned. For example, we can use it like the following code:

```javascript
Math.min(1,2) // returns 1  
Math.min(1,2,3,4,5) // returns 1  
Math.min() // returns Infinity
```

Math.pow(x, y)
--------------

Returns base to the exponent power. For example, we can use it like the following code:

```javascript
Math.pow(1,2) // returns 1  
Math.min(2,3) // returns 8
```

Math.random()
-------------

Returns a pseudo-random number between 0 and 1. For example, we can use it as the following code:

```javascript
Math.random() // returns 0.5275086314071882 or any other number between 0 and 1
```

Math.round(x)
-------------

Returns the value of a number rounded to the nearest integer. For example, we can use it as the following code:

```javascript
Math.round(1.2) // returns 1
```

Math.sign(x)
------------

Returns the sign of the x, indicating whether x is positive, negative, or zero. If `x` is positive, 1 is returned. If an `x` is negative, then -1 is returned. If `x` is 0 then 0 is returned. For example, we can use it like in the following code:

```javascript
Math.sign(1) // returns 1  
Math.sign(3) // returns 1  
Math.sign(-1) // returns -1  
Math.sign(-3) // returns -1  
Math.sign(0) // returns 0
```

Math.sin(x)
-----------

Returns the sine of a number. For example, we can use it as in the following code:

```javascript
Math.sin(1) // returns 0.8414709848078965
```

Math.sinh(x)
------------

Returns the hyperbolic sine of a number. For example, we can use it as in the following code:

```javascript
Math.sinh(1) // returns 1.1752011936438014
```

Math.sqrt(x)
------------

Returns the positive square root of a number. For example, we can use it like in the following code:

```javascript
Math.sqrt(1) // returns 1  
Math.sqrt(2) // returns 1.4142135623730951
```

Math.tan(x)
-----------

Returns the tangent of a number. For example, we can use it as in the following code:

```javascript
Math.tan(1) // returns 1.5574077246549023
```

Math.tanh(x)
------------

Returns the hyperbolic tangent of a number. For example, we can use it as in the following code:

```javascript
Math.tanh(2) // returns 0.9640275800758169
```

Math.trunc(x)
-------------

Returns the integer part of the number x, removing any fractional digits. For example, we can use it as in the following code:

```javascript
Math.trunc(2.2223) // returns 2
```

* * *

Extending the Math Object
=========================

We can extend the `Math` object by adding custom properties and methods to it since it’s not a constructor. For instance, we can add the following function to the Math object to calculate the fifth root of a number:

```javascript
Math.fifthRoot = (x) => Math.pow(x, 1/5);
```

The `Math` object is handy for making calculations in JavaScript. It has some useful constants and methods for calculations of common math operations like taking the logarithm and trigonometric functions.

We can extend the `Math` object easily by attaching methods and properties to it directly.