public GeneticAlgorithm(
double mutationProbability,
double crossoverPropability,
int minPopulationSize,
int maxPopulationSize,
IMutation mutationOperator,
ICrossover crossoverOperator,
IFitnessEvaluator <TWorkload> fitnessEvaluator,
IInitialPopulationCreator initialPopulationCreator,
ITerminationCondition <TState> terminationCondition,
ISelectionStrategy selectionStrategy,
IReinsertionStrategy reinsertionStrategy,
IDeploymentChromosomeFactory chromosomeFactory,
TState currentState,
TWorkload workload,
IRandomProvider randomProvider)
{
MutationProbability = mutationProbability;
CrossoverProbability = crossoverPropability;
MinPopulationSize = minPopulationSize;
MaxPopulationSize = maxPopulationSize;
MutationOperator = mutationOperator;
CrossoverOperator = crossoverOperator;
FitnessEvaluator = fitnessEvaluator;
InitialPopulationCreator = initialPopulationCreator;
TerminationCondition = terminationCondition;
SelectionStrategyStrategy = selectionStrategy;
ReinsertionStrategy = reinsertionStrategy;
ChromosomeFactory = chromosomeFactory;
CurrentState = currentState;
Workload = workload;
RandomProvider = randomProvider;
}
public TestGeneticAlgorithm(
double mutationProbability,
double crossoverPropability,
int minPopulationSize,
int maxPopulationSize,
IMutation mutationOperator,
ICrossover crossoverOperator,
IFitnessEvaluator <TestWorkload> fitnessEvaluator,
IInitialPopulationCreator initialPopulationCreator,
ITerminationCondition <TestState> terminationCondition,
ISelectionStrategy selectionStrategy,
IReinsertionStrategy reinsertionStrategy,
IDeploymentChromosomeFactory chromosomeFactory,
TestState currentState,
TestWorkload workload,
IRandomProvider randomProvider)
: base(
mutationProbability,
crossoverPropability,
minPopulationSize,
maxPopulationSize,
mutationOperator,
crossoverOperator,
fitnessEvaluator,
initialPopulationCreator,
terminationCondition,
selectionStrategy,
reinsertionStrategy,
chromosomeFactory,
currentState,
workload,
randomProvider)
{
}
public CombinedSCEwithRosenbrock(ShuffledComplexEvolution <T> shuffledComplexEvolution, IClonableObjectiveEvaluator <T> evaluator,
ITerminationCondition <T> rosenTerminationCondition, object AlgabraProvider)
{
this.evaluator = evaluator;
this.shuffledCE = shuffledComplexEvolution;
this.rosenTerminationCondition = rosenTerminationCondition;
this.rosenAlgabraProvider = AlgabraProvider;
}
public void AddTerminationCondition(ITerminationCondition condition)
{
if (condition == null)
{
throw new ArgumentNullException("Condition cannot be null");
}
_terminationConditions.Add(condition);
}
public Builder AddTerminationCondition(
[NotNull]
ITerminationCondition <TPopulation, TIndividual, TGene, TProcessInformation> terminationCondition)
{
if (terminationCondition == null)
{
throw new ArgumentNullException(nameof(terminationCondition));
}
_instance._terminationConditions.Add(terminationCondition);
return(this);
}
public GenerationalGeneticAlgorithm(
IProblem <T> problem,
int populationSize,
ISelectionOperator <T> selectionOperator,
ICrossoverOperator <T> crossoverOperator,
IMutationOperator <T> mutationOperator,
ITerminationCondition terminationCondition,
double elitismRate)
: base(problem, populationSize, selectionOperator,
crossoverOperator, mutationOperator, terminationCondition)
{
_elitismRate = elitismRate;
}
public SteadyStateGeneticAlgorithm(
IProblem <T> problem,
int populationSize,
ISelectionOperator <T> selectionOperator,
ICrossoverOperator <T> crossoverOperator,
IMutationOperator <T> mutationOperator,
ITerminationCondition terminationCondition,
double generationGap,
IReplacementOperator <T> replacementOperator) :
base(problem, populationSize, selectionOperator,
crossoverOperator, mutationOperator, terminationCondition)
{
_generationGap = generationGap;
_replacementOperator = replacementOperator;
}
public RosenbrockOptimizer(IObjectiveEvaluator <T> evaluator,
T startingPoint,
ITerminationCondition <T> terminationCondition,
double alpha = 1.4,
double beta = 0.7,
IAlgebraProvider algebraprovider = null,
IDictionary <string, string> logTags = null)
{
this.countingEvaluator = new CountingEvaluator(evaluator);
this.startingPoint = evaluator.EvaluateScore(startingPoint);
this.terminationCondition = terminationCondition;
terminationCondition.SetEvolutionEngine(this);
this.alpha = alpha;
this.beta = beta;
this.AlgebraProvider = algebraprovider;
this.logTags = logTags;
}
public void SetUp()
{
_mutationProbability = 1;
_crossoverProbability = 1;
_minPopulationSize = 2;
_maxPopulationSize = 4;
_mutationOperator = A.Fake <IMutation>();
_crossoverOperator = A.Fake <ICrossover>();
_fitnessEvaluator = A.Fake <IFitnessEvaluator <TestWorkload> >();
_initialPopulationCreator = A.Fake <IInitialPopulationCreator>();
_terminationCondition = A.Fake <ITerminationCondition <TestState> >();
_selectionStrategy = A.Fake <ISelectionStrategy>();
_reinsertionStrategy = A.Fake <IReinsertionStrategy>();
_deploymentChromosomeFactory = A.Fake <IDeploymentChromosomeFactory>();
_currentState = new TestState();
_workload = new TestWorkload();
_randomProvider = new DefaultRandomProvider();
}
protected AbstractGeneticAlgorithm(
IProblem <T> problem,
int populationSize,
ISelectionOperator <T> selectionOperator,
ICrossoverOperator <T> crossoverOperator,
IMutationOperator <T> mutationOperator,
ITerminationCondition terminationCondition)
{
_problem = problem;
_populationSize = populationSize;
_selectionOperator = selectionOperator;
_crossoverOperator = crossoverOperator;
_mutationOperator = mutationOperator;
_terminationCondition = terminationCondition;
CurrentGeneration = 1;
EvolutionTime = TimeSpan.Zero;
_population = CreateInitialPopulation();
_population = EvaluatePopulation(_population);
}
/// <summary>
/// Adds a termination condition to the metadata.
/// </summary>
/// <param name="condition"></param>
internal void AddTerminationCondition(ITerminationCondition condition)
{
_terminationConditions.Add(condition);
}
public Core(IObjectiveScoreCalculator scoreCalculator, IPopulationGenerator populationGenerator, ITerminationCondition terminationCondition)
{
this.scoreCalculator = scoreCalculator;
this.populationGenerator = populationGenerator;
this.terminationCondition = terminationCondition;
}
public Stage(IBase b, IObjectiveScores <T> startingPoint, IVector stepsLength, double alpha, double beta, CountingEvaluator countingEvaluator, IAlgebraProvider algebraProvider, ITerminationCondition <T> terminationCondition, IDictionary <string, string> logTags = null)
{
this.b = b;
this.startingPoint = startingPoint;
this.currentPoint = startingPoint;
this.stepsLength = stepsLength;
this.alpha = alpha;
this.beta = beta;
this.countingEvaluator = countingEvaluator;
this.terminationCondition = terminationCondition;
this.algebraProvider = algebraProvider;
this.logTags = logTags;
}
private static ShuffledComplexEvolution <T> internalCreateSceOptimizer <T>(IClonableObjectiveEvaluator <T> evaluator, T template, ITerminationCondition <T> terminationCondition, SceParameters SceParams)
where T : ICloneableSystemConfiguration, IHyperCube <double>
{
var populationInitializer = new UniformRandomSamplingFactory <T>(new CSIRO.Metaheuristics.RandomNumberGenerators.BasicRngFactory(0), template);
var sce = new ShuffledComplexEvolution <T>(evaluator, populationInitializer,
terminationCondition: terminationCondition, sceParameters: SceParams);
return(sce);
}
