From e28231b3be23e4527a58f3f7dd52ada4ab16da2e Mon Sep 17 00:00:00 2001 From: SarcasticMoose Date: Sun, 16 Jun 2024 20:26:28 +0200 Subject: [PATCH 1/7] docs: concat CHANGELOG.md --- CHANGELOG.md | 36 +++++++++++++++++++++++++++++++++++ McdaToolkit/CHANGELOG.md | 41 ---------------------------------------- 2 files changed, 36 insertions(+), 41 deletions(-) delete mode 100644 McdaToolkit/CHANGELOG.md diff --git a/CHANGELOG.md b/CHANGELOG.md index 0bd6c70..4fcf659 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,4 +8,40 @@ All notable changes to this project will be documented in this file. See [versio ### Features * add vector normalization ([c819676](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/c81967667e032413cdad426a9a5a0e6dfecd6804)) + +## [2.0.1](https://www.github.com/SarcasticMoose/mcda-toolkit/releases/tag/v2.0.1) (2024-06-12) + +### Bug Fixes + +* remove redundant casting ([6db1dbc](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/6db1dbc1f88f2e342d8b3d7aa81364d90e4dfab5)) +* update broken project ([ea46d0d](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/ea46d0d1c43ba0c25c957fbc6dd60e70dfd88326)) + + +## [2.0.0](https://www.github.com/SarcasticMoose/mcda-toolkit/releases/tag/v2.0.0) (2024-06-12) + +### Features + +* add enumeration iteration with index ([4c76513](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/4c76513a9100a629accd43f28bd41d33d6e211ea)) +* add generic methods ([7cfd3ea](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/7cfd3eac2afcd59b4c7f2e808eddf9aa926386a5)) +* add versioning ([8db0fc3](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/8db0fc30cd345134a7210b069fb519b193f27bc8)) + +### Bug Fixes + +* fix project ([a9cdc05](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/a9cdc05d72d01901eb0be13aa1772187fabfa083)) + +### Breaking Changes + +* adjust styling,names etc. ([d23c29d](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/d23c29dd9d1f3924f5aabc82b5a3472bc085d9dd)) + + +## [1.0.1](https://www.github.com/SarcasticMoose/mcda-toolkit/releases/tag/v1.0.1) (2024-06-03) + + +## [1.0.0](https://www.github.com/SarcasticMoose/mcda-toolkit/releases/tag/v1.0.0) (2024-06-03) + +### Features + +* add enumeration iteration with index ([5196aa1](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/5196aa1df9c2b86d6a495454b2e3fb9a2a5f3d1d)) +* add generic methods ([d75c45e](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/d75c45e9bb11a8a001be2151ffd8a070d1461fc7)) +* add versioning ([69b93d0](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/69b93d0b2d4669bb7ffb28f3e36fb754280ea352)) diff --git a/McdaToolkit/CHANGELOG.md b/McdaToolkit/CHANGELOG.md deleted file mode 100644 index 9531e4d..0000000 --- a/McdaToolkit/CHANGELOG.md +++ /dev/null @@ -1,41 +0,0 @@ -# Change Log - -All notable changes to this project will be documented in this file. See [versionize](https://github.com/versionize/versionize) for commit guidelines. - - -## [2.0.1](https://www.github.com/SarcasticMoose/mcda-toolkit/releases/tag/v2.0.1) (2024-06-12) - -### Bug Fixes - -* remove redundant casting ([6db1dbc](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/6db1dbc1f88f2e342d8b3d7aa81364d90e4dfab5)) -* update broken project ([ea46d0d](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/ea46d0d1c43ba0c25c957fbc6dd60e70dfd88326)) - - -## [2.0.0](https://www.github.com/SarcasticMoose/mcda-toolkit/releases/tag/v2.0.0) (2024-06-12) - -### Features - -* add enumeration iteration with index ([4c76513](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/4c76513a9100a629accd43f28bd41d33d6e211ea)) -* add generic methods ([7cfd3ea](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/7cfd3eac2afcd59b4c7f2e808eddf9aa926386a5)) -* add versioning ([8db0fc3](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/8db0fc30cd345134a7210b069fb519b193f27bc8)) - -### Bug Fixes - -* fix project ([a9cdc05](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/a9cdc05d72d01901eb0be13aa1772187fabfa083)) - -### Breaking Changes - -* adjust styling,names etc. ([d23c29d](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/d23c29dd9d1f3924f5aabc82b5a3472bc085d9dd)) - - -## [1.0.1](https://www.github.com/SarcasticMoose/mcda-toolkit/releases/tag/v1.0.1) (2024-06-03) - - -## [1.0.0](https://www.github.com/SarcasticMoose/mcda-toolkit/releases/tag/v1.0.0) (2024-06-03) - -### Features - -* add enumeration iteration with index ([5196aa1](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/5196aa1df9c2b86d6a495454b2e3fb9a2a5f3d1d)) -* add generic methods ([d75c45e](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/d75c45e9bb11a8a001be2151ffd8a070d1461fc7)) -* add versioning ([69b93d0](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/69b93d0b2d4669bb7ffb28f3e36fb754280ea352)) - From c3f3bc1193059c24b364d9628b83833c8bccb033 Mon Sep 17 00:00:00 2001 From: SarcasticMoose Date: Sun, 16 Jun 2024 20:56:40 +0200 Subject: [PATCH 2/7] other: update proejct structure --- CHANGELOG.md | 3 +- McdaMethods.sln | 21 ++++++------ McdaToolkit/McdaToolkit.csproj | 33 ------------------- .../Enums/NormalizationMethodEnum.cs | 0 .../Extensions/EnumerableExtentions.cs | 0 .../McdaMethods/Abstraction/McdaMethod.cs | 0 .../Errors/ArraySizesAreNotEqual.cs | 0 .../CriteriaNotBetweenMinusOneAndOne.cs | 0 .../Errors/WeightNotSumToOneError.cs | 0 .../McdaMethods/Helpers/CheckDataHelper.cs | 0 .../McdaMethods/Interfaces/IMethod.cs | 0 .../McdaToolkit}/McdaMethods/TopsisMethod.cs | 0 src/McdaToolkit/McdaToolkit.csproj | 28 ++++++++++++++++ .../Normalization/DataNormalizationService.cs | 0 .../Interfaces/IDataNormalization.cs | 0 .../McdaToolkit}/NormalizationFactory.cs | 0 .../Interfaces/INormalize.cs | 0 .../Types/Linear/MinMaxNormalization.cs | 0 .../Types/Sum/VectorNormalization.cs | 0 .../McdaToolkit}/Options/McdaMethodOptions.cs | 0 .../Helpers/TestHelpers.cs | 0 .../McdaMethodsTests.cs | 0 .../McdaToolkit.UnitTests.csproj | 2 +- .../NormalizationUnitTests.cs | 0 24 files changed, 41 insertions(+), 46 deletions(-) delete mode 100644 McdaToolkit/McdaToolkit.csproj rename {McdaToolkit => src/McdaToolkit}/Enums/NormalizationMethodEnum.cs (100%) rename {McdaToolkit => src/McdaToolkit}/Extensions/EnumerableExtentions.cs (100%) rename {McdaToolkit => src/McdaToolkit}/McdaMethods/Abstraction/McdaMethod.cs (100%) rename {McdaToolkit => src/McdaToolkit}/McdaMethods/Errors/ArraySizesAreNotEqual.cs (100%) rename {McdaToolkit => src/McdaToolkit}/McdaMethods/Errors/CriteriaNotBetweenMinusOneAndOne.cs (100%) rename {McdaToolkit => src/McdaToolkit}/McdaMethods/Errors/WeightNotSumToOneError.cs (100%) rename {McdaToolkit => src/McdaToolkit}/McdaMethods/Helpers/CheckDataHelper.cs (100%) rename {McdaToolkit => src/McdaToolkit}/McdaMethods/Interfaces/IMethod.cs (100%) rename {McdaToolkit => src/McdaToolkit}/McdaMethods/TopsisMethod.cs (100%) create mode 100644 src/McdaToolkit/McdaToolkit.csproj rename {McdaToolkit => src/McdaToolkit}/Normalization/DataNormalizationService.cs (100%) rename {McdaToolkit => src/McdaToolkit}/Normalization/Interfaces/IDataNormalization.cs (100%) rename {McdaToolkit => src/McdaToolkit}/NormalizationFactory.cs (100%) rename {McdaToolkit => src/McdaToolkit}/NormalizationMethods/Interfaces/INormalize.cs (100%) rename {McdaToolkit => src/McdaToolkit}/NormalizationMethods/Types/Linear/MinMaxNormalization.cs (100%) rename {McdaToolkit => src/McdaToolkit}/NormalizationMethods/Types/Sum/VectorNormalization.cs (100%) rename {McdaToolkit => src/McdaToolkit}/Options/McdaMethodOptions.cs (100%) rename {McdaToolkit.UnitTests => tests/McdaToolkit.UnitTests}/Helpers/TestHelpers.cs (100%) rename {McdaToolkit.UnitTests => tests/McdaToolkit.UnitTests}/McdaMethodsTests.cs (100%) rename {McdaToolkit.UnitTests => tests/McdaToolkit.UnitTests}/McdaToolkit.UnitTests.csproj (91%) rename {McdaToolkit.UnitTests => tests/McdaToolkit.UnitTests}/NormalizationUnitTests.cs (100%) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4fcf659..ef1009b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,7 +8,8 @@ All notable changes to this project will be documented in this file. See [versio ### Features * add vector normalization ([c819676](https://www.github.com/SarcasticMoose/mcda-toolkit/commit/c81967667e032413cdad426a9a5a0e6dfecd6804)) - + + ## [2.0.1](https://www.github.com/SarcasticMoose/mcda-toolkit/releases/tag/v2.0.1) (2024-06-12) ### Bug Fixes diff --git a/McdaMethods.sln b/McdaMethods.sln index 85f515f..bf99a35 100644 --- a/McdaMethods.sln +++ b/McdaMethods.sln @@ -1,11 +1,10 @@ - Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 VisualStudioVersion = 17.8.34525.116 MinimumVisualStudioVersion = 10.0.40219.1 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "McdaToolkit", "McdaToolkit\McdaToolkit.csproj", "{EC147B8B-336E-4744-8F54-43D1BB0E4FC3}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "McdaToolkit", "src\McdaToolkit\McdaToolkit.csproj", "{EC2ACBF0-59C4-4B03-B9AD-54E31E69A791}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "McdaToolkit.UnitTests", "McdaToolkit.UnitTests\McdaToolkit.UnitTests.csproj", "{675DE565-59A0-4865-A306-B12FCC64EF1F}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "McdaToolkit.UnitTests", "tests\McdaToolkit.UnitTests\McdaToolkit.UnitTests.csproj", "{C16A9430-0ABA-44D5-B9D2-256DEA133D38}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -13,14 +12,14 @@ Global Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution - {EC147B8B-336E-4744-8F54-43D1BB0E4FC3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {EC147B8B-336E-4744-8F54-43D1BB0E4FC3}.Debug|Any CPU.Build.0 = Debug|Any CPU - {EC147B8B-336E-4744-8F54-43D1BB0E4FC3}.Release|Any CPU.ActiveCfg = Release|Any CPU - {EC147B8B-336E-4744-8F54-43D1BB0E4FC3}.Release|Any CPU.Build.0 = Release|Any CPU - {675DE565-59A0-4865-A306-B12FCC64EF1F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {675DE565-59A0-4865-A306-B12FCC64EF1F}.Debug|Any CPU.Build.0 = Debug|Any CPU - {675DE565-59A0-4865-A306-B12FCC64EF1F}.Release|Any CPU.ActiveCfg = Release|Any CPU - {675DE565-59A0-4865-A306-B12FCC64EF1F}.Release|Any CPU.Build.0 = Release|Any CPU + {EC2ACBF0-59C4-4B03-B9AD-54E31E69A791}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {EC2ACBF0-59C4-4B03-B9AD-54E31E69A791}.Debug|Any CPU.Build.0 = Debug|Any CPU + {EC2ACBF0-59C4-4B03-B9AD-54E31E69A791}.Release|Any CPU.ActiveCfg = Release|Any CPU + {EC2ACBF0-59C4-4B03-B9AD-54E31E69A791}.Release|Any CPU.Build.0 = Release|Any CPU + {C16A9430-0ABA-44D5-B9D2-256DEA133D38}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C16A9430-0ABA-44D5-B9D2-256DEA133D38}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C16A9430-0ABA-44D5-B9D2-256DEA133D38}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C16A9430-0ABA-44D5-B9D2-256DEA133D38}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/McdaToolkit/McdaToolkit.csproj b/McdaToolkit/McdaToolkit.csproj deleted file mode 100644 index 9051825..0000000 --- a/McdaToolkit/McdaToolkit.csproj +++ /dev/null @@ -1,33 +0,0 @@ - - - - enable - enable - - - - McdaToolkit - 2.1.0 - Jakub Tokarczyk - latest - README.md - netstandard2.1;net6.0;net7.0;net8.0 - © 2024 Jakub Tokarczyk - MIT - https://github.com/SarcasticMoose/mcda-toolkit - - - - - - - - - - - - - - - - diff --git a/McdaToolkit/Enums/NormalizationMethodEnum.cs b/src/McdaToolkit/Enums/NormalizationMethodEnum.cs similarity index 100% rename from McdaToolkit/Enums/NormalizationMethodEnum.cs rename to src/McdaToolkit/Enums/NormalizationMethodEnum.cs diff --git a/McdaToolkit/Extensions/EnumerableExtentions.cs b/src/McdaToolkit/Extensions/EnumerableExtentions.cs similarity index 100% rename from McdaToolkit/Extensions/EnumerableExtentions.cs rename to src/McdaToolkit/Extensions/EnumerableExtentions.cs diff --git a/McdaToolkit/McdaMethods/Abstraction/McdaMethod.cs b/src/McdaToolkit/McdaMethods/Abstraction/McdaMethod.cs similarity index 100% rename from McdaToolkit/McdaMethods/Abstraction/McdaMethod.cs rename to src/McdaToolkit/McdaMethods/Abstraction/McdaMethod.cs diff --git a/McdaToolkit/McdaMethods/Errors/ArraySizesAreNotEqual.cs b/src/McdaToolkit/McdaMethods/Errors/ArraySizesAreNotEqual.cs similarity index 100% rename from McdaToolkit/McdaMethods/Errors/ArraySizesAreNotEqual.cs rename to src/McdaToolkit/McdaMethods/Errors/ArraySizesAreNotEqual.cs diff --git a/McdaToolkit/McdaMethods/Errors/CriteriaNotBetweenMinusOneAndOne.cs b/src/McdaToolkit/McdaMethods/Errors/CriteriaNotBetweenMinusOneAndOne.cs similarity index 100% rename from McdaToolkit/McdaMethods/Errors/CriteriaNotBetweenMinusOneAndOne.cs rename to src/McdaToolkit/McdaMethods/Errors/CriteriaNotBetweenMinusOneAndOne.cs diff --git a/McdaToolkit/McdaMethods/Errors/WeightNotSumToOneError.cs b/src/McdaToolkit/McdaMethods/Errors/WeightNotSumToOneError.cs similarity index 100% rename from McdaToolkit/McdaMethods/Errors/WeightNotSumToOneError.cs rename to src/McdaToolkit/McdaMethods/Errors/WeightNotSumToOneError.cs diff --git a/McdaToolkit/McdaMethods/Helpers/CheckDataHelper.cs b/src/McdaToolkit/McdaMethods/Helpers/CheckDataHelper.cs similarity index 100% rename from McdaToolkit/McdaMethods/Helpers/CheckDataHelper.cs rename to src/McdaToolkit/McdaMethods/Helpers/CheckDataHelper.cs diff --git a/McdaToolkit/McdaMethods/Interfaces/IMethod.cs b/src/McdaToolkit/McdaMethods/Interfaces/IMethod.cs similarity index 100% rename from McdaToolkit/McdaMethods/Interfaces/IMethod.cs rename to src/McdaToolkit/McdaMethods/Interfaces/IMethod.cs diff --git a/McdaToolkit/McdaMethods/TopsisMethod.cs b/src/McdaToolkit/McdaMethods/TopsisMethod.cs similarity index 100% rename from McdaToolkit/McdaMethods/TopsisMethod.cs rename to src/McdaToolkit/McdaMethods/TopsisMethod.cs diff --git a/src/McdaToolkit/McdaToolkit.csproj b/src/McdaToolkit/McdaToolkit.csproj new file mode 100644 index 0000000..c19e179 --- /dev/null +++ b/src/McdaToolkit/McdaToolkit.csproj @@ -0,0 +1,28 @@ + + + + enable + enable + + + + McdaToolkit + 2.1.0 + Jakub Tokarczyk + latest + README.md + netstandard2.1;net6.0;net7.0;net8.0 + © 2024 Jakub Tokarczyk + MIT + https://github.com/SarcasticMoose/mcda-toolkit + + + + + + + + + + + diff --git a/McdaToolkit/Normalization/DataNormalizationService.cs b/src/McdaToolkit/Normalization/DataNormalizationService.cs similarity index 100% rename from McdaToolkit/Normalization/DataNormalizationService.cs rename to src/McdaToolkit/Normalization/DataNormalizationService.cs diff --git a/McdaToolkit/Normalization/Interfaces/IDataNormalization.cs b/src/McdaToolkit/Normalization/Interfaces/IDataNormalization.cs similarity index 100% rename from McdaToolkit/Normalization/Interfaces/IDataNormalization.cs rename to src/McdaToolkit/Normalization/Interfaces/IDataNormalization.cs diff --git a/McdaToolkit/NormalizationFactory.cs b/src/McdaToolkit/NormalizationFactory.cs similarity index 100% rename from McdaToolkit/NormalizationFactory.cs rename to src/McdaToolkit/NormalizationFactory.cs diff --git a/McdaToolkit/NormalizationMethods/Interfaces/INormalize.cs b/src/McdaToolkit/NormalizationMethods/Interfaces/INormalize.cs similarity index 100% rename from McdaToolkit/NormalizationMethods/Interfaces/INormalize.cs rename to src/McdaToolkit/NormalizationMethods/Interfaces/INormalize.cs diff --git a/McdaToolkit/NormalizationMethods/Types/Linear/MinMaxNormalization.cs b/src/McdaToolkit/NormalizationMethods/Types/Linear/MinMaxNormalization.cs similarity index 100% rename from McdaToolkit/NormalizationMethods/Types/Linear/MinMaxNormalization.cs rename to src/McdaToolkit/NormalizationMethods/Types/Linear/MinMaxNormalization.cs diff --git a/McdaToolkit/NormalizationMethods/Types/Sum/VectorNormalization.cs b/src/McdaToolkit/NormalizationMethods/Types/Sum/VectorNormalization.cs similarity index 100% rename from McdaToolkit/NormalizationMethods/Types/Sum/VectorNormalization.cs rename to src/McdaToolkit/NormalizationMethods/Types/Sum/VectorNormalization.cs diff --git a/McdaToolkit/Options/McdaMethodOptions.cs b/src/McdaToolkit/Options/McdaMethodOptions.cs similarity index 100% rename from McdaToolkit/Options/McdaMethodOptions.cs rename to src/McdaToolkit/Options/McdaMethodOptions.cs diff --git a/McdaToolkit.UnitTests/Helpers/TestHelpers.cs b/tests/McdaToolkit.UnitTests/Helpers/TestHelpers.cs similarity index 100% rename from McdaToolkit.UnitTests/Helpers/TestHelpers.cs rename to tests/McdaToolkit.UnitTests/Helpers/TestHelpers.cs diff --git a/McdaToolkit.UnitTests/McdaMethodsTests.cs b/tests/McdaToolkit.UnitTests/McdaMethodsTests.cs similarity index 100% rename from McdaToolkit.UnitTests/McdaMethodsTests.cs rename to tests/McdaToolkit.UnitTests/McdaMethodsTests.cs diff --git a/McdaToolkit.UnitTests/McdaToolkit.UnitTests.csproj b/tests/McdaToolkit.UnitTests/McdaToolkit.UnitTests.csproj similarity index 91% rename from McdaToolkit.UnitTests/McdaToolkit.UnitTests.csproj rename to tests/McdaToolkit.UnitTests/McdaToolkit.UnitTests.csproj index b428fc1..961d6a9 100644 --- a/McdaToolkit.UnitTests/McdaToolkit.UnitTests.csproj +++ b/tests/McdaToolkit.UnitTests/McdaToolkit.UnitTests.csproj @@ -22,7 +22,7 @@ - + diff --git a/McdaToolkit.UnitTests/NormalizationUnitTests.cs b/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs similarity index 100% rename from McdaToolkit.UnitTests/NormalizationUnitTests.cs rename to tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs From f65ce3e69412df6c3fe6249f643c663b2980565a Mon Sep 17 00:00:00 2001 From: SarcasticMoose Date: Mon, 17 Jun 2024 13:52:06 +0200 Subject: [PATCH 3/7] feat: added logarithmic normalization --- .../Enums/NormalizationMethodEnum.cs | 3 ++- src/McdaToolkit/NormalizationFactory.cs | 1 + .../Interfaces/INormalize.cs | 7 ++++++ .../Types/Sum/LogarithmicNormalization.cs | 20 +++++++++++++++++ .../NormalizationUnitTests.cs | 22 +++++++++++++++++++ 5 files changed, 52 insertions(+), 1 deletion(-) create mode 100644 src/McdaToolkit/NormalizationMethods/Types/Sum/LogarithmicNormalization.cs diff --git a/src/McdaToolkit/Enums/NormalizationMethodEnum.cs b/src/McdaToolkit/Enums/NormalizationMethodEnum.cs index fff4dc5..e9e04cc 100644 --- a/src/McdaToolkit/Enums/NormalizationMethodEnum.cs +++ b/src/McdaToolkit/Enums/NormalizationMethodEnum.cs @@ -3,5 +3,6 @@ public enum NormalizationMethodEnum { MinMax, - Vector + Vector, + Logarithmic } \ No newline at end of file diff --git a/src/McdaToolkit/NormalizationFactory.cs b/src/McdaToolkit/NormalizationFactory.cs index 2c4ce3c..f164d5b 100644 --- a/src/McdaToolkit/NormalizationFactory.cs +++ b/src/McdaToolkit/NormalizationFactory.cs @@ -15,6 +15,7 @@ public static INormalize CreateNormalizationMethod(NormalizationMethodEn { NormalizationMethodEnum.MinMax => new MinMaxNormalization(), NormalizationMethodEnum.Vector => new VectorNormalization(), + NormalizationMethodEnum.Logarithmic => new LogarithmicNormalization(), _ => throw new Exception("Not existing normalization") }; } diff --git a/src/McdaToolkit/NormalizationMethods/Interfaces/INormalize.cs b/src/McdaToolkit/NormalizationMethods/Interfaces/INormalize.cs index 8e7ab64..1cd5ade 100644 --- a/src/McdaToolkit/NormalizationMethods/Interfaces/INormalize.cs +++ b/src/McdaToolkit/NormalizationMethods/Interfaces/INormalize.cs @@ -2,7 +2,14 @@ namespace McdaToolkit.NormalizationMethods.Interfaces; + public interface INormalize where T : struct, IEquatable, IFormattable { + /// + /// Normalize vector of data + /// + /// + /// + /// One-dimensional vector contains normalized values Vector Normalize(Vector data, bool cost); } \ No newline at end of file diff --git a/src/McdaToolkit/NormalizationMethods/Types/Sum/LogarithmicNormalization.cs b/src/McdaToolkit/NormalizationMethods/Types/Sum/LogarithmicNormalization.cs new file mode 100644 index 0000000..9e36ab9 --- /dev/null +++ b/src/McdaToolkit/NormalizationMethods/Types/Sum/LogarithmicNormalization.cs @@ -0,0 +1,20 @@ +using MathNet.Numerics.LinearAlgebra; +using McdaToolkit.NormalizationMethods.Interfaces; + +namespace McdaToolkit.NormalizationMethods.Types.Sum; + +public class LogarithmicNormalization : INormalize +{ + public Vector Normalize(Vector data, bool cost) + { + var product = data.Aggregate(1.0,(x,y) => x * y); + var exp = data.PointwiseLog() / Math.Log(product); + + if (cost) + { + return 1 - exp; + } + + return exp; + } +} \ No newline at end of file diff --git a/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs b/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs index 007765a..4e2b46f 100644 --- a/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs +++ b/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs @@ -63,4 +63,26 @@ public void Normalize_VectorNormalization_ShouldReturnedExpectedValues() var equalityResult = TestHelpers.CheckEquality(normalizedMatrix, expected); equalityResult.Should().BeTrue(); } + + [Fact] + public void Normalize_Logarithmic_ShouldReturnedExpectedValues() + { + var normalizationType = NormalizationMethodEnum.Logarithmic; + var expected = new double[][] + { + [0.87403010, 0.89954564, 0.16128664, 0.14438272, 0.86315596], + [0.83599827, 0.83739945, 0.12708112, 0.11624356, 0.85277256], + [0.84224030, 0.84123458, 0.13796910, 0.16008394, 0.87001329], + [0.85566609, 0.86712382, 0.14590034, 0.16216292, 0.84432373], + [0.88861531, 0.85092357, 0.15500620, 0.14993079, 0.85678609], + [0.83919604, 0.82785947, 0.13175623, 0.11299010, 0.85351828], + [0.86425385, 0.87591345, 0.14100037, 0.15420595, 0.85943008] + }; + var dataNormalization = new DataNormalizationService(normalizationType); + + var normalizedMatrix = dataNormalization.NormalizeMatrix(_matrixToNormalize,_types); + + var equalityResult = TestHelpers.CheckEquality(normalizedMatrix, expected); + equalityResult.Should().BeTrue(); + } } \ No newline at end of file From dc19047207858938f4d53dc6e9b8b53f558d2cd0 Mon Sep 17 00:00:00 2001 From: SarcasticMoose Date: Tue, 13 Aug 2024 20:11:32 +0200 Subject: [PATCH 4/7] feat: added sum and max normalization refactor: used IDataNormalization instead of it implementation docs: added docs for some functionality --- .../Enums/NormalizationMethodEnum.cs | 4 +- src/McdaToolkit/McdaMethods/TopsisMethod.cs | 4 +- .../Normalization/DataNormalizationService.cs | 2 +- ...ctory.cs => NormalizationMethodFactory.cs} | 6 ++- .../Types/Linear/MaxNormalization.cs | 25 +++++++++++ .../Types/Linear/MinMaxNormalization.cs | 14 ++++-- .../Types/Linear/SumNormalization.cs | 17 +++++++ .../Types/Sum/LogarithmicNormalization.cs | 10 ++++- .../McdaToolkit.UnitTests/McdaMethodsTests.cs | 3 +- .../NormalizationUnitTests.cs | 44 +++++++++++++++++++ 10 files changed, 117 insertions(+), 12 deletions(-) rename src/McdaToolkit/{NormalizationFactory.cs => NormalizationMethodFactory.cs} (70%) create mode 100644 src/McdaToolkit/NormalizationMethods/Types/Linear/MaxNormalization.cs create mode 100644 src/McdaToolkit/NormalizationMethods/Types/Linear/SumNormalization.cs diff --git a/src/McdaToolkit/Enums/NormalizationMethodEnum.cs b/src/McdaToolkit/Enums/NormalizationMethodEnum.cs index e9e04cc..fa8bb98 100644 --- a/src/McdaToolkit/Enums/NormalizationMethodEnum.cs +++ b/src/McdaToolkit/Enums/NormalizationMethodEnum.cs @@ -4,5 +4,7 @@ public enum NormalizationMethodEnum { MinMax, Vector, - Logarithmic + Logarithmic, + Sum, + Max } \ No newline at end of file diff --git a/src/McdaToolkit/McdaMethods/TopsisMethod.cs b/src/McdaToolkit/McdaMethods/TopsisMethod.cs index 1ede244..6c69fc6 100644 --- a/src/McdaToolkit/McdaMethods/TopsisMethod.cs +++ b/src/McdaToolkit/McdaMethods/TopsisMethod.cs @@ -2,15 +2,15 @@ using MathNet.Numerics.LinearAlgebra; using McdaToolkit.Enums; using McdaToolkit.McdaMethods.Abstraction; -using McdaToolkit.McdaMethods.Interfaces; using McdaToolkit.Normalization; +using McdaToolkit.Normalization.Interfaces; using McdaToolkit.Options; namespace McdaToolkit.McdaMethods; public class TopsisMethod : McdaMethod { - private readonly DataNormalizationService _normalizationServiceService; + private readonly IDataNormalization _normalizationServiceService; public TopsisMethod() { diff --git a/src/McdaToolkit/Normalization/DataNormalizationService.cs b/src/McdaToolkit/Normalization/DataNormalizationService.cs index 168504e..9aabfda 100644 --- a/src/McdaToolkit/Normalization/DataNormalizationService.cs +++ b/src/McdaToolkit/Normalization/DataNormalizationService.cs @@ -9,7 +9,7 @@ namespace McdaToolkit.Normalization; public class DataNormalizationService(NormalizationMethodEnum methodEnum) : IDataNormalization { - private readonly INormalize _method = NormalizationFactory.CreateNormalizationMethod(methodEnum); + private readonly INormalize _method = NormalizationMethodFactory.Create(methodEnum); public Matrix NormalizeMatrix(Matrix matrix, int[] criteriaTypes) { diff --git a/src/McdaToolkit/NormalizationFactory.cs b/src/McdaToolkit/NormalizationMethodFactory.cs similarity index 70% rename from src/McdaToolkit/NormalizationFactory.cs rename to src/McdaToolkit/NormalizationMethodFactory.cs index f164d5b..9cef4ac 100644 --- a/src/McdaToolkit/NormalizationFactory.cs +++ b/src/McdaToolkit/NormalizationMethodFactory.cs @@ -7,15 +7,17 @@ namespace McdaToolkit; -internal static class NormalizationFactory +internal static class NormalizationMethodFactory { - public static INormalize CreateNormalizationMethod(NormalizationMethodEnum methodEnum) + public static INormalize Create(NormalizationMethodEnum methodEnum) { return methodEnum switch { NormalizationMethodEnum.MinMax => new MinMaxNormalization(), NormalizationMethodEnum.Vector => new VectorNormalization(), NormalizationMethodEnum.Logarithmic => new LogarithmicNormalization(), + NormalizationMethodEnum.Sum => new SumNormalization() , + NormalizationMethodEnum.Max => new MaxNormalization(), _ => throw new Exception("Not existing normalization") }; } diff --git a/src/McdaToolkit/NormalizationMethods/Types/Linear/MaxNormalization.cs b/src/McdaToolkit/NormalizationMethods/Types/Linear/MaxNormalization.cs new file mode 100644 index 0000000..f52e033 --- /dev/null +++ b/src/McdaToolkit/NormalizationMethods/Types/Linear/MaxNormalization.cs @@ -0,0 +1,25 @@ +using MathNet.Numerics.LinearAlgebra; +using McdaToolkit.NormalizationMethods.Interfaces; + +namespace McdaToolkit.NormalizationMethods.Types.Linear; + +internal class MaxNormalization : INormalize +{ + /// + /// Create normalized vector using max normalization method + /// + /// One-dimensional vector of data to normalize + /// Describe type of vector, cost or profit + /// + /// Return normalized vector + /// + public Vector Normalize(Vector data, bool cost) + { + if (cost) + { + return 1 - data / data.Maximum(); + } + + return data / data.Maximum(); + } +} \ No newline at end of file diff --git a/src/McdaToolkit/NormalizationMethods/Types/Linear/MinMaxNormalization.cs b/src/McdaToolkit/NormalizationMethods/Types/Linear/MinMaxNormalization.cs index ea41c07..8c51e73 100644 --- a/src/McdaToolkit/NormalizationMethods/Types/Linear/MinMaxNormalization.cs +++ b/src/McdaToolkit/NormalizationMethods/Types/Linear/MinMaxNormalization.cs @@ -3,17 +3,25 @@ namespace McdaToolkit.NormalizationMethods.Types.Linear; -public class MinMaxNormalization : INormalize +internal class MinMaxNormalization : INormalize { - private const double MaxError = 1.11e-16; + private const double MaxTolerance = 1.11e-16; + /// + /// Create normalized vector using vector normalization method + /// + /// One-dimensional vector of data to normalize + /// Describe type of vector, cost or profit + /// + /// Return normalized vector + /// public Vector Normalize(Vector data, bool cost = false) { var max = data.Maximum(); var min = data.Minimum(); var difference = max - min; - if (Math.Abs(difference) < MaxError) + if (Math.Abs(difference) < MaxTolerance) { return Vector.Build.Dense(data.Count, _ => 1); } diff --git a/src/McdaToolkit/NormalizationMethods/Types/Linear/SumNormalization.cs b/src/McdaToolkit/NormalizationMethods/Types/Linear/SumNormalization.cs new file mode 100644 index 0000000..8712aa6 --- /dev/null +++ b/src/McdaToolkit/NormalizationMethods/Types/Linear/SumNormalization.cs @@ -0,0 +1,17 @@ +using MathNet.Numerics.LinearAlgebra; +using McdaToolkit.NormalizationMethods.Interfaces; + +namespace McdaToolkit.NormalizationMethods.Types.Linear; + +internal class SumNormalization : INormalize +{ + public Vector Normalize(Vector data, bool cost) + { + if (cost) + { + return 1 / data / data.Sum(x => 1/x); + } + + return data / data.Sum(); + } +} \ No newline at end of file diff --git a/src/McdaToolkit/NormalizationMethods/Types/Sum/LogarithmicNormalization.cs b/src/McdaToolkit/NormalizationMethods/Types/Sum/LogarithmicNormalization.cs index 9e36ab9..d674dd3 100644 --- a/src/McdaToolkit/NormalizationMethods/Types/Sum/LogarithmicNormalization.cs +++ b/src/McdaToolkit/NormalizationMethods/Types/Sum/LogarithmicNormalization.cs @@ -3,8 +3,16 @@ namespace McdaToolkit.NormalizationMethods.Types.Sum; -public class LogarithmicNormalization : INormalize +internal class LogarithmicNormalization : INormalize { + /// + /// Create normalized vector using logarithmic normalization method + /// + /// One-dimensional vector of data to normalize + /// Describe type of vector, cost or profit + /// + /// Return normalized vector + /// public Vector Normalize(Vector data, bool cost) { var product = data.Aggregate(1.0,(x,y) => x * y); diff --git a/tests/McdaToolkit.UnitTests/McdaMethodsTests.cs b/tests/McdaToolkit.UnitTests/McdaMethodsTests.cs index cb50ca9..5b512f7 100644 --- a/tests/McdaToolkit.UnitTests/McdaMethodsTests.cs +++ b/tests/McdaToolkit.UnitTests/McdaMethodsTests.cs @@ -2,7 +2,6 @@ using MathNet.Numerics; using McdaToolkit.McdaMethods; using McdaToolkit.McdaMethods.Errors; -using McdaToolkit.UnitTests.Helpers; using Xunit.Abstractions; namespace McdaToolkit.UnitTests; @@ -53,7 +52,7 @@ public void Calculate_TopsisMethod_ShouldBeEqualToExpected() .Should() .BeEquivalentTo(expectedTopsisScore); } - + [Fact] public void Calculate_WeightAreNotEqualOne_ShouldReturnResultFail() { diff --git a/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs b/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs index 4e2b46f..5a873d7 100644 --- a/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs +++ b/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs @@ -85,4 +85,48 @@ public void Normalize_Logarithmic_ShouldReturnedExpectedValues() var equalityResult = TestHelpers.CheckEquality(normalizedMatrix, expected); equalityResult.Should().BeTrue(); } + + [Fact] + public void Normalize_Sum_ShouldReturnedExpectedValues() + { + var normalizationType = NormalizationMethodEnum.Sum; + var expected = new double[][] + { + [0.87403010, 0.89954564, 0.16128664, 0.14438272, 0.86315596], + [0.83599827, 0.83739945, 0.12708112, 0.11624356, 0.85277256], + [0.84224030, 0.84123458, 0.13796910, 0.16008394, 0.87001329], + [0.85566609, 0.86712382, 0.14590034, 0.16216292, 0.84432373], + [0.88861531, 0.85092357, 0.15500620, 0.14993079, 0.85678609], + [0.83919604, 0.82785947, 0.13175623, 0.11299010, 0.85351828], + [0.86425385, 0.87591345, 0.14100037, 0.15420595, 0.85943008] + }; + var dataNormalization = new DataNormalizationService(normalizationType); + + var normalizedMatrix = dataNormalization.NormalizeMatrix(_matrixToNormalize,_types); + + var equalityResult = TestHelpers.CheckEquality(normalizedMatrix, expected); + equalityResult.Should().BeTrue(); + } + + [Fact] + public void Normalize_Max_ShouldReturnedExpectedValues() + { + var normalizationType = NormalizationMethodEnum.Max; + var expected = new double[][] + { + [0.87403010, 0.89954564, 0.16128664, 0.14438272, 0.86315596], + [0.83599827, 0.83739945, 0.12708112, 0.11624356, 0.85277256], + [0.84224030, 0.84123458, 0.13796910, 0.16008394, 0.87001329], + [0.85566609, 0.86712382, 0.14590034, 0.16216292, 0.84432373], + [0.88861531, 0.85092357, 0.15500620, 0.14993079, 0.85678609], + [0.83919604, 0.82785947, 0.13175623, 0.11299010, 0.85351828], + [0.86425385, 0.87591345, 0.14100037, 0.15420595, 0.85943008] + }; + var dataNormalization = new DataNormalizationService(normalizationType); + + var normalizedMatrix = dataNormalization.NormalizeMatrix(_matrixToNormalize,_types); + + var equalityResult = TestHelpers.CheckEquality(normalizedMatrix, expected); + equalityResult.Should().BeTrue(); + } } \ No newline at end of file From 916dae51933866165bcc8b85e3d5587eb55d8ffb Mon Sep 17 00:00:00 2001 From: SarcasticMoose Date: Tue, 13 Aug 2024 20:19:18 +0200 Subject: [PATCH 5/7] fix: fixed invalid expected test data --- .../NormalizationUnitTests.cs | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs b/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs index 5a873d7..97d413d 100644 --- a/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs +++ b/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs @@ -92,13 +92,13 @@ public void Normalize_Sum_ShouldReturnedExpectedValues() var normalizationType = NormalizationMethodEnum.Sum; var expected = new double[][] { - [0.87403010, 0.89954564, 0.16128664, 0.14438272, 0.86315596], - [0.83599827, 0.83739945, 0.12708112, 0.11624356, 0.85277256], - [0.84224030, 0.84123458, 0.13796910, 0.16008394, 0.87001329], - [0.85566609, 0.86712382, 0.14590034, 0.16216292, 0.84432373], - [0.88861531, 0.85092357, 0.15500620, 0.14993079, 0.85678609], - [0.83919604, 0.82785947, 0.13175623, 0.11299010, 0.85351828], - [0.86425385, 0.87591345, 0.14100037, 0.15420595, 0.85943008] + [0.19968511, 0.36006754, 0.22640921, 0.13248054, 0.16546924], + [0.06976021, 0.06867413, 0.08778814, 0.06038517, 0.12337416], + [0.08290305, 0.07606766, 0.11868812, 0.20537541, 0.20087001], + [0.12017266, 0.15169512, 0.14784688, 0.21764996, 0.09715942], + [0.29888530, 0.09848926, 0.19025962, 0.15467820, 0.13819885], + [0.07620980, 0.05325123, 0.09992463, 0.05514144, 0.12600289], + [0.15238388, 0.19175506, 0.12908340, 0.17428928, 0.14892543] }; var dataNormalization = new DataNormalizationService(normalizationType); @@ -114,13 +114,13 @@ public void Normalize_Max_ShouldReturnedExpectedValues() var normalizationType = NormalizationMethodEnum.Max; var expected = new double[][] { - [0.87403010, 0.89954564, 0.16128664, 0.14438272, 0.86315596], - [0.83599827, 0.83739945, 0.12708112, 0.11624356, 0.85277256], - [0.84224030, 0.84123458, 0.13796910, 0.16008394, 0.87001329], - [0.85566609, 0.86712382, 0.14590034, 0.16216292, 0.84432373], - [0.88861531, 0.85092357, 0.15500620, 0.14993079, 0.85678609], - [0.83919604, 0.82785947, 0.13175623, 0.11299010, 0.85351828], - [0.86425385, 0.87591345, 0.14100037, 0.15420595, 0.85943008] + [0.65064893, 0.85210767, 1, 0.60868626, 0.41282491], + [0, 0.22458101, 0.38774105, 0.27744166, 0.21248161], + [0.15853266, 0.29994921, 0.52421947, 0.94360415, 0.51630701], + [0.41950016, 0.64895886, 0.65300735, 1, 0], + [0.76659873, 0.45931945, 0.84033517, 0.71067416, 0.29695929], + [0.08462941, 0, 0.44134527, 0.25334918, 0.22891123], + [0.54220744, 0.72229558, 0.57013315, 0.80077787, 0.34759686] }; var dataNormalization = new DataNormalizationService(normalizationType); From 767771aef187bc882d91faade3973c123cc4ee7e Mon Sep 17 00:00:00 2001 From: SarcasticMoose Date: Tue, 13 Aug 2024 23:45:14 +0200 Subject: [PATCH 6/7] feat: added errors feat: added conversion for 2D arrays feat: added support for icon to upload with nuget package docs: improved documentation refactor: changed some names to be more precise refactor: adjusted namespacing --- ...onMethodEnum.cs => NormalizationMethod.cs} | 2 +- .../Extensions/EnumerableExtentions.cs | 21 +++++ .../Mcda/Abstraction/ICalculation.cs | 19 ++++ .../Mcda/Abstraction/IMcdaMethod.cs | 9 ++ .../Mcda/Abstraction/McdaMethod.cs | 90 +++++++++++++++++++ src/McdaToolkit/Mcda/Contracts/MatrixDto.cs | 8 ++ .../Errors/ArraySizesAreNotEqual.cs | 2 +- .../CriteriaNotBetweenMinusOneAndOne.cs | 2 +- .../Errors/WeightNotSumToOneError.cs | 2 +- .../Helpers/CheckDataHelper.cs | 7 +- .../Methods/Topsis.cs} | 31 +++---- .../McdaMethods/Abstraction/McdaMethod.cs | 59 ------------ .../McdaMethods/Interfaces/IMethod.cs | 9 -- src/McdaToolkit/McdaToolkit.csproj | 2 + .../Normalization/DataNormalizationService.cs | 25 ------ .../Interfaces/IDataNormalization.cs | 8 -- .../Abstraction/INormalizationMethod.cs | 9 ++ .../Abstraction/IVectorNormalizator.cs | 19 ++++ .../Methods/Linear/MaxNormalization.cs | 17 ++++ .../Methods}/Linear/MinMaxNormalization.cs | 15 +--- .../Methods}/Linear/SumNormalization.cs | 7 +- .../Methods/Sum/LogarithmicNormalization.cs | 21 +++++ .../Methods/Sum/VectorNormalization.cs | 18 ++++ .../IMatrixNormalizationService.cs | 10 +++ .../Abstraction/IMatrixNormalizator.cs | 17 ++++ .../Service/MatrixNormalizatorService.cs | 42 +++++++++ .../Service/NormalizationServiceErrors.cs | 8 ++ src/McdaToolkit/NormalizationMethodFactory.cs | 24 +++-- .../Interfaces/INormalize.cs | 15 ---- .../Types/Linear/MaxNormalization.cs | 25 ------ .../Types/Sum/LogarithmicNormalization.cs | 28 ------ .../Types/Sum/VectorNormalization.cs | 27 ------ src/McdaToolkit/Options/McdaMethodOptions.cs | 7 +- .../McdaToolkit.UnitTests/McdaMethodsTests.cs | 43 ++++++--- .../NormalizationUnitTests.cs | 19 ++-- 35 files changed, 391 insertions(+), 276 deletions(-) rename src/McdaToolkit/Enums/{NormalizationMethodEnum.cs => NormalizationMethod.cs} (72%) create mode 100644 src/McdaToolkit/Mcda/Abstraction/ICalculation.cs create mode 100644 src/McdaToolkit/Mcda/Abstraction/IMcdaMethod.cs create mode 100644 src/McdaToolkit/Mcda/Abstraction/McdaMethod.cs create mode 100644 src/McdaToolkit/Mcda/Contracts/MatrixDto.cs rename src/McdaToolkit/{McdaMethods => Mcda}/Errors/ArraySizesAreNotEqual.cs (78%) rename src/McdaToolkit/{McdaMethods => Mcda}/Errors/CriteriaNotBetweenMinusOneAndOne.cs (76%) rename src/McdaToolkit/{McdaMethods => Mcda}/Errors/WeightNotSumToOneError.cs (71%) rename src/McdaToolkit/{McdaMethods => Mcda}/Helpers/CheckDataHelper.cs (78%) rename src/McdaToolkit/{McdaMethods/TopsisMethod.cs => Mcda/Methods/Topsis.cs} (68%) delete mode 100644 src/McdaToolkit/McdaMethods/Abstraction/McdaMethod.cs delete mode 100644 src/McdaToolkit/McdaMethods/Interfaces/IMethod.cs delete mode 100644 src/McdaToolkit/Normalization/DataNormalizationService.cs delete mode 100644 src/McdaToolkit/Normalization/Interfaces/IDataNormalization.cs create mode 100644 src/McdaToolkit/Normalization/Methods/Abstraction/INormalizationMethod.cs create mode 100644 src/McdaToolkit/Normalization/Methods/Abstraction/IVectorNormalizator.cs create mode 100644 src/McdaToolkit/Normalization/Methods/Linear/MaxNormalization.cs rename src/McdaToolkit/{NormalizationMethods/Types => Normalization/Methods}/Linear/MinMaxNormalization.cs (53%) rename src/McdaToolkit/{NormalizationMethods/Types => Normalization/Methods}/Linear/SumNormalization.cs (52%) create mode 100644 src/McdaToolkit/Normalization/Methods/Sum/LogarithmicNormalization.cs create mode 100644 src/McdaToolkit/Normalization/Methods/Sum/VectorNormalization.cs create mode 100644 src/McdaToolkit/Normalization/Service/Abstraction/IMatrixNormalizationService.cs create mode 100644 src/McdaToolkit/Normalization/Service/Abstraction/IMatrixNormalizator.cs create mode 100644 src/McdaToolkit/Normalization/Service/MatrixNormalizatorService.cs create mode 100644 src/McdaToolkit/Normalization/Service/NormalizationServiceErrors.cs delete mode 100644 src/McdaToolkit/NormalizationMethods/Interfaces/INormalize.cs delete mode 100644 src/McdaToolkit/NormalizationMethods/Types/Linear/MaxNormalization.cs delete mode 100644 src/McdaToolkit/NormalizationMethods/Types/Sum/LogarithmicNormalization.cs delete mode 100644 src/McdaToolkit/NormalizationMethods/Types/Sum/VectorNormalization.cs diff --git a/src/McdaToolkit/Enums/NormalizationMethodEnum.cs b/src/McdaToolkit/Enums/NormalizationMethod.cs similarity index 72% rename from src/McdaToolkit/Enums/NormalizationMethodEnum.cs rename to src/McdaToolkit/Enums/NormalizationMethod.cs index fa8bb98..a34afc7 100644 --- a/src/McdaToolkit/Enums/NormalizationMethodEnum.cs +++ b/src/McdaToolkit/Enums/NormalizationMethod.cs @@ -1,6 +1,6 @@ namespace McdaToolkit.Enums; -public enum NormalizationMethodEnum +public enum NormalizationMethod { MinMax, Vector, diff --git a/src/McdaToolkit/Extensions/EnumerableExtentions.cs b/src/McdaToolkit/Extensions/EnumerableExtentions.cs index 4d2848d..4e6ee74 100644 --- a/src/McdaToolkit/Extensions/EnumerableExtentions.cs +++ b/src/McdaToolkit/Extensions/EnumerableExtentions.cs @@ -16,4 +16,25 @@ internal static class EnumerableExtentions ++i; } } + + public static T[,] To2DArray(this IEnumerable> source) + { + var sourceToArray = source.ToArray(); + var rows = sourceToArray.Length; + var cols = sourceToArray.First().Count(); + var result = new T[rows, cols]; + var i = 0; + + foreach (var row in sourceToArray) + { + var j = 0; + foreach (var value in row) + { + result[i, j] = value; + j++; + } + i++; + } + return result; + } } \ No newline at end of file diff --git a/src/McdaToolkit/Mcda/Abstraction/ICalculation.cs b/src/McdaToolkit/Mcda/Abstraction/ICalculation.cs new file mode 100644 index 0000000..b55c479 --- /dev/null +++ b/src/McdaToolkit/Mcda/Abstraction/ICalculation.cs @@ -0,0 +1,19 @@ +using System.Collections; +using LightResults; +using MathNet.Numerics.LinearAlgebra; +using MathNet.Numerics.LinearAlgebra.Double; + +namespace McdaToolkit.Mcda.Abstraction; + +public interface ICalculation where TValue : struct, IEquatable, IFormattable +{ + /// + /// Calculate provided data + /// + /// Data as set of alternatives and theirs attributes + /// Data determining relevance of each attribute + /// Data that determines the columns is profit or cost + /// Vector of processed data in descending order + Result> Calculate(IEnumerable> matrix, IEnumerable weights, IEnumerable criteriaDirections); +} + diff --git a/src/McdaToolkit/Mcda/Abstraction/IMcdaMethod.cs b/src/McdaToolkit/Mcda/Abstraction/IMcdaMethod.cs new file mode 100644 index 0000000..231af5b --- /dev/null +++ b/src/McdaToolkit/Mcda/Abstraction/IMcdaMethod.cs @@ -0,0 +1,9 @@ +namespace McdaToolkit.Mcda.Abstraction; + +/// +/// Marker interface indicates mcda method abstraction +/// +public interface IMcdaMethod : ICalculation +{ + +} \ No newline at end of file diff --git a/src/McdaToolkit/Mcda/Abstraction/McdaMethod.cs b/src/McdaToolkit/Mcda/Abstraction/McdaMethod.cs new file mode 100644 index 0000000..3a616b5 --- /dev/null +++ b/src/McdaToolkit/Mcda/Abstraction/McdaMethod.cs @@ -0,0 +1,90 @@ +using LightResults; +using MathNet.Numerics.LinearAlgebra; +using MathNet.Numerics.LinearAlgebra.Double; +using McdaToolkit.Extensions; +using McdaToolkit.Mcda.Contracts; +using McdaToolkit.Mcda.Errors; +using McdaToolkit.Mcda.Helpers; + +namespace McdaToolkit.Mcda.Abstraction; + +public abstract class McdaMethod : IMcdaMethod +{ + #region Private methods + private Result InitialErrorsCheck(double[,] matrix, double[] weights, int[] criteriaDirections) + { + if (weights == null) + { + throw new ArgumentNullException(nameof(weights), "Value cannot be null"); + } + + if (criteriaDirections == null) + { + throw new ArgumentNullException(nameof(criteriaDirections), "Value cannot be null"); + } + + var isWeightsCorrect = CheckDataHelper.IsWeightEqualOne(weights); + + if (!isWeightsCorrect) + { + return Result.Fail(new WeightNotSumToOneError()); + } + + var isCriteriaDecisionCorrect = CheckDataHelper.IsCriteriaDesisionBetweenMinusOneAndOne(criteriaDirections); + + if (!isCriteriaDecisionCorrect) + { + return Result.Fail(new CriteriaNotBetweenMinusOneAndOne()); + } + + var isSizesAreCorrect = CheckDataHelper.IsDataWeightsAndTypesHaveCorrectSizes(matrix, weights, criteriaDirections); + + if (!isSizesAreCorrect) + { + return Result.Fail(new ArraySizesAreNotEqual()); + } + + return Result.Ok(); + } + private Result CheckMatrix(double[,] matrix, double[] weights, int[] criteriaDirections) + { + var errorsCheckResult = InitialErrorsCheck(matrix,weights, criteriaDirections); + + return errorsCheckResult.IsFailed ? errorsCheckResult : Result.Ok(); + } + private MatrixDto PrepareMatrix(IEnumerable> matrix, IEnumerable weights, IEnumerable criteriaDirections) + { + var matrix2D = matrix.To2DArray(); + var weightsArray = weights.ToArray(); + var criteriaDirectionsArray = criteriaDirections.ToArray(); + + return new(matrix2D, weightsArray, criteriaDirectionsArray); + } + #endregion + + #region Protected methods + protected abstract Result> RunCalculation(Matrix matrix, Vector weights, int[] criteriaDirections); + #endregion + + #region Public methods + /// + public Result> Calculate(IEnumerable> matrix, IEnumerable weights, IEnumerable criteriaDirections) + { + var matrixDto = PrepareMatrix(matrix, weights, criteriaDirections); + return Calculate(matrixDto.Matrix, matrixDto.Weights, matrixDto.CriteriaDecision); + } + /// + public Result> Calculate(double[,] matrix, double[] weights, int[] criteriaDirections) + { + var checkMatrixResult = CheckMatrix(matrix,weights,criteriaDirections); + if (checkMatrixResult.IsFailed) + { + return Result>.Fail(new Error()); + } + + var finalMatrix = Matrix.Build.DenseOfArray(matrix); + var weightsVector = Vector.Build.DenseOfArray(weights); + return RunCalculation(finalMatrix,weightsVector,criteriaDirections); + } + #endregion +} \ No newline at end of file diff --git a/src/McdaToolkit/Mcda/Contracts/MatrixDto.cs b/src/McdaToolkit/Mcda/Contracts/MatrixDto.cs new file mode 100644 index 0000000..04880ce --- /dev/null +++ b/src/McdaToolkit/Mcda/Contracts/MatrixDto.cs @@ -0,0 +1,8 @@ +namespace McdaToolkit.Mcda.Contracts; + +internal record MatrixDto(double[,] Matrix, double[] Weights, int[] CriteriaDecision) +{ + public double[,] Matrix { get; } = Matrix; + public double[] Weights { get; } = Weights; + public int[] CriteriaDecision { get; } = CriteriaDecision; +} \ No newline at end of file diff --git a/src/McdaToolkit/McdaMethods/Errors/ArraySizesAreNotEqual.cs b/src/McdaToolkit/Mcda/Errors/ArraySizesAreNotEqual.cs similarity index 78% rename from src/McdaToolkit/McdaMethods/Errors/ArraySizesAreNotEqual.cs rename to src/McdaToolkit/Mcda/Errors/ArraySizesAreNotEqual.cs index d7ad7b2..d9439ca 100644 --- a/src/McdaToolkit/McdaMethods/Errors/ArraySizesAreNotEqual.cs +++ b/src/McdaToolkit/Mcda/Errors/ArraySizesAreNotEqual.cs @@ -1,5 +1,5 @@ using LightResults; -namespace McdaToolkit.McdaMethods.Errors; +namespace McdaToolkit.Mcda.Errors; public class ArraySizesAreNotEqual() : Error("Columns length of data matrix should be equal length of weights and types arrays"); \ No newline at end of file diff --git a/src/McdaToolkit/McdaMethods/Errors/CriteriaNotBetweenMinusOneAndOne.cs b/src/McdaToolkit/Mcda/Errors/CriteriaNotBetweenMinusOneAndOne.cs similarity index 76% rename from src/McdaToolkit/McdaMethods/Errors/CriteriaNotBetweenMinusOneAndOne.cs rename to src/McdaToolkit/Mcda/Errors/CriteriaNotBetweenMinusOneAndOne.cs index b7dba8b..3257a4c 100644 --- a/src/McdaToolkit/McdaMethods/Errors/CriteriaNotBetweenMinusOneAndOne.cs +++ b/src/McdaToolkit/Mcda/Errors/CriteriaNotBetweenMinusOneAndOne.cs @@ -1,5 +1,5 @@ using LightResults; -namespace McdaToolkit.McdaMethods.Errors; +namespace McdaToolkit.Mcda.Errors; public class CriteriaNotBetweenMinusOneAndOne() : Error("Criteria decision types should be number ∈Z{-1;1}"); \ No newline at end of file diff --git a/src/McdaToolkit/McdaMethods/Errors/WeightNotSumToOneError.cs b/src/McdaToolkit/Mcda/Errors/WeightNotSumToOneError.cs similarity index 71% rename from src/McdaToolkit/McdaMethods/Errors/WeightNotSumToOneError.cs rename to src/McdaToolkit/Mcda/Errors/WeightNotSumToOneError.cs index 4c05572..555a3f3 100644 --- a/src/McdaToolkit/McdaMethods/Errors/WeightNotSumToOneError.cs +++ b/src/McdaToolkit/Mcda/Errors/WeightNotSumToOneError.cs @@ -1,5 +1,5 @@ using LightResults; -namespace McdaToolkit.McdaMethods.Errors; +namespace McdaToolkit.Mcda.Errors; public class WeightNotSumToOneError() : Error("Sum of weight have to equal 1"); \ No newline at end of file diff --git a/src/McdaToolkit/McdaMethods/Helpers/CheckDataHelper.cs b/src/McdaToolkit/Mcda/Helpers/CheckDataHelper.cs similarity index 78% rename from src/McdaToolkit/McdaMethods/Helpers/CheckDataHelper.cs rename to src/McdaToolkit/Mcda/Helpers/CheckDataHelper.cs index 0149521..4f141d9 100644 --- a/src/McdaToolkit/McdaMethods/Helpers/CheckDataHelper.cs +++ b/src/McdaToolkit/Mcda/Helpers/CheckDataHelper.cs @@ -1,9 +1,6 @@ -using LightResults; -using MathNet.Numerics; -using MathNet.Numerics.LinearAlgebra; -using McdaToolkit.McdaMethods.Errors; +using MathNet.Numerics; -namespace McdaToolkit.McdaMethods.Helpers; +namespace McdaToolkit.Mcda.Helpers; public static class CheckDataHelper { diff --git a/src/McdaToolkit/McdaMethods/TopsisMethod.cs b/src/McdaToolkit/Mcda/Methods/Topsis.cs similarity index 68% rename from src/McdaToolkit/McdaMethods/TopsisMethod.cs rename to src/McdaToolkit/Mcda/Methods/Topsis.cs index 6c69fc6..32d0daa 100644 --- a/src/McdaToolkit/McdaMethods/TopsisMethod.cs +++ b/src/McdaToolkit/Mcda/Methods/Topsis.cs @@ -1,31 +1,24 @@ using LightResults; using MathNet.Numerics.LinearAlgebra; -using McdaToolkit.Enums; -using McdaToolkit.McdaMethods.Abstraction; -using McdaToolkit.Normalization; -using McdaToolkit.Normalization.Interfaces; +using McdaToolkit.Mcda.Abstraction; +using McdaToolkit.Normalization.Service; +using McdaToolkit.Normalization.Service.Abstraction; using McdaToolkit.Options; -namespace McdaToolkit.McdaMethods; +namespace McdaToolkit.Mcda.Methods; -public class TopsisMethod : McdaMethod +public sealed class Topsis : McdaMethod { - private readonly IDataNormalization _normalizationServiceService; - - public TopsisMethod() - { - _normalizationServiceService = new DataNormalizationService(NormalizationMethodEnum.MinMax); - } - - public TopsisMethod(McdaMethodOptions options) + private readonly IMatrixNormalizationService _normalizationServiceServiceService; + + public Topsis(McdaMethodOptions options) { - _normalizationServiceService = new DataNormalizationService(options.NormalizationMethodEnum); + _normalizationServiceServiceService = new MatrixNormalizatorService(options.NormalizationMethod); } - protected override Result> Calculate(Matrix matrix, double[] weights, - int[] criteriaDirections) + protected override Result> RunCalculation(Matrix matrix, Vector weights, int[] criteriaDirections) { - var normalizedMatrix = _normalizationServiceService.NormalizeMatrix(matrix, criteriaDirections); + var normalizedMatrix = _normalizationServiceServiceService.NormalizeMatrix(matrix, criteriaDirections); var weightedMatrix = WeightedMatrix(normalizedMatrix, weights); var idealBest = IdealValues(weightedMatrix, true); @@ -38,7 +31,7 @@ protected override Result> Calculate(Matrix matrix, doubl return Result.Ok(topsisScores); } - private Matrix WeightedMatrix(Matrix matrix, double[] weights) + private Matrix WeightedMatrix(Matrix matrix, Vector weights) { for (int i = 0; i < matrix.RowCount; i++) { diff --git a/src/McdaToolkit/McdaMethods/Abstraction/McdaMethod.cs b/src/McdaToolkit/McdaMethods/Abstraction/McdaMethod.cs deleted file mode 100644 index 68d5cc7..0000000 --- a/src/McdaToolkit/McdaMethods/Abstraction/McdaMethod.cs +++ /dev/null @@ -1,59 +0,0 @@ -using LightResults; -using MathNet.Numerics.LinearAlgebra; -using McdaToolkit.McdaMethods.Errors; -using McdaToolkit.McdaMethods.Helpers; -using McdaToolkit.McdaMethods.Interfaces; - -namespace McdaToolkit.McdaMethods.Abstraction; - -public abstract class McdaMethod : IMethod -{ - private Result InitialErrorsCheck(double[,] matrix, double[] weights, int[] criteriaDirections) - { - if (weights == null) - { - throw new ArgumentNullException(nameof(weights), "Value cannot be null"); - } - - if (criteriaDirections == null) - { - throw new ArgumentNullException(nameof(criteriaDirections), "Value cannot be null"); - } - - var isWeightsCorrect = CheckDataHelper.IsWeightEqualOne(weights); - - if (!isWeightsCorrect) - { - return Result.Fail(new WeightNotSumToOneError()); - } - - var isCriteriaDecisionCorrect = CheckDataHelper.IsCriteriaDesisionBetweenMinusOneAndOne(criteriaDirections); - - if (!isCriteriaDecisionCorrect) - { - return Result.Fail(new CriteriaNotBetweenMinusOneAndOne()); - } - - var isSizesAreCorrect = CheckDataHelper.IsDataWeightsAndTypesHaveCorrectSizes(matrix, weights, criteriaDirections); - - if (!isSizesAreCorrect) - { - return Result.Fail(new ArraySizesAreNotEqual()); - } - - return Result.Ok(); - } - public Result> Calculate(double[,] matrix, double[] weights, int[] criteriaDirections) - { - var errorsCheckResult = InitialErrorsCheck(matrix,weights, criteriaDirections); - - if (errorsCheckResult.IsFailed) - { - return Result.Fail>(errorsCheckResult.Errors); - } - - var matrixTypeOfMatrix = Matrix.Build.DenseOfArray(matrix); - return Calculate(matrixTypeOfMatrix, weights, criteriaDirections); - } - protected abstract Result> Calculate(Matrix matrix, double[] weights, int[] criteriaDirections); -} \ No newline at end of file diff --git a/src/McdaToolkit/McdaMethods/Interfaces/IMethod.cs b/src/McdaToolkit/McdaMethods/Interfaces/IMethod.cs deleted file mode 100644 index 4639692..0000000 --- a/src/McdaToolkit/McdaMethods/Interfaces/IMethod.cs +++ /dev/null @@ -1,9 +0,0 @@ -using LightResults; -using MathNet.Numerics.LinearAlgebra; - -namespace McdaToolkit.McdaMethods.Interfaces; - -public interface IMethod -{ - Result> Calculate(double[,] matrix, double[] weights, int[] criteriaDirections); -} \ No newline at end of file diff --git a/src/McdaToolkit/McdaToolkit.csproj b/src/McdaToolkit/McdaToolkit.csproj index c19e179..90bc43b 100644 --- a/src/McdaToolkit/McdaToolkit.csproj +++ b/src/McdaToolkit/McdaToolkit.csproj @@ -15,10 +15,12 @@ © 2024 Jakub Tokarczyk MIT https://github.com/SarcasticMoose/mcda-toolkit + icon.png + diff --git a/src/McdaToolkit/Normalization/DataNormalizationService.cs b/src/McdaToolkit/Normalization/DataNormalizationService.cs deleted file mode 100644 index 9aabfda..0000000 --- a/src/McdaToolkit/Normalization/DataNormalizationService.cs +++ /dev/null @@ -1,25 +0,0 @@ - -using MathNet.Numerics.LinearAlgebra; -using McdaToolkit.Enums; -using McdaToolkit.Extensions; -using McdaToolkit.Normalization.Interfaces; -using McdaToolkit.NormalizationMethods.Interfaces; -namespace McdaToolkit.Normalization; - - -public class DataNormalizationService(NormalizationMethodEnum methodEnum) : IDataNormalization -{ - private readonly INormalize _method = NormalizationMethodFactory.Create(methodEnum); - - public Matrix NormalizeMatrix(Matrix matrix, int[] criteriaTypes) - { - foreach (var (col,index) in matrix.EnumerateColumns().Indexed()) - { - matrix.SetColumn(index, - criteriaTypes[index] == 1 - ? _method.Normalize(data: col, cost: false) - : _method.Normalize(data: col, cost: true)); - } - return matrix; - } -} diff --git a/src/McdaToolkit/Normalization/Interfaces/IDataNormalization.cs b/src/McdaToolkit/Normalization/Interfaces/IDataNormalization.cs deleted file mode 100644 index ef571b4..0000000 --- a/src/McdaToolkit/Normalization/Interfaces/IDataNormalization.cs +++ /dev/null @@ -1,8 +0,0 @@ -using MathNet.Numerics.LinearAlgebra; - -namespace McdaToolkit.Normalization.Interfaces; - -public interface IDataNormalization -{ - Matrix NormalizeMatrix(Matrix matrix, int[] criteriaTypes); -} \ No newline at end of file diff --git a/src/McdaToolkit/Normalization/Methods/Abstraction/INormalizationMethod.cs b/src/McdaToolkit/Normalization/Methods/Abstraction/INormalizationMethod.cs new file mode 100644 index 0000000..87ccce5 --- /dev/null +++ b/src/McdaToolkit/Normalization/Methods/Abstraction/INormalizationMethod.cs @@ -0,0 +1,9 @@ +namespace McdaToolkit.Normalization.Methods.Abstraction; + +/// +/// Marker interface indicates normalization method abstraction +/// +internal interface INormalizationMethod : IVectorNormalizator +{ + +} \ No newline at end of file diff --git a/src/McdaToolkit/Normalization/Methods/Abstraction/IVectorNormalizator.cs b/src/McdaToolkit/Normalization/Methods/Abstraction/IVectorNormalizator.cs new file mode 100644 index 0000000..741e3b5 --- /dev/null +++ b/src/McdaToolkit/Normalization/Methods/Abstraction/IVectorNormalizator.cs @@ -0,0 +1,19 @@ +using MathNet.Numerics.LinearAlgebra; + +namespace McdaToolkit.Normalization.Methods.Abstraction; + +/// +/// Vector normalization generic abstraction +/// +internal interface IVectorNormalizator where T : struct, IEquatable, IFormattable +{ + /// + /// Normalize provided vector + /// + /// One-dimensional vector of data to normalize + /// Describe type of vector, cost or profit + /// + /// Return normalized vector + /// + Vector Normalize(Vector data, bool cost); +} \ No newline at end of file diff --git a/src/McdaToolkit/Normalization/Methods/Linear/MaxNormalization.cs b/src/McdaToolkit/Normalization/Methods/Linear/MaxNormalization.cs new file mode 100644 index 0000000..26848b8 --- /dev/null +++ b/src/McdaToolkit/Normalization/Methods/Linear/MaxNormalization.cs @@ -0,0 +1,17 @@ +using MathNet.Numerics.LinearAlgebra; +using McdaToolkit.Normalization.Methods.Abstraction; + +namespace McdaToolkit.Normalization.Methods.Linear; + +internal class MaxNormalization : INormalizationMethod +{ + /// + public Vector Normalize(Vector data, bool cost) + { + if (cost) + { + return 1 - data / data.Maximum(); + } + return data / data.Maximum(); + } +} \ No newline at end of file diff --git a/src/McdaToolkit/NormalizationMethods/Types/Linear/MinMaxNormalization.cs b/src/McdaToolkit/Normalization/Methods/Linear/MinMaxNormalization.cs similarity index 53% rename from src/McdaToolkit/NormalizationMethods/Types/Linear/MinMaxNormalization.cs rename to src/McdaToolkit/Normalization/Methods/Linear/MinMaxNormalization.cs index 8c51e73..f04fc5a 100644 --- a/src/McdaToolkit/NormalizationMethods/Types/Linear/MinMaxNormalization.cs +++ b/src/McdaToolkit/Normalization/Methods/Linear/MinMaxNormalization.cs @@ -1,20 +1,13 @@ using MathNet.Numerics.LinearAlgebra; -using McdaToolkit.NormalizationMethods.Interfaces; +using McdaToolkit.Normalization.Methods.Abstraction; -namespace McdaToolkit.NormalizationMethods.Types.Linear; +namespace McdaToolkit.Normalization.Methods.Linear; -internal class MinMaxNormalization : INormalize +internal class MinMaxNormalization : INormalizationMethod { private const double MaxTolerance = 1.11e-16; - /// - /// Create normalized vector using vector normalization method - /// - /// One-dimensional vector of data to normalize - /// Describe type of vector, cost or profit - /// - /// Return normalized vector - /// + /// public Vector Normalize(Vector data, bool cost = false) { var max = data.Maximum(); diff --git a/src/McdaToolkit/NormalizationMethods/Types/Linear/SumNormalization.cs b/src/McdaToolkit/Normalization/Methods/Linear/SumNormalization.cs similarity index 52% rename from src/McdaToolkit/NormalizationMethods/Types/Linear/SumNormalization.cs rename to src/McdaToolkit/Normalization/Methods/Linear/SumNormalization.cs index 8712aa6..8caf5ae 100644 --- a/src/McdaToolkit/NormalizationMethods/Types/Linear/SumNormalization.cs +++ b/src/McdaToolkit/Normalization/Methods/Linear/SumNormalization.cs @@ -1,10 +1,11 @@ using MathNet.Numerics.LinearAlgebra; -using McdaToolkit.NormalizationMethods.Interfaces; +using McdaToolkit.Normalization.Methods.Abstraction; -namespace McdaToolkit.NormalizationMethods.Types.Linear; +namespace McdaToolkit.Normalization.Methods.Linear; -internal class SumNormalization : INormalize +internal class SumNormalization : INormalizationMethod { + /// public Vector Normalize(Vector data, bool cost) { if (cost) diff --git a/src/McdaToolkit/Normalization/Methods/Sum/LogarithmicNormalization.cs b/src/McdaToolkit/Normalization/Methods/Sum/LogarithmicNormalization.cs new file mode 100644 index 0000000..08732bd --- /dev/null +++ b/src/McdaToolkit/Normalization/Methods/Sum/LogarithmicNormalization.cs @@ -0,0 +1,21 @@ +using MathNet.Numerics.LinearAlgebra; +using McdaToolkit.Normalization.Methods.Abstraction; + +namespace McdaToolkit.Normalization.Methods.Sum; + +internal class LogarithmicNormalization : INormalizationMethod +{ + /// + public Vector Normalize(Vector data, bool cost) + { + var product = data.Aggregate(1.0,(x,y) => x * y); + var exp = data.PointwiseLog() / Math.Log(product); + + if (cost) + { + return 1 - exp; + } + + return exp; + } +} \ No newline at end of file diff --git a/src/McdaToolkit/Normalization/Methods/Sum/VectorNormalization.cs b/src/McdaToolkit/Normalization/Methods/Sum/VectorNormalization.cs new file mode 100644 index 0000000..1025015 --- /dev/null +++ b/src/McdaToolkit/Normalization/Methods/Sum/VectorNormalization.cs @@ -0,0 +1,18 @@ +using MathNet.Numerics.LinearAlgebra; +using McdaToolkit.Normalization.Methods.Abstraction; + +namespace McdaToolkit.Normalization.Methods.Sum; + +internal class VectorNormalization : INormalizationMethod +{ + /// + public Vector Normalize(Vector data, bool cost) + { + var squaresOfSum = data / Math.Sqrt(data.PointwisePower(2).Sum()); + if (cost) + { + return 1 - squaresOfSum; + } + return squaresOfSum; + } +} \ No newline at end of file diff --git a/src/McdaToolkit/Normalization/Service/Abstraction/IMatrixNormalizationService.cs b/src/McdaToolkit/Normalization/Service/Abstraction/IMatrixNormalizationService.cs new file mode 100644 index 0000000..3444068 --- /dev/null +++ b/src/McdaToolkit/Normalization/Service/Abstraction/IMatrixNormalizationService.cs @@ -0,0 +1,10 @@ +using LightResults; +using McdaToolkit.Enums; + +namespace McdaToolkit.Normalization.Service.Abstraction; + +internal interface IMatrixNormalizationService : IMatrixNormalizator +{ + public NormalizationMethod GetCurrentNormalizationName { get; } + public Result ChangeNormalizationMethod(NormalizationMethod newMethod); +} \ No newline at end of file diff --git a/src/McdaToolkit/Normalization/Service/Abstraction/IMatrixNormalizator.cs b/src/McdaToolkit/Normalization/Service/Abstraction/IMatrixNormalizator.cs new file mode 100644 index 0000000..d2b7157 --- /dev/null +++ b/src/McdaToolkit/Normalization/Service/Abstraction/IMatrixNormalizator.cs @@ -0,0 +1,17 @@ +using MathNet.Numerics.LinearAlgebra; + +namespace McdaToolkit.Normalization.Service.Abstraction; + +/// +/// Matrix normalization generic abstraction +/// +internal interface IMatrixNormalizator where T : struct, IEquatable, IFormattable +{ + /// + /// Normalize provided matrix + /// + /// One-dimensional vector of data to normalize + /// Describe type of vector, cost or profit + /// Return normalized matrix + Matrix NormalizeMatrix(Matrix matrix, int[] criteriaTypes); +} \ No newline at end of file diff --git a/src/McdaToolkit/Normalization/Service/MatrixNormalizatorService.cs b/src/McdaToolkit/Normalization/Service/MatrixNormalizatorService.cs new file mode 100644 index 0000000..abcb8f0 --- /dev/null +++ b/src/McdaToolkit/Normalization/Service/MatrixNormalizatorService.cs @@ -0,0 +1,42 @@ +using LightResults; +using MathNet.Numerics.LinearAlgebra; +using McdaToolkit.Enums; +using McdaToolkit.Extensions; +using McdaToolkit.Normalization.Methods.Abstraction; +using McdaToolkit.Normalization.Service.Abstraction; + +namespace McdaToolkit.Normalization.Service; + +public sealed class MatrixNormalizatorService : IMatrixNormalizationService +{ + private IVectorNormalizator _vectorNormalizatorMethod; + + public MatrixNormalizatorService(NormalizationMethod name) + { + GetCurrentNormalizationName = name; + _vectorNormalizatorMethod = NormalizationMethodFactory.Create(GetCurrentNormalizationName); + } + + /// + public Matrix NormalizeMatrix(Matrix matrix, int[] criteriaTypes) + { + foreach (var (col, index) in matrix.EnumerateColumns().Indexed()) + matrix.SetColumn(columnIndex: index, + column: criteriaTypes[index] == 1 + ? _vectorNormalizatorMethod.Normalize(data: col, cost: false) + : _vectorNormalizatorMethod.Normalize(data: col, cost: true)); + return matrix; + } + + public NormalizationMethod GetCurrentNormalizationName { get; } + + public Result ChangeNormalizationMethod(NormalizationMethod newMethod) + { + if (newMethod == GetCurrentNormalizationName) + { + return Result.Fail(NormalizationServiceErrors.MethodsEqual()); + } + _vectorNormalizatorMethod = NormalizationMethodFactory.Create(newMethod); + return Result.Ok(); + } +} \ No newline at end of file diff --git a/src/McdaToolkit/Normalization/Service/NormalizationServiceErrors.cs b/src/McdaToolkit/Normalization/Service/NormalizationServiceErrors.cs new file mode 100644 index 0000000..53679af --- /dev/null +++ b/src/McdaToolkit/Normalization/Service/NormalizationServiceErrors.cs @@ -0,0 +1,8 @@ +using LightResults; + +namespace McdaToolkit.Normalization.Service; + +public static class NormalizationServiceErrors +{ + public static Error MethodsEqual() => new("New method have to be diffrent than current one"); +} \ No newline at end of file diff --git a/src/McdaToolkit/NormalizationMethodFactory.cs b/src/McdaToolkit/NormalizationMethodFactory.cs index 9cef4ac..f3d346a 100644 --- a/src/McdaToolkit/NormalizationMethodFactory.cs +++ b/src/McdaToolkit/NormalizationMethodFactory.cs @@ -1,23 +1,21 @@ -using System.Numerics; -using McdaToolkit.Enums; -using McdaToolkit.NormalizationMethods; -using McdaToolkit.NormalizationMethods.Interfaces; -using McdaToolkit.NormalizationMethods.Types.Linear; -using McdaToolkit.NormalizationMethods.Types.Sum; +using McdaToolkit.Enums; +using McdaToolkit.Normalization.Methods.Abstraction; +using McdaToolkit.Normalization.Methods.Linear; +using McdaToolkit.Normalization.Methods.Sum; namespace McdaToolkit; internal static class NormalizationMethodFactory { - public static INormalize Create(NormalizationMethodEnum methodEnum) + public static IVectorNormalizator Create(NormalizationMethod method) { - return methodEnum switch + return method switch { - NormalizationMethodEnum.MinMax => new MinMaxNormalization(), - NormalizationMethodEnum.Vector => new VectorNormalization(), - NormalizationMethodEnum.Logarithmic => new LogarithmicNormalization(), - NormalizationMethodEnum.Sum => new SumNormalization() , - NormalizationMethodEnum.Max => new MaxNormalization(), + NormalizationMethod.MinMax => new MinMaxNormalization(), + NormalizationMethod.Vector => new VectorNormalization(), + NormalizationMethod.Logarithmic => new LogarithmicNormalization(), + NormalizationMethod.Sum => new SumNormalization(), + NormalizationMethod.Max => new MaxNormalization(), _ => throw new Exception("Not existing normalization") }; } diff --git a/src/McdaToolkit/NormalizationMethods/Interfaces/INormalize.cs b/src/McdaToolkit/NormalizationMethods/Interfaces/INormalize.cs deleted file mode 100644 index 1cd5ade..0000000 --- a/src/McdaToolkit/NormalizationMethods/Interfaces/INormalize.cs +++ /dev/null @@ -1,15 +0,0 @@ -using MathNet.Numerics.LinearAlgebra; - -namespace McdaToolkit.NormalizationMethods.Interfaces; - - -public interface INormalize where T : struct, IEquatable, IFormattable -{ - /// - /// Normalize vector of data - /// - /// - /// - /// One-dimensional vector contains normalized values - Vector Normalize(Vector data, bool cost); -} \ No newline at end of file diff --git a/src/McdaToolkit/NormalizationMethods/Types/Linear/MaxNormalization.cs b/src/McdaToolkit/NormalizationMethods/Types/Linear/MaxNormalization.cs deleted file mode 100644 index f52e033..0000000 --- a/src/McdaToolkit/NormalizationMethods/Types/Linear/MaxNormalization.cs +++ /dev/null @@ -1,25 +0,0 @@ -using MathNet.Numerics.LinearAlgebra; -using McdaToolkit.NormalizationMethods.Interfaces; - -namespace McdaToolkit.NormalizationMethods.Types.Linear; - -internal class MaxNormalization : INormalize -{ - /// - /// Create normalized vector using max normalization method - /// - /// One-dimensional vector of data to normalize - /// Describe type of vector, cost or profit - /// - /// Return normalized vector - /// - public Vector Normalize(Vector data, bool cost) - { - if (cost) - { - return 1 - data / data.Maximum(); - } - - return data / data.Maximum(); - } -} \ No newline at end of file diff --git a/src/McdaToolkit/NormalizationMethods/Types/Sum/LogarithmicNormalization.cs b/src/McdaToolkit/NormalizationMethods/Types/Sum/LogarithmicNormalization.cs deleted file mode 100644 index d674dd3..0000000 --- a/src/McdaToolkit/NormalizationMethods/Types/Sum/LogarithmicNormalization.cs +++ /dev/null @@ -1,28 +0,0 @@ -using MathNet.Numerics.LinearAlgebra; -using McdaToolkit.NormalizationMethods.Interfaces; - -namespace McdaToolkit.NormalizationMethods.Types.Sum; - -internal class LogarithmicNormalization : INormalize -{ - /// - /// Create normalized vector using logarithmic normalization method - /// - /// One-dimensional vector of data to normalize - /// Describe type of vector, cost or profit - /// - /// Return normalized vector - /// - public Vector Normalize(Vector data, bool cost) - { - var product = data.Aggregate(1.0,(x,y) => x * y); - var exp = data.PointwiseLog() / Math.Log(product); - - if (cost) - { - return 1 - exp; - } - - return exp; - } -} \ No newline at end of file diff --git a/src/McdaToolkit/NormalizationMethods/Types/Sum/VectorNormalization.cs b/src/McdaToolkit/NormalizationMethods/Types/Sum/VectorNormalization.cs deleted file mode 100644 index bf2329e..0000000 --- a/src/McdaToolkit/NormalizationMethods/Types/Sum/VectorNormalization.cs +++ /dev/null @@ -1,27 +0,0 @@ -using MathNet.Numerics.LinearAlgebra; -using McdaToolkit.NormalizationMethods.Interfaces; - -namespace McdaToolkit.NormalizationMethods.Types.Sum; - -public class VectorNormalization : INormalize -{ - /// - /// Create normalized vector using vector normalization method - /// - /// One-dimensional vector of data to normalize - /// Describe type of vector, cost or profit - /// - /// Return normalized vector - /// - public Vector Normalize(Vector data, bool cost) - { - var squaresOfSum = data / Math.Sqrt(data.PointwisePower(2).Sum()); - - if (cost) - { - return 1 - squaresOfSum; - } - - return squaresOfSum; - } -} \ No newline at end of file diff --git a/src/McdaToolkit/Options/McdaMethodOptions.cs b/src/McdaToolkit/Options/McdaMethodOptions.cs index ebbd381..5bea2d4 100644 --- a/src/McdaToolkit/Options/McdaMethodOptions.cs +++ b/src/McdaToolkit/Options/McdaMethodOptions.cs @@ -2,7 +2,10 @@ namespace McdaToolkit.Options; -public class McdaMethodOptions +/// +/// Configuration for Mcda methods +/// +public record McdaMethodOptions { - public NormalizationMethodEnum NormalizationMethodEnum { get; set; } = NormalizationMethodEnum.MinMax; + public NormalizationMethod NormalizationMethod { get; set; } = NormalizationMethod.MinMax; } \ No newline at end of file diff --git a/tests/McdaToolkit.UnitTests/McdaMethodsTests.cs b/tests/McdaToolkit.UnitTests/McdaMethodsTests.cs index 5b512f7..1bad1e2 100644 --- a/tests/McdaToolkit.UnitTests/McdaMethodsTests.cs +++ b/tests/McdaToolkit.UnitTests/McdaMethodsTests.cs @@ -1,7 +1,9 @@ using FluentAssertions; using MathNet.Numerics; -using McdaToolkit.McdaMethods; -using McdaToolkit.McdaMethods.Errors; +using McdaToolkit.Enums; +using McdaToolkit.Mcda.Errors; +using McdaToolkit.Mcda.Methods; +using McdaToolkit.Options; using Xunit.Abstractions; namespace McdaToolkit.UnitTests; @@ -42,7 +44,11 @@ public void Calculate_TopsisMethod_ShouldBeEqualToExpected() 0.38805147,0.76189759,0.58509479,0.06374247,0.97647059,0.43681786 }; - var topsis = new TopsisMethod(); + var topsis = new Topsis(new McdaMethodOptions() + { + NormalizationMethod = NormalizationMethod.MinMax + }); + var topsisResult = topsis.Calculate(matrix,weights,types); var final = topsisResult.Value; @@ -56,8 +62,7 @@ public void Calculate_TopsisMethod_ShouldBeEqualToExpected() [Fact] public void Calculate_WeightAreNotEqualOne_ShouldReturnResultFail() { - var matrix = new double[,] - { + double[,] matrix = { { 66, 56, 95 }, { 61, 55, 166 }, { 65, 49, 113 }, @@ -65,18 +70,21 @@ public void Calculate_WeightAreNotEqualOne_ShouldReturnResultFail() { 63, 43, 178 }, { 74, 59, 140 }, }; - double[] weights = new double[] - { + double[] weights = + [ 0.8,0.25,0.35 - }; - int[] types = new int[] - { + ]; + int[] types = + [ -1, -1, 1 - }; + ]; - var topsis = new TopsisMethod(); + var topsis = new Topsis(new McdaMethodOptions() + { + NormalizationMethod = NormalizationMethod.MinMax + }); var topsisResult = topsis.Calculate(matrix, weights, types); topsisResult.IsSuccess.Should().BeFalse(); @@ -106,7 +114,11 @@ public void Calculate_DecisionCriteriaAreNotBetweenMinusOneAndOne_ShouldReturnRe 1 }; - var topsis = new TopsisMethod(); + var topsis = new Topsis(new McdaMethodOptions() + { + NormalizationMethod = NormalizationMethod.MinMax + }); + var topsisResult = topsis.Calculate(matrix, weights, types); topsisResult.IsSuccess.Should().BeFalse(); @@ -137,7 +149,10 @@ public void Calculate_DimensionsOfAllMatrixesNotTheSame_ShouldReturnResultFail() 1 }; - var topsis = new TopsisMethod(); + var topsis = new Topsis(new McdaMethodOptions() + { + NormalizationMethod = NormalizationMethod.MinMax + }); var topsisResult = topsis.Calculate(matrix, weights, types); topsisResult.IsSuccess.Should().BeFalse(); diff --git a/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs b/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs index 97d413d..12f623d 100644 --- a/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs +++ b/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs @@ -2,6 +2,7 @@ using MathNet.Numerics.LinearAlgebra; using McdaToolkit.Enums; using McdaToolkit.Normalization; +using McdaToolkit.Normalization.Service; using McdaToolkit.UnitTests.Helpers; namespace McdaToolkit.UnitTests; @@ -34,7 +35,7 @@ public void Normalize_MinMaxNormalization_ShouldReturnedExpectedValues() [0.11039597, 0, 0.08755156, 0, 0.44336262], [0.70728977, 0.84765765, 0.29790026, 0.73317899, 0.67323676] }; - var dataNormalization = new DataNormalizationService(NormalizationMethodEnum.MinMax); + var dataNormalization = new MatrixNormalizatorService(NormalizationMethod.MinMax); var normalizedMatrix = dataNormalization.NormalizeMatrix(_matrixToNormalize,_types); @@ -45,7 +46,7 @@ public void Normalize_MinMaxNormalization_ShouldReturnedExpectedValues() [Fact] public void Normalize_VectorNormalization_ShouldReturnedExpectedValues() { - var normalizationType = NormalizationMethodEnum.Vector; + var normalizationType = NormalizationMethod.Vector; var expected = new double[][] { [0.80678026, 0.90838501, 0.57002794, 0.32313221, 0.69529318], @@ -56,7 +57,7 @@ public void Normalize_VectorNormalization_ShouldReturnedExpectedValues() [0.49372513, 0.38052914, 0.25157913, 0.13449503, 0.59985358], [0.74680324, 0.82797021, 0.32499182, 0.42510755, 0.66144393] }; - var dataNormalization = new DataNormalizationService(normalizationType); + var dataNormalization = new MatrixNormalizatorService(normalizationType); var normalizedMatrix = dataNormalization.NormalizeMatrix(_matrixToNormalize,_types); @@ -67,7 +68,7 @@ public void Normalize_VectorNormalization_ShouldReturnedExpectedValues() [Fact] public void Normalize_Logarithmic_ShouldReturnedExpectedValues() { - var normalizationType = NormalizationMethodEnum.Logarithmic; + var normalizationType = NormalizationMethod.Logarithmic; var expected = new double[][] { [0.87403010, 0.89954564, 0.16128664, 0.14438272, 0.86315596], @@ -78,7 +79,7 @@ public void Normalize_Logarithmic_ShouldReturnedExpectedValues() [0.83919604, 0.82785947, 0.13175623, 0.11299010, 0.85351828], [0.86425385, 0.87591345, 0.14100037, 0.15420595, 0.85943008] }; - var dataNormalization = new DataNormalizationService(normalizationType); + var dataNormalization = new MatrixNormalizatorService(normalizationType); var normalizedMatrix = dataNormalization.NormalizeMatrix(_matrixToNormalize,_types); @@ -89,7 +90,7 @@ public void Normalize_Logarithmic_ShouldReturnedExpectedValues() [Fact] public void Normalize_Sum_ShouldReturnedExpectedValues() { - var normalizationType = NormalizationMethodEnum.Sum; + var normalizationType = NormalizationMethod.Sum; var expected = new double[][] { [0.19968511, 0.36006754, 0.22640921, 0.13248054, 0.16546924], @@ -100,7 +101,7 @@ public void Normalize_Sum_ShouldReturnedExpectedValues() [0.07620980, 0.05325123, 0.09992463, 0.05514144, 0.12600289], [0.15238388, 0.19175506, 0.12908340, 0.17428928, 0.14892543] }; - var dataNormalization = new DataNormalizationService(normalizationType); + var dataNormalization = new MatrixNormalizatorService(normalizationType); var normalizedMatrix = dataNormalization.NormalizeMatrix(_matrixToNormalize,_types); @@ -111,7 +112,7 @@ public void Normalize_Sum_ShouldReturnedExpectedValues() [Fact] public void Normalize_Max_ShouldReturnedExpectedValues() { - var normalizationType = NormalizationMethodEnum.Max; + var normalizationType = NormalizationMethod.Max; var expected = new double[][] { [0.65064893, 0.85210767, 1, 0.60868626, 0.41282491], @@ -122,7 +123,7 @@ public void Normalize_Max_ShouldReturnedExpectedValues() [0.08462941, 0, 0.44134527, 0.25334918, 0.22891123], [0.54220744, 0.72229558, 0.57013315, 0.80077787, 0.34759686] }; - var dataNormalization = new DataNormalizationService(normalizationType); + var dataNormalization = new MatrixNormalizatorService(normalizationType); var normalizedMatrix = dataNormalization.NormalizeMatrix(_matrixToNormalize,_types); From 3bde13c99db88c909f54d41ef822d095e5a35d62 Mon Sep 17 00:00:00 2001 From: SarcasticMoose Date: Thu, 15 Aug 2024 12:01:11 +0200 Subject: [PATCH 7/7] refactor: adjusted namespaces refactor: deleted unused code feat: added checker service --- .../Extensions/EnumerableExtentions.cs | 2 +- .../Mcda/Abstraction/IMcdaMethod.cs | 9 -- .../Mcda/Abstraction/McdaMethod.cs | 90 ------------ src/McdaToolkit/Mcda/Contracts/MatrixDto.cs | 8 -- .../Mcda/Errors/ArraySizesAreNotEqual.cs | 5 - .../CriteriaNotBetweenMinusOneAndOne.cs | 5 - ...DecisionCriteriaHaveIncorrectValueError.cs | 5 + ...nLengthNotEqualWeightsVectorLengthError.cs | 5 + .../Errors/WeightNotSumToOneError.cs | 2 +- .../{ => Methods}/Abstraction/ICalculation.cs | 4 +- .../Mcda/Methods/Abstraction/IMcdaMethod.cs | 6 + .../Mcda/Methods/Abstraction/McdaMethod.cs | 45 ++++++ src/McdaToolkit/Mcda/Methods/Topsis.cs | 40 +++--- .../{ => Mcda}/Options/McdaMethodOptions.cs | 5 +- .../Mcda/Services/MatrixCheckerService.cs | 30 ++++ src/McdaToolkit/McdaToolkit.csproj | 4 + .../MatrixCheckerTests.cs | 73 ++++++++++ .../McdaToolkit.UnitTests/McdaMethodsTests.cs | 129 +----------------- ...tionUnitTests.cs => NormalizationTests.cs} | 6 +- .../{Helpers => }/TestHelpers.cs | 2 +- 20 files changed, 202 insertions(+), 273 deletions(-) delete mode 100644 src/McdaToolkit/Mcda/Abstraction/IMcdaMethod.cs delete mode 100644 src/McdaToolkit/Mcda/Abstraction/McdaMethod.cs delete mode 100644 src/McdaToolkit/Mcda/Contracts/MatrixDto.cs delete mode 100644 src/McdaToolkit/Mcda/Errors/ArraySizesAreNotEqual.cs delete mode 100644 src/McdaToolkit/Mcda/Errors/CriteriaNotBetweenMinusOneAndOne.cs create mode 100644 src/McdaToolkit/Mcda/Helpers/Errors/DecisionCriteriaHaveIncorrectValueError.cs create mode 100644 src/McdaToolkit/Mcda/Helpers/Errors/MatrixColumnLengthNotEqualWeightsVectorLengthError.cs rename src/McdaToolkit/Mcda/{ => Helpers}/Errors/WeightNotSumToOneError.cs (70%) rename src/McdaToolkit/Mcda/{ => Methods}/Abstraction/ICalculation.cs (86%) create mode 100644 src/McdaToolkit/Mcda/Methods/Abstraction/IMcdaMethod.cs create mode 100644 src/McdaToolkit/Mcda/Methods/Abstraction/McdaMethod.cs rename src/McdaToolkit/{ => Mcda}/Options/McdaMethodOptions.cs (67%) create mode 100644 src/McdaToolkit/Mcda/Services/MatrixCheckerService.cs create mode 100644 tests/McdaToolkit.UnitTests/MatrixCheckerTests.cs rename tests/McdaToolkit.UnitTests/{NormalizationUnitTests.cs => NormalizationTests.cs} (97%) rename tests/McdaToolkit.UnitTests/{Helpers => }/TestHelpers.cs (95%) diff --git a/src/McdaToolkit/Extensions/EnumerableExtentions.cs b/src/McdaToolkit/Extensions/EnumerableExtentions.cs index 4e6ee74..4dd86b9 100644 --- a/src/McdaToolkit/Extensions/EnumerableExtentions.cs +++ b/src/McdaToolkit/Extensions/EnumerableExtentions.cs @@ -21,7 +21,7 @@ internal static class EnumerableExtentions { var sourceToArray = source.ToArray(); var rows = sourceToArray.Length; - var cols = sourceToArray.First().Count(); + var cols = sourceToArray[0].Count(); var result = new T[rows, cols]; var i = 0; diff --git a/src/McdaToolkit/Mcda/Abstraction/IMcdaMethod.cs b/src/McdaToolkit/Mcda/Abstraction/IMcdaMethod.cs deleted file mode 100644 index 231af5b..0000000 --- a/src/McdaToolkit/Mcda/Abstraction/IMcdaMethod.cs +++ /dev/null @@ -1,9 +0,0 @@ -namespace McdaToolkit.Mcda.Abstraction; - -/// -/// Marker interface indicates mcda method abstraction -/// -public interface IMcdaMethod : ICalculation -{ - -} \ No newline at end of file diff --git a/src/McdaToolkit/Mcda/Abstraction/McdaMethod.cs b/src/McdaToolkit/Mcda/Abstraction/McdaMethod.cs deleted file mode 100644 index 3a616b5..0000000 --- a/src/McdaToolkit/Mcda/Abstraction/McdaMethod.cs +++ /dev/null @@ -1,90 +0,0 @@ -using LightResults; -using MathNet.Numerics.LinearAlgebra; -using MathNet.Numerics.LinearAlgebra.Double; -using McdaToolkit.Extensions; -using McdaToolkit.Mcda.Contracts; -using McdaToolkit.Mcda.Errors; -using McdaToolkit.Mcda.Helpers; - -namespace McdaToolkit.Mcda.Abstraction; - -public abstract class McdaMethod : IMcdaMethod -{ - #region Private methods - private Result InitialErrorsCheck(double[,] matrix, double[] weights, int[] criteriaDirections) - { - if (weights == null) - { - throw new ArgumentNullException(nameof(weights), "Value cannot be null"); - } - - if (criteriaDirections == null) - { - throw new ArgumentNullException(nameof(criteriaDirections), "Value cannot be null"); - } - - var isWeightsCorrect = CheckDataHelper.IsWeightEqualOne(weights); - - if (!isWeightsCorrect) - { - return Result.Fail(new WeightNotSumToOneError()); - } - - var isCriteriaDecisionCorrect = CheckDataHelper.IsCriteriaDesisionBetweenMinusOneAndOne(criteriaDirections); - - if (!isCriteriaDecisionCorrect) - { - return Result.Fail(new CriteriaNotBetweenMinusOneAndOne()); - } - - var isSizesAreCorrect = CheckDataHelper.IsDataWeightsAndTypesHaveCorrectSizes(matrix, weights, criteriaDirections); - - if (!isSizesAreCorrect) - { - return Result.Fail(new ArraySizesAreNotEqual()); - } - - return Result.Ok(); - } - private Result CheckMatrix(double[,] matrix, double[] weights, int[] criteriaDirections) - { - var errorsCheckResult = InitialErrorsCheck(matrix,weights, criteriaDirections); - - return errorsCheckResult.IsFailed ? errorsCheckResult : Result.Ok(); - } - private MatrixDto PrepareMatrix(IEnumerable> matrix, IEnumerable weights, IEnumerable criteriaDirections) - { - var matrix2D = matrix.To2DArray(); - var weightsArray = weights.ToArray(); - var criteriaDirectionsArray = criteriaDirections.ToArray(); - - return new(matrix2D, weightsArray, criteriaDirectionsArray); - } - #endregion - - #region Protected methods - protected abstract Result> RunCalculation(Matrix matrix, Vector weights, int[] criteriaDirections); - #endregion - - #region Public methods - /// - public Result> Calculate(IEnumerable> matrix, IEnumerable weights, IEnumerable criteriaDirections) - { - var matrixDto = PrepareMatrix(matrix, weights, criteriaDirections); - return Calculate(matrixDto.Matrix, matrixDto.Weights, matrixDto.CriteriaDecision); - } - /// - public Result> Calculate(double[,] matrix, double[] weights, int[] criteriaDirections) - { - var checkMatrixResult = CheckMatrix(matrix,weights,criteriaDirections); - if (checkMatrixResult.IsFailed) - { - return Result>.Fail(new Error()); - } - - var finalMatrix = Matrix.Build.DenseOfArray(matrix); - var weightsVector = Vector.Build.DenseOfArray(weights); - return RunCalculation(finalMatrix,weightsVector,criteriaDirections); - } - #endregion -} \ No newline at end of file diff --git a/src/McdaToolkit/Mcda/Contracts/MatrixDto.cs b/src/McdaToolkit/Mcda/Contracts/MatrixDto.cs deleted file mode 100644 index 04880ce..0000000 --- a/src/McdaToolkit/Mcda/Contracts/MatrixDto.cs +++ /dev/null @@ -1,8 +0,0 @@ -namespace McdaToolkit.Mcda.Contracts; - -internal record MatrixDto(double[,] Matrix, double[] Weights, int[] CriteriaDecision) -{ - public double[,] Matrix { get; } = Matrix; - public double[] Weights { get; } = Weights; - public int[] CriteriaDecision { get; } = CriteriaDecision; -} \ No newline at end of file diff --git a/src/McdaToolkit/Mcda/Errors/ArraySizesAreNotEqual.cs b/src/McdaToolkit/Mcda/Errors/ArraySizesAreNotEqual.cs deleted file mode 100644 index d9439ca..0000000 --- a/src/McdaToolkit/Mcda/Errors/ArraySizesAreNotEqual.cs +++ /dev/null @@ -1,5 +0,0 @@ -using LightResults; - -namespace McdaToolkit.Mcda.Errors; - -public class ArraySizesAreNotEqual() : Error("Columns length of data matrix should be equal length of weights and types arrays"); \ No newline at end of file diff --git a/src/McdaToolkit/Mcda/Errors/CriteriaNotBetweenMinusOneAndOne.cs b/src/McdaToolkit/Mcda/Errors/CriteriaNotBetweenMinusOneAndOne.cs deleted file mode 100644 index 3257a4c..0000000 --- a/src/McdaToolkit/Mcda/Errors/CriteriaNotBetweenMinusOneAndOne.cs +++ /dev/null @@ -1,5 +0,0 @@ -using LightResults; - -namespace McdaToolkit.Mcda.Errors; - -public class CriteriaNotBetweenMinusOneAndOne() : Error("Criteria decision types should be number ∈Z{-1;1}"); \ No newline at end of file diff --git a/src/McdaToolkit/Mcda/Helpers/Errors/DecisionCriteriaHaveIncorrectValueError.cs b/src/McdaToolkit/Mcda/Helpers/Errors/DecisionCriteriaHaveIncorrectValueError.cs new file mode 100644 index 0000000..dcf728e --- /dev/null +++ b/src/McdaToolkit/Mcda/Helpers/Errors/DecisionCriteriaHaveIncorrectValueError.cs @@ -0,0 +1,5 @@ +using LightResults; + +namespace McdaToolkit.Mcda.Helpers.Errors; + +public class DecisionCriteriaHaveIncorrectValueError() : Error("Criteria decision types should be number ∈Z{-1;1}"); \ No newline at end of file diff --git a/src/McdaToolkit/Mcda/Helpers/Errors/MatrixColumnLengthNotEqualWeightsVectorLengthError.cs b/src/McdaToolkit/Mcda/Helpers/Errors/MatrixColumnLengthNotEqualWeightsVectorLengthError.cs new file mode 100644 index 0000000..1c1b64a --- /dev/null +++ b/src/McdaToolkit/Mcda/Helpers/Errors/MatrixColumnLengthNotEqualWeightsVectorLengthError.cs @@ -0,0 +1,5 @@ +using LightResults; + +namespace McdaToolkit.Mcda.Helpers.Errors; + +public class MatrixColumnLengthNotEqualWeightsVectorLengthError() : Error("Columns length of data matrix should be equal length of weights and types arrays"); \ No newline at end of file diff --git a/src/McdaToolkit/Mcda/Errors/WeightNotSumToOneError.cs b/src/McdaToolkit/Mcda/Helpers/Errors/WeightNotSumToOneError.cs similarity index 70% rename from src/McdaToolkit/Mcda/Errors/WeightNotSumToOneError.cs rename to src/McdaToolkit/Mcda/Helpers/Errors/WeightNotSumToOneError.cs index 555a3f3..5ddbdae 100644 --- a/src/McdaToolkit/Mcda/Errors/WeightNotSumToOneError.cs +++ b/src/McdaToolkit/Mcda/Helpers/Errors/WeightNotSumToOneError.cs @@ -1,5 +1,5 @@ using LightResults; -namespace McdaToolkit.Mcda.Errors; +namespace McdaToolkit.Mcda.Helpers.Errors; public class WeightNotSumToOneError() : Error("Sum of weight have to equal 1"); \ No newline at end of file diff --git a/src/McdaToolkit/Mcda/Abstraction/ICalculation.cs b/src/McdaToolkit/Mcda/Methods/Abstraction/ICalculation.cs similarity index 86% rename from src/McdaToolkit/Mcda/Abstraction/ICalculation.cs rename to src/McdaToolkit/Mcda/Methods/Abstraction/ICalculation.cs index b55c479..1340658 100644 --- a/src/McdaToolkit/Mcda/Abstraction/ICalculation.cs +++ b/src/McdaToolkit/Mcda/Methods/Abstraction/ICalculation.cs @@ -1,9 +1,7 @@ -using System.Collections; using LightResults; using MathNet.Numerics.LinearAlgebra; -using MathNet.Numerics.LinearAlgebra.Double; -namespace McdaToolkit.Mcda.Abstraction; +namespace McdaToolkit.Mcda.Methods.Abstraction; public interface ICalculation where TValue : struct, IEquatable, IFormattable { diff --git a/src/McdaToolkit/Mcda/Methods/Abstraction/IMcdaMethod.cs b/src/McdaToolkit/Mcda/Methods/Abstraction/IMcdaMethod.cs new file mode 100644 index 0000000..799fc81 --- /dev/null +++ b/src/McdaToolkit/Mcda/Methods/Abstraction/IMcdaMethod.cs @@ -0,0 +1,6 @@ +namespace McdaToolkit.Mcda.Methods.Abstraction; + +public interface IMcdaMethod : ICalculation +{ + +} \ No newline at end of file diff --git a/src/McdaToolkit/Mcda/Methods/Abstraction/McdaMethod.cs b/src/McdaToolkit/Mcda/Methods/Abstraction/McdaMethod.cs new file mode 100644 index 0000000..adfd888 --- /dev/null +++ b/src/McdaToolkit/Mcda/Methods/Abstraction/McdaMethod.cs @@ -0,0 +1,45 @@ +using LightResults; +using MathNet.Numerics.LinearAlgebra; +using McdaToolkit.Extensions; +using McdaToolkit.Mcda.Services; + +namespace McdaToolkit.Mcda.Methods.Abstraction; + +public abstract class McdaMethod : IMcdaMethod +{ + private readonly MatrixCheckerService _matrixCheckerService = new(); + + protected abstract Result> RunCalculation(double[,] matrix, double[] weights, int[] criteriaDirections); + + /// + public Result> Calculate(IEnumerable> matrix, IEnumerable weights, IEnumerable criteriaDirections) + { + var convertedMatrix = matrix.To2DArray(); + var convertedWeights = weights.ToArray(); + var convertedCriteriaDecision = criteriaDirections.ToArray(); + var matrixChecked = _matrixCheckerService.ValidateData(convertedMatrix, convertedWeights, convertedCriteriaDecision); + + if (matrixChecked.IsFailed) + { + return Result.Fail>(); + } + return RunCalculation(convertedMatrix, convertedWeights, convertedCriteriaDecision); + } + + /// + /// Calculate provided data + /// + /// Data as set of alternatives and theirs attributes + /// Data determining relevance of each attribute + /// Data that determines the columns is profit or cost + /// Vector of processed data in descending order + public Result> Calculate(double[,] matrix,double[] weights,int[] criteriaDirections) + { + var matrixChecked = _matrixCheckerService.ValidateData(matrix, weights, criteriaDirections); + if (matrixChecked.IsFailed) + { + return Result.Fail>(); + } + return RunCalculation(matrix, weights, criteriaDirections); + } +} \ No newline at end of file diff --git a/src/McdaToolkit/Mcda/Methods/Topsis.cs b/src/McdaToolkit/Mcda/Methods/Topsis.cs index 32d0daa..020e68d 100644 --- a/src/McdaToolkit/Mcda/Methods/Topsis.cs +++ b/src/McdaToolkit/Mcda/Methods/Topsis.cs @@ -1,9 +1,9 @@ using LightResults; using MathNet.Numerics.LinearAlgebra; -using McdaToolkit.Mcda.Abstraction; +using McdaToolkit.Mcda.Methods.Abstraction; +using McdaToolkit.Mcda.Options; using McdaToolkit.Normalization.Service; using McdaToolkit.Normalization.Service.Abstraction; -using McdaToolkit.Options; namespace McdaToolkit.Mcda.Methods; @@ -16,21 +16,6 @@ public Topsis(McdaMethodOptions options) _normalizationServiceServiceService = new MatrixNormalizatorService(options.NormalizationMethod); } - protected override Result> RunCalculation(Matrix matrix, Vector weights, int[] criteriaDirections) - { - var normalizedMatrix = _normalizationServiceServiceService.NormalizeMatrix(matrix, criteriaDirections); - var weightedMatrix = WeightedMatrix(normalizedMatrix, weights); - - var idealBest = IdealValues(weightedMatrix, true); - var idealWorst = IdealValues(weightedMatrix, false); - - var distanceToBest = CalculateEuclideanDistance(weightedMatrix, idealBest); - var distanceToWorst = CalculateEuclideanDistance(weightedMatrix, idealWorst); - var topsisScores = CalculateTopsisScores(distanceToBest, distanceToWorst); - - return Result.Ok(topsisScores); - } - private Matrix WeightedMatrix(Matrix matrix, Vector weights) { for (int i = 0; i < matrix.RowCount; i++) @@ -40,7 +25,6 @@ private Matrix WeightedMatrix(Matrix matrix, Vector weig matrix[i, j] *= weights[j]; } } - return matrix; } @@ -54,8 +38,7 @@ private Vector IdealValues(Matrix matrix, bool pis) }); } - private Vector CalculateEuclideanDistance(Matrix matrix, - Vector ideal) + private Vector CalculateEuclideanDistance(Matrix matrix, Vector ideal) { return Vector.Build .DenseOfArray(matrix @@ -72,4 +55,21 @@ private Vector CalculateTopsisScores(Vector distanceToBest, Vect { return distanceToWorst.PointwiseDivide(distanceToBest.Add(distanceToWorst)); } + + protected override Result> RunCalculation(double[,] matrix,double[] weights,int[] criteriaDirections) + { + var matrixBuilded = Matrix.Build.DenseOfArray(matrix); + var weightsBuilded = Vector.Build.DenseOfArray(weights); + var normalizedMatrix = _normalizationServiceServiceService.NormalizeMatrix(matrixBuilded, criteriaDirections); + var weightedMatrix = WeightedMatrix(normalizedMatrix, weightsBuilded); + + var idealBest = IdealValues(weightedMatrix, true); + var idealWorst = IdealValues(weightedMatrix, false); + + var distanceToBest = CalculateEuclideanDistance(weightedMatrix, idealBest); + var distanceToWorst = CalculateEuclideanDistance(weightedMatrix, idealWorst); + var topsisScores = CalculateTopsisScores(distanceToBest, distanceToWorst); + + return Result.Ok(topsisScores); + } } \ No newline at end of file diff --git a/src/McdaToolkit/Options/McdaMethodOptions.cs b/src/McdaToolkit/Mcda/Options/McdaMethodOptions.cs similarity index 67% rename from src/McdaToolkit/Options/McdaMethodOptions.cs rename to src/McdaToolkit/Mcda/Options/McdaMethodOptions.cs index 5bea2d4..a9cd065 100644 --- a/src/McdaToolkit/Options/McdaMethodOptions.cs +++ b/src/McdaToolkit/Mcda/Options/McdaMethodOptions.cs @@ -1,11 +1,14 @@ using McdaToolkit.Enums; -namespace McdaToolkit.Options; +namespace McdaToolkit.Mcda.Options; /// /// Configuration for Mcda methods /// public record McdaMethodOptions { + /// + /// Current normalization method + /// public NormalizationMethod NormalizationMethod { get; set; } = NormalizationMethod.MinMax; } \ No newline at end of file diff --git a/src/McdaToolkit/Mcda/Services/MatrixCheckerService.cs b/src/McdaToolkit/Mcda/Services/MatrixCheckerService.cs new file mode 100644 index 0000000..83c72ca --- /dev/null +++ b/src/McdaToolkit/Mcda/Services/MatrixCheckerService.cs @@ -0,0 +1,30 @@ +using LightResults; +using McdaToolkit.Mcda.Helpers; +using McdaToolkit.Mcda.Helpers.Errors; + +namespace McdaToolkit.Mcda.Services; + +internal sealed class MatrixCheckerService +{ + public Result ValidateData(double[,] matrix, double[] weights, int[] criteriaDirections) + { + var isWeightsCorrect = CheckDataHelper.IsWeightEqualOne(weights); + if (!isWeightsCorrect) + { + return Result.Fail(new WeightNotSumToOneError()); + } + + var isCriteriaDecisionCorrect = CheckDataHelper.IsCriteriaDesisionBetweenMinusOneAndOne(criteriaDirections); + if (!isCriteriaDecisionCorrect) + { + return Result.Fail(new DecisionCriteriaHaveIncorrectValueError()); + } + + var isSizesAreCorrect = CheckDataHelper.IsDataWeightsAndTypesHaveCorrectSizes(matrix, weights, criteriaDirections); + if (!isSizesAreCorrect) + { + return Result.Fail(new MatrixColumnLengthNotEqualWeightsVectorLengthError()); + } + return Result.Ok(); + } +} \ No newline at end of file diff --git a/src/McdaToolkit/McdaToolkit.csproj b/src/McdaToolkit/McdaToolkit.csproj index 90bc43b..612999c 100644 --- a/src/McdaToolkit/McdaToolkit.csproj +++ b/src/McdaToolkit/McdaToolkit.csproj @@ -23,6 +23,10 @@ + + + + diff --git a/tests/McdaToolkit.UnitTests/MatrixCheckerTests.cs b/tests/McdaToolkit.UnitTests/MatrixCheckerTests.cs new file mode 100644 index 0000000..7927503 --- /dev/null +++ b/tests/McdaToolkit.UnitTests/MatrixCheckerTests.cs @@ -0,0 +1,73 @@ +using FluentAssertions; +using McdaToolkit.Mcda.Helpers.Errors; +using McdaToolkit.Mcda.Services; + +namespace McdaToolkit.UnitTests; + +public class MatrixCheckerTests +{ + [Fact] + public void ValidateData_WeightAreNotEqualOne_ShouldReturnResultFail() + { + double[,] matrix = { + { 66, 56, 95 }, + { 61, 55, 166 }, + { 65, 49, 113 }, + { 95, 56, 99 }, + { 63, 43, 178 }, + { 74, 59, 140 }, + }; + double[] weights = [0.8,0.25,0.35]; + int[] types = [-1, -1, 1]; + var matrixCheckerService = new MatrixCheckerService(); + + var result = matrixCheckerService.ValidateData(matrix, weights, types); + + result.IsSuccess.Should().BeFalse(); + result.HasError(); + } + + [Fact] + public void Calculate_DecisionCriteriaAreNotBetweenMinusOneAndOne_ShouldReturnResultFail() + { + var matrix = new double[,] + { + { 66, 56, 95 }, + { 61, 55, 166 }, + { 65, 49, 113 }, + { 95, 56, 99 }, + { 63, 43, 178 }, + { 74, 59, 140 }, + }; + double[] weights = [0.4,0.25,0.35]; + int[] types = [-1, -2, 1]; + var matrixCheckerService = new MatrixCheckerService(); + + var result = matrixCheckerService.ValidateData(matrix, weights, types); + + result.IsSuccess.Should().BeFalse(); + result.HasError(); + } + + [Fact] + public void Calculate_DimensionsOfAllMatrixesNotTheSame_ShouldReturnResultFail() + { + var matrix = new double[,] + { + { 66, 56, 95 }, + { 61, 55, 166 }, + { 65, 49, 113 }, + { 95, 56, 99 }, + { 63, 43, 178 }, + { 74, 59, 140 }, + }; + double[] weights = [0.4,0.25,0.15,0.20]; + int[] types = [-1, -1, 1, 1]; + var matrixCheckerService = new MatrixCheckerService(); + + var result = matrixCheckerService.ValidateData(matrix, weights, types); + + result.IsSuccess.Should().BeFalse(); + result.HasError(); + } +} \ No newline at end of file diff --git a/tests/McdaToolkit.UnitTests/McdaMethodsTests.cs b/tests/McdaToolkit.UnitTests/McdaMethodsTests.cs index 1bad1e2..f92aa6b 100644 --- a/tests/McdaToolkit.UnitTests/McdaMethodsTests.cs +++ b/tests/McdaToolkit.UnitTests/McdaMethodsTests.cs @@ -1,22 +1,13 @@ using FluentAssertions; using MathNet.Numerics; using McdaToolkit.Enums; -using McdaToolkit.Mcda.Errors; using McdaToolkit.Mcda.Methods; -using McdaToolkit.Options; -using Xunit.Abstractions; +using McdaToolkit.Mcda.Options; namespace McdaToolkit.UnitTests; public class McdaMethodsTests { - private readonly ITestOutputHelper _testOutputHelper; - - public McdaMethodsTests(ITestOutputHelper testOutputHelper) - { - _testOutputHelper = testOutputHelper; - } - [Fact] public void Calculate_TopsisMethod_ShouldBeEqualToExpected() { @@ -29,20 +20,9 @@ public void Calculate_TopsisMethod_ShouldBeEqualToExpected() { 63, 43, 178 }, { 74, 59, 140 }, }; - double[] weights = new double[] - { - 0.4,0.25,0.35 - }; - int[] types = new int[] - { - -1, - -1, - 1 - }; - double[] expectedTopsisScore = new double[] - { - 0.38805147,0.76189759,0.58509479,0.06374247,0.97647059,0.43681786 - }; + double[] weights = [0.4,0.25,0.35]; + int[] types = [-1, -1, 1]; + double[] expectedTopsisScore = [0.38805147,0.76189759,0.58509479,0.06374247,0.97647059,0.43681786]; var topsis = new Topsis(new McdaMethodOptions() { @@ -50,7 +30,6 @@ public void Calculate_TopsisMethod_ShouldBeEqualToExpected() }); var topsisResult = topsis.Calculate(matrix,weights,types); - var final = topsisResult.Value; final.Enumerate() @@ -58,104 +37,4 @@ public void Calculate_TopsisMethod_ShouldBeEqualToExpected() .Should() .BeEquivalentTo(expectedTopsisScore); } - - [Fact] - public void Calculate_WeightAreNotEqualOne_ShouldReturnResultFail() - { - double[,] matrix = { - { 66, 56, 95 }, - { 61, 55, 166 }, - { 65, 49, 113 }, - { 95, 56, 99 }, - { 63, 43, 178 }, - { 74, 59, 140 }, - }; - double[] weights = - [ - 0.8,0.25,0.35 - ]; - int[] types = - [ - -1, - -1, - 1 - ]; - - var topsis = new Topsis(new McdaMethodOptions() - { - NormalizationMethod = NormalizationMethod.MinMax - }); - var topsisResult = topsis.Calculate(matrix, weights, types); - - topsisResult.IsSuccess.Should().BeFalse(); - topsisResult.HasError(); - } - - [Fact] - public void Calculate_DecisionCriteriaAreNotBetweenMinusOneAndOne_ShouldReturnResultFail() - { - var matrix = new double[,] - { - { 66, 56, 95 }, - { 61, 55, 166 }, - { 65, 49, 113 }, - { 95, 56, 99 }, - { 63, 43, 178 }, - { 74, 59, 140 }, - }; - double[] weights = new double[] - { - 0.4,0.25,0.35 - }; - int[] types = new int[] - { - -1, - -2, - 1 - }; - - var topsis = new Topsis(new McdaMethodOptions() - { - NormalizationMethod = NormalizationMethod.MinMax - }); - - var topsisResult = topsis.Calculate(matrix, weights, types); - - topsisResult.IsSuccess.Should().BeFalse(); - topsisResult.HasError(); - } - - [Fact] - public void Calculate_DimensionsOfAllMatrixesNotTheSame_ShouldReturnResultFail() - { - var matrix = new double[,] - { - { 66, 56, 95 }, - { 61, 55, 166 }, - { 65, 49, 113 }, - { 95, 56, 99 }, - { 63, 43, 178 }, - { 74, 59, 140 }, - }; - double[] weights = new double[] - { - 0.4,0.25,0.15,0.20 - }; - int[] types = new int[] - { - -1, - -1, - 1, - 1 - }; - - var topsis = new Topsis(new McdaMethodOptions() - { - NormalizationMethod = NormalizationMethod.MinMax - }); - var topsisResult = topsis.Calculate(matrix, weights, types); - - topsisResult.IsSuccess.Should().BeFalse(); - topsisResult.HasError(); - } } \ No newline at end of file diff --git a/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs b/tests/McdaToolkit.UnitTests/NormalizationTests.cs similarity index 97% rename from tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs rename to tests/McdaToolkit.UnitTests/NormalizationTests.cs index 12f623d..684143a 100644 --- a/tests/McdaToolkit.UnitTests/NormalizationUnitTests.cs +++ b/tests/McdaToolkit.UnitTests/NormalizationTests.cs @@ -1,15 +1,13 @@ using FluentAssertions; using MathNet.Numerics.LinearAlgebra; using McdaToolkit.Enums; -using McdaToolkit.Normalization; using McdaToolkit.Normalization.Service; -using McdaToolkit.UnitTests.Helpers; namespace McdaToolkit.UnitTests; -public class NormalizationUnitTests +public class NormalizationTests { - private readonly Matrix _matrixToNormalize = Matrix.Build.DenseOfArray(new double[,] + private readonly Matrix _matrixToNormalize = Matrix.Build.DenseOfArray(new[,] { { 32.57, 14.56, 87.12, 56.34, 47.89 }, { 93.23, 76.34, 33.78, 25.68, 64.23 }, diff --git a/tests/McdaToolkit.UnitTests/Helpers/TestHelpers.cs b/tests/McdaToolkit.UnitTests/TestHelpers.cs similarity index 95% rename from tests/McdaToolkit.UnitTests/Helpers/TestHelpers.cs rename to tests/McdaToolkit.UnitTests/TestHelpers.cs index 298a715..3b4e962 100644 --- a/tests/McdaToolkit.UnitTests/Helpers/TestHelpers.cs +++ b/tests/McdaToolkit.UnitTests/TestHelpers.cs @@ -1,7 +1,7 @@ using MathNet.Numerics; using MathNet.Numerics.LinearAlgebra; -namespace McdaToolkit.UnitTests.Helpers; +namespace McdaToolkit.UnitTests; public abstract class TestHelpers {