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