Fix warnings in VS and index (#92)

* Fix warnings in VS

* Fix redundant boolean literal

Author: siriak

Algorithms.Tests/Compressors/HuffmanCompressorTests.cs

@@ -1,4 +1,4 @@
-using Algorithms.Compressors;
+using Algorithms.DataCompression;
 using Algorithms.Sorters;
 using NUnit.Framework;
 using NUnit.Framework.Internal;

Algorithms.Tests/Compressors/ShannonFanoCompressorTests.cs

@@ -1,4 +1,4 @@
-using Algorithms.Compressors;
+using Algorithms.DataCompression;
 using Algorithms.Knapsack;
 using NUnit.Framework;
 using NUnit.Framework.Internal;

Algorithms.Tests/Compressors/TranslatorTests.cs

@@ -1,5 +1,5 @@
 using System.Collections.Generic;
-using Algorithms.Compressors;
+using Algorithms.DataCompression;
 using NUnit.Framework;
 
 namespace Algorithms.Tests.Compressors

Algorithms.Tests/Sorters/BucketSortTests.cs renamed to Algorithms.Tests/Sorters/BucketSorterTests.cs

@@ -5,13 +5,13 @@
 
 namespace Algorithms.Tests.Sorters
 {
-    public class BucketSortTests
+    public class BucketSorterTests
     {
         [Test]
         public void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
         {
             // Arrange
-            var sorter = new BucketSort();
+            var sorter = new BucketSorter();
             var intComparer = new IntComparer();
             var (correctArray, testArray) = RandomHelper.GetArrays(n);
 

Algorithms/Compressors/HuffmanCompressor.cs renamed to Algorithms/DataCompression/HuffmanCompressor.cs

@@ -3,7 +3,7 @@
 using System.Linq;
 using Algorithms.Sorters;
 
-namespace Algorithms.Compressors
+namespace Algorithms.DataCompression
 {
     /// <summary>
     /// Greedy lossless compression algorithm.
@@ -53,6 +53,14 @@ public HuffmanCompressor(ISorter<ListNode> sorter, Translator translator)
             return (translator.Translate(uncompressedText, compressionKeys), decompressionKeys);
         }
 
+        private static void AddMany(IDictionary<string, string> keys, IEnumerable<(string key, string value)> enumerable)
+        {
+            foreach (var (key, value) in enumerable)
+            {
+                keys.Add(key, value);
+            }
+        }
+
         private (Dictionary<string, string> compressionKeys, Dictionary<string, string> decompressionKeys) GetKeys(ListNode tree)
         {
             var compressionKeys = new Dictionary<string, string>();
@@ -84,14 +92,6 @@ public HuffmanCompressor(ISorter<ListNode> sorter, Translator translator)
             return (compressionKeys, decompressionKeys);
         }
 
-        private static void AddMany(IDictionary<string, string> keys, IEnumerable<(string key, string value)> enumerable)
-        {
-            foreach (var (key, value) in enumerable)
-            {
-                keys.Add(key, value);
-            }
-        }
-
         private ListNode GenerateHuffmanTree(ListNode[] nodes)
         {
             var comparer = new ListNodeComparer();
@@ -137,16 +137,6 @@ private ListNode[] GetListNodesFromText(string text)
         /// </summary>
         public class ListNode
         {
-            public char Data { get; }
-
-            public bool HasData { get; }
-
-            public double Frequency { get; }
-
-            public ListNode RightChild { get; }
-
-            public ListNode LeftChild { get; }
-
             public ListNode(char data, double frequency)
             {
                 HasData = true;
@@ -160,6 +150,16 @@ public ListNode(ListNode leftChild, ListNode rightChild)
                 RightChild = rightChild;
                 Frequency = leftChild.Frequency + rightChild.Frequency;
             }
+
+            public char Data { get; }
+
+            public bool HasData { get; }
+
+            public double Frequency { get; }
+
+            public ListNode RightChild { get; }
+
+            public ListNode LeftChild { get; }
         }
 
         private class ListNodeComparer : IComparer<ListNode>

Algorithms/Compressors/ShannonFano.cs renamed to Algorithms/DataCompression/ShannonFanoCompressor.cs

@@ -2,7 +2,7 @@
 using System.Linq;
 using Algorithms.Knapsack;
 
-namespace Algorithms.Compressors
+namespace Algorithms.DataCompression
 {
     /// <summary>
     /// Greedy lossless compression algorithm.
@@ -22,7 +22,7 @@ public ShannonFanoCompressor(IHeuristicKnapsackSolver<(char symbol, double frequ
         /// Given an input string, returns a new compressed string
         /// using Shannon-Fano enconding.
         /// </summary>
-        /// <param name="inputText">Text message to compress.</param>
+        /// <param name="uncompressedText">Text message to compress.</param>
         /// <returns>Compressed string and keys to decompress it.</returns>
         public (string compressedText, Dictionary<string, string> decompressionKeys) Compress(string uncompressedText)
         {
@@ -126,13 +126,13 @@ private ListNode GetListNodeFromText(string text)
         /// </summary>
         public class ListNode
         {
+            public ListNode((char symbol, double frequency)[] data) => Data = data;
+
             public (char symbol, double frequency)[] Data { get; }
 
             public ListNode RightChild { get; set; }
 
             public ListNode LeftChild { get; set; }
-
-            public ListNode((char symbol, double frequency)[] data) => Data = data;
         }
     }
 }

Algorithms/Compressors/Translator.cs renamed to Algorithms/DataCompression/Translator.cs

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using System.Text;
 
-namespace Algorithms.Compressors
+namespace Algorithms.DataCompression
 {
     public class Translator
     {

Algorithms/Encoders/HillEncoder.cs

@@ -64,23 +64,6 @@ public string Decode(string text, double[,] key)
         /// <returns>Message.</returns>
         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.
-        /// </summary>
-        /// <param name="list">List of ciphered arrays.</param>
-        /// <returns>unidimensional list.</returns>
-        private double[] MergeArrayList(double[][] list)
-        {
-            var merged = new double[list.Length * 3];
-
-            for (var i = 0; i < list.Length; i++)
-            {
-                Array.Copy(list[i], 0, merged, i * 3, list[0].Length);
-            }
-
-            return merged;
-        }
-
         /// <summary>
         /// Multiplies the key for the given scalar.
         /// </summary>
@@ -102,6 +85,23 @@ private static double[] MatrixCipher(double[] vector, double[,] key)
             return multiplied;
         }
 
+        /// <summary>
+        /// Given a list of vectors, returns a single array of elements.
+        /// </summary>
+        /// <param name="list">List of ciphered arrays.</param>
+        /// <returns>unidimensional list.</returns>
+        private double[] MergeArrayList(double[][] list)
+        {
+            var merged = new double[list.Length * 3];
+
+            for (var i = 0; i < list.Length; i++)
+            {
+                Array.Copy(list[i], 0, merged, i * 3, list[0].Length);
+            }
+
+            return merged;
+        }
+
         /// <summary>
         /// Splits the input text message as chunks of words.
         /// </summary>

Algorithms/Numeric/GaussJordanElimination.cs

@@ -38,15 +38,7 @@ public bool Solve(double[,] matrix)
         /// <param name="matrix">Multidimensional array matrix.</param>
         /// <returns>True: if algorithm can be use for given matrix;
         /// False: Otherwise. </returns>
-        private bool CanMatrixBeUsed(double[,] matrix)
-        {
-            if (matrix == null || matrix.Length != RowCount * (RowCount + 1))
-            {
-                return false;
-            }
-
-            return RowCount > 1;
-        }
+        private bool CanMatrixBeUsed(double[,] matrix) => matrix?.Length == RowCount * (RowCount + 1) && RowCount > 1;
 
         /// <summary>
         /// To prepare given matrix by pivoting rows.

Algorithms/Other/fermat_prime_checker.cs

@@ -25,7 +25,7 @@ private static void Main()
             var exponentBigInteger = new BigInteger(numberToTest - 1);
 
             // Create a random number generator using the current time as seed
-            var r = new Random(new DateTime().Millisecond);
+            var r = new Random(default(DateTime).Millisecond);
 
             var iterator = 1;
             var prime = true;

Algorithms/Search/AStar/Location.cs

@@ -4,6 +4,19 @@ namespace AStar
 {
     public class Location : IEquatable<Location>
     {
+        // Constructors
+        public Location(int a, int b, Location p)
+        {
+            X = a;
+            Y = b;
+            Parent = p;
+
+            G = p == null ? 0 : p.G + 1;
+
+            H = Program.ComputeHScore(X, Y);
+            F = G + H;
+        }
+
         // Properties
         public int F
         {
@@ -38,19 +51,6 @@ public int Y
             get;
         }
 
-        // Constructors
-        public Location(int a, int b, Location p)
-        {
-            X = a;
-            Y = b;
-            Parent = p;
-
-            G = p == null ? 0 : p.G + 1;
-
-            H = Program.ComputeHScore(X, Y);
-            F = G + H;
-        }
-
         // Methods
         public bool Equals(Location other) => X == other.X && Y == other.Y;
     }

Algorithms/Sorters/BinaryInsertionSorter.cs

@@ -30,8 +30,8 @@ public void Sort(T[] array, IComparer<T> comparer)
 
         /// <summary>Implementation of Binary Search using an iterative approach.</summary>
         /// <param name="array">An array of values sorted in ascending order between the index values left and right to search through.</param>
-        /// <param name="left">Left index to search from (inclusive).</param>
-        /// <param name="right">Right index to search to (inclusive).</param>
+        /// <param name="from">Left index to search from (inclusive).</param>
+        /// <param name="to">Right index to search to (inclusive).</param>
         /// <param name="target">The value to find placefor in the provided array.</param>
         /// <returns>The index where to insert target value.</returns>
         private static int BinarySearch(T[] array, int from, int to, T target, IComparer<T> comparer)

Algorithms/Sorters/BucketSort.cs renamed to Algorithms/Sorters/BucketSorter.cs

@@ -7,7 +7,7 @@ namespace Algorithms.Sorters
     /// <summary>
     /// Class that implements the BuckerSort Algorithm.
     /// </summary>
-    public class BucketSort : ISorter<int>
+    public class BucketSorter : ISorter<int>
     {
         private const int NumOfDigitsInBase10 = 10;
 

Algorithms/Sorters/ISorter.cs

@@ -2,8 +2,17 @@
 
 namespace Algorithms.Sorters
 {
+    /// <summary>
+    /// Sorts array in ascending order.
+    /// </summary>
+    /// <typeparam name="T">Type of array item.</typeparam>
     public interface ISorter<T>
     {
+        /// <summary>
+        /// Sorts array in ascending order.
+        /// </summary>
+        /// <param name="array">Array to sort.</param>
+        /// <param name="comparer">Comparer to compare items of <paramref name="array"/>.</param>
         void Sort(T[] array, IComparer<T> comparer);
     }
 }

Algorithms/Sorters/cocktail_sort.cs

@@ -1,31 +1,7 @@
-using System;
-
-namespace cocktail_sort
+namespace cocktail_sort
 {
     internal class Program
     {
-        private static void Main()
-        {
-            Console.WriteLine("Please enter some integers, separated by spaces:");
-
-            var input = Console.ReadLine();
-            var integers = input.Split(' ');
-            var data = new int[integers.Length];
-
-            for (var i = 0; i < data.Length; i++)
-            {
-                data[i] = int.Parse(integers[i]);
-            }
-
-            Console.WriteLine("Unsorted: {0}", string.Join(" ", data));
-
-            CocktailSort(data);
-
-            Console.WriteLine("Sorted: {0}", string.Join(" ", data));
-
-            _ = Console.ReadKey();
-        }
-
         public static void CocktailSort(int[] intArray)
         {
             var swapped = true;

Algorithms/Sorters/cycle_sort.cs

@@ -1,36 +1,7 @@
-using System;
-
 namespace cycle_sort
 {
     internal class Program
     {
-        private static void Main()
-        {
-            Console.WriteLine("Please enter some integers, separated by spaces:");
-            var input = Console.ReadLine();
-            var integers = input.Split(' ');
-            var data = new int[integers.Length];
-            for (var i = 0; i < data.Length; i++)
-            {
-                data[i] = int.Parse(integers[i]);
-            }
-
-            Console.Write("\nUnsorted: ");
-            for (var i = 0; i < data.Length; i++)
-            {
-                Console.Write(data[i] + " ");
-            }
-
-            CycleSort(data);
-            Console.Write("\nSorted: ");
-            for (var i = 0; i < data.Length; i++)
-            {
-                Console.Write(data[i] + " ");
-            }
-
-            _ = Console.ReadKey();
-        }
-
         public static void CycleSort(int[] data)
         {
             for (var cycleStart = 0; cycleStart <= data.Length - 2; cycleStart++)