This lesson explores the numerical data types in LOLCODE and how to convert between them.

LOLCODE NUMBRs (Numbers)

Traditional arithmetic operations are supported on numeric types in LOLCODE:

```lol
BTW Addition
SUM OF x AN y

BTW Subtraction
DIFF OF x AN y

BTW Multiplication
PRODUKT OF x AN y

BTW Division
QUOSHUNT OF x AN y
```

Let's start with the two most basic:

* `SUM OF`: Creates the sum of `x` and `y` (equivalent to `x + y` in most languages)
* `DIFF OF`: Subtracts `y` from `x` (equivalent to `x - y` in most languages)

If either number in an operation is a `NUMBAR`, the result will be too. Otherwise the result will be a `NUMBR`.

```lol
BTW equates to 7
SUM OF 3 AN 4
```

Multiple operations can be within the same statement, and will follow the traditional order as with other programming languages.

```lol
BTW equates to 5
DIFF OF SUM OF 3 AN 4 AN 2
```

Sums and Differences

You've seen that when dividing two integer numbers that don't fit evenly, some amount will be left out. That amount, called the _remainder_, can be directly retrieved by the _modulo_ operation.

Most languages enable this with the `%` operator:

```js
7 % 3         // 1 
```

LOLCODE enables an equivalent with `MOD OF`:

```lol
MOD OF 7 AN 3 BTW 1
```

Let's use this and `QUOSHUNT OF` to create a program that finds the integer result and remainder of two inputs.

Modulol

Similarly, LOLCODE supports equivalents of the `*` and `/` operators:

```lol
BTW Multiplication
PRODUKT OF x AN y

BTW Division
QUOSHUNT OF x AN y
```

These follow the same rules as adding or subtracting: if either is already a `NUMBAR`, the result is too; otherwise, the result is a `NUMBR`.

For dividing, if both numbers are `NUMBR`s, any remainder will be truncated, like when converting from a `NUMBAR` to a `NUMBR`.

Products and Quotients

LOLCODE also allows converting string types, or `YARN`s, to the two numeric types. The syntax is the same: given a variable name, follow it with `IS NOW A` and the numeric type to convert to.

Converting strings to numbers can be useful when our program receives input using `GIMMEH`. Inputs are stored as `YARN`s, so to convert them to numbers, we'll need to use `IS NOW A`.

Strings to Numbers

Some languages use a native `Math` object for advanced operations on numbers. LOLCODE doesn't have an advanced mathematics object.

Still, it does support two of the more common math functions from other languages. It provides a `BIGGR OF` operator for finding the greater of two numbers and a `SMALLR OF` operator for finding the lesser of two numbers.

```lol
BIGGR OF 3 AN 4    BTW 4
SMALLR OF 4 AN 3   BTW 3
```

Let's create another program that operates on two numbers. This time we'll be using those two operators.

Max and Min

LOLCODE allows converting a variable to a different types, such as from a `NUMBAR` (float) to a `NUMBR` (integer), using the `IS NOW A` command. 

It goes on a line between a variable's name and a new type for the variable:

```lol
[variable] IS NOW A [type]
```

Casting a `NUMBAR` to a `NUMBR` truncates the decimal portion of the floating point number. 

For example, in the code below:

```lol
I HAS A powerLevel ITZ 9000.1
powerLevel IS NOW A NUMBR
```

`powerLevel` is changed to contain `9000`.

Number Conversions

LOLCODE has 5 basic types of variables:

- `NOOB`: not yet given a type
- `NUMBR`: integers (whole numbers)
- `NUMBAR`: floats (decimal numbers)
- `YARN`: string (text)
- `TROOF`: booleans (`WIN` and `FAIL`, equivalent to true and false)

So far, we've only seen strings being used in LOLCODE. This lesson will dive into the `NUMBR` and `NUMBAR` data types.

---

_`NOOB` refers to a newbie, or someone who's new._  
_`NUMBR` and `NUMBAR` are "numbers."_  
_`YARN` means "to tell a story."_  
_`TROOF` means "truer than truth."_
