## Table of Contents

JavaScript makes working with math easy. It provides us with the **arithmetic operators** you'd expect from a programming language, and offers us a useful built-in **Math library** that does a lot of work for us so that we can focus on writing great code instead.

Math is easy.

## Arithmetic Operators

Here are some of the many **arithmetic operators** that allow you to manipulate numbers in JavaScript.

### Addition

You can add two numbers together using the `+`

operator. For example:

```
JAVASCRIPTconst blueCars = 4;
const redCars = 5;
const totalCars = blueCars + redCars;
console.log("I have " + totalCars + " cars!");
```

```
HTMLI have 9 cars!
```

You can add `1`

to a number using the **increment** operator. For example:

```
JAVASCRIPTlet burritos = 4;
burritos++; // adds 1
console.log("I have " + burritos + " burritos!");
```

```
HTMLI have 5 burritos!
```

You can add an arbitrary number by using **addition assignment**. For example:

```
JAVASCRIPTlet books = 10;
books += 20; // adds 20 books
console.log("I have read " + books + " books!");
```

```
HTMLI have read 30 books!
```

### Subtraction

You can subtract two numbers using the `-`

operator. For example:

```
JAVASCRIPTconst bobsApples = 13;
const stolenApples = 7;
const remainingApples = bobsApples - stolenApples;
console.log("After getting robbed, he was left with " + remainingApples + " apples.");
```

```
HTMLAfter getting robbed, he was left with 6 apples.
```

You can subtract `1`

from a number using the **decrement** operator. For example:

```
JAVASCRIPTlet waterBottles = 4;
waterBottles--;
console.log("I am down to " + waterBottles + " water bottles!");
```

```
HTMLI am down to 3 water bottles!
```

You can subtract an arbitrary number by using **subtraction assignment**. For example:

```
JAVASCRIPTlet apples = 50;
apples -= 30; // subtracts 30 apples
console.log("I have " + apples + " apples left!");
```

```
HTMLI have 20 apples left!
```

### Multiplication

You can multiply two numbers together using the `*`

operator. For example:

```
JAVASCRIPT// multiplying numbers
const tacosPerPerson = 3;
const people = 20;
const tacosNeeded = tacosPerPerson * people;
console.log("We need " + tacosNeeded + " tacos for the party.");
```

```
HTMLWe need 60 tacos for the party.
```

You can multiply by an arbitrary number by using **multiplication assignment**. For example:

```
JAVASCRIPTlet boxes = 2;
boxes *= 5; // multiplies the value by 5
console.log("I have " + boxes + " boxes left!");
```

```
HTMLI have 10 boxes left!
```

### Division

You can divide two numbers together using the `/`

operator. For example:

```
JAVASCRIPTconst totalSkittles = 75;
const kids = 5;
const skittlesPerKid = totalSkittles / kids;
console.log("Each kid gets " + skittlesPerKid + " skittles.");
```

```
HTMLEach kid gets 15 skittles.
```

You can divide by an arbitrary by using **division assignment**. For example:

```
JAVASCRIPTlet peanuts = 100;
peanuts /= 20; // divides the value by 20
console.log("I have " + peanuts + " peanuts left!");
```

```
HTMLI have 5 peanuts left!
```

### Modulus

You can find the remainder of a division by using the `%`

operator. For example:

```
JAVASCRIPTconst people = 20;
const peoplePerCar = 6;
const peopleInLastCar = people % peoplePerCar;
console.log("The last car will have " + peopleInLastCar + " people in it.");
```

```
HTMLThe last car will have 2 people in it.
```

You can find the remainder of an arbitrary number by using **modulus assignment**. For example:

```
JAVASCRIPTlet slices = 45;
slices %= 7; // does modulus 7
console.log("I have " + slices + " slices leftover!");
```

```
HTMLI have 3 slices leftover!
```

### Order of Operations

**Order of Operations**, also known as **PEMDAS**, is at play here, including with the use of parentheses. For example:

```
JAVASCRIPTconst x = (5 * 3) + 10 / 2;
console.log("The value of x is " + x + ".");
```

The order of operations is very important because it determines how the numbers are calculated and how the values are displayed. For example, the above expression is evaluated as `(5 * 3) + (10 / 2)`

which is `20`

because the `*`

operator has higher precedence than the `+`

operator.

## Math Properties

JavaScript's **Math** library, among other things, gives us access to mathematical properties that are commonly used so that we do not need to implement this ourselves. Let's look some examples below:

### Euler's Number - Math.E

One of these constants is **Euler's Number**, via `Math.E`

.

```
JAVASCRIPTconst euler = Math.E;
console.log(euler);
```

```
HTML2.718281828459045
```

### Pi - Math.PI

**Pi** is the ratio of the circumference of a circle relative to its diameter, and is accessed in JavaScript using `Math.PI`

.

```
JAVASCRIPTconst pi = Math.PI;
console.log(pi);
```

```
HTML3.141592653589793
```

## Math Methods

Likewise with properties, JavaScript also implements some commonly used mathematical methods that we can use anytime we want.

### Absolute Value

Getting the absolute value of a number is easy. Simple pass a number to `Math.abs()`

and it will return what you expect. For example:

```
JAVASCRIPTconst a = 6;
const b = -13;
console.log("Absolute value of a is " + Math.abs(a) + ".");
console.log("Absolute value of b is " + Math.abs(b) + ".");
```

```
HTMLAbsolute value of a is 6.
Absolute value of b is 13.
```

### Floor

The **floor** method rounds a number down to the nearest integer. Put a number inside `Math.floor()`

and you're good to go. For example:

```
JAVASCRIPTconst decimal = 24.942;
const floor = Math.floor(decimal);
console.log("The value of floor is " + floor + ".");
```

```
HTMLThe value of floor is 24.
```

### Ceiling

The **ceiling** method rounds a number up to the nearest integer. Put a number inside `Math.ceil()`

and you're good to go. For example:

```
JAVASCRIPTconst decimal = 13.37;
const ceiling = Math.ceil(decimal);
console.log("The value of ceiling is " + ceiling + ".");
```

```
HTMLThe value of ceiling is 14.
```

### Logarithm

You can get the **natural logarithm** of a number using the `Math.log()`

method. For example:

```
JAVASCRIPTconst number = Math.log(1);
console.log("The value of number is " + number + ".");
```

```
HTMLThe value of number is 0.
```

### Maximum

You can get the **maximum** of two numbers using the `Math.max()`

method. For example:

```
JAVASCRIPTconst number = Math.max(14, 349);
console.log("The value of number is " + number + ".");
```

```
HTMLThe value of number is 349.
```

### Minimum

You can get the **minimum** of two numbers using the `Math.min()`

method. For example:

```
JAVASCRIPTconst number = Math.min(53, 94);
console.log("The value of number is " + number + ".");
```

```
HTMLThe value of number is 53.
```

### Power

You can take the **power** of a number by using `Math.pow()`

. For example:

```
JAVASCRIPTconst number = Math.pow(3, 2);
console.log("The value of number is " + number + ".");
```

```
HTMLThe value of number is 9.
```

### Random

To get a **random number** in JavaScript, there's a `Math.random()`

method for that. By itself, it just returns a number between `0`

and `1`

.

```
JAVASCRIPTconst random = Math.random();
console.log("The value of random is " + random + ".");
```

```
HTMLThe value of random is 0.2156683652500082.
```

However, you can manipulate this fact to get a random number between two other numbers, like this:

```
JAVASCRIPTfunction randomBetween(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
const random = randomBetween(5, 25);
console.log("The value of random is " + random + ".");
```

```
HTMLThe value of random is 15.
```

### Round

You can **round** a number to the nearest integer using `Math.round()`

. For example:

```
JAVASCRIPTconst rounded = Math.round(3.14159);
console.log("The value of rounded is " + rounded + ".");
```

```
HTMLThe value of rounded is 3.
```

### Square Root

You can take the **square root** of a number with `Math.sqrt()`

. For example:

```
JAVASCRIPTconst root = Math.sqrt(49);
console.log("The value of root is " + root + ".");
```

```
HTMLThe value of root is 7.
```

That's all we got for math! 🤓🤓🤓

## Resources

- Getting Started with TypeScript
- Getting Started with Svelte
- Getting Started with Express
- Create an RSS Reader in Node
- How to Serve Static Files with Nginx and Docker
- How to deploy a .NET app using Docker
- Getting Started with Deno
- Learn how to use v-model with a custom Vue component
- Getting Started with Handlebars.js
- Build a Real-Time Chat App with Node, Express, and Socket.io
- Creating a Twitter bot with Node.js
- Setting Up Stylus CSS Preprocessor