From e71ae587526312d11476d98b3a54c97a9573786b Mon Sep 17 00:00:00 2001 From: Artem Date: Fri, 15 Sep 2023 19:43:11 +0300 Subject: [PATCH 1/7] =?UTF-8?q?=D0=9F=D0=B0=D1=80=D0=B0=D0=BB=D0=BB=D0=B5?= =?UTF-8?q?=D0=BB=D1=8C=D0=BD=D0=BE=D0=B5=20=D1=83=D0=BC=D0=BD=D0=BE=D0=B6?= =?UTF-8?q?=D0=B5=D0=BD=D0=B8=D0=B5=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8=D1=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../TestsForMatrixMultiplication.cs | 123 ++++++++++ .../TestsForMatrixMultiplication.csproj | 23 ++ .../TestsForMatrixMultiplication/Usings.cs | 1 + .../TestsForMatrix/firstCorrectMatrix.txt | 3 + .../net7.0/TestsForMatrix/incorrectMatrix.txt | 3 + .../net7.0/TestsForMatrix/resultMatrix.txt | 0 .../parallelMatrixMultiplication.sln | 31 +++ .../CreateTable.cs | 204 +++++++++++++++++ .../InvalidFileException.cs | 5 + .../parallelMatrixMultiplication/Matrix.cs | 214 ++++++++++++++++++ .../parallelMatrixMultiplication/Program.cs | 16 ++ .../parallelMatrixMultiplication.csproj | 10 + 12 files changed, 633 insertions(+) create mode 100644 parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs create mode 100644 parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.csproj create mode 100644 parallelMatrixMultiplication/TestsForMatrixMultiplication/Usings.cs create mode 100644 parallelMatrixMultiplication/TestsForMatrixMultiplication/bin/Debug/net7.0/TestsForMatrix/firstCorrectMatrix.txt create mode 100644 parallelMatrixMultiplication/TestsForMatrixMultiplication/bin/Debug/net7.0/TestsForMatrix/incorrectMatrix.txt create mode 100644 parallelMatrixMultiplication/TestsForMatrixMultiplication/bin/Debug/net7.0/TestsForMatrix/resultMatrix.txt create mode 100644 parallelMatrixMultiplication/parallelMatrixMultiplication.sln create mode 100644 parallelMatrixMultiplication/parallelMatrixMultiplication/CreateTable.cs create mode 100644 parallelMatrixMultiplication/parallelMatrixMultiplication/InvalidFileException.cs create mode 100644 parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs create mode 100644 parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs create mode 100644 parallelMatrixMultiplication/parallelMatrixMultiplication/parallelMatrixMultiplication.csproj diff --git a/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs b/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs new file mode 100644 index 0000000..cf8eb35 --- /dev/null +++ b/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs @@ -0,0 +1,123 @@ +namespace TestsForMatrixMultiplication; + +using parallelMatrixMultiplication; + +public class Tests +{ + [Test] + public void MultiplyingMatricesOfSizeThreeByThree() + { + var sizeThreads = 3; + var listOfValues = new List {1, 2, 3, 4, 5, 6, 7, 8, 9}; + var listOfCorrectValues = new List {30, 36, 42, 66, 81, 96, 102, 126, 150}; + var firstMatrix = Matrix.CreateMatrix(3, 3, listOfValues); + var secondMatrix = Matrix.CreateMatrix(3, 3, listOfValues); + var correctMatrix = Matrix.CreateMatrix(3, 3, listOfCorrectValues); + + var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); + Assert.True(Matrix.MatrixComparison(resultMatrix, correctMatrix)); + } + + [Test] + public void MultiplyingMatricesOfBigSize() + { + var sizeThreads = 50; + + var listOfValuesFirstMatrix = new List {}; + var listOfValuesSecondMatrix = new List {}; + var listOfCorrectValues = new List {}; + + for (int i = 0; i < 10000; i++) + { + for (int j = 0; j < 10000; ++j) + { + listOfValuesFirstMatrix.Add(1); + } + listOfValuesSecondMatrix.Add(1); + listOfCorrectValues.Add(10000); + } + + var firstMatrix = Matrix.CreateMatrix(10000, 10000, listOfValuesFirstMatrix); + var secondMatrix = Matrix.CreateMatrix(10000, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.CreateMatrix(10000, 1, listOfCorrectValues); + + var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); + Assert.True(Matrix.MatrixComparison(resultMatrix, correctMatrix)); + } + + [Test] + public void MultiplyingMatricesOfDifferentSizes() + { + var sizeThreads = 3; + var listOfValuesFirstMatrix = new List { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + var listOfValuesSecondMatrix = new List { 1, 2, 3 }; + var listOfCorrectValues = new List { 14, 32, 50 }; + var firstMatrix = Matrix.CreateMatrix(3, 3, listOfValuesFirstMatrix); + var secondMatrix = Matrix.CreateMatrix(3, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.CreateMatrix(3, 1, listOfCorrectValues); + + var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); + Assert.True(Matrix.MatrixComparison(resultMatrix, correctMatrix)); + } + + [Test] + public void MultiplyingOfNotSquareMatrices() + { + var sizeThreads = 10; + var listOfValuesFirstMatrix = new List { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + var listOfValuesSecondMatrix = new List { 1, 2, 3, 4, 5 }; + var listOfCorrectValues = new List { 55, 130 }; + var firstMatrix = Matrix.CreateMatrix(2, 5, listOfValuesFirstMatrix); + var secondMatrix = Matrix.CreateMatrix(5, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.CreateMatrix(2, 1, listOfCorrectValues); + + var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); + Assert.True(Matrix.MatrixComparison(resultMatrix, correctMatrix)); + } + + [Test] + public void MultiplyingMatricesWithNegativeNumbers() + { + var sizeThreads = 10; + var listOfValuesFirstMatrix = new List { 1, 2, -3, 4, 5, 6, -7, 8, 9, 10 }; + var listOfValuesSecondMatrix = new List { 1, 2, 3, -4, 5 }; + var listOfCorrectValues = new List { 5, 30 }; + var firstMatrix = Matrix.CreateMatrix(2, 5, listOfValuesFirstMatrix); + var secondMatrix = Matrix.CreateMatrix(5, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.CreateMatrix(2, 1, listOfCorrectValues); + + var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); + Assert.True(Matrix.MatrixComparison(resultMatrix, correctMatrix)); + } + + [Test] + public void MultiplyingMatricesWithZero() + { + var sizeThreads = 10; + var listOfValuesFirstMatrix = new List { 1, 2, 0, 4, 5, 6, 0, 8, 9, 10 }; + var listOfValuesSecondMatrix = new List { 1, 2, 0, 0, 5 }; + var listOfCorrectValues = new List { 30, 56 }; + var firstMatrix = Matrix.CreateMatrix(2, 5, listOfValuesFirstMatrix); + var secondMatrix = Matrix.CreateMatrix(5, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.CreateMatrix(2, 1, listOfCorrectValues); + + var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); + Assert.True(Matrix.MatrixComparison(resultMatrix, correctMatrix)); + } + + [Test] + public void MultiplyingMatricesWithWrongData() + { + var sizeThreads = 10; + var listOfCorrectValues = new List { 30, 56 }; + var correctMatrix = Matrix.CreateMatrix(2, 1, listOfCorrectValues); + Assert.Throws(() => Matrix.MatrixMultiplicationControlFunction(Path.Combine(TestContext.CurrentContext.TestDirectory, + "TestsForMatrix", "firstCorrectMatrix.txt"), + Path.Combine(TestContext.CurrentContext.TestDirectory, + "TestsForMatrix", "incorrectMatrix.txt"), + Path.Combine(TestContext.CurrentContext.TestDirectory, + "TestsForMatrix", "resultMatrix.txt"), + sizeThreads + )); + } +} \ No newline at end of file diff --git a/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.csproj b/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.csproj new file mode 100644 index 0000000..4e2539d --- /dev/null +++ b/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.csproj @@ -0,0 +1,23 @@ + + + + net7.0 + enable + enable + + false + + + + + + + + + + + + + + + diff --git a/parallelMatrixMultiplication/TestsForMatrixMultiplication/Usings.cs b/parallelMatrixMultiplication/TestsForMatrixMultiplication/Usings.cs new file mode 100644 index 0000000..cefced4 --- /dev/null +++ b/parallelMatrixMultiplication/TestsForMatrixMultiplication/Usings.cs @@ -0,0 +1 @@ +global using NUnit.Framework; \ No newline at end of file diff --git a/parallelMatrixMultiplication/TestsForMatrixMultiplication/bin/Debug/net7.0/TestsForMatrix/firstCorrectMatrix.txt b/parallelMatrixMultiplication/TestsForMatrixMultiplication/bin/Debug/net7.0/TestsForMatrix/firstCorrectMatrix.txt new file mode 100644 index 0000000..3d1d616 --- /dev/null +++ b/parallelMatrixMultiplication/TestsForMatrixMultiplication/bin/Debug/net7.0/TestsForMatrix/firstCorrectMatrix.txt @@ -0,0 +1,3 @@ +1 2 3 +4 5 6 +5 6 7 \ No newline at end of file diff --git a/parallelMatrixMultiplication/TestsForMatrixMultiplication/bin/Debug/net7.0/TestsForMatrix/incorrectMatrix.txt b/parallelMatrixMultiplication/TestsForMatrixMultiplication/bin/Debug/net7.0/TestsForMatrix/incorrectMatrix.txt new file mode 100644 index 0000000..96233ef --- /dev/null +++ b/parallelMatrixMultiplication/TestsForMatrixMultiplication/bin/Debug/net7.0/TestsForMatrix/incorrectMatrix.txt @@ -0,0 +1,3 @@ +1 2 a +3 4 5 +6 7 8 \ No newline at end of file diff --git a/parallelMatrixMultiplication/TestsForMatrixMultiplication/bin/Debug/net7.0/TestsForMatrix/resultMatrix.txt b/parallelMatrixMultiplication/TestsForMatrixMultiplication/bin/Debug/net7.0/TestsForMatrix/resultMatrix.txt new file mode 100644 index 0000000..e69de29 diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication.sln b/parallelMatrixMultiplication/parallelMatrixMultiplication.sln new file mode 100644 index 0000000..009b334 --- /dev/null +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.4.33403.182 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "parallelMatrixMultiplication", "parallelMatrixMultiplication\parallelMatrixMultiplication.csproj", "{E4C7CC35-FD7C-4BA7-B1C5-EF752CDAA263}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestsForMatrixMultiplication", "TestsForMatrixMultiplication\TestsForMatrixMultiplication.csproj", "{F6D3443D-537C-44C2-9988-5B3D10652CE1}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {E4C7CC35-FD7C-4BA7-B1C5-EF752CDAA263}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E4C7CC35-FD7C-4BA7-B1C5-EF752CDAA263}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E4C7CC35-FD7C-4BA7-B1C5-EF752CDAA263}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E4C7CC35-FD7C-4BA7-B1C5-EF752CDAA263}.Release|Any CPU.Build.0 = Release|Any CPU + {F6D3443D-537C-44C2-9988-5B3D10652CE1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F6D3443D-537C-44C2-9988-5B3D10652CE1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F6D3443D-537C-44C2-9988-5B3D10652CE1}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F6D3443D-537C-44C2-9988-5B3D10652CE1}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {4E527157-F298-4A47-B122-6710A34A14E1} + EndGlobalSection +EndGlobal diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/CreateTable.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/CreateTable.cs new file mode 100644 index 0000000..ee68087 --- /dev/null +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/CreateTable.cs @@ -0,0 +1,204 @@ +using System.Diagnostics; + +using parallelMatrixMultiplication; + +/// +/// A class for measuring the standard deviation and mathematical expectation +/// +public static class CreateTable +{ + private static int n = 10; + + private static double GetStandartDeviation(int n, double[] arrayForStandardDeviation, double minValue) + { + double summaryForStandartDeviation = 0; + for (int i = 0; i < n; i++) + { + summaryForStandartDeviation += Math.Pow(arrayForStandardDeviation[i] - minValue, 2); + } + + return Math.Sqrt(summaryForStandartDeviation / (n - 1)); + } + + private static double GetMinValue(int[][] firstMatrix, int[][] secondMatrix, int[][] correctMatrix, + double[] arrayForStandardDeviation, int n, int sizeThreads) + { + double summary = 0; + for (int i = 0; i < n; i++) + { + var stopWatch = new Stopwatch(); + stopWatch.Start(); + var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); + stopWatch.Stop(); + arrayForStandardDeviation[i] = (double)stopWatch.ElapsedMilliseconds / 1000; + summary += arrayForStandardDeviation[i]; + } + return summary / n; + } + + private static void MultiplyingMatricesOfSizeThreeByThree(string filePath) + { + var sizeThreads = 3; + var listOfValues = new List { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + var listOfCorrectValues = new List { 30, 36, 42, 66, 81, 96, 102, 126, 150 }; + var firstMatrix = Matrix.CreateMatrix(3, 3, listOfValues); + var secondMatrix = Matrix.CreateMatrix(3, 3, listOfValues); + var correctMatrix = Matrix.CreateMatrix(3, 3, listOfCorrectValues); + + var arrayForStandardDeviation = new double[n]; + double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, + arrayForStandardDeviation, n, sizeThreads); + var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, minValue); + var streamForWrite = new StreamWriter(filePath, true); + streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 3x3:"); + streamForWrite.Write("Матемматическое ожидание: "); + streamForWrite.Write(minValue); + streamForWrite.Write(" Среднеквадратичное отклонение: "); + streamForWrite.WriteLine(standardDeviation); + streamForWrite.Close(); + } + + private static void MultiplyingMatricesOfBigSize(string filePath) + { + var sizeThreads = 50; + + var listOfValuesFirstMatrix = new List { }; + var listOfValuesSecondMatrix = new List { }; + var listOfCorrectValues = new List { }; + + for (int i = 0; i < 10000; i++) + { + for (int j = 0; j < 10000; ++j) + { + listOfValuesFirstMatrix.Add(1); + } + listOfValuesSecondMatrix.Add(1); + listOfCorrectValues.Add(10000); + } + + var firstMatrix = Matrix.CreateMatrix(10000, 10000, listOfValuesFirstMatrix); + var secondMatrix = Matrix.CreateMatrix(10000, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.CreateMatrix(10000, 1, listOfCorrectValues); + + var arrayForStandardDeviation = new double[n]; + double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, + arrayForStandardDeviation, n, sizeThreads); + var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, minValue); + var streamForWrite = new StreamWriter(filePath, true); + streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 10000x10000 и 10000x1:"); + streamForWrite.Write("Матемматическое ожидание: "); + streamForWrite.Write(minValue); + streamForWrite.Write(" Среднеквадратичное отклонение: "); + streamForWrite.WriteLine(standardDeviation); + streamForWrite.Close(); + } + + private static void MultiplyingMatricesOfDifferentSizes(string filePath) + { + var sizeThreads = 3; + var listOfValuesFirstMatrix = new List { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + var listOfValuesSecondMatrix = new List { 1, 2, 3 }; + var listOfCorrectValues = new List { 14, 32, 50 }; + var firstMatrix = Matrix.CreateMatrix(3, 3, listOfValuesFirstMatrix); + var secondMatrix = Matrix.CreateMatrix(3, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.CreateMatrix(3, 1, listOfCorrectValues); + + var arrayForStandardDeviation = new double[n]; + double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, + arrayForStandardDeviation, n, sizeThreads); + var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, minValue); + var streamForWrite = new StreamWriter(filePath, true); + streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 3x3 и 3x1:"); + streamForWrite.Write("Матемматическое ожидание: "); + streamForWrite.Write(minValue); + streamForWrite.Write(" Среднеквадратичное отклонение: "); + streamForWrite.WriteLine(standardDeviation); + streamForWrite.Close(); + } + + private static void MultiplyingOfNotSquareMatrices(string filePath) + { + var sizeThreads = 10; + var listOfValuesFirstMatrix = new List { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + var listOfValuesSecondMatrix = new List { 1, 2, 3, 4, 5 }; + var listOfCorrectValues = new List { 55, 130 }; + var firstMatrix = Matrix.CreateMatrix(2, 5, listOfValuesFirstMatrix); + var secondMatrix = Matrix.CreateMatrix(5, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.CreateMatrix(2, 1, listOfCorrectValues); + + var arrayForStandardDeviation = new double[n]; + double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, + arrayForStandardDeviation, n, sizeThreads); + var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, minValue); + var streamForWrite = new StreamWriter(filePath, true); + streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 2x5 и 5x1:"); + streamForWrite.Write("Матемматическое ожидание: "); + streamForWrite.Write(minValue); + streamForWrite.Write(" Среднеквадратичное отклонение: "); + streamForWrite.WriteLine(standardDeviation); + streamForWrite.Close(); + } + + private static void MultiplyingMatricesWithNegativeNumbers(string filePath) + { + var sizeThreads = 10; + var listOfValuesFirstMatrix = new List { 1, 2, -3, 4, 5, 6, -7, 8, 9, 10 }; + var listOfValuesSecondMatrix = new List { 1, 2, 3, -4, 5 }; + var listOfCorrectValues = new List { 5, 30 }; + var firstMatrix = Matrix.CreateMatrix(2, 5, listOfValuesFirstMatrix); + var secondMatrix = Matrix.CreateMatrix(5, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.CreateMatrix(2, 1, listOfCorrectValues); + + var arrayForStandardDeviation = new double[n]; + double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, + arrayForStandardDeviation, n, sizeThreads); + var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, minValue); + var streamForWrite = new StreamWriter(filePath, true); + streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 2x5 и 5x1 с отрицательными числами:"); + streamForWrite.Write("Матемматическое ожидание: "); + streamForWrite.Write(minValue); + streamForWrite.Write(" Среднеквадратичное отклонение: "); + streamForWrite.WriteLine(standardDeviation); + streamForWrite.Close(); + } + + private static void MultiplyingMatricesWithZero(string filePath) + { + var sizeThreads = 10; + var listOfValuesFirstMatrix = new List { 1, 2, 0, 4, 5, 6, 0, 8, 9, 10 }; + var listOfValuesSecondMatrix = new List { 1, 2, 0, 0, 5 }; + var listOfCorrectValues = new List { 30, 56 }; + var firstMatrix = Matrix.CreateMatrix(2, 5, listOfValuesFirstMatrix); + var secondMatrix = Matrix.CreateMatrix(5, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.CreateMatrix(2, 1, listOfCorrectValues); + + var arrayForStandardDeviation = new double[n]; + double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, + arrayForStandardDeviation, n, sizeThreads); + var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, minValue); + var streamForWrite = new StreamWriter(filePath, true); + streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 2x5 и 5x1 с нулями:"); + streamForWrite.Write("Матемматическое ожидание: "); + streamForWrite.Write(minValue); + streamForWrite.Write(" Среднеквадратичное отклонение: "); + streamForWrite.WriteLine(standardDeviation); + streamForWrite.Close(); + } + + /// + /// The function calculates the mathematical expectation and the standard deviation + /// + /// The file where the results are recorded + public static void CreateTableWithResults(string filePath) + { + var streamForWrite = new StreamWriter(filePath); + streamForWrite.Write("В файле представлены: математическое ожидание и среднеквадратичное отклонение\n"); + streamForWrite.Close(); + MultiplyingMatricesOfSizeThreeByThree(filePath); + MultiplyingMatricesOfBigSize(filePath); + MultiplyingMatricesOfDifferentSizes(filePath); + MultiplyingOfNotSquareMatrices(filePath); + MultiplyingMatricesWithNegativeNumbers(filePath); + MultiplyingMatricesWithZero(filePath); + } +} diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/InvalidFileException.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/InvalidFileException.cs new file mode 100644 index 0000000..c13d7e9 --- /dev/null +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/InvalidFileException.cs @@ -0,0 +1,5 @@ +namespace parallelMatrixMultiplication; +/// +/// Exception for errors with file +/// +public class InvalidFileException : Exception{} \ No newline at end of file diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs new file mode 100644 index 0000000..9c6752b --- /dev/null +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs @@ -0,0 +1,214 @@ +namespace parallelMatrixMultiplication; +using System; +using System.Threading; + +/// +/// A class for multiplying matrices +/// +public static class Matrix +{ + /// + /// Function for creating matrices + /// + /// Number of rows + /// Number of columns + /// List with data + /// Returns the created matrix + /// Throws an exception if the number of items + /// in the list does not match the size of the matrix + public static int[][] CreateMatrix(int sizeRows, int sizeColumns, List numbersForMatrix) + { + if (numbersForMatrix.Count != sizeColumns * sizeRows) + { + throw new ArgumentException(); + } + + var matrix = new int[sizeRows][]; + for (int i = 0; i < sizeRows; i++) + { + matrix[i] = new int[sizeColumns]; + } + + var indexInList = 0; + + for (int i = 0; i < sizeRows; ++i) + { + for (int j = 0; j < sizeColumns; ++j) + { + matrix[i][j] = numbersForMatrix[indexInList]; + indexInList++; + } + } + + return matrix; + } + + /// + /// The function compares matrices + /// + public static bool MatrixComparison(int[][] firstMatrix, int[][] secondMatrix) + { + if (firstMatrix.Length != secondMatrix.Length) + { + return false; + } + + for (int i = 0; i < firstMatrix.Length; ++i) + { + if (firstMatrix[i].Length != secondMatrix[i].Length) + { + return false; + } + for (int j = 0; j < firstMatrix[i].Length; ++j) + { + if (firstMatrix[i][j] != secondMatrix[i][j]) + { + return false; + } + } + } + return true; + } + + private static int[][] ConvertinMatrixToTransposedOne(int[][] matrix)// сменить на private + { + var transposedMatrix = new int[matrix[0].Length][]; + for (int i = 0; i < matrix[0].Length; i++) + { + transposedMatrix[i] = new int[matrix.Length]; + } + + for (int i = 0; i < transposedMatrix.Length; ++i) + { + for (int j = 0; j < transposedMatrix[i].Length; ++j) + { + transposedMatrix[i][j] = matrix[j][i]; + } + } + return transposedMatrix; + } + + private static void Multiply(int start, int end, int[][] firstMatrix, int[][] transposedMatrix, int[][] resultMatrix) + { + while (start < end) + { + for (int i = 0; i < transposedMatrix.Length; i++) + { + for (int k = 0; k < transposedMatrix[0].Length; ++k) + { + resultMatrix[start][i] += firstMatrix[start][k] * transposedMatrix[i][k]; + } + } + start++; + } + } + + /// + /// Parallel matrix multiplication function + /// + /// Returns the calculated matrix + public static int[][] MatrixMultiplication(int[][] firstMatrix, int[][] secondMatrix, int threadCounts) + { + var resultMatrix = new int[firstMatrix.Length][]; + + for(int i = 0; i < firstMatrix.Length; ++i) + { + resultMatrix[i] = new int[secondMatrix[0].Length]; + } + + + if (threadCounts > firstMatrix.Length) + { + threadCounts = firstMatrix.Length; + } + + var numberOfRowsForThreads = firstMatrix.Length / threadCounts; + var remains = firstMatrix.Length % threadCounts; + var threads = new Thread[threadCounts]; + + int start = 0; + int end = 0; + + var transposedMatrix = ConvertinMatrixToTransposedOne(secondMatrix); + + for (int i = 0; i < threadCounts; i++) + { + end = i == 0 ? numberOfRowsForThreads + remains : end + numberOfRowsForThreads; + int localStart = start; + int localEnd = end; + threads[i] = new Thread(() => Multiply(localStart, localEnd, firstMatrix, transposedMatrix, resultMatrix)); + threads[i].Start(); + start = end; + } + + foreach (var thread in threads ) + { + thread.Join(); + } + + + return resultMatrix; + } + + private static int[][] ReadFromFileMatrix(string filePath) + { + var allLines = File.ReadAllLines(filePath); + + var matrix = new int[allLines.Length][]; + + var sizeColumns = 0; + + for (int i = 0; i < matrix.Length; i++) + { + var stringOfDigits = allLines[i].Trim().Split(' '); + matrix[i] = new int[stringOfDigits.Length]; + var sizeLine = 0; + for (int j = 0; j < stringOfDigits.Length; ++j) + { + var result = 0; + bool isCorrectResult = int.TryParse(stringOfDigits[j].Trim(), out result); + if (!isCorrectResult) + { + throw new InvalidFileException(); + } + matrix[i][j] = result; + if (i == 0) + { + sizeColumns++; + } + sizeLine++; + } + if (sizeLine != sizeColumns) + { + throw new InvalidFileException(); + } + } + return matrix; + } + + private static void WriteResultMatrixToFile(string filePath, int[][] matrix) + { + var streamForWrite = new StreamWriter(filePath); + for (int i = 0; i < matrix.Length; ++i) + { + for (int j = 0; j < matrix[i].Length; ++j) + { + streamForWrite.Write(matrix[i][j]); + streamForWrite.Write(' '); + } + streamForWrite.Write('\n'); + } + streamForWrite.Close(); + } + + /// + /// A function that receives files with matrices at the input, and a calculated matrix at the output + /// + public static void MatrixMultiplicationControlFunction(string firstFile, string secondFile, string resultFile, int sizeThreads) + { + var firstMatrix = ReadFromFileMatrix(firstFile); + var secondMatrix = ReadFromFileMatrix(secondFile); + var resultMatrix = MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); + WriteResultMatrixToFile(resultFile, resultMatrix); + } +} \ No newline at end of file diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs new file mode 100644 index 0000000..9d46dc9 --- /dev/null +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs @@ -0,0 +1,16 @@ +using parallelMatrixMultiplication; + +Console.WriteLine("Write first file name"); +var firstFile = Console.ReadLine(); +Console.WriteLine("Write second file name"); +var secondFile = Console.ReadLine(); +Console.WriteLine("Write name file where will be result"); +var resultFile = Console.ReadLine(); +Console.WriteLine("Write file path for create table"); +var tableFile = Console.ReadLine(); + +if (tableFile != null && firstFile != null && secondFile != null && resultFile != null) +{ + Matrix.MatrixMultiplicationControlFunction(firstFile, secondFile, resultFile, 8); + CreateTable.CreateTableWithResults(tableFile); +} \ No newline at end of file diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/parallelMatrixMultiplication.csproj b/parallelMatrixMultiplication/parallelMatrixMultiplication/parallelMatrixMultiplication.csproj new file mode 100644 index 0000000..f02677b --- /dev/null +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/parallelMatrixMultiplication.csproj @@ -0,0 +1,10 @@ + + + + Exe + net7.0 + enable + enable + + + From b2d9c13838191849afd7855fb27902fdcdf28887 Mon Sep 17 00:00:00 2001 From: Artem Date: Sat, 23 Sep 2023 14:44:36 +0300 Subject: [PATCH 2/7] =?UTF-8?q?=D0=98=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5=D0=BD?= =?UTF-8?q?=D0=B8=D1=8F=20=D0=BF=D0=BE=20=D1=80=D0=B5=D0=B2=D1=8C=D1=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../TestsForMatrixMultiplication.cs | 194 +++++++++++------- .../CreateTable.cs | 156 +++++++++----- .../InvalidFileException.cs | 8 +- .../parallelMatrixMultiplication/Matrix.cs | 89 ++++++-- .../MultiplyException.cs | 13 ++ .../parallelMatrixMultiplication/Program.cs | 38 +++- parallelMatrixMultiplication/tableFile.txt | 13 ++ 7 files changed, 376 insertions(+), 135 deletions(-) create mode 100644 parallelMatrixMultiplication/parallelMatrixMultiplication/MultiplyException.cs create mode 100644 parallelMatrixMultiplication/tableFile.txt diff --git a/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs b/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs index cf8eb35..fd51deb 100644 --- a/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs +++ b/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs @@ -7,117 +7,173 @@ public class Tests [Test] public void MultiplyingMatricesOfSizeThreeByThree() { - var sizeThreads = 3; - var listOfValues = new List {1, 2, 3, 4, 5, 6, 7, 8, 9}; - var listOfCorrectValues = new List {30, 36, 42, 66, 81, 96, 102, 126, 150}; - var firstMatrix = Matrix.CreateMatrix(3, 3, listOfValues); - var secondMatrix = Matrix.CreateMatrix(3, 3, listOfValues); - var correctMatrix = Matrix.CreateMatrix(3, 3, listOfCorrectValues); - - var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); - Assert.True(Matrix.MatrixComparison(resultMatrix, correctMatrix)); + var listOfValues = new List {}; + var listOfCorrectValues = new List {}; + + listOfValues.Add(new int[3] { 1, 2, 3 }); + listOfValues.Add(new int[3] { 4, 5, 6 }); + listOfValues.Add(new int[3] { 7, 8, 9 }); + + listOfCorrectValues.Add(new int[3] { 30, 36, 42 }); + listOfCorrectValues.Add(new int[3] { 66, 81, 96 }); + listOfCorrectValues.Add(new int[3] { 102, 126, 150 }); + + var firstMatrix = Matrix.Create(3, 3, listOfValues); + var secondMatrix = Matrix.Create(3, 3, listOfValues); + var correctMatrix = Matrix.Create(3, 3, listOfCorrectValues); + + var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix); + Assert.True(Matrix.AreMatricesEquals(resultMatrix, correctMatrix)); } [Test] public void MultiplyingMatricesOfBigSize() { - var sizeThreads = 50; - - var listOfValuesFirstMatrix = new List {}; - var listOfValuesSecondMatrix = new List {}; - var listOfCorrectValues = new List {}; + var listOfValuesFirstMatrix = new List {}; + var listOfValuesSecondMatrix = new List {}; + var listOfCorrectValues = new List {}; for (int i = 0; i < 10000; i++) { + listOfValuesFirstMatrix.Add(new int[10000]); + listOfValuesSecondMatrix.Add(new int[1]); + listOfCorrectValues.Add(new int[1]); for (int j = 0; j < 10000; ++j) { - listOfValuesFirstMatrix.Add(1); + listOfValuesFirstMatrix[i][j] = 1; } - listOfValuesSecondMatrix.Add(1); - listOfCorrectValues.Add(10000); + listOfValuesSecondMatrix[i][0] = 1; + listOfCorrectValues[i][0] = 10000; } - var firstMatrix = Matrix.CreateMatrix(10000, 10000, listOfValuesFirstMatrix); - var secondMatrix = Matrix.CreateMatrix(10000, 1, listOfValuesSecondMatrix); - var correctMatrix = Matrix.CreateMatrix(10000, 1, listOfCorrectValues); + var firstMatrix = Matrix.Create(10000, 10000, listOfValuesFirstMatrix); + var secondMatrix = Matrix.Create(10000, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.Create(10000, 1, listOfCorrectValues); - var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); - Assert.True(Matrix.MatrixComparison(resultMatrix, correctMatrix)); + var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix); + Assert.True(Matrix.AreMatricesEquals(resultMatrix, correctMatrix)); } [Test] public void MultiplyingMatricesOfDifferentSizes() { - var sizeThreads = 3; - var listOfValuesFirstMatrix = new List { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; - var listOfValuesSecondMatrix = new List { 1, 2, 3 }; - var listOfCorrectValues = new List { 14, 32, 50 }; - var firstMatrix = Matrix.CreateMatrix(3, 3, listOfValuesFirstMatrix); - var secondMatrix = Matrix.CreateMatrix(3, 1, listOfValuesSecondMatrix); - var correctMatrix = Matrix.CreateMatrix(3, 1, listOfCorrectValues); - - var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); - Assert.True(Matrix.MatrixComparison(resultMatrix, correctMatrix)); + var listOfValuesFirstMatrix = new List {}; + var listOfValuesSecondMatrix = new List {}; + var listOfCorrectValues = new List {}; + + listOfValuesFirstMatrix.Add(new int[3] { 1, 2, 3 }); + listOfValuesFirstMatrix.Add(new int[3] { 4, 5, 6 }); + listOfValuesFirstMatrix.Add(new int[3] { 7, 8, 9 }); + + listOfValuesSecondMatrix.Add(new int[1] { 1 }); + listOfValuesSecondMatrix.Add(new int[1] { 2 }); + listOfValuesSecondMatrix.Add(new int[1] { 3 }); + + listOfCorrectValues.Add(new int[1] { 14 }); + listOfCorrectValues.Add(new int[1] { 32 }); + listOfCorrectValues.Add(new int[1] { 50 }); + + var firstMatrix = Matrix.Create(3, 3, listOfValuesFirstMatrix); + var secondMatrix = Matrix.Create(3, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.Create(3, 1, listOfCorrectValues); + + var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix); + Assert.True(Matrix.AreMatricesEquals(resultMatrix, correctMatrix)); } [Test] public void MultiplyingOfNotSquareMatrices() { - var sizeThreads = 10; - var listOfValuesFirstMatrix = new List { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; - var listOfValuesSecondMatrix = new List { 1, 2, 3, 4, 5 }; - var listOfCorrectValues = new List { 55, 130 }; - var firstMatrix = Matrix.CreateMatrix(2, 5, listOfValuesFirstMatrix); - var secondMatrix = Matrix.CreateMatrix(5, 1, listOfValuesSecondMatrix); - var correctMatrix = Matrix.CreateMatrix(2, 1, listOfCorrectValues); - - var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); - Assert.True(Matrix.MatrixComparison(resultMatrix, correctMatrix)); + var listOfValuesFirstMatrix = new List { }; + var listOfValuesSecondMatrix = new List { }; + var listOfCorrectValues = new List { }; + + listOfValuesFirstMatrix.Add(new int[5] { 1, 2, 3, 4, 5 }); + listOfValuesFirstMatrix.Add(new int[5] { 6, 7, 8, 9, 10 }); + + listOfValuesSecondMatrix.Add(new int[1] { 1 }); + listOfValuesSecondMatrix.Add(new int[1] { 2 }); + listOfValuesSecondMatrix.Add(new int[1] { 3 }); + listOfValuesSecondMatrix.Add(new int[1] { 4 }); + listOfValuesSecondMatrix.Add(new int[1] { 5 }); + + listOfCorrectValues.Add(new int[1] { 55 }); + listOfCorrectValues.Add(new int[1] { 130 }); + + var firstMatrix = Matrix.Create(2, 5, listOfValuesFirstMatrix); + var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); + + var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix); + Assert.True(Matrix.AreMatricesEquals(resultMatrix, correctMatrix)); } [Test] public void MultiplyingMatricesWithNegativeNumbers() { - var sizeThreads = 10; - var listOfValuesFirstMatrix = new List { 1, 2, -3, 4, 5, 6, -7, 8, 9, 10 }; - var listOfValuesSecondMatrix = new List { 1, 2, 3, -4, 5 }; - var listOfCorrectValues = new List { 5, 30 }; - var firstMatrix = Matrix.CreateMatrix(2, 5, listOfValuesFirstMatrix); - var secondMatrix = Matrix.CreateMatrix(5, 1, listOfValuesSecondMatrix); - var correctMatrix = Matrix.CreateMatrix(2, 1, listOfCorrectValues); - - var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); - Assert.True(Matrix.MatrixComparison(resultMatrix, correctMatrix)); + var listOfValuesFirstMatrix = new List { }; + var listOfValuesSecondMatrix = new List { }; + var listOfCorrectValues = new List { }; + + listOfValuesFirstMatrix.Add(new int[5] { 1, 2, -3, 4, 5 }); + listOfValuesFirstMatrix.Add(new int[5] { 6, -7, 8, 9, 10 }); + + listOfValuesSecondMatrix.Add(new int[1] { 1 }); + listOfValuesSecondMatrix.Add(new int[1] { 2 }); + listOfValuesSecondMatrix.Add(new int[1] { 3 }); + listOfValuesSecondMatrix.Add(new int[1] { -4 }); + listOfValuesSecondMatrix.Add(new int[1] { 5 }); + + listOfCorrectValues.Add(new int[1] { 5 }); + listOfCorrectValues.Add(new int[1] { 30 }); + + var firstMatrix = Matrix.Create(2, 5, listOfValuesFirstMatrix); + var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); + + var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix); + Assert.True(Matrix.AreMatricesEquals(resultMatrix, correctMatrix)); } [Test] public void MultiplyingMatricesWithZero() { - var sizeThreads = 10; - var listOfValuesFirstMatrix = new List { 1, 2, 0, 4, 5, 6, 0, 8, 9, 10 }; - var listOfValuesSecondMatrix = new List { 1, 2, 0, 0, 5 }; - var listOfCorrectValues = new List { 30, 56 }; - var firstMatrix = Matrix.CreateMatrix(2, 5, listOfValuesFirstMatrix); - var secondMatrix = Matrix.CreateMatrix(5, 1, listOfValuesSecondMatrix); - var correctMatrix = Matrix.CreateMatrix(2, 1, listOfCorrectValues); - - var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); - Assert.True(Matrix.MatrixComparison(resultMatrix, correctMatrix)); + var listOfValuesFirstMatrix = new List { }; + var listOfValuesSecondMatrix = new List { }; + var listOfCorrectValues = new List { }; + + listOfValuesFirstMatrix.Add(new int[5] { 1, 2, 0, 4, 5 }); + listOfValuesFirstMatrix.Add(new int[5] { 6, 0, 8, 9, 10 }); + + listOfValuesSecondMatrix.Add(new int[1] { 1 }); + listOfValuesSecondMatrix.Add(new int[1] { 2 }); + listOfValuesSecondMatrix.Add(new int[1] { 0 }); + listOfValuesSecondMatrix.Add(new int[1] { 0 }); + listOfValuesSecondMatrix.Add(new int[1] { 5 }); + + listOfCorrectValues.Add(new int[1] { 30 }); + listOfCorrectValues.Add(new int[1] { 56 }); + + var firstMatrix = Matrix.Create(2, 5, listOfValuesFirstMatrix); + var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); + + var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix); + Assert.True(Matrix.AreMatricesEquals(resultMatrix, correctMatrix)); } [Test] public void MultiplyingMatricesWithWrongData() { - var sizeThreads = 10; - var listOfCorrectValues = new List { 30, 56 }; - var correctMatrix = Matrix.CreateMatrix(2, 1, listOfCorrectValues); - Assert.Throws(() => Matrix.MatrixMultiplicationControlFunction(Path.Combine(TestContext.CurrentContext.TestDirectory, + var listOfCorrectValues = new List { }; + listOfCorrectValues.Add(new int[1] { 30 }); + listOfCorrectValues.Add(new int[1] { 56 }); + var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); + Assert.Throws(() => Matrix.MatrixMultiplication(Path.Combine(TestContext.CurrentContext.TestDirectory, "TestsForMatrix", "firstCorrectMatrix.txt"), Path.Combine(TestContext.CurrentContext.TestDirectory, "TestsForMatrix", "incorrectMatrix.txt"), Path.Combine(TestContext.CurrentContext.TestDirectory, - "TestsForMatrix", "resultMatrix.txt"), - sizeThreads - )); + "TestsForMatrix", "resultMatrix.txt"))); } } \ No newline at end of file diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/CreateTable.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/CreateTable.cs index ee68087..3ee9805 100644 --- a/parallelMatrixMultiplication/parallelMatrixMultiplication/CreateTable.cs +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/CreateTable.cs @@ -5,7 +5,7 @@ /// /// A class for measuring the standard deviation and mathematical expectation /// -public static class CreateTable +public static class GetStandartDeviationAndMinValue { private static int n = 10; @@ -28,7 +28,7 @@ private static double GetMinValue(int[][] firstMatrix, int[][] secondMatrix, int { var stopWatch = new Stopwatch(); stopWatch.Start(); - var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); + var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix); stopWatch.Stop(); arrayForStandardDeviation[i] = (double)stopWatch.ElapsedMilliseconds / 1000; summary += arrayForStandardDeviation[i]; @@ -38,12 +38,21 @@ private static double GetMinValue(int[][] firstMatrix, int[][] secondMatrix, int private static void MultiplyingMatricesOfSizeThreeByThree(string filePath) { - var sizeThreads = 3; - var listOfValues = new List { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; - var listOfCorrectValues = new List { 30, 36, 42, 66, 81, 96, 102, 126, 150 }; - var firstMatrix = Matrix.CreateMatrix(3, 3, listOfValues); - var secondMatrix = Matrix.CreateMatrix(3, 3, listOfValues); - var correctMatrix = Matrix.CreateMatrix(3, 3, listOfCorrectValues); + var sizeThreads = Environment.ProcessorCount; + var listOfValues = new List { }; + var listOfCorrectValues = new List { }; + + listOfValues.Add(new int[3] { 1, 2, 3 }); + listOfValues.Add(new int[3] { 4, 5, 6 }); + listOfValues.Add(new int[3] { 7, 8, 9 }); + + listOfCorrectValues.Add(new int[3] { 30, 36, 42 }); + listOfCorrectValues.Add(new int[3] { 66, 81, 96 }); + listOfCorrectValues.Add(new int[3] { 102, 126, 150 }); + + var firstMatrix = Matrix.Create(3, 3, listOfValues); + var secondMatrix = Matrix.Create(3, 3, listOfValues); + var correctMatrix = Matrix.Create(3, 3, listOfCorrectValues); var arrayForStandardDeviation = new double[n]; double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, @@ -60,25 +69,28 @@ private static void MultiplyingMatricesOfSizeThreeByThree(string filePath) private static void MultiplyingMatricesOfBigSize(string filePath) { - var sizeThreads = 50; + var sizeThreads = Environment.ProcessorCount; - var listOfValuesFirstMatrix = new List { }; - var listOfValuesSecondMatrix = new List { }; - var listOfCorrectValues = new List { }; + var listOfValuesFirstMatrix = new List { }; + var listOfValuesSecondMatrix = new List { }; + var listOfCorrectValues = new List { }; for (int i = 0; i < 10000; i++) { + listOfValuesFirstMatrix.Add(new int[10000]); + listOfValuesSecondMatrix.Add(new int[1]); + listOfCorrectValues.Add(new int[1]); for (int j = 0; j < 10000; ++j) { - listOfValuesFirstMatrix.Add(1); + listOfValuesFirstMatrix[i][j] = 1; } - listOfValuesSecondMatrix.Add(1); - listOfCorrectValues.Add(10000); + listOfValuesSecondMatrix[i][0] = 1; + listOfCorrectValues[i][0] = 10000; } - var firstMatrix = Matrix.CreateMatrix(10000, 10000, listOfValuesFirstMatrix); - var secondMatrix = Matrix.CreateMatrix(10000, 1, listOfValuesSecondMatrix); - var correctMatrix = Matrix.CreateMatrix(10000, 1, listOfCorrectValues); + var firstMatrix = Matrix.Create(10000, 10000, listOfValuesFirstMatrix); + var secondMatrix = Matrix.Create(10000, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.Create(10000, 1, listOfCorrectValues); var arrayForStandardDeviation = new double[n]; double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, @@ -95,13 +107,26 @@ private static void MultiplyingMatricesOfBigSize(string filePath) private static void MultiplyingMatricesOfDifferentSizes(string filePath) { - var sizeThreads = 3; - var listOfValuesFirstMatrix = new List { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; - var listOfValuesSecondMatrix = new List { 1, 2, 3 }; - var listOfCorrectValues = new List { 14, 32, 50 }; - var firstMatrix = Matrix.CreateMatrix(3, 3, listOfValuesFirstMatrix); - var secondMatrix = Matrix.CreateMatrix(3, 1, listOfValuesSecondMatrix); - var correctMatrix = Matrix.CreateMatrix(3, 1, listOfCorrectValues); + var sizeThreads = Environment.ProcessorCount; + var listOfValuesFirstMatrix = new List { }; + var listOfValuesSecondMatrix = new List { }; + var listOfCorrectValues = new List { }; + + listOfValuesFirstMatrix.Add(new int[3] { 1, 2, 3 }); + listOfValuesFirstMatrix.Add(new int[3] { 4, 5, 6 }); + listOfValuesFirstMatrix.Add(new int[3] { 7, 8, 9 }); + + listOfValuesSecondMatrix.Add(new int[1] { 1 }); + listOfValuesSecondMatrix.Add(new int[1] { 2 }); + listOfValuesSecondMatrix.Add(new int[1] { 3 }); + + listOfCorrectValues.Add(new int[1] { 14 }); + listOfCorrectValues.Add(new int[1] { 32 }); + listOfCorrectValues.Add(new int[1] { 50 }); + + var firstMatrix = Matrix.Create(3, 3, listOfValuesFirstMatrix); + var secondMatrix = Matrix.Create(3, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.Create(3, 1, listOfCorrectValues); var arrayForStandardDeviation = new double[n]; double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, @@ -118,13 +143,26 @@ private static void MultiplyingMatricesOfDifferentSizes(string filePath) private static void MultiplyingOfNotSquareMatrices(string filePath) { - var sizeThreads = 10; - var listOfValuesFirstMatrix = new List { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; - var listOfValuesSecondMatrix = new List { 1, 2, 3, 4, 5 }; - var listOfCorrectValues = new List { 55, 130 }; - var firstMatrix = Matrix.CreateMatrix(2, 5, listOfValuesFirstMatrix); - var secondMatrix = Matrix.CreateMatrix(5, 1, listOfValuesSecondMatrix); - var correctMatrix = Matrix.CreateMatrix(2, 1, listOfCorrectValues); + var sizeThreads = Environment.ProcessorCount; + var listOfValuesFirstMatrix = new List { }; + var listOfValuesSecondMatrix = new List { }; + var listOfCorrectValues = new List { }; + + listOfValuesFirstMatrix.Add(new int[5] { 1, 2, 3, 4, 5 }); + listOfValuesFirstMatrix.Add(new int[5] { 6, 7, 8, 9, 10 }); + + listOfValuesSecondMatrix.Add(new int[1] { 1 }); + listOfValuesSecondMatrix.Add(new int[1] { 2 }); + listOfValuesSecondMatrix.Add(new int[1] { 3 }); + listOfValuesSecondMatrix.Add(new int[1] { 4 }); + listOfValuesSecondMatrix.Add(new int[1] { 5 }); + + listOfCorrectValues.Add(new int[1] { 55 }); + listOfCorrectValues.Add(new int[1] { 130 }); + + var firstMatrix = Matrix.Create(2, 5, listOfValuesFirstMatrix); + var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); var arrayForStandardDeviation = new double[n]; double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, @@ -141,13 +179,26 @@ private static void MultiplyingOfNotSquareMatrices(string filePath) private static void MultiplyingMatricesWithNegativeNumbers(string filePath) { - var sizeThreads = 10; - var listOfValuesFirstMatrix = new List { 1, 2, -3, 4, 5, 6, -7, 8, 9, 10 }; - var listOfValuesSecondMatrix = new List { 1, 2, 3, -4, 5 }; - var listOfCorrectValues = new List { 5, 30 }; - var firstMatrix = Matrix.CreateMatrix(2, 5, listOfValuesFirstMatrix); - var secondMatrix = Matrix.CreateMatrix(5, 1, listOfValuesSecondMatrix); - var correctMatrix = Matrix.CreateMatrix(2, 1, listOfCorrectValues); + var sizeThreads = Environment.ProcessorCount; + var listOfValuesFirstMatrix = new List { }; + var listOfValuesSecondMatrix = new List { }; + var listOfCorrectValues = new List { }; + + listOfValuesFirstMatrix.Add(new int[5] { 1, 2, -3, 4, 5 }); + listOfValuesFirstMatrix.Add(new int[5] { 6, -7, 8, 9, 10 }); + + listOfValuesSecondMatrix.Add(new int[1] { 1 }); + listOfValuesSecondMatrix.Add(new int[1] { 2 }); + listOfValuesSecondMatrix.Add(new int[1] { 3 }); + listOfValuesSecondMatrix.Add(new int[1] { -4 }); + listOfValuesSecondMatrix.Add(new int[1] { 5 }); + + listOfCorrectValues.Add(new int[1] { 5 }); + listOfCorrectValues.Add(new int[1] { 30 }); + + var firstMatrix = Matrix.Create(2, 5, listOfValuesFirstMatrix); + var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); var arrayForStandardDeviation = new double[n]; double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, @@ -164,13 +215,26 @@ private static void MultiplyingMatricesWithNegativeNumbers(string filePath) private static void MultiplyingMatricesWithZero(string filePath) { - var sizeThreads = 10; - var listOfValuesFirstMatrix = new List { 1, 2, 0, 4, 5, 6, 0, 8, 9, 10 }; - var listOfValuesSecondMatrix = new List { 1, 2, 0, 0, 5 }; - var listOfCorrectValues = new List { 30, 56 }; - var firstMatrix = Matrix.CreateMatrix(2, 5, listOfValuesFirstMatrix); - var secondMatrix = Matrix.CreateMatrix(5, 1, listOfValuesSecondMatrix); - var correctMatrix = Matrix.CreateMatrix(2, 1, listOfCorrectValues); + var sizeThreads = Environment.ProcessorCount; + var listOfValuesFirstMatrix = new List { }; + var listOfValuesSecondMatrix = new List { }; + var listOfCorrectValues = new List { }; + + listOfValuesFirstMatrix.Add(new int[5] { 1, 2, 0, 4, 5 }); + listOfValuesFirstMatrix.Add(new int[5] { 6, 0, 8, 9, 10 }); + + listOfValuesSecondMatrix.Add(new int[1] { 1 }); + listOfValuesSecondMatrix.Add(new int[1] { 2 }); + listOfValuesSecondMatrix.Add(new int[1] { 0 }); + listOfValuesSecondMatrix.Add(new int[1] { 0 }); + listOfValuesSecondMatrix.Add(new int[1] { 5 }); + + listOfCorrectValues.Add(new int[1] { 30 }); + listOfCorrectValues.Add(new int[1] { 56 }); + + var firstMatrix = Matrix.Create(2, 5, listOfValuesFirstMatrix); + var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); + var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); var arrayForStandardDeviation = new double[n]; double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/InvalidFileException.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/InvalidFileException.cs index c13d7e9..ae70dc3 100644 --- a/parallelMatrixMultiplication/parallelMatrixMultiplication/InvalidFileException.cs +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/InvalidFileException.cs @@ -2,4 +2,10 @@ /// /// Exception for errors with file /// -public class InvalidFileException : Exception{} \ No newline at end of file +public class InvalidFileException : Exception +{ + public InvalidFileException() { } + public InvalidFileException(string message) : base(message) {} + public InvalidFileException(string message, Exception inner) + : base(message, inner) {} +} \ No newline at end of file diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs index 9c6752b..48055ca 100644 --- a/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs @@ -1,5 +1,6 @@ namespace parallelMatrixMultiplication; using System; +using System.Diagnostics; using System.Threading; /// @@ -16,9 +17,9 @@ public static class Matrix /// Returns the created matrix /// Throws an exception if the number of items /// in the list does not match the size of the matrix - public static int[][] CreateMatrix(int sizeRows, int sizeColumns, List numbersForMatrix) + public static int[][] Create(int sizeRows, int sizeColumns, List numbersForMatrix) { - if (numbersForMatrix.Count != sizeColumns * sizeRows) + if (numbersForMatrix.Count * numbersForMatrix[0].Length != sizeColumns * sizeRows) { throw new ArgumentException(); } @@ -29,14 +30,11 @@ public static int[][] CreateMatrix(int sizeRows, int sizeColumns, List numb matrix[i] = new int[sizeColumns]; } - var indexInList = 0; - for (int i = 0; i < sizeRows; ++i) { for (int j = 0; j < sizeColumns; ++j) { - matrix[i][j] = numbersForMatrix[indexInList]; - indexInList++; + matrix[i][j] = numbersForMatrix[i][j]; } } @@ -46,7 +44,7 @@ public static int[][] CreateMatrix(int sizeRows, int sizeColumns, List numb /// /// The function compares matrices /// - public static bool MatrixComparison(int[][] firstMatrix, int[][] secondMatrix) + public static bool AreMatricesEquals(int[][] firstMatrix, int[][] secondMatrix) { if (firstMatrix.Length != secondMatrix.Length) { @@ -70,7 +68,33 @@ public static bool MatrixComparison(int[][] firstMatrix, int[][] secondMatrix) return true; } - private static int[][] ConvertinMatrixToTransposedOne(int[][] matrix)// сменить на private + /// + /// Multiplies matrices by a sequential algorithm + /// + /// The resulting matrix + public static int[][] ConsistentMatrixMultiply(int[][] firstMatrix, int[][] secondMatrix) + { + var resultMatrix = new int[firstMatrix.Length][]; + + for (int i = 0; i < firstMatrix.Length; ++i) + { + resultMatrix[i] = new int[secondMatrix[0].Length]; + } + + for (int i = 0; i < firstMatrix.Length; ++i) + { + for (int j = 0; j < secondMatrix[0].Length; ++j) + { + for (var k = 0; k < firstMatrix[0].Length; ++k) + { + resultMatrix[i][j] += firstMatrix[i][k] * secondMatrix[k][j]; + } + } + } + return resultMatrix; + } + + private static int[][] ConvertinMatrixToTransposedOne(int[][] matrix) { var transposedMatrix = new int[matrix[0].Length][]; for (int i = 0; i < matrix[0].Length; i++) @@ -107,7 +131,7 @@ private static void Multiply(int start, int end, int[][] firstMatrix, int[][] tr /// Parallel matrix multiplication function /// /// Returns the calculated matrix - public static int[][] MatrixMultiplication(int[][] firstMatrix, int[][] secondMatrix, int threadCounts) + public static int[][] MatrixMultiplication(int[][] firstMatrix, int[][] secondMatrix) { var resultMatrix = new int[firstMatrix.Length][]; @@ -116,7 +140,8 @@ public static int[][] MatrixMultiplication(int[][] firstMatrix, int[][] secondMa resultMatrix[i] = new int[secondMatrix[0].Length]; } - + var threadCounts = Environment.ProcessorCount; + if (threadCounts > firstMatrix.Length) { threadCounts = firstMatrix.Length; @@ -137,11 +162,15 @@ public static int[][] MatrixMultiplication(int[][] firstMatrix, int[][] secondMa int localStart = start; int localEnd = end; threads[i] = new Thread(() => Multiply(localStart, localEnd, firstMatrix, transposedMatrix, resultMatrix)); - threads[i].Start(); start = end; } - foreach (var thread in threads ) + foreach (var thread in threads) + { + thread.Start(); + } + + foreach (var thread in threads) { thread.Join(); } @@ -153,9 +182,7 @@ public static int[][] MatrixMultiplication(int[][] firstMatrix, int[][] secondMa private static int[][] ReadFromFileMatrix(string filePath) { var allLines = File.ReadAllLines(filePath); - var matrix = new int[allLines.Length][]; - var sizeColumns = 0; for (int i = 0; i < matrix.Length; i++) @@ -204,11 +231,41 @@ private static void WriteResultMatrixToFile(string filePath, int[][] matrix) /// /// A function that receives files with matrices at the input, and a calculated matrix at the output /// - public static void MatrixMultiplicationControlFunction(string firstFile, string secondFile, string resultFile, int sizeThreads) + public static void MatrixMultiplication(string firstFile, string secondFile, string resultFile) { var firstMatrix = ReadFromFileMatrix(firstFile); var secondMatrix = ReadFromFileMatrix(secondFile); - var resultMatrix = MatrixMultiplication(firstMatrix, secondMatrix, sizeThreads); + var resultMatrix = MatrixMultiplication(firstMatrix, secondMatrix); WriteResultMatrixToFile(resultFile, resultMatrix); } + + /// + /// Multiplies matrices by successive multiplication + /// + public static long CompareMatrixMultiplication(string firstFile, string secondFile) + { + var firstMatrix = ReadFromFileMatrix(firstFile); + var secondMatrix = ReadFromFileMatrix(secondFile); + + var stopwatchParallelMultiplication = new Stopwatch(); + stopwatchParallelMultiplication.Start(); + var resultMatrixFromParallelMultiplication = MatrixMultiplication(firstMatrix, secondMatrix); + stopwatchParallelMultiplication.Stop(); + + var result = stopwatchParallelMultiplication.ElapsedMilliseconds; + + var stopwatchConsistentMultiplication = new Stopwatch(); + stopwatchConsistentMultiplication.Start(); + var resultMatrixFromConsistentMultipliaction = ConsistentMatrixMultiply(firstMatrix, secondMatrix); + stopwatchConsistentMultiplication.Stop(); + + result -= stopwatchConsistentMultiplication.ElapsedMilliseconds; + + if (!AreMatricesEquals(resultMatrixFromConsistentMultipliaction, resultMatrixFromParallelMultiplication)) + { + throw new MultiplyException(); + } + + return result; + } } \ No newline at end of file diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/MultiplyException.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/MultiplyException.cs new file mode 100644 index 0000000..8d38a06 --- /dev/null +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/MultiplyException.cs @@ -0,0 +1,13 @@ +namespace parallelMatrixMultiplication; + +/// +/// An exception is thrown when the results of parallel and sequential multiplication do not match +/// +public class MultiplyException : Exception +{ + public MultiplyException() {} + + public MultiplyException(string? message) : base(message) {} + + public MultiplyException(string? message, Exception? innerException) : base(message, innerException) {} +} \ No newline at end of file diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs index 9d46dc9..6f82184 100644 --- a/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs @@ -9,8 +9,40 @@ Console.WriteLine("Write file path for create table"); var tableFile = Console.ReadLine(); -if (tableFile != null && firstFile != null && secondFile != null && resultFile != null) +if (tableFile == null) { - Matrix.MatrixMultiplicationControlFunction(firstFile, secondFile, resultFile, 8); - CreateTable.CreateTableWithResults(tableFile); + Console.WriteLine("Неверно прописан путь для tableFile"); + return; +} +if (resultFile == null) +{ + Console.WriteLine("Неверно прописан путь для firstFile"); + return; +} +if (secondFile == null) +{ + Console.WriteLine("Неверно прописан путь для secondFile"); + return; +} +if (firstFile == null) +{ + Console.WriteLine("Неверно прописан путь для resultFile"); + return; +} + +Matrix.MatrixMultiplication(firstFile, secondFile, resultFile); +GetStandartDeviationAndMinValue.CreateTableWithResults(tableFile); + +var resultCompare = Matrix.CompareMatrixMultiplication(firstFile, secondFile); +if (resultCompare < 0) +{ + Console.Write("Параллельное перемножение матриц медленнее, чем последовательное на "); + Console.Write(resultCompare); + Console.WriteLine(" миллисекунд"); +} +if (resultCompare > 0) +{ + Console.Write("Последовательное перемножение матриц медленнее, чем параллельное на "); + Console.Write(resultCompare); + Console.WriteLine(" миллисекунд"); } \ No newline at end of file diff --git a/parallelMatrixMultiplication/tableFile.txt b/parallelMatrixMultiplication/tableFile.txt new file mode 100644 index 0000000..c7f961c --- /dev/null +++ b/parallelMatrixMultiplication/tableFile.txt @@ -0,0 +1,13 @@ +В файле представлены: математическое ожидание и среднеквадратичное отклонение +Математическое ожидание и среднеквадратичное отклонение для матриц размера 3x3: +Матемматическое ожидание: 0,0019000000000000002 Среднеквадратичное отклонение: 0,002514402955419481 +Математическое ожидание и среднеквадратичное отклонение для матриц размера 10000x10000 и 10000x1: +Матемматическое ожидание: 0,19010000000000002 Среднеквадратичное отклонение: 0,094399211390303 +Математическое ожидание и среднеквадратичное отклонение для матриц размера 3x3 и 3x1: +Матемматическое ожидание: 0,0011000000000000003 Среднеквадратичное отклонение: 0,0003162277660168379 +Математическое ожидание и среднеквадратичное отклонение для матриц размера 2x5 и 5x1: +Матемматическое ожидание: 0,0004 Среднеквадратичное отклонение: 0,0005163977794943222 +Математическое ожидание и среднеквадратичное отклонение для матриц размера 2x5 и 5x1 с отрицательными числами: +Матемматическое ожидание: 0,0011000000000000003 Среднеквадратичное отклонение: 0,0003162277660168379 +Математическое ожидание и среднеквадратичное отклонение для матриц размера 2x5 и 5x1 с нулями: +Матемматическое ожидание: 0,0010000000000000002 Среднеквадратичное отклонение: 2,28569887277129E-19 From ef7f6c05ed9ddb5d18ddd8b9a533ad21935b9b03 Mon Sep 17 00:00:00 2001 From: Artem Date: Fri, 29 Sep 2023 23:53:14 +0300 Subject: [PATCH 3/7] =?UTF-8?q?=D0=A0=D0=B5=D0=B2=D1=8C=D1=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../TestsForMatrixMultiplication.cs | 200 +++++++++------- .../parallelMatrixMultiplication/Matrix.cs | 36 +-- .../parallelMatrixMultiplication/Program.cs | 10 +- ...=> StandartDeviationAndMathExpectation.cs} | 219 ++++++++++-------- 4 files changed, 258 insertions(+), 207 deletions(-) rename parallelMatrixMultiplication/parallelMatrixMultiplication/{CreateTable.cs => StandartDeviationAndMathExpectation.cs} (61%) diff --git a/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs b/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs index fd51deb..40cc657 100644 --- a/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs +++ b/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs @@ -5,29 +5,32 @@ namespace TestsForMatrixMultiplication; public class Tests { [Test] - public void MultiplyingMatricesOfSizeThreeByThree() + public void MultiplyMatricesOfSizeThreeByThree() { - var listOfValues = new List {}; - var listOfCorrectValues = new List {}; - - listOfValues.Add(new int[3] { 1, 2, 3 }); - listOfValues.Add(new int[3] { 4, 5, 6 }); - listOfValues.Add(new int[3] { 7, 8, 9 }); + var listOfValues = new List + { + new int[3] { 1, 2, 3 }, + new int[3] { 4, 5, 6 }, + new int[3] { 7, 8, 9 }, + }; - listOfCorrectValues.Add(new int[3] { 30, 36, 42 }); - listOfCorrectValues.Add(new int[3] { 66, 81, 96 }); - listOfCorrectValues.Add(new int[3] { 102, 126, 150 }); + var listOfCorrectValues = new List + { + new int[3] { 30, 36, 42 }, + new int[3] { 66, 81, 96 }, + new int[3] { 102, 126, 150 }, + }; var firstMatrix = Matrix.Create(3, 3, listOfValues); var secondMatrix = Matrix.Create(3, 3, listOfValues); var correctMatrix = Matrix.Create(3, 3, listOfCorrectValues); - var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix); - Assert.True(Matrix.AreMatricesEquals(resultMatrix, correctMatrix)); + var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); + Assert.True(Matrix.AreEquals(resultMatrix, correctMatrix)); } [Test] - public void MultiplyingMatricesOfBigSize() + public void MultiplyMatricesOfBigSize() { var listOfValuesFirstMatrix = new List {}; var listOfValuesSecondMatrix = new List {}; @@ -50,126 +53,149 @@ public void MultiplyingMatricesOfBigSize() var secondMatrix = Matrix.Create(10000, 1, listOfValuesSecondMatrix); var correctMatrix = Matrix.Create(10000, 1, listOfCorrectValues); - var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix); - Assert.True(Matrix.AreMatricesEquals(resultMatrix, correctMatrix)); + var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); + Assert.True(Matrix.AreEquals(resultMatrix, correctMatrix)); } [Test] - public void MultiplyingMatricesOfDifferentSizes() + public void MultiplyMatricesOfDifferentSizes() { - var listOfValuesFirstMatrix = new List {}; - var listOfValuesSecondMatrix = new List {}; - var listOfCorrectValues = new List {}; - - listOfValuesFirstMatrix.Add(new int[3] { 1, 2, 3 }); - listOfValuesFirstMatrix.Add(new int[3] { 4, 5, 6 }); - listOfValuesFirstMatrix.Add(new int[3] { 7, 8, 9 }); + var listOfValuesFirstMatrix = new List + { + new int[3] { 1, 2, 3 }, + new int[3] { 4, 5, 6 }, + new int[3] { 7, 8, 9 }, + }; - listOfValuesSecondMatrix.Add(new int[1] { 1 }); - listOfValuesSecondMatrix.Add(new int[1] { 2 }); - listOfValuesSecondMatrix.Add(new int[1] { 3 }); + var listOfValuesSecondMatrix = new List + { + new int[1] { 1 }, + new int[1] { 2 }, + new int[1] { 3 }, + }; - listOfCorrectValues.Add(new int[1] { 14 }); - listOfCorrectValues.Add(new int[1] { 32 }); - listOfCorrectValues.Add(new int[1] { 50 }); + var listOfCorrectValues = new List + { + new int[1] { 14 }, + new int[1] { 32 }, + new int[1] { 50 }, + }; var firstMatrix = Matrix.Create(3, 3, listOfValuesFirstMatrix); var secondMatrix = Matrix.Create(3, 1, listOfValuesSecondMatrix); var correctMatrix = Matrix.Create(3, 1, listOfCorrectValues); - var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix); - Assert.True(Matrix.AreMatricesEquals(resultMatrix, correctMatrix)); + var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); + Assert.True(Matrix.AreEquals(resultMatrix, correctMatrix)); } [Test] - public void MultiplyingOfNotSquareMatrices() + public void MultiplyOfNotSquareMatrices() { - var listOfValuesFirstMatrix = new List { }; - var listOfValuesSecondMatrix = new List { }; - var listOfCorrectValues = new List { }; - - listOfValuesFirstMatrix.Add(new int[5] { 1, 2, 3, 4, 5 }); - listOfValuesFirstMatrix.Add(new int[5] { 6, 7, 8, 9, 10 }); - - listOfValuesSecondMatrix.Add(new int[1] { 1 }); - listOfValuesSecondMatrix.Add(new int[1] { 2 }); - listOfValuesSecondMatrix.Add(new int[1] { 3 }); - listOfValuesSecondMatrix.Add(new int[1] { 4 }); - listOfValuesSecondMatrix.Add(new int[1] { 5 }); + var listOfValuesFirstMatrix = new List + { + new int[5] { 1, 2, 3, 4, 5 }, + new int[5] { 6, 7, 8, 9, 10 }, + }; - listOfCorrectValues.Add(new int[1] { 55 }); - listOfCorrectValues.Add(new int[1] { 130 }); + var listOfValuesSecondMatrix = new List + { + new int[1] { 1 }, + new int[1] { 2 }, + new int[1] { 3 }, + new int[1] { 4 }, + new int[1] { 5 }, + }; + + var listOfCorrectValues = new List + { + new int[1] { 55 }, + new int[1] { 130 }, + }; var firstMatrix = Matrix.Create(2, 5, listOfValuesFirstMatrix); var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); - var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix); - Assert.True(Matrix.AreMatricesEquals(resultMatrix, correctMatrix)); + var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); + Assert.True(Matrix.AreEquals(resultMatrix, correctMatrix)); } [Test] - public void MultiplyingMatricesWithNegativeNumbers() + public void MultiplyMatricesWithNegativeNumbers() { - var listOfValuesFirstMatrix = new List { }; - var listOfValuesSecondMatrix = new List { }; - var listOfCorrectValues = new List { }; - - listOfValuesFirstMatrix.Add(new int[5] { 1, 2, -3, 4, 5 }); - listOfValuesFirstMatrix.Add(new int[5] { 6, -7, 8, 9, 10 }); - - listOfValuesSecondMatrix.Add(new int[1] { 1 }); - listOfValuesSecondMatrix.Add(new int[1] { 2 }); - listOfValuesSecondMatrix.Add(new int[1] { 3 }); - listOfValuesSecondMatrix.Add(new int[1] { -4 }); - listOfValuesSecondMatrix.Add(new int[1] { 5 }); + var listOfValuesFirstMatrix = new List + { + new int[5] { 1, 2, -3, 4, 5 }, + new int[5] { 6, -7, 8, 9, 10 }, + }; - listOfCorrectValues.Add(new int[1] { 5 }); - listOfCorrectValues.Add(new int[1] { 30 }); + var listOfValuesSecondMatrix = new List + { + new int[1] { 1 }, + new int[1] { 2 }, + new int[1] { 3 }, + new int[1] { -4 }, + new int[1] { 5 }, + }; + + var listOfCorrectValues = new List + { + new int[1] { 5 }, + new int[1] { 30 }, + }; var firstMatrix = Matrix.Create(2, 5, listOfValuesFirstMatrix); var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); - var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix); - Assert.True(Matrix.AreMatricesEquals(resultMatrix, correctMatrix)); + var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); + Assert.True(Matrix.AreEquals(resultMatrix, correctMatrix)); } [Test] - public void MultiplyingMatricesWithZero() + public void MultiplyMatricesWithZero() { - var listOfValuesFirstMatrix = new List { }; - var listOfValuesSecondMatrix = new List { }; - var listOfCorrectValues = new List { }; - - listOfValuesFirstMatrix.Add(new int[5] { 1, 2, 0, 4, 5 }); - listOfValuesFirstMatrix.Add(new int[5] { 6, 0, 8, 9, 10 }); - - listOfValuesSecondMatrix.Add(new int[1] { 1 }); - listOfValuesSecondMatrix.Add(new int[1] { 2 }); - listOfValuesSecondMatrix.Add(new int[1] { 0 }); - listOfValuesSecondMatrix.Add(new int[1] { 0 }); - listOfValuesSecondMatrix.Add(new int[1] { 5 }); + var listOfValuesFirstMatrix = new List + { + new int[5] { 1, 2, 0, 4, 5 }, + new int[5] { 6, 0, 8, 9, 10 }, + }; - listOfCorrectValues.Add(new int[1] { 30 }); - listOfCorrectValues.Add(new int[1] { 56 }); + var listOfValuesSecondMatrix = new List + { + new int[1] { 1 }, + new int[1] { 2 }, + new int[1] { 0 }, + new int[1] { 0 }, + new int[1] { 5 }, + }; + + var listOfCorrectValues = new List + { + new int[1] { 30 }, + new int[1] { 56 }, + }; var firstMatrix = Matrix.Create(2, 5, listOfValuesFirstMatrix); var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); - var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix); - Assert.True(Matrix.AreMatricesEquals(resultMatrix, correctMatrix)); + var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); + Assert.True(Matrix.AreEquals(resultMatrix, correctMatrix)); } [Test] - public void MultiplyingMatricesWithWrongData() + public void MultiplyMatricesWithWrongData() { - var listOfCorrectValues = new List { }; - listOfCorrectValues.Add(new int[1] { 30 }); - listOfCorrectValues.Add(new int[1] { 56 }); + var listOfCorrectValues = new List + { + new int[1] { 30 }, + new int[1] { 56 }, + }; + var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); - Assert.Throws(() => Matrix.MatrixMultiplication(Path.Combine(TestContext.CurrentContext.TestDirectory, + Assert.Throws(() => Matrix.Multiplication(Path.Combine(TestContext.CurrentContext.TestDirectory, "TestsForMatrix", "firstCorrectMatrix.txt"), Path.Combine(TestContext.CurrentContext.TestDirectory, "TestsForMatrix", "incorrectMatrix.txt"), diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs index 48055ca..744a2f8 100644 --- a/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs @@ -44,7 +44,7 @@ public static int[][] Create(int sizeRows, int sizeColumns, List numbersF /// /// The function compares matrices /// - public static bool AreMatricesEquals(int[][] firstMatrix, int[][] secondMatrix) + public static bool AreEquals(int[][] firstMatrix, int[][] secondMatrix) { if (firstMatrix.Length != secondMatrix.Length) { @@ -72,7 +72,7 @@ public static bool AreMatricesEquals(int[][] firstMatrix, int[][] secondMatrix) /// Multiplies matrices by a sequential algorithm /// /// The resulting matrix - public static int[][] ConsistentMatrixMultiply(int[][] firstMatrix, int[][] secondMatrix) + public static int[][] ConsistentMultiply(int[][] firstMatrix, int[][] secondMatrix) { var resultMatrix = new int[firstMatrix.Length][]; @@ -94,7 +94,7 @@ public static int[][] ConsistentMatrixMultiply(int[][] firstMatrix, int[][] seco return resultMatrix; } - private static int[][] ConvertinMatrixToTransposedOne(int[][] matrix) + private static int[][] ConvertMatrixToTransposedOne(int[][] matrix) { var transposedMatrix = new int[matrix[0].Length][]; for (int i = 0; i < matrix[0].Length; i++) @@ -131,7 +131,7 @@ private static void Multiply(int start, int end, int[][] firstMatrix, int[][] tr /// Parallel matrix multiplication function /// /// Returns the calculated matrix - public static int[][] MatrixMultiplication(int[][] firstMatrix, int[][] secondMatrix) + public static int[][] Multiply(int[][] firstMatrix, int[][] secondMatrix) { var resultMatrix = new int[firstMatrix.Length][]; @@ -154,7 +154,7 @@ public static int[][] MatrixMultiplication(int[][] firstMatrix, int[][] secondMa int start = 0; int end = 0; - var transposedMatrix = ConvertinMatrixToTransposedOne(secondMatrix); + var transposedMatrix = ConvertMatrixToTransposedOne(secondMatrix); for (int i = 0; i < threadCounts; i++) { @@ -179,7 +179,7 @@ public static int[][] MatrixMultiplication(int[][] firstMatrix, int[][] secondMa return resultMatrix; } - private static int[][] ReadFromFileMatrix(string filePath) + private static int[][] ReadFromFile(string filePath) { var allLines = File.ReadAllLines(filePath); var matrix = new int[allLines.Length][]; @@ -213,7 +213,7 @@ private static int[][] ReadFromFileMatrix(string filePath) return matrix; } - private static void WriteResultMatrixToFile(string filePath, int[][] matrix) + private static void WriteResultToFile(string filePath, int[][] matrix) { var streamForWrite = new StreamWriter(filePath); for (int i = 0; i < matrix.Length; ++i) @@ -231,37 +231,37 @@ private static void WriteResultMatrixToFile(string filePath, int[][] matrix) /// /// A function that receives files with matrices at the input, and a calculated matrix at the output /// - public static void MatrixMultiplication(string firstFile, string secondFile, string resultFile) + public static void Multiplication(string firstFile, string secondFile, string resultFile) { - var firstMatrix = ReadFromFileMatrix(firstFile); - var secondMatrix = ReadFromFileMatrix(secondFile); - var resultMatrix = MatrixMultiplication(firstMatrix, secondMatrix); - WriteResultMatrixToFile(resultFile, resultMatrix); + var firstMatrix = ReadFromFile(firstFile); + var secondMatrix = ReadFromFile(secondFile); + var resultMatrix = Multiply(firstMatrix, secondMatrix); + WriteResultToFile(resultFile, resultMatrix); } /// /// Multiplies matrices by successive multiplication /// - public static long CompareMatrixMultiplication(string firstFile, string secondFile) + public static long CompareMultiplication(string firstFile, string secondFile) { - var firstMatrix = ReadFromFileMatrix(firstFile); - var secondMatrix = ReadFromFileMatrix(secondFile); + var firstMatrix = ReadFromFile(firstFile); + var secondMatrix = ReadFromFile(secondFile); var stopwatchParallelMultiplication = new Stopwatch(); stopwatchParallelMultiplication.Start(); - var resultMatrixFromParallelMultiplication = MatrixMultiplication(firstMatrix, secondMatrix); + var resultMatrixFromParallelMultiplication = Multiply(firstMatrix, secondMatrix); stopwatchParallelMultiplication.Stop(); var result = stopwatchParallelMultiplication.ElapsedMilliseconds; var stopwatchConsistentMultiplication = new Stopwatch(); stopwatchConsistentMultiplication.Start(); - var resultMatrixFromConsistentMultipliaction = ConsistentMatrixMultiply(firstMatrix, secondMatrix); + var resultMatrixFromConsistentMultipliaction = ConsistentMultiply(firstMatrix, secondMatrix); stopwatchConsistentMultiplication.Stop(); result -= stopwatchConsistentMultiplication.ElapsedMilliseconds; - if (!AreMatricesEquals(resultMatrixFromConsistentMultipliaction, resultMatrixFromParallelMultiplication)) + if (!AreEquals(resultMatrixFromConsistentMultipliaction, resultMatrixFromParallelMultiplication)) { throw new MultiplyException(); } diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs index 6f82184..c2a1af0 100644 --- a/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs @@ -16,7 +16,7 @@ } if (resultFile == null) { - Console.WriteLine("Неверно прописан путь для firstFile"); + Console.WriteLine("Неверно прописан путь для resulFile"); return; } if (secondFile == null) @@ -26,14 +26,14 @@ } if (firstFile == null) { - Console.WriteLine("Неверно прописан путь для resultFile"); + Console.WriteLine("Неверно прописан путь для firstFile"); return; } -Matrix.MatrixMultiplication(firstFile, secondFile, resultFile); -GetStandartDeviationAndMinValue.CreateTableWithResults(tableFile); +Matrix.Multiplication(firstFile, secondFile, resultFile); +StandartDeviationAndMathExpectation.CreateTableWithResults(tableFile); -var resultCompare = Matrix.CompareMatrixMultiplication(firstFile, secondFile); +var resultCompare = Matrix.CompareMultiplication(firstFile, secondFile); if (resultCompare < 0) { Console.Write("Параллельное перемножение матриц медленнее, чем последовательное на "); diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/CreateTable.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs similarity index 61% rename from parallelMatrixMultiplication/parallelMatrixMultiplication/CreateTable.cs rename to parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs index 3ee9805..2d64569 100644 --- a/parallelMatrixMultiplication/parallelMatrixMultiplication/CreateTable.cs +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs @@ -5,22 +5,22 @@ /// /// A class for measuring the standard deviation and mathematical expectation /// -public static class GetStandartDeviationAndMinValue +public static class StandartDeviationAndMathExpectation { private static int n = 10; - private static double GetStandartDeviation(int n, double[] arrayForStandardDeviation, double minValue) + private static double GetStandartDeviation(int n, double[] arrayForStandardDeviation, double mathExpectation) { double summaryForStandartDeviation = 0; for (int i = 0; i < n; i++) { - summaryForStandartDeviation += Math.Pow(arrayForStandardDeviation[i] - minValue, 2); + summaryForStandartDeviation += Math.Pow(arrayForStandardDeviation[i] - mathExpectation, 2); } return Math.Sqrt(summaryForStandartDeviation / (n - 1)); } - private static double GetMinValue(int[][] firstMatrix, int[][] secondMatrix, int[][] correctMatrix, + private static double GetMathExpectation(int[][] firstMatrix, int[][] secondMatrix, int[][] correctMatrix, double[] arrayForStandardDeviation, int n, int sizeThreads) { double summary = 0; @@ -28,7 +28,7 @@ private static double GetMinValue(int[][] firstMatrix, int[][] secondMatrix, int { var stopWatch = new Stopwatch(); stopWatch.Start(); - var resultMatrix = Matrix.MatrixMultiplication(firstMatrix, secondMatrix); + var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); stopWatch.Stop(); arrayForStandardDeviation[i] = (double)stopWatch.ElapsedMilliseconds / 1000; summary += arrayForStandardDeviation[i]; @@ -36,38 +36,41 @@ private static double GetMinValue(int[][] firstMatrix, int[][] secondMatrix, int return summary / n; } - private static void MultiplyingMatricesOfSizeThreeByThree(string filePath) + private static void MultiplyMatricesOfSizeThreeByThree(string filePath) { var sizeThreads = Environment.ProcessorCount; - var listOfValues = new List { }; - var listOfCorrectValues = new List { }; - - listOfValues.Add(new int[3] { 1, 2, 3 }); - listOfValues.Add(new int[3] { 4, 5, 6 }); - listOfValues.Add(new int[3] { 7, 8, 9 }); + var listOfValues = new List + { + new int[3] { 1, 2, 3 }, + new int[3] { 4, 5, 6 }, + new int[3] { 7, 8, 9 }, + }; - listOfCorrectValues.Add(new int[3] { 30, 36, 42 }); - listOfCorrectValues.Add(new int[3] { 66, 81, 96 }); - listOfCorrectValues.Add(new int[3] { 102, 126, 150 }); + var listOfCorrectValues = new List + { + new int[3] { 30, 36, 42 }, + new int[3] { 66, 81, 96 }, + new int[3] { 102, 126, 150 }, + }; var firstMatrix = Matrix.Create(3, 3, listOfValues); var secondMatrix = Matrix.Create(3, 3, listOfValues); var correctMatrix = Matrix.Create(3, 3, listOfCorrectValues); var arrayForStandardDeviation = new double[n]; - double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, + double mathExpectation = GetMathExpectation(firstMatrix, secondMatrix, correctMatrix, arrayForStandardDeviation, n, sizeThreads); - var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, minValue); + var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); var streamForWrite = new StreamWriter(filePath, true); streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 3x3:"); streamForWrite.Write("Матемматическое ожидание: "); - streamForWrite.Write(minValue); + streamForWrite.Write(mathExpectation); streamForWrite.Write(" Среднеквадратичное отклонение: "); streamForWrite.WriteLine(standardDeviation); streamForWrite.Close(); } - private static void MultiplyingMatricesOfBigSize(string filePath) + private static void MultiplyMatricesOfBigSize(string filePath) { var sizeThreads = Environment.ProcessorCount; @@ -93,157 +96,179 @@ private static void MultiplyingMatricesOfBigSize(string filePath) var correctMatrix = Matrix.Create(10000, 1, listOfCorrectValues); var arrayForStandardDeviation = new double[n]; - double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, + double mathExpectation = GetMathExpectation(firstMatrix, secondMatrix, correctMatrix, arrayForStandardDeviation, n, sizeThreads); - var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, minValue); + var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); var streamForWrite = new StreamWriter(filePath, true); streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 10000x10000 и 10000x1:"); streamForWrite.Write("Матемматическое ожидание: "); - streamForWrite.Write(minValue); + streamForWrite.Write(mathExpectation); streamForWrite.Write(" Среднеквадратичное отклонение: "); streamForWrite.WriteLine(standardDeviation); streamForWrite.Close(); } - private static void MultiplyingMatricesOfDifferentSizes(string filePath) + private static void MultiplyMatricesOfDifferentSizes(string filePath) { var sizeThreads = Environment.ProcessorCount; - var listOfValuesFirstMatrix = new List { }; - var listOfValuesSecondMatrix = new List { }; - var listOfCorrectValues = new List { }; - - listOfValuesFirstMatrix.Add(new int[3] { 1, 2, 3 }); - listOfValuesFirstMatrix.Add(new int[3] { 4, 5, 6 }); - listOfValuesFirstMatrix.Add(new int[3] { 7, 8, 9 }); + var listOfValuesFirstMatrix = new List + { + new int[3] { 1, 2, 3 }, + new int[3] { 4, 5, 6 }, + new int[3] { 7, 8, 9 }, + }; - listOfValuesSecondMatrix.Add(new int[1] { 1 }); - listOfValuesSecondMatrix.Add(new int[1] { 2 }); - listOfValuesSecondMatrix.Add(new int[1] { 3 }); + var listOfValuesSecondMatrix = new List + { + new int[1] { 1 }, + new int[1] { 2 }, + new int[1] { 3 }, + }; - listOfCorrectValues.Add(new int[1] { 14 }); - listOfCorrectValues.Add(new int[1] { 32 }); - listOfCorrectValues.Add(new int[1] { 50 }); + var listOfCorrectValues = new List + { + new int[1] { 14 }, + new int[1] { 32 }, + new int[1] { 50 }, + }; var firstMatrix = Matrix.Create(3, 3, listOfValuesFirstMatrix); var secondMatrix = Matrix.Create(3, 1, listOfValuesSecondMatrix); var correctMatrix = Matrix.Create(3, 1, listOfCorrectValues); var arrayForStandardDeviation = new double[n]; - double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, + double mathExpectation = GetMathExpectation(firstMatrix, secondMatrix, correctMatrix, arrayForStandardDeviation, n, sizeThreads); - var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, minValue); + var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); var streamForWrite = new StreamWriter(filePath, true); streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 3x3 и 3x1:"); streamForWrite.Write("Матемматическое ожидание: "); - streamForWrite.Write(minValue); + streamForWrite.Write(mathExpectation); streamForWrite.Write(" Среднеквадратичное отклонение: "); streamForWrite.WriteLine(standardDeviation); streamForWrite.Close(); } - private static void MultiplyingOfNotSquareMatrices(string filePath) + private static void MultiplyOfNotSquareMatrices(string filePath) { var sizeThreads = Environment.ProcessorCount; - var listOfValuesFirstMatrix = new List { }; - var listOfValuesSecondMatrix = new List { }; - var listOfCorrectValues = new List { }; - - listOfValuesFirstMatrix.Add(new int[5] { 1, 2, 3, 4, 5 }); - listOfValuesFirstMatrix.Add(new int[5] { 6, 7, 8, 9, 10 }); - listOfValuesSecondMatrix.Add(new int[1] { 1 }); - listOfValuesSecondMatrix.Add(new int[1] { 2 }); - listOfValuesSecondMatrix.Add(new int[1] { 3 }); - listOfValuesSecondMatrix.Add(new int[1] { 4 }); - listOfValuesSecondMatrix.Add(new int[1] { 5 }); + var listOfValuesFirstMatrix = new List + { + new int[5] { 1, 2, 3, 4, 5 }, + new int[5] { 6, 7, 8, 9, 10 }, + }; - listOfCorrectValues.Add(new int[1] { 55 }); - listOfCorrectValues.Add(new int[1] { 130 }); + var listOfValuesSecondMatrix = new List + { + new int[1] { 1 }, + new int[1] { 2 }, + new int[1] { 3 }, + new int[1] { 4 }, + new int[1] { 5 }, + }; + + var listOfCorrectValues = new List + { + new int[1] { 55 }, + new int[1] { 130 }, + }; var firstMatrix = Matrix.Create(2, 5, listOfValuesFirstMatrix); var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); var arrayForStandardDeviation = new double[n]; - double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, + double mathExpectation = GetMathExpectation(firstMatrix, secondMatrix, correctMatrix, arrayForStandardDeviation, n, sizeThreads); - var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, minValue); + var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); var streamForWrite = new StreamWriter(filePath, true); streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 2x5 и 5x1:"); streamForWrite.Write("Матемматическое ожидание: "); - streamForWrite.Write(minValue); + streamForWrite.Write(mathExpectation); streamForWrite.Write(" Среднеквадратичное отклонение: "); streamForWrite.WriteLine(standardDeviation); streamForWrite.Close(); } - private static void MultiplyingMatricesWithNegativeNumbers(string filePath) + private static void MultiplyMatricesWithNegativeNumbers(string filePath) { var sizeThreads = Environment.ProcessorCount; - var listOfValuesFirstMatrix = new List { }; - var listOfValuesSecondMatrix = new List { }; - var listOfCorrectValues = new List { }; - listOfValuesFirstMatrix.Add(new int[5] { 1, 2, -3, 4, 5 }); - listOfValuesFirstMatrix.Add(new int[5] { 6, -7, 8, 9, 10 }); - - listOfValuesSecondMatrix.Add(new int[1] { 1 }); - listOfValuesSecondMatrix.Add(new int[1] { 2 }); - listOfValuesSecondMatrix.Add(new int[1] { 3 }); - listOfValuesSecondMatrix.Add(new int[1] { -4 }); - listOfValuesSecondMatrix.Add(new int[1] { 5 }); + var listOfValuesFirstMatrix = new List + { + new int[5] { 1, 2, -3, 4, 5 }, + new int[5] { 6, -7, 8, 9, 10 }, + }; - listOfCorrectValues.Add(new int[1] { 5 }); - listOfCorrectValues.Add(new int[1] { 30 }); + var listOfValuesSecondMatrix = new List + { + new int[1] { 1 }, + new int[1] { 2 }, + new int[1] { 3 }, + new int[1] { -4 }, + new int[1] { 5 }, + }; + + var listOfCorrectValues = new List + { + new int[1] { 5 }, + new int[1] { 30 }, + }; var firstMatrix = Matrix.Create(2, 5, listOfValuesFirstMatrix); var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); var arrayForStandardDeviation = new double[n]; - double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, + double mathExpectation = GetMathExpectation(firstMatrix, secondMatrix, correctMatrix, arrayForStandardDeviation, n, sizeThreads); - var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, minValue); + var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); var streamForWrite = new StreamWriter(filePath, true); streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 2x5 и 5x1 с отрицательными числами:"); streamForWrite.Write("Матемматическое ожидание: "); - streamForWrite.Write(minValue); + streamForWrite.Write(mathExpectation); streamForWrite.Write(" Среднеквадратичное отклонение: "); streamForWrite.WriteLine(standardDeviation); streamForWrite.Close(); } - private static void MultiplyingMatricesWithZero(string filePath) + private static void MultiplyMatricesWithZero(string filePath) { var sizeThreads = Environment.ProcessorCount; - var listOfValuesFirstMatrix = new List { }; - var listOfValuesSecondMatrix = new List { }; - var listOfCorrectValues = new List { }; - - listOfValuesFirstMatrix.Add(new int[5] { 1, 2, 0, 4, 5 }); - listOfValuesFirstMatrix.Add(new int[5] { 6, 0, 8, 9, 10 }); - - listOfValuesSecondMatrix.Add(new int[1] { 1 }); - listOfValuesSecondMatrix.Add(new int[1] { 2 }); - listOfValuesSecondMatrix.Add(new int[1] { 0 }); - listOfValuesSecondMatrix.Add(new int[1] { 0 }); - listOfValuesSecondMatrix.Add(new int[1] { 5 }); + var listOfValuesFirstMatrix = new List + { + new int[5] { 1, 2, 0, 4, 5 }, + new int[5] { 6, 0, 8, 9, 10 }, + }; - listOfCorrectValues.Add(new int[1] { 30 }); - listOfCorrectValues.Add(new int[1] { 56 }); + var listOfValuesSecondMatrix = new List + { + new int[1] { 1 }, + new int[1] { 2 }, + new int[1] { 0 }, + new int[1] { 0 }, + new int[1] { 5 }, + }; + + var listOfCorrectValues = new List + { + new int[1] { 30 }, + new int[1] { 56 }, + }; var firstMatrix = Matrix.Create(2, 5, listOfValuesFirstMatrix); var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); var arrayForStandardDeviation = new double[n]; - double minValue = GetMinValue(firstMatrix, secondMatrix, correctMatrix, + double mathExpectation = GetMathExpectation(firstMatrix, secondMatrix, correctMatrix, arrayForStandardDeviation, n, sizeThreads); - var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, minValue); + var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); var streamForWrite = new StreamWriter(filePath, true); streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 2x5 и 5x1 с нулями:"); streamForWrite.Write("Матемматическое ожидание: "); - streamForWrite.Write(minValue); + streamForWrite.Write(mathExpectation); streamForWrite.Write(" Среднеквадратичное отклонение: "); streamForWrite.WriteLine(standardDeviation); streamForWrite.Close(); @@ -258,11 +283,11 @@ public static void CreateTableWithResults(string filePath) var streamForWrite = new StreamWriter(filePath); streamForWrite.Write("В файле представлены: математическое ожидание и среднеквадратичное отклонение\n"); streamForWrite.Close(); - MultiplyingMatricesOfSizeThreeByThree(filePath); - MultiplyingMatricesOfBigSize(filePath); - MultiplyingMatricesOfDifferentSizes(filePath); - MultiplyingOfNotSquareMatrices(filePath); - MultiplyingMatricesWithNegativeNumbers(filePath); - MultiplyingMatricesWithZero(filePath); + MultiplyMatricesOfSizeThreeByThree(filePath); + MultiplyMatricesOfBigSize(filePath); + MultiplyMatricesOfDifferentSizes(filePath); + MultiplyOfNotSquareMatrices(filePath); + MultiplyMatricesWithNegativeNumbers(filePath); + MultiplyMatricesWithZero(filePath); } } From 0c93f361e46bb78756344befc83ae37627bdb54f Mon Sep 17 00:00:00 2001 From: Artem Date: Tue, 3 Oct 2023 00:13:51 +0300 Subject: [PATCH 4/7] =?UTF-8?q?=D0=A0=D0=B5=D0=B2=D1=8C=D1=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../parallelMatrixMultiplication/Program.cs | 7 +- .../StandartDeviationAndMathExpectation.cs | 82 ++++++++++++++----- parallelMatrixMultiplication/tableFile.txt | 34 +++++--- 3 files changed, 90 insertions(+), 33 deletions(-) diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs index c2a1af0..4cbaf44 100644 --- a/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs @@ -1,5 +1,6 @@ using parallelMatrixMultiplication; +/* Console.WriteLine("Write first file name"); var firstFile = Console.ReadLine(); Console.WriteLine("Write second file name"); @@ -31,8 +32,11 @@ } Matrix.Multiplication(firstFile, secondFile, resultFile); +*/ +var tableFile = "C:\\Users\\User\\source\\repos\\HomeworksCSharp\\parallelMatrixMultiplication\\tableFile.txt"; StandartDeviationAndMathExpectation.CreateTableWithResults(tableFile); +/* var resultCompare = Matrix.CompareMultiplication(firstFile, secondFile); if (resultCompare < 0) { @@ -45,4 +49,5 @@ Console.Write("Последовательное перемножение матриц медленнее, чем параллельное на "); Console.Write(resultCompare); Console.WriteLine(" миллисекунд"); -} \ No newline at end of file +} +*/ \ No newline at end of file diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs index 2d64569..d23ed07 100644 --- a/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs @@ -17,7 +17,7 @@ private static double GetStandartDeviation(int n, double[] arrayForStandardDevia summaryForStandartDeviation += Math.Pow(arrayForStandardDeviation[i] - mathExpectation, 2); } - return Math.Sqrt(summaryForStandartDeviation / (n - 1)); + return Math.Round(Math.Sqrt(summaryForStandartDeviation / (n - 1)), 7); } private static double GetMathExpectation(int[][] firstMatrix, int[][] secondMatrix, int[][] correctMatrix, @@ -30,7 +30,7 @@ private static double GetMathExpectation(int[][] firstMatrix, int[][] secondMatr stopWatch.Start(); var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); stopWatch.Stop(); - arrayForStandardDeviation[i] = (double)stopWatch.ElapsedMilliseconds / 1000; + arrayForStandardDeviation[i] = stopWatch.ElapsedMilliseconds; summary += arrayForStandardDeviation[i]; } return summary / n; @@ -62,11 +62,11 @@ private static void MultiplyMatricesOfSizeThreeByThree(string filePath) arrayForStandardDeviation, n, sizeThreads); var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); var streamForWrite = new StreamWriter(filePath, true); - streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 3x3:"); - streamForWrite.Write("Матемматическое ожидание: "); + streamForWrite.Write("3x3 и 3x3\t\t"); streamForWrite.Write(mathExpectation); - streamForWrite.Write(" Среднеквадратичное отклонение: "); + streamForWrite.Write("\t\t"); streamForWrite.WriteLine(standardDeviation); + streamForWrite.Write('\n'); streamForWrite.Close(); } @@ -100,11 +100,11 @@ private static void MultiplyMatricesOfBigSize(string filePath) arrayForStandardDeviation, n, sizeThreads); var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); var streamForWrite = new StreamWriter(filePath, true); - streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 10000x10000 и 10000x1:"); - streamForWrite.Write("Матемматическое ожидание: "); + streamForWrite.Write("10000x10000\nи 10000x1\t\t"); streamForWrite.Write(mathExpectation); - streamForWrite.Write(" Среднеквадратичное отклонение: "); + streamForWrite.Write("\t\t"); streamForWrite.WriteLine(standardDeviation); + streamForWrite.Write('\n'); streamForWrite.Close(); } @@ -141,11 +141,11 @@ private static void MultiplyMatricesOfDifferentSizes(string filePath) arrayForStandardDeviation, n, sizeThreads); var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); var streamForWrite = new StreamWriter(filePath, true); - streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 3x3 и 3x1:"); - streamForWrite.Write("Матемматическое ожидание: "); + streamForWrite.Write("3x3 и 3x1\t\t"); streamForWrite.Write(mathExpectation); - streamForWrite.Write(" Среднеквадратичное отклонение: "); + streamForWrite.Write("\t\t"); streamForWrite.WriteLine(standardDeviation); + streamForWrite.Write('\n'); streamForWrite.Close(); } @@ -183,11 +183,11 @@ private static void MultiplyOfNotSquareMatrices(string filePath) arrayForStandardDeviation, n, sizeThreads); var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); var streamForWrite = new StreamWriter(filePath, true); - streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 2x5 и 5x1:"); - streamForWrite.Write("Матемматическое ожидание: "); + streamForWrite.Write("2x5 и 5x1\t\t"); streamForWrite.Write(mathExpectation); - streamForWrite.Write(" Среднеквадратичное отклонение: "); + streamForWrite.Write("\t\t"); streamForWrite.WriteLine(standardDeviation); + streamForWrite.Write('\n'); streamForWrite.Close(); } @@ -225,11 +225,11 @@ private static void MultiplyMatricesWithNegativeNumbers(string filePath) arrayForStandardDeviation, n, sizeThreads); var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); var streamForWrite = new StreamWriter(filePath, true); - streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 2x5 и 5x1 с отрицательными числами:"); - streamForWrite.Write("Матемматическое ожидание: "); + streamForWrite.Write("2x5 и 5x1 с \nотрицательными\n числами\t\t"); streamForWrite.Write(mathExpectation); - streamForWrite.Write(" Среднеквадратичное отклонение: "); + streamForWrite.Write("\t\t"); streamForWrite.WriteLine(standardDeviation); + streamForWrite.Write('\n'); streamForWrite.Close(); } @@ -266,11 +266,49 @@ private static void MultiplyMatricesWithZero(string filePath) arrayForStandardDeviation, n, sizeThreads); var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); var streamForWrite = new StreamWriter(filePath, true); - streamForWrite.WriteLine("Математическое ожидание и среднеквадратичное отклонение для матриц размера 2x5 и 5x1 с нулями:"); - streamForWrite.Write("Матемматическое ожидание: "); + streamForWrite.Write("2x5 и 5x1 с\n нулями\t\t\t"); streamForWrite.Write(mathExpectation); - streamForWrite.Write(" Среднеквадратичное отклонение: "); + streamForWrite.Write("\t\t"); streamForWrite.WriteLine(standardDeviation); + streamForWrite.Write('\n'); + streamForWrite.Close(); + } + + private static void MultiplyMatricesOfFiveHundredOnFiveHundredSize(string filePath) + { + var sizeThreads = Environment.ProcessorCount; + + var listOfValuesFirstMatrix = new List { }; + var listOfValuesSecondMatrix = new List { }; + var listOfCorrectValues = new List { }; + + for (int i = 0; i < 500; i++) + { + listOfValuesFirstMatrix.Add(new int[500]); + listOfValuesSecondMatrix.Add(new int[500]); + listOfCorrectValues.Add(new int[500]); + for (int j = 0; j < 500; ++j) + { + listOfValuesFirstMatrix[i][j] = 1; + listOfValuesSecondMatrix[i][j] = 1; + listOfCorrectValues[i][j] = 500; + } + } + + var firstMatrix = Matrix.Create(500, 500, listOfValuesFirstMatrix); + var secondMatrix = Matrix.Create(500, 500, listOfValuesSecondMatrix); + var correctMatrix = Matrix.Create(500, 500, listOfCorrectValues); + + var arrayForStandardDeviation = new double[n]; + double mathExpectation = GetMathExpectation(firstMatrix, secondMatrix, correctMatrix, + arrayForStandardDeviation, n, sizeThreads); + var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); + var streamForWrite = new StreamWriter(filePath, true); + streamForWrite.Write("500x500\nи 500x500\t\t"); + streamForWrite.Write(mathExpectation); + streamForWrite.Write("\t\t"); + streamForWrite.WriteLine(standardDeviation); + streamForWrite.Write('\n'); streamForWrite.Close(); } @@ -282,6 +320,9 @@ public static void CreateTableWithResults(string filePath) { var streamForWrite = new StreamWriter(filePath); streamForWrite.Write("В файле представлены: математическое ожидание и среднеквадратичное отклонение\n"); + streamForWrite.WriteLine("--------------------------------------------------------------------------"); + streamForWrite.Write("Размеры матриц\tМатематическое ожидание\tСреднеквадратичное отклонение\n"); + streamForWrite.WriteLine("---------------------------------------------------------------------"); streamForWrite.Close(); MultiplyMatricesOfSizeThreeByThree(filePath); MultiplyMatricesOfBigSize(filePath); @@ -289,5 +330,6 @@ public static void CreateTableWithResults(string filePath) MultiplyOfNotSquareMatrices(filePath); MultiplyMatricesWithNegativeNumbers(filePath); MultiplyMatricesWithZero(filePath); + MultiplyMatricesOfFiveHundredOnFiveHundredSize(filePath); } } diff --git a/parallelMatrixMultiplication/tableFile.txt b/parallelMatrixMultiplication/tableFile.txt index c7f961c..8aae942 100644 --- a/parallelMatrixMultiplication/tableFile.txt +++ b/parallelMatrixMultiplication/tableFile.txt @@ -1,13 +1,23 @@ В файле представлены: математическое ожидание и среднеквадратичное отклонение -Математическое ожидание и среднеквадратичное отклонение для матриц размера 3x3: -Матемматическое ожидание: 0,0019000000000000002 Среднеквадратичное отклонение: 0,002514402955419481 -Математическое ожидание и среднеквадратичное отклонение для матриц размера 10000x10000 и 10000x1: -Матемматическое ожидание: 0,19010000000000002 Среднеквадратичное отклонение: 0,094399211390303 -Математическое ожидание и среднеквадратичное отклонение для матриц размера 3x3 и 3x1: -Матемматическое ожидание: 0,0011000000000000003 Среднеквадратичное отклонение: 0,0003162277660168379 -Математическое ожидание и среднеквадратичное отклонение для матриц размера 2x5 и 5x1: -Матемматическое ожидание: 0,0004 Среднеквадратичное отклонение: 0,0005163977794943222 -Математическое ожидание и среднеквадратичное отклонение для матриц размера 2x5 и 5x1 с отрицательными числами: -Матемматическое ожидание: 0,0011000000000000003 Среднеквадратичное отклонение: 0,0003162277660168379 -Математическое ожидание и среднеквадратичное отклонение для матриц размера 2x5 и 5x1 с нулями: -Матемматическое ожидание: 0,0010000000000000002 Среднеквадратичное отклонение: 2,28569887277129E-19 +-------------------------------------------------------------------------- +Размеры матриц Математическое ожидание Среднеквадратичное отклонение +--------------------------------------------------------------------- +3x3 и 3x3 0,3 0,4830459 + +10000x10000 +и 10000x1 93,4 10,6479002 + +3x3 и 3x1 0,9 0,5676462 + +2x5 и 5x1 0,1 0,3162278 + +2x5 и 5x1 с +отрицательными + числами 0,1 0,3162278 + +2x5 и 5x1 с + нулями 0,1 0,3162278 + +500x500 +и 500x500 106,3 4,6916001 + From 9685a1deeef3cd2c8e7ce4732c10c3d284c0931e Mon Sep 17 00:00:00 2001 From: Artem Date: Wed, 11 Oct 2023 20:10:12 +0300 Subject: [PATCH 5/7] =?UTF-8?q?=D0=A0=D0=B5=D0=B2=D1=8C=D1=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../parallelMatrixMultiplication/Matrix.cs | 1 - .../parallelMatrixMultiplication/Program.cs | 8 +- .../StandartDeviationAndMathExpectation.cs | 308 +++++------------- parallelMatrixMultiplication/tableFile.txt | 24 +- 4 files changed, 89 insertions(+), 252 deletions(-) diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs index 744a2f8..3b66186 100644 --- a/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs @@ -174,7 +174,6 @@ public static int[][] Multiply(int[][] firstMatrix, int[][] secondMatrix) { thread.Join(); } - return resultMatrix; } diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs index 4cbaf44..c0f9173 100644 --- a/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/Program.cs @@ -1,6 +1,5 @@ using parallelMatrixMultiplication; -/* Console.WriteLine("Write first file name"); var firstFile = Console.ReadLine(); Console.WriteLine("Write second file name"); @@ -32,11 +31,9 @@ } Matrix.Multiplication(firstFile, secondFile, resultFile); -*/ -var tableFile = "C:\\Users\\User\\source\\repos\\HomeworksCSharp\\parallelMatrixMultiplication\\tableFile.txt"; + StandartDeviationAndMathExpectation.CreateTableWithResults(tableFile); -/* var resultCompare = Matrix.CompareMultiplication(firstFile, secondFile); if (resultCompare < 0) { @@ -49,5 +46,4 @@ Console.Write("Последовательное перемножение матриц медленнее, чем параллельное на "); Console.Write(resultCompare); Console.WriteLine(" миллисекунд"); -} -*/ \ No newline at end of file +} \ No newline at end of file diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs index d23ed07..09288df 100644 --- a/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs @@ -20,15 +20,22 @@ private static double GetStandartDeviation(int n, double[] arrayForStandardDevia return Math.Round(Math.Sqrt(summaryForStandartDeviation / (n - 1)), 7); } - private static double GetMathExpectation(int[][] firstMatrix, int[][] secondMatrix, int[][] correctMatrix, - double[] arrayForStandardDeviation, int n, int sizeThreads) + private static double GetMathExpectation(int[][] firstMatrix, int[][] secondMatrix, + double[] arrayForStandardDeviation, int n, bool isConsistentMultiply) { double summary = 0; for (int i = 0; i < n; i++) { var stopWatch = new Stopwatch(); stopWatch.Start(); - var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); + if (isConsistentMultiply) + { + var resultMatrix = Matrix.ConsistentMultiply(firstMatrix, secondMatrix); + } + else + { + var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); + } stopWatch.Stop(); arrayForStandardDeviation[i] = stopWatch.ElapsedMilliseconds; summary += arrayForStandardDeviation[i]; @@ -36,278 +43,122 @@ private static double GetMathExpectation(int[][] firstMatrix, int[][] secondMatr return summary / n; } - private static void MultiplyMatricesOfSizeThreeByThree(string filePath) + private static void MultiplyMatricesOfSizeTwoHundredAndFiftyByTwoHundredAndFifty(string filePath) { - var sizeThreads = Environment.ProcessorCount; - var listOfValues = new List - { - new int[3] { 1, 2, 3 }, - new int[3] { 4, 5, 6 }, - new int[3] { 7, 8, 9 }, - }; + var listOfValuesFirstMatrix = new List { }; + var listOfValuesSecondMatrix = new List { }; - var listOfCorrectValues = new List + for (int i = 0; i < 250; i++) { - new int[3] { 30, 36, 42 }, - new int[3] { 66, 81, 96 }, - new int[3] { 102, 126, 150 }, - }; - - var firstMatrix = Matrix.Create(3, 3, listOfValues); - var secondMatrix = Matrix.Create(3, 3, listOfValues); - var correctMatrix = Matrix.Create(3, 3, listOfCorrectValues); + listOfValuesFirstMatrix.Add(new int[250]); + listOfValuesSecondMatrix.Add(new int[250]); + for (int j = 0; j < 250; ++j) + { + listOfValuesFirstMatrix[i][j] = 1; + listOfValuesSecondMatrix[i][j] = 1; + } + } - var arrayForStandardDeviation = new double[n]; - double mathExpectation = GetMathExpectation(firstMatrix, secondMatrix, correctMatrix, - arrayForStandardDeviation, n, sizeThreads); - var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); + var firstMatrix = Matrix.Create(250, 250, listOfValuesFirstMatrix); + var secondMatrix = Matrix.Create(250, 250, listOfValuesSecondMatrix); + + var arrayForStandardDeviationMultiThreaded = new double[n]; + var arrayForStandardDeviationSingleThreaded = new double[n]; + double mathExpectationMultiThreaded = GetMathExpectation(firstMatrix, secondMatrix, + arrayForStandardDeviationMultiThreaded, n, false); + double mathExpectationSingleThreaded = GetMathExpectation(firstMatrix, secondMatrix, + arrayForStandardDeviationSingleThreaded, n, true); + var standardDeviationMultiThreaded = GetStandartDeviation(n, arrayForStandardDeviationMultiThreaded, mathExpectationMultiThreaded); + var standardDeviationSingleThreaded = GetStandartDeviation(n, arrayForStandardDeviationSingleThreaded, mathExpectationSingleThreaded); var streamForWrite = new StreamWriter(filePath, true); - streamForWrite.Write("3x3 и 3x3\t\t"); - streamForWrite.Write(mathExpectation); - streamForWrite.Write("\t\t"); - streamForWrite.WriteLine(standardDeviation); + streamForWrite.Write("250x250\nи 250x250\t\t"); + streamForWrite.Write(mathExpectationMultiThreaded); + streamForWrite.Write("\t\t\t\t\t\t\t\t\t\t"); + streamForWrite.Write(standardDeviationMultiThreaded); + streamForWrite.Write("\t\t\t\t\t\t"); + streamForWrite.Write(mathExpectationSingleThreaded); + streamForWrite.Write("\t\t\t\t\t\t\t"); + streamForWrite.WriteLine(standardDeviationSingleThreaded); streamForWrite.Write('\n'); streamForWrite.Close(); } private static void MultiplyMatricesOfBigSize(string filePath) { - var sizeThreads = Environment.ProcessorCount; - var listOfValuesFirstMatrix = new List { }; var listOfValuesSecondMatrix = new List { }; - var listOfCorrectValues = new List { }; for (int i = 0; i < 10000; i++) { listOfValuesFirstMatrix.Add(new int[10000]); listOfValuesSecondMatrix.Add(new int[1]); - listOfCorrectValues.Add(new int[1]); for (int j = 0; j < 10000; ++j) { listOfValuesFirstMatrix[i][j] = 1; } listOfValuesSecondMatrix[i][0] = 1; - listOfCorrectValues[i][0] = 10000; } var firstMatrix = Matrix.Create(10000, 10000, listOfValuesFirstMatrix); var secondMatrix = Matrix.Create(10000, 1, listOfValuesSecondMatrix); - var correctMatrix = Matrix.Create(10000, 1, listOfCorrectValues); - var arrayForStandardDeviation = new double[n]; - double mathExpectation = GetMathExpectation(firstMatrix, secondMatrix, correctMatrix, - arrayForStandardDeviation, n, sizeThreads); - var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); + var arrayForStandardDeviationMultiThreaded = new double[n]; + var arrayForStandardDeviationSingleThreaded = new double[n]; + double mathExpectationMultiThreaded = GetMathExpectation(firstMatrix, secondMatrix, + arrayForStandardDeviationMultiThreaded, n, false); + double mathExpectationSingleThreaded = GetMathExpectation(firstMatrix, secondMatrix, + arrayForStandardDeviationSingleThreaded, n, true); + var standardDeviationMultiThreaded = GetStandartDeviation(n, arrayForStandardDeviationMultiThreaded, mathExpectationMultiThreaded); + var standardDeviationSingleThreaded = GetStandartDeviation(n, arrayForStandardDeviationSingleThreaded, mathExpectationSingleThreaded); var streamForWrite = new StreamWriter(filePath, true); streamForWrite.Write("10000x10000\nи 10000x1\t\t"); - streamForWrite.Write(mathExpectation); - streamForWrite.Write("\t\t"); - streamForWrite.WriteLine(standardDeviation); - streamForWrite.Write('\n'); - streamForWrite.Close(); - } - - private static void MultiplyMatricesOfDifferentSizes(string filePath) - { - var sizeThreads = Environment.ProcessorCount; - var listOfValuesFirstMatrix = new List - { - new int[3] { 1, 2, 3 }, - new int[3] { 4, 5, 6 }, - new int[3] { 7, 8, 9 }, - }; - - var listOfValuesSecondMatrix = new List - { - new int[1] { 1 }, - new int[1] { 2 }, - new int[1] { 3 }, - }; - - var listOfCorrectValues = new List - { - new int[1] { 14 }, - new int[1] { 32 }, - new int[1] { 50 }, - }; - - var firstMatrix = Matrix.Create(3, 3, listOfValuesFirstMatrix); - var secondMatrix = Matrix.Create(3, 1, listOfValuesSecondMatrix); - var correctMatrix = Matrix.Create(3, 1, listOfCorrectValues); - - var arrayForStandardDeviation = new double[n]; - double mathExpectation = GetMathExpectation(firstMatrix, secondMatrix, correctMatrix, - arrayForStandardDeviation, n, sizeThreads); - var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); - var streamForWrite = new StreamWriter(filePath, true); - streamForWrite.Write("3x3 и 3x1\t\t"); - streamForWrite.Write(mathExpectation); - streamForWrite.Write("\t\t"); - streamForWrite.WriteLine(standardDeviation); - streamForWrite.Write('\n'); - streamForWrite.Close(); - } - - private static void MultiplyOfNotSquareMatrices(string filePath) - { - var sizeThreads = Environment.ProcessorCount; - - var listOfValuesFirstMatrix = new List - { - new int[5] { 1, 2, 3, 4, 5 }, - new int[5] { 6, 7, 8, 9, 10 }, - }; - - var listOfValuesSecondMatrix = new List - { - new int[1] { 1 }, - new int[1] { 2 }, - new int[1] { 3 }, - new int[1] { 4 }, - new int[1] { 5 }, - }; - - var listOfCorrectValues = new List - { - new int[1] { 55 }, - new int[1] { 130 }, - }; - - var firstMatrix = Matrix.Create(2, 5, listOfValuesFirstMatrix); - var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); - var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); - - var arrayForStandardDeviation = new double[n]; - double mathExpectation = GetMathExpectation(firstMatrix, secondMatrix, correctMatrix, - arrayForStandardDeviation, n, sizeThreads); - var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); - var streamForWrite = new StreamWriter(filePath, true); - streamForWrite.Write("2x5 и 5x1\t\t"); - streamForWrite.Write(mathExpectation); - streamForWrite.Write("\t\t"); - streamForWrite.WriteLine(standardDeviation); - streamForWrite.Write('\n'); - streamForWrite.Close(); - } - - private static void MultiplyMatricesWithNegativeNumbers(string filePath) - { - var sizeThreads = Environment.ProcessorCount; - - var listOfValuesFirstMatrix = new List - { - new int[5] { 1, 2, -3, 4, 5 }, - new int[5] { 6, -7, 8, 9, 10 }, - }; - - var listOfValuesSecondMatrix = new List - { - new int[1] { 1 }, - new int[1] { 2 }, - new int[1] { 3 }, - new int[1] { -4 }, - new int[1] { 5 }, - }; - - var listOfCorrectValues = new List - { - new int[1] { 5 }, - new int[1] { 30 }, - }; - - var firstMatrix = Matrix.Create(2, 5, listOfValuesFirstMatrix); - var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); - var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); - - var arrayForStandardDeviation = new double[n]; - double mathExpectation = GetMathExpectation(firstMatrix, secondMatrix, correctMatrix, - arrayForStandardDeviation, n, sizeThreads); - var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); - var streamForWrite = new StreamWriter(filePath, true); - streamForWrite.Write("2x5 и 5x1 с \nотрицательными\n числами\t\t"); - streamForWrite.Write(mathExpectation); - streamForWrite.Write("\t\t"); - streamForWrite.WriteLine(standardDeviation); - streamForWrite.Write('\n'); - streamForWrite.Close(); - } - - private static void MultiplyMatricesWithZero(string filePath) - { - var sizeThreads = Environment.ProcessorCount; - var listOfValuesFirstMatrix = new List - { - new int[5] { 1, 2, 0, 4, 5 }, - new int[5] { 6, 0, 8, 9, 10 }, - }; - - var listOfValuesSecondMatrix = new List - { - new int[1] { 1 }, - new int[1] { 2 }, - new int[1] { 0 }, - new int[1] { 0 }, - new int[1] { 5 }, - }; - - var listOfCorrectValues = new List - { - new int[1] { 30 }, - new int[1] { 56 }, - }; - - var firstMatrix = Matrix.Create(2, 5, listOfValuesFirstMatrix); - var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); - var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); - - var arrayForStandardDeviation = new double[n]; - double mathExpectation = GetMathExpectation(firstMatrix, secondMatrix, correctMatrix, - arrayForStandardDeviation, n, sizeThreads); - var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); - var streamForWrite = new StreamWriter(filePath, true); - streamForWrite.Write("2x5 и 5x1 с\n нулями\t\t\t"); - streamForWrite.Write(mathExpectation); - streamForWrite.Write("\t\t"); - streamForWrite.WriteLine(standardDeviation); + streamForWrite.Write(mathExpectationMultiThreaded); + streamForWrite.Write("\t\t\t\t\t\t\t\t\t\t"); + streamForWrite.Write(standardDeviationMultiThreaded); + streamForWrite.Write("\t\t\t\t\t\t"); + streamForWrite.Write(mathExpectationSingleThreaded); + streamForWrite.Write("\t\t\t\t\t\t\t"); + streamForWrite.WriteLine(standardDeviationSingleThreaded); streamForWrite.Write('\n'); streamForWrite.Close(); } private static void MultiplyMatricesOfFiveHundredOnFiveHundredSize(string filePath) { - var sizeThreads = Environment.ProcessorCount; - var listOfValuesFirstMatrix = new List { }; var listOfValuesSecondMatrix = new List { }; - var listOfCorrectValues = new List { }; for (int i = 0; i < 500; i++) { listOfValuesFirstMatrix.Add(new int[500]); listOfValuesSecondMatrix.Add(new int[500]); - listOfCorrectValues.Add(new int[500]); for (int j = 0; j < 500; ++j) { listOfValuesFirstMatrix[i][j] = 1; listOfValuesSecondMatrix[i][j] = 1; - listOfCorrectValues[i][j] = 500; } } var firstMatrix = Matrix.Create(500, 500, listOfValuesFirstMatrix); var secondMatrix = Matrix.Create(500, 500, listOfValuesSecondMatrix); - var correctMatrix = Matrix.Create(500, 500, listOfCorrectValues); - var arrayForStandardDeviation = new double[n]; - double mathExpectation = GetMathExpectation(firstMatrix, secondMatrix, correctMatrix, - arrayForStandardDeviation, n, sizeThreads); - var standardDeviation = GetStandartDeviation(n, arrayForStandardDeviation, mathExpectation); + var arrayForStandardDeviationMultiThreaded = new double[n]; + var arrayForStandardDeviationSingleThreaded = new double[n]; + double mathExpectationMultiThreaded = GetMathExpectation(firstMatrix, secondMatrix, + arrayForStandardDeviationMultiThreaded, n, false); + double mathExpectationSingleThreaded = GetMathExpectation(firstMatrix, secondMatrix, + arrayForStandardDeviationSingleThreaded, n, true); + var standardDeviationMultiThreaded = GetStandartDeviation(n, arrayForStandardDeviationMultiThreaded, mathExpectationMultiThreaded); + var standardDeviationSingleThreaded = GetStandartDeviation(n, arrayForStandardDeviationSingleThreaded, mathExpectationSingleThreaded); var streamForWrite = new StreamWriter(filePath, true); streamForWrite.Write("500x500\nи 500x500\t\t"); - streamForWrite.Write(mathExpectation); - streamForWrite.Write("\t\t"); - streamForWrite.WriteLine(standardDeviation); + streamForWrite.Write(mathExpectationMultiThreaded); + streamForWrite.Write("\t\t\t\t\t\t\t\t\t\t"); + streamForWrite.Write(standardDeviationMultiThreaded); + streamForWrite.Write("\t\t\t\t\t\t"); + streamForWrite.Write(mathExpectationSingleThreaded); + streamForWrite.Write("\t\t\t\t\t\t\t"); + streamForWrite.WriteLine(standardDeviationSingleThreaded); streamForWrite.Write('\n'); streamForWrite.Close(); } @@ -320,16 +171,17 @@ public static void CreateTableWithResults(string filePath) { var streamForWrite = new StreamWriter(filePath); streamForWrite.Write("В файле представлены: математическое ожидание и среднеквадратичное отклонение\n"); - streamForWrite.WriteLine("--------------------------------------------------------------------------"); - streamForWrite.Write("Размеры матриц\tМатематическое ожидание\tСреднеквадратичное отклонение\n"); - streamForWrite.WriteLine("---------------------------------------------------------------------"); + streamForWrite.WriteLine("-----------------------------------------------------------------------------"); + streamForWrite.Write("Размеры матриц\tМатематическое ожидание с использованием многопоточности\t" + + "Среднеквадратичное отклонение с использованием многопотчности" + + "\tМатематическое ожидание без использования\tСреднеквадратическое " + + "отклонение без использования\n"); + streamForWrite.WriteLine("--------------------------------------------------------------------------------" + + "--------------------------------------------------------------------------------" + + "---------------------------------------------------------------------------------"); streamForWrite.Close(); - MultiplyMatricesOfSizeThreeByThree(filePath); + MultiplyMatricesOfSizeTwoHundredAndFiftyByTwoHundredAndFifty(filePath); MultiplyMatricesOfBigSize(filePath); - MultiplyMatricesOfDifferentSizes(filePath); - MultiplyOfNotSquareMatrices(filePath); - MultiplyMatricesWithNegativeNumbers(filePath); - MultiplyMatricesWithZero(filePath); MultiplyMatricesOfFiveHundredOnFiveHundredSize(filePath); } } diff --git a/parallelMatrixMultiplication/tableFile.txt b/parallelMatrixMultiplication/tableFile.txt index 8aae942..6a03b20 100644 --- a/parallelMatrixMultiplication/tableFile.txt +++ b/parallelMatrixMultiplication/tableFile.txt @@ -1,23 +1,13 @@ В файле представлены: математическое ожидание и среднеквадратичное отклонение --------------------------------------------------------------------------- -Размеры матриц Математическое ожидание Среднеквадратичное отклонение ---------------------------------------------------------------------- -3x3 и 3x3 0,3 0,4830459 +----------------------------------------------------------------------------- +Размеры матриц Математическое ожидание с использованием многопоточности Среднеквадратичное отклонение с использованием многопотчности Математическое ожидание без использования Среднеквадратическое отклонение без использования +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +250x250 +и 250x250 30,1 5,4456915 110,8 13,6284017 10000x10000 -и 10000x1 93,4 10,6479002 - -3x3 и 3x1 0,9 0,5676462 - -2x5 и 5x1 0,1 0,3162278 - -2x5 и 5x1 с -отрицательными - числами 0,1 0,3162278 - -2x5 и 5x1 с - нулями 0,1 0,3162278 +и 10000x1 129,3 33,3168292 556,7 72,4891563 500x500 -и 500x500 106,3 4,6916001 +и 500x500 129,5 29,9007618 614,8 7,4654761 From bd2282fc6cff94ab2dcd7faa74d6624e85ae663a Mon Sep 17 00:00:00 2001 From: Artem Date: Sat, 14 Oct 2023 15:14:03 +0300 Subject: [PATCH 6/7] =?UTF-8?q?=D0=A0=D0=B5=D0=B2=D1=8C=D1=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../TestsForMatrixMultiplication.cs | 30 +++++++++++++++---- .../parallelMatrixMultiplication/Matrix.cs | 8 ++--- .../StandartDeviationAndMathExpectation.cs | 2 +- 3 files changed, 29 insertions(+), 11 deletions(-) diff --git a/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs b/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs index 40cc657..8cc6bb1 100644 --- a/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs +++ b/parallelMatrixMultiplication/TestsForMatrixMultiplication/TestsForMatrixMultiplication.cs @@ -25,7 +25,7 @@ public void MultiplyMatricesOfSizeThreeByThree() var secondMatrix = Matrix.Create(3, 3, listOfValues); var correctMatrix = Matrix.Create(3, 3, listOfCorrectValues); - var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); + var resultMatrix = Matrix.ParallelMultiply(firstMatrix, secondMatrix); Assert.True(Matrix.AreEquals(resultMatrix, correctMatrix)); } @@ -53,7 +53,7 @@ public void MultiplyMatricesOfBigSize() var secondMatrix = Matrix.Create(10000, 1, listOfValuesSecondMatrix); var correctMatrix = Matrix.Create(10000, 1, listOfCorrectValues); - var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); + var resultMatrix = Matrix.ParallelMultiply(firstMatrix, secondMatrix); Assert.True(Matrix.AreEquals(resultMatrix, correctMatrix)); } @@ -85,7 +85,7 @@ public void MultiplyMatricesOfDifferentSizes() var secondMatrix = Matrix.Create(3, 1, listOfValuesSecondMatrix); var correctMatrix = Matrix.Create(3, 1, listOfCorrectValues); - var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); + var resultMatrix = Matrix.ParallelMultiply(firstMatrix, secondMatrix); Assert.True(Matrix.AreEquals(resultMatrix, correctMatrix)); } @@ -117,7 +117,7 @@ public void MultiplyOfNotSquareMatrices() var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); - var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); + var resultMatrix = Matrix.ParallelMultiply(firstMatrix, secondMatrix); Assert.True(Matrix.AreEquals(resultMatrix, correctMatrix)); } @@ -149,7 +149,7 @@ public void MultiplyMatricesWithNegativeNumbers() var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); - var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); + var resultMatrix = Matrix.ParallelMultiply(firstMatrix, secondMatrix); Assert.True(Matrix.AreEquals(resultMatrix, correctMatrix)); } @@ -181,7 +181,7 @@ public void MultiplyMatricesWithZero() var secondMatrix = Matrix.Create(5, 1, listOfValuesSecondMatrix); var correctMatrix = Matrix.Create(2, 1, listOfCorrectValues); - var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); + var resultMatrix = Matrix.ParallelMultiply(firstMatrix, secondMatrix); Assert.True(Matrix.AreEquals(resultMatrix, correctMatrix)); } @@ -202,4 +202,22 @@ public void MultiplyMatricesWithWrongData() Path.Combine(TestContext.CurrentContext.TestDirectory, "TestsForMatrix", "resultMatrix.txt"))); } + + [Test] + public void CompareParalelAndConsistentMultiply() + { + var listOfValues = new List + { + new int[3] { 1, 2, 3 }, + new int[3] { 4, 5, 6 }, + new int[3] { 7, 8, 9 }, + }; + + var firstMatrix = Matrix.Create(3, 3, listOfValues); + var secondMatrix = Matrix.Create(3, 3, listOfValues); + + var resultMatrixFromParallelMultiply = Matrix.ParallelMultiply(firstMatrix, secondMatrix); + var resultMatrixFromConsistentMultiply = Matrix.ConsistentMultiply(firstMatrix, secondMatrix); + Assert.True(Matrix.AreEquals(resultMatrixFromParallelMultiply, resultMatrixFromConsistentMultiply)); + } } \ No newline at end of file diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs index 3b66186..2e372c9 100644 --- a/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/Matrix.cs @@ -131,7 +131,7 @@ private static void Multiply(int start, int end, int[][] firstMatrix, int[][] tr /// Parallel matrix multiplication function /// /// Returns the calculated matrix - public static int[][] Multiply(int[][] firstMatrix, int[][] secondMatrix) + public static int[][] ParallelMultiply(int[][] firstMatrix, int[][] secondMatrix) { var resultMatrix = new int[firstMatrix.Length][]; @@ -234,7 +234,7 @@ public static void Multiplication(string firstFile, string secondFile, string re { var firstMatrix = ReadFromFile(firstFile); var secondMatrix = ReadFromFile(secondFile); - var resultMatrix = Multiply(firstMatrix, secondMatrix); + var resultMatrix = ParallelMultiply(firstMatrix, secondMatrix); WriteResultToFile(resultFile, resultMatrix); } @@ -245,10 +245,10 @@ public static long CompareMultiplication(string firstFile, string secondFile) { var firstMatrix = ReadFromFile(firstFile); var secondMatrix = ReadFromFile(secondFile); - + var stopwatchParallelMultiplication = new Stopwatch(); stopwatchParallelMultiplication.Start(); - var resultMatrixFromParallelMultiplication = Multiply(firstMatrix, secondMatrix); + var resultMatrixFromParallelMultiplication = ParallelMultiply(firstMatrix, secondMatrix); stopwatchParallelMultiplication.Stop(); var result = stopwatchParallelMultiplication.ElapsedMilliseconds; diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs index 09288df..c80095c 100644 --- a/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs @@ -34,7 +34,7 @@ private static double GetMathExpectation(int[][] firstMatrix, int[][] secondMatr } else { - var resultMatrix = Matrix.Multiply(firstMatrix, secondMatrix); + var resultMatrix = Matrix.ParallelMultiply(firstMatrix, secondMatrix); } stopWatch.Stop(); arrayForStandardDeviation[i] = stopWatch.ElapsedMilliseconds; From 8d4757be43ae27ee97fc4fc03d11a837999867aa Mon Sep 17 00:00:00 2001 From: Artem Date: Tue, 24 Oct 2023 17:46:11 +0300 Subject: [PATCH 7/7] =?UTF-8?q?=D0=A0=D0=B5=D0=B2=D1=8C=D1=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../StandartDeviationAndMathExpectation.cs | 31 +++++++++---------- parallelMatrixMultiplication/tableFile.txt | 10 +++--- 2 files changed, 19 insertions(+), 22 deletions(-) diff --git a/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs b/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs index c80095c..4b97258 100644 --- a/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs +++ b/parallelMatrixMultiplication/parallelMatrixMultiplication/StandartDeviationAndMathExpectation.cs @@ -17,7 +17,7 @@ private static double GetStandartDeviation(int n, double[] arrayForStandardDevia summaryForStandartDeviation += Math.Pow(arrayForStandardDeviation[i] - mathExpectation, 2); } - return Math.Round(Math.Sqrt(summaryForStandartDeviation / (n - 1)), 7); + return Math.Round(Math.Sqrt(summaryForStandartDeviation / (n - 1)), 3); } private static double GetMathExpectation(int[][] firstMatrix, int[][] secondMatrix, @@ -73,11 +73,11 @@ private static void MultiplyMatricesOfSizeTwoHundredAndFiftyByTwoHundredAndFifty var streamForWrite = new StreamWriter(filePath, true); streamForWrite.Write("250x250\nи 250x250\t\t"); streamForWrite.Write(mathExpectationMultiThreaded); - streamForWrite.Write("\t\t\t\t\t\t\t\t\t\t"); + streamForWrite.Write("\t\t "); streamForWrite.Write(standardDeviationMultiThreaded); - streamForWrite.Write("\t\t\t\t\t\t"); + streamForWrite.Write(" "); streamForWrite.Write(mathExpectationSingleThreaded); - streamForWrite.Write("\t\t\t\t\t\t\t"); + streamForWrite.Write(" "); streamForWrite.WriteLine(standardDeviationSingleThreaded); streamForWrite.Write('\n'); streamForWrite.Close(); @@ -113,11 +113,11 @@ private static void MultiplyMatricesOfBigSize(string filePath) var streamForWrite = new StreamWriter(filePath, true); streamForWrite.Write("10000x10000\nи 10000x1\t\t"); streamForWrite.Write(mathExpectationMultiThreaded); - streamForWrite.Write("\t\t\t\t\t\t\t\t\t\t"); + streamForWrite.Write("\t\t "); streamForWrite.Write(standardDeviationMultiThreaded); - streamForWrite.Write("\t\t\t\t\t\t"); + streamForWrite.Write(" "); streamForWrite.Write(mathExpectationSingleThreaded); - streamForWrite.Write("\t\t\t\t\t\t\t"); + streamForWrite.Write(" "); streamForWrite.WriteLine(standardDeviationSingleThreaded); streamForWrite.Write('\n'); streamForWrite.Close(); @@ -153,11 +153,11 @@ private static void MultiplyMatricesOfFiveHundredOnFiveHundredSize(string filePa var streamForWrite = new StreamWriter(filePath, true); streamForWrite.Write("500x500\nи 500x500\t\t"); streamForWrite.Write(mathExpectationMultiThreaded); - streamForWrite.Write("\t\t\t\t\t\t\t\t\t\t"); + streamForWrite.Write("\t\t "); streamForWrite.Write(standardDeviationMultiThreaded); - streamForWrite.Write("\t\t\t\t\t\t"); + streamForWrite.Write(" "); streamForWrite.Write(mathExpectationSingleThreaded); - streamForWrite.Write("\t\t\t\t\t\t\t"); + streamForWrite.Write(" "); streamForWrite.WriteLine(standardDeviationSingleThreaded); streamForWrite.Write('\n'); streamForWrite.Close(); @@ -172,13 +172,10 @@ public static void CreateTableWithResults(string filePath) var streamForWrite = new StreamWriter(filePath); streamForWrite.Write("В файле представлены: математическое ожидание и среднеквадратичное отклонение\n"); streamForWrite.WriteLine("-----------------------------------------------------------------------------"); - streamForWrite.Write("Размеры матриц\tМатематическое ожидание с использованием многопоточности\t" + - "Среднеквадратичное отклонение с использованием многопотчности" + - "\tМатематическое ожидание без использования\tСреднеквадратическое " + - "отклонение без использования\n"); - streamForWrite.WriteLine("--------------------------------------------------------------------------------" + - "--------------------------------------------------------------------------------" + - "---------------------------------------------------------------------------------"); + streamForWrite.Write("Размеры матриц\tμ+parallelization\t" + + "σ+parallelization" + + "\tμ\tσ\n"); + streamForWrite.WriteLine("-----------------------------------------------------------------------------"); streamForWrite.Close(); MultiplyMatricesOfSizeTwoHundredAndFiftyByTwoHundredAndFifty(filePath); MultiplyMatricesOfBigSize(filePath); diff --git a/parallelMatrixMultiplication/tableFile.txt b/parallelMatrixMultiplication/tableFile.txt index 6a03b20..3b86ac4 100644 --- a/parallelMatrixMultiplication/tableFile.txt +++ b/parallelMatrixMultiplication/tableFile.txt @@ -1,13 +1,13 @@ В файле представлены: математическое ожидание и среднеквадратичное отклонение ----------------------------------------------------------------------------- -Размеры матриц Математическое ожидание с использованием многопоточности Среднеквадратичное отклонение с использованием многопотчности Математическое ожидание без использования Среднеквадратическое отклонение без использования -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +Размеры матриц μ+parallelization σ+parallelization μ σ +----------------------------------------------------------------------------- 250x250 -и 250x250 30,1 5,4456915 110,8 13,6284017 +и 250x250 16,4 3,169 57,5 0,707 10000x10000 -и 10000x1 129,3 33,3168292 556,7 72,4891563 +и 10000x1 94,2 13,122 343,4 1,713 500x500 -и 500x500 129,5 29,9007618 614,8 7,4654761 +и 500x500 105,8 3,259 477,4 4,195