/// <summary>
/// Set DE operator variants to be used, and determine the number
/// of behavioural parameters associated with that variant.
/// </summary>
/// <param name="crossover">Crossover variant to be used.</param>
/// <param name="dither">Dither variant to be used.</param>
void SetVariant(DECrossover.Variant crossover, DitherVariant dither)
{
_dither = dither;
_crossover = crossover;
if (_dither == DitherVariant.None)
{
_dimensionality = 3;
}
else
{
_dimensionality = 4;
}
}
/// <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)
: base(problem)
{
// Set DE operator variants to be used.
SetVariant(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 JDE method.
int numAgents = GetNumAgents(parameters);
double FInit = GetFInit(parameters);
double Fl = GetFl(parameters);
double Fu = GetFu(parameters);
double tauF = GetTauF(parameters);
double CRInit = GetCRInit(parameters);
double CRl = GetCRl(parameters);
double CRu = GetCRu(parameters);
double tauCR = GetTauCR(parameters);
// Adjust CR parameters to remain within [0,1]
if (CRl + CRu > 1)
{
CRu = 1 - CRl;
}
// Get problem-context.
double[] lowerInit = Problem.LowerInit;
double[] upperInit = Problem.UpperInit;
int n = Problem.Dimensionality;
// Allocate agent positions and associated fitnesses.
double[][] agents = Tools.NewMatrix(numAgents, n);
double[] fitness = new double[numAgents];
bool[] feasible = new bool[numAgents];
double[] y = new double[n];
double[] w = new double[n];
double[] F = new double[numAgents];
double[] CR = new double[numAgents];
// Initialize 'self-adaptive' parameters.
Tools.Initialize(ref F, FInit);
Tools.Initialize(ref CR, CRInit);
// 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.
// This counts as iterations below.
for (j = 0; j < numAgents && Problem.Continue(j, gFitness, gFeasible); j++)
{
// Refer to the j'th agent as x.
double[] x = agents[j];
// Initialize agent-position in search-space.
Tools.InitializeUniform(ref x, lowerInit, upperInit);
// Enforce constraints and evaluate feasibility.
feasible[j] = Problem.EnforceConstraints(ref x);
// Compute fitness of initial position.
fitness[j] = Problem.Fitness(x, feasible[j]);
// Update population's best known position if it either does not exist or,
// if feasibility is same or better and fitness is an improvement.
if (Tools.BetterFeasibleFitness(gFeasible, feasible[j], gFitness, fitness[j]))
{
g = agents[j];
gFitness = fitness[j];
gFeasible = feasible[j];
}
// Trace fitness of best found solution.
Trace(j, gFitness, gFeasible);
}
for (i = numAgents; Problem.Continue(i, gFitness, gFeasible);)
{
Debug.Assert(numAgents > 0);
for (j = 0; j < numAgents && Problem.Continue(i, gFitness, gFeasible); j++, i++)
{
// Reset the random-set used for picking distinct agents.
// Exclude the j'th agent (also referred to as x).
randomSet.ResetExclude(j);
// Refer to the j'th agent as x.
double[] x = agents[j];
// JDE 'Self-adaptive' parameters.
double newF = (Globals.Random.Bool(tauF)) ? (Globals.Random.Uniform(Fl, Fl + Fu)) : (F[j]);
double newCR = (Globals.Random.Bool(tauCR)) ? (Globals.Random.Uniform(CRl, CRl + CRu)) : (CR[j]);
// Initialize crossover-weight vector.
Tools.Initialize(ref w, newF);
// Perform crossover.
DECrossover.DoCrossover(_crossover, newCR, n, w, x, ref y, g, agents, randomSet);
// Enforce constraints and evaluate feasibility.
bool newFeasible = Problem.EnforceConstraints(ref y);
// Compute fitness if feasibility (constraint satisfaction) is same or better.
if (Tools.BetterFeasible(feasible[j], newFeasible))
{
// Compute new fitness.
double newFitness = Problem.Fitness(y, fitness[j], feasible[j], newFeasible);
// Update agent in case of fitness improvement.
if (Tools.BetterFeasibleFitness(feasible[j], newFeasible, fitness[j], newFitness))
{
// Update agent's position.
y.CopyTo(agents[j], 0);
// Update agent's fitness.
fitness[j] = newFitness;
// Update agent's feasibility.
feasible[j] = newFeasible;
// Update population's best known position,
// if feasibility is same or better and fitness is an improvement.
if (Tools.BetterFeasibleFitness(gFeasible, newFeasible, gFitness, newFitness))
{
g = agents[j];
gFitness = newFitness;
gFeasible = newFeasible;
}
// JDE 'Self-adaptive' parameters.
// Keep the new parameters because they led to fitness improvement.
F[j] = newF;
CR[j] = newCR;
}
}
// 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));
}
/// <summary>
/// Construct the object.
/// </summary>
/// <param name="problem">Problem to optimize.</param>
/// <param name="crossover">Crossover variant.</param>
public JDE(Problem problem, DECrossover.Variant crossover)
: base(problem)
{
SetVariant(crossover);
}
/// <summary>
/// Construct the object.
/// </summary>
/// <param name="crossover">Crossover variant.</param>
public JDE(DECrossover.Variant crossover)
: base()
{
SetVariant(crossover);
}
/// <summary>
/// Set the optimizer variant to be used.
/// </summary>
/// <param name="crossover">Crossover variant.</param>
void SetVariant(DECrossover.Variant crossover)
{
_crossover = crossover;
}
/// <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);
// Get problem-context.
double[] lowerInit = Problem.LowerInit;
double[] upperInit = Problem.UpperInit;
int n = Problem.Dimensionality;
// Allocate agent positions and associated fitnesses and feasibility.
double[][] agents = Tools.NewMatrix(numAgents, n);
double[] fitness = new double[numAgents];
bool[] feasible = new bool[numAgents];
double[] y = new double[n];
// 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.
// This counts as iterations below.
for (j = 0; j < numAgents && Problem.Continue(j, gFitness, gFeasible); j++)
{
// Refer to the j'th agent as x.
double[] x = agents[j];
// Initialize agent-position in search-space.
Tools.InitializeUniform(ref x, lowerInit, upperInit);
// Enforce constraints and evaluate feasibility.
feasible[j] = Problem.EnforceConstraints(ref x);
// Compute fitness of initial position.
fitness[j] = Problem.Fitness(x, feasible[j]);
// Update population's best known position if it either does not exist or,
// if feasibility is same or better and fitness is an improvement.
if (Tools.BetterFeasibleFitness(gFeasible, feasible[j], gFitness, fitness[j]))
{
g = agents[j];
gFitness = fitness[j];
gFeasible = feasible[j];
}
// Trace fitness of best found solution.
Trace(j, gFitness, gFeasible);
}
for (i = numAgents; Problem.Continue(i, gFitness, gFeasible);)
{
Debug.Assert(numAgents > 0);
// 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));
}
for (j = 0; j < numAgents && Problem.Continue(i, gFitness, gFeasible); j++, i++)
{
// 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);
// Refer to the j'th agent as x.
double[] x = agents[j];
// Perform crossover.
DECrossover.DoCrossover(_crossover, CR, n, w, x, ref y, g, agents, randomSet);
// Enforce constraints and evaluate feasibility.
bool newFeasible = Problem.EnforceConstraints(ref y);
// Compute fitness if feasibility (constraint satisfaction) is same or better.
if (Tools.BetterFeasible(feasible[j], newFeasible))
{
// Compute new fitness.
double newFitness = Problem.Fitness(y, fitness[j], feasible[j], newFeasible);
// Update agent in case of fitness improvement.
if (Tools.BetterFeasibleFitness(feasible[j], newFeasible, fitness[j], newFitness))
{
// Update agent's position.
y.CopyTo(agents[j], 0);
// Update agent's fitness.
fitness[j] = newFitness;
// Update agent's feasibility.
feasible[j] = newFeasible;
// Update population's best known position,
// if feasibility is same or better and fitness is an improvement.
if (Tools.BetterFeasibleFitness(gFeasible, newFeasible, gFitness, newFitness))
{
g = agents[j];
gFitness = newFitness;
gFeasible = newFeasible;
}
}
}
// 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));
}
