public async Task GeneticEnvironment_EvaluateFitness_Async()
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
PopulationSeed = new MockPopulation(),
GeneticEntitySeed = new MockEntity(),
FitnessEvaluator = new MockFitnessEvaluator(),
SelectionOperator = new MockSelectionOperator
{
SelectionBasedOnFitnessType = FitnessType.Scaled
}
};
algorithm.FitnessEvaluator = new MockFitnessEvaluator();
algorithm.FitnessEvaluator.Initialize(algorithm);
algorithm.SelectionOperator = new MockSelectionOperator();
algorithm.SelectionOperator.Initialize(algorithm);
GeneticEnvironment environment = new GeneticEnvironment(algorithm);
MockPopulation population1 = GetPopulation(algorithm);
MockPopulation population2 = GetPopulation(algorithm);
environment.Populations.Add(population1);
environment.Populations.Add(population2);
await environment.EvaluateFitnessAsync();
VerifyFitnessEvaluation(population1);
VerifyFitnessEvaluation(population2);
}
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 MinimumFitness_GetResultValue_WithScaling()
{
MinimumFitness metric = new MinimumFitness();
metric.Initialize(new MockGeneticAlgorithm {
FitnessScalingStrategy = new MockFitnessScalingStrategy()
});
MockPopulation population = new MockPopulation();
population.Entities.Add(new MockEntity {
ScaledFitnessValue = 11
});
population.Entities.Add(new MockEntity {
ScaledFitnessValue = 10
});
population.Entities.Add(new MockEntity {
ScaledFitnessValue = 15
});
population.Entities.Add(new MockEntity {
ScaledFitnessValue = 13
});
object result = metric.GetResultValue(population);
Assert.Equal((double)10, result);
}
public void Population_Serialization()
{
MockPopulation population = new MockPopulation
{
MinimumPopulationSize = 10,
Index = 3,
};
population.Entities.Add(new MockEntity());
PrivateObject privObj = new PrivateObject(population, new PrivateType(typeof(Population)));
privObj.SetField("rawMean", (double)1);
privObj.SetField("rawStandardDeviation", (double)2);
privObj.SetField("rawMax", (double)3);
privObj.SetField("rawMin", (double)4);
MockPopulation result = (MockPopulation)SerializationHelper.TestSerialization(population, new Type[]
{
typeof(MockEntity)
});
PrivateObject resultPrivObj = new PrivateObject(result, new PrivateType(typeof(Population)));
Assert.Equal(population.MinimumPopulationSize, result.MinimumPopulationSize);
Assert.Equal(population.Index, result.Index);
Assert.IsType <MockEntity>(result.Entities[0]);
Assert.Equal((double)1, resultPrivObj.GetField("rawMean"));
Assert.Equal((double)2, resultPrivObj.GetField("rawStandardDeviation"));
Assert.Equal((double)3, resultPrivObj.GetField("rawMax"));
Assert.Equal((double)4, resultPrivObj.GetField("rawMin"));
}
public async Task Population_Initialize_Async()
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
FitnessEvaluator = new MockFitnessEvaluator(),
SelectionOperator = new MockSelectionOperator(),
GeneticEntitySeed = new MockEntity
{
TestProperty = 3
},
PopulationSeed = new MockPopulation
{
MinimumPopulationSize = 10
}
};
algorithm.GeneticEntitySeed.Initialize(algorithm);
MockPopulation population = new MockPopulation();
population.Initialize(algorithm);
await population.InitializeAsync();
Assert.Equal(algorithm.PopulationSeed.MinimumPopulationSize, population.Entities.Count);
Assert.Equal(3, ((MockEntity)population.Entities[0]).TestProperty);
}
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.");
}
public void FitnessStandardDeviation_GetResultValue_WithScaling()
{
FitnessStandardDeviation metric = new FitnessStandardDeviation();
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm {
FitnessScalingStrategy = new MockFitnessScalingStrategy()
};
MeanFitness meanFitness = new MeanFitness();
meanFitness.GetResults(0).Add(new MetricResult(0, 0, (double)12, meanFitness));
algorithm.Metrics.Add(meanFitness);
metric.Initialize(algorithm);
MockPopulation population = new MockPopulation();
population.Entities.Add(new MockEntity {
ScaledFitnessValue = 10
});
population.Entities.Add(new MockEntity {
ScaledFitnessValue = 11
});
population.Entities.Add(new MockEntity {
ScaledFitnessValue = 15
});
object result = metric.GetResultValue(population);
Assert.Equal(2.16025, Math.Round((double)result, 5));
}
private static void VerifyFitnessEvaluation(MockPopulation population)
{
Assert.Equal("5", ((MockEntity)population.Entities[0]).Identifier);
Assert.Equal("2", ((MockEntity)population.Entities[1]).Identifier);
Assert.Equal((double)5, population.Entities[0].RawFitnessValue);
Assert.Equal((double)2, population.Entities[1].RawFitnessValue);
}
public void PopulationSizeTest_Valid()
{
MockPopulation target = new MockPopulation();
int val = 100;
target.MinimumPopulationSize = val;
Assert.Equal(val, target.MinimumPopulationSize);
}
public void SelectionOperator_SelectEntities_NullSelectionResult()
{
MockSelectionOperator2 op = new MockSelectionOperator2();
MockPopulation population = new MockPopulation();
population.Entities.Add(new MockEntity());
Assert.Throws <InvalidOperationException>(() => op.SelectEntities(0, population));
}
public void ElitismStrategy_NullPopulation()
{
MockElitismStrategy3 strategy = new MockElitismStrategy3();
MockPopulation population = new MockPopulation();
population.Entities.Add(new MockEntity());
Assert.Throws <ArgumentNullException>(() => strategy.GetEliteEntities(population));
Assert.True(strategy.GetEliteGeneticEntitiesCoreCalled);
}
public void ElitismStrategy_GetElitistGeneticEntities_EmptyPopulation()
{
GeneticAlgorithm algorithm = GetGeneticAlgorithm(.1);
MockElitismStrategy strategy = new MockElitismStrategy();
strategy.Initialize(algorithm);
MockPopulation pop = new MockPopulation();
pop.Initialize(algorithm);
Assert.Throws <ArgumentException>(() => strategy.GetEliteEntities(pop));
}
public void FitnessScalingStrategy_Scale_EmptyPopulation()
{
GeneticAlgorithm algorithm = GetAlgorithm();
FakeFitnessScalingStrategy2 strategy = new FakeFitnessScalingStrategy2();
strategy.Initialize(algorithm);
MockPopulation population = new MockPopulation();
population.Initialize(algorithm);
Assert.Throws <ArgumentException>(() => strategy.Scale(population));
}
public void SelectionOperator_Select_EmptyPopulation()
{
GeneticAlgorithm algorithm = GetAlgorithm();
MockSelectionOperator op = new MockSelectionOperator();
op.Initialize(algorithm);
MockPopulation population = new MockPopulation();
population.Initialize(algorithm);
Assert.Throws <ArgumentException>(() => op.SelectEntities(1, population));
}
public void MinimumFitness_GetResultValue_NoScaling()
{
MinimumFitness metric = new MinimumFitness();
metric.Initialize(new MockGeneticAlgorithm());
MockPopulation population = new MockPopulation();
PrivateObject populationAccessor = new PrivateObject(population, new PrivateType(typeof(Population)));
populationAccessor.SetField("rawMin", (double)2);
object result = metric.GetResultValue(population);
Assert.Equal((double)2, result);
}
public void FitnessStandardDeviation_GetResultValue_NoScaling()
{
FitnessStandardDeviation metric = new FitnessStandardDeviation();
metric.Initialize(new MockGeneticAlgorithm());
MockPopulation population = new MockPopulation();
PrivateObject populationAccessor = new PrivateObject(population, new PrivateType(typeof(Population)));
populationAccessor.SetField("rawStandardDeviation", (double)18);
object result = metric.GetResultValue(population);
Assert.Equal((double)18, result);
}
public void Population_Ctor()
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new MockEntity(),
PopulationSeed = new MockPopulation(),
};
Population population = new MockPopulation();
population.Initialize(algorithm);
PrivateObject accessor = new PrivateObject(population);
Assert.Same(algorithm, accessor.GetProperty("Algorithm"));
}
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);
}
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 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.");
}
public void BestMaximumFitness_GetResultValue_AllNegative()
{
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm();
MaximumFitness maximumFitness = new MaximumFitness();
algorithm.Metrics.Add(maximumFitness);
ObservableCollection <MetricResult> population1Results = maximumFitness.GetResults(0);
population1Results.Add(new MetricResult(0, 0, (double)-5, maximumFitness));
BestMaximumFitness target = new BestMaximumFitness();
target.Initialize(algorithm);
MockPopulation population = new MockPopulation
{
Index = 0
};
object result = target.GetResultValue(population);
Assert.Equal((double)-5, result);
population1Results.Add(new MetricResult(1, 0, (double)-6, maximumFitness));
result = target.GetResultValue(population);
Assert.Equal((double)-5, result);
ObservableCollection <MetricResult> population2Results = maximumFitness.GetResults(1);
population2Results.Add(new MetricResult(0, 2, (double)-10, maximumFitness));
MockPopulation population2 = new MockPopulation
{
Index = 1
};
result = target.GetResultValue(population2);
Assert.Equal((double)-10, result);
population2Results.Add(new MetricResult(1, 1, (double)-4, maximumFitness));
result = target.GetResultValue(population2);
Assert.Equal((double)-4, result);
}
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 PopulationSizeTest_Invalid()
{
MockPopulation target = new MockPopulation();
Assert.Throws <ValidationException>(() => target.MinimumPopulationSize = 0);
}
private static async Task TestEvaluateFitnessAsync(bool useScaling, bool useMetric)
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
SelectionOperator = new MockSelectionOperator(),
GeneticEntitySeed = new MockEntity(),
PopulationSeed = new MockPopulation(),
FitnessEvaluator = new MockFitnessEvaluator(),
};
if (useScaling)
{
algorithm.FitnessScalingStrategy = new FakeFitnessScalingStrategy();
}
if (useMetric)
{
algorithm.Metrics.Add(new MockMetric());
}
algorithm.FitnessEvaluator = new MockFitnessEvaluator();
algorithm.FitnessEvaluator.Initialize(algorithm);
if (useScaling)
{
algorithm.FitnessScalingStrategy = new FakeFitnessScalingStrategy();
algorithm.FitnessScalingStrategy.Initialize(algorithm);
}
MockPopulation population = new MockPopulation();
population.Initialize(algorithm);
MockEntity entity1 = new MockEntity();
entity1.Initialize(algorithm);
entity1.Identifier = "123";
population.Entities.Add(entity1);
MockEntity entity2 = new MockEntity();
entity2.Initialize(algorithm);
entity2.Identifier = "456";
population.Entities.Add(entity2);
await population.EvaluateFitnessAsync();
Assert.Equal((double)123, entity1.RawFitnessValue);
Assert.Equal((double)456, entity2.RawFitnessValue);
if (useScaling)
{
Assert.Equal(entity1.RawFitnessValue - 1, entity1.ScaledFitnessValue);
Assert.Equal(entity2.RawFitnessValue - 1, entity2.ScaledFitnessValue);
}
else
{
Assert.Equal(entity1.RawFitnessValue, entity1.ScaledFitnessValue);
Assert.Equal(entity2.RawFitnessValue, entity2.ScaledFitnessValue);
}
if (!useMetric && !useScaling)
{
Assert.False(population.RawMax.HasValue, "RawMax not set correctly.");
Assert.False(population.RawMin.HasValue, "RawMax not set correctly.");
Assert.False(population.RawMean.HasValue, "RawMean not set correctly.");
Assert.False(population.RawStandardDeviation.HasValue, "RawStandardDeviation not set correctly.");
}
else
{
Assert.Equal(entity2.RawFitnessValue, population.RawMax);
Assert.Equal(entity1.RawFitnessValue, population.RawMin);
Assert.Equal((entity1.RawFitnessValue + entity2.RawFitnessValue) / 2, population.RawMean);
}
}
public void Population_Ctor_NullAlgorithm()
{
MockPopulation population = new MockPopulation();
Assert.Throws <ArgumentNullException>(() => population.Initialize(null));
}
