PRIR LAB 3

#define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_WARNINGS

#include <math.h>
#include <conio.h>
#include <cstdio>
#include <omp.h>
#include <cmath>

double f(double x)
{
    return sin(x);
}

double CalkujSekwencyjne(double Start, double Stop, int Precision, double dx)
{
    double SUM = 0;

    for (double x = Start; x < Stop; x += dx)
    {
        SUM += f(x) * dx;
    }

    return SUM;
}

double CalkujRownolegleReduction(double Start, double Stop, int Precision, double dx, int ThreadsNum)
{
    double SUMA = 0;
    double x = Start;

    int start = 0;
    int i = 0;

#pragma omp parallel for shared(x,Precision,dx,start,Start) private(i) num_threads(ThreadsNum) reduction(+ : SUMA)
    for (i = start; i < Precision; i++)
    {
        SUMA += f(Start + i*dx)*dx;
        x += dx;
    }
    //SUMA *= dx;

    return SUMA;
}

double CalkujRownolegleAtomic(double Start, double Stop, int Precision, double dx, int ThreadsNum)
{
    double SUM = 0;
    double x = Start;

    int start = 0;
    int i = 0;

#pragma omp parallel shared(x,Precision,dx,start,Start,SUM) private(i) num_threads(ThreadsNum)
    {
        double Result = 0;
#pragma omp for
        for (i = start; i < Precision; i++)
        {
            x += dx;
            Result += f(Start + i*dx)*dx;
        }
#pragma omp atomic
        SUM += Result;
    }
    //SUM *= dx;

    return SUM;
}

void AtomicAndReductionFor(double Start, double Stop, int Precision, double dx, int ThreadsNum)
{
    double Time; // Czas pracy algorytmu
    double Result; // Wynik algorytmu

    // Calkowanie rownolegle (atomic)
    printf("Rownolegle atomic %d\n", ThreadsNum);

    Time = omp_get_wtime();// Pobranie aktualnego czasu
    Result = CalkujRownolegleAtomic(Start, Stop, Precision, dx, ThreadsNum);// Calkowanie rownolegle

    printf("Czas: %lf\n", omp_get_wtime() - Time);// Obliczenie czasu trwania algorytmu
    printf("Wynik: %.10lf\n", Result);// Wynik algorytmu

    printf("\n");

    // Calkowanie rownolegle (reduction)
    printf("Rownolegle reduction %d\n", ThreadsNum);

    Time = omp_get_wtime();// Pobranie aktualnego czasu
    Result = CalkujRownolegleReduction(Start, Stop, Precision, dx, ThreadsNum);// Calkowanie rownolegle

    printf("Czas: %lf\n", omp_get_wtime() - Time);// Obliczenie czasu trwania algorytmu
    printf("Wynik: %.10lf\n", Result);// Wynik algorytmu
}

int main()
{
    double Start = 0; // Startatek zakresu calkowania
    double Stop = M_PI_2; // Stop zakresu calkowania
    long long int Precision = 100000000; // Dokladnosc

    double Time; // Czas pracy algorytmu
    double Result; // Wynik algorytmu

    // Obliczenie dx (wielkosci skoku)
    double dx = (Stop - Start) / Precision;

    // Calkowanie sekwencyjne
    printf("Sekwencyjnie\n");

    Time = omp_get_wtime(); // Pobranie aktualnego czasu
    Result = CalkujSekwencyjne(Start, Stop, Precision, dx); // Calkowanie sekwencyjne

    printf("Czas: %lf\n", omp_get_wtime() - Time); // Obliczenie czasu trwania algorytmu
    printf("Wynik: %.10lf\n", Result); // Wynik algorytmu

    printf("\n");

    AtomicAndReductionFor(Start, Stop, Precision, dx, 4);
    printf("\n--------------------\n");
    AtomicAndReductionFor(Start, Stop, Precision, dx, 8);
    printf("\n--------------------\n");
    AtomicAndReductionFor(Start, Stop, Precision, dx, 16);

    _getch();
    return 0;
}