public void TreeEntityBase_SetRootNode()
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
PopulationSeed = new MockPopulation(),
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new TestTreeEntity()
};
TestTreeEntity entity = new TestTreeEntity();
entity.Initialize(algorithm);
TreeNode node = new TreeNode();
TreeNode childNode = new TreeNode();
PrivateObject nodeAccessor = new PrivateObject(childNode);
nodeAccessor.SetField("parentNode", node);
TreeNode grandChildNode = new TreeNode();
node.ChildNodes.Add(childNode);
childNode.ChildNodes.Add(grandChildNode);
entity.SetRootNode(childNode);
Assert.Same(childNode, entity.RootNode);
Assert.Null(childNode.ParentNode);
Assert.Same(entity, childNode.Tree);
Assert.Same(entity, grandChildNode.Tree);
}
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 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 TreeEntityBase_GetSize()
{
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
PopulationSeed = new MockPopulation(),
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new TestTreeEntity()
};
TestTreeEntity entity = new TestTreeEntity();
entity.Initialize(algorithm);
int size = entity.GetSize();
Assert.Equal(0, size);
entity.SetRootNode(new TreeNode());
entity.RootNode.AppendChild(new TreeNode());
entity.RootNode.ChildNodes[0].AppendChild(new TreeNode());
entity.RootNode.AppendChild(new TreeNode());
size = entity.GetSize();
Assert.Equal(4, size);
}
public async Task Metric_Calculate()
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
MinimumEnvironmentSize = 2,
GeneticEntitySeed = new MockEntity(),
FitnessEvaluator = new MockFitnessEvaluator(),
SelectionOperator = new MockSelectionOperator(),
PopulationSeed = new MockPopulation()
};
algorithm.Metrics.Add(new FakeMetric());
await algorithm.InitializeAsync();
FakeMetric metric = (FakeMetric)algorithm.Metrics[0];
metric.Calculate(algorithm.Environment, 1);
Assert.Equal(4, metric.GetResultValueCallCount);
ObservableCollection <MetricResult> results = metric.GetResults(0);
Assert.Equal(2, results.Count);
Assert.Equal(0, results[0].GenerationIndex);
Assert.Equal(0, results[0].PopulationIndex);
Assert.Equal(1, results[0].ResultValue);
Assert.Same(metric, results[0].Metric);
results = metric.GetResults(1);
Assert.Equal(0, results[0].GenerationIndex);
Assert.Equal(1, results[0].PopulationIndex);
Assert.Equal(2, results[0].ResultValue);
Assert.Same(metric, results[0].Metric);
}
private static void TestIsValid(int crossoverPointCount, bool requiresUniqueElementValues, bool expectedIsValid)
{
MultiPointCrossoverOperator op = new MultiPointCrossoverOperator
{
CrossoverPointCount = crossoverPointCount
};
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
GeneticEntitySeed = new IntegerListEntity
{
RequiresUniqueElementValues = requiresUniqueElementValues
}
};
op.Initialize(algorithm);
MultiPointCrossoverOperatorCrossoverPointValidator validator =
new MultiPointCrossoverOperatorCrossoverPointValidator();
bool result = validator.IsValid(op, out string errorMessage);
Assert.Equal(expectedIsValid, result);
if (expectedIsValid)
{
Assert.Null(errorMessage);
}
else
{
Assert.NotNull(errorMessage);
}
}
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));
}
public async Task GeneticEnvironment_Initialize_Async()
{
int environmentSize = 2;
int populationSize = 5;
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
FitnessEvaluator = new MockFitnessEvaluator(),
SelectionOperator = new MockSelectionOperator(),
GeneticEntitySeed = new MockEntity(),
MinimumEnvironmentSize = environmentSize,
PopulationSeed = new MockPopulation
{
MinimumPopulationSize = populationSize
}
};
algorithm.GeneticEntitySeed.Initialize(algorithm);
algorithm.PopulationSeed.Initialize(algorithm);
GeneticEnvironment environment = new GeneticEnvironment(algorithm);
await environment.InitializeAsync();
Assert.Equal(environmentSize, environment.Populations.Count);
for (int i = 0; i < environmentSize; i++)
{
Assert.Equal(i, environment.Populations[i].Index);
Assert.IsType <MockPopulation>(environment.Populations[i]);
Assert.Equal(populationSize, environment.Populations[i].Entities.Count);
}
}
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 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 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 SingleNodeTreeCrossoverOperator_Crossover()
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
FitnessEvaluator = new MockFitnessEvaluator(),
SelectionOperator = new MockSelectionOperator(),
PopulationSeed = new MockPopulation(),
GeneticEntitySeed = new FakeTreeEntity(),
CrossoverOperator = new SingleNodeTreeCrossoverOperator
{
CrossoverRate = 1
}
};
SingleNodeTreeCrossoverOperator op = (SingleNodeTreeCrossoverOperator)algorithm.CrossoverOperator;
op.Initialize(algorithm);
FakeTreeEntity entity1 = new FakeTreeEntity();
entity1.Initialize(algorithm);
entity1.SetRootNode(new FakeTreeNode(1));
entity1.RootNode.ChildNodes.Add(new FakeTreeNode(2));
entity1.RootNode.ChildNodes.Add(new FakeTreeNode(3));
entity1.RootNode.ChildNodes[1].ChildNodes.Add(new FakeTreeNode(4));
entity1.RootNode.ChildNodes.Add(new FakeTreeNode(5));
FakeTreeEntity entity2 = new FakeTreeEntity();
entity2.Initialize(algorithm);
entity2.SetRootNode(new FakeTreeNode(6));
entity2.RootNode.ChildNodes.Add(new FakeTreeNode(7));
entity2.RootNode.ChildNodes[0].ChildNodes.Add(new FakeTreeNode(8));
entity2.RootNode.ChildNodes[0].ChildNodes[0].ChildNodes.Add(new FakeTreeNode(9));
RandomNumberService.Instance = new TestRandomUtil();
IList <GeneticEntity> result = op.Crossover(new GeneticEntity[] { entity1, entity2 }).ToList();
FakeTreeNode rootNode1 = (FakeTreeNode)((TreeEntityBase)result[0]).RootNode;
FakeTreeNode rootNode2 = (FakeTreeNode)((TreeEntityBase)result[1]).RootNode;
Assert.Equal(1, rootNode1.Value);
Assert.Equal(3, rootNode1.ChildNodes.Count);
Assert.Equal(2, rootNode1.ChildNodes[0].Value);
Assert.Equal(7, rootNode1.ChildNodes[1].Value);
Assert.Single(rootNode1.ChildNodes[1].ChildNodes);
Assert.Equal(8, rootNode1.ChildNodes[1].ChildNodes[0].Value);
Assert.Single(rootNode1.ChildNodes[1].ChildNodes[0].ChildNodes);
Assert.Equal(9, rootNode1.ChildNodes[1].ChildNodes[0].ChildNodes[0].Value);
Assert.Equal(5, rootNode1.ChildNodes[2].Value);
Assert.Equal(6, rootNode2.Value);
Assert.Single(rootNode2.ChildNodes);
Assert.Equal(3, rootNode2.ChildNodes[0].Value);
Assert.Single(rootNode2.ChildNodes[0].ChildNodes);
Assert.Equal(4, rootNode2.ChildNodes[0].ChildNodes[0].Value);
}
private static GeneticAlgorithm GetAlgorithm()
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
PopulationSeed = new MockPopulation(),
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new TestTreeEntity()
};
return(algorithm);
}
public void VariableSinglePointCrossoverOperator_Validation_WithListEntityBase()
{
VariableSinglePointCrossoverOperator op = new VariableSinglePointCrossoverOperator();
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
GeneticEntitySeed = new IntegerListEntity()
};
op.Initialize(algorithm);
op.Validate();
}
public void VariableSinglePointCrossoverOperator_Validation_WithoutListEntityBase()
{
VariableSinglePointCrossoverOperator op = new VariableSinglePointCrossoverOperator();
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
GeneticEntitySeed = new MockEntity()
};
op.Initialize(algorithm);
Assert.Throws <ValidationException>(() => op.Validate());
}
public void Plugin_OnFitnessEvaluated()
{
TestPlugin plugin = new TestPlugin();
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm();
plugin.Initialize(algorithm);
PrivateObject accessor = new PrivateObject(algorithm, new PrivateType(typeof(GeneticAlgorithm)));
accessor.Invoke("OnFitnessEvaluated", new EnvironmentFitnessEvaluatedEventArgs(new GeneticEnvironment(algorithm), 0));
Assert.True(plugin.OnFitnessEvaluatedCalled);
}
public void Plugin_OnAlgorithmStarting()
{
TestPlugin plugin = new TestPlugin();
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm();
plugin.Initialize(algorithm);
PrivateObject accessor = new PrivateObject(algorithm, new PrivateType(typeof(GeneticAlgorithm)));
accessor.Invoke("OnAlgorithmStarting");
Assert.True(plugin.OnAlgorithmStartingCalled);
}
private static GeneticAlgorithm GetAlgorithm()
{
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new MockEntity(),
PopulationSeed = new MockPopulation(),
FitnessScalingStrategy = new FakeFitnessScalingStrategy2()
};
return(algorithm);
}
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 TreeEntityBase_CopyToNullEntity()
{
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
PopulationSeed = new MockPopulation(),
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new TestTreeEntity()
};
TestTreeEntity entity = new TestTreeEntity();
entity.Initialize(algorithm);
Assert.Throws <ArgumentNullException>(() => entity.CopyTo(null));
}
private GeneticAlgorithm GetAlgorithm()
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new MockEntity(),
PopulationSeed = new MockPopulation(),
SelectionOperator = new MockSelectionOperator
{
SelectionBasedOnFitnessType = FitnessType.Scaled
}
};
return(algorithm);
}
public void RequiredComponentTypeValidator_IsValid_NotValid()
{
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm();
CustomValidator validator = new CustomValidator(typeof(MockEntity), typeof(GeneticEntity))
{
HasRequiredComponentReturnValue = false,
ExpectedGeneticAlgorithm = algorithm
};
bool result = validator.IsValid(algorithm, out string errorMessage);
Assert.False(result);
Assert.NotNull(errorMessage);
}
public void TreeEntityBase_GetPrefixTree()
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
PopulationSeed = new MockPopulation(),
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new TestTreeEntity()
};
TestTreeEntity entity = new TestTreeEntity();
entity.Initialize(algorithm);
entity.SetRootNode(new TreeNode());
entity.RootNode.AppendChild(new TreeNode());
entity.RootNode.ChildNodes[0].AppendChild(new TreeNode());
entity.RootNode.AppendChild(new TreeNode());
int loopCount = 0;
IEnumerable <TreeNode> nodes = entity.GetPrefixTree();
foreach (TreeNode node in nodes)
{
switch (loopCount)
{
case 0:
Assert.Same(entity.RootNode, node);
break;
case 1:
Assert.Same(entity.RootNode.ChildNodes[0], node);
break;
case 2:
Assert.Same(entity.RootNode.ChildNodes[0].ChildNodes[0], node);
break;
case 3:
Assert.Same(entity.RootNode.ChildNodes[1], node);
break;
default:
Assert.True(false, "More nodes encountered than expected.");
break;
}
loopCount++;
}
}
private static GeneticAlgorithm GetAlgorithm(TimeSpan timeLimit)
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
GeneticEntitySeed = new MockEntity(),
PopulationSeed = new MockPopulation(),
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
Terminator = new TimeDurationTerminator
{
TimeLimit = timeLimit
}
};
return(algorithm);
}
private static GeneticAlgorithm GetAlgorithm(int entityLength)
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
PopulationSeed = new MockPopulation(),
GeneticEntitySeed = new TestIntegerListEntity
{
MinimumStartingLength = entityLength,
MaximumStartingLength = entityLength
}
};
return(algorithm);
}
private static MockGeneticAlgorithm GetGeneticAlgorithm(double elitismRatio)
{
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new MockEntity(),
PopulationSeed = new MockPopulation(),
ElitismStrategy = new MockElitismStrategy
{
ElitistRatio = elitismRatio
}
};
return(algorithm);
}
private static MockGeneticAlgorithm GetMockAlgorithm(double initialTemp)
{
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new MockEntity(),
PopulationSeed = new MockPopulation(),
SelectionOperator = new FakeBoltzmannSelectionOperator
{
SelectionBasedOnFitnessType = FitnessType.Scaled,
InitialTemperature = initialTemp
}
};
return(algorithm);
}
private static GeneticAlgorithm GetAlgorithm(double scalingPower)
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
GeneticEntitySeed = new MockEntity(),
PopulationSeed = new SimplePopulation(),
FitnessScalingStrategy = new ExponentialScalingStrategy
{
ScalingPower = scalingPower
}
};
return(algorithm);
}
private static GeneticAlgorithm GetAlgorithm(double mutationRate)
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
PopulationSeed = new MockPopulation(),
GeneticEntitySeed = new MockEntity(),
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
MutationOperator = new MockMutationOperator
{
MutationRate = mutationRate
}
};
return(algorithm);
}
private static MockGeneticAlgorithm GetGeneticAlgorithm(double crossoverRate)
{
MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
PopulationSeed = new MockPopulation(),
FitnessEvaluator = new MockFitnessEvaluator(),
SelectionOperator = new MockSelectionOperator(),
GeneticEntitySeed = new MockEntity(),
CrossoverOperator = new FakeCrossoverOperator
{
CrossoverRate = crossoverRate
}
};
return(algorithm);
}
