public IList <IChromosome> Cross(IPopulation population, ICrossover crossover, float crossoverProbability, IList <IChromosome> parents) { var minSize = population.MinSize; var offspring = new List <IChromosome>(minSize); for (int i = 0; i < minSize; i += crossover.ParentsNumber) { var selectedParents = parents.Skip(i).Take(crossover.ParentsNumber).ToList(); // If match the probability cross is made, otherwise the offspring is an exact copy of the parents. // Checks if the number of selected parents is equal which the crossover expect, because the in the end of the list we can // have some rest chromosomes. if (selectedParents.Count == crossover.ParentsNumber && RandomizationProvider.Current.GetDouble() <= crossoverProbability) { offspring.AddRange(crossover.Cross(selectedParents)); } else { var left = crossover.ParentsNumber - selectedParents.Count; for (int j = 0; j < left; j++) { offspring.Add(parents[RandomizationProvider.Current.GetInt(0, parents.Count)].Clone()); } } } return(offspring); }
private Configuration(int n, int k, double a, double b, ISelection method1, ISelection method2, ISelection method3, ISelection method4, ICrossover crossover, IMutation mutation, double mutationProbability, IReplacement replacement, IFinisher finisher, Character.Type characterType) { this.N = n; this.K = k; this.A = a; this.B = b; this.Method1 = method1; this.Method2 = method2; this.Method3 = method3; this.Method4 = method4; this.CrossoverMethod = crossover; this.MutationMethod = mutation; this.ReplacementMethod = replacement; this.MutationProbablity = mutationProbability; this.FinishCondition = finisher; this.CharacterType = characterType; }
public IList <IChromosome> Cross(IPopulation population, ICrossover crossover, float crossoverProbability, IList <IChromosome> parents) { var offspring = new List <IChromosome>(); var clonedParents = parents.Select(x => x.Clone()).ToList(); for (int i = 0; i < population.MaxSize; i += crossover.ParentsNumber) { var selectedParents = clonedParents.Skip(i).Take(crossover.ParentsNumber).ToList(); // If match the probability cross is made, otherwise the offspring is an exact copy of the parents. // Checks if the number of selected parents is equal which the crossover expect, because in the end of the list we can // have some rest chromosomes. if (selectedParents.Count == crossover.ParentsNumber) { bool shouldCrossover = RandomizationProvider.Current.GetDouble() <= crossoverProbability; offspring.AddRange(shouldCrossover ? crossover.Cross(selectedParents) : selectedParents); } else { offspring.AddRange(selectedParents); int leftToAdd = crossover.ParentsNumber - selectedParents.Count; for (int j = 0; j < leftToAdd; j++) { offspring.Add(clonedParents[RandomizationProvider.Current.GetInt(0, clonedParents.Count)].Clone()); } } } return(offspring); }
private void UpdateCrossovers() { ICrossover oldCrossover = CrossoverParameter.Value; ICrossover defaultCrossover = Problem.Operators.OfType <ICrossover>().FirstOrDefault(); CrossoverParameter.ValidValues.Clear(); foreach (ICrossover crossover in Problem.Operators.OfType <ICrossover>().OrderBy(x => x.Name)) { ParameterizeStochasticOperatorForIsland(crossover); CrossoverParameter.ValidValues.Add(crossover); } if (oldCrossover != null) { ICrossover crossover = CrossoverParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldCrossover.GetType()); if (crossover != null) { CrossoverParameter.Value = crossover; } else { oldCrossover = null; } } if (oldCrossover == null && defaultCrossover != null) { CrossoverParameter.Value = defaultCrossover; } }
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 OptimizationResult Optimize() { _selection = new EliteSelection(); _crossover = new UniformCrossover(); _mutation = new TworsMutation(); _chromosome = new BlockedTestcasesChromosome(_dataset.Blockers.Count); _fitness = new WeightedMaximizeSolvedTestcasesFitness(_resolver); _population = new Population(20, 40, _chromosome); _ga = new GeneticAlgorithm(_population, _fitness, _selection, _crossover, _mutation); _ga.Termination = new OrTermination(new FitnessStagnationTermination(100), new GenerationNumberTermination(10000), new TimeEvolvingTermination(TimeSpan.FromMinutes(5))); //_ga.GenerationRan += Ga_GenerationRan; //_fitness.Evaluated += Fitness_Evaluated; _ga.Start(); var resolvedBlockers = GetBlockersToResolve(_ga.BestChromosome); var resolution = _resolver.Resolve(resolvedBlockers); var resolvedTestcases = resolution.ResolvedTestcases; var resolvedTestcasesIncludingUnblocked = resolution.ResolvedDataset.Testcases.Where(x => x.BlockerIds.Count <= 0).ToList();// GetResolvedTestcasesIncludingUnblocked(resolvedBlockers); var cost = _dataset.GetCostForBlockers(resolvedBlockers); var value = _dataset.GetValueForTestcases(resolvedTestcases); var valueIncludingUnblocked = _dataset.GetValueForTestcases(resolvedTestcasesIncludingUnblocked); var optimizationResult = new OptimizationResult(_ga.BestChromosome.Fitness.Value, value, valueIncludingUnblocked, cost, resolvedBlockers, resolvedTestcases, resolvedTestcasesIncludingUnblocked); return(optimizationResult); }
/// <summary>Initializes a new instance of the <see cref="GeneticAlgorithm"/> class.</summary> /// <param name="population">The chromosomes population.</param> /// <param name="selection">The selection operator.</param> /// <param name="crossover">The crossover operator.</param> /// <param name="mutation">The mutation operator.</param> /// <param name="reinsertion">The reinsertion operator.</param> /// <param name="termination">The termination operator.</param> public DynamoGeneticAlgorithm( IPopulation population, ISelection selection, ICrossover crossover, IMutation mutation, IReinsertion reinsertion, ITermination termination) { ExceptionHelper.ThrowIfNull("population", population); ExceptionHelper.ThrowIfNull("selection", selection); ExceptionHelper.ThrowIfNull("crossover", crossover); ExceptionHelper.ThrowIfNull("mutation", mutation); ExceptionHelper.ThrowIfNull("reinsertion", reinsertion); ExceptionHelper.ThrowIfNull("termination", termination); Population = population; Selection = selection; Crossover = crossover; Mutation = mutation; Reinsertion = reinsertion; Termination = termination; SelectionSize = 0; CrossoverProbability = (float)DefaultCrossoverProbability; MutationProbability = (float)DefaultMutationProbability; TimeEvolving = TimeSpan.Zero; OperatorsStrategy = new DefaultOperatorsStrategy(); State = GeneticAlgorithmState.NotStarted; }
public static ParameterSelection CreateSelection() { Console.Clear(); string[] names = GetNames(); string expression = GetExpression(); var bounds = GetBounds(); float upperBound = bounds.upper; float lowerBound = bounds.lower; bool adaptiveOn = IsAdaptive(); ISelection selection = GetSelection(); ICrossover crossover = GetCrossover(); IMutation mutation = GetMutation(); ITermination termination = GetTermination(); Console.Clear(); return(new ParameterSelection { Variables = names, Expression = expression, LowerBound = lowerBound, UpperBound = upperBound, AdaptiveOn = adaptiveOn, Selection = selection, Crossover = crossover, Mutation = mutation, Termination = termination }); }
public void Configure(IFitness fItness, IMutate mutate, ICrossover crossover, ISelection selection) { Mutate = mutate; Crossover = crossover; Fitness = fItness; Selection = selection; }
public DefaultSolver(Solver.Config cfg) { config = cfg; random = new Random(); mutation = new Mutation(config.mutationChance); crossover = new Crossover(config.singleFeatureCrossoverChance, config.crossoverChance, random); }
public Engine(IInitializer initializer, ICrossover crossoverer, IMutator mutator, bool isDebug) { PopulationInitializer = initializer; PopulationMutator = mutator; PopulationCrossoverer = crossoverer; IsDebug = isDebug; }
public EliminationGeneticAlgorithm(IMutation <DecimalArrayChromosome> mutation, ISelection <DecimalArrayChromosome> selection, ICrossover <DecimalArrayChromosome> crossover, IFitnessFunction <DecimalArrayChromosome> fitnessFunction, int iterationLimit, decimal fitnessTerminator, int populationSize) : base(mutation, selection, crossover, fitnessFunction, iterationLimit, fitnessTerminator, populationSize) { Population = new Population <DecimalArrayChromosome>(populationSize); InitializePopulation(); }
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; }
/// <summary> /// Initializes a new instance of the <see cref="GeneticSharp.Domain.GeneticAlgorithm"/> class. /// </summary> /// <param name="population">The chromosomes population.</param> /// <param name="fitness">The fitness evaluation function.</param> /// <param name="selection">The selection operator.</param> /// <param name="crossover">The crossover operator.</param> /// <param name="mutation">The mutation operator.</param> public GeneticAlgorithm( IPopulation population, IFitness fitness, ISelection selection, ICrossover crossover, IMutation mutation) { ExceptionHelper.ThrowIfNull("population", population); ExceptionHelper.ThrowIfNull("fitness", fitness); ExceptionHelper.ThrowIfNull("selection", selection); ExceptionHelper.ThrowIfNull("crossover", crossover); ExceptionHelper.ThrowIfNull("mutation", mutation); Population = population; Fitness = fitness; Selection = selection; Crossover = crossover; Mutation = mutation; Reinsertion = new ElitistReinsertion(); Termination = new GenerationNumberTermination(1); CrossoverProbability = DefaultCrossoverProbability; MutationProbability = DefaultMutationProbability; TimeEvolving = TimeSpan.Zero; State = GeneticAlgorithmState.NotStarted; TaskExecutor = new LinearTaskExecutor(); }
static Population AdvanceGeneration(Population population, ISelection selection, ICrossover crossover, IMutation mutation) { var chromosomes = new List<Chromosome>(); population = new Population(population.Take((int)(truncationRate * population.Count()))); // TRUNCATION chromosomes.AddRange(population.Take((int)(elitismRate * chromosomeCount))); //ELITE (assuming that the chromosomes in the population are sorted by fitness (the fitter are at the top of the list) do { Chromosome chosen1 = selection.Select(population), chosen2 = selection.Select(population); if (random.NextDouble() < crossoverRate) { var children = crossover.Crossover(chosen1, chosen2); // CROSSOVER chosen1 = children.Item1; chosen2 = children.Item2; } if (random.NextDouble() < mutationRate) { chosen1 = mutation.Mutate(chosen1); // MUTATION } if (random.NextDouble() < mutationRate) { chosen2 = mutation.Mutate(chosen2); // MUTATION } chromosomes.Add(chosen1); chromosomes.Add(chosen2); } while (chromosomes.Count < chromosomeCount); return new Population(chromosomes); }
public GeneticSettings(int populationSize, int geneCount, int selectionSize, double mutationProbabiltyAgents, double mutationProbabilityGenes, IRandomNumberGenerator randomNumberGenerator, IFitnessCalculator fitnessCalculator, IMutator mutator, ISelector selector, ICrossover crossover, IAgentViewer agentViewer, int topKAgentsCount) { if (populationSize < selectionSize) { throw new Exception("The population size has to be greater than the selection size"); } PopulationSize = populationSize; GeneCount = geneCount; SelectionSize = selectionSize; MutationProbabiltyAgents = mutationProbabiltyAgents; MutationProbabilityGenes = mutationProbabilityGenes; RandomNumberGenerator = randomNumberGenerator; FitnessCalculator = fitnessCalculator; Mutator = mutator; Selector = selector; Crossover = crossover; AgentViewer = agentViewer; TopKAgentsCount = topKAgentsCount; }
public Individual <double[]> FindBestIndividual(bool speedRun, Func <double[], double> function, ISelection <double[]> selection, ICrossover <double[]> crossover, IMutation <double[]> mutation, double epsilon = 10E-6) { var lowerBound = _populationRange[0]; var upperBound = _populationRange[1]; Population = InitializePopulation(_dimensions, _populationSize, lowerBound, upperBound); var i = 0; do { var child = selection.Select(Population); if (child.Fitness > _maxFitness) { _maxFitness = child.Fitness; _maxIndividual = child; } if (speedRun && Math.Abs(_maxFitness) < epsilon) { Console.WriteLine($"Total iterations: {i:N0}"); return(_maxIndividual); } i++; } while (i < _iterations); // return _maxFitness; Console.WriteLine($"Total iterations: {i:N0}"); return(_maxIndividual); }
/// <summary> /// Crosses the agents in population and returns the children. /// </summary> /// <param name="crossover"></param> /// <param name="populationSize"></param> /// <param name="random"></param> /// <returns></returns> public List <Agent> MakeCrossovers(ICrossover crossover, int populationSize, IRandomNumberGenerator random) { List <Agent> children = new List <Agent>(); children = crossover.MakeCrossovers(Agents, populationSize, random); return(children); }
/// <summary> /// Enumerates through the offspring created from the specie. /// </summary> /// <param name="population"></param> /// <param name="specie"></param> /// <param name="crossover"></param> /// <param name="childrenCount"></param> /// <param name="allParents"></param> /// <param name="parentsLookup"></param> /// <returns></returns> protected virtual IEnumerable <IChromosome> PerformCrossSpecie( ISpeciedPopulation population, Specie specie, ICrossover crossover, int childrenCount, IList <IChromosome> allParents, ILookup <Specie, IChromosome> parentsLookup) { if (parentsLookup[specie].Count() < crossover.ParentsNumber) { throw new InvalidOperationException("Not enough specie parents available for this crossover."); } if (childrenCount <= 0) { yield break; } var curParents = new List <IChromosome>(crossover.ParentsNumber); int pInd = 0; for (int i = 0; i < childrenCount; i += crossover.ChildrenNumber) { IList <IChromosome> kids; // Interspecie crossover if (RandomizationProvider.Current.GetDouble() <= InterspecieMatingRate) { kids = PerformInterspecieCross(crossover, allParents); } // Crossover within specie else { List <IChromosome> specieParents = parentsLookup[specie].ToList(); // Choose parents, place into curParents list curParents.Clear(); while (curParents.Count < crossover.ParentsNumber) { curParents.Add(specieParents[pInd++]); // Wrap around and re-shuffle if (pInd >= specieParents.Count) { pInd = 0; specieParents = specieParents.Shuffle(RandomizationProvider.Current).ToList(); } } kids = crossover.Cross(curParents); } // Return children for (int k = 0; k < kids.Count; k++) { if (i + k < childrenCount) { yield return(kids[k]); } } } }
private void PrepareComboBoxes() { PrepareEditComboBox( cmbSelection, btnEditSelection, SelectionService.GetSelectionNames, SelectionService.GetSelectionTypeByName, SelectionService.CreateSelectionByName, () => m_selection, (i) => m_selection = i); PrepareEditComboBox( cmbCrossover, btnEditCrossover, CrossoverService.GetCrossoverNames, CrossoverService.GetCrossoverTypeByName, CrossoverService.CreateCrossoverByName, () => m_crossover, (i) => m_crossover = i); PrepareEditComboBox( cmbMutation, btnEditMutation, MutationService.GetMutationNames, MutationService.GetMutationTypeByName, MutationService.CreateMutationByName, () => m_mutation, (i) => m_mutation = i); PrepareEditComboBox( cmbTermination, btnEditTermination, () => { return(TerminationService.GetTerminationNames() .Where(t => !t.Equals("And", StringComparison.OrdinalIgnoreCase) && !t.Equals("Or", StringComparison.OrdinalIgnoreCase)).ToList()); }, TerminationService.GetTerminationTypeByName, TerminationService.CreateTerminationByName, () => m_termination, (i) => m_termination = i); PrepareEditComboBox( cmbTermination1, btnEditReinsertion, ReinsertionService.GetReinsertionNames, ReinsertionService.GetReinsertionTypeByName, ReinsertionService.CreateReinsertionByName, () => m_reinsertion, (i) => m_reinsertion = i); PrepareEditComboBox( cmbGenerationStrategy, btnEditGenerationStrategy, PopulationService.GetGenerationStrategyNames, PopulationService.GetGenerationStrategyTypeByName, PopulationService.CreateGenerationStrategyByName, () => m_generationStrategy, (i) => m_generationStrategy = i); }
private void PrepareComboBoxes() { PrepareEditComboBox( cmbSelection, btnEditSelection, SelectionService.GetSelectionNames, SelectionService.GetSelectionTypeByName, SelectionService.CreateSelectionByName, () => m_selection, (i) => m_selection = i); PrepareEditComboBox( cmbCrossover, btnEditCrossover, CrossoverService.GetCrossoverNames, CrossoverService.GetCrossoverTypeByName, CrossoverService.CreateCrossoverByName, () => m_crossover, (i) => m_crossover = i); PrepareEditComboBox( cmbMutation, btnEditMutation, MutationService.GetMutationNames, MutationService.GetMutationTypeByName, MutationService.CreateMutationByName, () => m_mutation, (i) => m_mutation = i); PrepareEditComboBox( cmbTermination, btnEditTermination, () => { return(TerminationService.GetTerminationNames()); }, TerminationService.GetTerminationTypeByName, TerminationService.CreateTerminationByName, () => m_termination, (i) => m_termination = i); PrepareEditComboBox( cmbReinsertion, btnEditReinsertion, ReinsertionService.GetReinsertionNames, ReinsertionService.GetReinsertionTypeByName, ReinsertionService.CreateReinsertionByName, () => m_reinsertion, (i) => m_reinsertion = i); PrepareEditComboBox( cmbGenerationStrategy, btnEditGenerationStrategy, PopulationService.GetGenerationStrategyNames, PopulationService.GetGenerationStrategyTypeByName, PopulationService.CreateGenerationStrategyByName, () => m_generationStrategy, (i) => m_generationStrategy = i); }
/// <summary> /// Removes a crossover operator to the metadata. /// </summary> /// <param name="crossover">The crossover operator.</param> public void RemoveCrossover(ICrossover crossover) { if (_crossovers != null && _crossovers.Contains(crossover)) { _crossovers.Remove(crossover); _crossoverF -= crossover.Weight; } }
public GeneticAlgorithmInstance(TSPProblem problem, ISelection selection, ICrossover crossover, IMutation mutation) { this.problem = problem; this.selection = selection; this.crossover = crossover; this.mutation = mutation; randomGenerator = new Random(); }
public SchedulesCrossover(ICrossover permutationCrossover) { this.permutationCrossover = permutationCrossover; IsOrdered = true; ParentsNumber = 2; ChildrenNumber = 2; MinChromosomeLength = 0; }
public Generation(Individual[] currentPopulation, Cities cities, IParentSelection parentSelection, ICrossover crossoverOperator, IMutation methodOfMutation) { this.population = currentPopulation; this.cities = cities; this.parentSelection = parentSelection; this.crossoverOperator = crossoverOperator; this.methodOfMutation = methodOfMutation; }
public GeneticSolver(IGeneticSolverParameters parameters, IMutatable mutator, ICrossover crossover, IEvaluator evaluator, ISelector selector) { _numberOfIterations = 0; _parameters = parameters; EvaluationMethod = evaluator; CrossoverAlgorithm = crossover; SelectionMethod = selector; MutationAlgorithm = mutator; }
public GeneticAlgorithm(SeedGenerator seedGenerator, FitnessEvaluator fitnessEvaluator, ISelection selection, ICrossover crossover, IMutation mutation, IElitism elitism) { this.seedGenerator = seedGenerator; this.fitnessEvaluator = fitnessEvaluator; this.selection = selection; this.crossover = crossover; this.mutation = mutation; this.elitism = elitism; }
public GeneticAlgorithm(Population population, ISelection selection, ICrossover crossover, IReinsertion reinsertion) { Population = population; Selection = selection; Crossover = crossover; Reinsertion = reinsertion; CrossoverProbability = DefaultCrossoverProbability; MutationProbability = DefaultMutationProbability; }
public PopulationController() { members = new PopulationMember[0]; crosser = ClassFactory.GetCrossover(); mutator = ClassFactory.GetMutator(); selector = ClassFactory.GetSelector(); generator = ClassFactory.GetRandomGenertor(); }
public GeneticAlgorithm(IFittnessFunction <T> fittnessFunction, ISelection <T> selection, ICrossover <T> crossover, IMutation <T> mutation, ITerminate <T> terminate) { Population = new List <IChromosome <T> >(); FittnessFunction = fittnessFunction; Selection = selection; Crossover = crossover; Mutation = mutation; Terminate = terminate; }
public IList <IChromosome> Cross(IPopulation population, ICrossover crossover, float crossoverProbability, IList <IChromosome> parents) { var pop = population as ISpeciedPopulation; if (pop is null) { throw new InvalidOperationException(); } return(PerformCrossPopulation(pop, crossover, crossoverProbability, parents)); }
public TSPAlgorithm(int numberOfGenerations, int populationSize, Cities cities, IParentSelection parentSelection, IMutation methodOfMutation, ICrossover crossoverOperator) { this.numberOfGenerations = numberOfGenerations; this.populationSize = populationSize; this.cities = cities; this.parentSelection = parentSelection; this.crossoverOperator = crossoverOperator; this.methodOfMutation = methodOfMutation; this.bestResults = new double[numberOfGenerations]; }
public GeneticAlgorithm(double crossoverRate, double mutationRate, double elitism, double truncation, double chromosomeCount, ISelection selection, ICrossover crossover, IMutation mutation, FitnessCalculator fitnessCalculator) { CrossoverRate = crossoverRate; MutationRate = mutationRate; ElitismRate = elitism; TruncationRate = truncation; ChromosomeCount = chromosomeCount; this.selection = selection; this.mutation = mutation; this.crossover = crossover; this.fitnessCalculator = fitnessCalculator; random = new Random(); }
public GeneticAlgorithm(IRandom rand, Population candidates, Func<IOrganism, double> fitnessFunction, ISelector selector, IMutator mutator, ICrossover crossLinker, double elitismProportion, int maximumGenerations) { this.rand = rand; this.candidates = candidates; this.fitnessFunction = fitnessFunction; this.selector = selector; this.mutator = mutator; this.crossLinker = crossLinker; this.elitismProportion = elitismProportion; this._generationCount = 0; this.generationInformation = new Dictionary<int, double>(); this.initialCount = candidates.Count; this.maximumGenerations = maximumGenerations; this.candidates.CalculateFitnesses(this.fitnessFunction); }
static bool HandleCommandLineArgs(Game game, IEnumerable<string> args) { string fitnessType = "", crossoverType = ""; bool status = true; options = new OptionSet { {"m|mutation=", "The mutation rate (0-1)", (double v) => mutationRate = v}, {"s|crossover=", "The crossover rate (0-1)", (double v) => crossoverRate = v}, {"e|elitism=", "The elitism rate (0-1)", (double v) => elitismRate = v}, {"c|crcount=", "The number of chromosomes per population (>1)", (int v) => chromosomeCount = v}, {"fitness=", "The fitness calculator [sum | levenshtein | hamming]", v => fitnessType = v}, {"ctype=", "The crossover type [one | two ]", v => crossoverType = v}, {"t|truncate=", "The rate of the chromosomes to keep from a population before advancing (0 < t <= 1)", (double v) => truncationRate = v}, {"?|h|help", "Show help", v => { status = false; }}, //{"<>", v => target = v} // this can be used for a seed }; try { options.Parse(args); } catch (OptionException ex) { status = false; } fitness = (FitnessCalculator)Activator.CreateInstance(GetOperationType(fitnessTypes, fitnessType), new object[] { game }); crossover = (ICrossover)Activator.CreateInstance(GetOperationType(crossoverTypes, crossoverType), new object[] { fitness }); mutation = new SinglePointMutation(new ReplayCharacterSet(), fitness); selection = new RouletteWheelSelection(); if (mutationRate > 1 || crossoverRate > 1 || elitismRate > 1 || chromosomeCount <= 1 || truncationRate <= 0 || truncationRate > 1) { status = false; } return status; }
/// <summary> /// Initializes a new instance of the <see cref="GeneticSharp.Domain.GeneticAlgorithm"/> class. /// </summary> /// <param name="population">The chromosomes population.</param> /// <param name="fitness">The fitness evaluation function.</param> /// <param name="selection">The selection operator.</param> /// <param name="crossover">The crossover operator.</param> /// <param name="mutation">The mutation operator.</param> public GeneticAlgorithm( Population population, IFitness fitness, ISelection selection, ICrossover crossover, IMutation mutation) { ExceptionHelper.ThrowIfNull("Population", population); ExceptionHelper.ThrowIfNull("fitness", fitness); ExceptionHelper.ThrowIfNull("selection", selection); ExceptionHelper.ThrowIfNull("crossover", crossover); ExceptionHelper.ThrowIfNull("mutation", mutation); Population = population; Fitness = fitness; Selection = selection; Crossover = crossover; Mutation = mutation; Reinsertion = new ElitistReinsertion(); Termination = new GenerationNumberTermination(1); CrossoverProbability = DefaultCrossoverProbability; MutationProbability = DefaultMutationProbability; TimeEvolving = TimeSpan.Zero; State = GeneticAlgorithmState.NotStarted; TaskExecutor = new LinearTaskExecutor(); }
/// <summary> /// Initializes a new instance of the <see cref="GeneticSharp.Domain.Crossovers.CrossoverException"/> class. /// </summary> /// <param name="crossover">The crossover where occurred the error.</param> /// <param name="message">The error message.</param> /// <param name="innerException">The inner exception.</param> public CrossoverException(ICrossover crossover, string message, Exception innerException) : base("{0}: {1}".With(crossover != null ? crossover.GetType().Name : String.Empty, message), innerException) { Crossover = crossover; }
public OffspringSelector(ICrossover crossover) { this.crossover = crossover; }