# numeric

***

**1. Initialize a Numeric Value**

```cpp
numeric<10> num1 = 1234567890;  // Initialize a numeric value with 10 digits
```

**2. Addition**

```cpp
numeric<10> num1 = 1234567890;
numeric<10> num2 = 1122334455;
numeric<10> result = num1 + num2;  // result = 2356902345
```

**3. Subtraction**

```cpp
numeric<10> num1 = 1234567890;
numeric<10> num2 = 1122334455;
numeric<10> result = num1 - num2;  // result = 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
```

**4. Multiplication**

```cpp
numeric<10> num1 = 1234567890;
numeric<10> num2 = 1122334455;
numeric<10> result = num1 * num2;  // result = 1385225090750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
```

**5. Division**

```cpp
numeric<10> num1 = 1234567890;
numeric<10> num2 = 1122334455;
numeric<10> result = num1 / num2;  // result = 1.1002197802197802197802197802197802197802197802197802197802197802197802197802197802197802197802197802
```

**6. Modulo**

```cpp
numeric<10> num1 = 1234567890;
numeric<10> num2 = 1122334455;
numeric<10> result = num1 % num2;  // result = 839959185
```

**7. Comparison Operators**

```cpp
numeric<10> num1 = 1234567890;
numeric<10> num2 = 1122334455;
bool is_equal = (num1 == num2);  // False
bool is_not_equal = (num1 != num2);  // True
bool is_greater = (num1 > num2);  // True
bool is_less = (num1 < num2);  // False
bool is_greater_or_equal = (num1 >= num2);  // True
bool is_less_or_equal = (num1 <= num2);  // False
```

**8. Increment Operator**

```cpp
numeric<10> num = 1234567890;
++num;  // num = 1234567891
```

**9. Decrement Operator**

```cpp
numeric<10> num = 1234567890;
--num;  // num = 1234567889
```

**10. Assignment Operator**

```cpp
numeric<10> num1 = 1234567890;
numeric<10> num2;
num2 = num1;  // num2 = 1234567890
```

**11. Addition Assignment Operator**

```cpp
numeric<10> num1 = 1234567890;
numeric<10> num2 = 1122334455;
num1 += num2;  // num1 = 2356902345
```

**12. Subtraction Assignment Operator**

```cpp
numeric<10> num1 = 1234567890;
numeric<10> num2 = 1122334455;
num1 -= num2;  // num1 = 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
```

**13. Multiplication Assignment Operator**

```cpp
numeric<10> num1 = 1234567890;
numeric<10> num2 = 1122334455;
num1 *= num2;  // num1 = 1385225090750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
```

**14. Division Assignment Operator**

```cpp
numeric<10> num1 = 1234567890;
numeric<10> num2 = 1122334455;
num1 /= num2;  // num1 = 1.1002197802197802197802197802197802197802197802197802197802197802197802197802197802197802197802197802
```

**15. Modulo Assignment Operator**

```cpp
numeric<10> num1 = 1234567890;
numeric<10> num2 = 1122334455;
num1 %= num2;  // num1 = 839959185
```

**16. String Conversion**

```cpp
numeric<10> num = 1234567890;
string num_str = to_string(num);  // num_str = "1234567890"
```

**17. Integer Conversion**

```cpp
numeric<10> num = 1234567890;
int num_int = static_cast<int>(num);  // num_int = 1234567890
```

**18. Double Conversion**

```cpp
numeric<10> num = 1234567890;
double num_double = static_cast<double>(num);  // num_double = 1.2345678901234567e+10
```

**19. Formatted Output**

```cpp
numeric<10> num = 1234567890;
cout << setprecision(15) << num << endl;  // Output: 1234567890.000000000000000
```

**20. Scientific Notation Output**

```cpp
numeric<10> num = 1234567890;
cout << scientific << num << endl;  // Output: 1.2345678901e+10
```

**21. Fixed-Point Number Input**

```cpp
numeric<10, 2> num;  // Create a numeric with 10 digits and 2 decimal places
cin >> num;  // Input a fixed-point number from the user
```

**22. Floating-Point Number Input**

```cpp
numeric<10> num;  // Create a numeric with 10 digits
cin >> num;  // Input a floating-point number from the user
```

**23. Reading a Number from a File**

```cpp
numeric<10> num;
ifstream infile("numbers.txt");
infile >> num;  // Read a number from the file
```

**24. Writing a Number to a File**

```cpp
numeric<10> num = 1234567890;
ofstream outfile("numbers.txt");
outfile << num;  // Write a number to the file
```

**25. Random Number Generation**

```cpp
numeric<10> num;
random_device rd;  // Obtain a random seed from the OS
mt19937 gen(rd());  // Seed the Mersenne Twister engine
uniform_int_distribution<numeric<10>::value_type> dist;  // Create a distribution for the numeric type
num = dist(gen);  // Generate a random number
```

**26. Counting Leading Zeros**

```cpp
numeric<10> num = 12345;
int leading_zeros = 0;
while (num < 10) {
  leading_zeros++;
  num *= 10;
}
```

**27. Finding the Maximum Value**

```cpp
numeric<10> num1 = 12345;
numeric<10> num2 = 67890;
numeric<10> max_num = max(num1, num2);  // max_num = 67890
```

**28. Finding the Minimum Value**

```cpp
numeric<10> num1 = 12345;
numeric<10> num2 = 67890;
numeric<10> min_num = min(num1, num2);  // min_num = 12345
```

**29. Rounding to the Nearest Integer**

```cpp
numeric<10> num = 123.456;
numeric<10> rounded_num = round(num);  // rounded_num = 123
```

**30. Truncating to the Integer Part**

```cpp
numeric<10> num = 123.456;
numeric<10> truncated_num = trunc(num);  // truncated_num = 123
```

**31. Calculating the Absolute Value**

```cpp
numeric<10> num = -123.456;
numeric<10> abs_num = abs(num);  // abs_num = 123.456
```

**32. Calculating the Square Root**

```cpp
numeric<10> num = 144;
numeric<10> sqrt_num = sqrt(num);  // sqrt_num = 12
```

**33. Calculating the Power**

```cpp
numeric<10> num = 2;
int exponent = 3;
numeric<10> pow_num = pow(num, exponent);  // pow_num = 8
```

**34. Calculating the Logarithm**

```cpp
numeric<10> num = 100;
numeric<10> log_num = log10(num);  // log_num = 2
```

**35. Converting to Binary**

```cpp
numeric<10> num = 123;
string binary_num = bitset<10>(num).to_string();  // binary_num = "1111011"
```

**36. Converting to Octal**

```cpp
numeric<10> num = 123;
string octal_num = bitset<10>(num).to_ulong();  // octal_num = "173"
```

**37. Converting to Hexadecimal**

```cpp
numeric<10> num = 123;
string hex_num = bitset<10>(num).to_string();  // hex_num = "7b"
```

**38. Swapping Two Numbers**

```cpp
numeric<10> num1 = 123;
numeric<10> num2 = 456;
num1 ^= num2;
num2 ^= num1;
num1 ^= num2;
```

**39. Checking if a Number is Prime**

```cpp
bool is_prime(numeric<10> num) {
  if (num <= 1) {
    return false;
  }
  for (numeric<10> i = 2; i * i <= num; i++) {
    if (num % i == 0) {
      return false;
    }
  }
  return true;
}
```

**40. Finding the GCD**

```cpp
numeric<10> gcd(numeric<10> num1, numeric<10> num2) {
  while (num2 != 0) {
    numeric<10> temp = num2;
    num2 = num1 % num2;
    num1 = temp;
  }
  return num1;
}
```

**41. Finding the LCM**

```cpp
numeric<10> lcm(numeric<10> num1, numeric<10> num2) {
  return (num1 * num2) / gcd(num1, num2);
}
```

**42. Finding the Factorial**

```cpp
numeric<10> factorial(numeric<10> num) {
  numeric<10> result = 1;
  for (numeric<10> i = 1; i <= num; i++) {
    result *= i;
  }
  return result;
}
```

**43. Finding the Fibonacci Number**

```cpp
numeric<10> fibonacci(numeric<10> num) {
  if (num <= 1) {
    return 1;
  }
  return fibonacci(num - 1) + fibonacci(num - 2);
}
```

**44. Solving a Linear Equation**

```cpp
numeric<10> solve_linear_equation(numeric<10> a, numeric<10> b) {
  if (a == 0) {
    throw invalid_argument("Coefficient 'a' cannot be zero.");
  }
  return -b / a;
}
```

**45. Solving a Quadratic Equation**

```cpp
pair<numeric<10>, numeric<10>> solve_quadratic_equation(numeric<10> a, numeric<10> b, numeric<10> c) {
  numeric<10> discriminant = b * b - 4 * a * c;
  if (discriminant < 0) {
    return pair<numeric<10>, numeric<10>>(NAN, NAN);  // Return complex roots
  }
  numeric<10> sqrt_discriminant = sqrt(discriminant);
  return pair<numeric<10>, numeric<10>>((-b + sqrt_discriminant) / (2 * a), (-b - sqrt_discriminant) / (2 * a));
}
```

**46. Calculating the Mean of an Array**

```cpp
numeric<10> mean(numeric<10> *array, int size) {
  numeric<10> sum = 0;
  for (int i = 0; i < size; i++) {
    sum += array[i];
  }
  return sum / size;
}
```

**47. Calculating the Median of an Array**

```cpp
numeric<10> median(numeric<10

```