/**
* Creates a LZ09_F2 problem instance
*
* @param solutionType The solution type must "Real" or "BinaryReal".
*/
public LZ09_F2(String solutionType, Integer ptype, Integer dtype, Integer ltype)
throws ClassNotFoundException {
numberOfVariables_ = 30;
numberOfObjectives_ = 2;
numberOfConstraints_ = 0;
problemName_ = "LZ09_F2";
LZ09_ = new LZ09(numberOfVariables_, numberOfObjectives_, ptype, dtype, ltype);
lowerLimit_ = new double[numberOfVariables_];
upperLimit_ = new double[numberOfVariables_];
lowerLimit_[0] = 0.0;
upperLimit_[0] = 1.0;
for (int var = 1; var < numberOfVariables_; var++) {
lowerLimit_[var] = -1.0;
upperLimit_[var] = 1.0;
} // for
if (solutionType.compareTo("BinaryReal") == 0) solutionType_ = new BinaryRealSolutionType(this);
else if (solutionType.compareTo("Real") == 0) solutionType_ = new RealSolutionType(this);
else {
System.out.println("Error: solution type " + solutionType + " invalid");
System.exit(-1);
}
} // LZ09_F2
double fitnessFunction(Solution individual, double[] lambda) {
double fitness;
fitness = 0.0;
if (functionType_.equals("_TCHE1")) {
double maxFun = -1.0e+30;
for (int n = 0; n < problem_.getNumberOfObjectives(); n++) {
double diff = Math.abs(individual.getObjective(n) - z_[n]);
double feval;
if (lambda[n] == 0) {
feval = 0.0001 * diff;
} else {
feval = diff * lambda[n];
}
if (feval > maxFun) {
maxFun = feval;
}
} // for
fitness = maxFun;
} // if
else if (functionType_.equals("_AGG")) {
double sum = 0.0;
for (int n = 0; n < problem_.getNumberOfObjectives(); n++) {
sum += (lambda[n]) * individual.getObjective(n);
}
fitness = sum;
} else if (functionType_.equals("_PBI")) {
double d1, d2, nl;
double theta = 5.0;
d1 = d2 = nl = 0.0;
for (int i = 0; i < problem_.getNumberOfObjectives(); i++) {
d1 += (individual.getObjective(i) - z_[i]) * lambda[i];
nl += Math.pow(lambda[i], 2.0);
}
nl = Math.sqrt(nl);
d1 = Math.abs(d1) / nl;
for (int i = 0; i < problem_.getNumberOfObjectives(); i++) {
d2 += Math.pow((individual.getObjective(i) - z_[i]) - d1 * (lambda[i] / nl), 2.0);
}
d2 = Math.sqrt(d2);
fitness = (d1 + theta * d2);
} else {
System.out.println("MOEAD.fitnessFunction: unknown type " + functionType_);
System.exit(-1);
}
return fitness;
} // fitnessEvaluation
public void readProblem(String fileName) throws FileNotFoundException, IOException {
Reader inputFile = new BufferedReader(new InputStreamReader(new FileInputStream(fileName)));
StreamTokenizer token = new StreamTokenizer(inputFile);
try {
token.nextToken();
numberOfCities_ = (int) token.nval;
distanceMatrix_ = new double[numberOfCities_][numberOfCities_];
flujo1 = new double[numberOfCities_][numberOfCities_];
flujo2 = new double[numberOfCities_][numberOfCities_];
// Cargar objetivo 1
for (int k = 0; k < numberOfCities_; k++) {
for (int j = 0; j < numberOfCities_; j++) {
token.nextToken();
flujo1[k][j] = token.nval;
}
}
// Cargar objetivo 2
for (int k = 0; k < numberOfCities_; k++) {
for (int j = 0; j < numberOfCities_; j++) {
token.nextToken();
flujo2[k][j] = token.nval;
}
}
// Carga de distancias
for (int k = 0; k < numberOfCities_; k++) {
for (int j = 0; j < numberOfCities_; j++) {
token.nextToken();
distanceMatrix_[k][j] = token.nval;
}
}
} // try
catch (Exception e) {
System.err.println("QAP.readProblem(): error when reading data file " + e);
System.exit(1);
} // catch
} // readProblem
/**
* Constructor. Creates a default instance of the Srinivas problem
*
* @param solutionType The solution type must "Real" or "BinaryReal".
*/
public Srinivas(String solutionType) throws ClassNotFoundException {
numberOfVariables_ = 2;
numberOfObjectives_ = 2;
numberOfConstraints_ = 2;
problemName_ = "Srinivas";
lowerLimit_ = new double[numberOfVariables_];
upperLimit_ = new double[numberOfVariables_];
for (int var = 0; var < numberOfVariables_; var++) {
lowerLimit_[var] = -20.0;
upperLimit_[var] = 20.0;
} // for
if (solutionType.compareTo("BinaryReal") == 0) solutionType_ = new BinaryRealSolutionType(this);
else if (solutionType.compareTo("Real") == 0) solutionType_ = new RealSolutionType(this);
else {
System.out.println("Error: solution type " + solutionType + " invalid");
System.exit(-1);
}
} // Srinivas
/**
* Creates a new DTLZ5 problem instance
*
* @param numberOfVariables Number of variables
* @param numberOfObjectives Number of objective functions
* @param solutionType The solution type must "Real" or "BinaryReal".
*/
public DTLZ5(String solutionType, Integer numberOfVariables, Integer numberOfObjectives)
throws ClassNotFoundException {
numberOfVariables_ = numberOfVariables.intValue();
numberOfObjectives_ = numberOfObjectives.intValue();
numberOfConstraints_ = 0;
problemName_ = "DTLZ5";
lowerLimit_ = new double[numberOfVariables_];
upperLimit_ = new double[numberOfVariables_];
for (int var = 0; var < numberOfVariables_; var++) {
lowerLimit_[var] = 0.0;
upperLimit_[var] = 1.0;
}
if (solutionType.compareTo("BinaryReal") == 0) solutionType_ = new BinaryRealSolutionType(this);
else if (solutionType.compareTo("Real") == 0) solutionType_ = new RealSolutionType(this);
else {
System.out.println("Error: solution type " + solutionType + " invalid");
System.exit(-1);
}
} // DTLZ5
/**
* Creates a new instance of problem CEC2009_UF10.
*
* @param numberOfVariables Number of variables.
* @param solutionType The solution type must "Real" or "BinaryReal".
*/
public CEC2009_UF10(String solutionType, Integer numberOfVariables)
throws ClassNotFoundException {
numberOfVariables_ = numberOfVariables.intValue();
numberOfObjectives_ = 3;
numberOfConstraints_ = 0;
problemName_ = "CEC2009_UF10";
upperLimit_ = new double[numberOfVariables_];
lowerLimit_ = new double[numberOfVariables_];
// Establishes upper and lower limits for the variables
for (int var = 0; var < numberOfVariables_; var++) {
lowerLimit_[var] = 0.0;
upperLimit_[var] = 1.0;
} // for
if (solutionType.compareTo("BinaryReal") == 0) solutionType_ = new BinaryRealSolutionType(this);
else if (solutionType.compareTo("Real") == 0) solutionType_ = new RealSolutionType(this);
else {
System.out.println("Error: solution type " + solutionType + " invalid");
System.exit(-1);
}
} // CEC2009_UF10