Chapter 7: More Mathematics | Course Notes

Introduction

This Tutorial marks the end of the math-focused phase before moving into more advanced C# features. It covers several independent but essential topics that every developer needs to handle data correctly.

Core Topics Covered

Integer Division: Understanding how C# handles remainders when dividing whole numbers.
Typecasting (Casting): How to convert one data type to another ( int to double)
Dividing by Zero: What happens in C# when a denominator is zero
Special Constants: An introduction to infinity, NaN, and mathematical constants like $\pi$ and $e$
Errors & Limits: Identifying Overflow( exceeding variable limits) and Roundoff Error (decimal inaccuracies)
Increment/Decrement: Using ++ and — for efficient coding

Don’t skip Casting and Incrementing/Decrementing. These are functional tools you will use in almost every future project. While some details like roundoff errors are complex, this guide serves as a permanent reference for when you encounter advanced math logic later on

Integer Division

In everyday math, $7 \div 2 = 3.5$ However, in programming, when you divide two whole numbers (integers), the computer handles it differently.

Integer division is a type of division where the fractional part ( the remainder ) is completely discarded. The result is always a whole number.

2. How it works the computer finds the largest number of times the divisor fits into the dividend and “chops off” everything after the decimal point. it does not round the number to the nearest whole; it simply truncates it.

Example 1: 7/2 becomes 3 ( The .5 is ignored ).
Example 2: 99/100 becomes 0 ( Even though it is 0.99 and very close to 1, the fractional part is dropped).

3. When does this happen? integer division occurs whenever you use integer-based data types in C# These include.

int
short / ushort
long / ulong
byte / sbyte

4. Mixing Data Types ( The Trap) The rules of division depend on the types of the number involved. If you mix integers and floating-point numbers (like float or double) the behavior changes:

int a = 7;
int b = 2;

float c = 4.0f;
float d = 3.0f;

float result = ( a / b) + ( c / d);

Breaking it down

a / b Both are int Result is 3 (Integer Division)
c / d Both are float Result is 1.33333 (Standard Division)
Final Result: 3 + 1.33333 = 4.33333.

Decimal loss If you store the result of two integers in a float you still lose the decimal because the division happens before it is stored.
- Example float x = 7 / 2; will still result is 3.0, not 3.5
Precision matters: if you need the remainder or the decimal, at least one of the numbers in your equation must be a float or double
Advantage: Integer division is very useful when you only care about “whole groups” ( e.g: calculating how many full weeks are in 10 days 10/7 = 1 week).

Casting (Typecasting)

In programming, you often need to mix different types of number (like adding a small int to a big long ). To do this, C# uses a process called Casting ( or Typecasting ) Think of it as “converting” a value from one container type to another.

There are two main ways this happens: Implicit (automatic) and Explicit (manual)

Implicit (Up): byte → short → int → long → float → double
Explicit (Down): double → float → long → int → short → byte

1. Implicit Casting ( The Automatic Way)

Implicit casting happens “magically” when you move from a narrower type to wider type. Because the new container is bigger. there is no risk of losing data, so C# does it for you.

Rule of Thumb: small -> large = Automatic.
Example: An int (32-bit) fits easily into a long (64-bit)

int a = 4049;
long b = 284404039;

// C# automatically converts 'a' to a long before adding it to 'b'
long sum = a + b;

Note on Floating Points: float and double are considered “wider” than integers. If you do math with an int and a float, C# will automatically turn the int into a float to keep the decimal precision.

2. Implicit Casting ( The Automatic Way)

Explicit casting is required when you want to go from a wider type to narrower type. Since you might “overflow” the smaller container or lose decimal data, C# makes you confirm you want to do it.

Rule of thumb: Large -> small = manual.
Syntax: Put the desired type in Parentheses () before the value.

long bigNumber = 3; 
int smallNumber = (int)bigNumber; // you are telling c#: "I know what i'm doing".

You can cast almost any number type “down” the ladder, as long as you use the syntax. Look at the chain:

double to float: float f = (float)3.55555555; (Loses some precision)
float to long: long 1 = (long)f; (loses all decimals)
long to int : itn i = (int)l; (Loses capacity for huge numbers)
int to byte : byte b = (byte)i; ( can now only hold 0-255)

“Down” Casting = Data Surgery When you cast “Down,” you are performing surgery on you data. You might be cutting off decimals or cutting off the size of the number. C# requires the (type) syntax as your “signature” to perform the surgery.

2. The Order of operations Trap.

C# performs casting before math operations unless you use extra parentheses. This is a very common mistake for beginners!

Look at how the position of the cast changes the result of $7 \div 2 + 4$:

Scenario A: Casting a variable First

int a = 7;
int b = 2; 
int c = 4;

float result = a / (float)b + c;

What happens: b becomes 2.0f.
Because one number is a float a is implicitly cast to 7.0f.
Math: $7.0 / 2.0 = 3.5$. Then $3.5 + 4 = \mathbf{7.5}$.

Scenario B: Casting a Final Result

float result = (float) (a / b + c);

What happens: The math inside the parentheses happens first
a/b uses integer division (since both are ints), resulting in 3 .
3 + 4 = 7
Finally, the 7 is cast to a float, resulting in 7.0

Feature	Implicit Casting	Explicit Casting
Direction	Narrow ➔ Wide (e.g., `int` to `long`)	Wide ➔ Narrow (e.g., `double` to `int`)
Effort	Automatic (handled by C#)	Manual (requires parentheses)
Risk	Safe (No data loss)	Risky (Data might be cut off)
Example	`double d = 5;`	`int i = (int)5.5;` (Result is 5)

Division By Zero

In math, dividing by zero is “undefined” In C# the computer handles this in two very different ways depending on where you are using integers or floating-point numbers.

Integer Division by zero (The Crash) If you try to divide an int, long, or short by zero, the program doesn’t know how to handle the result because integers must be whole numbers, and “infinity” isn’t a whole number.

The Result: The program throws as Exception
What is an Exception? : Think of it a as a “Panic Attack” for your code. If you don’t’ “catch” the exception. your program will immediately crash and stop running.

	int a = 10;
	int b = 0;
	int result = a / b; // crash : System.DivideByZeroException

2.Floating-Point Division by Zero (The “Infinity” Result) Interestingly, float and double types do not crash your program. Instead, they use a special internal value to represent the result.

The Result: You get Infinity or (-Infinit) if the top number was negative.
Why? Floating-point standards (IEEE 754) allow for special values like infinity and NaN (Not a Number) so that complex math calculations can keep running without stopping the whole system.

float a = 10.0f;
float b = 0.0f;
float result = a / b; // no crash! result = Infinity

Data Type	Operation	Result	Program Status
Integer (`int`)	`10 / 0`	Exception	Crashes
Floating-Point (`float`/`double`)	`10.0 / 0.0`	Infinity	Keeps Running

What is NaN ? While we are talking about weird math, there is one more special value: NaN (Not a Number)

This happens if you do something even more “impossible” than dividing by zero, like dividing zero by zero using floats.
0.0 / 0.0 = NaN

Whenever you are writing a division like a/b it is a “Best Practice” to check if your divisor (b) is zero before you do the math. This prevents your app from crashing in the hands of a user!

if ( b != 0 ) {
	int result = a / b;
} else {
	Console.WriteLine("cannot divide by zero!");	
}

Special Numbers: Infinity, NaN, e, Pi, MinValue and MaxValue

When working with numbers in C#, there are “built-in” values that represent infinity, errors and famous mathematical constants. Using these makes your code more accurate and easier to read.

1.Infinity (Floating-point only)

As we learned float and double don’t’ crash when they hit a limit they just go to “infinity”

Positive Infinity: A value larger than any other number.
Negative Infinity: A value smaller than any other number.
Math with infinity: Adding or subtracting from infinity still results in infinity ( $\infty + 1 = \infty$)

double posInf = double.PositiveInfinity; 
float negInf = float.NegativeInfinity;

The reason int crashes and float/ double don’t is because they follow two different sets of “rules” created by computer scientists decades ago.

The Safety rule ( integers ) Integers are designed for exactness. If you are counting inventory or money (in paisa) being off by even a tiny bit is a disaster.

The Logic: if C# can’t give you the exact right answer ( because dividing by zero is impossible), it assumes your code has a major bug.
The action: it “creates” (throws an exception) to stop you from moving forward with a wrong number. Its like a safety fuse in a house it blows to protect the rest of the system.

The Keep going Rule (floats /doubles) floating-point numbers follow a global standard called IEEE 754. This standard was designed for scientific and engineering calculations (like physics engines in games or NASA trajectory math)

The logic: In massive scientific simulations, if you have one tiny error in a billion calculations, you don’t want the whole supercomputer to shut down. You want it to mark that one result as “infinity” or “invalid” and keep moving.
The Actions: instead of crashing, the CPU set a specific “bit pattern” in the memory that represents Infinity

What does “Hitting a Limit” actually mean? There are two ways to hit a limit:

Division by Zero
Going Out of bounds (overflow)

Division by Zero

Integer: 10/0 -> CRASH The CPU literally doesn’t have a whole number to represent this.
Float: 10.0/0.0 -> Infinity The IEEE 754 rule says: “if a positive number is divided by zero, return the special infinity symbol.”

Going “Out of bounds” (overflow) Every type has a MaxValue

Integer: If you go past int.MaxValue, it wraps around to the most negative number (like a car odometer flipping back to zero). This is called Overflow, but it usually doesn’t crash unless you specifically tell C# to check for it.
Float: If you calculate a number so huge that it’s bigger than float.MaxValue (which is a massive $3.4 \times 10^{38}$), C# just says: “This is too big for me to track anymore; let’s just call it Infinity.”

Think of it like this: > * Integers are like a strict accountant. If the math doesn’t add up perfectly, they close the shop and go home (Crash).

Floats are like a chill scientist. If the number gets too big or weird, they just label it “Infinite” and keep working (Infinity).

2.NaN (Not a Number)

NaN is a special value used when a mathematical operation is impossible to calculate. Think of NaN as the computer’s way of saying, “I have no idea what the answer is, and math rules have officially broken down” While Infinity represents a number that is just “too big to count” NaN represents a result that isn’t a number at all

Examples: $0.0 \div 0.0$ or $\infty \div \infty$
The Result: It isn’t a number at all, so C# labels it NaN

double bug = double.NaN; // Testing for it: 
bool isItBad = double.IsNaN(bug);

1. When does NaN happen?

NaN occurs during “Indeterminate Forms”—math problems that don’t have a logical answer even in advanced calculus.

Zero divided by Zero: 0.0 / 0.0
Infinity divided by Infinity: double.PositiveInfinity / double.PositiveInfinity
Infinity minus Infinity: double.PositiveInfinity - double.PositiveInfinity
Square root of a negative: Math.Sqrt(-1.0) (Since the result is an “imaginary number,” and double can only hold “real” numbers).

2. The “Contamination” Effect

This is the most important thing for students to know: NaN is contagious. Once a variable becomes NaN, almost any math you do with it will also result in NaN.

NaN + 10 = NaN
NaN * 0 = NaN
Math.Sqrt(NaN) = NaN

Analogy: Think of NaN like a drop of black ink in a glass of water. Once it’s in there, the whole glass is ruined. You can’t “clean it out” by adding more water (numbers).

3. The Equality Trap ( A Common Student Mistake )

This is a famous “gotcha” in C#. NaN is not equal to anything—including itself.

If you try to check if a calculation resulted in NaN using ==, it will always return false.


double result = 0.0 / 0.0; 
// This is NaN 
if (result == double.NaN) { 
// This code will NEVER run! // Logic: "Is this unknown thing equal to another unknown thing? No." 
}

You must use the built-in function double.IsNaN() or float.IsNaN().

if (double.IsNaN(result)) { 
Console.WriteLine("The calculation failed!"); 
}

4.Why do we need it ? Imagine you are coding a video game. A physics calculation goes wrong, and a character’s speed becomes NaN

If C# crashed, the player’s would close instantly.
By using NaN, the game stays open, you can check if (double.IsNaN(speed)) and if it’s true, you can just reset the character’s speed to 0 and keep the game running.

3.Famous Math Constants : $\pi$ and $e$

You don’t need to type 3.14159 manually! C# has a built-in “library” called the Math Class that holds these for you with maximum precision.

Math.PI: The ratio of a circle’s circumference to its diameter (~3.14159).
Math.E: The base of natural logarithms (~2.71828).

Example: Calculating the area of a circle ($Area = \pi r^2$):

double radius = 5; 
double area = Math.PI * radius * radius;

Method	What it does	Example	Result
`Math.PI`	Circular Constant	`Math.PI * 2`	`6.28...`
`Math.Pow`	Power/Exponent	`Math.Pow(2, 3)`	`8`
`Math.Sqrt`	Square Root	`Math.Sqrt(16)`	`4`
`Math.Max`	Finds the highest	`Math.Max(10, 20)`	`20`
`Math.Abs`	Removes negative sign	`Math.Abs(-5)`	`5`
`Math.Floor`	Forced round down	`Math.Floor(1.9)`	`1`

4.MinValue and MaxValue (The “Limits”)

Every numeric type has a “floor” and a “ceiling” . if you need to know that largest or smallest number a type can hold, you can ask the type itself.

MaxValue : The highest possible value.
MinValue: The lowest possible value.

int maxInt = int.MaxValue; // 2,147,483,647 
int minInt = int.MinValue; // -2,147,483,648 
sbyte maxByte = sbyte.MaxValue; // 127

Category	Type	Bits	MinValue	MaxValue	Common Use Case
Small Integers	`sbyte`	8	-128	127	Very small counters.
	`byte`	8	0	255	Raw data / Colors (RGB).
Medium Integers	`short`	16	-32,768	32,767	Older game systems.
	`ushort`	16	0	65,535	Character stats.
Standard Integers	`int`	32	-2.1 Billion	2.1 Billion	Default for whole numbers.
	`uint`	32	0	4.2 Billion	IDs / Address tracking.
Large Integers	`long`	64	Massive (18 digits)	Massive (18 digits)	World populations / Time.
	`ulong`	64	0	Massive (20 digits)	Crypto / Huge data.
Decimal Types	`float`	32	$-3.4 \times 10^{38}$	$3.4 \times 10^{38}$	Physics / Graphics (`3.5f`).
	`double`	64	$-1.7 \times 10^{308}$	$1.7 \times 10^{308}$	Default for decimals.

Overflow and RoundOff Error

When numbers get too large to too precise for their “containers” (data types), C# has to make a choice: wrap the number around or lose the tiny details. This leads to two important concepts: Overflow and Roundoff/Underflow Error.

1.Integer overflow (The “wrap-Around”) Every integer type has a “ceiling” (MaxValue) When you try to add more to a number that is already at its limit, the computer “drops” the extra data. Because of how computers handle binary math, this causes the number to flip from the highest positive to the lowest negative.

The concept: Think of a car’s odometer. if it hits 999,999 and you drive one more mile, it flips back to 000,000.
The result: Your program doesn’t crash; it just continues with a very “wrong” number.

int aNumber = int.MaxValue; // 2,147,483,647
aNumber = aNumber + 1;

Console.WriteLine(aNumber); // Output: -2,127,483,648 (The Minimum Value!)

2.Floating-Point Overflow (To Infinity) Floating-point types (float and double) handle overflow differently than integers. They don’t wrap around to negative numbers.

The Result : If a calculation becomes too large for a float or double to track, it simply becomes PositiveInfinity or NegativeInfinity
The Logic: It’s safer for a scientist to see “Infinity” than a random negative number.

3.Roundoff Error & Precision Limits This is a “hidden” error. A float can store a huge number, and it can store a tiny decimal, but it cannot store them at the same time if the difference between them is too great.

The Problem A float only has about 7 digits of “significant” precision.
the Scenario: If you add a tiny grain of sand to a massive mountain, the mountain’s weight doesn’t change in the computer’s eyes because the grain of sand is “below the resolution” of the float.

float big = 1_000_000_000f;
float tiny = 0.0000000001f;

float result = big + tiny;
// // Result: 1,000,000,000 (The tiny part was "ignored" or lost)

This is why we use the decimal type for money. In banking, losing even 0.00001 over millions of transactions add up to a huge mistake!

4.Underflow (The “Disappearing” Number) Underflow occurs when a number becomes so incredibly small (close to zero) that the computer can no longer represent it. Instead of keeping a tiny fraction, the computer just gives up and calls it 0

Feature	Integer Types (int, long)	Floating Point (float, double)
Overflow Result	Wrap-around (Positive becomes Negative)	Infinity
Precision	100% Accurate for whole numbers	Limited (Loses small decimals in big math)
Program Behavior	Keeps running with wrong data	Keeps running with Infinity/NaN
Safety Check	Can use `checked` mode to force a crash	Usually handled via logic checks

Incrementing and Decrementing

In Programming, we constantly count things (lives in a game, items in a shopping cart, loops in a cycle). Instead of writing score = score + 1, C# gives us a unary operator ( an operator that works on only one variable).

++ (Increment) : The “Plus One” button.
-- (Decrement): The “Minus One” button.

The Three Levels of Adding 1 All three of these lines do the exact same thing to variable a :

a = a + 1; The Manual Way (Clear, but wordy).
a += 1; The Shortcut Way (Common for adding numbers other than 1).
a++; The Professional Way (Fastest to type and read).

The “When” Matters : Prefix vs. Postfix

This is the part that trips up most students. The position of the ++ tells the computer when to do the math during a larger instructions.

Postfix Notation ( a++)

The Rule : “Use the current value now, but add 1 to the variable immediately after”.
The story: Imagine a waiter taking an order. He writes down your current order (5) and then goes to the kitchen to add an extra item to the total.

int x = 10;
int y = x++;  // y gets 10, then x becomes 11.

Prefix Notation (++a)

The Rule : “Add 1 to the variable immediately, then use that new value for the rest of the line”
The Story: The waiter adds the extra item to the bill before showing you the total. You see the new, higer number immediately.

int x = 10;
int y = ++x; // x becomes 11, then y get 11.

Code	Name	Value of Variable After	Value “Returned” to the Expression
`x++`	Postfix	Increased by 1	The Old value (before the plus).
`++x`	Prefix	Increased by 1	The New value (after the plus).
`x--`	Postfix	Decreased by 1	The Old value (before the minus).
`--x`	Prefix	Decreased by 1	The New value (after the minus).