public List <double> ILVector(OptimizationSolution[] samples, OptimizationSolution best)
{
var length = (samples.Length - 1) * (samples.Length - 2) / 2;
List <double> result = new List <double>(length);
for (int i = 0; i < samples.Length; i++)
{
if (samples[i].Position.Equals(best.Position))
{
continue; //skip the best parameter set
}
for (int j = i + 1; j < samples.Length; j++) //only consider solutions in upper half (due to symmetry)
{
if (samples[j].Position.Equals(best.Position))
{
continue; //skip the best parameter set
}
if (samples[i].Fitness.CompareTo(samples[j].Fitness) > 0)
{
result.Add(1);
}
else if (samples[i].Fitness.CompareTo(samples[j].Fitness) < 0)
{
result.Add(0);
}
else
{
result.Add(0.5);
}
}
}
return(result);
}
public double SphericalReference(OptimizationSolution solution, OptimizationSolution best)
{
double sum = 0;
for (int i = 0; i < solution.Position.Length; i++)
{
double d = solution.Position[i] - best.Position[i];
sum += d * d;
}
return(sum);
}
public double Calculate(IEnumerable <OptimizationSolution> solutions, IObjective objective)
{
OptimizationSolution[] samples = solutions.ToArray();
OptimizationSolution best = Helpers.GetBest(samples);
OptimizationSolution[] reference = solutions.Select(x => new OptimizationSolution(x.Position, objective.Evaluate(SphericalReference(x, best)))).ToArray();
List <double> ilVec = ILVector(samples, best); //information landscape of problem
List <double> ilVecRef = ILVector(reference, best); //information landscape of reference
return(AbsoluteDistance(ilVec, ilVecRef));
}
public (double avg, double dev) Calculate(IEnumerable <OptimizationSolution> solutions, double stepSize, Domain problemDomain)
{
OptimizationSolution[] solutionArray = solutions.ToArray();
double[] gradients = new double[solutionArray.Length - 1];
double fMin = double.PositiveInfinity;
double fMax = double.NegativeInfinity;
for (int i = 1; i < solutionArray.Length; i++)
{
fMin = Math.Min(fMin, solutionArray[i].Fitness.Value);
fMax = Math.Max(fMax, solutionArray[i].Fitness.Value);
}
double fRange = fMax - fMin;
double domSum = 0;
for (int i = 0; i < problemDomain.Dimension; i++)
{
domSum += problemDomain[i].Range;
}
double gradSum = 0;
//calculate gradients
double distTerm = stepSize / domSum;
for (int i = 1; i < solutionArray.Length; i++)
{
OptimizationSolution a = solutionArray[i - 1];
OptimizationSolution b = solutionArray[i];
double fitTerm = (b.Fitness.Value - a.Fitness.Value) / fRange;
gradients[i - 1] = fitTerm / distTerm;
gradSum += Math.Abs(gradients[i - 1]);
}
double avg = gradSum / solutionArray.Length;
double devSum = 0;
for (int i = 0; i < gradients.Length; i++)
{
devSum += Math.Pow(avg - Math.Abs(gradients[i]), 2);
}
double dev = Math.Sqrt(devSum / (solutionArray.Length - 2));
return(avg, dev);
}
public double Calculate(IEnumerable <OptimizationSolution> solutions)
{
OptimizationSolution[] samples = solutions.ToArray();
int numSamples = samples.Length;
OptimizationSolution best = Helpers.GetBest(samples);
List <double> fitnesses = new List <double>(numSamples);
List <double> distances = new List <double>(numSamples);
double fitnessSum = 0;
double distanceSum = 0;
foreach (var sample in samples)
{
fitnessSum += sample.Fitness.Value;
fitnesses.Add(sample.Fitness.Value);
double distance = distanceMeasure.Measure(sample.Position, best.Position);
distanceSum += distance;
distances.Add(distance);
}
double avgFitness = fitnessSum / numSamples;
double avgDistance = distanceSum / numSamples;
double numerator = 0;
double lDenominator = 0;
double rDenominator = 0;
//calculate the sums used in the final calculation
for (int i = 0; i < numSamples; i++)
{
double fitnessDiff = fitnesses[i] - avgFitness;
double distanceDiff = distances[i] - avgDistance;
numerator += fitnessDiff * distanceDiff;
lDenominator += fitnessDiff * fitnessDiff;
rDenominator += distanceDiff * distanceDiff;
}
return(numerator / (Math.Sqrt(lDenominator) * Math.Sqrt(rDenominator)));
}
