public ResettingGA(IEvaluation <Element> evaluation, AStopCondition stopCondition, AGenerator <Element> generator,
ASelection selection, ACrossover crossover, IMutation <Element> mutation, int populationSize, int patience, int?seed = null)
: base(evaluation, stopCondition, generator, selection, crossover, mutation, populationSize)
{
this.patience = patience;
rng = seed.HasValue ? new Random(seed.Value) : new Random();
}
/// <summary>
/// Linear mutaion execution.
/// </summary>
/// <param name="mutation">Mutation operator.</param>
/// <param name="mutationProbability">Probability of mutaiton</param>
/// <param name="individuals">Individual</param>
public virtual void Mutate(IMutation mutation, float mutationProbability, IList <IIndividual> individuals)
{
for (int i = 0; i < individuals.Count; i++)
{
mutation.Mutate(individuals[i], mutationProbability);
}
}
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 GAStallDetection(IEvaluation<Element> evaluation, AStopCondition stopCondition, AGenerator<Element> generator,
ASelection selection, ACrossover crossover, IMutation<Element> mutation, int populationSize,
int maxNoChangeDetections)
: base(evaluation, stopCondition, generator, selection, crossover, mutation, populationSize)
{
MaxNCD = maxNoChangeDetections;
}
public DefaultSolver(Solver.Config cfg)
{
config = cfg;
random = new Random();
mutation = new Mutation(config.mutationChance);
crossover = new Crossover(config.singleFeatureCrossoverChance, config.crossoverChance, random);
}
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 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)
{
}
/// <summary>
/// Parallel mutaion execution.
/// </summary>
/// <param name="mutation">Mutation operator.</param>
/// <param name="mutationProbability">Probability of mutaiton</param>
/// <param name="individuals">Individual</param>
public override void Mutate(IMutation mutation, float mutationProbability, IList <IIndividual> individuals)
{
Parallel.ForEach(individuals, ind =>
{
mutation.Mutate(ind, mutationProbability);
});
}
/// <summary>
/// Mutate the specified chromosomes.
/// </summary>
/// <param name="mutation">The mutation class.</param>
/// <param name="mutationProbability">The mutation probability.</param>
/// <param name="chromosomes">The chromosomes.</param>
public override void Mutate(IMutation mutation, float mutationProbability, IList <IChromosome> chromosomes)
{
Parallel.ForEach(chromosomes, c =>
{
mutation.Mutate(c, mutationProbability);
});
}
public void AddMutation(IMutation mutation)
{
if (_Mutations.Any(x => x.GetType().Equals(mutation.GetType())) == false)
{
_Mutations.Add(mutation);
}
}
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 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);
}
public KnapsackGA(CBinaryKnapsackEvaluation evaluation, AStopCondition stopCondition, AGenerator <bool> generator,
ASelection selection, ACrossover crossover, IMutation <bool> mutation, int populationSize, EffectType effType, int?seed)
: base(evaluation, stopCondition, generator, selection, crossover, mutation, populationSize)
{
this.seed = seed;
effectType = effType;
}
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 NSGA2(IEvaluation <Element, Tuple <double, double> > evaluation, IStopCondition stopCondition, AGenerator <Element> generator,
IDominationComparer dominationComparer, ACrossover crossover, IMutation <Element> mutation, int populationSize,
int?seed = null)
: base(evaluation, stopCondition, generator, new NSGA2Selection(2, evaluation.tMaxValue, dominationComparer, true, seed),
crossover, mutation, populationSize, seed)
{
}
/// <summary>
/// Mutate the specified chromosomes.
/// </summary>
/// <param name="mutation">The mutation class.</param>
/// <param name="mutationProbability">The mutation probability.</param>
/// <param name="chromosomes">The chromosomes.</param>
public override void Mutate(IMutation mutation, float mutationProbability, IList <IChromosome> chromosomes)
{
for (int i = 0; i < chromosomes.Count; i++)
{
mutation.Mutate(chromosomes[i], mutationProbability);
}
}
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>
/// Causes the organism to mutate accordingly to the settings in the mutation.
/// </summary>
/// <param name="m">The mutation</param>
public void Mutate(IMutation m)
{
if(m != null) {
Root.Accept(m);
} else {
throw new Exception("The mutation is null");
}
}
public DSMGA(IEvaluation <bool> evaluation, AStopCondition stopCondition, AGenerator <bool> generator,
ASelection selection, ACrossover crossover, IMutation <bool> mutation, int populationSize)
: base(evaluation, stopCondition, generator, selection, crossover, mutation, populationSize)
{
Combinations = GetKCombs(Enumerable.Range(0, evaluation.iSize), 2)
.Select(x => x.ToList()).ToList();
ResetContingencyMatrixTable();
}
public ProxyMutation(IMutation mutation)
{
_mutation = mutation;
_numberOfGoodStarts = 0;
_numberOfBadStarts = 0;
_progressList = new List<double> {OneHundredPercent};
_progress = OneHundredPercent;
}
public bool Equals(IMutation obj)
{
if (!(obj is MutationalChunk o))
{
return(false);
}
return(Equals(o));
}
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 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 GEngine(AbstractTrack[] tracks, int pCrossingover, int pMutation, IFitnessFunction fitnessFunction, IMutation mutation, ICrossingover crossingover, ISelection selection)
{
_countOfPerson = tracks.Length;
_tracks = new AbstractTrack[_countOfPerson];
_tracks = tracks;
_pCrossingover = pCrossingover;
_pMutation = pMutation;
_fitnessFunction = fitnessFunction;
_mutation = mutation;
_crossingover = crossingover;
_selection = selection;
_geneticsDataSet = new DB_GeneticsDataSet();
_launchId = Guid.NewGuid();
_launchTableAdapter = new DB_GeneticsDataSetTableAdapters.LaunchesTableAdapter();
_personsTableAdapter = new DB_GeneticsDataSetTableAdapters.PersonsTableAdapter();
}
public void RunCounterTest()
{
_mutation = new NotRandomMutation();
_selection = new TournamentSelection();
_crossingover = new CyclicalCrossingover();
int expectCountOfGeneration = 12000;
IFitnessFunction fitnessFunction = new GenerationCounter(expectCountOfGeneration);
int pCrossingover = 80;
int pMutation = 60;
Array.Sort(_closedTracks);
double preBestResult = _closedTracks[0].GetTrackLength();
GEngine target = new GEngine(_closedTracks, pCrossingover, pMutation, fitnessFunction, _mutation, _crossingover, _selection);
target.Run();
Assert.AreEqual(expectCountOfGeneration, target.FitnessFunction.ActualCountOfReps);
Assert.IsTrue(preBestResult >= target.FitnessFunction.BestResult);
}
static void OnImprovement(Species sender, IMutation mutationType)
{
Console.Clear();
var improve = sender.BestFit - lastFit;
if (imrovement.ContainsKey(mutationType))
imrovement[mutationType] += improve;
else
imrovement.Add(mutationType,improve);
Console.WriteLine("Iteration: {0} Seconds elapsed: {1}", sender.Iterations, (DateTime.Now- startTime).TotalSeconds);
Console.WriteLine("Fit: {0}",sender.BestFit);
Console.WriteLine("Neurons: {0}, Synapses: {1} \r\n", sender.Network.NeuronsCount, sender.Network.SynapsesCount);
foreach (var value in imrovement.OrderByDescending(a=>a.Value))
Console.WriteLine(value.Key.GetType().Name+" "+value.Value/sender.MutationsCollection[value.Key]);
}
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.Mutations.MutationException"/> class.
/// </summary>
/// <param name="mutation">The Mutation where ocurred the error.</param>
/// <param name="message">The error message.</param>
/// <param name="innerException">The inner exception.</param>
public MutationException(IMutation mutation, string message, Exception innerException)
: base("{0}: {1}".With(mutation != null ? mutation.GetType().Name : String.Empty, message), innerException)
{
Mutation = mutation;
}
public void values_init()
{
//---pobranie danych z bazy danych---
var db = new BazaDanychDataContext();
IDictionary<Przedmiot, IList<Prowadzący>> prowadzacyZajecia;
IList<Zajecia> genotyp;
InitializeFromDataBase(db, this.comboBox1.Text, out genotyp, out prowadzacyZajecia);
Application.DoEvents();
//---przypisanie genotypu---
Timetable.Genome = genotyp;
//---randomy---
DoubleRandomGenerator randMutation = new DoubleRandomGenerator();
DoubleRandomGenerator randSelector = new DoubleRandomGenerator();
IntegerRandomGenerator randGen = new IntegerRandomGenerator();
IntegerRandomGenerator randMateUp = new IntegerRandomGenerator();
IntegerRandomGenerator randGenSelector = new IntegerRandomGenerator();
//---komponenty algorytmu---
population = new List<Timetable>();
mutation = new TimetableTeacherMutation(prowadzacyZajecia, randMutation, randGenSelector, 0.02);
breeder = new TimetableFactory(mutation, randMateUp);
evalSelector = new TimetableEvaluator();
//Timetable primeChromosome = breeder.CreateNew();
reproducer = new CrossOverReproducer<Timetable, TimetableLocus, Zajecia>(randMateUp, breeder, new CrossOverReproducer<Timetable, TimetableLocus, Zajecia>.Config() { ChildCount = 2, ParentCount = 2 });
selector = new RouletSelector<Timetable, TimetableLocus, Zajecia>(evalSelector, randSelector);
//---inicjacja populacji--- (calosciowy plan dla uczelni)
//Application.DoEvents();
for (int i = 0; i < MaxPopulationCount; i++)
population.Add(breeder.CreateNew());
//moze zrobic tak...
//populacje duzych planow rozpic na N populacjie mniejszych planow
//dla kazdego duzego planu
//duzy plan uzyskany z populacji rozbic na mniejsze juz teraz
//stworzyc populacje pomiejszych planow
//przeprowadzic iteracje GA
//potem wszystkie te plany skonkatenowac
//odtworzyc populacje duzych planow
//i ocenic...
it = 0;
this.wykres.Series[0].Points.Clear();
this.wykres.Series[1].Points.Clear();
this.comboBox1.Enabled = true;
this.poprzedni.Enabled = false;
this.nastepny.Enabled = true;
wybranaGrupa_SelectedIndexChanged(null, null);
this.dataGridView1.ReadOnly = false; this.dataGridView1.AllowUserToDeleteRows = true;
this.dataGridView2.ReadOnly = false; this.dataGridView2.AllowUserToDeleteRows = true;
this.dataGridView3.ReadOnly = false; this.dataGridView3.AllowUserToDeleteRows = true;
this.dataGridView4.ReadOnly = false; this.dataGridView4.AllowUserToDeleteRows = true;
this.dataGridView5.ReadOnly = false; this.dataGridView5.AllowUserToDeleteRows = true;
}
private static TestComposite<ClassToTest> MakeSut(ITestComposite<ClassToTest> parent = null, IMutation<ClassToTest> mutation = null )
{
parent = parent ?? new DummyTestComposite<ClassToTest>();
mutation = mutation ?? new DummyMutation<ClassToTest>();
return new TestComposite<ClassToTest>(parent, mutation);
}
/// <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();
}
public Test(IMutation mutation)
: this()
{
mutate(mutation);
}
/// <summary>
/// Causes the organism to mutate accordingly to the settings in the mutation.
/// </summary>
/// <param name="m">The mutation</param>
public void mutate(IMutation m)
{
if (rootElement == null)
throw new NullReferenceException(errorEmptyGenotype);
rootElement.accept(m);
}
/// <summary>
/// Causes the organism to mutate accordingly to the settings in the mutation.
/// </summary>
/// <param name="m">The mutation</param>
public void mutate(IMutation m)
{
genotype.mutate(m);
}
public void RunSearchBestTest()
{
int bestReps = 50;
int wantedResult = 6;
List<ProxyMutation> proxyMutations = new List<ProxyMutation>();
proxyMutations.Add(new ProxyMutation(new TwoPointMutation()));
proxyMutations.Add(new ProxyMutation(new FourPointMutation()));
proxyMutations.Add(new ProxyMutation(new NotRandomMutation()));
_mutation = new SearchBestMutation(proxyMutations);
List<ProxySelection> proxySelectios = new List<ProxySelection>();
proxySelectios.Add(new ProxySelection(new TournamentSelection()));
proxySelectios.Add(new ProxySelection(new RouletteSelection()));
proxySelectios.Add(new ProxySelection(new RankingSelection()));
_selection = new SearchBestSelection(proxySelectios);
List<ProxyCrossingover> proxyCrossingovers = new List<ProxyCrossingover>();
proxyCrossingovers.Add(new ProxyCrossingover(new CyclicalCrossingover()));
proxyCrossingovers.Add(new ProxyCrossingover(new InversionCrossingover()));
proxyCrossingovers.Add(new ProxyCrossingover(new OnePointCrossingover()));
proxyCrossingovers.Add(new ProxyCrossingover(new TwoPointCrossingover()));
_crossingover = new SearchBestCrossingover(proxyCrossingovers);
IFitnessFunction fitnessFunction = new BestReps(bestReps);
int pCrossingover = 100;
int pMutation = 100;
Array.Sort(_closedTracks);
double preBestResult = _closedTracks[0].GetTrackLength();
GEngine target = new GEngine(_closedTracks, pCrossingover, pMutation, fitnessFunction, _mutation, _crossingover, _selection);
target.Run();
double progress1 = proxySelectios[0].GetProgress();
double progress2 = proxySelectios[1].GetProgress();
double progress3 = proxySelectios[2].GetProgress();
Assert.IsTrue(preBestResult >= target.FitnessFunction.BestResult);
}
/// <summary>
/// Apply the mutation on the extension and his childs.
/// </summary>
/// <param name="mutation">The mutation</param>
public void accept(IMutation mutation)
{
// Shortcuts can be made here to gain in performance.
// Apply mutation locally first.
mutation.apply(this);
IList<Extension> copy = extensions.ToList<Extension>();
// Propagate in lower levels.
foreach (Extension extension in copy)
{
extension.accept(mutation);
}
}
public void RunReachWantedResultTest()
{
_mutation = new NotRandomMutation();
_selection = new TournamentSelection();
_crossingover = new CyclicalCrossingover();
int wantedResult = 6;
IFitnessFunction fitnessFunction = new ReachWantedResult(wantedResult);
int pCrossingover = 80;
int pMutation = 60;
Array.Sort(_closedTracks);
double preBestResult = _closedTracks[0].GetTrackLength();
GEngine target = new GEngine(_closedTracks, pCrossingover, pMutation, fitnessFunction, _mutation, _crossingover, _selection);
target.Run();
Assert.AreEqual(wantedResult, target.FitnessFunction.BestResult);
Assert.IsTrue(preBestResult > target.FitnessFunction.BestResult);
}
