# Mathematical Calculations

## Mathematical operations in C#.

### C# Language

#### QnA

* You can also perform mathematical calculations using the 'System' namespace, as like strings.

## C# Mathematics

Mathematics in C# can involve a wide range of calculations, from basic arithmetic operations to more advanced mathematical functions and algorithms. Let's dive into some common areas:

### Arithmetic Operations:

```int a = 10;
int b = 5;
int sum = a + b;        // Addition
int difference = a - b; // Subtraction
int product = a * b;    // Multiplication
int quotient = a / b;   // Division```

C# supports all basic arithmetic operations such as addition, subtraction, multiplication, and division. These operations can be performed using the standard operators '+', '-', '*', and '/'.

### Math Class:

```double sqrtResult = Math.Sqrt(25);     // Square root
double powerResult = Math.Pow(2, 3);    // Power (2^3)
double sinResult = Math.Sin(Math.PI / 2);  // Sine (90 degrees)
double logResult = Math.Log(10);        // Natural logarithm```

C# provides a 'Math' class in the 'System' namespace, which contains many static methods for performing common mathematical functions such as square root, power, trigonometric functions, logarithms, etc.

### Random Numbers:

```Random rand = new Random();
// Generates a random number between 1 and 100
int randomNumber = rand.Next(1, 101);```

Generating random numbers is often needed in mathematical simulations, games, and statistical analysis. C# provides the 'Random' class in the 'System' namespace for generating random numbers.

### Numeric Conversions:

```int intNumber = 10;
// Implicit conversion from int to double
double doubleNumber = intNumber;

// Explicit conversion from double to int
double doubleNumber2 = 10.5;
int intNumber2 = (int)doubleNumber2; ```

C# supports implicit and explicit conversions between numeric data types. It's essential to understand these conversions to avoid loss of precision or data truncation.

### Complex Numbers:

```public struct Complex
{
public double Real;
public double Imaginary;

public Complex(double real, double imaginary)
{
Real = real;
Imaginary = imaginary;
}

// Implement arithmetic operations for complex numbers
// Addition, Subtraction, Multiplication, Division, etc.
}```

Although not built into the standard library, you can implement complex number arithmetic using structs or classes. Complex numbers have real and imaginary parts and are widely used in engineering and physics.

### Numerical Analysis:

```using MathNet.Numerics.Integration;

Func＜double, double> f = x => x * x;
// Numerical integration using Simpson's rule
double integral = SimpsonRule.IntegrateComposite(f, 0, 1, 100);```

For advanced mathematical calculations like numerical integration, solving differential equations, and optimization, you may need to use external libraries like Math.NET Numerics or ILNumerics.

### Custom Mathematical Functions:

```// Custom function to calculate factorial
static int Factorial(int n)
{
if (n == 0)
return 1;
else
return n * Factorial(n - 1);
}```

You can define your own mathematical functions or algorithms as per your requirements.

By leveraging these tools and techniques, you can perform a wide range of mathematical calculations in C# with precision and efficiency.

Here's a simple example demonstrating some common math calculations:

cs Copy Code
```using System;

class Program
{
static void Main(string[] args)
{
// Basic Arithmetic Operations
int a = 10;
int b = 5;
int sum = a + b;
int difference = a - b;
int product = a * b;
int quotient = a / b;
Console.WriteLine(\$"Sum: {sum}, Difference: {difference}");
Console.WriteLine(\$"Product: {product}, Quotient: {quotient}");

// Math Class
double sqrtResult = Math.Sqrt(25);
double powerResult = Math.Pow(2, 3);
double sinResult = Math.Sin(Math.PI / 2);
double logResult = Math.Log(10);
Console.WriteLine(\$"Square root of 25: {sqrtResult}");
Console.WriteLine(\$"2^3: {powerResult}");
Console.WriteLine(\$"Sin(90 degrees): {sinResult}");
Console.WriteLine(\$"Natural Logarithm of 10: {logResult}");

// Random Numbers
Random rand = new Random();
int randomNumber = rand.Next(1, 101);
Console.WriteLine(\$"Random Number between 1 and 100: {randomNumber}");

// Numeric Conversions
int intNumber = 10;
double doubleNumber = intNumber;
double doubleNumber2 = 10.5;
int intNumber2 = (int)doubleNumber2;
Console.WriteLine(\$"Implicit Conversion: int to double: {doubleNumber}");
Console.WriteLine(\$"Explicit Conversion: double to int: {intNumber2}");

// Complex Numbers (Simple Example)
Complex complex1 = new Complex(3, 4);
Complex complex2 = new Complex(1, 2);
Console.WriteLine(\$"Sum of Complex Numbers: {sumComplex.Real} + {sumComplex.Imaginary}i");

// Numerical Integration (Simple Example: Trapezoidal Rule)
double integral = NumericalIntegration(x => x * x, 0, 1, 100);
Console.WriteLine(\$"Integral of x^2 from 0 to 1: {integral}");
}

// Trapezoidal Rule for Numerical Integration
static double NumericalIntegration(Func＜double, double> func, double a, double b, int n)
{
double h = (b - a) / n;
double sum = (func(a) + func(b)) / 2.0;

for (int i = 1; i < n; i++)
{
double x = a + i * h;
sum += func(x);
}

return sum * h;
}
}

// Complex Number Structure
public struct Complex
{
public double Real;
public double Imaginary;

public Complex(double real, double imaginary)
{
Real = real;
Imaginary = imaginary;
}

{
return new Complex(Real + other.Real, Imaginary + other.Imaginary);
}
}```
Output:
```Sum: 15, Difference: 5
Product: 50, Quotient: 2
Square root of 25: 5
2^3: 8
Sin(90 degrees): 1
Natural Logarithm of 10: 2.302585092994046
Random Number between 1 and 100: 96
Implicit Conversion: int to double: 10
Explicit Conversion: double to int: 10
Sum of Complex Numbers: 4 + 6i
Integral of x^2 from 0 to 1: 0.33335000000000004```

#### What's Next?

We've now entered the finance section on this platform, where you can enhance your financial literacy.