public void RandomInitialize()
 {
     // Generate Initial Population
     while (IndividualCount < this.InitialPopulationSize)
     {
         IndividualBase individual = Problem.CreateRandomSolution();
         Problem.ValidateIndividual(individual);
         IndividualEvaluator.Execute(individual, Problem);
         if (!Content.Contains(individual))
         {
             AddIndividual(individual);
         }
     }
 }
Beispiel #2
0
        private Population_MultiObjective_AG Procreate(Population_MultiObjective_AG mating)
        {
            int expectedChildCount = InitialPopulationSize;

            Population_MultiObjective_AG newGeneration = new Population_MultiObjective_AG(Problem, expectedChildCount);

            while (newGeneration.IndividualCount < expectedChildCount)
            {
                // Selection Method
                IndividualBase parent1 = BinaryTournment(mating);
                IndividualBase parent2 = BinaryTournment(mating);
                IndividualBase child1 = null, child2 = null;

                // Crossover Method
                Problem.PMXCrossover(parent1, parent2, out child1, out child2);
                for (int i = 0; i < 10; ++i)
                {
                    if (!newGeneration.Content.Contains(child1) || i == 9)
                    {
                        newGeneration.AddIndividual(child1);
                        break;
                    }
                }
                for (int i = 0; i < 10; ++i)
                {
                    if (!newGeneration.Content.Contains(child2) || i == 9)
                    {
                        newGeneration.AddIndividual(child2);
                        break;
                    }
                }
            }

            foreach (IndividualBase individual in newGeneration.Content)
            {
                int aleatoryPercentage = Aleatoriety.GetRandomInt(100);
                if (aleatoryPercentage < mutationPct)
                {
                    Problem.MutateIndividual(individual);
                }
                Problem.ValidateIndividual(individual);
                IndividualEvaluator.Execute(individual, Problem);
            }
            return(newGeneration);
        }
        protected override void EvaluateObjectiveValues()
        {
            // Create Temporary Individuals
            List <IndividualBase> temporaryList = new List <IndividualBase>();

            for (int iCount = 0; iCount < 200; ++iCount)
            {
                IndividualBase i = Problem.CreateRandomSolution();
                IndividualEvaluator.Execute(i, Problem);
                temporaryList.Add(i);
            }

            foreach (Objective objective in Problem.MultiObjectiveGoal)
            {
                double maxValueFound   = temporaryList.Max(I => I.GetFitnessForObjective(objective));
                double adaptedMaxValue = Math.Abs(maxValueFound) * 2;
                objective.BigValueForMaximization = adaptedMaxValue;
            }
        }