public void ManyIndividuals_AllocatesParetoFrontToAll()
{
var rng = new System.Random();
var shouldMinimise = new[] { true, true, true };
var inds = new List <Individual>();
for (var i = 0; i < 200; i++)
{
inds.Add(ObjectCreators.GetIndividual(new[] { rng.NextDouble(), rng.NextDouble(), rng.NextDouble() }));
}
foreach (var ind in inds)
{
ind.SendForEvaluation();
ind.SetProperty("sol1", ind.DecisionVector[0]);
ind.SetProperty("sol2", ind.DecisionVector[1]);
ind.SetProperty("sol3", ind.DecisionVector[2]);
ind.SetSolution("sol1", "sol2", "sol3");
}
var sorter = new FastNonDominatedSort();
sorter.PerformSort(inds, shouldMinimise);
Assert.True(inds.All(i => i.GetProperty <int>(OptimiserPropertyNames.ParetoFront) > 0));
}
public FastNonDominatedSortTests()
{
var solution1Name = ObjectCreators.Solution_Key;
var solution2Name = ObjectCreators.Solution_Key + "2";
individuals = new List <Individual>
{
ObjectCreators.GetIndividual(new double[] { 0, 3 }), // F1
ObjectCreators.GetIndividual(new double[] { 1, 3 }), // F2
ObjectCreators.GetIndividual(new double[] { 1, 2 }), // F1
ObjectCreators.GetIndividual(new double[] { 2, 2 }), // F2
ObjectCreators.GetIndividual(new double[] { 2, 1 }), // F1
ObjectCreators.GetIndividual(new double[] { 3, 2 }), // F3
ObjectCreators.GetIndividual(new double[] { 3, 1 }), // F2
ObjectCreators.GetIndividual(new double[] { 3, 0 }), // F1
ObjectCreators.GetIndividual(new double[] { 4, 1 }) // F3
};
minimise = new[] { true, true };
foreach (var ind in individuals)
{
ind.SendForEvaluation();
ind.SetProperty(solution1Name, ind.DecisionVector[0]);
ind.SetProperty(solution2Name, ind.DecisionVector[1]);
ind.SetSolution(solution1Name, solution2Name);
}
}
public IndividualTests()
{
testVector = new double[] { 0, 2 };
var dv = ObjectCreators.GetDecisionVector(testVector);
ind = new Individual(dv);
}
public IndividualMetricsTests()
{
// Set up multi-objective population
moTestInd = ObjectCreators.GetIndividual(new double[] { 0, 2 });
moTestInd.SendForEvaluation();
var solution1 = 0.2;
var solution1Name = ObjectCreators.Solution_Key;
var solution2 = 5.1;
var solution2Name = ObjectCreators.Solution_Key + "2";
var solution3 = 55.0;
var solution3Name = ObjectCreators.Solution_Key + "3";
moTestInd.SetProperty(solution1Name, solution1);
moTestInd.SetProperty(solution2Name, solution2);
moTestInd.SetProperty(solution3Name, solution3);
indEqual = moTestInd.Clone();
indParetoDominant = moTestInd.Clone();
indParetoEqual1 = moTestInd.Clone();
indWrong = moTestInd.Clone();
indParetoDominant.SetProperty(solution1Name, solution1 - 0.1);
indParetoEqual1.SetProperty(solution1Name, solution1 - 0.1);
indParetoEqual1.SetProperty(solution2Name, solution2 + 0.1);
minimise = new[] { true, true, true };
moTestInd.SetSolution(solution1Name, solution2Name, solution3Name);
indEqual.SetSolution(solution1Name, solution2Name, solution3Name);
indParetoDominant.SetSolution(solution1Name, solution2Name, solution3Name);
indParetoEqual1.SetSolution(solution1Name, solution2Name, solution3Name);
indWrong.SetSolution(solution1Name, solution2Name);
}
public void ConstantLengthDvPop_AddIndividualWithDifferentLengthDv_Fails()
{
var numDims = ind.DecisionVector.Count;
var ind1 = ObjectCreators.GetIndividual(Enumerable.Range(0, numDims + 1).ToArray());
Assert.Throws <ArgumentException>(
() => popConstLenDvInitInd.AddIndividual(ind1));
}
public void Reinsertion_EvaluatingIndividual_NotAllowed()
{
var newInd = ObjectCreators.GetIndividual(builder.StartingDecVec);
newInd.SendForEvaluation();
Assert.Throws <InvalidOperationException>(() => optimiserMock.ReInsert(new[] { newInd }));
}
public void NewIndividuals_HaveSameDecisionVector_AreEqual()
{
var vector2 = testVector.ToArray();
var dv2 = ObjectCreators.GetDecisionVector(vector2);
var ind2 = new Individual(dv2);
Assert.Equal(ind2, ind);
}
public ModelTests()
{
builder = new ObjectCreators.OptimiserBuilderMock();
modelMock = new ObjectCreators.ModelMock(
ObjectCreators.GetDecisionVector(builder.StartingDecVec),
builder.GetConverterMock());
}
public void TwoEqualVectors_WithDifferentSpace_AreNotEqual()
{
var space2 = ObjectCreators.GetDecisionSpace(Dims, MinValueContinuous - 1, MaxValueContinuous + 1);
var dv1 = DecisionVector.CreateFromArray(continuousSpace, exampleContinuousVector);
var dv2 = DecisionVector.CreateFromArray(space2, exampleContinuousVector);
Assert.False(dv1.Equals(dv2));
}
public void NewIndividuals_HaveDifferentDecisionSpace_AreNotEqual()
{
var vector2 = testVector.Select(i => (int)i).ToArray();
var dv2 = ObjectCreators.GetDecisionVector(vector2);
var ind2 = new Individual(dv2);
Assert.NotEqual(ind2, ind);
}
public void Reinsertion_FitnessAssessedIndividual_NotAllowed()
{
// TODO: Is this the desired behaviour?
var newInd = ObjectCreators.GetIndividual(builder.StartingDecVec);
ObjectCreators.EvaluateIndividualAndSetFitness(newInd);
Assert.Throws <InvalidOperationException>(() => optimiserMock.ReInsert(new[] { newInd }));
}
public void Reinsertion_FailedIndividual_RethrowsError()
{
var newInd = ObjectCreators.GetIndividual(builder.StartingDecVec);
ObjectCreators.EvaluateIndividualHasError(newInd,
new ArgumentOutOfRangeException("Test failure."));
Assert.Throws <InvalidOperationException>(() => optimiserMock.ReInsert(new[] { newInd }));
}
public void DifferenceOfTwoDifferentVectors_WithDifferentSpace_Fails()
{
var dv1 = DecisionVector.CreateFromArray(continuousSpace, exampleContinuousVector);
var dv2 = DecisionVector.CreateFromArray(
ObjectCreators.GetDecisionSpace(4, MinValueContinuous - 1, MaxValueContinuous + 1),
exampleContinuousVector);
Assert.Throws <ArgumentException>(
() => dv1 - dv2);
}
public void ErrorIsStoredAndNotThrown()
{
var ind = ObjectCreators.GetIndividual(new[] { 1.2 });
ind.SetProperty(ObjectCreators.Definition_Key, Test_Solution);
ind.SendForEvaluation();
evaluatorWithErrorMock.Evaluate(ind);
Assert.Contains(OptimiserPropertyNames.EvaluationError, ind.GetPropertyNames());
}
public void IndividualIsEvaluated()
{
var newInd = ObjectCreators.GetIndividual(new[] { 1.7 });
newInd.SetProperty(ObjectCreators.Definition_Key, Test_Solution);
newInd.SendForEvaluation();
agent.IndividualsForEvaluation.Post(newInd);
agent.EvaluatedIndividuals.Receive(); // Won't happen without this line.
Assert.Equal(Test_Solution, newInd.SolutionVector.ElementAt(0));
}
public void VariableLengthDvPop_AddIndividualWithDifferentLengthDv_Succeeds()
{
var numDims = ind.DecisionVector.Count;
var ind1 = ObjectCreators.GetIndividual(Enumerable.Range(0, numDims + 1).ToArray());
ObjectCreators.EvaluateIndividualAndSetFitness(ind1);
popVarLenDv.AddIndividual(ind1);
Assert.True(popVarLenDv.Count == 2);
Assert.Equal(popVarLenDv[1], ind1);
}
public void Reinsertion_IllegalIndividual_Allowed()
{
var newInd = ObjectCreators.GetIndividual(builder.StartingDecVec);
ObjectCreators.EvaluateIndividualAsIllegal(newInd);
optimiserMock.ReInsert(new[] { newInd });
Assert.Equal(
ObjectCreators.OptimiserBuilderMock.PenaltyValue,
newInd.Fitness);
}
public void ConstantLengthDvPop_AddBetterIndividual_SortsCorrectly()
{
var ind1 = ObjectCreators.GetIndividual(
ind.DecisionVector.Select(i => (double)i + 1).ToArray());
ObjectCreators.EvaluateIndividualAndSetFitness(ind1, ind.Fitness - 1);
popConstLenDvInitInd.AddIndividual(ind1);
Assert.Equal(ind1, popConstLenDvInitInd.Best());
Assert.Equal(ind, popConstLenDvInitInd.Worst());
}
public void Centroid_DifferentLengthDecisionVectors_Throws()
{
var newInd = ObjectCreators.GetIndividual(Enumerable.Repeat <double>(1.2, bestDv.Length + 1));
ObjectCreators.EvaluateIndividualAndSetFitness(newInd, BestFitness + FitnessDifference);
var pop2 = ObjectCreators.GetEmptyPopulation(5, false);
pop2.AddIndividual(singleObjectivePopulation.Best());
pop2.AddIndividual(newInd);
Assert.Throws <InvalidOperationException>(() => pop2.Centroid());
}
public void ConstantLengthDvPop_GetDecisionVectors_ReturnsSortedList()
{
var ind1 = ObjectCreators.GetIndividual(
ind.DecisionVector.Select(i => (double)i + 1).ToArray());
ObjectCreators.EvaluateIndividualAndSetFitness(ind1, ind.Fitness - 1);
popConstLenDvInitInd.AddIndividual(ind1);
var decisionVectors = popConstLenDvInitInd.GetMemberDecisionVectors();
Assert.True(decisionVectors.Count() == 2);
Assert.Equal(ind1.DecisionVector, decisionVectors.ElementAt(0));
}
public void ErrorIsStoredAndNotThrown()
{
var errorAgent = new EvaluationAgent(new ObjectCreators.EvaluatorWithErrorMock(), CancellationToken.None);
var newInd = ObjectCreators.GetIndividual(new[] { 1.7 });
newInd.SetProperty(ObjectCreators.Definition_Key, Test_Solution);
newInd.SendForEvaluation();
errorAgent.IndividualsForEvaluation.Post(newInd);
errorAgent.EvaluatedIndividuals.Receive(); // Won't happen without this line.
Assert.Contains(OptimiserPropertyNames.EvaluationError, newInd.GetPropertyNames());
}
public void EvaluatesCorrectly()
{
var ind = ObjectCreators.GetIndividual(new[] { 1.2 });
ind.SetProperty(ObjectCreators.Definition_Key, Test_Solution);
ind.SendForEvaluation();
evaluatorMock.Evaluate(ind);
Assert.Equal(Test_Solution,
ind.GetProperty <double>(ObjectCreators.Solution_Key));
Assert.Equal(IndividualState.Evaluated, ind.State);
Assert.True(ind.Legal);
Assert.Equal(new[] { Test_Solution }, ind.SolutionVector);
}
public void TwoIndividuals_HaveSameSolutionVector_AreEqual()
{
var vector2 = testVector.ToArray();
var dv2 = ObjectCreators.GetDecisionVector(vector2);
var ind2 = new Individual(dv2);
ind.SendForEvaluation();
ind.SetProperty(ObjectCreators.Solution_Key, 2.6);
ind.SetSolution(ObjectCreators.Solution_Key);
ind2.SendForEvaluation();
ind2.SetProperty(ObjectCreators.Solution_Key, 2.6);
ind2.SetSolution(ObjectCreators.Solution_Key);
Assert.Equal(ind2, ind);
}
public PopulationExtensionsTests()
{
// Set up single-objective population for Convergence and Centroid tests
bestDv = new[] { 0.1, 0.5, 1.2 };
worstDv = new[] { 0.1, bestDv[1] + DvDifference, 1.2 };
var ind1 = ObjectCreators.GetIndividual(worstDv);
var ind2 = ObjectCreators.GetIndividual(bestDv);
ObjectCreators.EvaluateIndividualAndSetFitness(ind1, BestFitness + FitnessDifference);
ObjectCreators.EvaluateIndividualAndSetFitness(ind2, BestFitness);
singleObjectivePopulation = ObjectCreators.GetEmptyPopulation(140, true);
singleObjectivePopulation.AddIndividual(ind1);
singleObjectivePopulation.AddIndividual(ind2);
}
public ReinsertionAgentTests()
{
var builder = new ObjectCreators.OptimiserBuilderMock();
agent = new ReinsertionAgent(
builder.CreateOptimiser(),
new ObjectCreators.ModelMock(
ObjectCreators.GetDecisionVector(builder.StartingDecVec),
builder.GetConverterMock()),
new TimeOutManager(5, TimeSpan.MaxValue),
p => p.AbsoluteDecisionVectorConvergence(1),
1, NumberOfNewIndividuals)
{
SaveAll = true
};
}
public PopulationTests()
{
popConstLenDv = new Population(
140, null, true);
var testVector = new[] { 0.5, 1.5 };
unevaluatedInd = ObjectCreators.GetIndividual(testVector);
ind = ObjectCreators.GetIndividual(testVector);
ObjectCreators.EvaluateIndividualAndSetFitness(ind);
popConstLenDvInitInd = new Population(
140, new[] { ind }, true);
popVarLenDv = new Population(
140, new[] { ind }, false);
}
public void Reinsertion_EvaluatedIndividual_AddedToPopulation()
{
var newInd = ObjectCreators.GetIndividual(builder.StartingDecVec);
ObjectCreators.EvaluateIndividual(newInd);
Assert.Empty(optimiserMock.Population);
optimiserMock.ReInsert(new[] { newInd });
Assert.Collection(optimiserMock.Population,
i => Assert.Equal(
builder.StartingDecVec, i.DecisionVector.Select(d => (double)d)));
var reinsertionTime = newInd.GetProperty <DateTime>(OptimiserPropertyNames.ReinsertionTime);
Assert.True(reinsertionTime < DateTime.Now);
}
public void ConstantLengthDvPop_ReplaceIndividualWithIndex_PerformsCorrectly()
{
var bestInd = ObjectCreators.GetIndividual(
ind.DecisionVector.Select(i => (double)i + 1).ToArray());
ObjectCreators.EvaluateIndividualAndSetFitness(bestInd, ind.Fitness - 1);
popConstLenDvInitInd.AddIndividual(bestInd);
var evenBetterInd = ObjectCreators.GetIndividual(
ind.DecisionVector.Select(i => (double)i + 1).ToArray());
ObjectCreators.EvaluateIndividualAndSetFitness(evenBetterInd, ind.Fitness - 2);
popConstLenDvInitInd.ReplaceIndividualAt(1, evenBetterInd);
Assert.Equal(evenBetterInd, popConstLenDvInitInd.Best());
Assert.True(popConstLenDvInitInd.Count == 2);
}
public void GetParetoFront_OneDimension_ReturnsBest()
{
var bestInd = ObjectCreators.GetIndividual(
ind.DecisionVector.Select(i => (double)i + 1).ToArray());
ObjectCreators.EvaluateIndividualAndSetFitness(bestInd, ind.Fitness - 1);
popConstLenDvInitInd.AddIndividual(bestInd);
var evenBetterInd = ObjectCreators.GetIndividual(
ind.DecisionVector.Select(i => (double)i + 1).ToArray());
ObjectCreators.EvaluateIndividualAndSetFitness(evenBetterInd, ind.Fitness - 2);
popConstLenDvInitInd.AddIndividual(evenBetterInd);
// TODO!
//Assert.True(popConstLenDvInitInd.ParetoFront().Count() == 1);
//Assert.Equal(popConstLenDvInitInd.Best(), popConstLenDvInitInd.ParetoFront().First());
}
public ParetoFrontMetricsTests()
{
// Set up multi-objective population
moTestInd = ObjectCreators.GetIndividual(new double[] { 0, 2 });
moTestInd.SendForEvaluation();
var solution1Name = ObjectCreators.Solution_Key;
var solution2Name = ObjectCreators.Solution_Key + "2";
var solution3Name = ObjectCreators.Solution_Key + "3";
moTestInd.SetProperty(solution1Name, WorstSolution1 - 0.01); // 3
moTestInd.SetProperty(solution2Name, WorstSolution2 - 0.18); // 2
moTestInd.SetProperty(solution3Name, WorstSolution3 - 0.1); // 1
indParetoEqual1 = moTestInd.Clone();
indParetoEqual2 = moTestInd.Clone();
indParetoEqual3 = moTestInd.Clone();
indParetoEqual1.SetProperty(solution1Name, WorstSolution1 - 0.1); // 1
indParetoEqual1.SetProperty(solution2Name, WorstSolution2); // 4
indParetoEqual1.SetProperty(solution3Name, WorstSolution3 - 0.09); // 2
indParetoEqual2.SetProperty(solution1Name, WorstSolution1 - 0.09); // 2
indParetoEqual2.SetProperty(solution2Name, WorstSolution2 - 0.02); // 3
indParetoEqual2.SetProperty(solution3Name, WorstSolution3 - 0.01); // 3
indParetoEqual3.SetProperty(solution1Name, WorstSolution1); // 4
indParetoEqual3.SetProperty(solution2Name, WorstSolution2 - 0.2); // 1
indParetoEqual3.SetProperty(solution3Name, WorstSolution3); // 4
minimise = new[] { true, true, true };
moTestInd.SetSolution(solution1Name, solution2Name, solution3Name);
indParetoEqual1.SetSolution(solution1Name, solution2Name, solution3Name);
indParetoEqual2.SetSolution(solution1Name, solution2Name, solution3Name);
indParetoEqual3.SetSolution(solution1Name, solution2Name, solution3Name);
}
