# tgmath

***

**1. Calculating Sine and Cosine Values**

```cpp
#include <tgmath.h>

double angle_radians = 45.0 * (M_PI / 180.0);
double sine_value = sin(angle_radians);
double cosine_value = cos(angle_radians);

cout << "Sine value: " << sine_value << endl;
cout << "Cosine value: " << cosine_value << endl;
```

**2. Solving Trigonometric Equations**

```cpp
#include <tgmath.h>

double angle = atan2(opposite, adjacent);

cout << "Angle in radians: " << angle << endl;
```

**3. Converting Degrees to Radians**

```cpp
#include <tgmath.h>

double angle_degrees = 45.0;
double angle_radians = angle_degrees * (M_PI / 180.0);

cout << "Angle in radians: " << angle_radians << endl;
```

**4. Calculating the Hypotenuse of a Right Triangle**

```cpp
#include <tgmath.h>

double opposite = 3.0;
double adjacent = 4.0;
double hypotenuse = sqrt(pow(opposite, 2) + pow(adjacent, 2));

cout << "Hypotenuse: " << hypotenuse << endl;
```

**5. Finding the Area of a Circle**

```cpp
#include <tgmath.h>

double radius = 5.0;
double area = M_PI * pow(radius, 2);

cout << "Area of circle: " << area << endl;
```

**6. Calculating the Circumference of a Circle**

```cpp
#include <tgmath.h>

double radius = 5.0;
double circumference = 2 * M_PI * radius;

cout << "Circumference of circle: " << circumference << endl;
```

**7. Finding the Slope of a Line**

```cpp
#include <tgmath.h>

double x1 = 1.0;
double y1 = 2.0;
double x2 = 3.0;
double y2 = 4.0;
double slope = (y2 - y1) / (x2 - x1);

cout << "Slope of line: " << slope << endl;
```

**8. Solving Quadratic Equations**

```cpp
#include <tgmath.h>

double a = 1.0;
double b = -5.0;
double c = 6.0;
double discriminant = pow(b, 2) - 4 * a * c;

cout << "Discriminant: " << discriminant << endl;
```

**9. Finding the Roots of a Complex Number**

```cpp
#include <tgmath.h>
#include <complex>

complex<double> c = 3.0 + 4.0i;
complex<double> roots[2];

cmath::sqrt(c, roots);

cout << "Roots: " << roots[0] << ", " << roots[1] << endl;
```

**10. Calculating the Variance of a Data Set**

```cpp
#include <tgmath.h>

double data[] = {1.0, 2.0, 3.0, 4.0, 5.0};
size_t n = sizeof(data) / sizeof(data[0]);
double sum = 0.0;
for (size_t i = 0; i < n; i++)
  sum += data[i];
double mean = sum / n;
double variance = 0.0;
for (size_t i = 0; i < n; i++)
  variance += pow(data[i] - mean, 2);
variance /= n;

cout << "Variance: " << variance << endl;
```

**11. Finding the Standard Deviation of a Data Set**

```cpp
#include <tgmath.h>

double data[] = {1.0, 2.0, 3.0, 4.0, 5.0};
size_t n = sizeof(data) / sizeof(data[0]);
double sum = 0.0;
for (size_t i = 0; i < n; i++)
  sum += data[i];
double mean = sum / n;
double variance = 0.0;
for (size_t i = 0; i < n; i++)
  variance += pow(data[i] - mean, 2);
variance /= n;
double standard_deviation = sqrt(variance);

cout << "Standard deviation: " << standard_deviation << endl;
```

**12. Calculating the Probability Density Function of a Normal Distribution**

```cpp
#include <tgmath.h>

double mean = 0.0;
double standard_deviation = 1.0;
double x = 1.5;
double pdf = 1 / (standard_deviation * sqrt(2 * M_PI)) * exp(-pow(x - mean, 2) / (2 * pow(standard_deviation, 2)));

cout << "Probability density function: " << pdf << endl;
```

**13. Finding the Mode of a Data Set**

```cpp
#include <tgmath.h>
#include <algorithm>

double data[] = {1.0, 2.0, 3.0, 4.0, 5.0, 2.0, 3.0};
size_t n = sizeof(data) / sizeof(data[0]);
sort(data, data + n);
double mode = data[n / 2];

cout << "Mode: " << mode << endl;
```

**14. Calculating the Median of a Data Set**

```cpp
#include <tgmath.h>
#include <algorithm>

double data[] = {1.0, 2.0, 3.0, 4.0, 5.0};
size_t n = sizeof(data) / sizeof(data[0]);
sort(data, data + n);
double median = n % 2 == 0 ? (data[n / 2] + data[n / 2 - 1]) / 2 : data[n / 2];

cout << "Median: " << median << endl;
```

**15. Finding the Quartiles of a Data Set**

```cpp
#include <tgmath.h>
#include <algorithm>

double data[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0};
size_t n = sizeof(data) / sizeof(data[0]);
sort(data, data + n);
double q1 = data[n / 4];
double q2 = data[n / 2];
double q3 = data[3 * n / 4];

cout << "Quartiles: Q1=" << q1 << ", Q2=" << q2 << ", Q3=" << q3 << endl;
```

**16. Calculating the Interquartile Range of a Data Set**

```cpp
#include <tgmath.h>
#include <algorithm>

double data[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0};
size_t n = sizeof(data) / sizeof(data[0]);
sort(data, data + n);
double q1 = data[n / 4];
double q3 = data[3 * n / 4];
double iqr = q3 - q1;

cout << "Interquartile range: " << iqr << endl;
```

**17. Finding the Outliers in a Data Set**

```cpp
#include <tgmath.h>
#include <algorithm>

double data[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 100.0};
size_t n = sizeof(data) / sizeof(data[0]);
sort(data, data + n);
double q1 = data[n / 4];
double q3 = data[3 * n / 4];
double iqr = q3 - q1;
double lower_outlier_threshold = q1 - 1.5 * iqr;
double upper_outlier_threshold = q3 + 1.5 * iqr;

for (size_t i = 0; i < n; i++) {
  if (data[i] < lower_outlier_threshold || data[i] > upper_outlier_threshold)
    cout << "Outlier: " << data[i] << endl;
}
```

**18. Calculating the Correlation Coefficient between Two Data Sets**

```cpp
#include <tgmath.h>

double data1[] = {1.0, 2.0, 3.0, 4.0, 5.0};
double data2[] = {2.0, 4.0, 6.0, 8.0, 10.0};
size_t n = sizeof(data1) / sizeof(data1[0]);
double sumx = 0.0, sumy = 0.0, sumx2 = 0.0, sumy2 = 0.0, sumxy = 0.0;
for (size_t i = 0; i < n; i++) {
  sumx += data1[i];
  sumy += data2[i];
  sumx2 += pow(data1[i], 2);
  sumy2 += pow(data2[i], 2);
  sumxy += data1[i] * data2[i];
}
double correlation_coefficient = (n * sumxy - sumx * sumy) / (sqrt(n * sumx2 - pow(sumx, 2)) * sqrt(n * sumy2 - pow(sumy, 2)));

cout << "Correlation coefficient: " << correlation_coefficient << endl;
```

**19. Finding the Linear Regression Line for Two Data Sets**

```cpp
#include <tgmath.h>

double data1[] = {1.0, 2.0, 3.0, 4.0, 5.0};
double data2[] = {2.0, 4.0, 6.0, 8.0, 10.0};
size_t n = sizeof(data1) / sizeof(data1[0]);
double sumx = 0.0, sumy = 0.0, sumx2 = 0.0, sumy2 = 0.0, sumxy = 0.0;
for (size_t i = 0; i < n; i++) {
  sumx += data1[i];
  sumy += data2[i];
  sumx2 += pow(data1[i], 2);
  sumy2 += pow(data2[i], 2);
  sumxy += data1[i] * data2[i];
}
double slope = (n * sumxy - sumx * sumy) / (n * sumx2 - pow(sumx, 2));
double intercept = (sumy - slope * sumx) / n;

cout << "Slope: " << slope << endl;
cout << "Intercept: " << intercept << endl;
```

**20. Calculating the Minimum Value of a Data Set**

```cpp
#include <tgmath.h>

double data[] = {1.0, 2.0, 3.0, 4.0, 5.0};
size_t n = sizeof(data) / sizeof(data[0]);
double min_value = DBL_MAX;
for (size_t i = 0; i < n; i++) {
  if (data[i] < min_value)
    min_value = data[i];
}

cout << "Minimum value: " << min_value << endl;
```

**21. Finding the Maximum Value of a Data Set**

```cpp
#include <tgmath.h>

double data[] = {1.0, 2.0, 3.0, 4.0, 5.0};
size_t n = sizeof(data) / sizeof(data[0]);
double max_value = DBL_MIN;
for (size_t i = 0; i < n; i++) {
  if (data[i] > max_value)
    max_value = data[i];
}

cout << "Maximum value: " << max_value << endl;
```

**22. Calculating the Sum of a Data Set**

```cpp
#include <tgmath.h>

double data[] = {1.0, 2.0, 3.0, 4.0, 5.0};
size_t n = sizeof(data) / sizeof(data[0]);
double sum = 0.0;
for (size_t i = 0; i < n; i++)
  sum += data[i];

cout << "Sum: " << sum << endl;
```

**23. Finding the Product of a Data Set**

```cpp
#include <tgmath.h>

double data[] = {1.0, 2.0, 3.0, 4.0, 5.0};
size_t n = sizeof(data) / sizeof(data[0]);
double product = 1.0;
for (size_t i = 0; i < n; i++)
  product *= data[i];

cout << "Product: " << product << endl;
```

**24. Calculating the Mean of a Data Set**

```cpp
#include <tgmath.h>

double data[] = {1.0, 2.0, 3.0, 4.0, 5.0};
size_t n = sizeof(data) / sizeof(data[0]);
double sum = 0.0;
for (size_t i = 0; i < n; i++)
  sum += data[i];
double mean = sum / n;

cout << "Mean: " << mean << endl;
```

**25. Finding the Range of a Data Set**

```cpp
#include <tgmath.h>

double data[] = {1.0, 2.0, 3.0, 4.0, 5.0};
size_t n = sizeof(data) / sizeof(data[0]);
double min_value = DBL_MAX;
double max_value = DBL_MIN;
for (size_t i = 0; i < n; i++) {
  if (data[i] < min_value)
    min_value = data[i];
  if (data[i] > max_value)
    max_value = data[i];
}
double range = max_value - min_value;

cout << "Range: " << range << endl;
```

**26. Calculating the Absolute Deviation from the Mean**

```cpp
#include <tgmath.h>

double data[] = {1.0, 2.0, 3.0, 4.0, 5.0};
size_t n = sizeof(data) / sizeof(data[0]);
double sum = 0.0;
for (size_t i = 0; i < n; i++)
  sum += data[i];
double mean = sum / n;
double sum_absolute_deviation = 0.0;
for (size_t i = 0

```