/// <summary>
/// Construct the object.
/// </summary>
/// <param name="numAgentsMultiple">Population size multiple, e.g. 4 ensures populations are sized 4, 8, 12, 16, ...</param>
/// <param name="problem">Problem to optimize.</param>
/// <param name="crossover">Crossover variant to be used.</param>
/// <param name="dither">Dither variant to be used.</param>
public DESuite(int numAgentsMultiple, Problem problem, DECrossover.Variant crossover, DitherVariant dither)
: base(problem, crossover, dither)
{
NumAgentsMultiple = numAgentsMultiple;
}
/// <summary>
/// Construct the object.
/// </summary>
/// <param name="crossover">Crossover variant to be used.</param>
/// <param name="dither">Dither variant to be used.</param>
public DESuite(DECrossover.Variant crossover, DitherVariant dither)
: this(1, crossover, dither)
{
}
/// <summary>
/// Construct the object.
/// </summary>
/// <param name="problem">Problem to optimize.</param>
/// <param name="crossover">Crossover variant to be used.</param>
/// <param name="dither">Dither variant to be used.</param>
public DESuite(Problem problem, DECrossover.Variant crossover, DitherVariant dither)
: this(1, problem, crossover, dither)
{
}
/// <summary>
/// Perform one optimization run and return the best found solution.
/// </summary>
/// <param name="parameters">Control parameters for the optimizer.</param>
public override Result Optimize(double[] parameters)
{
Debug.Assert(parameters != null && parameters.Length == Dimensionality);
// Signal beginning of optimization run.
Problem.BeginOptimizationRun();
// Retrieve parameters specific to DE method.
int numAgents = GetNumAgents(parameters);
double CR = GetCR(parameters);
double F = GetF(parameters);
double FMid = GetFMid(parameters);
double FRange = GetFRange(parameters);
Debug.Assert(numAgents > 0);
// Get problem-context.
double[] lowerBound = Problem.LowerBound;
double[] upperBound = Problem.UpperBound;
double[] lowerInit = Problem.LowerInit;
double[] upperInit = Problem.UpperInit;
int n = Problem.Dimensionality;
// Allocate agent positions and associated fitnesses.
double[][] agentsX = Tools.NewMatrix(numAgents, n);
double[][] agentsY = Tools.NewMatrix(numAgents, n);
double[] fitnessX = new double[numAgents];
double[] fitnessY = new double[numAgents];
bool[] feasibleX = new bool[numAgents];
bool[] feasibleY = new bool[numAgents];
// Allocate differential weight vector.
double[] w = new double[n];
// Initialize differential weight vector, if no dithering is wanted.
if (_dither == DitherVariant.None)
{
// Initialize crossover-weight vector.
// Same value for all elements, vectors, and generations.
Tools.Initialize(ref w, F);
}
// Random set for picking distinct agents.
RandomOps.Set randomSet = new RandomOps.Set(Globals.Random, numAgents);
// Iteration variables.
int i, j;
// Fitness variables.
double[] g = null;
double gFitness = Problem.MaxFitness;
bool gFeasible = false;
// Initialize all agents. (Non-parallel)
for (j = 0; j < numAgents; j++)
{
// Initialize agent-position in search-space.
Tools.InitializeUniform(ref agentsX[j], lowerInit, upperInit);
// Enforce constraints and evaluate feasibility.
feasibleX[j] = Problem.EnforceConstraints(ref agentsX[j]);
}
// This counts as iterations below.
// Compute fitness of initial position.
System.Threading.Tasks.Parallel.For(0, numAgents, Globals.ParallelOptions, (jPar) =>
{
fitnessX[jPar] = Problem.Fitness(agentsX[jPar], feasibleX[jPar]);
});
// Update best found position. (Non-parallel)
for (j = 0; j < numAgents; j++)
{
if (Tools.BetterFeasibleFitness(gFeasible, feasibleX[j], gFitness, fitnessX[j]))
{
g = agentsX[j];
gFitness = fitnessX[j];
gFeasible = feasibleX[j];
}
// Trace fitness of best found solution.
Trace(j, gFitness, gFeasible);
}
for (i = numAgents; Problem.Continue(i, gFitness, gFeasible);)
{
// Perform dithering of differential weight, depending on dither variant wanted.
if (_dither == DitherVariant.Generation)
{
// Initialize differential-weight vector. Generation-based.
Tools.Initialize(ref w, Globals.Random.Uniform(FMid - FRange, FMid + FRange));
}
// Update agent positions. (Non-parallel)
for (j = 0; j < numAgents; j++)
{
// Perform dithering of differential weight, depending on dither variant wanted.
if (_dither == DitherVariant.Vector)
{
// Initialize differential-weight vector. Vector-based.
Tools.Initialize(ref w, Globals.Random.Uniform(FMid - FRange, FMid + FRange));
}
else if (_dither == DitherVariant.Element)
{
// Initialize differential-weight vector. Element-based.
Tools.InitializeUniform(ref w, FMid - FRange, FMid + FRange);
}
// Reset the random-set used for picking distinct agents.
// Exclude the j'th agent (also referred to as x).
randomSet.ResetExclude(j);
// Perform crossover.
DECrossover.DoCrossover(_crossover, CR, n, w, agentsX[j], ref agentsY[j], g, agentsX, randomSet);
}
// Compute new fitness. (Parallel)
System.Threading.Tasks.Parallel.For(0, numAgents, Globals.ParallelOptions, (jPar) =>
{
// Enforce constraints and evaluate feasibility.
feasibleY[jPar] = Problem.EnforceConstraints(ref agentsY[jPar]);
// Compute fitness if feasibility (constraint satisfaction) is same or better.
if (Tools.BetterFeasible(feasibleX[jPar], feasibleY[jPar]))
{
fitnessY[jPar] = Problem.Fitness(agentsY[jPar], fitnessX[jPar], feasibleX[jPar], feasibleY[jPar]);
}
});
// Update agent positions. (Non-parallel)
for (j = 0; j < numAgents; j++, i++)
{
// Update agent in case feasibility is same or better and fitness is improvement.
if (Tools.BetterFeasibleFitness(feasibleX[j], feasibleY[j], fitnessX[j], fitnessY[j]))
{
// Update agent's position.
agentsY[j].CopyTo(agentsX[j], 0);
// Update agent's fitness.
fitnessX[j] = fitnessY[j];
// Update agent's feasibility.
feasibleX[j] = feasibleY[j];
// Update swarm's best known position.
if (Tools.BetterFeasibleFitness(gFeasible, feasibleX[j], gFitness, fitnessX[j]))
{
g = agentsX[j];
gFitness = fitnessX[j];
gFeasible = feasibleX[j];
}
}
// Trace fitness of best found solution.
Trace(i, gFitness, gFeasible);
}
}
// Signal end of optimization run.
Problem.EndOptimizationRun();
// Return best-found solution and fitness.
return(new Result(g, gFitness, gFeasible, i));
}
