// ===========================================================
static Result PSO(Parameters parameters, IProblem pb, int level)
{
int added; // For information
Fitness error = new Fitness(Constants.fMax);
Fitness errorInit = new Fitness(Constants.fMax); // Just for information
Fitness errorPrev = new Fitness(Constants.fMax);
double errorTot;
int g;
int sBest; // Rank in g of the best of the bests
int improvTot; // Number of particles that have improved their previous best
int[] index = new int[Constants.SMax];
int initLinks; // Flag to (re)init or not the information links
int initLinkNb;
int iterBegin;
int[,] LINKS = new int[Constants.SMax, Constants.SMax]; // Information links
int m;
int moved;
int n;
int noStop;
Result R = new Result();
int removed; // For information
int s0 = 0;
int s, s1, s2;
int spread;
int stagnation = 0;
int swarmMod;
int sWorst;
XV xvNorm = new XV();
// -----------------------------------------------------
// INITIALISATION
R.SW.S = parameters.S; // Initial size of the swarm
memPos.Rank = 0; // Rank (in M) where to memorise a new position
memPos.Size = 0; // Number of memorised positions
// Positions
for (s = 0; s < R.SW.S; s++)
{
R.SW.X[s] = Position.Initialize(pb.SwarmSize);
memPos.memSave(R.SW.X[s]); // Save the position
}
// Velocities
for (s = 0; s < R.SW.S; s++)
{
R.SW.V[s] = Velocity.Initialize(R.SW.X[s], pb.SwarmSize);
}
// Discrete values
// Note: may be removed if you are sure that the initialisation
// takes discretisation into account (or if there is none)
for (s = 0; s < R.SW.S; s++)
{
R.SW.X[s] = Position.Discrete(R.SW.X[s], pb);
}
// Note: at this point no confinement is needed:
// initialisation is supposed to be OK from this point of view
// (but some constraints may be not respected)
// First evaluations
for (s = 0; s < R.SW.S; s++)
{
R.SW.X[s].f = pb.Evaluate(R.SW.X[s]);
R.SW.P[s] = R.SW.X[s]; // Best position = current one
}
// Save the positions
for (s = 0; s < R.SW.S; s++) memPos.memSave(R.SW.X[s]);
// Find the best
R.SW.best = best(R.SW);
error = R.SW.P[R.SW.best].f;
// Display the best
Console.WriteLine("Best value after init. {0} ", R.SW.P[R.SW.best].f.f[0]);
if (pb.Constraint > 0)
{
Console.WriteLine("Constraints (should be < 0) ");
for (n = 0; n < pb.Constraint; n++) Console.WriteLine("{0} ", error.f[n + 1]);
}
//fprintf(f_run,"\n Best value after init. %f ", errorPrev );
//printf( "\n Position :\n" );
//for ( d = 0; d < pb.SwarmSize.D; d++ ) printf( " %f", R.SW.P[R.SW.best].x[d] );
initLinks = 1; // So that information links will beinitialized
initLinkNb = 0; // Count the number of iterations between two reinit of the links
iter = 0;
nEval = 0;
noStop = 0;
added = 0; removed = 0; // For information
spread = spreadIter(parameters.spreadProba, R.SW.S, parameters.formula); // Number of iterations
// needed to "spread" the information
errorInit = error; // For information
// ---------------------------------------------- ITERATIONS
while (noStop == 0)
{
//printf("\niter %i",iter);
//fprintf(f_run,"\niter %i",iter);
iter = iter + 1;
errorPrev = error;
Alea.Shuffle(index, R.SW.S); // Random numbering of the particles
if (initLinks == 1) // Bidirectional ring topology. Randomly built
{
initLinks = 0;
initLinkNb = 0; // Count the number of iterations since the last re-init
// of the links
// Init to zero (no link)
for (s = 0; s < R.SW.S; s++)
{
for (m = 0; m < R.SW.S; m++) LINKS[m, s] = 0;
}
// Information links (bidirectional ring)
for (s = 0; s < R.SW.S - 1; s++)
{
LINKS[index[s], index[s + 1]] = 1;
LINKS[index[s + 1], index[s]] = 1;
}
LINKS[index[0], index[R.SW.S - 1]] = 1;
LINKS[index[R.SW.S - 1], index[0]] = 1;
// Each particle informs itself
for (m = 0; m < R.SW.S; m++) LINKS[m, m] = 1;
}
// Loop on particles, for move
improvTot = 0;
for (s0 = 0; s0 < R.SW.S; s0++)
{
s = index[s0];
// Find the best informant
g = s;
for (m = 0; m < R.SW.S; m++)
{
if (m == s) continue;
if (LINKS[m, s] == 1 && betterThan(R.SW.P[m].f, R.SW.P[g].f) == 1)
g = m;
}
// Move
xvNorm = move(R, s, g, pb, parameters);
xvNorm.x = Position.Discrete(xvNorm.x, pb);
// Confinement and evaluation
xvNorm.Confinement(pb);
// New position and new velocity
R.SW.X[s] = xvNorm.x;
R.SW.V[s] = xvNorm.v;
// Update the best previous position
if (betterThan(R.SW.X[s].f, R.SW.P[s].f) == 1) // Improvement of the previous best
{
R.SW.P[s] = R.SW.X[s].Clone();
improvTot++; // Increase the number of improvements during this iteration
// Memorise the improved position
memPos.memSave(R.SW.P[s]);
// Update the best of the bests
if (betterThan(R.SW.P[s].f, R.SW.P[R.SW.best].f) == 1) R.SW.best = s;
}
// Decide to stop or not
errorTot = R.SW.P[R.SW.best].f.errorFC();
if (errorTot > pb.Epsilon && nEval < pb.EvaluationMaximum)
noStop = 0; // Won't stop
else // Failure
{
noStop = 1; // Will stop
goto end;
}
} // End of "for (s0=0 ... " = end of the iteration (move)
/*-------------------------------------------------- Adaptations
Rule 1:
Check every "spread" iterations after each re-init of the links
If no improvement of the global best
=> reinit links before the next iteration
Rule 2:
if no improvement of the global best during "spread" iterations
=> Try to add a particle (and initialise it in a non-searched area)
=> re-init links before the next iteration
Note that the condition is slightly different from the one of Rule 1
Rule 3:
if "enough" local improvements during the iteration
=> try to remove a particle (keep at least D+1 ones)
*/
// Rule 1 - Re-initializing the information links
// Check if improvement since last re-init of the links
initLinkNb = initLinkNb + 1; // Number of iterations since the last check
if (initLinkNb >= spread) // It's time to check
{
initLinkNb = 0; // Reset to zero the number of iterations since the last check
// The swarm size may have been modified, so must be "spread"
spread = spreadIter(parameters.spreadProba, R.SW.S, parameters.formula);
if (betterThan(error, errorPrev) == 1) // Improvement
initLinks = 0; // No need of structural adaptation
else // No improvement
initLinks = 1; // Information links will be reinitialized
}
else initLinks = 0; // To early, no need to check
sWorst = worst(R.SW); // Rank of the worst particle, before any adaptation
// Rule 2 - Adding a particle
// Check global stagnation (improvement of the global best)
if (betterThan(R.SW.P[R.SW.best].f, errorPrev) == 1) stagnation = 0; // Improvement
else stagnation++; // No improvement during this iteration
swarmMod = 0; // Information flag
if (stagnation >= spread) // Too many iterations without global improvement
// => add a particle
{
if (R.SW.S < Constants.SMax) // if not too many particles
{
s = R.SW.S;
R.SW.X[s] = memPos.InitializeFar(pb); // Init in a non-searched area
R.SW.X[s] = Position.Discrete(xvNorm.x, pb); // If discrete search space
R.SW.X[s].f = pb.Evaluate(R.SW.X[s]); // Evaluation
R.SW.V[s] = Velocity.Initialize(R.SW.X[s], pb.SwarmSize); // Init velocity
R.SW.P[s] = R.SW.X[s].Clone(); // Previous best = current position
R.SW.S = R.SW.S + 1; // Increase the swarm size
//fprintf(f_swarm,"%i %i %f\n",iter, R.SW.S,error.f[0]);
// Count the number of added particles (for information)
added++;
initLinks = 1; // Links will be reinitialised
stagnation = 0; // Reset the count for stagnation
swarmMod = 1; // A particle has been added
//printf("\n iter %i, added %i, S %i, spread %i",iter, added, R.SW.S, spread);
}
}
// Rule 3 - Removing a particle
// If enough improvements of some particles, remove the worst
// (but keep at least D+1 particles)
// NOTE: this is "the worst" without taking into account the particle
// that has (possibly) been added
// NOTE: it is perfectly possible to have a particle added
// (because of no improvement of the global best) AND
// a particle removed (because enough _local_ improvements)
if (R.SW.S > pb.SwarmSize.D + 1 && improvTot > 0.5 * R.SW.S)
{
if ((swarmMod == 0 && sWorst < R.SW.S - 1) || swarmMod == 1)
// if the worst is not the last
{
R.SW.P[sWorst] = R.SW.P[R.SW.S - 1]; // ... replace it by the last
R.SW.V[sWorst] = R.SW.V[R.SW.S - 1];
R.SW.X[sWorst] = R.SW.X[R.SW.S - 1];
// Compact the matrix of the links
for (s1 = 0; s1 < R.SW.S; s1++) // For each line, compact the columns
for (s2 = sWorst; s2 < R.SW.S - 1; s2++) LINKS[s1, s2] = LINKS[s1, s2 + 1];
for (s2 = 0; s2 < R.SW.S - 1; s2++) // For each column, compact the lines
for (s1 = sWorst; s1 < R.SW.S - 1; s1++) LINKS[s1, s2] = LINKS[s1 + 1, s2];
}
R.SW.S = R.SW.S - 1; // Decrease the swarm size
if (s < R.SW.best) R.SW.best = R.SW.best - 1; // The rank of the best may
// have been modified
// Count the number of removed particles (for information)
removed++;
swarmMod = -1; // A particle has been remowed
//printf("\n iter %i, removed %i, S %i, spread %i",iter, removed, R.SW.S, spread);
}
// Save on a the result of the iteration on a file
if (swarmMod != 0)
{
//fprintf(f_swarm,"%i %i %f\n",iter, R.SW.S,R.SW.P[R.SW.best].f.f[0]);
}
// End of the iteration
end: ;
} // End of "while (noStop==0)"
// Convergence rate, just for information
R.convRate = (errorInit.f[0] - R.SW.P[R.SW.best].f.f[0]) / errorInit.f[0];
// Information about the evolution of the swarm size
Console.WriteLine("{0} iterations, +{1} -{2} particles", iter, added, removed);
// Final number of evaluations
R.nEval = nEval;
// Final fitness
R.error = R.SW.P[R.SW.best].f;
return R;
}
static XV move(Result R, int s, int g, IProblem pb,
Parameters parameters)
{
double c1, c2;
int d;
Velocity GX = new Velocity(Constants.DMax);
Velocity PX = new Velocity(Constants.DMax);
XV xv = new XV();
double w;
xv.x.size = pb.SwarmSize.D;
xv.v.Size = pb.SwarmSize.D;
PX.Size = pb.SwarmSize.D;
GX.Size = pb.SwarmSize.D;
w = parameters.w;
c1 = parameters.c1;
c2 = parameters.c2;
// Update the velocity (Exploration tendency)
for (d = 0; d < pb.SwarmSize.D; d++)
{
xv.v.V[d] = w * R.SW.V[s].V[d];
}
// --------------------------------------------------------NORMAL PSO STRATEGY
// Prepare Exploitation tendency
for (d = 0; d < pb.SwarmSize.D; d++) // p-x
{
PX.V[d] = R.SW.P[s].x[d] - R.SW.X[s].x[d];
}
if (g != s)
{
for (d = 0; d < pb.SwarmSize.D; d++) // g-x
{
GX.V[d] = R.SW.P[g].x[d] - R.SW.X[s].x[d];
}
}
// Complete the velocity
for (d = 0; d < pb.SwarmSize.D; d++)
{
xv.v.V[d] = xv.v.V[d] + Alea.NextDouble(0, c1) * PX.V[d];
}
if (g != s) // If the best neighbour is not the particle itself
{
for (d = 0; d < pb.SwarmSize.D; d++)
{
xv.v.V[d] = xv.v.V[d] + Alea.NextDouble(0, c2) * GX.V[d];
}
}
// Update the position
for (d = 0; d < pb.SwarmSize.D; d++)
{
xv.x.x[d] = R.SW.X[s].x[d] + xv.v.V[d];
}
// NOTE that the position is not yet evaluated
return xv;
}
