Merge branch 'release/2.2.1'

src/GeneticSharp.Extensions.UnitTests/Sudoku/SudokuBoardTest.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using GeneticSharp.Extensions.Sudoku;
+using NUnit.Framework;
+
+namespace GeneticSharp.Extensions.UnitTests.Sudoku
+{
+
+
+    [TestFixture()]
+    [Category("Extensions")]
+    public class SudokuBoardTest
+    {
+        [Test()]
+        public void Constructor_TooManyCells_Exception()
+        {
+            var tooMuchCells = Enumerable.Repeat(0, 82);
+            var actual = Assert.Catch<ArgumentException>(() =>
+            {
+                new SudokuBoard(tooMuchCells);
+            });
+            Assert.AreEqual("cells", actual.ParamName);
+        }
+
+        /// <summary>
+        /// The sample sudoku string should parse properly into corresponding cells
+        /// </summary>
+        [Test()]
+        public void Parse_SampleString_ConsistantCells()
+        {
+
+            var sudoku = SudokuTestHelper.CreateBoard();
+
+            Assert.AreEqual(sudoku.Cells[0], 9);
+            Assert.AreEqual(sudoku.Cells[1], 0);
+            Assert.AreEqual(sudoku.Cells[2], 2);
+            Assert.AreEqual(sudoku.Cells[sudoku.Cells.Count - 2], 5);
+            Assert.AreEqual(sudoku.Cells[sudoku.Cells.Count - 1], 0);
+
+            sudoku.SetCell(0,0,0);
+            Assert.AreEqual(sudoku.Cells[0], 0);
+            var stringExport = sudoku.ToString();
+            var currentIndex = 0;
+            foreach (var sudokuCell in sudoku.Cells)
+            {
+                var newIndex = stringExport.IndexOf(sudokuCell.ToString(CultureInfo.InvariantCulture), currentIndex, StringComparison.Ordinal);
+                Assert.Greater(newIndex, currentIndex);
+                currentIndex = newIndex+1;
+            }
+        }
+
+
+        /// <summary>
+        /// The sample sudoku file should parse properly into corresponding individual Sudokus
+        /// </summary>
+        [Test()]  
+        public void Parse_SampleFile_SudokusAreParsedFromFile()
+        {
+
+            var fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Sudoku", "SudokuList.sdk");
+            var sudokus = SudokuBoard.ParseFile(fileName);
+            Assert.AreEqual(sudokus.Count, 16002);
+            Assert.AreEqual(sudokus[0].Cells[2], 7);
+            Assert.AreEqual(sudokus[1].Cells[1], 2);
+        }
+    }
+}

src/GeneticSharp.Extensions.UnitTests/Sudoku/SudokuCellsChromosomeTest.cs

@@ -0,0 +1,35 @@
+using GeneticSharp.Extensions.Sudoku;
+using NUnit.Framework;
+
+namespace GeneticSharp.Extensions.UnitTests.Sudoku
+{
+    [TestFixture]
+    [Category("Extensions")]
+    public class SudokuCellsChromosomeTest
+    {
+        [Test]
+        public void Constructor_NoArgs_Length81()
+        {
+            var target = new SudokuCellsChromosome();
+            Assert.AreEqual(81, target.Length);
+
+            var genes = target.GetGenes();
+            Assert.AreEqual(81, genes.Length);
+        }
+
+        /// <summary>
+        /// The cells chromosome might need more individuals, so in order to keep execution time low, we only expect near completion
+        /// </summary>
+        [Test]
+        public void Evolve_SimpleSudokuCellsChromosome_NearlySolved()
+        {
+            var sudoku = SudokuTestHelper.CreateBoard();
+
+            //the cells chromosome should solve the sudoku or nearly in less than 50 generations with 500 chromosomes
+            var chromosome = new SudokuCellsChromosome(sudoku);
+            var fitness = SudokuTestHelper.Eval(chromosome, sudoku, 500, -20, 30);
+            Assert.GreaterOrEqual(fitness, -20);
+
+        }
+    }
+}

src/GeneticSharp.Extensions.UnitTests/Sudoku/SudokuPermutationsChromosomeTest.cs

@@ -0,0 +1,34 @@
+using GeneticSharp.Domain.Chromosomes;
+using GeneticSharp.Extensions.Sudoku;
+using NUnit.Framework;
+
+namespace GeneticSharp.Extensions.UnitTests.Sudoku
+{
+    [TestFixture]
+    [Category("Extensions")]
+    public class SudokuPermutationsChromosomeTest
+    {
+        [Test]
+        public void Constructor_NoArgs_Length9()
+        {
+            var target = new SudokuPermutationsChromosome();
+            Assert.AreEqual(9, target.Length);
+
+            var genes = target.GetGenes();
+            Assert.AreEqual(9, genes.Length);
+        }
+
+        /// <summary>
+        /// The permutation chromosome should always solve the sudoku in a reasonable time with 1000 chromosomes
+        /// </summary>
+        [Test]
+        public void Evolve_SimpleSudokuPermutationsChromosome_Solved()
+        {
+            var sudoku = SudokuTestHelper.CreateBoard();
+
+            IChromosome chromosome = new SudokuPermutationsChromosome(sudoku);
+            var fitness = SudokuTestHelper.Eval(chromosome, sudoku, 1000, 0, 50);
+            Assert.AreEqual(fitness, 0);
+        }
+    }
+}

src/GeneticSharp.Extensions.UnitTests/Sudoku/SudokuRandomPermutationsChromosomeTest.cs

@@ -0,0 +1,37 @@
+using GeneticSharp.Extensions.Sudoku;
+using NUnit.Framework;
+
+namespace GeneticSharp.Extensions.UnitTests.Sudoku
+{
+    [TestFixture]
+    [Category("Extensions")]
+    public class SudokuRandomPermutationsChromosomeTest
+    {
+        [Test]
+        public void Constructor_NoArgs_Length9()
+        {
+            var target = new SudokuRandomPermutationsChromosome();
+            Assert.AreEqual(9, target.Length);
+
+            var genes = target.GetGenes();
+            Assert.AreEqual(9, genes.Length);
+        }
+
+        /// <summary>
+        /// The random permutations chromosome require more individuals and generations, so we only test for significant progresses
+        /// </summary>
+        [Test]
+        public void Evolve_SimpleSudokuRandomPermutationsChromosome_Progressed()
+        {
+            var sudoku = SudokuTestHelper.CreateBoard();
+
+            //the Random permutations chromosome should make significant progresses over 3 generations with 5 individuals
+
+            var chromosome = new SudokuRandomPermutationsChromosome(sudoku, 2, 3);
+            var fitness1 = new SudokuFitness(sudoku).Evaluate((ISudokuChromosome)chromosome);
+            var fitness2 = SudokuTestHelper.Eval(chromosome, sudoku, 5, fitness1 + 20, 3);
+            Assert.GreaterOrEqual(fitness2, fitness1 + 20);
+
+        }
+    }
+}

src/GeneticSharp.Extensions.UnitTests/Sudoku/SudokuTestHelper.cs

@@ -0,0 +1,46 @@
+using System.Linq;
+using GeneticSharp.Domain;
+using GeneticSharp.Domain.Chromosomes;
+using GeneticSharp.Domain.Crossovers;
+using GeneticSharp.Domain.Mutations;
+using GeneticSharp.Domain.Populations;
+using GeneticSharp.Domain.Selections;
+using GeneticSharp.Domain.Terminations;
+using GeneticSharp.Extensions.Sudoku;
+
+namespace GeneticSharp.Extensions.UnitTests.Sudoku
+{
+    public static class SudokuTestHelper
+    {
+        private static readonly string _easySudokuString = "9.2..54.31...63.255.84.7.6..263.9..1.57.1.29..9.67.53.24.53.6..7.52..3.4.8..4195.";
+
+        public static SudokuBoard CreateBoard()
+        {
+            return SudokuBoard.Parse(_easySudokuString);
+        }
+
+        public static double Eval(IChromosome sudokuChromosome, SudokuBoard sudokuBoard, int populationSize, double fitnessThreshold, int generationNb)
+        {
+            var fitness = new SudokuFitness(sudokuBoard);
+            var selection = new EliteSelection();
+            var crossover = new UniformCrossover();
+            var mutation = new UniformMutation();
+
+            var population = new Population(populationSize, populationSize, sudokuChromosome);
+            var ga = new GeneticAlgorithm(population, fitness, selection, crossover, mutation)
+            {
+                Termination = new OrTermination(new ITermination[]
+                {
+                    new FitnessThresholdTermination(fitnessThreshold),
+                    new GenerationNumberTermination(generationNb)
+                })
+            };
+
+            ga.Start();
+
+            var bestIndividual = ((ISudokuChromosome)ga.Population.BestChromosome);
+            var solutions = bestIndividual.GetSudokus();
+            return solutions.Max(solutionSudoku => fitness.Evaluate(solutionSudoku));
+        }
+    }
+}