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 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.");
}
public async Task ElitismStrategy_GetElitistGeneticEntities()
{
double elitismRatio = .1;
int totalGeneticEntities = 100;
GeneticAlgorithm algorithm = GetGeneticAlgorithm(elitismRatio);
await algorithm.InitializeAsync();
MockPopulation population = new MockPopulation();
population.Initialize(algorithm);
for (int i = 0; i < totalGeneticEntities; i++)
{
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
population.Entities.Add(entity);
}
algorithm.Environment.Populations.Add(population);
MockElitismStrategy strategy = (MockElitismStrategy)algorithm.ElitismStrategy;
strategy.Initialize(algorithm);
IList <GeneticEntity> geneticEntities = strategy.GetEliteEntities(population);
Assert.Equal(Convert.ToInt32(Math.Round(elitismRatio * totalGeneticEntities)), geneticEntities.Count);
}
public void TestChangingSceneGraphForEntity()
{
var entity = new MockEntity(0);
entity.Initialize();
var root1 = new SceneGraphRoot();
var root2 = new SceneGraphRoot();
root1.AddAsync(entity);
entity.Parent.Should().Be(root1);
new Action(() => root1.AddAsync(entity)).Should().Throw <NotSupportedException>();
root1.RemoveAsync(entity);
entity.Parent.Should().Be(root1, "because RemoveScheduled will only be called in the next update");
root1.Update(new GameTime());
entity.Parent.Should().BeNull("because update now removed the entity from the scene");
root2.AddAsync(entity);
entity.Parent.Should().Be(root2);
root1.IsRegistered(entity).Should().BeFalse("because it will only be registered in the update call");
new Action(() => entity.ChangeParent(root1)).Should().Throw <NotSupportedException>();
// call update so entity is actually registered with the root2
root2.Update(new GameTime());
// only now is the alternative method possible
entity.ChangeParent(root1);
entity.Parent.Should().Be(root1);
}
public void CrossoverOperator_Crossover()
{
double crossoverRate = 1; // force crossover to occur
MockGeneticAlgorithm algorithm = GetGeneticAlgorithm(crossoverRate);
FakeCrossoverOperator op = new FakeCrossoverOperator {
CrossoverRate = crossoverRate
};
op.Initialize(algorithm);
MockEntity entity1 = new MockEntity();
entity1.Initialize(algorithm);
entity1.Age = 2;
entity1.Identifier = "1";
MockEntity entity2 = new MockEntity();
entity2.Initialize(algorithm);
entity2.Age = 5;
entity2.Identifier = "3";
IList <GeneticEntity> geneticEntities = op.Crossover(new GeneticEntity[] { entity1, entity2 }).ToList();
Assert.NotSame(entity1, geneticEntities[1]);
Assert.NotSame(entity2, geneticEntities[0]);
Assert.Equal(entity1.Identifier, ((MockEntity)geneticEntities[1]).Identifier);
Assert.Equal(entity2.Identifier, ((MockEntity)geneticEntities[0]).Identifier);
Assert.Equal(0, geneticEntities[0].Age);
Assert.Equal(0, geneticEntities[1].Age);
}
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 void ChildParentRelationBetweenEntityAndGraphShouldExist()
{
var root = new SceneGraphRoot();
root.Parent.Should().BeNull();
var node = new MockEntity(0);
node.Parent.Should().BeNull();
node.Initialize();
node.Initialized.Should().BeTrue();
root.AddAsync(node);
node.Parent.Should().Be(root, "because add scheduled added the node right away as it was already initialized");
const int sleep = 1000;
var lazyNode = new MockEntity(sleep);
lazyNode.Initialized.Should().BeFalse();
var before = DateTime.Now;
root.AddAsync(lazyNode);
lazyNode.Initialized.Should().BeFalse();
lazyNode.Parent.Should().Be(root);
// wait longer than init would take
while (DateTime.Now < before + TimeSpan.FromMilliseconds(sleep + 1000))
{
Thread.Sleep(10);
}
// assert that it was infact executed
lazyNode.Initialized.Should().BeTrue();
}
public void EntityCollection_SortByFitness()
{
ObservableCollection <GeneticEntity> geneticEntities = new ObservableCollection <GeneticEntity>();
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
PopulationSeed = new MockPopulation(),
GeneticEntitySeed = new MockEntity()
};
for (int i = 9; i >= 0; i--)
{
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
entity.ScaledFitnessValue = Convert.ToDouble(i);
geneticEntities.Add(entity);
}
GeneticEntity[] sortedEntities = geneticEntities.GetEntitiesSortedByFitness(FitnessType.Scaled, FitnessEvaluationMode.Maximize).ToArray();
for (int i = 0; i < 10; i++)
{
Assert.Equal(Convert.ToDouble(i), sortedEntities[i].ScaledFitnessValue);
}
sortedEntities = geneticEntities.GetEntitiesSortedByFitness(FitnessType.Scaled, FitnessEvaluationMode.Minimize).ToArray();
int entityIndex = 0;
for (int i = 9; i >= 0; i--)
{
Assert.Equal(Convert.ToDouble(i), sortedEntities[entityIndex].ScaledFitnessValue);
entityIndex++;
}
}
public void Entity_CopyTo()
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
PopulationSeed = new MockPopulation(),
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new MockEntity()
};
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
entity.Age = 10;
entity.ScaledFitnessValue = 10;
PrivateObject accessor = new PrivateObject(entity, new PrivateType(typeof(GeneticEntity)));
accessor.SetField("rawFitnessValue", 123);
MockEntity newEntity = new MockEntity();
newEntity.Initialize(algorithm);
entity.CopyTo(newEntity);
Assert.Equal(entity.Age, newEntity.Age);
Assert.Equal(entity.RawFitnessValue, newEntity.RawFitnessValue);
Assert.Equal(entity.ScaledFitnessValue, newEntity.ScaledFitnessValue);
}
public void BoltzmannSelectionOperator_Select()
{
double initialTemp = 10;
GeneticAlgorithm algorithm = GetMockAlgorithm(initialTemp);
FakeBoltzmannSelectionOperator op = (FakeBoltzmannSelectionOperator)algorithm.SelectionOperator;
op.Initialize(algorithm);
MockPopulation population = new MockPopulation();
population.Initialize(algorithm);
MockEntity entity1 = new MockEntity();
entity1.Initialize(algorithm);
population.Entities.Add(entity1);
MockEntity entity2 = new MockEntity();
entity2.Initialize(algorithm);
population.Entities.Add(entity2);
IEnumerable <GeneticEntity> entities = op.SelectEntities(2, population);
Assert.NotNull(entities);
Assert.True(entities.Count() > 0, "An entity should have been selected.");
}
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]);
}
private void AddEntity(GeneticAlgorithm algorithm, double fitness, Population population)
{
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
PrivateObject accessor = new PrivateObject(entity, new PrivateType(typeof(GeneticEntity)));
accessor.SetField("rawFitnessValue", fitness);
population.Entities.Add(entity);
}
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 void Entity_Initialize()
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
PopulationSeed = new MockPopulation(),
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new MockEntity()
};
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
Assert.Equal("11111", entity.Identifier);
}
public void MutationOperator_Mutate()
{
GeneticAlgorithm algorithm = GetAlgorithm(.03);
MockMutationOperator op = new MockMutationOperator();
op.Initialize(algorithm);
GeneticEntity entity = new MockEntity();
entity.Initialize(algorithm);
entity.Age = 10;
GeneticEntity mutant = op.Mutate(entity);
Assert.NotSame(entity, mutant);
Assert.Equal(entity.Age, mutant.Age);
Assert.Equal(1, op.DoMutateCallCount);
}
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]);
}
public void FitnessScalingStrategy_Scale()
{
GeneticAlgorithm algorithm = GetAlgorithm();
FakeFitnessScalingStrategy2 strategy = new FakeFitnessScalingStrategy2();
strategy.Initialize(algorithm);
MockPopulation population = new MockPopulation();
population.Initialize(algorithm);
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
population.Entities.Add(entity);
strategy.Scale(population);
Assert.True(strategy.OnScaleCalled, "ScaleCore was not called.");
}
private static MockPopulation GetPopulation(GeneticAlgorithm algorithm)
{
MockPopulation population = new MockPopulation();
population.Initialize(algorithm);
MockEntity entity1 = new MockEntity();
entity1.Initialize(algorithm);
entity1.Identifier = "5";
MockEntity entity2 = new MockEntity();
entity2.Initialize(algorithm);
entity2.Identifier = "2";
population.Entities.Add(entity1);
population.Entities.Add(entity2);
return(population);
}
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 BoltzmannSelectionOperator_Select_Overflow()
{
double initialTemp = .0000001;
MockGeneticAlgorithm algorithm = GetMockAlgorithm(initialTemp);
FakeBoltzmannSelectionOperator op = new FakeBoltzmannSelectionOperator();
op.Initialize(algorithm);
MockPopulation population = new MockPopulation();
population.Initialize(algorithm);
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
entity.ScaledFitnessValue = 1;
population.Entities.Add(entity);
Assert.Throws <OverflowException>(() => op.SelectEntities(1, population));
}
public void Entity_GetFitnessValue()
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
PopulationSeed = new MockPopulation(),
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new MockEntity()
};
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
PrivateObject accessor = new PrivateObject(entity, new PrivateType(typeof(GeneticEntity)));
entity.ScaledFitnessValue = 12;
accessor.SetField("rawFitnessValue", 10);
Assert.Equal(entity.ScaledFitnessValue, entity.GetFitnessValue(FitnessType.Scaled));
Assert.Equal(accessor.GetField("rawFitnessValue"), entity.GetFitnessValue(FitnessType.Raw));
}
public async Task FitnessEvaluator_EvaluateFitness_Async()
{
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
SelectionOperator = new MockSelectionOperator(),
PopulationSeed = new MockPopulation(),
GeneticEntitySeed = new MockEntity(),
FitnessEvaluator = new FakeFitnessEvaluator2()
};
FakeFitnessEvaluator2 evaluator = new FakeFitnessEvaluator2();
evaluator.Initialize(algorithm);
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
double actualVal = await evaluator.EvaluateFitnessAsync(entity);
Assert.Equal((double)99, actualVal);
}
public void CrossoverOperator_Crossover_NoOp()
{
double crossoverRate = 0; // force crossover not to occur
MockGeneticAlgorithm algorithm = GetGeneticAlgorithm(crossoverRate);
FakeCrossoverOperator op = (FakeCrossoverOperator)algorithm.CrossoverOperator;
op.Initialize(algorithm);
MockEntity entity1 = new MockEntity();
entity1.Initialize(algorithm);
entity1.Identifier = "1";
MockEntity entity2 = new MockEntity();
entity2.Initialize(algorithm);
entity2.Identifier = "3";
IList <GeneticEntity> geneticEntities = op.Crossover(new GeneticEntity[] { entity1, entity2 }).ToList();
Assert.Same(entity1, geneticEntities[0]);
Assert.Same(entity2, geneticEntities[1]);
}
public async Task Entity_EvaluateFitness_Async()
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
PopulationSeed = new MockPopulation(),
SelectionOperator = new MockSelectionOperator(),
GeneticEntitySeed = new MockEntity(),
FitnessEvaluator = new MockFitnessEvaluator(),
};
algorithm.FitnessEvaluator = new MockFitnessEvaluator();
algorithm.FitnessEvaluator.Initialize(algorithm);
MockEntity entity = new MockEntity();
entity.Initialize(algorithm);
entity.Identifier = "123";
await entity.EvaluateFitnessAsync();
Assert.Equal((double)123, entity.RawFitnessValue);
Assert.Equal((double)123, entity.ScaledFitnessValue);
}
public void SelectionOperator_Select()
{
GeneticAlgorithm algorithm = GetAlgorithm();
MockSelectionOperator op = new MockSelectionOperator();
op.Initialize(algorithm);
MockPopulation population = new MockPopulation();
population.Initialize(algorithm);
GeneticEntity entity1 = new MockEntity();
entity1.Initialize(algorithm);
GeneticEntity entity2 = new MockEntity();
entity2.Initialize(algorithm);
population.Entities.Add(entity1);
population.Entities.Add(entity2);
IList <GeneticEntity> selectedEntities = op.SelectEntities(1, population);
Assert.Same(entity1, selectedEntities[0]);
Assert.Equal(1, op.DoSelectCallCount);
}
public void RouletteWheelSampler_GetEntity_NoSizes()
{
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
GeneticEntitySeed = new MockEntity(),
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
PopulationSeed = new MockPopulation()
};
List <WheelSlice> slices = new List <WheelSlice>();
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);
slices.Add(new WheelSlice(entity1, 0));
slices.Add(new WheelSlice(entity2, 0));
slices.Add(new WheelSlice(entity3, 0));
slices.Add(new WheelSlice(entity4, 0));
TestRandomUtil randomUtil = new TestRandomUtil();
RandomNumberService.Instance = randomUtil;
randomUtil.RandomValue = 2;
GeneticEntity sampledEntity = RouletteWheelSampler.GetEntity(slices);
Assert.Equal(4, randomUtil.MaxValuePassed);
Assert.Same(entity3, sampledEntity);
}
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 void Entity_Ctor_NullAlgorithm()
{
MockEntity entity = new MockEntity();
Assert.Throws <ArgumentNullException>(() => entity.Initialize(null));
}
public void RouletteWheelSampler_GetEntity()
{
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
GeneticEntitySeed = new MockEntity(),
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
PopulationSeed = new MockPopulation()
};
List <WheelSlice> slices = new List <WheelSlice>();
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);
slices.Add(new WheelSlice(entity1, 4));
slices.Add(new WheelSlice(entity2, 2));
slices.Add(new WheelSlice(entity3, 1));
slices.Add(new WheelSlice(entity4, 3));
TestRandomUtil randomUtil = new TestRandomUtil();
RandomNumberService.Instance = randomUtil;
randomUtil.Ratio = 0;
GeneticEntity sampledEntity = RouletteWheelSampler.GetEntity(slices);
Assert.Same(entity1, sampledEntity);
randomUtil.Ratio = .39999;
sampledEntity = RouletteWheelSampler.GetEntity(slices);
Assert.Same(entity1, sampledEntity);
randomUtil.Ratio = .4;
sampledEntity = RouletteWheelSampler.GetEntity(slices);
Assert.Same(entity2, sampledEntity);
randomUtil.Ratio = .59999;
sampledEntity = RouletteWheelSampler.GetEntity(slices);
Assert.Same(entity2, sampledEntity);
randomUtil.Ratio = .6;
sampledEntity = RouletteWheelSampler.GetEntity(slices);
Assert.Same(entity3, sampledEntity);
randomUtil.Ratio = .69999;
sampledEntity = RouletteWheelSampler.GetEntity(slices);
Assert.Same(entity3, sampledEntity);
randomUtil.Ratio = .7;
sampledEntity = RouletteWheelSampler.GetEntity(slices);
Assert.Same(entity4, sampledEntity);
randomUtil.Ratio = 1;
sampledEntity = RouletteWheelSampler.GetEntity(slices);
Assert.Same(entity4, sampledEntity);
}
