public NumberVectorTests() { mutationManager = new IntUniformMutationManager(0, 100); evaluator = new BasicEvaluator(); populationGenerator = new IntVectorChromosomePopulationGenerator(VECTOR_SIZE, 0, 1, mutationManager, evaluator); crossoverManager = new SinglePointCrossoverManager <int>(mutationManager, evaluator); }
public static void TestChromosomeChanged(this IMutationManager <string> mutationManager) { var elements = new List <string> { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J" }; var generator = new AllElementsVectorChromosomePopulationGenerator <string>(elements, null, null); // Since there's a certain chance that this test will fail, I want to run it twice var passed = false; for (int i = 0; i < 4; i++) { try { var before = ((VectorChromosome <string>)generator.GeneratePopulation(1).First()).GetVector(); var after = mutationManager.Mutate(before.ToArray()); before.AssertAreNotTheSame(after); passed = true; } catch { // Do nothing } } Assert.IsTrue(passed); }
/// <summary> /// Creates a population of chromosomes of type VectorChromosome<T> in which each chromosome contains every element exactly once. /// </summary> public AllElementsVectorChromosomePopulationGenerator(ICollection<T> elements, IMutationManager<T> mutationManager, IEvaluator evaluator) { if (!elements.Any()) throw new GeneticAlgorithmException($"{nameof(elements)} is empty"); this.elements = elements; this.mutationManager = mutationManager; this.evaluator = evaluator; }
public static void AssertAllValuesAreWithinRange <T>(this IMutationManager <T> mutationManager, int maxValue, int minValue) { for (int i = 0; i < attempts; i++) { var value = mutationManager.Mutate(new[] { default(T) }).First().ToInt(); Assert.IsTrue(value <= maxValue, $"{nameof(value)} ({value}) > {nameof(maxValue)} ({maxValue})"); Assert.IsTrue(value >= minValue, $"{nameof(value)} ({value}) < {nameof(minValue)} ({minValue})"); } }
public static void AssertValuesAreScattered <T>(this IMutationManager <T> mutationManager) { var values = new HashSet <int>(); for (int i = 0; i < 50; i++) { var value = mutationManager.Mutate(new[] { default(T) }).First().ToInt(); values.Add(value.ToInt()); } Assert.IsTrue(values.Count > 8, $"We only got {values.Count} different values"); }
public static void CheckMutationsHappenWithRightProbability <T>(this IMutationManager <T> mutationManager, Func <T, bool> isMutated) { var mutatedGenomes = 0; for (int i = 0; i < attempts; i++) { var newChromosome = mutationManager.Mutate(new[] { default(T), default(T), default(T), default(T), default(T) }); mutatedGenomes += newChromosome.Count(isMutated); } mutatedGenomes.AssertIsWithinRange(attempts, attempts * 0.1); }
public static void TestAllElementsInEachVector(this IMutationManager <string> mutationManager, int testRuns) { var elements = new List <string> { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J" }; var generator = new AllElementsVectorChromosomePopulationGenerator <string>(elements, null, null); for (int i = 0; i < testRuns; i++) { var before = ((VectorChromosome <string>)generator.GeneratePopulation(1).First()).GetVector(); var after = mutationManager.Mutate(before.ToArray()); before.AssertContainSameElements(after); } }
public static void AssertAllValuesAreGenerated <T>(this IMutationManager <T> mutationManager, int maxValue, int minValue) { var gottenValues = new HashSet <int>(); var runs = maxValue - minValue; for (int i = 0; i < runs * 5; i++) { gottenValues.Add(mutationManager.Mutate(new[] { default(T) }).First().ToInt() + 5); } for (int i = 1; i < runs; i++) { Assert.IsTrue(gottenValues.Contains(i), $"We didn't get {i}"); } }
/// <summary> /// This class will create chromosomes of type VectorChromosome<int> /// </summary> /// <param name="vectorSize">The size of the generated chromosomes</param> /// <param name="minGenome">The genomes will be equal to or greater than minGenom</param> /// <param name="maxGenome">The genomes will be equal to or smaller than minGenom</param> /// <param name="mutationManager">A mutation manager to use</param> /// <param name="evaluator">An evaluator to use</param> public IntVectorChromosomePopulationGenerator(int vectorSize, int minGenome, int maxGenome, IMutationManager <int> mutationManager, IEvaluator evaluator) { if (vectorSize <= 0) { throw new GeneticAlgorithmException($"{nameof(vectorSize)} must be bigger than 0. It was {vectorSize}"); } if (maxGenome < minGenome) { throw new GeneticAlgorithmException($"{nameof(maxGenome)} ({maxGenome}) must be bigger than {nameof(minGenome)} ({minGenome})"); } this.vectorSize = vectorSize; this.minGenome = minGenome; this.maxGenome = maxGenome; this.mutationManager = mutationManager; this.evaluator = evaluator; }
public static void AssertCommonValuesAreMoreLikely <T>(this IMutationManager <T> mutationManager, double bourderValue) { var smallCount = 0; var bigCount = 0; for (int i = 0; i < 10; i++) { var value = Math.Abs(mutationManager.Mutate(new[] { default(T) }).First().ToInt()); Console.WriteLine(value); if (value >= bourderValue) { bigCount++; } else { smallCount++; } } Assert.IsTrue(smallCount > bigCount, "Got to many big genomes"); }
/// <summary> /// Creates a population of chromosomes of type VectorChromosome<T> by using the elements in element. /// </summary> public FromElementsVectorChromosomePopulationGenerator(T[] elements, int vectorLength, bool repeatElements, IMutationManager <T> mutationManager, IEvaluator evaluator) { if (elements.Length == 0) { throw new GeneticAlgorithmException($"{nameof(elements)} is empty"); } if (vectorLength <= 0) { throw new GeneticAlgorithmException($"{nameof(vectorLength)} must be greater than 0 (it was {vectorLength})"); } if (!repeatElements && elements.Length < vectorLength) { throw new GeneticAlgorithmException($"{nameof(elements)}.Count is only {elements.Length}, while {nameof(vectorLength)} is {vectorLength}."); } this.repeatElements = repeatElements; length = vectorLength; this.elements = elements; this.mutationManager = mutationManager; this.evaluator = evaluator; }
public GeneralEdgeRecombinationCrossover(IMutationManager <T> mutationManager, IEvaluator evaluator) { this.mutationManager = mutationManager; this.evaluator = evaluator; }
public K_PointCrossoverManager(int k, IMutationManager <T> mutationManager, IEvaluator evaluator) { this.k = k; this.mutationManager = mutationManager; this.evaluator = evaluator; }
/// <summary> /// PositionBasedCrossover Works on chromosomes of type VectorChromosome<T>. /// It assumes that both parents are of the same length, that every genome appears only once in each parent, /// and that both parents contain the same genomes (but probably in different orders). /// If one of these conditions isn't met, OrderBasedCrossover may throw an exception. /// /// Also, the Equals method must be implemented for type T. /// </summary> public PositionBasedCrossoverManager(IMutationManager <T> mutationManager, IEvaluator evaluator) { this.mutationManager = mutationManager; this.evaluator = evaluator; }
/// <summary> /// Ordered crossover Works on chromosomes of type VectorChromosome<T>. /// It assumes that both parents are of the same length, that every genome appears only once in each parent, /// and that both parents contain the same genomes (but probably in different orders). /// If one of these conditions isn't met, OrderCrossover may throw an exception. /// /// Also, the Equals method must be implemented for type T. /// </summary> public OrderCrossover(IMutationManager <T> mutationManager, IEvaluator evaluator) { this.mutationManager = mutationManager; this.evaluator = evaluator; }
/// <summary> /// HeuristicCrossover Works on chromosomes of type VectorChromosome<T>. /// It assumes that both parents are of the same length, that every genome appears only once in each parent, /// and that both parents contain the same genomes (but probably in different orders). /// If one of these conditions isn't met, HeuristicCrossover may throw an exception. /// /// Also, the Equals method must be implemented for type T. /// </summary> public HeuristicCrossover(IMutationManager <T> mutationManager, IEvaluator evaluator) { this.mutationManager = mutationManager; this.evaluator = evaluator; }
public SinglePointCrossoverManager(IMutationManager <T> mutationManager, IEvaluator evaluator) { kPointCrossover = new K_PointCrossoverManager <T>(1, mutationManager, evaluator); }
public UniformCrossoverManager(IMutationManager <T> mutationManager, IEvaluator evaluator) { this.mutationManager = mutationManager; this.evaluator = evaluator; }
/// <summary> /// AlternatingPositionCrossover Works on chromosomes of type VectorChromosome<T>. /// It assumes that both parents are of the same length, that every genome appears only once in each parent, /// and that both parents contain the same genomes (but probably in different orders). /// If one of these conditions isn't met, AlternatingPositionCrossover may throw an exception. /// /// Also, the Equals method must be implemented for type T. /// </summary> public AlternatingPositionCrossover(IMutationManager <T> mutationManager, IEvaluator evaluator) { this.mutationManager = mutationManager; this.evaluator = evaluator; }
/// <summary> /// PartiallyMatchedCrossover Works on chromosomes of type VectorChromosome<T>. /// It assumes that both parents are of the same length, that every genome appears only once in each parent, /// and that both parents contain the same genomes (but probably in different orders). /// If one of these conditions isn't met, PartiallyMatchedCrossover may throw an exception. /// /// Also, the Equals method must be implemented for type T. /// </summary> public PartiallyMappedCrossover(IMutationManager <T> mutationManager, IEvaluator evaluator) { this.mutationManager = mutationManager; this.evaluator = evaluator; }
public VectorChromosome(T[] vector, IMutationManager <T> mutationManager, IEvaluator evaluator) { this.vector = vector; this.mutationManager = mutationManager; this.evaluator = evaluator; }
public BinaryVectorChromosomePopulationGenerator(int vectorSize, IMutationManager <bool> mutationManager, IEvaluator evaluator) { this.vectorSize = vectorSize; this.mutationManager = mutationManager; this.evaluator = evaluator; }