//    Student: Den Kryvoshey
//    Group:   IO-71
//
//    F1 = A = B + C + D*(MD*ME)
//    F2 = MF=MF*MG*k
//    F3 = (MP *MR)*S + T

#include "Data.h"
#include <windows.h>
#include <iostream>
#include <mpi.h>

#define N 3

#pragma push_macro("max")
#undef max

void Thread1();
void Thread2();
void Thread3();

using namespace std;

int main(int argc, char** argv)
{

    MPI_Init(&argc, &argv);
#pragma comment(linker, "/STACK:400000000")

    int tid;

    MPI_Comm_rank(MPI_COMM_WORLD, &tid);

    //switch (tid)
    //{
    //case 0:
    //  Thread1();
    //  break;
    //case 1:
    //  Thread2();
    //  break;
    //case 2:
    //  Thread3();
    //  break;
    //}

    Thread1();
    Thread2();
    Thread3();

    MPI_Finalize();

    //system("pause");
    return 0;
}

void Thread1()
{
    cout << "Thread 1 started!\n";

    Vector* A = new Vector(N, true);
    Vector* B = new Vector(N, true);
    Vector* C = new Vector(N, true);
    Vector* D = new Vector(N, true);
    Matrix* MD = new Matrix(N, true);
    Matrix* ME = new Matrix(N, true);

    D = *(*B + *B) + *(*(*MD * *ME) * *D);
    delete A, B, C, MD, ME;
    Sleep(1000);
    printf("F1 =\n");
    D->print();

    cout << "Thread 1 finished execution!\n";
}

void Thread2()
{
    cout << "Thread 2 started!\n";

    Matrix* MF = new Matrix(N, true);
    Matrix* MK = new Matrix(N, true);
    long k = 1;
    //Matrix* ML = (*MF->transpose() * *MK)->sort();
    //Matrix* ML = (*(*MF * *MK) * k);
    Matrix* ML = (*MF * *MK);

    Sleep(100);
    printf("F2 = \n");
    ML->print();
    delete MF, MK, ML;

    cout << "Thread 2 finished execution!\n";
}

void Thread3()
{
    cout << "Thread 3 started!\n";

    Vector* T = new Vector(N, true);
    Vector* S = new Vector(N, true);
    Matrix* MR = new Matrix(N, true);
    Matrix* MP = new Matrix(N, true);
    Matrix* MS = new Matrix(N, true);

    Vector A = *(*(*(*MP * *MR) * *S) + *T) ;
    delete T, S, MR, MP, MS;
    printf("F3 = \n");
    A.print();
    cout << "Thread 3 finished execution\n";
}









#pragma once


#ifndef LAB5_DATA_H
#define LAB5_DATA_H


class Vector {
private:
    int _size;
    int* _data;

public:
    Vector(int size, bool fill);

    ~Vector();

    Vector* operator+(Vector& that);

    void setElement(int index, int value);

    void print();

    int operator*(Vector& that);

    int getElement(int index);

    int max();
};

class Matrix {
private:
    int _size;
    int** _data;

public:
    Matrix(int size, bool fill);

    ~Matrix();

    Matrix* operator+(Matrix& that);

    Matrix* operator-(Matrix& that);

    Matrix* operator*(Matrix& that);

    Matrix* operator*(long& that);

    Vector* operator*(Vector& vector);

    void print();
};

#endif










#include "Data.h"

#include <iostream>

using namespace std;

Matrix::Matrix(int size, bool fill)
{
    _size = size;
    _data = new int* [size];
    for (int i = 0; i < size; i++)
        _data[i] = new int[size];

    if (fill)
        for (int i = 0; i < size; i++)
            for (int j = 0; j < size; j++)
                _data[i][j] = /*rand() % 100 + */1;

    else
        for (int i = 0; i < size; i++)
            for (int j = 0; j < size; j++)
                _data[i][j] = 0;
}

Matrix::~Matrix()
{
    for (int i = 0; i < _size; i++)
        delete[] _data[i];
    delete[] _data;
}

Matrix* Matrix::operator+(Matrix& that)
{
    auto* result = new Matrix(_size, false);
    for (int i = 0; i < _size; i++)
        for (int j = 0; j < _size; j++)
            result->_data[i][j] = _data[i][j] + that._data[i][j];
    return result;
}

Matrix* Matrix::operator-(Matrix& that)
{
    auto* result = new Matrix(_size, false);
    for (int i = 0; i < _size; i++)
        for (int j = 0; j < _size; j++)
            result->_data[i][j] = _data[i][j] - that._data[i][j];
    return result;
}

Matrix* Matrix::operator*(Matrix& that)
{
    auto* result = new Matrix(_size, false);
    for (int i = 0; i < _size; i++)
        for (int j = 0; j < _size; j++)
            for (int k = 0; k < _size; k++)
                result->_data[i][j] += _data[i][k] * that._data[k][j];
    return result;
}

Matrix* Matrix::operator*(long& that)
{
    auto* result = new Matrix(_size, false);
    for (int i = 0; i < _size; i++)
        for (int j = 0; j < _size; j++)
                result->_data[i][j] *= that;
    return result;
}

Vector* Matrix::operator*(Vector& that)
{
    auto* result = new Vector(_size, false);
    for (int i = 0; i < _size; i++)
        for (int j = 0; j < _size; j++)
            result->setElement(i, result->getElement(i) + _data[i][j] * that.getElement(i));
    return result;
}


void Matrix::print()
{
    for (int i = 0; i < _size; i++)
    {
        printf("[");
        for (int j = 0; j < _size - 1; j++) {
            printf("%1d,", _data[i][j]);
        }
        printf("%1d]", _data[i][_size - 1]);
        printf("\n");
    }
}









#include "Data.h"

#include <iostream>
#include <cstdlib>

using namespace std;

Vector::Vector(int size, bool fill)
{
    _size = size;
    _data = new int[size];
    if (fill)
        for (int i = 0; i < _size; i++)
            _data[i] = /*rand() % 100 +*/ 1;
    else
        for (int i = 0; i < _size; i++)
            _data[i] = 0;
}

Vector::~Vector()
{
    delete[] _data;
}

Vector* Vector::operator+(Vector& that)
{
    auto* result = new Vector(_size, false);
    for (int i = 0; i < _size; i++)
        result->_data[i] = _data[i] + that._data[i];
    return result;
}

void Vector::setElement(int index, int value)
{
    _data[index] = value;
}

void Vector::print()
{
    printf("[");
    for (int i = 0; i < _size - 1; i++)
        printf("%1d,", _data[i]);
    printf("%1d]", _data[_size - 1]);
    printf("\n");
}

int Vector::operator*(Vector& that)
{
    int result = 0;
    for (int i = 0; i < _size; i++)
        result += _data[i] * that._data[i];
    return result;
}

int Vector::getElement(int index)
{
    return _data[index];
}

int Vector::max()
{
    int max = 0;
    for (int i = 0; i < _size; i++)
        if (_data[i] > max)
            max = _data[i];
    return max;
}