Cleanup minor things (#221)

* Add DIRECTORY.md to solution

* Add missing algorithms to README.md

* Apply code style

* Update .editorconfig

Author: siriak

.editorconfig

@@ -1,8 +1,6 @@
 using Algorithms.DataCompression;
 using Algorithms.Sorters.Comparison;
-
 using FluentAssertions;
-
 using NUnit.Framework;
 using NUnit.Framework.Internal;
 
@@ -33,7 +31,9 @@ public static void CompressingPhrase(string uncompressedText, string expectedCom
         }
 
         [Test]
-        public static void DecompressedTextTheSameAsOriginal([Random(0, 1000, 100, Distinct = true)]int length)
+        public static void DecompressedTextTheSameAsOriginal(
+            [Random(0, 1000, 100, Distinct = true)]
+            int length)
         {
             //Arrange
             var sorter = new BubbleSorter<HuffmanCompressor.ListNode>();

Algorithms.Tests/Compressors/HuffmanCompressorTests.cs

@@ -28,7 +28,7 @@ public static void CompressingPhrase(string uncompressedText, string expectedCom
         }
 
         [Test]
-        public static void DecompressedTextTheSameAsOriginal([Random(0, 1000, 100)]int length)
+        public static void DecompressedTextTheSameAsOriginal([Random(0, 1000, 100)] int length)
         {
             //Arrange
             var solver = new NaiveKnapsackSolver<(char, double)>();

Algorithms.Tests/Compressors/ShannonFanoCompressorTests.cs

@@ -7,7 +7,7 @@ namespace Algorithms.Tests.Encoders
     public static class CaesarEncoderTests
     {
         [Test]
-        public static void DecodedStringIsTheSame([Random(100)]int key)
+        public static void DecodedStringIsTheSame([Random(100)] int key)
         {
             // Arrange
             var encoder = new CaesarEncoder();

Algorithms.Tests/Encoders/CaesarEncoderTests.cs

@@ -1,33 +1,32 @@
 using System.Collections.Generic;
+using System.Linq;
 using Algorithms.Encoders;
 using NUnit.Framework;
-using System.Linq;
 
 namespace Algorithms.Tests.Encoders
 {
     public class NysiisEncoderTests
     {
+        private static readonly string[] _names =
+        {
+            "Jay", "John", "Jane", "Zayne", "Guerra", "Iga", "Cowan", "Louisa", "Arnie", "Olsen", "Corban", "Nava",
+            "Cynthia Malone", "Amiee MacKee", "MacGyver", "Yasmin Edge",
+        };
+
+        private static readonly string[] _expected =
+        {
+            "JY", "JAN", "JAN", "ZAYN", "GAR", "IG", "CAN", "LAS", "ARNY", "OLSAN", "CARBAN", "NAV", "CYNTANALAN",
+            "ANANACY", "MCGYVAR", "YASNANADG",
+        };
+
+        private static IEnumerable<string[]> TestData => _names.Zip(_expected, (l, r) => new[] { l, r });
+
         [TestCaseSource(nameof(TestData))]
         public void AttemptNysiis(string source, string expected)
         {
             var enc = new NysiisEncoder();
             var nysiis = enc.Encode(source);
             Assert.AreEqual(expected, nysiis);
         }
-        
-        static IEnumerable<string[]> TestData => _names.Zip(_expected, (l, r) => new[] { l, r });
-
-        static string[] _names = {
-            "Jay", "John", "Jane", "Zayne", "Guerra",
-            "Iga", "Cowan", "Louisa", "Arnie", "Olsen",
-            "Corban", "Nava", "Cynthia Malone", "Amiee MacKee",
-            "MacGyver", "Yasmin Edge"
-        };
-        static string[] _expected = {
-            "JY", "JAN", "JAN", "ZAYN", "GAR",
-            "IG", "CAN", "LAS", "ARNY", "OLSAN",
-            "CARBAN", "NAV", "CYNTANALAN", "ANANACY",
-            "MCGYVAR", "YASNANADG"
-        };
     }
 }

Algorithms.Tests/Encoders/NysiisEncoderTests.cs

@@ -7,23 +7,21 @@ namespace Algorithms.Tests.Encoders
 {
     public static class SoundexEncoderTest
     {
+        private static readonly string[] _names =
+        {
+            "Robert", "Rupert", "Rubin", "Ashcraft", "Ashcroft", "Tymczak", "Pfister", "Honeyman",
+        };
+
+        private static readonly string[] _expected = { "R163", "R163", "R150", "A261", "A261", "T522", "P236", "H555" };
+
+        private static IEnumerable<string[]> TestData => _names.Zip(_expected, (l, r) => new[] { l, r });
+
         [TestCaseSource(nameof(TestData))]
         public static void AttemptSoundex(string source, string encoded)
         {
             SoundexEncoder enc = new();
             var nysiis = enc.Encode(source);
             Assert.AreEqual(nysiis, encoded);
         }
-
-        static IEnumerable<string[]> TestData => _names.Zip(_expected, (l, r) => new[] { l, r });
-
-        static readonly string[] _names = {
-            "Robert", "Rupert", "Rubin", "Ashcraft", "Ashcroft",
-            "Tymczak", "Pfister", "Honeyman"
-        };
-        static readonly string[] _expected = {
-            "R163", "R163", "R150", "A261", "A261", "T522", "P236",
-            "H555"
-        };
     }
 }

Algorithms.Tests/Encoders/SoundexEncoderTest.cs

@@ -19,7 +19,10 @@ public static (int[] correctArray, int[] testArray) GetArrays(int n)
             return (correctArray, testArr);
         }
 
-        public static (string[] correctArray, string[] testArray) GetStringArrays(int n, int maxLength, bool equalLength)
+        public static (string[] correctArray, string[] testArray) GetStringArrays(
+            int n,
+            int maxLength,
+            bool equalLength)
         {
             var testArr = new string[n];
             var correctArray = new string[n];

Algorithms.Tests/Helpers/RandomHelper.cs

@@ -85,7 +85,9 @@ public static void FSU_P07_WithNonIntegralValues()
 
 
         [Test]
-        public static void TakesHalf([Random(0, 1000, 100, Distinct = true)]int length)
+        public static void TakesHalf(
+            [Random(0, 1000, 100, Distinct = true)]
+            int length)
         {
             //Arrange
             var solver = new DynamicProgrammingKnapsackSolver<int>();

Algorithms.Tests/Knapsack/DynamicProgrammingKnapsackSolverTests.cs

@@ -7,7 +7,9 @@ namespace Algorithms.Tests.Knapsack
     public static class NaiveKnapsackSolverTests
     {
         [Test]
-        public static void TakesHalf([Random(0, 1000, 100, Distinct = true)]int length)
+        public static void TakesHalf(
+            [Random(0, 1000, 100, Distinct = true)]
+            int length)
         {
             //Arrange
             var solver = new NaiveKnapsackSolver<int>();

Algorithms.Tests/Knapsack/NaiveKnapsackSolverTests.cs

@@ -1,71 +1,74 @@
 using System;
 using Algorithms.LinearAlgebra.Eigenvalue;
 using FluentAssertions;
-using Utilities.Extensions;
 using NUnit.Framework;
+using Utilities.Extensions;
 
 namespace Algorithms.Tests.LinearAlgebra.Eigenvalue
 {
     public class PowerIterationTests
     {
+        private static readonly object[] DominantVectorTestCases =
+        {
+            new object[]
+            {
+                3.0,
+                new[] { 0.7071039, 0.70710966 },
+                new[,] { { 2.0, 1.0 }, { 1.0, 2.0 } },
+            },
+            new object[]
+            {
+                4.235889,
+                new[] { 0.91287093, 0.40824829 },
+                new[,] { { 2.0, 5.0 }, { 1.0, 2.0 } },
+            },
+        };
+
         private readonly double epsilon = Math.Pow(10, -5);
 
         [Test]
         public void Dominant_ShouldThrowArgumentException_WhenSourceMatrixIsNotSquareShaped()
         {
             // Arrange
-            var source = new double[,] {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {0, 0, 0}};
-            
+            var source = new double[,] { { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }, { 0, 0, 0 } };
+
             // Act
             Action action = () => PowerIteration.Dominant(source, StartVector(source.GetLength(0)), epsilon);
-            
+
             // Assert
             action.Should().Throw<ArgumentException>().WithMessage("The source matrix is not square-shaped.");
         }
-        
+
         [Test]
         public void Dominant_ShouldThrowArgumentException_WhenStartVectorIsNotSameSizeAsMatrix()
         {
             // Arrange
-            var source = new double[,] {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
-            var startVector = new double[] {1, 0, 0, 0};
-            
+            var source = new double[,] { { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 } };
+            var startVector = new double[] { 1, 0, 0, 0 };
+
             // Act
             Action action = () => PowerIteration.Dominant(source, startVector, epsilon);
-            
+
             // Assert
             action.Should().Throw<ArgumentException>()
                 .WithMessage("The length of the start vector doesn't equal the size of the source matrix.");
         }
 
-        [Test, TestCaseSource(nameof(DominantVectorTestCases))]
+        [TestCaseSource(nameof(DominantVectorTestCases))]
         public void Dominant_ShouldCalculateDominantEigenvalueAndEigenvector(
-            double eigenvalue, double[] eigenvector, double[,] source)
+            double eigenvalue,
+            double[] eigenvector,
+            double[,] source)
         {
             // Act
-            var (actualEigVal, actualEigVec) = PowerIteration.Dominant(source, StartVector(source.GetLength(0)), epsilon);
-            
+            var (actualEigVal, actualEigVec) =
+                PowerIteration.Dominant(source, StartVector(source.GetLength(0)), epsilon);
+
             // Assert
             actualEigVal.Should().BeApproximately(eigenvalue, epsilon);
             actualEigVec.Magnitude().Should().BeApproximately(eigenvector.Magnitude(), epsilon);
         }
 
-        static readonly object[] DominantVectorTestCases =
-        {
-            new object[]
-            {
-                3.0,
-                new[] { 0.7071039, 0.70710966 },
-                new[,] { { 2.0, 1.0 }, { 1.0, 2.0 } }
-            },
-            new object[]
-            {
-                4.235889,
-                new[] { 0.91287093, 0.40824829 },
-                new[,] { { 2.0, 5.0 }, { 1.0, 2.0 } }
-            }
-        };
-
-        private double[] StartVector(int length) => new Random(Seed: 111111).NextVector(length);
+        private double[] StartVector(int length) => new Random(111111).NextVector(length);
     }
-}
+}