Learn how to write short programs with numbers. 

Working with Numbers

One arithmetic operator that we haven't covered yet and may be less familiar is a _modulo_. A modulo returns a _remainder_, what is left over when we divide a number by another number.

```
4 % 3 = 1
4 % 2 = 0
```

The modulo is the same as the percentage symbol, but it's important to remember its different meaning in this context. 

Modulos are useful because they let us know if a number "fits" into a larger number, or if there will be a remainder. For example, how many eggs will be left over if I try and fit 56 eggs into crates of a dozen eggs?

```csharp
int eggs = 56;
int crateAmount = 12;

int eggsLeftOver = eggs % crateAmount; 
Console.Write(eggsLeftOver); // prints 8
```

It can also be used to check if a number is odd or even. If a number is even, taking its modulo with 2 it will return a 0 and if it is odd it will return a 1:

```csharp
int myNum = 85939824;
Console.Write(myNum % 2); // prints 0, so number is even
```

Modulo

No matter what you want to make in C#, you'll need numbers!

**Art:** what are the dimensions of your canvas?  
**Games:** how fast can your player move?  
**Business:** how much does your product cost?  

In this lesson, we'll look at a few of the most commonly used numerical data types in C#. By the end of this lesson, you will be able to manipulate numerical data and write programs that perform calculations using arithmetic operators and built-in methods. 


Introduction to Working with Numbers

Great job! You just learned about numerical data types and how to work with numerical data in a few different ways:
- Use arithmetic operators to write expressions.
- Combine operators together to write more concise programs.
- Use the modulo operator (`%`) to find remainders. 
- Use built-in methods to do more complex math.
- Use documentation to look new things up. 

Now that you know a few ways of working with numbers, try writing some small programs that use what you learned in this lesson. Some ideas:

- Write a program that calculates compound interest 
- Write a program that finds your age in dog years 

What other program ideas can you come up with?

Review

So how do we do more advanced mathematical operations? For example, how would we perform a square root on a number if the program doesn't recognize a square root symbol?

There are several built-in methods that we can use to manipulate numerical data and perform more complex mathematical calculations. Here are a few:

- `Math.Abs()`&mdash;will find the absolute value of a number. Example: `Math.Abs(-5)` returns 5.
- `Math.Sqrt()`&mdash;will find the square root of a number. Example: `Math.Sqrt(16)` returns 4.
- `Math.Floor()`&mdash;will round the given double or decimal down to the nearest whole number. Example: `Math.Floor(8.65)` returns 8.
- `Math.Min()`&mdash;returns the smaller of two numbers. Example: `Math.Min(39, 12)` returns 12. 


Built-In Methods

Often we need to update a variable in our program. We can do so by modifying that variable using an arithmetic expression, then re-saving it to the same variable name:

```csharp
int apple = 0;
apple = apple + 1;
Console.Write(apple); // prints 1
```

Programmers are always looking for shortcuts. For instance, we can condense the same program above using the shorthand `++`. The combined addition signs represent the idea of _incrementing by one_. We can do the same with the subtraction symbol `--`. 

```csharp
// a shorter way to do the same thing 
int apple = 0;
apple++;
Console.Write(apple); // prints 1
```
If we want the amount to increment by another value, say 3, we would do the following:

```csharp
int apple = 0;
apple += 3; // is the same as apple = apple + 3
Console.Write(apple); // prints 3
```
Again, if we want to decrement, you would do `-=3`.

Ultimately, programmers disagree on this, so everyone does it differently! On Codecademy, we prefer clarity over conciseness, so we'll use the long form (apple = apple + 3) except for incrementing by one (apple++).


Operator Shortcuts

We introduced you to a few common built-in methods, but there are many more out there! 
Now's a good time to practice your documentation search skills. Take a moment to look up the following built-in methods to understand their usage:

- `Math.Pow()`
- `Math.Max()`
- `Math.Ceiling()`

(If you're having trouble locating what you need, we recommend the [Microsoft .NET API documentation](https://docs.microsoft.com/en-us/dotnet/api)).


Using Documentation

So what can we do with numerical data? A first step is to write expressions using _arithmetic operators_. 

Arithmetic operators include:
- addition `+`
- subtraction `-`
- multiplication `*`
- division `/` 

We can use these symbols to perform operations on numbers and create new values. 

```csharp
int answer = 4 + 19;
Console.Write(answer);

// prints 23
```

When using operators, it's important to pay attention to data types. If we use two integers, it will return an integer *every time*. However, if we combine an integer with a double, the answer will be a double. Let's look at the following example:

```csharp
Console.WriteLine(5 / 3);
Console.WriteLine(5 / 3.0);

// prints 1
// prints 1.66667
```

The first operation that we log uses two ints. While 3 doesn't go into 5 evenly, we are still left with an int whole number. In the second operation, we use an int and a double, so the final result is a double. 


C# follows [the order of operations](https://en.wikipedia.org/wiki/Order_of_operations). If we do 1 + 2 * 3, should the answer be 9 or 7? C# follows a set of rules to determine which operations to perform first (the answer is 7). It's good practice to use parentheses to explicitly tell C# how to calculate these expressions. 

Notice in the following example, even if the addition symbol appears like it should come first, the multiplication operation will happen first.

```csharp
int answer = 8 + (9 * 3);
Console.Write(answer);

// prints 35
```


Arithmetic Operators

In C#, there are several ways of representing numerical data. Your usage of each will depend on your application. When choosing a data type, think about the following questions:

Do I need a whole number or do I need something that will represent a fraction, or a decimal?
If I want to use a decimal, how precise do I need to be? Depending on your application, whether it's a hobby project or building a B2B financial services software, you'll need a different data type. 
Is performance a factor? Most times, choosing a data type that takes up less memory will result in faster applications.  

Let's look at two data types that we can use to represent different numerical values: 

#### Int 
An _int_ is a whole integer value, like 4, 100, or 2349. They're a good way to count units of things. For example, if we wanted to track the number of coin flips a user makes, we'd use an int. It doesn't make sense to have 0.5 coin flips! 

To define a variable with the type `int`, you would write it as follows:
```csharp
int variableName = 7;
```

#### Double and Decimal

If we need to use a decimal value, we have a few options: float, double, and decimal. These values are useful for anything that requires more precision than a whole number, like measuring the precise location of an object in 3D space. 

A _double_ is usually the best choice of the three because it is more precise than a `float`, but faster to process than a _decimal_. However, make sure to use a decimal for financial applications, since it is the most precise.

To define a variable with the type `double`, you would write it as follows:
```csharp
double variableName = 39.76876;
```

To define a variable with the type `decimal`, you would write it as follows:
```csharp
decimal variableName = 489872.76m;
```
Don't forget the `m` character after the number! This character tells C# that we're defining a decimal and not a double. 
