public static Sudoku New(int[,] cellValues)
 {
     return(new Sudoku(MatrixHelper.DuplicateMatrix(cellValues)));
 }
 public static Sudoku New(Sudoku sudoku)
 {
     return(new Sudoku(MatrixHelper.DuplicateMatrix(sudoku.CellValues)));
 }
Exemple #3
0
        private Sudoku SolveInternal(Sudoku sudoku, int numOrganisms, int maxEpochs)
        {
            var numberOfWorkers = (int)(numOrganisms * 0.90);
            //hive, la collection d'organismes.
            var hive = new Organism[numOrganisms];

            var    bestError    = int.MaxValue;
            Sudoku bestSolution = null;

            for (var i = 0; i < numOrganisms; ++i)
            {
                var organismType = i < numberOfWorkers
                  ? OrganismType.Worker
                  : OrganismType.Explorer;

                //Pour le SWARM, nous initialisation une matrice a une solution possible aleatoire
                var randomSudoku = Sudoku.New(MatrixHelper.RandomMatrix(_rnd, sudoku.CellValues));
                var err          = randomSudoku.Error;

                hive[i] = new Organism(organismType, randomSudoku.CellValues, err, 0);

                if (err >= bestError)
                {
                    continue;
                }
                bestError    = err;
                bestSolution = Sudoku.New(randomSudoku);
            }

            var epoch = 0;

            while (epoch < maxEpochs)
            {
                if (epoch % 1000 == 0)
                {
                    Console.WriteLine($"Epoch: {epoch}, Best error: {bestError}");
                }

                if (bestError == 0)
                {
                    break;
                }

                for (var i = 0; i < numOrganisms; ++i)
                {
                    if (hive[i].Type == OrganismType.Worker)
                    {
                        // il existe plusieurs type d'organisme : celles sertvant a l'exploration de solutions aleatoire,
                        //et les organismes analysant les voisins
                        var neighbor       = MatrixHelper.NeighborMatrix(_rnd, sudoku.CellValues, hive[i].Matrix);
                        var neighborSudoku = Sudoku.New(neighbor);
                        var neighborError  = neighborSudoku.Error;

                        var p = _rnd.NextDouble();
                        if (neighborError < hive[i].Error || p < 0.001)
                        {
                            hive[i].Matrix = MatrixHelper.DuplicateMatrix(neighbor);
                            hive[i].Error  = neighborError;
                            if (neighborError < hive[i].Error)
                            {
                                hive[i].Age = 0;
                            }

                            if (neighborError >= bestError)
                            {
                                continue;
                            }
                            bestError    = neighborError;
                            bestSolution = neighborSudoku;
                        }
                        else
                        {
                            hive[i].Age++;
                            if (hive[i].Age <= 1000)
                            {
                                continue;
                            }
                            var randomSudoku = Sudoku.New(MatrixHelper.RandomMatrix(_rnd, sudoku.CellValues));
                            hive[i] = new Organism(0, randomSudoku.CellValues, randomSudoku.Error, 0);
                        }
                    }
                    else
                    {
                        var randomSudoku = Sudoku.New(MatrixHelper.RandomMatrix(_rnd, sudoku.CellValues));
                        hive[i].Matrix = MatrixHelper.DuplicateMatrix(randomSudoku.CellValues);
                        hive[i].Error  = randomSudoku.Error;

                        if (hive[i].Error >= bestError)
                        {
                            continue;
                        }
                        bestError    = hive[i].Error;
                        bestSolution = randomSudoku;
                    }
                }

                // merge best worker with best explorer into worst worker
                var bestWorkerIndex     = 0;
                var smallestWorkerError = hive[0].Error;
                for (var i = 0; i < numberOfWorkers; ++i)
                {
                    if (hive[i].Error >= smallestWorkerError)
                    {
                        continue;
                    }
                    smallestWorkerError = hive[i].Error;
                    bestWorkerIndex     = i;
                }

                var bestExplorerIndex     = numberOfWorkers;
                var smallestExplorerError = hive[numberOfWorkers].Error;
                for (var i = numberOfWorkers; i < numOrganisms; ++i)
                {
                    if (hive[i].Error >= smallestExplorerError)
                    {
                        continue;
                    }
                    smallestExplorerError = hive[i].Error;
                    bestExplorerIndex     = i;
                }

                var worstWorkerIndex   = 0;
                var largestWorkerError = hive[0].Error;
                for (var i = 0; i < numberOfWorkers; ++i)
                {
                    if (hive[i].Error <= largestWorkerError)
                    {
                        continue;
                    }
                    largestWorkerError = hive[i].Error;
                    worstWorkerIndex   = i;
                }
                //les blocks de bonnes solution ssont utiliser afin de creer une bonne solution enfant => en prenant deux bonnes solutions
                //pour une nouvelle iteration
                //cet enfant prends la place d'un mauvaise solution
                var merged       = MatrixHelper.MergeMatrices(_rnd, hive[bestWorkerIndex].Matrix, hive[bestExplorerIndex].Matrix);
                var mergedSudoku = Sudoku.New(merged);

                hive[worstWorkerIndex] = new Organism(0, merged, mergedSudoku.Error, 0);
                if (hive[worstWorkerIndex].Error < bestError)
                {
                    bestError    = hive[worstWorkerIndex].Error;
                    bestSolution = mergedSudoku;
                }

                ++epoch;
            }

            return(bestSolution);
        }