ENDS 12/4: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


Take a deeper dive into Kotlin's number variables and explore what's possible with Integers, Floats, and more. 

Using Number Variables

As seen in the previous exercise, Kotlin allows us to combine or chain arithmetic expressions in order to achieve more complex calculations. When doing so, we must keep in mind the order in which each expression gets evaluated. 

Most programming languages follow a certain order of operations (similar to [PEMDAS](https://en.wiktionary.org/wiki/PEMDAS)) when evaluating such expressions. In Kotlin, this order looks like: 

1. Parentheses
2. Multiplication
3. Division
4. Modulus
5. Addition
6. Subtraction

You may have noticed that we skipped over the E (Exponents) in PEMDAS. This is because Kotlin does not have an exponent operator and instead relies on the `.pow()` function to calculate exponentiation. We'll cover this more in-depth in the following exercise. 

Let's see a few examples of compound arithmetic expressions: 

```kt 
println(5 + 8 * 2 / 4 - 3) // Prints: 6 
println(3 + (5 + 5) / 2)   // Prints: 8
println(3 * 2 + 1 * 7)     // Prints: 13
```

Another rule to keep in mind is when an expression contains sister operations such as multiplication and division or addition and subtraction, side by side. The compiler will evaluate this expression in a left to right order. For example:

```kt 
println(3 + 16 / 2 * 4) // Prints: 35
```

Since we have division, `/`, and multiplication, `*`, side by side, the left to right order goes into effect and the expression evaluates as such:

<img src="https://content.codecademy.com/courses/learn-kotlin/Variables%20and%20Data%20Types/Kotlin_OrderofOperationsDiagram_v4.svg" alt="Diagram showing flow of operations of arithmetic expressions without parentheses">

<br> 

Keep in mind both sets of rules when creating complex arithmetic expressions. 

Order of Operations 

As we build upon our programs, we'll often need to update the values of variables following certain calculations. Assume a program that increases the current speed of a vehicle to match a speed limit of `55`:

```kt
var currentSpeed = 45 
currentSpeed = currentSpeed + 10
print(currentSpeed) // Prints: 55
```

In order to increase and update the value of `currentSpeed`, we've added `10` to `currentSpeed` and reassigned it back to `currentSpeed`. Kotlin provides an even shorter syntax for operations like this with augmented assignment operators. 

_Augmented assignment operators_ execute a calculation and reassign its result to a variable all in one step. Each consists of an arithmetic operator immediately followed by the `=` operator. Take a look at the difference in syntaxes:

**Long Syntax**:
```pseudo 
a = a + b
``` 

**Short Syntax with an Augmented Assignment Operator**:
```pseudo
a += b 
```

Here's a breakdown of each: 


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

| **Operation** | **Long Syntax** | **Short Syntax** | 
| --------------------------- |------------------- |------------------- |
| Add | a = a + b | a += b |
| Subtract | a = a - b | a -= b | 
| Multiply | a = a * b | a *= b |  
| Divide | a = a / b | a /= b |  
| Mod | a = a % b | a %= b |    

</div>
<br>

Keeping the short syntax in mind, we can now refactor and optimize our previous program to its final, concise state: 

```kt
currentSpeed += 10
println(currentSpeed) // Prints: 55 
```

🚗💨

Augmented Assignment Operators

In addition to augmented assignment operators, Kotlin provides us with two arithmetic shortcuts that can be used to perform quick addition and subtraction calculations. These are known as increment and decrement operators. 

An _increment operator_ represents the addition of `1` to a variable using two consecutive plus operators, `++`: 

```pseudo
variableName++  
```

The _decrement operator_ represents the subtraction of `1` from a variable using two consecutive minus operators, `--`:
 
```pseudo
variableName--  
```

This shorthand syntax is most useful with loops and conditionals - concepts we'll explore later in this course. For now, let's just get familiar with the syntax. 

Assume we're writing a program that keeps track of how many apples we have in our basket whilst apple picking. 🍎

```kt
var apples = 5
``` 

We picked up a Gala apple, so let's add `1` to our basket using an increment operator: 

```kt
apples++ 
println(apples) // Prints: 6 
```

We ate a Honey Crisp apple from our basket, so let's subtract `1` from the total: 

```kt
apples-- 
println(apples) // Prints: 5 
```

**Note**: `++` and `+= 1` are the same operations and can be used interchangeably throughout a program.  

Increment and Decrement Operators

The arithmetic operators that exist in Kotlin resemble the operators we know from basic math. They can be used in various applications from calculating the average test grade for a student class to determining the total restaurant bill. 

Kotlin supports the following arithmetic operators:

- `+` addition
- `-` subtraction
- `*` multiplication
- `/` division
- `%` modulus (divides and gives the remainder)

The above arithmetic operators aside from modulus, `%`, should all be familiar. Modulus is a programming symbol that is used to calculate the division and return the remainder. For example:

```kt 
println(7 % 2) 
```

`7` gets divided by `2` and results in `3` remainder `1`. The remainder then gets returned and printed to the terminal: 

```
1
```

Within the `println()` statement above, we built an arithmetic expression. An _arithmetic expression_ is the grouping of arithmetic operators and numeric values. Take a look at some of the ways in which we can set up and use arithmetic expressions throughout a Kotlin program. 

With variables:

```kt
var operand1 = 5.5
var operand2 = 4.3
println(operand1 + operand2) 
// Prints: 9.8
```

In a print statement:

```kt 
println(8 - 4) 
// Prints: 4
```

Concatenated within a String:

```kt
println("The quotient of -9 and 3 is " + -9 / 3) 
// Prints: The quotient of -9 and 3 is -3
```

In the `{ }` of a String template:

```kt
println("The product of 6 and 2, is ${6 * 2}") 
// Prints: The product of 6 and 2 is 12
```

Arithmetic Operators

Excellent work! You’ve completed the final lesson on variables and learned the fundamentals of numbers in Kotlin. Let’s review what was covered.

- The `Number` superclass contains `Int`, `Long`, `Short`, `Byte`, `Float` and `Double` data types. 
- The arithmetic operators supported by Kotlin include `+`, `-`, `*`, `/` and `%`.
- Augmented assignment operators include an arithmetic and assignment operator used to calculate and reassign a value in one step. 
- The increment operator includes two consecutive plus operators, `++`, used to add 1 to a value and reassign the result. 
- The decrement operator includes two consecutive minus operators, `--`, used to subtract one from a value and reassign the result. 
- The order of operations includes parentheses, multiplication, division, modulus, addition and subtraction. 
- The `Math` library is inherited from Java and contains various mathematical functions for use in a Kotlin program.  

Feel free to utilize the empty **Review.kt** file and output terminal on the right to hone your understanding of numbers and practice writing Kotlin code.

Review

We've briefly worked with integers in the previous lesson, and in this section, we'll take a deeper dive into the various types of numbers that exist in Kotlin. 

Kotlin numbers fall into two categories: integers and decimals as part of the [Number](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-number/) superclass. Take a look at the image on the right. Each book occupies a certain amount of space on the shelf depending on its size. The same goes for the various numerical data types in Kotlin. The larger a variable is in size (Bits), the more space it occupies in our computer's memory. 

The books on the left side represent 4 different types of data for an integer value:

Name | Bit (Size) | Min Value | Max Value 
------ | ------ | ----- | ------ 
Long | 64 | -9,223,372,036,854... | 9,223,372,036,854...
Int | 32 | -2,147,483,648 | 2,147,483,647
Short | 16 | -32,768 | 32,767
Byte | 8 | -128 | 127

<br>

A `Long` variable is meant to store significantly large values, whereas a `Byte` variable cannot store a value larger than `127`. Hence, their size and occupation in memory vary. 

The books on the right represent 2 various types of data for decimal or floating-point values: 

Name | Bit (Size) | Decimal Digit Precision 
------ | ------ | ----- 
Double | 64 | 15-16
Float | 32 | 6-7

<br>

A `Double` variable contains a longer, more precise decimal precision than a `Float`. For example: 

```kt 
var doubleNum: Double = 6.0 / 13.0 
var floatNum: Float = 6.0f / 13.0f
println(doubleNum) // Prints: 0.46153846153846156
println(floatNum)  // Prints: 0.46153846
```

When declaring a numerical variable in Kotlin, the compiler will determine which of the above data types to assign to it. The default type for whole numbers is `Int` and the default type for decimals is `Double`, thus we'll be working with these two types of data more closely throughout this lesson. 

Shelf of books representing Kotlin data types. The books on the left are in descending order of size: Long, Int, Short, Byte. The books on the right are Double, and Float. 

Number Types

For more complex mathematical calculations, we can reference the `Math` library which is inherited from Java. It consists of various mathematical functionalities that cover a range of topics from logarithms, trigonometry, statistics, and more. Let's take a look at some of the most commonly used functions it provides. 

**Math.pow()** returns the first value raised to the power of the second value. It accepts and returns `Double` values. 

```kt 
Math.pow(5.0, 3.0) // 125.0
```

**Math.min()** returns the minimum value from two given numbers.  

```kt 
Math.min(5, 3) // 3
```

Alternatively, **Math.max()** determines the maximum value. 

**Math.random()** returns a randomly generated number between `0` and `1`.

```kt 
Math.random() // 0.3335735290527727
```

**Math.round()** accepts a single `Double` value and returns the result of rounding that value to the nearest Integer.  

```kt 
Math.round(15.7) // 16
```