/**
* Constructor. Creates a new instance of Spea2Fitness for a given <code>SolutionSet</code>.
*
* @param solutionSet The <code>SolutionSet</code>
*/
public Spea2Fitness(SolutionSet solutionSet) {
distance = distance_.distanceMatrix(solutionSet);
solutionSet_ = solutionSet;
for (int i = 0; i < solutionSet_.size(); i++) {
solutionSet_.get(i).setLocation(i);
} // for
} // Spea2Fitness
protected void addRankedSolutionsToPopulation(Ranking ranking, int rank) throws JMetalException {
SolutionSet front;
front = ranking.getSubfront(rank);
for (int i = 0; i < front.size(); i++) {
population.add(front.get(i));
}
}
/**
* Apply a mutation operator to some particles in the swarm
*
* @throws jmetal.util.JMException
*/
private void mopsoMutation(int actualIteration, int totalIterations) throws JMException {
for (int i = 0; i < particles_.size(); i++) {
if ((i % 6) == 0) polynomialMutation_.execute(particles_.get(i));
// if (i % 3 == 0) { //particles_ mutated with a non-uniform mutation %3
// nonUniformMutation_.execute(particles_.get(i));
// } else if (i % 3 == 1) { //particles_ mutated with a uniform mutation operator
// uniformMutation_.execute(particles_.get(i));
// } else //particles_ without mutation
// ;
}
} // mopsoMutation
protected void addLastRankedSolutions(Ranking ranking, int rank) throws JMetalException {
SolutionSet currentRankedFront = ranking.getSubfront(rank);
currentRankedFront.sort(new CrowdingComparator());
int i = 0;
while (population.size() < populationSize) {
population.add(currentRankedFront.get(i));
i++;
}
}
/**
* Returns the minimum distance from a <code>Solution</code> to a <code>
* SolutionSet according to the variable values</code>.
*
* @param solution The <code>Solution</code>.
* @param solutionSet The <code>SolutionSet</code>.
* @return The minimum distance between solution and the set.
* @throws JMException
*/
public double distanceToSolutionSetInSolutionSpace(Solution solution, SolutionSet solutionSet)
throws JMException {
// At start point the distance is the max
double distance = Double.MAX_VALUE;
// found the min distance respect to population
for (int i = 0; i < solutionSet.size(); i++) {
double aux = this.distanceBetweenSolutions(solution, solutionSet.get(i));
if (aux < distance) distance = aux;
} // for
// ->Return the best distance
return distance;
} // distanceToSolutionSetInSolutionSpace
/**
* Constructor
*
* @param problem Problem to solve
*/
public SMPSO(Problem problem, String trueParetoFront) throws FileNotFoundException {
super(problem);
hy_ = new Hypervolume();
jmetal.qualityIndicator.util.MetricsUtil mu = new jmetal.qualityIndicator.util.MetricsUtil();
trueFront_ = mu.readNonDominatedSolutionSet(trueParetoFront);
trueHypervolume_ =
hy_.hypervolume(
trueFront_.writeObjectivesToMatrix(),
trueFront_.writeObjectivesToMatrix(),
problem_.getNumberOfObjectives());
// Default configuration
r1Max_ = 1.0;
r1Min_ = 0.0;
r2Max_ = 1.0;
r2Min_ = 0.0;
C1Max_ = 2.5;
C1Min_ = 1.5;
C2Max_ = 2.5;
C2Min_ = 1.5;
WMax_ = 0.1;
WMin_ = 0.1;
ChVel1_ = -1;
ChVel2_ = -1;
} // Constructor
/**
* Performs the operation
*
* @param object Object representing a SolutionSet.
* @return the best solution found
*/
public Object execute(Object object) {
SolutionSet solutionSet = (SolutionSet) object;
if (solutionSet.size() == 0) {
return null;
}
int worstSolution;
worstSolution = 0;
for (int i = 1; i < solutionSet.size(); i++) {
if (comparator_.compare(solutionSet.get(i), solutionSet.get(worstSolution)) > 0)
worstSolution = i;
} // for
return worstSolution;
} // Execute
/**
* Performs the operation
*
* @param object Object representing a SolutionSet.
* @return the best solution found
*/
public Object execute(Object object, CITO_CAITO problem) {
SolutionSet solutionSet = (SolutionSet) object;
if (solutionSet.size() == 0) {
return null;
}
int bestSolution;
bestSolution = 0;
for (int i = 1; i < solutionSet.size(); i++) {
if (comparator_.compare(solutionSet.get(i), solutionSet.get(bestSolution)) < 0)
bestSolution = i;
} // for
return bestSolution;
} // Execute
public static void main(String[] args) throws JMException, ClassNotFoundException {
Problem problem; // The problem to solve
Algorithm algorithm; // The algorithm to use
Operator crossover; // Crossover operator
Operator mutation; // Mutation operator
Operator selection; // Selection operator
// int bits ; // Length of bit string in the OneMax problem
// bits = 512 ;
// problem = new OneMax(bits);
problem = new Sphere("Real", 20);
// problem = new Easom("Real") ;
// problem = new Griewank("Real", 10) ;
algorithm = new DE(problem); // Asynchronous cGA
/* Algorithm parameters*/
algorithm.setInputParameter("populationSize", 100);
algorithm.setInputParameter("maxEvaluations", 1000000);
// Crossover operator
crossover = CrossoverFactory.getCrossoverOperator("DifferentialEvolutionCrossover");
crossover.setParameter("CR", 0.1);
crossover.setParameter("F", 0.5);
crossover.setParameter("DE_VARIANT", "rand/1/bin");
// Add the operators to the algorithm
selection = SelectionFactory.getSelectionOperator("DifferentialEvolutionSelection");
algorithm.addOperator("crossover", crossover);
algorithm.addOperator("selection", selection);
/* Execute the Algorithm */
long initTime = System.currentTimeMillis();
SolutionSet population = algorithm.execute();
long estimatedTime = System.currentTimeMillis() - initTime;
System.out.println("Total execution time: " + estimatedTime);
/* Log messages */
System.out.println("Objectives values have been writen to file FUN");
population.printObjectivesToFile("FUN");
System.out.println("Variables values have been writen to file VAR");
population.printVariablesToFile("VAR");
} // main
protected void createInitialPopulation() throws ClassNotFoundException, JMetalException {
population = new SolutionSet(populationSize);
Solution newSolution;
for (int i = 0; i < populationSize; i++) {
newSolution = new Solution(problem);
population.add(newSolution);
}
}
protected void crowdingDistanceSelection(Ranking ranking) {
population.clear();
int rankingIndex = 0;
while (populationIsNotFull()) {
if (subfrontFillsIntoThePopulation(ranking, rankingIndex)) {
addRankedSolutionsToPopulation(ranking, rankingIndex);
rankingIndex++;
} else {
computeCrowdingDistance(ranking, rankingIndex);
addLastRankedSolutions(ranking, rankingIndex);
}
}
}
/**
* Update the position of each particle
*
* @throws jmetal.util.JMException
*/
private void computeNewPositions() throws JMException {
for (int i = 0; i < swarmSize_; i++) {
XReal particle = new XReal(particles_.get(i));
for (int var = 0; var < particle.getNumberOfDecisionVariables(); var++) {
particle.setValue(var, particle.getValue(var) + speed_[i][var]);
if (particle.getValue(var) < problem_.getLowerLimit(var)) {
particle.setValue(var, problem_.getLowerLimit(var));
speed_[i][var] = speed_[i][var] * ChVel1_; //
}
if (particle.getValue(var) > problem_.getUpperLimit(var)) {
particle.setValue(var, problem_.getUpperLimit(var));
speed_[i][var] = speed_[i][var] * ChVel2_; //
}
}
}
} // computeNewPositions
/**
* Update the speed of each particle
*
* @throws jmetal.util.JMException
*/
private void computeSpeed(int iter, int miter) throws JMException, IOException {
double r1, r2, W, C1, C2;
double wmax, wmin, deltaMax, deltaMin;
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 = PseudoRandom.randInt(0, leaders_.size() - 1);
int pos2 = PseudoRandom.randInt(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 = PseudoRandom.randDouble(r1Min_, r1Max_);
r2 = PseudoRandom.randDouble(r2Min_, r2Max_);
C1 = PseudoRandom.randDouble(C1Min_, C1Max_);
C2 = PseudoRandom.randDouble(C2Min_, C2Max_);
W = PseudoRandom.randDouble(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_, // [var],
deltaMin_, // [var],
var,
i);
}
}
} // computeSpeed
private void computeNewPositions_parallel(int i) throws JMException {
//Variable[] particle = particles_.get(i).getDecisionVariables();
XReal particle = new XReal(particles_.get(i)) ;
//particle.move(speed_[i]);
for (int var = 0; var < particle.size(); var++) {
particle.setValue(var, particle.getValue(var) + speed_[i][var]) ;
if (particle.getValue(var) < problem_.getLowerLimit(var)) {
particle.setValue(var, problem_.getLowerLimit(var));
speed_[i][var] = speed_[i][var] * ChVel1_; //
}
if (particle.getValue(var) > problem_.getUpperLimit(var)) {
particle.setValue(var, problem_.getUpperLimit(var));
speed_[i][var] = speed_[i][var] * ChVel2_; //
}
}
}
/**
* Returns a matrix with distances between solutions in a <code>SolutionSet</code>.
*
* @param solutionSet The <code>SolutionSet</code>.
* @return a matrix with distances.
*/
public double[][] distanceMatrix(SolutionSet solutionSet) {
Solution solutionI, solutionJ;
// The matrix of distances
double[][] distance = new double[solutionSet.size()][solutionSet.size()];
// -> Calculate the distances
for (int i = 0; i < solutionSet.size(); i++) {
distance[i][i] = 0.0;
solutionI = solutionSet.get(i);
for (int j = i + 1; j < solutionSet.size(); j++) {
solutionJ = solutionSet.get(j);
distance[i][j] = this.distanceBetweenObjectives(solutionI, solutionJ);
distance[j][i] = distance[i][j];
} // for
} // for
// ->Return the matrix of distances
return distance;
} // distanceMatrix
/**
* @param args Command line arguments. The first (optional) argument specifies the problem to
* solve.
* @throws JMException
* @throws IOException
* @throws SecurityException Usage: three options - jmetal.metaheuristics.mocell.MOCell_main -
* jmetal.metaheuristics.mocell.MOCell_main problemName -
* jmetal.metaheuristics.mocell.MOCell_main problemName ParetoFrontFile
*/
public static void main(String[] args) throws JMException, IOException, ClassNotFoundException {
Problem problem; // The problem to solve
Algorithm algorithm; // The algorithm to use
Operator mutation; // Mutation operator
QualityIndicator indicators; // Object to get quality indicators
// Logger object and file to store log messages
logger_ = Configuration.logger_;
fileHandler_ = new FileHandler("PAES_main.log");
logger_.addHandler(fileHandler_);
indicators = null;
if (args.length == 1) {
Object[] params = {"Real"};
problem = (new ProblemFactory()).getProblem(args[0], params);
} // if
else if (args.length == 2) {
Object[] params = {"Real"};
problem = (new ProblemFactory()).getProblem(args[0], params);
indicators = new QualityIndicator(problem, args[1]);
} // if
else { // Default problem
problem = new Kursawe("ArrayReal", 3);
// problem = new Fonseca("Real");
// problem = new Kursawe("BinaryReal",3);
// problem = new Water("Real");
// problem = new ZDT4("Real", 1000);
// problem = new WFG1("Real");
// problem = new DTLZ1("Real");
// problem = new OKA2("Real") ;
} // else
algorithm = new PAES(problem);
// Algorithm parameters
algorithm.setInputParameter("archiveSize", 100);
algorithm.setInputParameter("biSections", 5);
algorithm.setInputParameter("maxEvaluations", 25000);
// Mutation (Real variables)
mutation = MutationFactory.getMutationOperator("PolynomialMutation");
mutation.setParameter("probability", 1.0 / problem.getNumberOfVariables());
mutation.setParameter("distributionIndex", 20.0);
// Mutation (BinaryReal variables)
// mutation = MutationFactory.getMutationOperator("BitFlipMutation");
// mutation.setParameter("probability",0.1);
// Add the operators to the algorithm
algorithm.addOperator("mutation", mutation);
// Execute the Algorithm
long initTime = System.currentTimeMillis();
SolutionSet population = algorithm.execute();
long estimatedTime = System.currentTimeMillis() - initTime;
// Result messages
// STEP 8. Print the results
logger_.info("Total execution time: " + estimatedTime + "ms");
logger_.info("Variables values have been writen to file VAR");
population.printVariablesToFile("VAR");
logger_.info("Objectives values have been writen to file FUN");
population.printObjectivesToFile("FUN");
if (indicators != null) {
logger_.info("Quality indicators");
logger_.info("Hypervolume: " + indicators.getHypervolume(population));
logger_.info("GD : " + indicators.getGD(population));
logger_.info("IGD : " + indicators.getIGD(population));
logger_.info("Spread : " + indicators.getSpread(population));
logger_.info("Epsilon : " + indicators.getEpsilon(population));
} // if
} // main
protected Ranking rankPopulation() throws JMetalException {
SolutionSet union = population.union(offspringPopulation);
return new Ranking(union);
}
protected SolutionSet evaluatePopulation(SolutionSet population) throws JMetalException {
evaluations += population.size();
return evaluator.evaluate(population, problem);
}
/**
* Execute the ElitistES algorithm
* @throws JMException
*/
public SolutionSet execute() throws JMException, ClassNotFoundException {
int maxEvaluations ;
int evaluations ;
SolutionSet population ;
SolutionSet offspringPopulation ;
Operator mutationOperator ;
Comparator comparator ;
comparator = new ObjectiveComparator(0) ; // Single objective comparator
// Read the params
maxEvaluations = ((Integer)this.getInputParameter("maxEvaluations")).intValue();
// Initialize the variables
population = new SolutionSet(mu_) ;
offspringPopulation = new SolutionSet(mu_ + lambda_) ;
evaluations = 0;
// Read the operators
mutationOperator = this.operators_.get("mutation");
System.out.println("(" + mu_ + " + " + lambda_+")ES") ;
// Create the parent population of mu solutions
Solution newIndividual;
for (int i = 0; i < mu_; i++) {
newIndividual = new Solution(problem_);
evaluations++;
population.add(newIndividual);
} //for
finish {
//
async {
for (int i = 0; i < mu_; i++) {
evaluate_internal(population, i, null);
}
}
}
// Main loop
int offsprings ;
offsprings = lambda_ / mu_ ;
while (evaluations < maxEvaluations) {
// STEP 1. Generate the mu+lambda population
for (int i = 0; i < mu_; i++) {
for (int j = 0; j < offsprings; j++) {
Solution offspring = new Solution(population.get(i)) ;
offspringPopulation.add(offspring) ;
evaluations ++ ;
} // for
} // for
finish {
//
async {
for (int i = 0; i < mu_*offsprings; i++) {
evaluate_internal(offspringPopulation, i, mutationOperator);
}
}
}
// STEP 2. Add the mu individuals to the offspring population
for (int i = 0 ; i < mu_; i++) {
offspringPopulation.add(population.get(i)) ;
} // for
population.clear() ;
// STEP 3. Sort the mu+lambda population
offspringPopulation.sort(comparator) ;
// STEP 4. Create the new mu population
for (int i = 0; i < mu_; i++)
population.add(offspringPopulation.get(i)) ;
System.out.println("Evaluation: " + evaluations + " Fitness: " +
population.get(0).getObjective(0)) ;
// STEP 6. Delete the mu+lambda population
offspringPopulation.clear() ;
} // while
// Return a population with the best individual
SolutionSet resultPopulation = new SolutionSet(1) ;
resultPopulation.add(population.get(0)) ;
/**
* Runs of the Spea2 algorithm.
*
* @return a <code>SolutionSet</code> that is a set of non dominated solutions as a result of the
* algorithm execution
* @throws JMException
*/
public SolutionSet execute() throws JMException, ClassNotFoundException {
int populationSize, archiveSize, maxEvaluations, evaluations;
Operator crossoverOperator, mutationOperator, selectionOperator;
SolutionSet solutionSet, archive, offSpringSolutionSet;
// Read the params
populationSize = ((Integer) getInputParameter("populationSize")).intValue();
archiveSize = ((Integer) getInputParameter("archiveSize")).intValue();
maxEvaluations = ((Integer) getInputParameter("maxEvaluations")).intValue();
// Read the operators
crossoverOperator = operators_.get("crossover");
mutationOperator = operators_.get("mutation");
selectionOperator = operators_.get("selection");
// Initialize the variables
solutionSet = new SolutionSet(populationSize);
archive = new SolutionSet(archiveSize);
evaluations = 0;
// -> Create the initial solutionSet
Solution newSolution;
for (int i = 0; i < populationSize; i++) {
newSolution = new Solution(problem_);
problem_.evaluate(newSolution);
problem_.evaluateConstraints(newSolution);
evaluations++;
solutionSet.add(newSolution);
}
while (evaluations < maxEvaluations) {
SolutionSet union = ((SolutionSet) solutionSet).union(archive);
Spea2Fitness spea = new Spea2Fitness(union);
spea.fitnessAssign();
archive = spea.environmentalSelection(archiveSize);
// Create a new offspringPopulation
offSpringSolutionSet = new SolutionSet(populationSize);
Solution[] parents = new Solution[2];
while (offSpringSolutionSet.size() < populationSize) {
int j = 0;
do {
j++;
parents[0] = (Solution) selectionOperator.execute(archive);
} while (j < SPEA2.TOURNAMENTS_ROUNDS); // do-while
int k = 0;
do {
k++;
parents[1] = (Solution) selectionOperator.execute(archive);
} while (k < SPEA2.TOURNAMENTS_ROUNDS); // do-while
// make the crossover
Solution[] offSpring = (Solution[]) crossoverOperator.execute(parents);
mutationOperator.execute(offSpring[0]);
problem_.evaluate(offSpring[0]);
problem_.evaluateConstraints(offSpring[0]);
offSpringSolutionSet.add(offSpring[0]);
evaluations++;
} // while
// End Create a offSpring solutionSet
solutionSet = offSpringSolutionSet;
} // while
Ranking ranking = new Ranking(archive);
return ranking.getSubfront(0);
} // execute
/** @param args the command line arguments -- modelname, alg_name, evaluation_times, [runid] */
public static void main(String[] args) throws Exception {
try {
String name = args[0];
URL location = Main.class.getProtectionDomain().getCodeSource().getLocation();
String loc = location.toString();
String project_path =
loc.substring(5, loc.lastIndexOf("SPL/")) + "SPL/"; // with '/' at the end
String fm = project_path + "dimacs_data/" + name + ".dimacs";
String augment = fm + ".augment";
String dead = fm + ".dead";
String mandatory = fm + ".mandatory";
String seed = fm + ".richseed";
String opfile = fm + ".sipop";
Problem p = new ProductLineProblem(fm, augment, mandatory, dead, seed);
// Problem p = new ProductLineProblemNovelPrep(fm, augment, mandatory, dead, seed,
// opfile);
// GroupedProblem.grouping((ProductLineProblem) p, 100); System.exit(0);
Algorithm a;
int evaluation_times = Integer.parseInt(args[2]);
String alg_name = args[1];
String runid = "";
if (args.length >= 4) {
runid = args[3];
}
switch (alg_name) {
case "IBEA":
a = new SPL_SettingsIBEA(p).configureICSE2013(evaluation_times);
break;
case "SIPIBEA":
a = new SPL_SettingsIBEA(p).configureSIPIBEA(evaluation_times);
break;
case "SPEA2":
a = new SPL_SettingsEMOs(p).configureSPEA2(evaluation_times);
break;
case "NSGA2":
a = new SPL_SettingsEMOs(p).configureNSGA2(evaluation_times);
break;
case "IBEASEED":
a = new SPL_SettingsIBEA(p).configureIBEASEED(evaluation_times);
break;
case "SATIBEA":
// a = new SPL_SettingsIBEA(p).configureICSE15(1000, fm, ((ProductLineProblem)
// p).getNumFeatures(),
// ((ProductLineProblem) p).getConstraints());
a =
new SPL_SettingsIBEA(p)
.configureSATIBEA(
evaluation_times,
fm,
((ProductLineProblem) p).getNumFeatures(),
((ProductLineProblem) p).getConstraints());
break;
default:
a = new SPL_SettingsIBEA(p).configureICSE2013(evaluation_times);
}
long start = System.currentTimeMillis();
SolutionSet pop = a.execute();
float total_time = (System.currentTimeMillis() - start) / 1000.0f;
String file_tag =
name + "_" + alg_name + '_' + evaluation_times / 1000 + "k_" + runid + ".txt";
String file_path = project_path + "j_res/" + file_tag;
File file = new File(file_path);
if (!file.exists()) {
file.createNewFile();
}
FileWriter fw = new FileWriter(file.getAbsoluteFile());
BufferedWriter bw = new BufferedWriter(fw);
for (int i = 0; i < pop.size(); i++) {
Variable v = pop.get(i).getDecisionVariables()[0];
bw.write((Binary) v + "\n");
System.out.println("Conf" + (i + 1) + ": " + (Binary) v + " ");
}
bw.write("~~~\n");
for (int i = 0; i < pop.size(); i++) {
Variable v = pop.get(i).getDecisionVariables()[0];
for (int j = 0; j < pop.get(i).getNumberOfObjectives(); j++) {
bw.write(pop.get(i).getObjective(j) + " ");
System.out.print(pop.get(i).getObjective(j) + " ");
}
bw.write("\n");
System.out.println("");
}
System.out.println(total_time);
bw.write("~~~\n" + total_time + "\n");
bw.close();
fw.close();
} catch (Exception e) {
e.printStackTrace();
}
}
} // execute
private void evaluate_internal(SolutionSet s, int i, Operator mutationOperator) throws JMException, ClassNotFoundException {
Solution sol = s.get(i);
if(mutationOperator != null) mutationOperator.execute(sol);
protected boolean subfrontFillsIntoThePopulation(Ranking ranking, int rank) {
return ranking.getSubfront(rank).size() < (populationSize - population.size());
}
private void evaluate_parallel_internal(int i) throws JMException, ClassNotFoundException {
Solution particle = particles_.get(i);
problem_.evaluate(particle);
}
/**
* Gets 'size' elements from a population of more than 'size' elements using for this de
* enviromentalSelection truncation
*
* @param size The number of elements to get.
*/
public SolutionSet environmentalSelection(int size) {
if (solutionSet_.size() < size) {
size = solutionSet_.size();
}
// Create a new auxiliar population for no alter the original population
SolutionSet aux = new SolutionSet(solutionSet_.size());
int i = 0;
while (i < solutionSet_.size()) {
if (solutionSet_.get(i).getFitness() < 1.0) {
aux.add(solutionSet_.get(i));
solutionSet_.remove(i);
} else {
i++;
} // if
} // while
if (aux.size() < size) {
Comparator comparator = new FitnessComparator();
solutionSet_.sort(comparator);
int remain = size - aux.size();
for (i = 0; i < remain; i++) {
aux.add(solutionSet_.get(i));
}
return aux;
} else if (aux.size() == size) {
return aux;
}
double[][] distance = distance_.distanceMatrix(aux);
List<List<DistanceNode>> distanceList = new LinkedList<List<DistanceNode>>();
for (int pos = 0; pos < aux.size(); pos++) {
aux.get(pos).setLocation(pos);
List<DistanceNode> distanceNodeList = new ArrayList<DistanceNode>();
for (int ref = 0; ref < aux.size(); ref++) {
if (pos != ref) {
distanceNodeList.add(new DistanceNode(distance[pos][ref], ref));
} // if
} // for
distanceList.add(distanceNodeList);
} // for
for (int q = 0; q < distanceList.size(); q++) {
Collections.sort(distanceList.get(q), distanceNodeComparator);
} // for
while (aux.size() > size) {
double minDistance = Double.MAX_VALUE;
int toRemove = 0;
i = 0;
Iterator<List<DistanceNode>> iterator = distanceList.iterator();
while (iterator.hasNext()) {
List<DistanceNode> dn = iterator.next();
if (dn.get(0).getDistance() < minDistance) {
toRemove = i;
minDistance = dn.get(0).getDistance();
// i y toRemove have the same distance to the first solution
} else if (dn.get(0).getDistance() == minDistance) {
int k = 0;
while ((dn.get(k).getDistance() == distanceList.get(toRemove).get(k).getDistance())
&& k < (distanceList.get(i).size() - 1)) {
k++;
}
if (dn.get(k).getDistance() < distanceList.get(toRemove).get(k).getDistance()) {
toRemove = i;
} // if
} // if
i++;
} // while
int tmp = aux.get(toRemove).getLocation();
aux.remove(toRemove);
distanceList.remove(toRemove);
Iterator<List<DistanceNode>> externIterator = distanceList.iterator();
while (externIterator.hasNext()) {
Iterator<DistanceNode> interIterator = externIterator.next().iterator();
while (interIterator.hasNext()) {
if (interIterator.next().getReference() == tmp) {
interIterator.remove();
continue;
} // if
} // while
} // while
} // while
return aux;
} // environmentalSelection
/**
* Assigns crowding distances to all solutions in a <code>SolutionSet</code>.
*
* @param solutionSet The <code>SolutionSet</code>.
* @param nObjs Number of objectives.
*/
public void crowdingDistanceAssignment(SolutionSet solutionSet, int nObjs) {
int size = solutionSet.size();
if (size == 0) return;
if (size == 1) {
solutionSet.get(0).setCrowdingDistance(Double.POSITIVE_INFINITY);
return;
} // if
if (size == 2) {
solutionSet.get(0).setCrowdingDistance(Double.POSITIVE_INFINITY);
solutionSet.get(1).setCrowdingDistance(Double.POSITIVE_INFINITY);
return;
} // if
// Use a new SolutionSet to evite alter original solutionSet
SolutionSet front = new SolutionSet(size);
for (int i = 0; i < size; i++) {
front.add(solutionSet.get(i));
}
for (int i = 0; i < size; i++) front.get(i).setCrowdingDistance(0.0);
double objetiveMaxn;
double objetiveMinn;
double distance;
for (int i = 0; i < nObjs; i++) {
// Sort the population by Obj n
front.sort(new ObjectiveComparator(i));
objetiveMinn = front.get(0).getObjective(i);
objetiveMaxn = front.get(front.size() - 1).getObjective(i);
// Set de crowding distance
front.get(0).setCrowdingDistance(Double.POSITIVE_INFINITY);
front.get(size - 1).setCrowdingDistance(Double.POSITIVE_INFINITY);
for (int j = 1; j < size - 1; j++) {
distance = front.get(j + 1).getObjective(i) - front.get(j - 1).getObjective(i);
distance = distance / (objetiveMaxn - objetiveMinn);
distance += front.get(j).getCrowdingDistance();
front.get(j).setCrowdingDistance(distance);
} // for
} // for
} // crowdingDistanceAssing
protected boolean populationIsNotFull() {
return population.size() < populationSize;
}
/** Assigns fitness for all the solutions. */
public void fitnessAssign() {
double[] strength = new double[solutionSet_.size()];
double[] rawFitness = new double[solutionSet_.size()];
double kDistance;
// Calculate the strength value
// strength(i) = |{j | j <- SolutionSet and i dominate j}|
for (int i = 0; i < solutionSet_.size(); i++) {
for (int j = 0; j < solutionSet_.size(); j++) {
if (dominance_.compare(solutionSet_.get(i), solutionSet_.get(j)) == -1) {
strength[i] += 1.0;
} // if
} // for
} // for
// Calculate the raw fitness
// rawFitness(i) = |{sum strenght(j) | j <- SolutionSet and j dominate i}|
for (int i = 0; i < solutionSet_.size(); i++) {
for (int j = 0; j < solutionSet_.size(); j++) {
if (dominance_.compare(solutionSet_.get(i), solutionSet_.get(j)) == 1) {
rawFitness[i] += strength[j];
} // if
} // for
} // for
// Add the distance to the k-th individual. In the reference paper of SPEA2,
// k = sqrt(population.size()), but a value of k = 1 recommended. See
// http://www.tik.ee.ethz.ch/pisa/selectors/spea2/spea2_documentation.txt
int k = 1;
for (int i = 0; i < distance.length; i++) {
Arrays.sort(distance[i]);
kDistance = 1.0 / (distance[i][k] + 2.0); // Calcule de D(i) distance
// population.get(i).setFitness(rawFitness[i]);
solutionSet_.get(i).setFitness(rawFitness[i] + kDistance);
} // for
} // fitnessAsign
/**
* Runs of the SMPSO algorithm.
*
* @return a <code>SolutionSet</code> that is a set of non dominated solutions as a result of the
* algorithm execution
* @throws jmetal.util.JMException
*/
public SolutionSet execute() throws JMException, ClassNotFoundException {
initParams();
success_ = false;
// ->Step 1 (and 3) Create the initial population and evaluate
for (int i = 0; i < swarmSize_; i++) {
Solution particle = new Solution(problem_);
problem_.evaluate(particle);
problem_.evaluateConstraints(particle);
particles_.add(particle);
}
// -> Step2. Initialize the speed_ of each particle to 0
for (int i = 0; i < swarmSize_; i++) {
for (int j = 0; j < problem_.getNumberOfVariables(); j++) {
speed_[i][j] = 0.0;
}
}
// Step4 and 5
for (int i = 0; i < particles_.size(); i++) {
Solution particle = new Solution(particles_.get(i));
leaders_.add(particle);
}
// -> Step 6. Initialize the memory of each particle
for (int i = 0; i < particles_.size(); i++) {
Solution particle = new Solution(particles_.get(i));
best_[i] = particle;
}
// Crowding the leaders_
distance_.crowdingDistanceAssignment(leaders_, problem_.getNumberOfObjectives());
// -> Step 7. Iterations ..
while (iteration_ < maxIterations_) {
try {
// Compute the speed_
computeSpeed(iteration_, maxIterations_);
} catch (IOException ex) {
Logger.getLogger(SMPSO.class.getName()).log(Level.SEVERE, null, ex);
}
// Compute the new positions for the particles_
computeNewPositions();
// Mutate the particles_
mopsoMutation(iteration_, maxIterations_);
// Evaluate the new particles_ in new positions
for (int i = 0; i < particles_.size(); i++) {
Solution particle = particles_.get(i);
problem_.evaluate(particle);
problem_.evaluateConstraints(particle);
}
// Actualize the archive
for (int i = 0; i < particles_.size(); i++) {
Solution particle = new Solution(particles_.get(i));
leaders_.add(particle);
}
// Actualize the memory of this particle
for (int i = 0; i < particles_.size(); i++) {
int flag = dominance_.compare(particles_.get(i), best_[i]);
if (flag != 1) { // the new particle is best_ than the older remeber
Solution particle = new Solution(particles_.get(i));
best_[i] = particle;
}
}
// Assign crowding distance to the leaders_
distance_.crowdingDistanceAssignment(leaders_, problem_.getNumberOfObjectives());
iteration_++;
/*
if ((iteration_ % 1) == 0) {
leaders_.printObjectivesOfValidSolutionsToFile("FUNV"+iteration_) ;
leaders_.printObjectivesToFile("FUN"+iteration_) ;
leaders_.printVariablesToFile("VAR"+iteration_) ;
}
*/
}
// leaders_.printObjectivesOfValidSolutionsToFile("FUNV.SMPSO") ;
leaders_.printFeasibleFUN("FUN_SMPSO");
return this.leaders_;
} // execute
/**
* Runs of the PESA2 algorithm.
*
* @return a <code>SolutionSet</code> that is a set of non dominated solutions as a result of the
* algorithm execution
* @throws JMException
*/
public SolutionSet execute() throws JMException, ClassNotFoundException {
int archiveSize, bisections, maxEvaluations, evaluations, populationSize;
AdaptiveGridArchive archive;
SolutionSet solutionSet;
Operator crossover, mutation, selection;
// Read parameters
populationSize = ((Integer) (inputParameters_.get("populationSize"))).intValue();
archiveSize = ((Integer) (inputParameters_.get("archiveSize"))).intValue();
bisections = ((Integer) (inputParameters_.get("bisections"))).intValue();
maxEvaluations = ((Integer) (inputParameters_.get("maxEvaluations"))).intValue();
// Get the operators
crossover = operators_.get("crossover");
mutation = operators_.get("mutation");
// Initialize the variables
evaluations = 0;
archive = new AdaptiveGridArchive(archiveSize, bisections, problem_.getNumberOfObjectives());
solutionSet = new SolutionSet(populationSize);
HashMap parameters = null;
selection = new PESA2Selection(parameters);
// -> Create the initial individual and evaluate it and his constraints
for (int i = 0; i < populationSize; i++) {
Solution solution = new Solution(problem_);
problem_.evaluate(solution);
problem_.evaluateConstraints(solution);
solutionSet.add(solution);
}
// Incorporate non-dominated solution to the archive
for (int i = 0; i < solutionSet.size(); i++) {
archive.add(solutionSet.get(i)); // Only non dominated are accepted by
// the archive
}
// Clear the init solutionSet
solutionSet.clear();
// Iterations....
Solution[] parents = new Solution[2];
do {
// -> Create the offSpring solutionSet
while (solutionSet.size() < populationSize) {
parents[0] = (Solution) selection.execute(archive);
parents[1] = (Solution) selection.execute(archive);
Solution[] offSpring = (Solution[]) crossover.execute(parents);
mutation.execute(offSpring[0]);
problem_.evaluate(offSpring[0]);
problem_.evaluateConstraints(offSpring[0]);
evaluations++;
solutionSet.add(offSpring[0]);
}
for (int i = 0; i < solutionSet.size(); i++) archive.add(solutionSet.get(i));
// Clear the solutionSet
solutionSet.clear();
} while (evaluations < maxEvaluations);
// Return the solutionSet of non-dominated individual
return archive;
} // execute
