public void FastHypervolumeTestRandomSinglePoint()
{
//Front with a single Point
double[] point = new double[3];
var r = new System.Random();
point[0] = r.NextDouble();
point[1] = r.NextDouble();
point[2] = r.NextDouble();
double[][] front = { point };
double[] referencePoint = new double[3];
//Northeast
referencePoint[0] = 1;
referencePoint[1] = 1;
referencePoint[2] = 1;
double hv = Hypervolume.Calculate(front, referencePoint, new bool[3]);
double hv2 = 1;
foreach (double d in point)
{
hv2 *= Math.Abs(d - 1);
}
Assert.AreEqual(hv2, hv);
}
public void FastHypervolumeTestSinglePoint()
{
double[] point = new double[] { 0.5, 0.5, 0.5 };
double[][] front = { point };
double[] referencePoint = new double[] { 1, 1, 1 };
double hv = Hypervolume.Calculate(front, referencePoint, new bool[3]);
Assert.AreEqual(0.125, hv);
}
private static double Contribution(IList <double[]> front, int idx, bool[] maximization, double[] refPoint)
{
var point = front[idx];
front.RemoveAt(idx);
var contribution = -Hypervolume.Calculate(front.ToArray(), refPoint, maximization);
front.Insert(idx, point);
return(contribution);
}
public void FastHypervolumeTestDiagonalPoint()
{
//Front with three points
double[] point1 = new double[] { 1, 0, 0 };
double[] point2 = new double[] { 0, 1, 0 };
double[] point3 = new double[] { 0.5, 0.5, 0 };
double[][] front = { point1, point2, point3 };
double[] referencePoint = new double[] { 1, 1, 1 };
double hv = Hypervolume.Calculate(front, referencePoint, new bool[3]);
Assert.AreEqual(0.5, hv);
}
public void HypervolumeTestDiagonalPoint()
{
//Front with three points
double[] point1 = new double[2];
point1[0] = 0;
point1[1] = 1;
double[] point2 = new double[2];
point2[0] = 1;
point2[1] = 0;
double[] point3 = new double[2];
point3[0] = 0.5;
point3[1] = 0.5;
double[][] front = { point1, point2, point3 };
double[] referencePoint = new double[2];
bool[] maximization;
//Northeast
maximization = new bool[] { false, false };
referencePoint[0] = 1;
referencePoint[1] = 1;
double ne = Hypervolume.Calculate(front, referencePoint, maximization);
Assert.AreEqual(0.25, ne);
//NorthWest
maximization = new bool[] { true, false };
referencePoint[0] = 0;
referencePoint[1] = 1;
double nw = Hypervolume.Calculate(NonDominatedSelect.SelectNonDominatedVectors(front, maximization, true), referencePoint, maximization);
Assert.AreEqual(1, nw);
//SouthWest
maximization = new bool[] { true, true };
referencePoint[0] = 0;
referencePoint[1] = 0;
double sw = Hypervolume.Calculate(front, referencePoint, maximization);
Assert.AreEqual(0.25, sw);
//SouthEast
maximization = new bool[] { false, true };
referencePoint[0] = 1;
referencePoint[1] = 0;
double se = Hypervolume.Calculate(NonDominatedSelect.SelectNonDominatedVectors(front, maximization, true), referencePoint, maximization);
Assert.AreEqual(1, se);
}
private void Analyze()
{
ResultsScatterPlot = new ParetoFrontScatterPlot(solutions.Select(x => x.Fitness).ToArray(), solutions.Select(x => x.Mean.ToArray()).ToArray(), ResultsScatterPlot.ParetoFront, ResultsScatterPlot.Objectives, ResultsScatterPlot.ProblemSize);
ResultsSolutions = solutions.Select(x => x.Mean.ToArray()).ToMatrix();
var problem = Problem as MultiObjectiveTestFunctionProblem;
if (problem == null)
{
return;
}
var front = NonDominatedSelect.GetDominatingVectors(solutions.Select(x => x.Fitness), problem.ReferencePoint.CloneAsArray(), Problem.Maximization, true).ToArray();
if (front.Length == 0)
{
return;
}
var bounds = problem.Bounds.CloneAsMatrix();
ResultsCrowding = Crowding.Calculate(front, bounds);
ResultsSpacing = Spacing.Calculate(front);
ResultsGenerationalDistance = problem.BestKnownFront != null?GenerationalDistance.Calculate(front, problem.BestKnownFront.ToJaggedArray(), 1) : double.NaN;
ResultsInvertedGenerationalDistance = problem.BestKnownFront != null?InvertedGenerationalDistance.Calculate(front, problem.BestKnownFront.ToJaggedArray(), 1) : double.NaN;
ResultsHypervolume = Hypervolume.Calculate(front, problem.ReferencePoint.CloneAsArray(), Problem.Maximization);
ResultsBestHypervolume = Math.Max(ResultsHypervolume, ResultsBestHypervolume);
ResultsDifferenceBestKnownHypervolume = ResultsBestKnownHypervolume - ResultsBestHypervolume;
ResultsBestHypervolumeDataLine.Values.Add(ResultsBestHypervolume);
ResultsHypervolumeDataLine.Values.Add(ResultsHypervolume);
ResultsCrowdingDataLine.Values.Add(ResultsCrowding);
ResultsGenerationalDistanceDataLine.Values.Add(ResultsGenerationalDistance);
ResultsInvertedGenerationalDistanceDataLine.Values.Add(ResultsInvertedGenerationalDistance);
ResultsSpacingDataLine.Values.Add(ResultsSpacing);
ResultsHypervolumeDifferenceDataLine.Values.Add(ResultsDifferenceBestKnownHypervolume);
Problem.Analyze(
solutions.Select(x => (Optimization.Individual) new SingleEncodingIndividual(Problem.Encoding, new Scope {
Variables = { new Variable(Problem.Encoding.Name, x.Mean) }
})).ToArray(),
solutions.Select(x => x.Fitness).ToArray(),
Results,
random);
}
public void HypervolumeTestReferencePointViolationNE()
{
//Front with a single Point
double[] point = new double[2];
point[0] = 0.5;
point[1] = 0.5;
double[][] front = { point };
double[] referencePoint = new double[2];
bool[] maximization;
//Northeast
maximization = new bool[] { true, true };
referencePoint[0] = 1;
referencePoint[1] = 1;
double ne = Hypervolume.Calculate(front, referencePoint, maximization);
}
public void HypervolumeTestSinglePoint()
{
//Front with a single Point
double[] point = new double[2];
point[0] = 0.5;
point[1] = 0.5;
double[][] front = { point };
double[] referencePoint = new double[2];
bool[] maximization;
//Northeast
maximization = new bool[] { false, false };
referencePoint[0] = 1;
referencePoint[1] = 1;
double ne = Hypervolume.Calculate(front, referencePoint, maximization);
Assert.AreEqual(0.25, ne);
//NorthWest
maximization = new bool[] { true, false };
referencePoint[0] = 0;
referencePoint[1] = 1;
double nw = Hypervolume.Calculate(front, referencePoint, maximization);
Assert.AreEqual(0.25, nw);
//SouthWest
maximization = new bool[] { true, true };
referencePoint[0] = 0;
referencePoint[1] = 0;
double sw = Hypervolume.Calculate(front, referencePoint, maximization);
Assert.AreEqual(0.25, sw);
//SouthEast
maximization = new bool[] { false, true };
referencePoint[0] = 1;
referencePoint[1] = 0;
double se = Hypervolume.Calculate(front, referencePoint, maximization);
Assert.AreEqual(0.25, se);
}
public void HypervolumeTestReferencePointViolationSE()
{
//Front with a single Point
double[] point = new double[2];
point[0] = 0.5;
point[1] = 0.5;
double[][] front = { point };
double[] referencePoint = new double[2];
bool[] maximization;
//SouthEast
maximization = new bool[] { true, false };
referencePoint[0] = 1;
referencePoint[1] = 0;
double se = Hypervolume.Calculate(front, referencePoint, maximization);
Assert.AreEqual(0.25, se);
}
public void HypervolumeTestReferencePointViolationNW()
{
//Front with a single Point
double[] point = new double[2];
point[0] = 0.5;
point[1] = 0.5;
double[][] front = { point };
double[] referencePoint = new double[2];
bool[] maximization;
//NorthWest
maximization = new bool[] { false, true };
referencePoint[0] = 0;
referencePoint[1] = 1;
double nw = Hypervolume.Calculate(front, referencePoint, maximization);
Assert.AreEqual(0.25, nw);
}
private void InitResults()
{
Results.Add(new Result(IterationsResultName, "The number of gererations evaluated", new IntValue(0)));
Results.Add(new Result(EvaluationsResultName, "The number of function evaltions performed", new IntValue(0)));
Results.Add(new Result(HypervolumeResultName, "The hypervolume of the current front considering the Referencepoint defined in the Problem", new DoubleValue(0.0)));
Results.Add(new Result(BestHypervolumeResultName, "The best hypervolume of the current run considering the Referencepoint defined in the Problem", new DoubleValue(0.0)));
Results.Add(new Result(BestKnownHypervolumeResultName, "The best knwon hypervolume considering the Referencepoint defined in the Problem", new DoubleValue(double.NaN)));
Results.Add(new Result(DifferenceToBestKnownHypervolumeResultName, "The difference between the current and the best known hypervolume", new DoubleValue(double.NaN)));
Results.Add(new Result(GenerationalDistanceResultName, "The generational distance to an optimal pareto front defined in the Problem", new DoubleValue(double.NaN)));
Results.Add(new Result(InvertedGenerationalDistanceResultName, "The inverted generational distance to an optimal pareto front defined in the Problem", new DoubleValue(double.NaN)));
Results.Add(new Result(CrowdingResultName, "The average crowding value for the current front (excluding infinities)", new DoubleValue(0.0)));
Results.Add(new Result(SpacingResultName, "The spacing for the current front (excluding infinities)", new DoubleValue(0.0)));
var table = new DataTable("QualityIndicators");
table.Rows.Add(new DataRow(BestHypervolumeResultName));
table.Rows.Add(new DataRow(HypervolumeResultName));
table.Rows.Add(new DataRow(CrowdingResultName));
table.Rows.Add(new DataRow(GenerationalDistanceResultName));
table.Rows.Add(new DataRow(InvertedGenerationalDistanceResultName));
table.Rows.Add(new DataRow(DifferenceToBestKnownHypervolumeResultName));
table.Rows.Add(new DataRow(SpacingResultName));
Results.Add(new Result(TimetableResultName, "Different quality meassures in a timeseries", table));
Results.Add(new Result(CurrentFrontResultName, "The current front", new DoubleMatrix()));
Results.Add(new Result(ScatterPlotResultName, "A scatterplot displaying the evaluated solutions and (if available) the analytically optimal front", new ParetoFrontScatterPlot()));
var problem = Problem as MultiObjectiveTestFunctionProblem;
if (problem == null)
{
return;
}
if (problem.BestKnownFront != null)
{
ResultsBestKnownHypervolume = Hypervolume.Calculate(problem.BestKnownFront.ToJaggedArray(), problem.TestFunction.ReferencePoint(problem.Objectives), Problem.Maximization);
ResultsDifferenceBestKnownHypervolume = ResultsBestKnownHypervolume;
}
ResultsScatterPlot = new ParetoFrontScatterPlot(new double[0][], new double[0][], problem.BestKnownFront.ToJaggedArray(), problem.Objectives, problem.ProblemSize);
}
public void HypervolumeTestRandomSinglePoint()
{
//Front with a single Point
double[] point = new double[2];
var r = new System.Random();
point[0] = r.NextDouble();
point[1] = r.NextDouble();
double[][] front = { point };
double[] referencePoint = new double[2];
bool[] maximization;
//Northeast
maximization = new bool[] { false, false };
referencePoint[0] = 1;
referencePoint[1] = 1;
double ne = Hypervolume.Calculate(front, referencePoint, maximization);
//NorthWest
maximization = new bool[] { true, false };
referencePoint[0] = 0;
referencePoint[1] = 1;
double nw = Hypervolume.Calculate(front, referencePoint, maximization);
//SouthWest
maximization = new bool[] { true, true };
referencePoint[0] = 0;
referencePoint[1] = 0;
double sw = Hypervolume.Calculate(front, referencePoint, maximization);
//SouthEast
maximization = new bool[] { false, true };
referencePoint[0] = 1;
referencePoint[1] = 0;
double se = Hypervolume.Calculate(front, referencePoint, maximization);
Assert.AreEqual(1.0, ne + se + nw + sw, 1e8);
}
