Learn about the PHP number data types and arithmetic operators.

PHP Numbers

PHP also provides an operator that might be less familiar: modulo (`%`). The _modulo_ operator returns the remainder after the left operand is divided by the right operand. 

```php
echo 7 % 3; // Prints: 1
```

In the code above, `7 % 3` returns `1`. Why? We're trying to fit `3` into `7` as many times as we can. `3` fits into `7` at most twice. What's left over—the remainder—is `1`, since `7` minus `6` is `1`.

![gif of modulo operation](https://content.codecademy.com/courses/php-strings-variables/PHP_m2l2.gif)

The modulo operator will convert its operands to integers before performing the operation. This means `7.9 % 3.8` will perform the same calculation as `7 % 3`—both operations will return `1`. 

Let's look at another example of the modulo operator in action:
```php
$num_cookies = 27;
$cookies_per_serving = 4;
$leftover_cookies = $num_cookies % $cookies_per_serving;
echo $leftover_cookies; // Prints: 3
```
Let's practice using modulo!


Modulo

Great job! In this lesson, we learned all about using numbers in PHP. Let's review what we covered: 
- PHP has two number data types: integers and floating point numbers 
- We can use arithmetic operators for performing math operations:

<div class="narrative-table-container">

| **Operation:** |   | **Example:** | 
| --------------- |----------------------- |---------------------- |
| Addition | `+` | `echo 1 + 4.5; // Prints: 5.5` |
| Subtraction | `-` | `echo 9 - 1; // Prints: 8` | 
| Multiplication | `*` | `echo -1.9 * 2.9; // Prints: -5.51` |  
| Division | `/` | `echo 9 / 1; // Prints: 9` |  
| Modulo | `%` | `echo 11 % 3; // Prints: 2` |  
| Exponentiation | `**` | `echo 8**2; // Prints: 64`|    

</div>
<br>

- Operations have an order of precedence meaning that certain types of operations in a chain will be evaluated before others: first evaluated will be any operation wrapped in **p**arenthesis (`()`), next **e**xponents (`**`), then **m**ultiplication (`*`) and **d**ivision (`/`), and finally **a**ddition (`+`) and **s**ubtraction (`-`). The acronym PEMDAS can be a helpful way of remembering the order. 
- We can assign number values to variables and then perform numerical operations with them. 
- We can use mathematical assignment operators as a shorthand when reassigning number variables:

<div class="narrative-table-container">

| **Operation:** | **Long Syntax:** | **Short Syntax:** | 
| --------------------------- |------------------- |------------------- |
| Add | $x = $x + $y | $x += $y |
| Subtract | $x = $x - $y | $x -= $y | 
| Multiply | $x = $x * $y | $x *= $y |  
| Divide | $x = $x / $y | $x /= $y |  
| Mod | $x = $x % $y | $x %= $y |    

</div>
<br>

Review

PHP provides several operators we can use on numbers. Let's start with two that are likely familiar: the addition (`+`) and  subtraction (`-`) operators:
```php
echo 5 + 1; // Prints: 6
echo 6.6 + 1.2; // Prints: 7.8
echo 198263 - 263;  // Prints: 198000
echo -22.8 - 19.1; // Prints: -41.9
```
Most of the time, we don't have to worry about which type of number we're using. 
We can add a float to an integer, subtract an integer from a float, and so on. 

One quirk is that operators will return integers whenever the result of the operation evaluates to a whole number. So `8.9 + 1.1` will return `10`, an integer, and not `10.0` even though both of the operands in the calculation were floating point numbers. 

Let's do some adding and subtracting!


Addition and Subtraction

Numbers and arithmetic operations are a fundamental part of programming. In this lesson, we'll learn how to use and manipulate numbers in PHP. 

PHP has two number data types. The _integer_ data type includes positive and negative whole numbers (such as 3, 4599, -98, and 0). The _floating point_ data type is used to represent decimal numbers (such as 4.98273, 2.1, -9.7, -182736.8). 

```php
echo 5; // Prints: 5
echo -22.8; // Prints: -22.8
```
We can also declare variables and assign numbers as their values:

```php
$my_int = 78;
$my_float = -897.21;

echo $my_int; // Prints: 78
echo $my_float; // Prints: -897.21
```

In the code above, we created the `$my_int` variable and assigned the integer value of 78 to it. Next, we created the `$my_float` variable and assigned the floating point value of -897.21 to it.

Let's practice making number variables!


Numbers

PHP also gives us operators for performing multiplication (`*`) and division (`/`).

```php
echo 2 * 3; // Prints: 6
echo -21 / 7; // Prints: -3
```
Like with addition and subtraction, when we perform multiplication or division, the computer will return an integer whenever the operation evaluates to a whole number. 

The reverse is also true: 
```php
$num_cookies = 24;
$num_friends = 7;
$cookies_per_friend = $num_cookies / $num_friends;
echo $cookies_per_friend; // Prints: 3.4285714285714
```
In the code above, we performed an operation on two integers that didn't divide into each other evenly, so the computer returned a floating point number. 

Let's multiply and divide!


Multiplication and Division

We can use number operators on variables that hold number values:
```php
$tadpole_age = 7;
$lily_age = 6; 
$age_difference = $tadpole_age - $lily_age;
echo $age_difference; // Prints 1
```
Let's look at another example of performing operations with number variables:
```php
$favorite_num = 22;
echo $favorite_num + 1; // Prints 23
echo $favorite_num; //Prints 22
```
In the code above, we created the variable `$favorite_num` then we used `echo` to print that value plus 1. Note that we didn't reassign the value of the `$favorite_num` variable, so it still had the value 22 when we printed it on the last line. 

We reassign number variables using the assignment operator:
```php
$age = 82;
echo $age; // Prints: 82

$age = $age + 2;
echo $age; // Prints: 84
```
Let's do some addition and subtraction with variables!


Using Number Variables

One common task when manipulating number variables is to reassign them to their old value with some operation performed on it. 

```php
$savings = 800;
$bike_cost = 75;
$savings = $savings - $bike_cost;
echo $savings; // Prints: 725
```
This is such a common task that PHP provides a shorter syntax using arithmetic assignment operators:
<div class="narrative-table-container">

| **Operation:** | **Long Syntax:** | **Short Syntax:** | 
| --------------------------- |------------------- |------------------- |
| Add | $x = $x + $y | $x += $y |
| Subtract | $x = $x - $y | $x -= $y | 
| Multiply | $x = $x * $y | $x *= $y |  
| Divide | $x = $x / $y | $x /= $y |  
| Mod | $x = $x % $y | $x %= $y |    

</div>
<br>

We could use this shorter syntax to rewrite the above code:
```php
$savings = 800;
$bike_cost = 75;
$savings -= $bike_cost;
echo $savings; // Prints: 725
```
With mathematical assignment operators, PHP doesn't allow spaces between the two characters. 

Ready for one more shortcut? [Increment operators](https://www.php.net/manual/en/language.operators.increment.php) allow us to subtract or add one to a number with just two characters.
```php
$age = 89; 
$age++;
echo $age; // Prints: 90

$days_til_vacation = 7; 
$days_til_vacation--;
echo $days_til_vacation; // Prints: 6
```
In the code above, we used the post-increment (`++`) operator to add one to `$age` and we used the post-decrement operator (`--`) to subtract one from `$days_til_vacation`. 

Those keystrokes can add up, so let's practice using arithmetic assignment operators on variables!


Mathematical Assignment Operators

PHP give us an operator for raising a number to the power of another number: the exponentiation operator (`**`). 

For example, we can square a number by raising it to the power of 2:
```php
echo 4 ** 2; // Prints: 16
```
We can also use this operator on floats and negative numbers:
```php
echo 2.89 ** 3.2;  // Prints: 29.845104015297
echo 10 ** -1; // Prints: 0.1
```

For PHP to interpret this operator correctly it can't have any spaces between the two `*` characters:
```php
echo 2 * * 3; // Will result in an error
```
Let's do some more math!


Exponentiation

We can chain multiple operations together to get a single result:
```php
echo 2 + 3 + 4 + 5 - 1.1; // Prints: 12.9
echo 2 * 9 / 6; // Prints: 3
```
You might have learned about operations having an order of precedence in a math class. This means that operations in a chain aren't simply performed from left to right; rather each operator is given a special rank. 

Operations will be evaluated in the following order:
1. Any operation wrapped in parentheses (`()`)
2. Exponents (`**`)
3. Multiplication (`*`) and division (`/`)
4. Addition (`+`) and subtraction (`-`). 

The acronym PEMDAS can be helpful for remembering the order of precedence for these arithmetic operations. 


```php
echo 1 + 3 * 9; // Prints: 28
```
In the example above, `3 * 9` (27) is calculated first and then is added to 1 to yield a final result of 28. We can change what this expression returns by using parentheses:
```php
echo (1 + 3) * 9; // Prints: 36
```
Here, `1 + 3` (4) is calculated first and then that value is multiplied by 9 to which returns 36. 

Let's practice writing some chained operations!
