ms_learn_csharp/004_Basic_operation_on_numbers/004_csharp.md

# Basic number operations

### Introduction

The applications you'll build in C# will require that you operate on literal
and variable numeric data. Examples might include:

- Performing simple mathematical operations including addition, subtraction,
multiplication, and division
- Performing multi-step operations that must be completed in a certain order
- Determining the remainder after performing division
- Incrementing or decrementing a value, and so on

Suppose you want to perform a calculation that converts a value from one unit
of measure to another. For example, what if you needed to convert the current
temperature from Fahrenheit to Celsius? Once you've calculated the temperature
in degrees Celsius, you need to display that information in a formatted
message to the user. To accomplish this, you'll need to learn to use operators
to act on operands like literal and variable values.

In this module, you'll perform basic string and numeric operations on your data.
As you'll learn, the compiler will perform different tasks depending on the
data types of the values around the given operator. More importantly, you'll
come to understand how operators perform actions on operands. Learning how to
work with operators and operands correctly will help you formulate meaningful
instructions in your code.

By the end of this module, you will be able to write code that performs basic
operations on literal and variable values.

### Learning objectives

In this module, you will:

- Perform mathematical operations on numeric values
- Observe implicit type conversion between strings and numeric values
- Temporarily convert one data type into another

#### Prerequisites

- Beginner level experience with a .NET editor
- Beginner level experience with basic C# syntax rules
- Beginner level experience with displaying a message to a console using the
`Console.WriteLine` and `Console.Write` methods
- Beginner level experience with creating literal values and declare variables
of basic data types like string, int, and decimal
- Beginner level experience with string concatenation and string interpolation

---

## Exercise

### Perform addition with implicit data conversion

Often, you'll want to perform mathematical operations on numeric data. You'll
start with addition in this unit, and expand to other operations in the next
unit because there's an important lesson to learn about how the C# compiler
parses and interprets your code.

#### Add two numeric values

To add two numbers together, you'll use the addition operator, which is the
plus symbol `+`. Yes, the same plus symbol + that you use for string
concatenation is also used for addition. The reuse of one symbol for multiple
purposes is sometimes called "overloading the operator" and happens frequently
in C#.

In this instance, the C# compiler understands what you're attempting to do.
The compiler parses your code and sees that the `+` (the operator) is surrounded
by two numeric values (the operands). Given the data types of the variables 
(both are ints), it figures out that you intended to add those two values.

Enter the following code into the .NET Editor:

```cs
int firstNumber = 12;
int secondNumber = 7;
Console.WriteLine(firstNumber + secondNumber);
```

Run the code and you'll see the following result in the output console:

Output

```txt
19
```

Mix data types to force implicit type conversions
What happens if you try to use the + symbol with both string and int values?

Modify the code you wrote to match the following code:

```cs
string firstName = "Bob";
int widgetsSold = 7;
Console.WriteLine(firstName + " sold " + widgetsSold + " widgets.");
```

Run the code and you'll see the following result in the output console:

Output

```txt
Bob sold 7 widgets.
```

In this case, the C# compiler understands that you want to use the `+` symbol
to concatenate the two operands. It deduces this because the `+` symbol is
surrounded by operands of string and int data types. So, it attempts to
implicitly convert the int variable widgetsSold into a string temporarily so
it can concatenate it to the rest of the string. The C# compiler tries to help
you when it can, but ideally, you would be explicit about your intentions.

Attempt a more advanced case of adding numbers and concatenating strings
Modify the code you wrote to match the following code:

```cs
string firstName = "Bob";
int widgetsSold = 7;
Console.WriteLine(firstName + " sold " + widgetsSold + 7 + " widgets.");
```

Run the code and you'll see the following result in the output console:

Output

```txt
Bob sold 77 widgets.
```

Instead of adding the int variable widgetsSold to the literal int 7, the
compiler treats everything as a string and concatenates it all together.

Add parentheses to clarify your intention to the compiler
Modify the code you wrote to match the following code:

```cs
string firstName = "Bob";
int widgetsSold = 7;
Console.WriteLine(firstName + " sold " + (widgetsSold + 7) + " widgets.");
```

Run the code and you'll see the following result in the output console:

Output

```txt
Bob sold 14 widgets.
```

The parentheses symbol `()` becomes another overloaded operator. In this case,
the opening and closing parentheses form the order of operations operator,
just like you might use in a mathematical formula. You indicate that you want
the inner-most parentheses resolved first resulting in the addition of int
values widgetsSold and the value 7. Once that is resolved, then it will
implicitly convert the result to a string so that it can be concatenated with
the rest of the message.

> Note  
> You should probably avoid performing both a calculation and concatenation in
a single line of code. The point here is to help you understand how to view
operators and operands the way the compiler does.

### Recap

Here's what you've learned so far about mathematical operations in C#:

- You can perform mathematical-like addition operations on numbers.
- Both string concatenation and addition use the plus + symbol. This is called
overloading an operator, and the compiler infers the proper use based on the
data types it's operating on.
- When it can, the C# compiler will implicitly convert an int into a string if
it's obvious that the developer is trying to concatenate the string
representation of a number for presentation purposes.
- Use parentheses to define an order of operations to explicitly tell the
compiler that you want to perform certain operations before other operations.

---

## Exercise 

### Perform math operations

Now that you understand the basics of addition and more importantly, implicit
type conversion between numeric and string data types, let's look at several
other common mathematical operations on numeric data.

#### Perform basic math operations

Write code to perform addition, subtraction, multiplication, and division with
integers

Enter the following code in the .NET Editor:

```cs
int sum = 7 + 5;
int difference = 7 - 5;
int product = 7 * 5;
int quotient = 7 / 5;

Console.WriteLine("Sum: " + sum);
Console.WriteLine("Difference: " + difference);
Console.WriteLine("Product: " + product);
Console.WriteLine("Quotient: " + quotient);
```

Run the code. You should see the following output:

Output

```txt
Sum: 12
Difference: 2
Product: 35
Quotient: 1
```

As you can see:

- `+` is the addition operator
- `-` is the subtraction operator
- `*` is the multiplication operator
- `/` is the division operator

However, the resulting quotient of the division example may not be what you
may have expected. The values after the decimal are truncated from the
quotient since it is defined as an `int`, and `int` cannot contain values after
the `decimal`.

#### Add code to perform division using literal decimal data

To see division working properly, you need to use a data type that supports
fractional digits after the decimal point like decimal.

```cs
decimal decimalQuotient = 7.0m / 5;
Console.WriteLine($"Decimal quotient: {decimalQuotient}");
```

Run the code. You should see the following output:

Output

```txt
Decimal quotient: 1.4
```

For this to work, the quotient (left of the assignment operator) must be of
type `decimal` and at least one of numbers being divided must also be of type
`decimal` (both numbers can also be a `decimal` type).

Here are two additional examples that work equally well:

```cs
decimal decimalQuotient = 7 / 5.0m;
decimal decimalQuotient = 7.0m / 5.0m;
```

However, the following lines of code won't work (or give inaccurate results):

```cs
int decimalQuotient = 7 / 5.0m;
int decimalQuotient = 7.0m / 5;
int decimalQuotient = 7.0m / 5.0m;
decimal decimalQuotient = 7 / 5;
```

#### Add code to cast results of integer division

What if you are not working with literal values? In other words, what if you
need to divide two variables of type `int` but do not want the result truncated?
In that case, you must perform a data type cast from `int` to `decimal`. Casting
is one type of data conversion that instructs the compiler to temporarily
treat a value as if it were a different data type.

To cast `int` to `decimal`, you add the cast operator before the value. You use
the name of the data type surrounded by parentheses in front of the value to
cast it. In this case, you would add (`decimal`) before the variables `first`
and `second`.

```cs
int first = 7;
int second = 5;
decimal quotient = (decimal)first / (decimal)second;
Console.WriteLine(quotient);
```

Run the code. You should see the following output:

Output

```txt
1.4
```

> Note  
> You've seen three uses for the parenthesis operator: method invocation, order
of operations and casting.

Write code to determine the remainder after integer division
The modulus operator % tells you the remainder of int division. What you
really learn from this is whether one number is divisible by another. This can
be useful during long processing operations when looping through hundreds or
thousands of data records and you want to provide feedback to the end user
after every 100 data records have been processed.

```cs
Console.WriteLine($"Modulus of 200 / 5 : {200 % 5}");
Console.WriteLine($"Modulus of 7 / 5 : {7 % 5}");
```

Run the code. You should see the following output:

Output

```txt
Modulus of 200 / 5 : 0
Modulus of 7 / 5 : 2
```

When the modulus is 0, that means the dividend is divisible by the divisor.

### Order of operations

As you learned in the previous exercise, you can use the `()` symbols as
the order of operations operators. However, this isn't the only way the order
of operations is determined.

In math, PEMDAS is an acronym that helps students remember the order of
operations. The order is:

- Parentheses (whatever is inside the parenthesis is performed first)
- Exponents
- Multiplication and Division (from left to right)
- Addition and Subtraction (from left to right)

C# follows the same order as PEMDAS except for exponents. While there's no
exponent operator in C#, you can use the System.Math.Pow method. The module 
"Call methods from the .NET Class Library using C#" will feature this method
and others.

#### Write code to exercise C#'s order of operations

```cs
int value1 = 3 + 4 * 5;
int value2 = (3 + 4) * 5;
Console.WriteLine(value1);
Console.WriteLine(value2);
```

Here you see the difference when performing the same operations in a different
order.

Run the code. You should see the following output:

Output

```txt
23
35
```

### Recap

Here's what you've learned so far about mathematical operations in C#:

- Use operators like `+`, `-`, `*`, and `/` to perform basic mathematical
operations.
- The division of two int values will result in the truncation of any values
after the decimal point. To retain values after the decimal point, you need to
cast the divisor or dividend (or both) from int into a floating point number
like decimal first, then the quotient must be of the same floating point type
as well in order to avoid truncation.
- Perform a cast operation to temporarily treat a value as if it were a
different data type.
- Use the % operator to capture the remainder after division.
- The order of operations will follow the rules of the acronym PEMDAS.

---

## Exercise

### Increment and decrement values

The final basic operations you'll learn about in this module is how to
increment and decrement values using special operators that are combinations
of symbols.

### Increment and decrement

Frequently, you'll need to increment and/or decrement values, especially when
you're writing looping logic or code that interacts with a data structure.

The `+=` operator adds and assigns the value on the right of the operator to
the value on the left of the operator. So, lines two and three in the
following code snippet are the same:

```cs
int value = 0;     // value is now 0.
value = value + 5; // value is now 5.
value += 5;        // value is now 10.
```

The `++` operator increments the value of the variable by 1. So, lines two and
three in the following code snippet are the same:

```cs
int value = 0;     // value is now 0.
value = value + 1; // value is now 1.
value++;           // value is now 2.
```

These same techniques can be used for subtraction, multiplication, and more.
The following exercise steps will highlight a few.

> Note  
> Operators like `+=`, `-=`, `*=`, `++`, and `--` are known as compound
assignment operators because they compound some operation in addition to
assigning the result to the variable. The `+=` operator is specifically termed
the addition assignment operator.

### Write code to increment and decrement a value

Enter the following code in the .NET Editor:

```cs
int value = 1;

value = value + 1;
Console.WriteLine("First increment: " + value);

value += 1;
Console.WriteLine("Second increment: " + value);

value++;
Console.WriteLine("Third increment: " + value);

value = value - 1;
Console.WriteLine("First decrement: " + value);

value -= 1;
Console.WriteLine("Second decrement: " + value);

value--;
Console.WriteLine("Third decrement: " + value);
```

Run the code. You should see the following output:

```txt
First increment: 2
Second increment: 3
Third increment: 4
First decrement: 3
Second decrement: 2
Third decrement: 1
```

> Note  
> In the "second increment", you used value `+= 1;`. However you could have
used any literal int value (or a variable) to increment that amount. The same
holds true for the "second decrement": value `-= 1;`.

### Position the increment and decrement operators

Both the increment and decrement operators have an interesting quality —
depending on their position, they perform their operation before or after they
retrieve their value. In other words, if you use the operator before the value
as in `++value`, then the increment will happen before the value is retrieved.
Likewise, `value++` will increment the value after the value has been retrieved.

#### Use the increment operator before and after the value

```cs
int value = 1;
value++;
Console.WriteLine("First: " + value);
Console.WriteLine($"Second: {value++}");
Console.WriteLine("Third: " + value);
Console.WriteLine("Fourth: " + (++value));
```

Run the code. You should see the following output:

Output

```txt
First: 2
Second: 2
Third: 3
Fourth: 4
```

Notice this line of code:

```cs
Console.WriteLine($"Second: {value++}");
```

There's two steps to this line:

- Retrieve the current value of the variable value and use that in the string
interpolation operation.
- Increment the value.

The next line of code confirms that the value was, in fact, incremented.

```cs
Console.WriteLine("Third: " + value);
```

In contrast, consider the last line of code:

```cs
Console.WriteLine("Fourth: " + (++value));
```

Here, the order of operations is switched because the `++` operator is placed
before the operand `value`.

- Increment the value.
- Retrieve the new incremented value of the variable `value` and use that in
the string operation.

While not strictly necessary, you added parenthesis around the expression
(`++value`) to improve readability. Seeing so many `+` operators next to each
other seems like it could be misunderstood by other developers. Stylistic
decisions like this are subjective. However, since you'll write the code once
but read it many times, you should prioritize readability.

### Recap

Here's what you've learned so far about mathematical operations in C#:

- Use compound assignment operators like `+=`, `-=`, `*=`, `++`, and `--` to
perform a mathematical operation like increment or decrement, then assign the
result into the original variable.
- Increment and decrement operators perform differently depending on whether
the operator is before or after the operand.

---

## Complete the challenge to convert Fahrenheit to Celsius

In this challenge, you'll write code that will use a formula to convert a
temperature from degrees Fahrenheit to Celsius. You'll print the result in a
formatted message to the user.

### Challenge

Calculate Celsius given the current temperature in Fahrenheit

Enter the following code in the .NET Editor:

```cs
int fahrenheit = 94;
```

To convert temperatures in degrees Fahrenheit to Celsius, first subtract 32,
then multiply by five ninths (5 / 9).

Display the result of the temperature conversion in a formatted message

Combine the variables with literal strings passed into a series of
`Console.WriteLine()` commands to form the complete message.

When you're finished, the message should resemble the following output:

Output

```txt
The temperature is 34.444444444444444444444444447 Celsius.
```

> Note  
> Admittedly, it is preferred to not see so many values after the decimal point.
Ideally the value would be formatted to a single value after the decimal point:
34.4.