Math and Rounding

In this lecture, we will learn about some more mathematical operations and also about rounding numbers. We have already been using many mathematical operations, for example, *plus*, *minus*, *times*, *divided*, *exponentiation*, etc. And so we don't need to go over these again. So let's start here with the square root.

script.js

```
// Just like many other functions, sqrt is part of the Math namespace.
Math.sqrt(25); // 5
Math.sqrt(9); // 3
Math.sqrt(4); // 2
```

The same result could be achieved by using the exponentiation operator.

script.js

```
console.log(25 ** (1 / 2)); // 5
console.log(9 ** (1 / 2)); // 3
// You can also get the cube root by using 1/3
console.log(8 ** (1 / 3)); // 2
```

Next up, let's get the maximum value of a couple of values.

script.js

```
console.log(Math.max(5, 18, 23, 11, 2)); // 23
console.log(Math.max(5, 18, '23', 11, 2)); // 23 ==> Does type coercion
console.log(Math.max(5, 18, '23px', 11, 2)); // NaN ==> Does not do parsing
```

Just as we have the `Math.max`

function, we also have the `Math.min`

function.

script.js

`console.log(Math.min(5, 18, 23, 11, 2)); // 2`

Besides a couple of methods, there are also constants on the `Math`

object or on the `Math`

namespace. For example, if we wanted to calculate the area of a circle, we would need the value of pi. So for that, we can use the `Math.PI`

constant.

script.js

```
const radius = 10;
console.log(Math.PI); // 3.141592653589793
console.log(radius ** 2 * Math.PI); // 314.1592653589793
```

Another thing that's on the `Math`

object is the `random`

function that we already have been using a couple of times. And it's very important to generate good random numbers when we need them.Remember we already used the `Math.random`

function to create random dice rolls?

First, `Math.random()`

will return a random number between *0* and *1*.

script.js

`console.log(Math.random()); // 0.123456789`

Then we multiply that number by *6* since we want random numbers between *1* and *6* , and remove the decimal part using the `Math.trunc`

function.

script.js

`console.log(Math.trunc(Math.random() * 6)); // 4`

But now, the problem is that we are getting numbers between *0* and *5* , and we want numbers between *1* and *6* . So we can add *1* to the result.

script.js

`console.log(Math.trunc(Math.random() * 6) + 1); // 5`

Let's now actually actually generalize this and create a function that will return a random integer between two values.

script.js

`const randomInt = (min, max) => // do something..`

As always, we need to start by removing any decimal part of the result of `Math.random()`

.

script.js

`const randomInt = (min, max) => Math.trunc(Math.random());`

We now need to multiply the result by the difference between the maximum and the minimum value, plus one.

script.js

`const randomInt = (min, max) => Math.trunc(Math.random() * (max - min) + 1);`

Before we move on, let me just quickly explain why we multiply by `max - min`

. `Math.random()`

will return a number between *0* and *1*. So if we multiply that by `max - min`

, we will get a number between *0* and `max - min`

. And now, if we add `min`

to that, we will get a number between `min`

and `max`

. So that's why we multiply by `max - min`

.

script.js

```
// 1. Math.random() will return a number between 0 and 1
// 0...1
// 2. We multiply that by max - min
// 0...(max - min)
// 3. Add min to the result
// min...(max - min + min) = min...max
```

Let's now add the minimum value to the result.

script.js

```
const randomInt = (min, max) =>
Math.trunc(Math.random() * (max - min) + 1) + min;
```

Let's test it out.

script.js

```
console.log(randomInt(10, 20)); // 15
console.log(randomInt(10, 20)); // 19
console.log(randomInt(10, 20)); // 13
```

Next, let's talk about rounding and let's start by rounding integers. We have already seen the `Math.trunc`

function, which removes the decimal part of a number.

script.js

```
console.log(Math.trunc(23.3)); // 23
console.log(Math.trunc(23.9)); // 23
```

We also have the `Math.round`

function, which rounds a number to the nearest integer.

script.js

```
console.log(Math.round(23.3)); // 23
console.log(Math.round(23.9)); // 24
```

Then we have the `Math.ceil`

function, which rounds a number up to the nearest integer in **Upward direction** of rounding i.e towards the greater value.

script.js

```
console.log(Math.ceil(23.3)); // 24
console.log(Math.ceil(23.9)); // 24
```

And finally, we have the `Math.floor`

function, which rounds a number down to the nearest integer in **Downward direction** of rounding i.e. towards the lesser value.

script.js

```
console.log(Math.floor(23.3)); // 23
console.log(Math.floor(23.9)); // 23
```

All these methods do type coercion, so they will also work with strings.

script.js

```
console.log(Math.trunc('23.3')); // 23
console.log(Math.round('23.9')); // 24
console.log(Math.ceil('23.3')); // 24
console.log(Math.floor('23.9')); // 23
```

Now you might think that `floor`

and `trunc`

are very similar. And indeed they do the same when we are dealing with positive numbers. So basically, `floor`

and `trunc`

both remove the decimal part when dealing with positive numbers. However, with negative numbers, they behave differently.

script.js

```
console.log(Math.floor(-23.3)); // -24
console.log(Math.trunc(-23.3)); // -23
```

Hence `floor`

is a little bit better than `trunc`

because it works in all situations, no matter if we are working with positive or negative numbers. We can therefore use `floor`

instead of `trunc`

in our `randomInt`

function.

script.js

```
const randomInt = (min, max) =>
Math.floor(Math.random() * (max - min) + 1) + min;
```

Let's now talk about rounding floating point numbers or decimals. Things work a little bit differently here. With floating point numbers, we have to specify the number in parenthsis, and then on that number we call the `toFixed`

method.

One thing to note is that `toFixed`

will always return a **string** and not a **number**.

script.js

```
// toFixed specifies the number of decimal places after the decimal point
console.log((2.7).toFixed(0)); // 3 ==> stringconsole.log((2.7).toFixed(3)); // 2.700 ==> string
console.log((2.345).toFixed(2)); // 2.35 ==> string
console.log(+(2.345).toFixed(2)); // 2.35 ==> number (Notice the + sign)
```

Just keep in mind that the above `toFixed`

operations work similarly to the string methods. What I mean is, the *2.7* on the avove highlighted line is a number, and primitives actually don't have methods. Hence, behind the scenes, JavaScript will do boxing. And boxing is to basically convert the *2.7* to a number object, and then call the `toFixed`

method on that number object. And then it will convert the number object back to a primitive once the operation is finished.

To finish, this lecture was just to give you a short overview of some more `Math`

functions. And as always if there is anything you don't understand in this lecture or want to learn more you can always check out the MDN documentation.