nasyrov_artur_lab_6 is ready

nasyrov_artur_lab_6/README.md

@@ -0,0 +1,39 @@
+# Лабораторная работа №5 - Параллельное перемножение матриц
+## Как запустить лабораторную работу
+1. Склонировать ветку. 
+2. Перейти в папку Solution
+3. В консоли ввести "dotnet run", следовать подсказкам на экране
+4. Исходная матрица сохраняется в Data/Result.txt
+## Какие технологии использовались
+В лабораторной использовались инструменты .NET(c#).
+## Что делает лабораторная работа
+Лабораторная работа реализует программу, которая генерирует матрицу, вычисляет ее дискриминант по методу Гаусса и делает замеры скорости.
+## Касательно скорости
+Замеры: 
+___________________________________________
+Введите размер матрицы: 100
+Введите количество потоков: 100
+
+Однопоточный алгоритм: 2 мс 
+Параллельный алгоритм (100 потоков): 15 мс
+___________________________________________
+
+Введите размер матрицы: 300
+Введите количество потоков: 300
+
+Однопоточный алгоритм: 51 мс 
+Параллельный алгоритм (300 потоков): 36 мс
+___________________________________________
+
+Введите размер матрицы: 500
+Введите количество потоков: 500
+
+Однопоточный алгоритм: 242 мс 
+Параллельный алгоритм (500 потоков): 114 мс
+___________________________________________
+
+Аналогично предыдущей лабораторной, при небольшом количестве данных, выигрывает однопоточный алгоритм, так как не тратится время на создание потоков. 
+Если же количество данных достаточно велико, то преимущество забирает многопоточный алгоритм. 
+## Ссылка на видео 
+https://vkvideo.ru/video-232718139_456239022
+

nasyrov_artur_lab_6/Solution/Program.cs

@@ -0,0 +1,124 @@
+using System;
+using System.Diagnostics;
+
+
+class Program
+{
+    static void Main()
+    {
+        Console.Write("Введите размер матрицы: ");
+        int size = int.Parse(Console.ReadLine());
+        double[,] matrix = GenerateMatrix(size);
+        WriteArrayToFile("Data/Result.txt", matrix);
+        Console.Write("Введите количество потоков: ");
+        int threadCount = int.Parse(Console.ReadLine());
+
+        Stopwatch parallelStopwatch = Stopwatch.StartNew();
+        double determinant = ParallelGaussianDeterminant(matrix, threadCount);
+        parallelStopwatch.Stop();
+        Console.WriteLine($"\nОпределитель матрицы: {determinant}");
+
+        // Сравнение с однопоточным вычислением
+        Stopwatch sequentialStopwatch = Stopwatch.StartNew();
+        double sequentialDet = ParallelGaussianDeterminant(matrix,1);
+        sequentialStopwatch.Stop();
+        Console.WriteLine($"Однопоточный результат: {sequentialDet}");
+
+        Console.WriteLine($"\nОднопоточный алгоритм: {sequentialStopwatch.ElapsedMilliseconds} мс ");
+        Console.WriteLine($"Параллельный алгоритм ({threadCount} потоков): {parallelStopwatch.ElapsedMilliseconds} мс");
+    }
+
+    static double ParallelGaussianDeterminant(double[,] matrix, int threadCount)
+    {
+        int n = matrix.GetLength(0);
+        double[,] tempMatrix = (double[,])matrix.Clone();
+        double determinant = 1;
+
+        for (int i = 0; i < n - 1; i++)
+        {
+
+            int pivotRow = i;
+            double maxVal = Math.Abs(tempMatrix[i, i]);
+            for (int k = i + 1; k < n; k++)
+            {
+                if (Math.Abs(tempMatrix[k, i]) > maxVal)
+                {
+                    maxVal = Math.Abs(tempMatrix[k, i]);
+                    pivotRow = k;
+                }
+            }
+
+            if (pivotRow != i)
+            {
+                SwapRows(tempMatrix, i, pivotRow, n);
+                determinant *= -1;
+            }
+
+            if (Math.Abs(tempMatrix[i, i]) < 1e-15)
+                return 0;
+
+            determinant *= tempMatrix[i, i];
+
+
+            Parallel.For(i + 1, n, new ParallelOptions { MaxDegreeOfParallelism = threadCount },
+                         k =>
+                         {
+                             double factor = tempMatrix[k, i] / tempMatrix[i, i];
+
+                             for (int j = i + 1; j < n; j++)
+                             {
+                                 tempMatrix[k, j] -= factor * tempMatrix[i, j];
+                             }
+                             tempMatrix[k, i] = 0;
+                         });
+        }
+
+        determinant *= tempMatrix[n - 1, n - 1];
+        return determinant;
+    }
+
+    static double[,] GenerateMatrix(int size)
+    {
+        Random rand = new Random();
+        double[,] matrix = new double[size, size];
+
+        for (int i = 0; i < size; i++)
+        {
+            for (int j = 0; j < size; j++)
+            {
+                matrix[i, j] = rand.Next(1, 10) + rand.NextDouble();
+            }
+        }
+        return matrix;
+    }
+
+    static void SwapRows(double[,] matrix, int row1, int row2, int n)
+    {
+        for (int j = 0; j < n; j++)
+        {
+            double temp = matrix[row1, j];
+            matrix[row1, j] = matrix[row2, j];
+            matrix[row2, j] = temp;
+        }
+    }
+
+    static void WriteArrayToFile(string filePath, double[,] array)
+    {
+        using (StreamWriter writer = new StreamWriter(filePath))
+        {
+            int rows = array.GetLength(0);
+            int cols = array.GetLength(1);
+
+            for (int i = 0; i < rows; i++)
+            {
+                for (int j = 0; j < cols; j++)
+                {
+                    writer.Write(array[i, j]);
+                    if (j < cols - 1)
+                        writer.Write(" ");
+                }
+                writer.WriteLine();
+            }
+        }
+    }
+}

nasyrov_artur_lab_6/Solution/Solution.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>