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); }