public void ExponentialScalingStrategy_Scale()
{
GeneticAlgorithm algorithm = GetAlgorithm(2);
ExponentialScalingStrategy target = (ExponentialScalingStrategy)algorithm.FitnessScalingStrategy;
target.Initialize(algorithm);
SimplePopulation population = new SimplePopulation();
population.Initialize(algorithm);
MockEntity entity1 = new MockEntity();
entity1.Initialize(algorithm);
PrivateObject entity1Accessor = new PrivateObject(entity1, new PrivateType(typeof(GeneticEntity)));
entity1Accessor.SetField("rawFitnessValue", 5);
MockEntity entity2 = new MockEntity();
entity2.Initialize(algorithm);
PrivateObject entity2Accessor = new PrivateObject(entity2, new PrivateType(typeof(GeneticEntity)));
entity2Accessor.SetField("rawFitnessValue", 7);
population.Entities.Add(entity1);
population.Entities.Add(entity2);
target.Scale(population);
Assert.Equal((double)25, entity1.ScaledFitnessValue);
Assert.Equal((double)49, entity2.ScaledFitnessValue);
}
public async Task MultiDemeGeneticAlgorithm_Migrate()
{
MultiDemeGeneticAlgorithm algorithm = new MultiDemeGeneticAlgorithm
{
MinimumEnvironmentSize = 3,
GeneticEntitySeed = new MockEntity(),
PopulationSeed = new SimplePopulation
{
MinimumPopulationSize = 4
},
FitnessEvaluator = new MockFitnessEvaluator(),
MigrantCount = 2,
SelectionOperator = new MockSelectionOperator
{
SelectionBasedOnFitnessType = FitnessType.Scaled
},
};
algorithm.SelectionOperator = new MockSelectionOperator();
algorithm.FitnessEvaluator = new MockFitnessEvaluator();
await algorithm.InitializeAsync();
SimplePopulation population1 = (SimplePopulation)algorithm.Environment.Populations[0];
population1.Entities[0].ScaledFitnessValue = 1;
population1.Entities[1].ScaledFitnessValue = 5;
population1.Entities[2].ScaledFitnessValue = 2;
population1.Entities[3].ScaledFitnessValue = 4;
SimplePopulation population2 = (SimplePopulation)algorithm.Environment.Populations[1];
population2.Entities[0].ScaledFitnessValue = 6;
population2.Entities[1].ScaledFitnessValue = 3;
population2.Entities[2].ScaledFitnessValue = 8;
population2.Entities[3].ScaledFitnessValue = 7;
SimplePopulation population3 = (SimplePopulation)algorithm.Environment.Populations[2];
population3.Entities[0].ScaledFitnessValue = 9;
population3.Entities[1].ScaledFitnessValue = 13;
population3.Entities[2].ScaledFitnessValue = 10;
population3.Entities[3].ScaledFitnessValue = 12;
algorithm.Migrate();
Assert.Equal((double)1, population1.Entities[0].ScaledFitnessValue);
Assert.Equal((double)2, population1.Entities[1].ScaledFitnessValue);
Assert.Equal((double)13, population1.Entities[2].ScaledFitnessValue);
Assert.Equal((double)12, population1.Entities[3].ScaledFitnessValue);
Assert.Equal((double)6, population2.Entities[0].ScaledFitnessValue);
Assert.Equal((double)3, population2.Entities[1].ScaledFitnessValue);
Assert.Equal((double)5, population2.Entities[2].ScaledFitnessValue);
Assert.Equal((double)4, population2.Entities[3].ScaledFitnessValue);
Assert.Equal((double)9, population3.Entities[0].ScaledFitnessValue);
Assert.Equal((double)10, population3.Entities[1].ScaledFitnessValue);
Assert.Equal((double)8, population3.Entities[2].ScaledFitnessValue);
Assert.Equal((double)7, population3.Entities[3].ScaledFitnessValue);
}
public async Task FitnessTargetTerminator_IsComplete_RawFitness()
{
double fitnessTarget = 15;
GeneticAlgorithm algorithm = GetAlgorithm(fitnessTarget, FitnessType.Raw);
await algorithm.InitializeAsync();
FitnessTargetTerminator terminator = (FitnessTargetTerminator)algorithm.Terminator;
terminator.Initialize(algorithm);
// Check with no populations
Assert.False(terminator.IsComplete(), "No genetic entities have the fitness target.");
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
SimplePopulation population = new SimplePopulation();
population.Initialize(algorithm);
population.Entities.Add(entity);
algorithm.Environment.Populations.Add(population);
// Check with a population with one entity
Assert.False(terminator.IsComplete(), "No genetic entities have the fitness target.");
PrivateObject accessor = new PrivateObject(entity, new PrivateType(typeof(GeneticEntity)));
accessor.SetField("rawFitnessValue", 15);
Assert.True(terminator.IsComplete(), "A entity does have the fitness target.");
}
public void SigmaScalingStrategy_Scale_Multiplier1()
{
GeneticAlgorithm algorithm = GetAlgorithm(5);
SigmaScalingStrategy strategy = new SigmaScalingStrategy {
Multiplier = 1
};
strategy.Initialize(algorithm);
SimplePopulation population = new SimplePopulation();
population.Initialize(algorithm);
PrivateObject populationAccessor = new PrivateObject(population, new PrivateType(typeof(Population)));
AddEntity(algorithm, 4, population);
AddEntity(algorithm, 10, population);
AddEntity(algorithm, 20, population);
AddEntity(algorithm, 0, population);
populationAccessor.SetField("rawMean", (double)(4 + 10 + 20) / 4);
populationAccessor.SetField("rawStandardDeviation", MathHelper.GetStandardDeviation(population.Entities, population.RawMean.Value, FitnessType.Raw));
strategy.Scale(population);
Assert.Equal(3.03, Math.Round(population.Entities[0].ScaledFitnessValue, 2));
Assert.Equal(9.03, Math.Round(population.Entities[1].ScaledFitnessValue, 2));
Assert.Equal(19.03, Math.Round(population.Entities[2].ScaledFitnessValue, 2));
Assert.Equal(0, Math.Round(population.Entities[3].ScaledFitnessValue, 2));
}
public async Task FitnessTargetTerminator_IsComplete_ScaledFitness()
{
double fitnessTarget = 15;
GeneticAlgorithm algorithm = GetAlgorithm(fitnessTarget, FitnessType.Scaled);
await algorithm.InitializeAsync();
FitnessTargetTerminator terminator = (FitnessTargetTerminator)algorithm.Terminator;
terminator.Initialize(algorithm);
// Check with no populations
Assert.False(terminator.IsComplete(), "No genetic entities have the fitness target.");
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
SimplePopulation population = new SimplePopulation();
population.Initialize(algorithm);
population.Entities.Add(entity);
algorithm.Environment.Populations.Add(population);
// Check with a population with one entity
Assert.False(terminator.IsComplete(), "No genetic entities have the fitness target.");
entity.ScaledFitnessValue = 15;
Assert.True(terminator.IsComplete(), "A entity does have the fitness target.");
}
private static GeneticEntity AddEntity(GeneticAlgorithm algorithm, SimplePopulation population, double scaledFitnessValue)
{
GeneticEntity entity = new MockEntity();
entity.Initialize(algorithm);
entity.ScaledFitnessValue = scaledFitnessValue;
population.Entities.Add(entity);
return(entity);
}
public void FitnessProportionateSelectionOperator_Select_MinimizeFitness()
{
GeneticAlgorithm algorithm = GetAlgorithm();
((MockFitnessEvaluator)algorithm.FitnessEvaluator).EvaluationMode = FitnessEvaluationMode.Minimize;
FitnessProportionateSelectionOperator op = new FitnessProportionateSelectionOperator();
op.Initialize(algorithm);
SimplePopulation population = new SimplePopulation();
population.Initialize(algorithm);
MockEntity entity1 = new MockEntity();
entity1.Initialize(algorithm);
entity1.ScaledFitnessValue = 1; // Slice size: 5
MockEntity entity2 = new MockEntity();
entity2.Initialize(algorithm);
entity2.ScaledFitnessValue = 5; // Slice size: 1
MockEntity entity3 = new MockEntity();
entity3.Initialize(algorithm);
entity3.ScaledFitnessValue = 4; // Slice size: 4
population.Entities.Add(entity1);
population.Entities.Add(entity2);
population.Entities.Add(entity3);
FakeRandomUtil randomUtil = new FakeRandomUtil();
RandomNumberService.Instance = randomUtil;
randomUtil.RandomRatio = 0;
IList <GeneticEntity> selectedEntities = op.SelectEntities(1, population).ToList();
Assert.Same(entity2, selectedEntities[0]);
randomUtil.RandomRatio = .099999;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity2, selectedEntities[0]);
randomUtil.RandomRatio = .1;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity3, selectedEntities[0]);
randomUtil.RandomRatio = .499999;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity3, selectedEntities[0]);
randomUtil.RandomRatio = .5;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity1, selectedEntities[0]);
randomUtil.RandomRatio = 1;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity1, selectedEntities[0]);
}
public void SigmaScalingStrategy_Scale_EmptyPopulation()
{
GeneticAlgorithm algorithm = GetAlgorithm(10);
SigmaScalingStrategy op = new SigmaScalingStrategy();
op.Initialize(algorithm);
SimplePopulation population = new SimplePopulation();
population.Initialize(algorithm);
Assert.Throws <ArgumentException>(() => op.Scale(population));
}
public void FitnessProportionateSelectionOperator_Select()
{
GeneticAlgorithm algorithm = GetAlgorithm();
FitnessProportionateSelectionOperator op = new FitnessProportionateSelectionOperator();
op.Initialize(algorithm);
SimplePopulation population = new SimplePopulation();
population.Initialize(algorithm);
MockEntity entity1 = new MockEntity();
entity1.Initialize(algorithm);
entity1.ScaledFitnessValue = 1;
MockEntity entity2 = new MockEntity();
entity2.Initialize(algorithm);
entity2.ScaledFitnessValue = 5;
MockEntity entity3 = new MockEntity();
entity3.Initialize(algorithm);
entity3.ScaledFitnessValue = 4;
population.Entities.Add(entity1);
population.Entities.Add(entity2);
population.Entities.Add(entity3);
FakeRandomUtil randomUtil = new FakeRandomUtil();
RandomNumberService.Instance = randomUtil;
randomUtil.RandomRatio = 0;
IList <GeneticEntity> selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity1, selectedEntities[0]);
randomUtil.RandomRatio = .099999;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity1, selectedEntities[0]);
randomUtil.RandomRatio = .1;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity2, selectedEntities[0]);
randomUtil.RandomRatio = .599999;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity2, selectedEntities[0]);
randomUtil.RandomRatio = .6;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity3, selectedEntities[0]);
randomUtil.RandomRatio = 1;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity3, selectedEntities[0]);
}
public async Task SteadyStateGeneticAlgorithm_CreateNextGeneration_Percentage()
{
SteadyStateGeneticAlgorithm algorithm = new SteadyStateGeneticAlgorithm
{
GeneticEntitySeed = new MockEntity(),
PopulationSeed = new SimplePopulation(),
FitnessEvaluator = new MockFitnessEvaluator(),
PopulationReplacementValue = new PopulationReplacementValue(20, ReplacementValueKind.Percentage),
SelectionOperator = new MockSelectionOperator
{
SelectionBasedOnFitnessType = FitnessType.Scaled
},
CrossoverOperator = new MockCrossoverOperator
{
CrossoverRate = 1
},
MutationOperator = new MockMutationOperator
{
MutationRate = 1
}
};
algorithm.SelectionOperator = new MockSelectionOperator {
SelectionBasedOnFitnessType = FitnessType.Scaled
};
algorithm.SelectionOperator.Initialize(algorithm);
algorithm.CrossoverOperator = new MockCrossoverOperator {
CrossoverRate = 1
};
algorithm.CrossoverOperator.Initialize(algorithm);
algorithm.MutationOperator = new MockMutationOperator {
MutationRate = 1
};
algorithm.MutationOperator.Initialize(algorithm);
algorithm.FitnessEvaluator = new MockFitnessEvaluator();
algorithm.FitnessEvaluator.Initialize(algorithm);
await algorithm.InitializeAsync();
PrivateObject ssAccessor = new PrivateObject(algorithm);
SimplePopulation population = GetPopulation(algorithm, 10);
int prevPopCount = population.Entities.Count;
await(Task) ssAccessor.Invoke("CreateNextGenerationAsync", population);
Assert.Equal(1, ((MockSelectionOperator)algorithm.SelectionOperator).DoSelectCallCount);
Assert.Equal(1, ((MockCrossoverOperator)algorithm.CrossoverOperator).DoCrossoverCallCount);
Assert.Equal(2, ((MockMutationOperator)algorithm.MutationOperator).DoMutateCallCount);
Assert.Equal(prevPopCount, population.Entities.Count);
}
public void UniformSelectionOperator_Select()
{
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new MockEntity(),
PopulationSeed = new SimplePopulation(),
SelectionOperator = new UniformSelectionOperator
{
SelectionBasedOnFitnessType = FitnessType.Scaled
}
};
UniformSelectionOperator op = new UniformSelectionOperator();
op.Initialize(algorithm);
SimplePopulation population = new SimplePopulation();
population.Initialize(algorithm);
for (int i = 0; i < 4; i++)
{
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
population.Entities.Add(entity);
}
TestRandomUtil randomUtil = new TestRandomUtil();
RandomNumberService.Instance = randomUtil;
randomUtil.Value = 3;
IList <GeneticEntity> selectedEntities = op.SelectEntities(1, population);
Assert.Same(population.Entities[randomUtil.Value], selectedEntities[0]);
randomUtil.Value = 2;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(population.Entities[randomUtil.Value], selectedEntities[0]);
randomUtil.Value = 1;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(population.Entities[randomUtil.Value], selectedEntities[0]);
randomUtil.Value = 0;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(population.Entities[randomUtil.Value], selectedEntities[0]);
}
private static SimplePopulation GetPopulation(GeneticAlgorithm algorithm, int populationSize)
{
SimplePopulation population = new SimplePopulation {
MinimumPopulationSize = populationSize
};
population.Initialize(algorithm);
for (int i = 0; i < population.MinimumPopulationSize; i++)
{
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
population.Entities.Add(entity);
}
return(population);
}
public void MeanTreeSize_GetResultValue()
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new TestTreeEntity(),
PopulationSeed = new SimplePopulation(),
};
algorithm.Metrics.Add(new MeanTreeSize());
MeanTreeSize target = new MeanTreeSize();
target.Initialize(algorithm);
SimplePopulation population = new SimplePopulation();
population.Initialize(algorithm);
TreeEntityBase entity = new TestTreeEntity();
entity.Initialize(algorithm);
entity.SetRootNode(new TreeNode());
entity.RootNode.ChildNodes.Add(new TreeNode());
entity.RootNode.ChildNodes.Add(new TreeNode());
entity.RootNode.ChildNodes[0].ChildNodes.Add(new TreeNode());
population.Entities.Add(entity);
entity = new TestTreeEntity();
entity.Initialize(algorithm);
entity.SetRootNode(new TreeNode());
population.Entities.Add(entity);
entity = new TestTreeEntity();
entity.Initialize(algorithm);
entity.SetRootNode(new TreeNode());
entity.RootNode.ChildNodes.Add(new TreeNode());
population.Entities.Add(entity);
object result = target.GetResultValue(population);
Assert.Equal(2.33, Math.Round((double)result, 2));
}
public void FitnessSharingScalingStrategy_Scale()
{
double scalingCurvature = .8;
double scalingDistance = 3;
GeneticAlgorithm algorithm = GetAlgorithm(scalingCurvature, scalingDistance);
FakeFitnessSharingScalingStrategy strategy = (FakeFitnessSharingScalingStrategy)algorithm.FitnessScalingStrategy;
strategy.Initialize(algorithm);
SimplePopulation population = new SimplePopulation();
population.Initialize(algorithm);
GeneticEntity entity1 = AddEntity(algorithm, population, 5);
GeneticEntity entity2 = AddEntity(algorithm, population, 6);
GeneticEntity entity3 = AddEntity(algorithm, population, 9);
GeneticEntity entity4 = AddEntity(algorithm, population, 11.5);
GeneticEntity entity5 = AddEntity(algorithm, population, 20);
GeneticEntity entity6 = AddEntity(algorithm, population, 25);
strategy.Scale(population);
ValidateScale(entity1, 3.16);
ValidateScale(entity2, 3.79);
ValidateScale(entity3, 7.92);
ValidateScale(entity4, 10.13);
ValidateScale(entity5, 20);
ValidateScale(entity6, 25);
// Change the population size to verify fitness distances are recalculated
GeneticEntity entity7 = AddEntity(algorithm, population, 10);
strategy.Scale(population);
ValidateScale(entity1, 1.84);
ValidateScale(entity2, 2.21);
ValidateScale(entity3, 5.37);
ValidateScale(entity4, 4.73);
ValidateScale(entity5, 20);
ValidateScale(entity6, 25);
ValidateScale(entity7, 4.6);
}
public void BestMaximumFitnessEntity_GetResultValue()
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new MockEntity(),
PopulationSeed = new SimplePopulation(),
};
algorithm.Metrics.Add(new BestMaximumFitnessEntity());
BestMaximumFitnessEntity target = new BestMaximumFitnessEntity();
target.Initialize(algorithm);
SimplePopulation population1 = new SimplePopulation()
{
Index = 0
};
population1.Initialize(algorithm);
VerifyGetResultValue(2, target, population1, algorithm, "20");
VerifyGetResultValue(1, target, population1, algorithm, "20");
VerifyGetResultValue(3, target, population1, algorithm, "30");
SimplePopulation population2 = new SimplePopulation()
{
Index = 1
};
population2.Initialize(algorithm);
VerifyGetResultValue(7, target, population2, algorithm, "70");
VerifyGetResultValue(1, target, population1, algorithm, "30");
VerifyGetResultValue(4, target, population2, algorithm, "70");
}
public async Task MultiDemeGeneticAlgorithm_CreateNextGeneration_Async()
{
TestMultiDemeGeneticAlgorithm algorithm = new TestMultiDemeGeneticAlgorithm
{
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new MockEntity(),
PopulationSeed = new SimplePopulation
{
MinimumPopulationSize = 3
},
MigrantCount = 1,
SelectionOperator = new MockSelectionOperator
{
SelectionBasedOnFitnessType = FitnessType.Raw
}
};
MockSelectionOperator selectionOp = new MockSelectionOperator();
algorithm.SelectionOperator = selectionOp;
await algorithm.InitializeAsync();
PrivateObject accessor = new PrivateObject(algorithm);
algorithm.Environment.Populations.Add(GetPopulation(algorithm));
algorithm.Environment.Populations.Add(GetPopulation(algorithm));
SimplePopulation population = GetPopulation(algorithm);
algorithm.Environment.Populations.Add(population);
int prevPopCount = population.Entities.Count;
await(Task) accessor.Invoke("CreateNextGenerationAsync", population);
Assert.Equal(1, selectionOp.DoSelectCallCount);
Assert.Equal(prevPopCount, population.Entities.Count);
}
private static void VerifyGetResultValue(int multiplier, BestMaximumFitnessEntity metric, SimplePopulation population, GeneticAlgorithm algorithm, string expectedReturnVal)
{
for (int i = 0; i < 5; i++)
{
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
entity.ScaledFitnessValue = i * multiplier;
entity.Identifier = entity.ScaledFitnessValue.ToString();
population.Entities.Add(entity);
}
for (int i = 10; i >= 5; i--)
{
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
entity.ScaledFitnessValue = i * multiplier;
entity.Identifier = entity.ScaledFitnessValue.ToString();
population.Entities.Add(entity);
}
object representation = metric.GetResultValue(population);
Assert.Equal(expectedReturnVal, representation.ToString());
}
public async Task SimpleGeneticAlgorithm_CreateNextGeneration_Async()
{
SimpleGeneticAlgorithm algorithm = new SimpleGeneticAlgorithm
{
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new MockEntity(),
PopulationSeed = new SimplePopulation(),
ElitismStrategy = new MockElitismStrategy
{
ElitistRatio = .1
},
SelectionOperator = new MockSelectionOperator
{
SelectionBasedOnFitnessType = FitnessType.Scaled
},
CrossoverOperator = new MockCrossoverOperator
{
CrossoverRate = 1
},
MutationOperator = new MockMutationOperator
{
MutationRate = 1
}
};
algorithm.ElitismStrategy = new MockElitismStrategy {
ElitistRatio = .1
};
algorithm.ElitismStrategy.Initialize(algorithm);
algorithm.SelectionOperator = new MockSelectionOperator {
SelectionBasedOnFitnessType = FitnessType.Scaled
};
algorithm.SelectionOperator.Initialize(algorithm);
algorithm.CrossoverOperator = new MockCrossoverOperator {
CrossoverRate = 1
};
algorithm.CrossoverOperator.Initialize(algorithm);
algorithm.MutationOperator = new MockMutationOperator {
MutationRate = 1
};
algorithm.MutationOperator.Initialize(algorithm);
PrivateObject accessor = new PrivateObject(algorithm);
SimplePopulation population = GetPopulation(algorithm, 10);
List <GeneticEntity> originalEntities = new List <GeneticEntity>(population.Entities);
int prevPopCount = population.Entities.Count;
await(Task) accessor.Invoke("CreateNextGenerationAsync", population);
// Find the number of entities in the new population that were in the original population
int actualElitistEntitiesCount = population.Entities.Count(e => originalEntities.Contains(e));
Assert.Equal(1, actualElitistEntitiesCount);
Assert.Equal(1, ((MockElitismStrategy)algorithm.ElitismStrategy).GetElitistGeneticEntitiesCallCount);
Assert.Equal(1, ((MockSelectionOperator)algorithm.SelectionOperator).DoSelectCallCount);
Assert.Equal(4, ((MockCrossoverOperator)algorithm.CrossoverOperator).DoCrossoverCallCount);
Assert.Equal(9, ((MockMutationOperator)algorithm.MutationOperator).DoMutateCallCount);
Assert.Equal(prevPopCount, population.Entities.Count);
}
public void RankSelectionOperator_Select()
{
GeneticAlgorithm algorithm = GetAlgorithm();
RankSelectionOperator op = new RankSelectionOperator();
op.Initialize(algorithm);
SimplePopulation population = new SimplePopulation();
population.Initialize(algorithm);
MockEntity entity1 = new MockEntity();
entity1.Initialize(algorithm);
MockEntity entity2 = new MockEntity();
entity2.Initialize(algorithm);
MockEntity entity3 = new MockEntity();
entity3.Initialize(algorithm);
MockEntity entity4 = new MockEntity();
entity4.Initialize(algorithm);
entity1.ScaledFitnessValue = 0;
entity2.ScaledFitnessValue = 50;
entity3.ScaledFitnessValue = 23;
entity4.ScaledFitnessValue = 25;
population.Entities.Add(entity1);
population.Entities.Add(entity2);
population.Entities.Add(entity3);
population.Entities.Add(entity4);
TestRandomUtil randomUtil = new TestRandomUtil();
RandomNumberService.Instance = randomUtil;
randomUtil.Ratio = 0;
IList <GeneticEntity> selectedEntities = op.SelectEntities(1, population).ToList();
Assert.Same(entity1, selectedEntities[0]);
randomUtil.Ratio = .099999;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity1, selectedEntities[0]);
randomUtil.Ratio = .1;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity3, selectedEntities[0]);
randomUtil.Ratio = .299999;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity3, selectedEntities[0]);
randomUtil.Ratio = .3;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity4, selectedEntities[0]);
randomUtil.Ratio = .599999;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity4, selectedEntities[0]);
randomUtil.Ratio = .6;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity2, selectedEntities[0]);
randomUtil.Ratio = 1;
selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity2, selectedEntities[0]);
}
