/* Function to initialize an individual randomly */
public void Initialize(ProblemDefinition problem, Randomization randomObj)
{
int j;
if (problem.RealVariableCount != 0)
{
for (j = 0; j < problem.RealVariableCount; j++)
{
Xreal[j] = randomObj.RandomDouble(problem.MinRealvar[j], problem.MaxRealvar[j]);
}
}
if (problem.BinaryVariableCount != 0)
{
for (j = 0; j < problem.BinaryVariableCount; j++)
{
for (int k = 0; k < problem.Nbits[j]; k++)
{
if (randomObj.RandomPercent() <= 0.5)
{
Gene[j][k] = 0;
}
else
{
Gene[j][k] = 1;
}
}
}
}
}
/* Routine for binary mutation of an individual */
static void BinaryMutate(Individual ind, ProblemDefinition problemObj, Randomization randomizationObj)
{
int j, k;
double prob;
for (j = 0; j < problemObj.BinaryVariableCount; j++)
{
for (k = 0; k < problemObj.Nbits[j]; k++)
{
prob = randomizationObj.RandomPercent();
if (prob <= problemObj.BinaryMutationProbability)
{
if (ind.Gene[j][k] == 0)
{
ind.Gene[j][k] = 1;
}
else
{
ind.Gene[j][k] = 0;
}
problemObj.BinaryMutationCount += 1;
}
}
}
}
/* Routine for two point binary Crossover */
static void BinaryCrossover(Individual parent1, Individual parent2, Individual child1, Individual child2, ProblemDefinition problemObj, Randomization randomizationObj)
{
int i, j;
double rand;
int temp, site1, site2;
for (i = 0; i < problemObj.BinaryVariableCount; i++)
{
rand = randomizationObj.RandomPercent();
if (rand <= problemObj.BinaryCrossoverProbability)
{
problemObj.BinaryCrossoverCount++;
site1 = randomizationObj.RandomInteger(0, problemObj.Nbits[i] - 1);
site2 = randomizationObj.RandomInteger(0, problemObj.Nbits[i] - 1);
if (site1 > site2)
{
temp = site1;
site1 = site2;
site2 = temp;
}
for (j = 0; j < site1; j++)
{
child1.Gene[i][j] = parent1.Gene[i][j];
child2.Gene[i][j] = parent2.Gene[i][j];
}
for (j = site1; j < site2; j++)
{
child1.Gene[i][j] = parent2.Gene[i][j];
child2.Gene[i][j] = parent1.Gene[i][j];
}
for (j = site2; j < problemObj.Nbits[i]; j++)
{
child1.Gene[i][j] = parent1.Gene[i][j];
child2.Gene[i][j] = parent2.Gene[i][j];
}
}
else
{
for (j = 0; j < problemObj.Nbits[i]; j++)
{
child1.Gene[i][j] = parent1.Gene[i][j];
child2.Gene[i][j] = parent2.Gene[i][j];
}
}
}
}
/* Routine for binary Tournament */
static Individual Tournament(Individual ind1, Individual ind2, ProblemDefinition problemObj, Randomization randomizationObj)
{
var flag = CheckDominance(ind1, ind2, problemObj);
if (flag == 1)
{
return ind1;
}
if (flag == -1)
{
return ind2;
}
if (ind1.CrowdDist > ind2.CrowdDist)
{
return ind1;
}
if (ind2.CrowdDist > ind1.CrowdDist)
{
return ind2;
}
if (randomizationObj.RandomPercent() <= 0.5)
{
return ind1;
}
else
{
return ind2;
}
}
/* Routine for real polynomial mutation of an individual */
static void RealMutate(Individual ind, ProblemDefinition problemObj, Randomization randomizationObj)
{
int j;
double rnd, delta1, delta2, mutPow, deltaq;
double y, yl, yu, val, xy;
for (j = 0; j < problemObj.RealVariableCount; j++)
{
if (randomizationObj.RandomPercent() <= problemObj.RealMutationProbability)
{
y = ind.Xreal[j];
yl = problemObj.MinRealvar[j];
yu = problemObj.MaxRealvar[j];
delta1 = (y - yl) / (yu - yl);
delta2 = (yu - y) / (yu - yl);
rnd = randomizationObj.RandomPercent();
mutPow = 1.0 / (problemObj.MutationDistributionIndex + 1.0);
if (rnd <= 0.5)
{
xy = 1.0 - delta1;
val = 2.0 * rnd + (1.0 - 2.0 * rnd) * Math.Pow(xy, problemObj.MutationDistributionIndex + 1.0);
deltaq = Math.Pow(val, mutPow) - 1.0;
}
else
{
xy = 1.0 - delta2;
val = 2.0 * (1.0 - rnd) + 2.0 * (rnd - 0.5) * Math.Pow(xy, problemObj.MutationDistributionIndex + 1.0);
deltaq = 1.0 - Math.Pow(val, mutPow);
}
y = y + deltaq * (yu - yl);
if (y < yl)
y = yl;
if (y > yu)
y = yu;
ind.Xreal[j] = y;
problemObj.RealMutationCount += 1;
}
}
}
/* Routine for real variable SBX Crossover */
static void RealCrossover(Individual parent1, Individual parent2, Individual child1, Individual child2, ProblemDefinition problemObj, Randomization randomizationObj)
{
int i;
double rand;
double y1, y2, yl, yu;
double c1, c2;
double alpha, beta, betaq;
if (randomizationObj.RandomPercent() <= problemObj.RealCrossoverProbability)
{
problemObj.RealCrossoverCount++;
for (i = 0; i < problemObj.RealVariableCount; i++)
{
if (randomizationObj.RandomPercent() <= 0.5)
{
if (Math.Abs(parent1.Xreal[i] - parent2.Xreal[i]) > problemObj.Eps)
{
if (parent1.Xreal[i] < parent2.Xreal[i])
{
y1 = parent1.Xreal[i];
y2 = parent2.Xreal[i];
}
else
{
y1 = parent2.Xreal[i];
y2 = parent1.Xreal[i];
}
yl = problemObj.MinRealvar[i];
yu = problemObj.MaxRealvar[i];
rand = randomizationObj.RandomPercent();
beta = 1.0 + 2.0 * (y1 - yl) / (y2 - y1);
alpha = 2.0 - Math.Pow(beta, -(problemObj.CrossoverDistributionIndex + 1.0));
if (rand <= 1.0 / alpha)
{
betaq = Math.Pow(rand * alpha, 1.0 / (problemObj.CrossoverDistributionIndex + 1.0));
}
else
{
betaq = Math.Pow(1.0 / (2.0 - rand * alpha), 1.0 / (problemObj.CrossoverDistributionIndex + 1.0));
}
c1 = 0.5 * (y1 + y2 - betaq * (y2 - y1));
beta = 1.0 + 2.0 * (yu - y2) / (y2 - y1);
alpha = 2.0 - Math.Pow(beta, -(problemObj.CrossoverDistributionIndex + 1.0));
if (rand <= 1.0 / alpha)
{
betaq = Math.Pow(rand * alpha, 1.0 / (problemObj.CrossoverDistributionIndex + 1.0));
}
else
{
betaq = Math.Pow(1.0 / (2.0 - rand * alpha), 1.0 / (problemObj.CrossoverDistributionIndex + 1.0));
}
c2 = 0.5 * (y1 + y2 + betaq * (y2 - y1));
if (c1 < yl)
c1 = yl;
if (c2 < yl)
c2 = yl;
if (c1 > yu)
c1 = yu;
if (c2 > yu)
c2 = yu;
if (randomizationObj.RandomPercent() <= 0.5)
{
child1.Xreal[i] = c2;
child2.Xreal[i] = c1;
}
else
{
child1.Xreal[i] = c1;
child2.Xreal[i] = c2;
}
}
else
{
child1.Xreal[i] = parent1.Xreal[i];
child2.Xreal[i] = parent2.Xreal[i];
}
}
else
{
child1.Xreal[i] = parent1.Xreal[i];
child2.Xreal[i] = parent2.Xreal[i];
}
}
}
else
{
for (i = 0; i < problemObj.RealVariableCount; i++)
{
child1.Xreal[i] = parent1.Xreal[i];
child2.Xreal[i] = parent2.Xreal[i];
}
}
}
