public void SteadyStateGeneticAlgorithm_Initialize_InvalidPopulationReplacement2()
{
SteadyStateGeneticAlgorithm config = new SteadyStateGeneticAlgorithm();
PopulationReplacementValue val = new PopulationReplacementValue(101, ReplacementValueKind.Percentage);
Assert.Throws <ValidationException>(() => config.PopulationReplacementValue = val);
}
public void SteadyStateGeneticAlgorithm_Serialization()
{
SteadyStateGeneticAlgorithm algorithm = new SteadyStateGeneticAlgorithm
{
PopulationReplacementValue = new PopulationReplacementValue(3, ReplacementValueKind.Percentage)
};
SteadyStateGeneticAlgorithm result = (SteadyStateGeneticAlgorithm)SerializationHelper.TestSerialization(
algorithm, new Type[] { typeof(DefaultTerminator) });
Assert.Equal(algorithm.PopulationReplacementValue.Kind, result.PopulationReplacementValue.Kind);
Assert.Equal(algorithm.PopulationReplacementValue.Value, result.PopulationReplacementValue.Value);
}
public async Task SteadyStateGeneticAlgorithm_CreateNextGeneration_Percentage()
{
SteadyStateGeneticAlgorithm algorithm = new SteadyStateGeneticAlgorithm
{
GeneticEntitySeed = new MockEntity(),
PopulationSeed = new SimplePopulation(),
FitnessEvaluator = new MockFitnessEvaluator(),
PopulationReplacementValue = new PopulationReplacementValue(20, ReplacementValueKind.Percentage),
SelectionOperator = new MockSelectionOperator
{
SelectionBasedOnFitnessType = FitnessType.Scaled
},
CrossoverOperator = new MockCrossoverOperator
{
CrossoverRate = 1
},
MutationOperator = new MockMutationOperator
{
MutationRate = 1
}
};
algorithm.SelectionOperator = new MockSelectionOperator {
SelectionBasedOnFitnessType = FitnessType.Scaled
};
algorithm.SelectionOperator.Initialize(algorithm);
algorithm.CrossoverOperator = new MockCrossoverOperator {
CrossoverRate = 1
};
algorithm.CrossoverOperator.Initialize(algorithm);
algorithm.MutationOperator = new MockMutationOperator {
MutationRate = 1
};
algorithm.MutationOperator.Initialize(algorithm);
algorithm.FitnessEvaluator = new MockFitnessEvaluator();
algorithm.FitnessEvaluator.Initialize(algorithm);
await algorithm.InitializeAsync();
PrivateObject ssAccessor = new PrivateObject(algorithm);
SimplePopulation population = GetPopulation(algorithm, 10);
int prevPopCount = population.Entities.Count;
await(Task) ssAccessor.Invoke("CreateNextGenerationAsync", population);
Assert.Equal(1, ((MockSelectionOperator)algorithm.SelectionOperator).DoSelectCallCount);
Assert.Equal(1, ((MockCrossoverOperator)algorithm.CrossoverOperator).DoCrossoverCallCount);
Assert.Equal(2, ((MockMutationOperator)algorithm.MutationOperator).DoMutateCallCount);
Assert.Equal(prevPopCount, population.Entities.Count);
}
public async Task SteadyStateGeneticAlgorithm_CreateNextGeneration_NullPopulation()
{
SteadyStateGeneticAlgorithm algorithm = new SteadyStateGeneticAlgorithm();
PrivateObject accessor = new PrivateObject(algorithm);
await Assert.ThrowsAsync <ArgumentNullException>(() => (Task)accessor.Invoke("CreateNextGenerationAsync", (Population)null));
}
public void Evaluate(GAParametersChromosome chromosome)
{
// if (chromosome.IsEvaluated) return;
_evaluations++;
GAParameters parameters = chromosome.GetValue(0);
_function.Clear();
int iters = 10;
int childEvaluations = 10000;
int maxGenerations = 100;
double[] childGAFitnesses = new double[iters];
var chromosomeRepresentation = GAParameters.ChromosomeRepresentation[parameters.ChromosomeRepresentationIndex];
for (int i = 0; i < iters; i++)
{
if (chromosomeRepresentation == GAParameters.ChromosomeRepresentationType.Binary)
{
IProblem <BinaryChromosome> problem = new FunctionMinimizationBinaryProblem(_function, _functionDimension, 4, -50, 150);
int populationSize = GAParameters.PopulationSize[parameters.PopulationSizeIndex];
double crossoverRate = GAParameters.CrossoverRate[parameters.CrossoverRateIndex];
ICrossoverOperator <BinaryChromosome> crossoverOperator;
ISelectionOperator <BinaryChromosome> selectionOperator;
int tournamentSize = GAParameters.TournamentSize[parameters.TournamentSizeIndex];
double selectivePressure = GAParameters.SelectivePressure[parameters.SelectivePressureIndex];
IMutationOperator <BinaryChromosome> mutationOperator;
double mutationRate = GAParameters.MutationRate[parameters.MutationRateIndex];
GeneticAlgorithmVariant variant = GAParameters.GAVariant[parameters.GAVariantIndex];
double elitismRate = GAParameters.ElitismRate[parameters.ElitismRateIndex];
double generationGap = GAParameters.GenerationGap[parameters.GenerationGapIndex];
var crossOperatorType = GAParameters.CrossoverOperator[parameters.CrossoverOperatorIndex];
if (crossOperatorType == GAParameters.CrossoverOperatorType.OnePoint)
{
crossoverOperator = new OnePointCrossoverOperator(crossoverRate);
}
else
{
crossoverOperator = new TwoPointCrossoverOperator(crossoverRate);
}
var mutationOperatorType = GAParameters.MutationOperator[parameters.MutationOperatorIndex];
if (mutationOperatorType == GAParameters.MutationOperatorType.BinaryBoundary)
{
mutationOperator = new BinaryBoundaryMutationOperator(mutationRate);
}
else if (mutationOperatorType == GAParameters.MutationOperatorType.BitFlip)
{
mutationOperator = new BitFlipMutationOperator(mutationRate);
}
else
{
mutationOperator = new SimpleMutationOperator(mutationRate);
}
if (GAParameters.SelectionOperator[parameters.SelectionOperatorIndex] == GAParameters.SelectionOperatorType.Tournament)
{
selectionOperator = new TournamentSelectionOperator <BinaryChromosome>(tournamentSize, problem);
}
else
{
selectionOperator = new RouletteWheelSelectionOperator <BinaryChromosome>(selectivePressure, problem);
}
IGeneticAlgorithm <BinaryChromosome> ga;
if (variant == GeneticAlgorithmVariant.Generational)
{
ga = new GenerationalGeneticAlgorithm <BinaryChromosome>(
problem,
populationSize,
selectionOperator,
crossoverOperator,
mutationOperator,
new CompositeTerminationCondition(
new MaxEvaluationsTerminationCondition(childEvaluations),
new MaxGenerationsTerminationCondition(maxGenerations)
),
elitismRate
);
}
else
{
ga = new SteadyStateGeneticAlgorithm <BinaryChromosome>(
problem,
populationSize,
selectionOperator,
crossoverOperator,
mutationOperator,
new CompositeTerminationCondition(
new MaxEvaluationsTerminationCondition(childEvaluations),
new MaxGenerationsTerminationCondition(maxGenerations)
),
generationGap,
new WorstFitnessReplacementOperator <BinaryChromosome>(problem)
);
}
// new GeneticAlgorithmRunner<BinaryChromosome>(ga).Run();
ga.Run();
childGAFitnesses[i] = ga.BestIndividual.Fitness;
}
else
{
IProblem <FloatingPointChromosome> problem = new FunctionMinimizationFloatingPointProblem(_function, _functionDimension, -50, 150);
int populationSize = GAParameters.PopulationSize[parameters.PopulationSizeIndex];
double crossoverRate = GAParameters.CrossoverRate[parameters.CrossoverRateIndex];
ICrossoverOperator <FloatingPointChromosome> crossoverOperator;
ISelectionOperator <FloatingPointChromosome> selectionOperator;
int tournamentSize = GAParameters.TournamentSize[parameters.TournamentSizeIndex];
double selectivePressure = GAParameters.SelectivePressure[parameters.SelectivePressureIndex];
IMutationOperator <FloatingPointChromosome> mutationOperator;
double mutationRate = GAParameters.MutationRate[parameters.MutationRateIndex];
GeneticAlgorithmVariant variant = GAParameters.GAVariant[parameters.GAVariantIndex];
double elitismRate = GAParameters.ElitismRate[parameters.ElitismRateIndex];
double generationGap = GAParameters.GenerationGap[parameters.GenerationGapIndex];
var crossOperatorType = GAParameters.CrossoverOperator[parameters.CrossoverOperatorIndex];
if (crossOperatorType == GAParameters.CrossoverOperatorType.Arithmetic)
{
crossoverOperator = new ArithmeticCrossoverOperator(crossoverRate);
}
else
{
crossoverOperator = new HeuristicCrossoverOperator(crossoverRate);
}
var mutationOperatorType = GAParameters.MutationOperator[parameters.MutationOperatorIndex];
if (mutationOperatorType == GAParameters.MutationOperatorType.FloatingPointBoundary)
{
mutationOperator = new FloatingPointBoundaryMutationOperator(mutationRate);
}
else if (mutationOperatorType == GAParameters.MutationOperatorType.Uniform)
{
mutationOperator = new UniformMutationOperator(mutationRate);
}
else
{
mutationOperator = new GaussianMutationOperator(mutationRate);
}
if (GAParameters.SelectionOperator[parameters.SelectionOperatorIndex] == GAParameters.SelectionOperatorType.Tournament)
{
selectionOperator = new TournamentSelectionOperator <FloatingPointChromosome>(tournamentSize, problem);
}
else
{
selectionOperator = new RouletteWheelSelectionOperator <FloatingPointChromosome>(selectivePressure, problem);
}
IGeneticAlgorithm <FloatingPointChromosome> ga;
if (variant == GeneticAlgorithmVariant.Generational)
{
ga = new GenerationalGeneticAlgorithm <FloatingPointChromosome>(
problem,
populationSize,
selectionOperator,
crossoverOperator,
mutationOperator,
new CompositeTerminationCondition(
new MaxEvaluationsTerminationCondition(childEvaluations),
new MaxGenerationsTerminationCondition(maxGenerations)
),
elitismRate
);
}
else
{
ga = new SteadyStateGeneticAlgorithm <FloatingPointChromosome>(
problem,
populationSize,
selectionOperator,
crossoverOperator,
mutationOperator,
new CompositeTerminationCondition(
new MaxEvaluationsTerminationCondition(childEvaluations),
new MaxGenerationsTerminationCondition(maxGenerations)
),
generationGap,
new WorstFitnessReplacementOperator <FloatingPointChromosome>(problem)
);
}
// new GeneticAlgorithmRunner<FloatingPointChromosome>(ga).Run();
ga.Run();
childGAFitnesses[i] = ga.BestIndividual.Fitness;
}
}
chromosome.Fitness = childGAFitnesses.Average();
}
