Fix codacy (#56)

* Refactor code

* Simplify FillGaps in HillEncoder

Author: siriak

Algorithms.Tests/Encoders/CaesarEncoderTests.cs

@@ -1,15 +1,16 @@
-using System;
-using Algorithms.Encoders;
+using Algorithms.Encoders;
 using NUnit.Framework;
 using NUnit.Framework.Internal;
+using System;
 
 namespace Algorithms.Tests.Encoders
 {
     public class CaesarEncoderTests
     {
-        readonly Randomizer random = new Randomizer();
-        readonly CaesarEncoder encoder = new CaesarEncoder();
-        string RandomMessage => random.GetString();
+        private readonly Randomizer random = new Randomizer();
+        private readonly CaesarEncoder encoder = new CaesarEncoder();
+
+        private string RandomMessage => random.GetString();
 
         [Test]
         [Parallelizable]

Algorithms.Tests/Encoders/VigenereEncoderTests.cs

@@ -6,9 +6,10 @@ namespace Algorithms.Tests.Encoders
 {
     public class VigenereEncoderTests
     {
-        readonly Randomizer random = new Randomizer();
-        readonly VigenereEncoder encoder = new VigenereEncoder();
-        string RandomMessage => random.GetString();
+        private readonly Randomizer random = new Randomizer();
+        private readonly VigenereEncoder encoder = new VigenereEncoder();
+
+        private string RandomMessage => random.GetString();
 
         [Test]
         [Parallelizable]

Algorithms.Tests/Sorters/BubbleSorterTests.cs

@@ -1,15 +1,15 @@
-using System;
+using Algorithms.Sorters;
 using NUnit.Framework;
 using NUnit.Framework.Internal;
-using Algorithms.Sorters;
+using System;
 using System.Collections.Generic;
 
 namespace Algorithms.Tests.Sorters
 {
     public class BubbleSorterTests
     {
-        readonly BubbleSorter<int> sorter = new BubbleSorter<int>();
-        readonly Random random = new Random();
+        private readonly BubbleSorter<int> sorter = new BubbleSorter<int>();
+        private readonly Random random = new Random();
 
         [Test]
         [Parallelizable]

Algorithms.Tests/Sorters/SelectionSorterTests.cs

@@ -1,15 +1,15 @@
-using System;
+using Algorithms.Sorters;
 using NUnit.Framework;
 using NUnit.Framework.Internal;
-using Algorithms.Sorters;
+using System;
 using System.Collections.Generic;
 
 namespace Algorithms.Tests.Sorters
 {
     public class SelectionSorterTests
     {
-        readonly SelectionSorter<int> sorter = new SelectionSorter<int>();
-        readonly Random random = new Random();
+        private readonly SelectionSorter<int> sorter = new SelectionSorter<int>();
+        private readonly Random random = new Random();
 
         [Test]
         [Parallelizable]

Algorithms/DataCompression/huffman.cs

@@ -4,7 +4,7 @@
 
 namespace DC5
 {
-    class Huff
+    internal class Huff
     {
         public string Data { get; set; }
         public int Frequency { get; set; }
@@ -24,14 +24,16 @@ public Huff(Huff leftChild, Huff rightChild)
             Frequency = leftChild.Frequency + rightChild.Frequency;
         }
     }
-    class Man
+
+    internal class Man
     {
         public List<string> Codec { get; set; } = new List<string>();
         public List<string> Data { get; set; } = new List<string>();
     }
-    class Program
+
+    internal class Program
     {
-        static void Main()
+        private static void Main()
         {
             IList<Huff> list = new List<Huff>();
             Console.Write("Enter String: ");

Algorithms/DataCompression/shannon_fano.cs

@@ -3,15 +3,16 @@
 
 namespace DC4
 {
-    class Program
+    internal class Program
     {
-        class Fano
+        private class Fano
         {
             public float pro;
             public int[] arr = new int[20];
             public int top;
         }
-        static void Main()
+
+        private static void Main()
         {
             var f = Enumerable.Range(0, 20).Select(ind => new Fano()).ToArray();
             Console.Write("Enter String: ");
@@ -133,7 +134,8 @@ static void Main()
             Console.WriteLine(cStr.Replace(" ", ""));
             Console.ReadKey();
         }
-        static void Shannon(int l, int h, Fano[] f)
+
+        private static void Shannon(int l, int h, Fano[] f)
         {
             float set1 = 0, set2 = 0;
             int i, j, k = 0;

Algorithms/Encoders/CaesarEncoder.cs

@@ -29,7 +29,7 @@ public class CaesarEncoder : IEncoder<int>
         /// <returns>Decoded text</returns>
         public string Decode(string text, int key) => Cipher(text, -key);
 
-        private string Cipher(string text, int key)
+        private static string Cipher(string text, int key)
         {
             var newText = new StringBuilder(text.Length);
             for (var i = 0; i < text.Length; i++)

Algorithms/Encoders/HillEncoder.cs

@@ -1,6 +1,6 @@
 using Algorithms.Numeric;
 using System;
-using System.Text;
+using System.Linq;
 
 namespace Algorithms.Encoders
 {
@@ -11,33 +11,21 @@ namespace Algorithms.Encoders
     /// </summary>
     public class HillEncoder : IEncoder<double[,]>
     {
-        #region DEFINITION
-
         private readonly GaussJordanElimination LinearEquationSolver;
 
-        public HillEncoder()
-        {
-            LinearEquationSolver = new GaussJordanElimination();
-        }
-
-        public string Decode(string text, double[,] key) => Decipher(text, key);
-
-        public string Encode(string text, double[,] key) => Cipher(text, key);
-
-        #endregion DEFINITION
+        public HillEncoder() => LinearEquationSolver = new GaussJordanElimination(); //TODO: add DI
 
-        #region MAIN
-        private string Cipher(string text, double[,] key)
+        public string Encode(string text, double[,] key)
         {
             var preparedText = FillGaps(text);
             var chunked = ChunkTextToArray(preparedText);
             var splitted = SplitToCharArray(chunked);
 
-            double[][] ciphered = new double[chunked.Length][];
+            var ciphered = new double[chunked.Length][];
 
             for (var i = 0; i < chunked.Length; i++)
             {
-                double[] vector = new double[3];
+                var vector = new double[3];
                 Array.Copy(splitted, i * 3, vector, 0, 3);
                 var product = MatrixCipher(vector, key);
                 ciphered[i] = product;
@@ -48,16 +36,16 @@ private string Cipher(string text, double[,] key)
             return BuildStringFromArray(merged);
         }
 
-        private string Decipher(string text, double[,] key)
+        public string Decode(string text, double[,] key)
         {
             var chunked = ChunkTextToArray(text);
             var splitted = SplitToCharArray(chunked);
 
-            double[][] deciphered = new double[chunked.Length][];
+            var deciphered = new double[chunked.Length][];
 
             for (var i = 0; i < chunked.Length; i++)
             {
-                double[] vector = new double[3];
+                var vector = new double[3];
                 Array.Copy(splitted, i * 3, vector, 0, 3);
                 var product = MatrixDeCipher(vector, key);
                 deciphered[i] = product;
@@ -68,25 +56,13 @@ private string Decipher(string text, double[,] key)
 
             return UnFillGaps(str);
         }
-        #endregion MAIN
 
         /// <summary>
-        /// To convert elements from the array to their corresponding char ASCII.
+        /// Converts elements from the array to their corresponding Unicode characters.
         /// </summary>
         /// <param name="arr">array of vectors</param>
         /// <returns>Message</returns>
-        private static string BuildStringFromArray(double[] arr)
-        {
-            var strBuilder = new StringBuilder();
-
-            for (var i = 0; i < arr.Length; i++)
-            {
-                // To cast it to its corresponding (char)value.
-                strBuilder.Append((char)arr[i]);
-            }
-
-            return strBuilder.ToString();
-        }
+        private static string BuildStringFromArray(double[] arr) => new string(arr.Select(c => (char)c).ToArray());
 
         /// <summary>
         /// Given a list of vectors, returns a single array of elements.
@@ -106,7 +82,7 @@ private double[] MergeArrayList(double[][] list)
         }
 
         /// <summary>
-        /// To multiply the key for the given scalar.
+        /// Multiplies the key for the given scalar.
         /// </summary>
         /// <param name="vector">list of splitted words as numbers.</param>
         /// <param name="key">Cipher selected key</param>
@@ -127,17 +103,17 @@ private static double[] MatrixCipher(double[] vector, double[,] key)
         }
 
         /// <summary>
-        /// To split the input text message as chunks of words.
+        /// Splits the input text message as chunks of words.
         /// </summary>
         /// <param name="chunked">chunked words list</param>
         /// <returns>spliiter char array.</returns>
         private static char[] SplitToCharArray(string[] chunked)
         {
-            char[] splitted = new char[chunked.Length * 3];
+            var splitted = new char[chunked.Length * 3];
 
-            for (int i = 0; i < chunked.Length; i++)
+            for (var i = 0; i < chunked.Length; i++)
             {
-                for (int j = 0; j < 3; j++)
+                for (var j = 0; j < 3; j++)
                 {
                     splitted[(i * 3) + j] = chunked[i].ToCharArray()[j];
                 }
@@ -147,7 +123,7 @@ private static char[] SplitToCharArray(string[] chunked)
         }
 
         /// <summary>
-        /// To chunk the input text message.
+        /// Chunks the input text message.
         /// </summary>
         /// <param name="text">text message</param>
         /// <returns>array of words.</returns>
@@ -173,33 +149,16 @@ private static string[] ChunkTextToArray(string text)
         /// <returns>Modified text Message.</returns>
         private static string FillGaps(string text)
         {
-            string newText = text;
-            var isChunkable = false;
-
-            while (!isChunkable)
-            {
-                if (newText.Length % 3 != 0)
-                {
-                    newText += " ";
-                }
-                else
-                {
-                    isChunkable = true;
-                }
-            }
-
-            return newText;
+            var remainder = text.Length % 3;
+            return remainder == 0 ? text : text + new string(' ', 3 - remainder);
         }
 
         /// <summary>
         /// Removes the extra spaces included on the cipher phase.
         /// </summary>
         /// <param name="text">Text message</param>
         /// <returns>Deciphered Message</returns>
-        private static string UnFillGaps(string text)
-        {
-            return text.TrimEnd();
-        }
+        private static string UnFillGaps(string text) => text.TrimEnd();
 
         /// <summary>
         /// Finds the inverse of the given matrix using a linear equation solver.
@@ -214,13 +173,13 @@ private double[] MatrixDeCipher(double[] vector, double[,] key)
 
             for (var i = 0; i < key.GetLength(0); i++)
             {
-                for (int j = 0; j < key.GetLength(1); j++)
+                for (var j = 0; j < key.GetLength(1); j++)
                 {
                     augM[i, j] = key[i, j];
                 }
             }
 
-            for (int k = 0; k < vector.Length; k++)
+            for (var k = 0; k < vector.Length; k++)
             {
                 augM[k, 3] = vector[k];
             }

Algorithms/Encoders/VigenereEncoder.cs

@@ -8,7 +8,7 @@ namespace Algorithms.Encoders
     /// </summary>
     public class VigenereEncoder : IEncoder<string>
     {
-        readonly CaesarEncoder caesarEncoder = new CaesarEncoder();
+        private readonly CaesarEncoder caesarEncoder = new CaesarEncoder();
 
         /// <summary>
         /// Encodes text using specified key,

Algorithms/Numeric/GaussJordanElimination.cs

@@ -55,7 +55,7 @@ private bool CanMatrixBeUsed(double[,] matrix)
         /// <returns>Matrix</returns>
         private bool PivotMatrix(ref double[,] matrix)
         {
-            for (int col = 0; col + 1 < RowCount; col++)
+            for (var col = 0; col + 1 < RowCount; col++)
             {
                 if (matrix[col, col] == 0)
                 {
@@ -65,7 +65,7 @@ private bool PivotMatrix(ref double[,] matrix)
                     if (matrix[rowToSwap, col] != 0)
                     {
                         var tmp = new double[RowCount + 1];
-                        for (int i = 0; i < RowCount + 1; i++)
+                        for (var i = 0; i < RowCount + 1; i++)
                         {
                             // To make the swap with the element above.
                             tmp[i] = matrix[rowToSwap, i];
@@ -105,14 +105,14 @@ private int FindNonZeroCoefficient(ref double[,] matrix, int col)
         /// <param name="matrix">Matrix</param>
         private void Elimination(ref double[,] matrix)
         {
-            for (int srcRow = 0; srcRow + 1 < RowCount; srcRow++)
+            for (var srcRow = 0; srcRow + 1 < RowCount; srcRow++)
             {
-                for (int destRow = srcRow + 1; destRow < RowCount; destRow++)
+                for (var destRow = srcRow + 1; destRow < RowCount; destRow++)
                 {
-                    double df = matrix[srcRow, srcRow];
-                    double sf = matrix[destRow, srcRow];
+                    var df = matrix[srcRow, srcRow];
+                    var sf = matrix[destRow, srcRow];
 
-                    for (int i = 0; i < RowCount + 1; i++)
+                    for (var i = 0; i < RowCount + 1; i++)
                     {
                         matrix[destRow, i] = matrix[destRow, i] * df - matrix[srcRow, i] * sf;
                     }
@@ -135,12 +135,12 @@ private bool ElementaryReduction(ref double[,] matrix)
                     return false;
                 }
 
-                for (int i = 0; i < RowCount + 1; i++)
+                for (var i = 0; i < RowCount + 1; i++)
                 {
                     matrix[row, i] /= element;
                 }
 
-                for (int destRow = 0; destRow < row; destRow++)
+                for (var destRow = 0; destRow < row; destRow++)
                 {
                     matrix[destRow, RowCount] -= matrix[destRow, row] * matrix[row, RowCount];
                     matrix[destRow, row] = 0;