Пример #1
0
    /// <summary>
    /// Moves a piece to another place on the board
    /// </summary>
    /// <param name="oldBoard"> the board before the piece is moved </param>
    /// <param name="pieceToMove"> the piece to be moved on the board </param>
    /// <param name="squareToMoveTo"> yhe square to move the piece to </param>
    public Move(char[] oldBoard, int pieceToMove, int squareToMoveTo)
    {
        from = pieceToMove;
        to   = squareToMoveTo;

        newBoard = new char[oldBoard.Length];


        for (int i = 0; i < newBoard.Length; i++)
        {
            if (i == squareToMoveTo)
            {
                //moves piece to new place
                newBoard[i] = oldBoard[pieceToMove];
            }
            else
            {
                //Just copy it over
                newBoard[i] = oldBoard[i];
            }
        }

        //Enpassant check
        if (to == BoardManager.Instance.enPassentIndex && char.ToUpper(oldBoard[from]) == 'P')
        {
            if (from > to && to + 8 < newBoard.Length)
            {
                //Moving downward
                newBoard[to + 8] = '\0';
                enpassentIndex   = to + 8;
            }
            else if (to - 8 >= 0)
            {
                //Moving upward
                newBoard[to - 8] = '\0';
                enpassentIndex   = to - 8;
            }
        }

        //Promotion Check
        if ((char.ToUpper(movedPiece) == 'P') && (to > 55 || to < 8))
        {
            //Promoted
            if (TurnManager.Instance.IsPlayerTurn())
            {
                //Prompt player for which piece they want
            }
            else
            {
                //Choose queen, as statistcally it is the best choice
                newBoard[to]  = (GameManager.Instance.playerTeam == PieceScript.Team.White) ? 'q' : 'Q';
                promotionType = PieceScript.Type.Queen;
            }
        }

        //Remove old piece
        newBoard[pieceToMove] = '\0';


        //Set Self Fitness
        self_fitness = FitnessEvaluator.Evaluate(newBoard);

        pathFitness = self_fitness;
    }
Пример #2
0
        static void Main(string[] args)
        {
            string targetPhenotype;
            int    popSize;
            long   maxGenerations;
            long   totalGenerationsPassed = 0;
            double bestFitness            = 0.0;
            double mutationRate;
            double crossoverRate;

            Random        random     = new Random();
            Stopwatch     stopwatch  = new Stopwatch();
            List <Genome> population = new List <Genome>();

            List <Tuple <double, Genome> > evaluatedPopulation = new List <Tuple <double, Genome> >();

            List <Task <Tuple <double, Genome> > > taskList = new List <Task <Tuple <double, Genome> > >();

            (popSize,
             maxGenerations,
             mutationRate,
             crossoverRate,
             targetPhenotype) = MultiStrandCLISetup();

            for (int i = 0; i < popSize; i++)
            {
                /*
                 * The initial population has random generators seeded with randomly generated numbers.
                 * That way the states of generators won't be the same and mutations will be applied in more stochastic manner.
                 */
                population.Add(new Genome(targetPhenotype.Length, random.Next()));
            }

            stopwatch.Start();

            while (bestFitness != 1 && maxGenerations <= totalGenerationsPassed)
            {
                foreach (Genome genome in population)
                {
                    taskList.Add(
                        Task.Run(
                            () => FitnessEvaluator.EvaluateGenome(targetPhenotype, genome)));
                }
                for (int i = 0; i < popSize; i++)
                {
                    evaluatedPopulation.Add(taskList[i].Result);
                }

                evaluatedPopulation = evaluatedPopulation.OrderBy(
                    genomeFitnessPair => genomeFitnessPair.Item1).ToList();

                //Clear lists
                population.Clear();
                taskList.Clear();

                //Keep only the 10 best individuals
                evaluatedPopulation = evaluatedPopulation.TakeLast(10).ToList();

                bestFitness = evaluatedPopulation.Last().Item1;

                //Print results every 10th generations or if the optimum fitness is met.
                if (totalGenerationsPassed % 10 == 0 || bestFitness == 1.0)
                {
                    Console.WriteLine("Generation: {2} \nBest fitness: {0} \nText: {1} \n\n",
                                      bestFitness,
                                      evaluatedPopulation.First().Item2.Genes,
                                      totalGenerationsPassed);
                }

                for (int index = 0; index < popSize; index++)
                {
                    if (random.NextDouble() <= crossoverRate)
                    {
                        population.Add(
                            evaluatedPopulation[(index + 1) % evaluatedPopulation.Count].Item2.Cross(
                                evaluatedPopulation[index % evaluatedPopulation.Count].Item2));
                    }
                    else
                    {
                        population.Add(evaluatedPopulation[index % evaluatedPopulation.Count].Item2);
                    }
                }

                foreach (Genome genome in population)
                {
                    genome.Mutate(mutationRate);
                }

                population.Add(evaluatedPopulation[0].Item2);

                totalGenerationsPassed++;
            }

            stopwatch.Stop();

            Console.WriteLine("Time elapsed: {0:T}", stopwatch.Elapsed);
            Console.WriteLine("Over {0} generations.", totalGenerationsPassed);
        }
        /// <summary>
        /// Solves the specified minimum temperature.
        /// </summary>
        /// <param name="minimumTemperature">The minimum temperature.</param>
        /// <param name="maximumTemperature">The maximum temperature.</param>
        /// <param name="iterationCount">The iteration count.</param>
        /// <param name="fitnessEvaluator">The fitness evaluator.</param>
        public void Solve(double minimumTemperature, double maximumTemperature, int iterationCount, FitnessEvaluator fitnessEvaluator)
        {
            double bestFitness = double.PositiveInfinity;
            var    bestValues  = new double[this.Variables.Length];
            //providing initial value for fitness
            double Fitness = fitnessEvaluator();
            double temperatureIncrement = (maximumTemperature - minimumTemperature) / iterationCount;

            for (int i = 0; i <= iterationCount; i++)
            {
                this.randomizeValues();
                //in addition to evaluating fitness, the FitnessEvaluator delegate can also update interface
                double currentFitness = fitnessEvaluator();
                //updating the best set of variable values
                if (currentFitness < bestFitness)
                {
                    for (int j = 0; j < bestValues.Length; j++)
                    {
                        bestValues[j] = this.Variables[j].Value;
                    }
                    bestFitness = currentFitness;
                    this.OnBestFitnessUpdated(new UIEventArgs(bestFitness));
                }
                //annealing core
                if (currentFitness < Fitness)
                {
                    Fitness = currentFitness;
                    this.OnFitnessUpdated(new UIEventArgs(Fitness));
                }
                else // fitness - currentfitness < 0
                {
                    double temperature = minimumTemperature + (iterationCount - i) * temperatureIncrement;
                    double power       = (Fitness - currentFitness) / temperature;
                    double p           = Math.Exp(power);
                    double random      = this._randomizer.NextDouble();
                    if (p > random)
                    {
                        Fitness = currentFitness;
                        this.OnFitnessUpdated(new UIEventArgs(Fitness));
                    }
                    else //revesring the changes in variable values
                    {
                        this.Variables[this._selectedVariableIndex].Value = this._selectedVariablePreviousValue;
                    }
                }
            }
            //updating the variables with the best set of variables
            for (int i = 0; i < this.Variables.Length; i++)
            {
                this.Variables[i].Value = bestValues[i];
            }
        }
Пример #4
0
        /// <summary>
        /// Creates a population and let it evolve until termination condition is reached.
        /// </summary>
        /// <param name="terminationCondition">Evolution termination condition evaluated on each new epoch</param>
        /// <returns>The best solution found across the evolution</returns>
        public ISolution EvolveUntil(TerminationCondition terminationCondition)
        {
            var          rnd                  = RandomProvider.GetThreadRandom();
            var          shiftMatrix          = MatrixBuilder.Build(this.problem);
            var          enumerator           = new IncreasingRowsRandomColumns(this.problem.Days, this.problem.Slots);
            var          constraints          = ConstraintsBuilder.Build(this.problem);
            var          chromoProcessor      = new ChromosomeProcessor(shiftMatrix, enumerator, constraints);
            var          evaluator            = new FitnessEvaluator(problem);
            var          fitnessFunction      = new Fitness.FitnessFunction(chromoProcessor, evaluator, shiftMatrix);
            var          chromosomeLength     = shiftMatrix.GetNumberOfUnforcedSlots();
            const double crossoverProbability = 0.90;
            const double mutationProbability  = 0.05;
            const int    elitismPercentage    = 5;

            epochs = 1;
            epochsWithoutFitnessImprovement = 0;
            overallBestFitness = -1;

            log.Debug("Starting population.");
            var population = new Population();

            for (var i = 0; i < populationSize; i++)
            {
                var c = new Double[chromosomeLength];
                for (var k = 0; k < chromosomeLength; k++)
                {
                    c[k] = rnd.NextDouble();
                }
                var ch = new Chromosome(c);
                population.Solutions.Add(ch);
            }

            //create the genetic operators
            var elite = new Elite(elitismPercentage);

            var crossover = new Crossover(crossoverProbability, true)
            {
                CrossoverType = CrossoverType.SinglePoint
            };

            var mutation = new SwapMutate(mutationProbability);

            //create the GA itself
            var ga = new GeneticAlgorithm(population, fitnessFunction.Evaluate);

            //subscribe to the GAs Generation Complete event
            ga.OnGenerationComplete += Ga_OnGenerationComplete;

            //add the operators to the ga process pipeline
            ga.Operators.Add(elite);
            ga.Operators.Add(crossover);
            ga.Operators.Add(mutation);

            //run the GA
            ga.Run((pop, currentGeneration, currentEvaluation) =>
            {
                return(terminationCondition(currentGeneration, epochsWithoutFitnessImprovement, population.MaximumFitness, population.AverageFitness));
            });

            population.GetTop(1)[0].Evaluate(fitnessFunction.Evaluate);
            return(SolutionBuilder.Build(overallBestFitness, shiftMatrix, epochs * population.PopulationSize, this.problem.Items));
        }