Easy Learn C#

// Using the Math class
double result = Math.Sqrt(25);  // Square root of 25 = 5
Console.WriteLine(result);      // Output: 5
                            

Using Math Constants:

// Calculate the area of a circle with radius 5
double radius = 5;
double area = Math.PI * Math.Pow(radius, 2);
Console.WriteLine($"Area of circle: {area}");  // Output: Area of circle: 78.53981633974483

// Calculate compound interest
double principal = 1000;
double rate = 0.05;  // 5% interest
int time = 3;        // 3 years
double amount = principal * Math.Pow(Math.E, rate * time);
Console.WriteLine($"Amount after {time} years: {amount:C}");  // Output depends on culture settings
                            

Basic Math Functions Example:

// Absolute value
Console.WriteLine(Math.Abs(-10.5));  // Output: 10.5

// Ceiling and Floor
Console.WriteLine(Math.Ceiling(4.3));  // Output: 5
Console.WriteLine(Math.Floor(4.7));    // Output: 4

// Rounding
Console.WriteLine(Math.Round(4.3));    // Output: 4
Console.WriteLine(Math.Round(4.7));    // Output: 5
Console.WriteLine(Math.Round(4.5));    // Output: 4 (banker's rounding)
Console.WriteLine(Math.Round(5.5));    // Output: 6 (banker's rounding)
Console.WriteLine(Math.Round(4.567, 2));  // Output: 4.57 (round to 2 decimal places)

// Min and Max
Console.WriteLine(Math.Max(15, 20));  // Output: 20
Console.WriteLine(Math.Min(15, 20));  // Output: 15

// Power and Square Root
Console.WriteLine(Math.Pow(2, 4));    // Output: 16 (2^4)
Console.WriteLine(Math.Sqrt(81));     // Output: 9
                            

Trigonometric Functions Examples:

// Convert degrees to radians
double DegreesToRadians(double degrees)
{
    return degrees * Math.PI / 180.0;
}

// Convert radians to degrees
double RadiansToDegrees(double radians)
{
    return radians * 180.0 / Math.PI;
}

// Trigonometric functions with angles in degrees
double angle = 90;
double radians = DegreesToRadians(angle);

Console.WriteLine($"Sine of {angle} degrees: {Math.Sin(radians)}");             // Output: 1
Console.WriteLine($"Cosine of {angle} degrees: {Math.Cos(radians)}");           // Output: ~0
Console.WriteLine($"Tangent of {angle} degrees: {Math.Tan(radians)}");          // Output: Very large (undefined)

// Inverse trigonometric functions
double value = 0.5;
double arcSine = Math.Asin(value);
double arcCosine = Math.Acos(value);
double arcTangent = Math.Atan(value);

Console.WriteLine($"Arc sine of {value}: {RadiansToDegrees(arcSine)} degrees");     // Output: ~30 degrees
Console.WriteLine($"Arc cosine of {value}: {RadiansToDegrees(arcCosine)} degrees"); // Output: ~60 degrees
Console.WriteLine($"Arc tangent of {value}: {RadiansToDegrees(arcTangent)} degrees"); // Output: ~26.57 degrees

// Atan2 - determines the quadrant based on the signs of x and y
double y = 1.0;
double x = 1.0;
double angle2 = Math.Atan2(y, x);
Console.WriteLine($"Angle from x-axis to point ({x}, {y}): {RadiansToDegrees(angle2)} degrees"); // Output: 45 degrees
                            

Logarithmic Functions Examples:

// Exponential function (e^x)
Console.WriteLine(Math.Exp(1));      // Output: 2.718... (e)
Console.WriteLine(Math.Exp(2));      // Output: 7.389... (e^2)

// Natural logarithm (base e)
Console.WriteLine(Math.Log(Math.E));  // Output: 1
Console.WriteLine(Math.Log(7.389));   // Output: ~2 (because e^2 ≈ 7.389)

// Base 10 logarithm
Console.WriteLine(Math.Log10(10));    // Output: 1
Console.WriteLine(Math.Log10(100));   // Output: 2
Console.WriteLine(Math.Log10(1000));  // Output: 3

// Base 2 logarithm
Console.WriteLine(Math.Log2(2));      // Output: 1
Console.WriteLine(Math.Log2(8));      // Output: 3 (because 2^3 = 8)
Console.WriteLine(Math.Log2(1024));   // Output: 10 (because 2^10 = 1024)

// Custom base logarithm using the change of base formula: log_b(x) = log_e(x) / log_e(b)
double LogBase(double number, double base_value)
{
    return Math.Log(number) / Math.Log(base_value);
}

Console.WriteLine(LogBase(27, 3));  // Output: 3 (because 3^3 = 27)
Console.WriteLine(LogBase(16, 4));  // Output: 2 (because 4^2 = 16)
                            

Random Number Generation Examples:

// Create a Random object
Random random = new Random();

// Generate a random integer between 0 and 100 (exclusive of 100)
int randomInt = random.Next(100);
Console.WriteLine($"Random integer (0-99): {randomInt}");

// Generate a random integer within a specific range (min inclusive, max exclusive)
int randomRange = random.Next(10, 21);  // 10 to 20
Console.WriteLine($"Random integer (10-20): {randomRange}");

// Generate a random double between 0.0 and 1.0
double randomDouble = random.NextDouble();
Console.WriteLine($"Random double (0-1): {randomDouble}");

// Generate a random double within a specific range
double randomDoubleRange = random.NextDouble() * (20 - 10) + 10;  // 10.0 to 20.0
Console.WriteLine($"Random double (10-20): {randomDoubleRange}");

// Generate a sequence of random bytes
byte[] buffer = new byte[5];
random.NextBytes(buffer);
Console.WriteLine("Random bytes: " + string.Join(", ", buffer));

// Notes on Random class usage:
// 1. Don't create a new Random object for each random number - reuse it
// 2. For cryptographic purposes, use System.Security.Cryptography.RandomNumberGenerator instead
// 3. In .NET 6+ you can use the static Random.Shared property for better performance in concurrent scenarios
                            

Advanced Math Functions Examples:

// Math.Sign - returns -1 for negative, 0 for zero, and 1 for positive values
Console.WriteLine(Math.Sign(-10));  // Output: -1
Console.WriteLine(Math.Sign(0));    // Output: 0
Console.WriteLine(Math.Sign(10));   // Output: 1

// Math.Truncate - removes the fractional part (different from Floor for negative numbers)
Console.WriteLine(Math.Truncate(5.7));   // Output: 5
Console.WriteLine(Math.Truncate(-5.7));  // Output: -5 (Floor would be -6)

// Math.IEEERemainder - different from % operator
// Formula: x - y * round(x / y)
Console.WriteLine(Math.IEEERemainder(9, 4));   // Output: 1 (9 - 4 * 2)
Console.WriteLine(9 % 4);                      // Output: 1 (regular remainder)
Console.WriteLine(Math.IEEERemainder(5, 2));   // Output: 1 (5 - 2 * 2)
Console.WriteLine(5 % 2);                      // Output: 1 (regular remainder)
Console.WriteLine(Math.IEEERemainder(3, 2));   // Output: -1 (3 - 2 * 2)
Console.WriteLine(3 % 2);                      // Output: 1 (regular remainder)

// Math.Clamp - restricts a value to be within a specified range
Console.WriteLine(Math.Clamp(5, 0, 10));    // Output: 5 (within range)
Console.WriteLine(Math.Clamp(-5, 0, 10));   // Output: 0 (below min)
Console.WriteLine(Math.Clamp(15, 0, 10));   // Output: 10 (above max)

// Math.BitIncrement and Math.BitDecrement (C# 8.0+)
// Get the next and previous IEEE 754 floating-point representation
Console.WriteLine(Math.BitIncrement(0.0));  // Output: 5E-324 (smallest positive value)
Console.WriteLine(Math.BitDecrement(0.0));  // Output: -5E-324 (smallest negative value)
                            

Custom Math Functions Examples:

// Calculate the hypotenuse of a right triangle using the Pythagorean theorem
double Hypotenuse(double a, double b)
{
    return Math.Sqrt(a * a + b * b);
}
Console.WriteLine($"Hypotenuse of a 3-4-5 triangle: {Hypotenuse(3, 4)}");  // Output: 5

// Convert degrees to radians
double DegreesToRadians(double degrees)
{
    return degrees * Math.PI / 180.0;
}
Console.WriteLine($"45 degrees in radians: {DegreesToRadians(45)}");  // Output: ~0.785398

// Convert radians to degrees
double RadiansToDegrees(double radians)
{
    return radians * 180.0 / Math.PI;
}
Console.WriteLine($"π/4 radians in degrees: {RadiansToDegrees(Math.PI / 4)}");  // Output: 45

// Calculate factorial (n!)
long Factorial(int n)
{
    if (n < 0) throw new ArgumentException("Factorial is not defined for negative numbers.");
    if (n > 20) throw new ArgumentException("Result would overflow a long.");
    
    long result = 1;
    for (int i = 2; i <= n; i++)
    {
        result *= i;
    }
    return result;
}
Console.WriteLine($"5! = {Factorial(5)}");  // Output: 120

// Calculate the n-th Fibonacci number
int Fibonacci(int n)
{
    if (n < 0) throw new ArgumentException("Index cannot be negative.");
    if (n <= 1) return n;
    
    int a = 0, b = 1;
    for (int i = 2; i <= n; i++)
    {
        int temp = a;
        a = b;
        b = temp + b;
    }
    return b;
}
Console.WriteLine($"10th Fibonacci number: {Fibonacci(10)}");  // Output: 55

// Check if a number is prime
bool IsPrime(int number)
{
    if (number <= 1) return false;
    if (number <= 3) return true;
    if (number % 2 == 0 || number % 3 == 0) return false;
    
    for (int i = 5; i * i <= number; i += 6)
    {
        if (number % i == 0 || number % (i + 2) == 0)
            return false;
    }
    return true;
}
Console.WriteLine($"Is 17 prime? {IsPrime(17)}");  // Output: True
Console.WriteLine($"Is 20 prime? {IsPrime(20)}");  // Output: False
                            

Performance Optimization Examples:

// Avoid redundant calculations
double radius = 5;
// Inefficient - calculates the square twice
double perimeter = 2 * Math.PI * radius;
double area = Math.PI * Math.Pow(radius, 2);

// More efficient - calculate the square once
double radiusSquared = radius * radius;
double area2 = Math.PI * radiusSquared;

// For performance-critical trigonometric calculations on many values
// consider precomputing commonly used values
Dictionary sinTable = new Dictionary();
for (int degree = 0; degree < 360; degree++)
{
    sinTable[degree] = Math.Sin(DegreesToRadians(degree));
}

// Later, use the lookup table instead of calculating each time
double sinValue = sinTable[45];  // Much faster than Math.Sin(DegreesToRadians(45))

// Use System.Numerics for SIMD operations (C# 8.0+)
using System.Numerics;

Vector v1 = new Vector(new[] { 1.0f, 2.0f, 3.0f, 4.0f });
Vector v2 = new Vector(new[] { 5.0f, 6.0f, 7.0f, 8.0f });
Vector result = Vector.Multiply(v1, v2); // Performs parallel multiplication