omp_1

#include <omp.h>
#include <iostream>
#include <cmath>
#include <ctime>
#include <chrono>
#include <iomanip>
#include <algorithm>
#include <tuple>

using namespace std;

const double PI = 3.1415926535897932384626433832795;

double f(double x) {
    return 1 / (sqrt(x - x * x));
}

double integral(double a, double b, double h) {

    int n = (b - a) / h;

    double sum = 0.0;

    for (int i = 0; i < n; i++)
    {
        double x = a + i * h + h / 2;
        sum += f(x) * h;
    }

    return sum;
}

double integral_parallel(double a, double b, double h) {

    int n = (b - a) / h;

    double sum = 0.0;

    #pragma omp parallel for reduction(+: sum)
    for (int i = 0; i < n; i++)
    {
        double x = a + i * h + h / 2;
        sum += f(x) * h;
    }

    return sum;
}

double integral_simpson(double a, double b, double n) {

    double h = (b - a) / 2.0 / n;

    double sum1 = 0.0;

    for (int k = 1; k <= (int)n; k++)
    {
        sum1 += f(a + (2 * k - 1) * h);
    }

    double sum2 = 0.0;

    for (int k = 1; k <= (int)n - 1; ++k) {
        sum2 += f(a + 2 * k * h);
    }

    double res = h / 3 * (f(a) + f(b) + 4 * sum1 + 2 * sum2);

    return res;
}

double integral_simpson_parallel(double a, double b, double n) {

    double h = (b - a) / 2.0 / n;

    double sum1 = 0.0;


    #pragma omp parallel for reduction(+: sum1)
    for (int k = 1; k <= (int)n; k++)
    {
        sum1 += f(a + (2 * k - 1) * h);
    }

    double sum2 = 0.0;

    #pragma omp parallel for reduction(+: sum2)
    for (int k = 1; k <= (int)n - 1; k++) {
        sum2 += f(a + 2 * k * h);
    }

    double res = h / 3 * (f(a) + f(b) + 4 * sum1 + 2 * sum2);

    return res;
}

tuple<int, int, double> experiment(double a, double b, double h, double (*calc)(double, double, double), int n) {

    chrono::time_point<chrono::system_clock> start, end;

    int min_time, max_time;
    int sum = 0;
    bool first = true;

    for (int i = 0; i < n; ++i) {
        start = chrono::system_clock::now();
        calc(a, b, h);
        end = chrono::system_clock::now();

        int elapsed_nanoseconds = chrono::duration_cast<chrono::nanoseconds> (end - start).count();

        if (first) {
            min_time = elapsed_nanoseconds;
            max_time = elapsed_nanoseconds;
            first = false;
        }

        min_time = min(min_time, elapsed_nanoseconds);
        max_time = max(max_time, elapsed_nanoseconds);

        sum += elapsed_nanoseconds;

    }

    double avg_time = (double) sum / n;

    return { min_time, max_time, avg_time };
}

//3
int main() {

    double a = 1.0 / 2;
    double b = 3.0 / 4;
    double h = 0.00001;
    int N = 1000;

    cout << "Naive:" << endl;

    cout << setprecision(15) << fixed;
    cout << "Consistently:" << endl;
    cout << "Expected value: " << PI / 6 << endl;
    cout << "Current value: " << integral(a, b, h) << endl;
    auto res_c = experiment(a, b, h, integral, N);
    cout << "Min time: " << get<0>(res_c) << endl;
    cout << "Max time: " << get<1>(res_c) << endl;
    cout << "Avg time: " << get<2>(res_c) << endl;
    cout << endl;

    cout << "Parallel:" << endl;
    cout << "Expected value: " << PI / 6 << endl;
    cout << "Current value: " << integral(a, b, h) << endl;
    auto res_p = experiment(a, b, h, integral_parallel, N);
    cout << "Min time: " << get<0>(res_p) << endl;
    cout << "Max time: " << get<1>(res_p) << endl;
    cout << "Avg time: " << get<2>(res_p) << endl;
    cout << endl;

    int n = 10000;

    cout << "Simpson's Formula" << endl;
    cout << "Consistently:" << endl;
    cout << "Expected value: " << PI / 6 << endl;
    cout << "Current value: " << integral_simpson(a, b, n) << endl;
    auto res_s = experiment(a, b, h, integral_simpson, N);
    cout << "Min time: " << get<0>(res_s) << endl;
    cout << "Max time: " << get<1>(res_s) << endl;
    cout << "Avg time: " << get<2>(res_s) << endl;
    cout << endl;

    cout << "Simpson's Formula Parallel:" << endl;
    cout << "Expected value: " << PI / 6 << endl;
    cout << "Current value: " << integral_simpson_parallel(a, b, n) << endl;
    auto res_s_p = experiment(a, b, h, integral_simpson_parallel, N);
    cout << "Min time: " << get<0>(res_s_p) << endl;
    cout << "Max time: " << get<1>(res_s_p) << endl;
    cout << "Avg time: " << get<2>(res_s_p) << endl;
    cout << endl;


    system("pause");
    return 0;

}