#include <iostream>

#include <fstream>

#include <random>

#include <thread> // Библиотека для работы с многопоточностью

using namespace std;

// Функция для генерации случайного целого числа в диапазоне [min, max]

int randomInt(int min, int max) {

    static random_device rd; // Генератор случайных чисел

    static mt19937 gen(rd()); // Инициализация генератора случайных чисел

    uniform_int_distribution<> dis(min, max); // Равномерное распределение случайных чисел в заданном диапазоне

    return dis(gen); // Возвращает случайное число в заданном диапазоне

}

// Функция для вычисления части произведения матриц

void matrixMultiplication(double** A, double** B, double** C, int start, int end, int n) {

    for (int i = start; i < end; ++i) { // Проход по строкам части матрицы C

        for (int j = 0; j < n; ++j) { // Проход по столбцам матрицы C

            C[i][j] = 0; // Инициализация элемента матрицы C нулём

            for (int k = 0; k < n; ++k) { // Проход по столбцам матрицы A и строкам матрицы B

                C[i][j] += A[i][k] * B[k][j]; // Вычисление элемента матрицы C как суммы произведений соответствующих элементов матриц A и B

            }

        }

    }

}

int main() {

    int n;

    cout << "Enter the dimensionality of the matrix: ";

    cin >> n;

    // Выделение памяти для матриц и генерация случайных элементов

    double** A = new double* [n];

    double** B = new double* [n];

    double** C = new double* [n];

    for (int i = 0; i < n; ++i) {

        A[i] = new double[n];

        B[i] = new double[n];

        C[i] = new double[n];

        for (int j = 0; j < n; ++j) {

            A[i][j] = randomInt(1, 10); // Генерация случайного элемента матрицы A

            B[i][j] = randomInt(1, 10); // Генерация случайного элемента матрицы B

        }

    }

    // Вычисление произведения матриц параллельно с использованием нескольких потоков

    int num_threads = thread::hardware_concurrency(); // Получаем количество ядер процессора

    vector<thread> threads;

    int chunk_size = n / num_threads;

    int start = 0;

    int end = chunk_size;

    for (int i = 0; i < num_threads; ++i) {

        if (i == num_threads - 1) end = n; // Последний поток обрабатывает оставшуюся часть

        threads.emplace_back(matrixMultiplication, A, B, C, start, end, n); // Создание потока для вычисления части произведения матриц

        start = end;

        end += chunk_size;

    }

    // Ожидание завершения всех потоков

    for (auto& t : threads) {

        t.join(); // Присоединение потока к главному потоку

    }

    // Запись результатов в файл

    ofstream outfile("result.txt");

    if (outfile.is_open()) {

        outfile << "Matrix A:\n";

        for (int i = 0; i < n; ++i) {

            for (int j = 0; j < n; ++j) {

                outfile << A[i][j] << " "; // Запись элемента матрицы A в файл

            }

            outfile << endl;

        }

        outfile << "Matrix B:\n";

        for (int i = 0; i < n; ++i) {

            for (int j = 0; j < n; ++j) {

                outfile << B[i][j] << " "; // Запись элемента матрицы B в файл

            }

            outfile << endl;

        }

        outfile << "Matrix C:\n";

        for (int i = 0; i < n; ++i) {

            for (int j = 0; j < n; ++j) {

                outfile << C[i][j] << " "; // Запись элемента матрицы C в файл

            }

            outfile << endl;

        }

        outfile.close(); // Закрытие файла

        cout << "Results have been written to result.txt" << endl;

    }

    else {

        cout << "Unable to open file for writing." << endl;

    }

    // Освобождение памяти

    for (int i = 0; i < n; ++i) {

        delete[] A[i];

        delete[] B[i];

        delete[] C[i];

    }

    delete[] A;

    delete[] B;

    delete[] C;

    return 0;

}