aleikin_artem_lab_5

.gitignore

@@ -0,0 +1,17 @@
+################################################################################
+# Данный GITIGNORE-файл был автоматически создан Microsoft(R) Visual Studio.
+################################################################################
+
+/.vs
+/aleikin_artem_lab_3
+/aleikin_artem_lab_4
+/aleikin_artem_lab_5/MultiplyMatrix/.vs/MultiplyMatrix
+/aleikin_artem_lab_5/MultiplyMatrix/bin/Debug/net8.0
+/aleikin_artem_lab_5/MultiplyMatrix/obj
+/aleikin_artem_lab_5/MultiplyMatrix/MultiplyMatrix.sln
+/dozorova_alena_lab_2
+/dozorova_alena_lab_3
+/dozorova_alena_lab_4
+/dozorova_alena_lab_5/ConsoleApp1/obj
+/dozorova_alena_lab_5/ConsoleApp1/obj/Debug/net6.0/.NETCoreApp,Version=v6.0.AssemblyAttributes.cs
+/dozorova_alena_lab_6/ConsoleApp1/obj

aleikin_artem_lab_5/MultiplyMatrix/MultiplyMatrix.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>

aleikin_artem_lab_5/MultiplyMatrix/Program.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        // Размеры матриц
+        int[] sizes = { 100, 300, 500, 700, 1000 };
+
+        // Максимальное количество потоков
+        int maxThreads = 20;
+
+        foreach (var size in sizes)
+        {
+            Console.WriteLine($"\nРазмер матрицы: {size}x{size}");
+
+            // Генерация двух матриц
+            var matrixA = GenerateMatrix(size);
+            var matrixB = GenerateMatrix(size);
+
+            // Последовательное умножение
+            var stopwatch = Stopwatch.StartNew();
+            var resultSequential = MultiplyMatricesSequential(matrixA, matrixB);
+            stopwatch.Stop();
+            long timeSequential = stopwatch.ElapsedMilliseconds;
+            Console.WriteLine($"Последовательное умножение: {timeSequential} мс");
+
+            // Параллельное умножение с разным количеством потоков
+            Console.WriteLine("Параллельное умножение (время выполнения для каждого количества потоков):");
+            for (int threads = 1; threads <= maxThreads; threads++)
+            {
+                stopwatch.Restart();
+                var resultParallel = MultiplyMatricesParallel(matrixA, matrixB, threads);
+                stopwatch.Stop();
+                long timeParallel = stopwatch.ElapsedMilliseconds;
+                Console.WriteLine($"Потоков: {threads} — {timeParallel} мс");
+            }
+        }
+    }
+
+    // Генерация квадратной матрицы размером size x size
+    static double[,] GenerateMatrix(int size)
+    {
+        var random = new Random();
+        var matrix = new double[size, size];
+        for (int i = 0; i < size; i++)
+            for (int j = 0; j < size; j++)
+                matrix[i, j] = random.NextDouble();
+        return matrix;
+    }
+
+    // Последовательное умножение матриц
+    static double[,] MultiplyMatricesSequential(double[,] matrixA, double[,] matrixB)
+    {
+        int size = matrixA.GetLength(0);
+        var result = new double[size, size];
+
+        for (int i = 0; i < size; i++)
+        {
+            for (int j = 0; j < size; j++)
+            {
+                for (int k = 0; k < size; k++)
+                {
+                    result[i, j] += matrixA[i, k] * matrixB[k, j];
+                }
+            }
+        }
+        return result;
+    }
+
+    // Параллельное умножение матриц
+    static double[,] MultiplyMatricesParallel(double[,] matrixA, double[,] matrixB, int threadCount)
+    {
+        int size = matrixA.GetLength(0);
+        var result = new double[size, size];
+
+        Parallel.For(0, threadCount, threadIndex =>
+        {
+            int rowsPerThread = size / threadCount;
+            int startRow = threadIndex * rowsPerThread;
+            int endRow = (threadIndex == threadCount - 1) ? size : startRow + rowsPerThread;
+
+            for (int i = startRow; i < endRow; i++)
+            {
+                for (int j = 0; j < size; j++)
+                {
+                    for (int k = 0; k < size; k++)
+                    {
+                        result[i, j] += matrixA[i, k] * matrixB[k, j];
+                    }
+                }
+            }
+        });
+
+        return result;
+    }
+}

aleikin_artem_lab_5/readme.md

@@ -0,0 +1,16 @@
+# Лабораторная работа 5 - Параллельное умножение матриц
+## ПИбд-42 || Алейкин Артем
+
+### Описание
+В данной лабораторной работе мы вспоминали математику и работу с матрицами.
+
+### Отчет
+Написав алгоритм для перемножения матриц, как последовательно, так и в многопоточном режиме, получаю следующие графики времени.
+![Матрицы 100х100 и 300х300](./Images/Отчет1.png)
+![Матрицы 500х500 и 700х700](./Images/Отчет2.png)
+![Матрица 1000х1000](./Images/Отчет3.png)
+
+Выводы: последовательное выполнение выполняет вычисления довольно медленно.
+В многопоточном формате каждый поток ускоряет вычисления по закону убывающей полезности.
+
+Видео демонстрации работы: https://vk.com/video248424990_456239612?list=ln-mPzeO3z06S0FiqGXsz