Added TSP components

GeneticAlgorithm.UnitTests/Components/CrossoverManagers/CycleCrossoverManagerTests.cs

@@ -0,0 +1,80 @@
+using System.Collections.Generic;
+using System.Linq;
+using GeneticAlgorithm.Components.Chromosomes;
+using GeneticAlgorithm.Components.CrossoverManagers;
+using GeneticAlgorithm.Components.PopulationGenerators;
+using GeneticAlgorithm.Interfaces;
+using GeneticAlgorithm.UnitTests.TestUtils;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace GeneticAlgorithm.UnitTests.Components.CrossoverManagers
+{
+    [TestClass]
+    public class CycleCrossoverManagerTests
+    {
+        private static readonly List<string> elements = new List<string>() { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J" };
+        private readonly IPopulationGenerator generator = new AllElementsVectorChromosomePopulationGenerator<string>(elements, null, null);
+        private readonly ICrossoverManager crossoverManager = new CycleCrossoverManager<string>(null, null);
+
+        [TestMethod]
+        public void CycleCrossoverTest1()
+        {
+            var parent1 = new[] {"A", "B", "C", "D", "E"};
+            var parent2 = new[] {"D", "E", "C", "A", "B"};
+            var expectedChild = new[] {"A", "E", "C", "D", "B"};
+
+            TestCycleCrossover(parent1, parent2, expectedChild);
+        }
+
+        [TestMethod]
+        public void CycleCrossoverTest2()
+        {
+            var parent1 = new[] { "A", "B", "C", "D", "E" };
+            var parent2 = new[] { "A", "B", "C", "D", "E" };
+            var expectedChild = new[] { "A", "B", "C", "D", "E" };
+
+            TestCycleCrossover(parent1, parent2, expectedChild);
+        }
+
+        [TestMethod]
+        public void CycleCrossoverTest3()
+        {
+            var parent1 = new[] { "A", "B", "C", "D", "E" };
+            var parent2 = new[] { "D", "A", "E", "C", "B" };
+            var expectedChild = new[] { "A", "B", "C", "D", "E" };
+
+            TestCycleCrossover(parent1, parent2, expectedChild);
+        }
+
+        [TestMethod]
+        public void CycleCrossoverTest()
+        {
+            var parent1 = new[] { "A", "B", "C", "D", "E", "F" };
+            var parent2 = new[] { "D", "E", "F", "A", "B", "C" };
+            var expectedChild = new[] { "A", "E", "C", "D", "B", "F" };
+
+            TestCycleCrossover(parent1, parent2, expectedChild);
+        }
+
+        [TestMethod]
+        [DataRow(20)]
+        public void CycleCrossover_AllElementsInEachVector(int vectors)
+        {
+            for (int i = 0; i < vectors; i++)
+            {
+                var parentChromosomes = generator.GeneratePopulation(2);
+                var child = (VectorChromosome<string>)crossoverManager.Crossover(parentChromosomes.ElementAt(0), parentChromosomes.ElementAt(1));
+                child.AssertContainSameElements(elements);
+            }
+        }
+
+        private void TestCycleCrossover(string[] parent1, string[] parent2, string[] expectedChild)
+        {
+            var chromosome1 = new VectorChromosome<string>(parent1, null, null);
+            var chromosome2 = new VectorChromosome<string>(parent2, null, null);
+
+            var child = (VectorChromosome<string>)crossoverManager.Crossover(chromosome1, chromosome2);
+            child.AssertAreTheSame(expectedChild);
+        }
+    }
+}

GeneticAlgorithm.UnitTests/Components/CrossoverManagers/K_PointCrossoverTests.cs

@@ -0,0 +1,88 @@
+using System.Collections.Generic;
+using System.Linq;
+using FakeItEasy;
+using GeneticAlgorithm.Components.Chromosomes;
+using GeneticAlgorithm.Components.CrossoverManagers;
+using GeneticAlgorithm.Components.Interfaces;
+using GeneticAlgorithm.Components.PopulationGenerators;
+using GeneticAlgorithm.Interfaces;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace GeneticAlgorithm.UnitTests.Components.CrossoverManagers
+{
+    [TestClass]
+    public class K_PointCrossoverTests
+    {
+        private const int TEST_RUNS = 20;
+        private const int SMALL_CHROMOSOME_SIZE = 10;
+        private const int LARGE_CHROMOSOME_SIZE = 20;
+
+        private readonly IPopulationGenerator smallPopulationGenerator1 =
+            new IntVectorChromosomePopulationGenerator(SMALL_CHROMOSOME_SIZE, 0, 10, A.Fake<IMutationManager<int>>(),
+                A.Fake<IEvaluator>());
+        private readonly IPopulationGenerator smallPopulationGenerator2 =
+            new IntVectorChromosomePopulationGenerator(SMALL_CHROMOSOME_SIZE, 11, 20, A.Fake<IMutationManager<int>>(),
+                A.Fake<IEvaluator>());
+        private readonly IPopulationGenerator largePopulationGenerator =
+            new IntVectorChromosomePopulationGenerator(LARGE_CHROMOSOME_SIZE, 21, 30, A.Fake<IMutationManager<int>>(),
+                A.Fake<IEvaluator>());
+
+        [TestMethod]
+        [DataRow(1)]
+        [DataRow(2)]
+        [DataRow(5)]
+        [DataRow(SMALL_CHROMOSOME_SIZE - 1)]
+        public void K_PointCrossoverTest(int k)
+        {
+            var crossoverManager = new K_PointCrossoverManager<int>(k, A.Fake<IMutationManager<int>>(), A.Fake<IEvaluator>());
+            for (int i = 0; i < TEST_RUNS; i++)
+            {
+                var chromosome1 = (VectorChromosome<int>)smallPopulationGenerator1.GeneratePopulation(1).First();
+                var chromosome2 = (VectorChromosome<int>)smallPopulationGenerator2.GeneratePopulation(1).First();
+                var newChromosome = (VectorChromosome<int>)crossoverManager.Crossover(chromosome1, chromosome2);
+
+                var crossoverPoints = Utils.K_CrossoverGetCrossoverPointsAndAssertThatGenomesAreRight(newChromosome, chromosome2, chromosome1);
+                Assert.AreEqual(k, crossoverPoints.Count,
+                    $"Found wrong number of crossoverPoints. 1: {chromosome1}; 2 {chromosome2}; newChromosome {newChromosome}");
+            }
+        }
+
+        [TestMethod]
+        [DataRow(1)]
+        [DataRow(2)]
+        [DataRow(5)]
+        [DataRow(SMALL_CHROMOSOME_SIZE - 1)]
+        public void K_PointCrossover_ShortAndLongChromosomes(int k)
+        {
+            var crossoverManager = new K_PointCrossoverManager<int>(k, A.Fake<IMutationManager<int>>(), A.Fake<IEvaluator>());
+            for (int i = 0; i < TEST_RUNS; i++)
+            {
+                var chromosome1 = (VectorChromosome<int>)smallPopulationGenerator1.GeneratePopulation(1).First();
+                var chromosome2 = (VectorChromosome<int>)largePopulationGenerator.GeneratePopulation(1).First();
+                var newChromosome = (VectorChromosome<int>)crossoverManager.Crossover(chromosome1, chromosome2);
+
+                var crossoverPoints = Utils.K_CrossoverGetCrossoverPointsAndAssertThatGenomesAreRight(newChromosome, chromosome2, chromosome1);
+                Assert.AreEqual(k, crossoverPoints.Count,
+                    $"Found wrong number of crossoverPoints. 1: {chromosome1}; 2 {chromosome2}; newChromosome {newChromosome}");
+            }
+        }
+
+        [TestMethod]
+        public void K_PointCrossover_CrossoverPointsAreDiffrent()
+        {
+            var crossoverPoints = new List<int>();
+            var crossoverManager = new K_PointCrossoverManager<int>(2, A.Fake<IMutationManager<int>>(), A.Fake<IEvaluator>());
+            for (int i = 0; i < 100; i++)
+            {
+                var chromosome1 = (VectorChromosome<int>)smallPopulationGenerator1.GeneratePopulation(1).First();
+                var chromosome2 = (VectorChromosome<int>)smallPopulationGenerator2.GeneratePopulation(1).First();
+                var newChromosome = (VectorChromosome<int>)crossoverManager.Crossover(chromosome1, chromosome2);
+
+                crossoverPoints.AddRange(Utils.K_CrossoverGetCrossoverPointsAndAssertThatGenomesAreRight(newChromosome, chromosome2, chromosome1));
+            }
+
+            for (int i = 1; i < SMALL_CHROMOSOME_SIZE; i++)
+                Assert.IsTrue(crossoverPoints.Contains(i), $"{nameof(crossoverPoints)} dosn't contain {i}");
+        }
+    }
+}

GeneticAlgorithm.UnitTests/Components/CrossoverManagers/OrderCrossoverTests.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using GeneticAlgorithm.Components.Chromosomes;
+using GeneticAlgorithm.Components.CrossoverManagers;
+using GeneticAlgorithm.Components.PopulationGenerators;
+using GeneticAlgorithm.Interfaces;
+using GeneticAlgorithm.UnitTests.TestUtils;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace GeneticAlgorithm.UnitTests.Components.CrossoverManagers
+{
+    [TestClass]
+    public class OrderCrossoverTests
+    {
+        private static readonly List<string> elements = new List<string>() { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J" };
+        private readonly IPopulationGenerator generator = new AllElementsVectorChromosomePopulationGenerator<string>(elements, null, null);
+        private readonly ICrossoverManager crossoverManager = new OrderCrossover<string>(null, null);
+
+        [TestMethod]
+        [DataRow(20)]
+        public void OrderCrossover_AllElementsInEachVector(int vectors)
+        {
+            for (int i = 0; i < vectors; i++)
+            {
+                var parentChromosomes = generator.GeneratePopulation(2);
+                var child = (VectorChromosome<string>)crossoverManager.Crossover(parentChromosomes.ElementAt(0), parentChromosomes.ElementAt(1));
+                child.AssertContainSameElements(elements);
+            }
+        }
+
+        [TestMethod]
+        public void OrderCrossover_ChildChanged()
+        {
+            // Since there's a certain chance that this test will fail, I want to run it twice
+            var passed = false;
+            for (int i = 0; i < 2; i++)
+            {
+                var parentChromosomes = generator.GeneratePopulation(2);
+                var child = (VectorChromosome<string>) crossoverManager.Crossover(parentChromosomes.ElementAt(0),
+                    parentChromosomes.ElementAt(1));
+
+                try
+                {
+                    ((VectorChromosome<string>)parentChromosomes.ElementAt(0)).AssertAreNotTheSame(child);
+                    ((VectorChromosome<string>)parentChromosomes.ElementAt(1)).AssertAreNotTheSame(child);
+                    passed = true;
+                }
+                catch
+                {
+                    // Do nothing
+                }
+            }
+            Assert.IsTrue(passed);
+        }
+    }
+}