https://github.com/jMetal/jMetalDocumentation/blob/master/problem.md
Ich habe das gerade ins Japanische gemacht. Der Text unten.
The Problem interface
Die Klasse, die das Problem ausdrückt, implementiert die Schnittstelle "Problem".
package org.uma.jmetal.problem;
/**
* Interface representing a multi-objective optimization problem
*
* @author Antonio J. Nebro <[email protected]>
*
* @param <S> Encoding
*/
public interface Problem<S extends Solution<?>> extends Serializable {
/* Getters */
public int getNumberOfVariables() ;
public int getNumberOfObjectives() ;
public int getNumberOfConstraints() ;
public String getName() ;
/* Methods */
public void evaluate(S solution) ;
public S createSolution() ;
Probleme sind durch die Anzahl der Determinanten, die Anzahl der Zielfunktionen und die Anzahl der Einschränkungen gekennzeichnet.
Daher wird eine Getter-Methode zum Erfassen jedes Werts definiert.
Der virtuelle Parameter "S" bestimmt die Codierung der Lösung.
evalu () ist eine Methode, die die Lösung der Klasse S auswertet, und createSolution () ist eine Methode, die eine neue Lösung erstellt.
Da die Solution-Schnittstelle ein generischer Typ ist,
jMetal5 verfügt über viele Schnittstellen, die Solution erweitern, um kontinuierliche Wertprobleme und binäre Probleme darzustellen.
Beispielsweise ist die DoubleProblem-Schnittstelle wie folgt definiert.
package org.uma.jmetal.problem;
/**
* Interface representing continuous problems
*
* @author Antonio J. Nebro <[email protected]>
*/
public interface DoubleProblem extends Problem<DoubleSolution> {
Double getLowerBound(int index) ;
Double getUpperBound(int index) ;
}
Eine Klasse, die "DoubleProblem" implementiert, akzeptiert nur "DoubleSolution". Dann ist es notwendig, eine Getter-Methode zu implementieren, die die unteren und oberen Grenzen jeder Variablen erfasst. In jMetal5 wird "AbstractDoubleProblem" als standardmäßige abstrakte Klasse vorbereitet, die "DoubleProblem" implementiert.
package org.uma.jmetal.problem.impl;
public abstract class AbstractDoubleProblem extends AbstractGenericProblem<DoubleSolution>
implements DoubleProblem {
private List<Double> lowerLimit ;
private List<Double> upperLimit ;
/* Getters */
@Override
public Double getUpperBound(int index) {
return upperLimit.get(index);
}
@Override
public Double getLowerBound(int index) {
return lowerLimit.get(index);
}
/* Setters */
protected void setLowerLimit(List<Double> lowerLimit) {
this.lowerLimit = lowerLimit;
}
protected void setUpperLimit(List<Double> upperLimit) {
this.upperLimit = upperLimit;
}
@Override
public DoubleSolution createSolution() {
return new DefaultDoubleSolution(this) ;
}
}
Als Beispiel für das Problem des kontinuierlichen Werts [Kursawa](https://github.com/jMetal/jMetal/blob/jmetal-5.0/jmetal-problem/src/main/java/org/uma/jmetal /problem/multiobjective/Kursawe.java) Das Problem ist implementiert.
package org.uma.jmetal.problem.multiobjective;
/**
* Class representing problem Kursawe
*/
public class Kursawe extends AbstractDoubleProblem {
/**
* Constructor.
* Creates a default instance of the Kursawe problem.
*/
public Kursawe() {
// 3 variables by default
this(3);
}
/**
* Constructor.
* Creates a new instance of the Kursawe problem.
*
* @param numberOfVariables Number of variables of the problem
*/
public Kursawe(Integer numberOfVariables) {
setNumberOfVariables(numberOfVariables);
setNumberOfObjectives(2);
setName("Kursawe");
List<Double> lowerLimit = new ArrayList<>(getNumberOfVariables()) ;
List<Double> upperLimit = new ArrayList<>(getNumberOfVariables()) ;
for (int i = 0; i < getNumberOfVariables(); i++) {
lowerLimit.add(-5.0);
upperLimit.add(5.0);
}
setLowerLimit(lowerLimit);
setUpperLimit(upperLimit);
}
/** Evaluate() method */
public void evaluate(DoubleSolution solution){
double aux, xi, xj;
double[] fx = new double[getNumberOfObjectives()];
double[] x = new double[getNumberOfVariables()];
for (int i = 0; i < solution.getNumberOfVariables(); i++) {
x[i] = solution.getVariableValue(i) ;
}
fx[0] = 0.0;
for (int var = 0; var < solution.getNumberOfVariables() - 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 < solution.getNumberOfVariables(); var++) {
fx[1] += Math.pow(Math.abs(x[var]), 0.8) +
5.0 * Math.sin(Math.pow(x[var], 3.0));
}
solution.setObjective(0, fx[0]);
solution.setObjective(1, fx[1]);
}
}
Wie die "DoubleProblem" -Schnittstelle und das "AbstractDoubleProblem",
BinaryProblem und AbstractBinaryProblem,
IntegerProblem und AbstractIntegerProblem sind definiert.
org.uma.jmetal.problem (Modul jmetal-core)) []: Schnittstellendefinition.org.uma.jmetal.problem.impl (Modul jmetal-core) :) []: Standardimplementierung.org.uma.jmetal.problem (Modul jmetal-problem) :) []: Problem implementiert.Es gibt zwei Möglichkeiten, um eingeschränkte Probleme mit jMetal5 zu lösen.
evalu () -Methode.package org.uma.jmetal.problem;
/**
* Interface representing problems having constraints
*
* @author Antonio J. Nebro <[email protected]>
*/
public interface ConstrainedProblem<S extends Solution<?>> extends Problem<S> {
/* Getters */
public int getNumberOfConstraints() ;
/* Methods */
public void evaluateConstraints(S solution) ;
}
jMetal5 verfolgt normalerweise den letzteren Ansatz.
Als Beispiel ist das Folgende ein Tanaka - Problem mit zwei Einschränkungen.
package org.uma.jmetal.problem.multiobjective;
/**
* Class representing problem Tanaka
*/
public class Tanaka extends AbstractDoubleProblem implements ConstrainedProblem<DoubleSolution> {
public OverallConstraintViolation<DoubleSolution> overallConstraintViolationDegree ;
public NumberOfViolatedConstraints<DoubleSolution> numberOfViolatedConstraints ;
/**
* Constructor.
* Creates a default instance of the problem Tanaka
*/
public Tanaka() {
setNumberOfVariables(2);
setNumberOfObjectives(2);
setNumberOfConstraints(2);
setName("Tanaka") ;
List<Double> lowerLimit = new ArrayList<>(getNumberOfVariables()) ;
List<Double> upperLimit = new ArrayList<>(getNumberOfVariables()) ;
for (int i = 0; i < getNumberOfVariables(); i++) {
lowerLimit.add(10e-5);
upperLimit.add(Math.PI);
}
setLowerLimit(lowerLimit);
setUpperLimit(upperLimit);
overallConstraintViolationDegree = new OverallConstraintViolation<DoubleSolution>() ;
numberOfViolatedConstraints = new NumberOfViolatedConstraints<DoubleSolution>() ;
}
@Override
public void evaluate(DoubleSolution solution) {
solution.setObjective(0, solution.getVariableValue(0));
solution.setObjective(1, solution.getVariableValue(1));
}
/** EvaluateConstraints() method */
@Override
public void evaluateConstraints(DoubleSolution solution) {
double[] constraint = new double[this.getNumberOfConstraints()];
double x1 = solution.getVariableValue(0) ;
double x2 = solution.getVariableValue(1) ;
constraint[0] = (x1 * x1 + x2 * x2 - 1.0 - 0.1 * Math.cos(16.0 * Math.atan(x1 / x2)));
constraint[1] = -2.0 * ((x1 - 0.5) * (x1 - 0.5) + (x2 - 0.5) * (x2 - 0.5) - 0.5);
double overallConstraintViolation = 0.0;
int violatedConstraints = 0;
for (int i = 0; i < getNumberOfConstraints(); i++) {
if (constraint[i]<0.0){
overallConstraintViolation+=constraint[i];
violatedConstraints++;
}
}
overallConstraintViolationDegree.setAttribute(solution, overallConstraintViolation);
numberOfViolatedConstraints.setAttribute(solution, violatedConstraints);
}
}
Discusion
Einbindung der "ConstrainedProblem" -Schnittstelle
Motiviert durch die Tatsache, dass in früheren Versionen alle Probleme "evaluieren ()" und "evaluierenConstraints ()" hatten.
Für uneingeschränkte Probleme wurde evaluConstraints () als Methode von implementiert.
Um Verstöße gegen das Prinzip der Schnittstellentrennung zu vermeiden, wertet jMetal5 Einschränkungen nur für Probleme aus, für die Einschränkungen erforderlich sind.
Im ursprünglichen jMetal war es notwendig, die Lösung zweimal wie folgt zu bewerten.
Problem problem ;
Solution solution ;
...
problem.evaluate(solution) ;
problem.evaluateContraints(solution) ;
Die aktuelle Version muss eine Überprüfung auf Einschränkungen enthalten.
Problem problem ;
Solution solution ;
...
problem.evaluate(solution) ;
problem.evaluateContraints(solution) ;