/// <summary>
/// Evaluates a solution
/// </summary>
/// <param name="solution">The solution to evaluate</param>
public override void Evaluate(Solution solution)
{
XReal x = new XReal(solution);
double[] f = new double[NumberOfObjectives];
double sum1 = 0.0;
for (int var = 0; var < NumberOfVariables; var++)
{
sum1 += Math.Pow(x.GetValue(var) - (1.0 / Math.Sqrt((double)NumberOfVariables)), 2.0);
}
double exp1 = Math.Exp((-1.0) * sum1);
f[0] = 1 - exp1;
double sum2 = 0.0;
for (int var = 0; var < NumberOfVariables; var++)
{
sum2 += Math.Pow(x.GetValue(var) + (1.0 / Math.Sqrt((double)NumberOfVariables)), 2.0);
}
double exp2 = Math.Exp((-1.0) * sum2);
f[1] = 1 - exp2;
solution.Objective[0] = f[0] * -1;
solution.Objective[1] = f[1] * -1;
}
/// <summary>
/// Perform the mutation operation
/// </summary>
/// <param name="probability">Mutation probability</param>
/// <param name="solution">The solution to mutate</param>
private void DoMutation(double probability, Solution solution)
{
XReal x = new XReal(solution);
for (int var = 0; var < solution.Variable.Length; var++)
{
if (JMetalRandom.NextDouble() < probability)
{
double rand = JMetalRandom.NextDouble();
double tmp;
if (rand <= 0.5)
{
tmp = Delta(x.GetUpperBound(var) - x.GetValue(var), perturbation.Value);
tmp += x.GetValue(var);
}
else
{
tmp = Delta(x.GetLowerBound(var) - x.GetValue(var), perturbation.Value);
tmp += x.GetValue(var);
}
if (tmp < x.GetLowerBound(var))
{
tmp = x.GetLowerBound(var);
}
else if (tmp > x.GetUpperBound(var))
{
tmp = x.GetUpperBound(var);
}
x.SetValue(var, tmp);
}
}
}
public override void Evaluate(Solution solution)
{
_counter++;
IntergenSolution s = (IntergenSolution)solution;
s.FoundAtEval = _counter;
var doubleVal = new double[Model.Setting.NumberOfFeatures];
var values = new XReal(solution);
for (var i = 0; i < Model.Setting.NumberOfFeatures; i++)
{
doubleVal[i] = values.GetValue(i);
}
//the distribution from the NSGA2
var nsgaFv = new Distribution(doubleVal);
var fc = new FitnessCalculator(Model, _counter);
var fitnessValues = fc.Calculate(null, null, nsgaFv, FeatureTarget, null, null);
solution.Objective[0] = fitnessValues.FeatureVal;
FitnessTracker.AddFeat(s.FoundAtEval, fitnessValues.FeatureVal);
}
/// <summary>
/// Evaluates a solution
/// </summary>
/// <param name="solution">The solution to evaluate</param>
public override void Evaluate(Solution solution)
{
XReal vars = new XReal(solution);
double aux, xi, xj; // auxiliary variables
double[] fx = new double[2]; // function values
double[] x = new double[NumberOfVariables];
for (int i = 0; i < NumberOfVariables; i++)
{
x[i] = vars.GetValue(i);
}
fx[0] = 0.0;
for (int var = 0; var < NumberOfVariables - 1; var++)
{
xi = x[var] * x[var];
xj = x[var + 1] * x[var + 1];
aux = (-0.2) * Math.Sqrt(xi + xj);
fx[0] += (-10.0) * Math.Exp(aux);
}
fx[1] = 0.0;
for (int var = 0; var < NumberOfVariables; var++)
{
fx[1] += Math.Pow(Math.Abs(x[var]), 0.8) + 5.0 * Math.Sin(Math.Pow(x[var], 3.0));
}
solution.Objective[0] = fx[0];
solution.Objective[1] = fx[1];
}
public override void Evaluate(Solution solution)
{
var s = (IntergenSolution)solution;
var doubleVal = new double[Model.Setting.NumberOfFeatures];
var interacVal = new double[Model.Setting.NumberOfInteractions];
var values = new XReal(solution);
for (var i = 0; i < Model.Setting.NumberOfFeatures; i++)
{
doubleVal[i] = values.GetValue(i);
}
for (var i = 0; i < Model.Setting.NumberOfInteractions; i++)
{
interacVal[i] = values.GetValue(i + Model.Setting.NumberOfFeatures);
}
//the distribution from the NSGA2
var nsgaFv = new Distribution(doubleVal);
var interacDist = new Distribution(interacVal);
var variantValuesWithoutInteraction = FeatureMatrix.Dot(doubleVal);
var interacVals = InteractionMatrix.Dot(interacVal);
var variantResults = variantValuesWithoutInteraction.Add(interacVals);
var variantResult = new Distribution(variantResults);
var fc = new FitnessCalculator(Model, s.FoundAtEval);
var fitnessValues = fc.Calculate(null, null, null, null, interacDist, InteractionTarget);
solution.Objective[0] = fitnessValues.InteracVal;
FitnessTracker.AddInterac(s.FoundAtEval, fitnessValues.InteracVal);
}
public override bool IsPointOk(XReal tAreaX, XReal tAreaY)
{
foreach (var area in AreaProvider) {
if (!area.Built) continue;
int significantDist = 0;
if (MaxDistance != XReal.MaxValue) significantDist = (int)MaxDistance;
else if (MinDistance != XReal.MinValue) significantDist = (int)MinDistance;
else throw new Exception("No min or max specified?");
XReal dist2 = AreaMap.GetDistanceSquaredToArea(
new XPoint2((tAreaX / metersPerTile).RoundedToInt, (tAreaY / metersPerTile).RoundedToInt),
area, significantDist) * metersPerTile * metersPerTile;
/*float dist2 =
XVector2.DistanceSquared(
new XVector2(tAreaX, tAreaY),
area.Position
);*/
if (MaxDistance != XReal.MaxValue && (dist2 == int.MaxValue || dist2 > MaxDistance * MaxDistance))
return false;
if (dist2 < MinDistance * MinDistance)
return false;
/*if (dist2 > (MaxDistance + area.Size) * (MaxDistance + area.Size) ||
dist2 < (MinDistance + area.Size) * (MinDistance + area.Size)) {
return false;
}*/
}
return true;
}
/// <summary>
/// DoMutation method
/// </summary>
/// <param name="realProbability"></param>
/// <param name="binaryProbability"></param>
/// <param name="solution"></param>
private void DoMutation(double realProbability, double binaryProbability, Solution solution)
{
double rnd, delta1, delta2, mut_pow, deltaq;
double y, yl, yu, val, xy;
XReal x = new XReal(solution);
Binary binaryVariable = (Binary)solution.Variable[1];
// Polynomial mutation applied to the array real
for (int var = 0; var < x.Size(); var++)
{
if (JMetalRandom.NextDouble() <= realProbability)
{
y = x.GetValue(var);
yl = x.GetLowerBound(var);
yu = x.GetUpperBound(var);
delta1 = (y - yl) / (yu - yl);
delta2 = (yu - y) / (yu - yl);
rnd = JMetalRandom.NextDouble();
mut_pow = 1.0 / (eta_m + 1.0);
if (rnd <= 0.5)
{
xy = 1.0 - delta1;
val = 2.0 * rnd + (1.0 - 2.0 * rnd) * (Math.Pow(xy, (distributionIndex + 1.0)));
deltaq = Math.Pow(val, mut_pow) - 1.0;
}
else
{
xy = 1.0 - delta2;
val = 2.0 * (1.0 - rnd) + 2.0 * (rnd - 0.5) * (Math.Pow(xy, (distributionIndex + 1.0)));
deltaq = 1.0 - (Math.Pow(val, mut_pow));
}
y = y + deltaq * (yu - yl);
if (y < yl)
{
y = yl;
}
if (y > yu)
{
y = yu;
}
x.SetValue(var, y);
}
}
// BitFlip mutation applied to the binary part
for (int i = 0; i < binaryVariable.NumberOfBits; i++)
{
if (JMetalRandom.NextDouble() < binaryProbability)
{
binaryVariable.Bits.Flip(i);
}
}
}
/// <summary>
/// Evaluates a solution
/// </summary>
/// <param name="solution">The solution to evaluate</param>
public override void Evaluate(Solution solution)
{
XReal x = new XReal(solution);
int[,] main = new int[NumberOfVariables, NumberOfPairs]; // matrixe avalie
main = JMetalCSharp.initVar.initialMain.initialArray(NumberOfVariables, NumberOfPairs); //farakhani method meqdar dehi avalie be matrix
double[] f = new double[NumberOfObjectives];
int[] coverage = new int[NumberOfPairs]; // motaqayeri ke neshan dahande tedade pair haye poshesh dade shode mibashad
double cost = 0.0;
for (int var = 0; var < NumberOfVariables; var++)
{
if (x.GetValue(var) >= 1)
{
for (int i = 0; i < NumberOfPairs; i++)
{
if (main[var, i] == 1)
{
coverage[i] = 1;
}
}
cost++;
}
}
for (int j = 0; j < coverage.Length; j++)
{
if (coverage[j] >= 1)
{
f[0]++;
}
}
for (int j = 0; j < coverage.Length; j++)
{
if (coverage[j] == 1)
{
f[0]++;
}
}
int sum2 = 0;
for (int var = 0; var < NumberOfVariables; var++)
{
sum2 += 1;
}
double exp2 = Math.Exp((-1.0) * sum2);
f[1] = cost;
solution.Objective[0] = f[0];
solution.Objective[1] = f[1];
}
private void GetStdDev1(int[][] n, int type)
{
if (type == 1)
{
for (int i = 0; i < populationSize; i++)
{
XReal xTmp = new XReal(population.Get(i));
for (int k = 0; k < population.Get(i).NumberOfVariables(); k++)
{
double r = 0;
/*for (int l = 0; l < n[i].Length; l++)
* {
* XReal xTmp1 = new XReal(population.Get(n[i][l]));
* double abs = Math.Abs(xTmp1.GetValue(k) - xTmp.GetValue(k));
* r = r + (abs / (n[i].Length - 1));
* }*/
for (int l = 0; l < populationSize; l++)
{
XReal xTmp1 = new XReal(population.Get(l));
double abs = Math.Abs(xTmp1.GetValue(k) - xTmp.GetValue(k));
r = r + (abs / (populationSize - 1));
}
xTmp.SetstdDev(k, r);
}
}
}
else
{
for (int i = 0; i < populationSize; i++)
{
XReal xTmp = new XReal(population.Get(i));
for (int k = 0; k < population.Get(i).NumberOfVariables(); k++)
{
double r = 0;
for (int l = 0; l < n[i].Length; l++)
{
XReal xTmp1 = new XReal(population.Get(n[i][l]));
double abs = Math.Abs(xTmp1.GetValue(k) - xTmp.GetValue(k));
r = r + (abs / (n[i].Length - 1));
}
/*for (int l = 0; l < populationSize; l++)
* {
* XReal xTmp1 = new XReal(population.Get(l));
* double abs = Math.Abs(xTmp1.GetValue(k) - xTmp.GetValue(k));
* r = r + (abs / (populationSize - 1));
* }*/
xTmp.SetstdDev(k, r);
}
}
}
}
/// <summary>
/// Returns the value of the ZDT6 function G.
/// </summary>
/// <param name="x">Solution</param>
/// <returns></returns>
private double EvalG(XReal x)
{
double g = 0.0;
for (int i = 1; i < NumberOfVariables; i++)
{
g += x.GetValue(i);
}
g = g / (NumberOfVariables - 1);
g = Math.Pow(g, 0.25);
g = 9.0 * g;
g = 1.0 + g;
return(g);
}
// Returns a point along the surface, expected f from 0 to Length
public XVector2 GetPointAlongSurface(XReal f)
{
for (int p = 0; p < Points.Length; ++p)
{
XVector2 p1 = Points[p], p2 = Points[(p + 1) % Points.Length];
XReal len = XVector2.Distance(p1, p2);
if (len > f)
{
return(XVector2.Lerp(p1, p2, f / len));
}
f -= len;
}
throw new Exception("rmPolygon::GetPointAlongSurface(), f is not in range!");
}
/// <summary>
///
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
public double EvalG(XReal x)
{
double g = 0.0;
for (int i = 1; i < x.GetNumberOfDecisionVariables(); i++)
{
g += x.GetValue(i);
}
double constant = (9.0 / (NumberOfVariables - 1));
g = constant * g;
g = g + 1.0;
return(g);
}
public override void Evaluate(Solution solution)
{
var s = (IntergenSolution)solution;
var doubleVal = new double[Model.Setting.NumberOfFeatures];
var interacVal = new double[Model.Setting.NumberOfInteractions];
var values = new XReal(solution);
for (var i = 0; i < Model.Setting.NumberOfFeatures; i++)
{
doubleVal[i] = values.GetValue(i);
}
for (var i = 0; i < Model.Setting.NumberOfInteractions; i++)
{
interacVal[i] = values.GetValue(i + Model.Setting.NumberOfFeatures);
}
//the distribution from the NSGA2
var nsgaFv = new Distribution(doubleVal);
var interacDist = new Distribution(interacVal);
var multiplicationTime = new Stopwatch(); multiplicationTime.Start();
var variantValuesWithoutInteraction = FeatureMatrix.Dot(doubleVal);
var interacVals = InteractionMatrix.Dot(interacVal);
var variantResults = variantValuesWithoutInteraction.Add(interacVals);
multiplicationTime.Stop();
FitnessTracker.AddMultiplicationTime(multiplicationTime.ElapsedMilliseconds);
var variantResult = new Distribution(variantResults);
var localScaledVariants = new double[VariantTarget.Values.Length];
Array.Copy(VariantTarget.Values, localScaledVariants, VariantTarget.Values.Length);
var localVariantTarget = new Distribution(localScaledVariants);
localVariantTarget = FMScaling.InteractionToScale(localVariantTarget, variantResults.Min(),
variantResults.Max());
var fc = new FitnessCalculator(Model, s.FoundAtEval);
var fitnessValues = fc.Calculate(variantResult, localVariantTarget, nsgaFv, FeatureTarget, interacDist, InteractionTarget);
solution.Objective[0] = fitnessValues.FeatureVal;
solution.Objective[1] = fitnessValues.InteracVal;
solution.Objective[2] = fitnessValues.VariantVal;
FitnessTracker.AddCalcTime(fc.GetFitnessTime());
FitnessTracker.Add(s.FoundAtEval, fitnessValues.FeatureVal, fitnessValues.InteracVal, fitnessValues.VariantVal);
}
public override void Evaluate(Solution solution)
{
XReal x = new XReal(solution);
double[] f = new double[NumberOfObjectives];
f[0] = x.GetValue(0);
double g = this.EvalG(x);
double h = this.EvalH(f[0], g);
f[1] = h * g;
solution.Objective[0] = f[0];
solution.Objective[1] = f[1];
}
/// <summary>
/// Returns the value of the ZDT4 function G.
/// </summary>
/// <param name="x">Solution</param>
/// <returns></returns>
public double EvalG(XReal x)
{
double g = 0.0;
for (int i = 1; i < NumberOfVariables; i++)
{
g += Math.Pow(x.GetValue(i), 2.0) +
-10.0 * Math.Cos(4.0 * Math.PI * x.GetValue(i));
}
double constante = 1.0 + 10.0 * (NumberOfVariables - 1);
return(g + constante);
}
/// <summary>
/// /Update the speed of each particle
/// </summary>
/// <param name="iter"></param>
/// <param name="miter"></param>
private void ComputeSpeed(int iter, int miter)
{
double r1, r2, W, C1, C2;
double wmax, wmin;
XReal bestGlobal;
for (int i = 0; i < swarmSize; i++)
{
XReal particle = new XReal(particles.Get(i));
XReal bestParticle = new XReal(best[i]);
//Select a global best for calculate the speed of particle i, bestGlobal
Solution one, two;
int pos1 = JMetalRandom.Next(0, Leaders.Size() - 1);
int pos2 = JMetalRandom.Next(0, Leaders.Size() - 1);
one = Leaders.Get(pos1);
two = Leaders.Get(pos2);
if (crowdingDistanceComparator.Compare(one, two) < 1)
{
bestGlobal = new XReal(one);
}
else
{
bestGlobal = new XReal(two);
//Params for velocity equation
}
r1 = JMetalRandom.NextDouble(r1Min, r1Max);
r2 = JMetalRandom.NextDouble(r2Min, r2Max);
C1 = JMetalRandom.NextDouble(C1Min, C1Max);
C2 = JMetalRandom.NextDouble(C2Min, C2Max);
W = JMetalRandom.NextDouble(WMin, WMax);
wmax = WMax;
wmin = WMin;
for (int var = 0; var < particle.GetNumberOfDecisionVariables(); var++)
{
//Computing the velocity of this particle
speed[i][var] = VelocityConstriction(ConstrictionCoefficient(C1, C2) * (InertiaWeight(iter, miter, wmax, wmin) * speed[i][var] + C1 * r1 * (bestParticle.GetValue(var) - particle.GetValue(var)) + C2 * r2 * (bestGlobal.GetValue(var) - particle.GetValue(var))),
deltaMax,
deltaMin,
var,
i);
}
}
}
/// <summary>
/// Perform the mutation operation
/// </summary>
/// <param name="probability">Mutation probability</param>
/// <param name="solution">The solution to mutate</param>
private void DoMutation(Solution solution)
{
double rnd, delta1, delta2, mut_pow, deltaq;
double y, yl, yu, val, xy;
mutationProbability = mutationProbability - solution.NumberofReplace * 0.001;
if (mutationProbability <= 0.1)
{
mutationProbability = 0.1;
}
XReal x = new XReal(solution);
for (int var = 0; var < solution.NumberOfVariables(); var++)
{
if (JMetalRandom.NextDouble() <= mutationProbability)
{
y = x.GetValue(var);
yl = x.GetLowerBound(var);
yu = x.GetUpperBound(var);
delta1 = (y - yl) / (yu - yl);
delta2 = (yu - y) / (yu - yl);
rnd = JMetalRandom.NextDouble();
mut_pow = 1.0 / (eta_m + 1.0);
if (rnd <= 0.5)
{
xy = 1.0 - delta1;
val = 2.0 * rnd + (1.0 - 2.0 * rnd) * (Math.Pow(xy, (distributionIndex + 1.0)));
deltaq = Math.Pow(val, mut_pow) - 1.0;
}
else
{
xy = 1.0 - delta2;
val = 2.0 * (1.0 - rnd) + 2.0 * (rnd - 0.5) * (Math.Pow(xy, (distributionIndex + 1.0)));
deltaq = 1.0 - (Math.Pow(val, mut_pow));
}
y = y + deltaq * (yu - yl);
if (y < yl)
{
y = yl;
}
if (y > yu)
{
y = yu;
}
x.SetValue(var, y);
}
}
}
/// <summary>
/// Returns the value of the ZDT1 function G.
/// </summary>
/// <param name="x">Solution</param>
/// <returns></returns>
private double EvalG(XReal x)
{
double g = 0;
double tmp;
for (int i = 1; i < x.GetNumberOfDecisionVariables(); i++)
{
tmp = x.GetValue(i);
g += tmp;
}
double constant = (9.0 / (NumberOfVariables - 1));
g = constant * g;
g = g + 1;
return(g);
}
public override void Evaluate(Solution solution)
{
XReal x = new XReal(solution);
double x1 = x.GetValue(0);
double[] f = new double[NumberOfObjectives];
f[0] = 1.0 - Math.Exp((-4.0) * x1) * Math.Pow(Math.Sin(6.0 * Math.PI * x1), 6.0);
double g = this.EvalG(x);
double h = this.EvalH(f[0], g);
f[1] = h * g;
solution.Objective[0] = f[0];
solution.Objective[1] = f[1];
}
/// <summary>
/// Returns a <code>Solution</code> using the diversification generation method
/// described in the scatter search template.
/// </summary>
/// <returns></returns>
public Solution DiversificationGeneration()
{
Solution solution;
solution = new Solution(this.Problem);
XReal wrapperSolution = new XReal(solution);
double value;
int range;
for (int i = 0; i < this.Problem.NumberOfVariables; i++)
{
sumOfReverseFrequencyValues[i] = 0;
for (int j = 0; j < numberOfSubranges; j++)
{
reverseFrequency[j][i] = sumOfFrequencyValues[i] - frequency[j][i];
sumOfReverseFrequencyValues[i] += reverseFrequency[j][i];
}
if (sumOfReverseFrequencyValues[i] == 0)
{
range = JMetalRandom.Next(0, numberOfSubranges - 1);
}
else
{
value = JMetalRandom.Next(0, sumOfReverseFrequencyValues[i] - 1);
range = 0;
while (value > reverseFrequency[range][i])
{
value -= reverseFrequency[range][i];
range++;
}
}
frequency[range][i]++;
sumOfFrequencyValues[i]++;
double low = this.Problem.LowerLimit[i] + range * (this.Problem.UpperLimit[i] -
this.Problem.LowerLimit[i]) / numberOfSubranges;
double high = low + (this.Problem.UpperLimit[i] -
this.Problem.LowerLimit[i]) / numberOfSubranges;
value = JMetalRandom.NextDouble(low, high);
wrapperSolution.SetValue(i, value);
}
return(solution);
}
/// <summary>
/// Returns the distance between two solutions in the search space.
/// </summary>
/// <param name="solutionI">The first <code>Solution</code>.</param>
/// <param name="solutionJ">The second <code>Solution</code>.</param>
/// <returns>The distance between solutions.</returns>
public double DistanceBetweenSolutions(Solution solutionI, Solution solutionJ)
{
double distance = 0.0;
XReal solI = new XReal(solutionI);
XReal solJ = new XReal(solutionJ);
double diff; //Auxiliar var
//-> Calculate the Euclidean distance
for (int i = 0; i < solI.GetNumberOfDecisionVariables(); i++)
{
diff = solI.GetValue(i) - solJ.GetValue(i);
distance += Math.Pow(diff, 2.0);
}
//-> Return the euclidean distance
return(Math.Sqrt(distance));
}
public override bool IsPointOk(XReal tAreaX, XReal tAreaY)
{
foreach (var area in AreaProvider)
{
if (!area.Built)
{
continue;
}
int significantDist = 0;
if (MaxDistance != XReal.MaxValue)
{
significantDist = (int)MaxDistance;
}
else if (MinDistance != XReal.MinValue)
{
significantDist = (int)MinDistance;
}
else
{
throw new Exception("No min or max specified?");
}
XReal dist2 = AreaMap.GetDistanceSquaredToArea(
new XPoint2((tAreaX / metersPerTile).RoundedToInt, (tAreaY / metersPerTile).RoundedToInt),
area, significantDist) * metersPerTile * metersPerTile;
/*float dist2 =
* XVector2.DistanceSquared(
* new XVector2(tAreaX, tAreaY),
* area.Position
* );*/
if (MaxDistance != XReal.MaxValue && (dist2 == int.MaxValue || dist2 > MaxDistance * MaxDistance))
{
return(false);
}
if (dist2 < MinDistance * MinDistance)
{
return(false);
}
/*if (dist2 > (MaxDistance + area.Size) * (MaxDistance + area.Size) ||
* dist2 < (MinDistance + area.Size) * (MinDistance + area.Size)) {
* return false;
* }*/
}
return(true);
}
/// <summary>
/// Perform the mutation operation
/// </summary>
/// <param name="probability">Mutation probability</param>
/// <param name="solution">The solution to mutate</param>
private void DoMutation(double probability, Solution solution)
{
XReal v = new XReal(solution);
try
{
if ((solution.Type.GetType() == typeof(BinarySolutionType)) ||
(solution.Type.GetType() == typeof(BinaryRealSolutionType)))
{
for (int i = 0; i < solution.Variable.Length; i++)
{
for (int j = 0; j < ((Binary)solution.Variable[i]).NumberOfBits; j++)
{
if (JMetalRandom.NextDouble() < probability)
{
((Binary)solution.Variable[i]).Bits.Flip(j);
}
}
}
for (int i = 0; i < solution.Variable.Length; i++)
{
((Binary)solution.Variable[i]).Decode();
}
}
else
{ // Integer representation
for (int i = 0; i < solution.Variable.Length; i++)
{
if (JMetalRandom.NextDouble() < probability)
{
int value = JMetalRandom.Next(
(int)v.GetLowerBound(i),
(int)v.GetUpperBound(i));
v.SetValue(i, value);
}
}
}
}
catch (Exception ex)
{
Logger.Log.Error("Error in " + this.GetType().FullName + ".DoMutation()", ex);
Console.WriteLine("Error in " + this.GetType().FullName + ".DoMutation()");
throw new Exception("Exception in " + this.GetType().FullName + ".DoMutation()");
}
}
public override bool IsPointOk(XReal tAreaX, XReal tAreaY)
{
var area = Area;
XReal dist =
XVector2.Distance(
new XVector2(tAreaX, tAreaY),
area.Position
);
XReal distFromEdge = dist - area.Size;
if (XReal.Abs(distFromEdge) > MaxDistance ||
XReal.Abs(distFromEdge) < MinDistance)
{
return(false);
}
return(true);
}
public override void Evaluate(Solution solution)
{
var s = (IntergenSolution)solution;
var doubleVal = new double[Model.Setting.NumberOfFeatures];
var interacVal = new double[Model.Setting.NumberOfInteractions];
var values = new XReal(solution);
for (var i = 0; i < Model.Setting.NumberOfFeatures; i++)
{
doubleVal[i] = values.GetValue(i);
}
for (var i = 0; i < Model.Setting.NumberOfInteractions; i++)
{
interacVal[i] = values.GetValue(i + Model.Setting.NumberOfFeatures);
}
//the distribution from the NSGA2
var nsgaFv = new Distribution(doubleVal);
var interacDist = new Distribution(interacVal);
var fc = new FitnessCalculator(Model, s.FoundAtEval);
var fitnessValues = fc.Calculate(null, null, nsgaFv, FeatureTarget, interacDist, InteractionTarget);
var time = fc.GetFitnessTime();
solution.Objective[0] = fitnessValues.FeatureVal;
solution.Objective[1] = fitnessValues.InteracVal;
FitnessTracker.AddFeatInterac(s.FoundAtEval, fitnessValues.FeatureVal, fitnessValues.InteracVal);
/*var cont = new SolutionContainer
* {
*
* Features = nsgaFv,
* Interaction = interacDist,
* //TargetFeatures = FeatureTarget,
* FeatureTVal = fitnessValues.FeatureVal,
* InteracTVal = fitnessValues.InteracVal,
* VariantTVal = fitnessValues.VariantVal,
* FoundAtEval = _counter,
* };
* Model.AddSolutionToHistory(cont); */
//_worker.ReportProgress((int) (_counter*100/(double) Model.Setting.MaxEvaluations));
}
public override void Evaluate(Solution solution)
{
XReal x = new XReal(solution);
double[] f = new double[NumberOfObjectives];
float[] coverage = new float[numberOfPairs]; // motaqayeri ke neshan dahande tedade pair haye poshesh dade shode mibashad
float cost = 0;
for (int var = 0; var < NumberOfVariables; var++)
{
if (x.GetValue(var) >= 1)
{
cost++;
for (int i = 0; i < numberOfPairs; i++)
{
if (Matrix[i, var] == 1)
{
coverage[i] = 1;
}
}
}
}
for (int j = 0; j < coverage.Length; j++)
{
f[0] += coverage[j];
}
f[0] = numberOfPairs - f[0];// uncoverage
f[1] = cost;
if (f[1] == 0)
{
f[0] = numberOfPairs;
f[1] = numberOfVariables;
}
f[0] /= numberOfPairs;
f[1] /= numberOfVariables;
f[0] = Math.Round(f[0], 2);
f[1] = Math.Round(f[1], 2);
//f[0] = f[0] - 1;
Console.WriteLine(f[0] + " : " + f[1]);
solution.Objective[0] = f[0];
solution.Objective[1] = f[1];
}
public static T ElementOrDefault <T>(this XElement el, XName name, T dflt) where T : struct
{
if (el == null)
{
return(dflt);
}
var attrib = el.ElementCase(name);
if (attrib == null)
{
return(dflt);
}
if (typeof(T) == typeof(XReal))
{
var val = new XReal(PrimitiveConverter <string, float> .Convert(attrib.Value));
return((T)(object)val);
}
return(PrimitiveConverter <string, T> .Convert(attrib.Value));
}
private Solution DoMutation(double probability, Solution parent)
{
Solution current = new Solution(parent);
Solution child;
child = new Solution(current);
XReal xCurrent = new XReal(current);
XReal xChild = new XReal(child);
int numberOfVariables = xCurrent.GetNumberOfDecisionVariables();
randStdNormal = new double[numberOfVariables];
for (int j = 0; j < numberOfVariables; j++)
{
double value;
// value = xParent2.GetValue(j) + f * (xParent0.GetValue(j) - xParent1.GetValue(j));
double u1 = JMetalRandom.NextDouble(0, 1);
double u2 = JMetalRandom.NextDouble(0, 1);
if (JMetalRandom.NextDouble() <= probability)
{
randStdNormal[j] = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2); //random normal(0,1)
value = xCurrent.GetValue(j) + zeta * xCurrent.GetStdDev(j) * randStdNormal[j];
if (value < xChild.GetLowerBound(j))
{
value = xChild.GetLowerBound(j);
//value = JMetalRandom.NextDouble(xChild.GetLowerBound(j), xChild.GetUpperBound(j));
}
if (value > xChild.GetUpperBound(j))
{
value = xChild.GetUpperBound(j);
//value = JMetalRandom.NextDouble(xChild.GetLowerBound(j), xChild.GetUpperBound(j));
}
xChild.SetValue(j, value);
}
}
return(child);
}
private void GetStdDev(int[][] n)
{
//GetFS();
for (int i = 0; i < populationSize; i++)
{
XReal xTmp = new XReal(population.Get(i));
for (int k = 0; k < population.Get(i).NumberOfVariables(); k++)
{
double r = 0;
for (int l = 0; l < n[i].Length; l++)
{
XReal xTmp1 = new XReal(population.Get(n[i][l]));
double abs = Math.Abs(xTmp1.GetValue(k) - xTmp.GetValue(k));
//if (abs < Math.Abs(xTmp.GetUpperBound(k) - xTmp.GetLowerBound(k)) / n[i].Length)
r = r + (abs / (n[i].Length - 1));
}
xTmp.SetstdDev(k, r);
}
}
}
/// <summary>
/// Evaluates a solution
/// </summary>
/// <param name="solution">The solution to evaluate</param>
public override void Evaluate(Solution solution)
{
XReal V = new XReal(solution);
double[] fx = new double[2]; // function values
fx[0] = 0.0;
for (int var = 0; var < intVariables; var++)
{
fx[0] = V.GetValue(var);
}
fx[1] = 0.0;
for (int var = intVariables; var < NumberOfVariables; var++)
{
fx[1] += V.GetValue(var);
}
solution.Objective[0] = fx[0];
solution.Objective[1] = fx[1];
}
public override void Evaluate(Solution solution)
{
// Current Solution
List <double> currentSolution = new List <double>();
double[] storeVar = new double[NumberOfVariables];
double[] storeObj = new double[NumberOfObjectives];
XReal x = new XReal(solution);
// Reading x values
double[] xValues = new double[NumberOfVariables];
for (int i = 0; i < NumberOfVariables; i++)
{
xValues[i] = x.GetValue(i);
var1Value.Add(x.GetValue(0));
var2Value.Add(x.GetValue(1));
currentSolution.Add(x.GetValue(i)); // add current variable value to current solution
}
GH_NumberSlider currentSlider = null;
for (int i = 0; i < component.readSlidersList().Count; i++)
{
currentSlider = component.readSlidersList()[i];
currentSlider.SetSliderValue((decimal)x.GetValue(i));
//Grasshopper.Instances.ActiveCanvas.Document.NewSolution(true); //<- NOTE: Is this the part that's re-evaluating after every slider change??
}
Grasshopper.Instances.ActiveCanvas.Document.NewSolution(true);
for (int i = 0; i < component.objectives.Count; i++)
{
solution.Objective[i] = component.objectives[i];
currentSolution.Add(component.objectives[i]); //adding current i-objective to current solution
}
//component.allSolutions = component.allSolutions +"" + component.objectives[i] + " ";
allSolutions.Add(currentSolution);
}
/**Sets area coherence (0-1).*/
public void rmSetAreaCoherence(int areaID, XReal coherence)
{
areas[areaID].Coherence = coherence;
}
/**Make an area cliff ramp edge distance constraint. Returns its ID.*/
// not used
//public int rmCreateCliffRampDistanceConstraint(string name, int areaID, float distance) { return -1; }
/**Make an area cliff ramp edge max distance constraint. Returns its ID.*/
// not used
//public int rmCreateCliffRampMaxDistanceConstraint(string name, int areaID, float distance) { return -1; }
/**Make a constraint that forces something to remain within an area's edge. Returns its ID.*/
// not used
//public int rmCreateEdgeConstraint(string name, int areaID) { return -1; }
/**Make an area edge distance constraint and returns its ID*/
public int rmCreateEdgeDistanceConstraint(string name, int areaID, XReal distance)
{
constraints.Add(new RMConstraintEdge(name) {
MinDistance = distance,
MaxDistance = XReal.MaxValue,
Area = areas[areaID],
});
return constraints.Count - 1;
}
/**Make a constraint to be close to terrain with certain a passability.*/
public int rmCreateTerrainMaxDistanceConstraint(string name, string type, bool passable, XReal distance)
{
return -1;
}
/**Make a type distance constraint.*/
public int rmCreateTypeDistanceConstraint(string name, string className, XReal distance)
{
return -1;
}
/**
* Sets one player location. You can use this to place players anywhere.
* Once a player is placed, it won't be repositioned by any future calls to the various rmPlacePlayers functions.
*/
public void rmPlacePlayer(int playerID, XReal xFraction, XReal zFraction)
{
players[playerID].Position = fracToMeters(new XVector2(xFraction, zFraction));
}
/**
* Makes a line of player locations. Sometimes you will want players to be placed in a line.
* Anatolia places each team on a line, while Vinlandsaga places all players in a line.
* Using a line placement is not easy because there may not be enough room for player areas or resources.
* X and Z determine the starting and ending locations of the line.
* DistVariation determines how far from the line player areas can vary, and spacingVariation determines how much space there is among points along the line where players are placed.
*/
public void rmPlacePlayersLine(XReal x1, XReal z1, XReal x2, XReal z2, XReal distVariation, XReal spacingVariation)
{
XVector2 p1 = new XVector2(x1, z1), p2 = new XVector2(x2, z2);
for (int p = 1; p < players.Count; ++p) {
players[p].Position =
fracToMeters(XVector2.Lerp(p1, p2, (XReal)(p - 1) / (players.Count - 1)));
}
}
/**Make a constraint that forces something to remain within a given distance from the areaID. Returns its ID.*/
// not used
//public int rmCreateAreaMaxDistanceConstraint(string name, int areaID, float distance) { return -1; }
/**Make an area overlap constraint. This prevents areas from overlapping. Returns its ID.*/
// not used
//public int rmCreateAreaOverlapConstraint(string name, int areaID) { return -1; }
/**Make a box constraint and forces something to remain in it. Returns its ID.*/
public int rmCreateBoxConstraint(string name, XReal startX, XReal startZ, XReal endX, XReal endZ, XReal bufferFraction)
{
// NOTE: Unsure of use of bufferFraction, documentation unclear
constraints.Add(new RMConstraintBox(name) {
Box = new XRectangleF(rmXFractionToMeters(startX - bufferFraction),
rmXFractionToMeters(startZ - bufferFraction),
rmXFractionToMeters(endX - startX + bufferFraction * 2),
rmXFractionToMeters(endZ - startZ + bufferFraction * 2)
),
});
return constraints.Count - 1;
}
////////////// class Converter //////////////
// http://aomcodereference.googlecode.com/svn/trunk/doc/aom/scripting/xs/rm/Converter.html
public int rmAreaFractionToTiles(XReal fraction)
{
return (fraction * (TileSizeX * TileSizeX)).RoundedToInt;
}
/**
* Set cliff painting options for an area.
* Determines how a cliff is painted with impassable and passable textures.
* @param paintGround Specifies if the ground should be painted or just left whatever it already is. Defaults true.
* @param paintSide Specifies if the cliff sides should be painted. Defaults true.
* @param paintOutsideEdge Specifies if the outside cliff edge should be painted. This is the area between the cliff side and the ground. Defaults true.
* @param minSideHeight Specifies the minimum height that a cliff tile must be sloped before treating it as a cliff side. Set to 0 to have the minimum amount of cliff sides painted. Defaults to 1.5.
* @param paintInsideEdge Specifies if the inside cliff edge should be painted. This is the area between the cliff side and the ground. Defaults true.
*/
public void rmSetAreaCliffPainting(int areaID, bool paintGround, bool paintOutsideEdge, bool paintSide, XReal minSideHeight, bool paintInsideEdge)
{
}
/**Make a constraint that forces something to remain within an area's cliff edge. Returns its ID.*/
// not used
//public int rmCreateCliffEdgeConstraint(string name, int areaID) { return -1; }
/**Make an area cliff edge distance constraint. Returns its ID.*/
// not used
//public int rmCreateCliffEdgeDistanceConstraint(string name, int areaID, float distance) { return -1; }
/**Make an area cliff edge max distance constraint. Returns its ID.*/
public int rmCreateCliffEdgeMaxDistanceConstraint(string name, int areaID, XReal distance)
{
constraints.Add(new RMConstraintEdge(name) {
MinDistance = 0,
MaxDistance = distance,
Area = areas[areaID],
AreaMap = areaMap,
});
return constraints.Count - 1;
}
/**
* Adds a terrain layer to an area. Terrain layers allow you to place a border of one or more textures around an area.
* For example, you can have grassDirt50 and grassDirt75 around an area of grass. You can specify multiple layers for an area,
* as long as the minDistance for one starts where the maxDistance for another leaves off.
* Because different textures overlap one another you may need to experiment with distances to get a good effect.
* Here is an example:
* <code>
* rmSetAreaTerrainType(areaID, "GrassA");
* rmAddAreaTerrainLayer(areaID, "SnowGrass75", 13, 20);
* rmAddAreaTerrainLayer(areaID, "SnowGrass50", 6, 13);
* rmAddAreaTerrainLayer(areaID, "SnowGrass25", 0, 6);
* </code>
*/
public void rmAddAreaTerrainLayer(int areaID, string terrain, XReal minDist, XReal maxDist)
{
areas[areaID].TerrainLayers.Add(new RMArea.TerrainLayer() {
TerrainType = terrain,
MinDist = minDist,
MaxDist = maxDist,
});
}
/**
* Makes a square of player locations. Places players in a square, which automatically adjusts to a rectangle for rectangular maps.
* Unlike the circle, variance here is determined by a plus or minus (the distVariation) off of the mean distance.
* SpacingVariation determines whether players are equidistant or can be slightly closer or farther apart.
*/
public void rmPlacePlayersSquare(XReal dist, XReal distVariation, XReal spacingVariationfloat)
{
XReal half = (XReal)0.5f;
XVector2 min = new XVector2(TileSizeX * (half - dist), TileSizeZ * (half - dist));
XVector2 max = new XVector2(TileSizeX - min.X, TileSizeZ - min.Y);
RMPolygon poly = new RMPolygon() {
Points = new[] {
new XVector2(min.X, min.Y), new XVector2(min.X, max.Y),
new XVector2(max.X, max.Y), new XVector2(max.X, min.Y)
}
};
XReal polyLen = poly.Length;
XReal off = (XReal)rand.NextDouble();
for (int p = 1; p < players.Count; ++p) {
players[p].Position =
fracToMeters(tileToFrac(poly.GetPointAlongSurface(
((p - 1 + off) / (players.Count - 1)) * polyLen)
));
}
}
/**Sets the base height for an area.*/
public void rmSetAreaBaseHeight(int areaID, XReal height)
{
areas[areaID].BaseHeight = height;
}
// From AOE3?
//public void rmDefineConstant(string name, int value) { }
public XReal rmRandFloat(XReal min, XReal max)
{
return min + (max - min) * (XReal)rand.NextDouble();
}
/**
* Multiplies a player's resource amount by the given factor.
* @param resourceName
* <li>"food"</li>
* <li>"wood"</li>
* <li>"gold"</li>
* <li>"favor"</li>
*/
public void rmMultiplyPlayerResource(int playerID, string resourceName, XReal factor)
{
}
/**Make a class distance constraint taht forces something to stay away from everything in the given class. Returns its ID.*/
public int rmCreateClassDistanceConstraint(string name, int classID, XReal distance)
{
constraints.Add(new RMConstraintAreas(name, MetersPerTile) {
MinDistance = distance,
AreaProvider = classes[classID].Areas,
AreaMap = areaMap,
});
return constraints.Count - 1;
}
/**Set the area location.*/
public void rmSetAreaLocation(int areaID, XReal xFraction, XReal zFraction)
{
areas[areaID].Position = fracToMeters(new XVector2(xFraction, zFraction));
}
/**Make a constraint that forces something to remain within an area. Returns its ID.*/
// not used
//public int rmCreateAreaConstraint(string name, int areaID) { return rmCreateAreaMaxDistanceConstraint(name, areaID, 0); }
/**Make a constraint that forces something to stay away from an area. Returns its ID.*/
public int rmCreateAreaDistanceConstraint(string name, int areaID, XReal distance)
{
constraints.Add(new RMConstraintAreas(name, MetersPerTile) {
MinDistance = distance,
AreaProvider = new [] { areas[areaID] },
AreaMap = areaMap,
});
return constraints.Count;
}
/**Sets maximum blob distance.*/
public void rmSetAreaMaxBlobDistance(int areaID, XReal dist)
{
}
////////////// class Player //////////////
// http://aomcodereference.googlecode.com/svn/trunk/src/aom/scripting/xs/rm/Player.java
/**
* Adds to a player's resource amount.
* @param resourceName
* <li>"food"</li>
* <li>"wood"</li>
* <li>"gold"</li>
* <li>"favor"</li>
*/
public void rmAddPlayerResource(int playerID, string resourceName, XReal amount)
{
players[playerID].GetResource(resourceName).Amount += amount.ToInt;
}
////////////// class FairLoc //////////////
// http://aomcodereference.googlecode.com/svn/trunk/src/aom/scripting/xs/rm/FairLoc.java
/**Adds some fairLoc placement info.*/
public int rmAddFairLoc(string unitName, bool forward, bool inside, XReal minPlayerDist, XReal maxPlayerDist, XReal locDist, XReal edgeDist, bool playerArea, bool teamArea)
{
return -1;
}
public XReal rmAreaFractionToMeters(XReal fraction)
{
return (fraction * (TileSizeX * TileSizeX)) * MetersPerTile;
}
/**
* Makes a circle of player locations. Places players in a circle.
* Variation is determined by the difference between the min and max.
* Angle variation determines whether players are equidistant or can be slightly closer or farther apart.
*/
public void rmPlacePlayersCircular(XReal minFraction, XReal maxFraction, XReal angleVariation)
{
}
/**Add item to object definition.*/
public void rmAddObjectDefItem(int defID, string unitName, int count, XReal clusterDistance)
{
}
public XReal rmDegreesToRadians(XReal degrees)
{
return degrees * (XReal)Math.PI / 180;
}
/**
* Set cliff edge parameters for an area. Determines whether there should be pathable ramps or not connecting the top of the cliff to the surrounding area.
* @param count Number of cliff edges to create. The count times the size should not be more than 1.0. Defaults to 1.
* @param size This specifies how much of the area's outline should be turned into cliff edges. It should be between 0.0 and 1.0. Set to 1.0 to make the whole area surrounded. Defaults to 0.5.
* @param variance The variance to use for the size. Defaults to 0.0.
* @param spacing Spacing modifier. This should be between 0.0 and 1.0. The smaller this is, the closer together the cliff edges will be. Defaults to 1.0.
* @param mapEdge Specifies where the cliff edge should be in relation to the map edge. Set to 0 for any, 1 to be away from the map edge, or 2 to be close to the map edge. Defaults to 0.
*/
public void rmSetAreaCliffEdge(int areaID, int count, XReal size, XReal variance, XReal spacing, int mapEdge)
{
}
/**Place object definition at specific location for given player.*/
public void rmPlaceObjectDefAtLoc(int defID, int playerID, XReal xFraction, XReal zFraction, long placeCount)
{
}
public XReal rmRadiansToDegrees(XReal radians)
{
return radians / 180 * (XReal)Math.PI;
}
/**
* Set an area's cliff height.
* @param val Make positive for raised cliffs and negative for lowered cliffs. Defaults to 4.0.
* @param variance The variance to use for the height.
* @param ramp This is used to determine how quickly the height ramps up to the cliff height (it refers to steepness in this context, not pathable ramps to reach the top of a cliff). Defaults to 0.5.
*/
public void rmSetAreaCliffHeight(int areaID, XReal val, XReal variance, XReal ramp)
{
areas[areaID].BaseHeight = val * (XReal)(7f / 5f);
}
