// NSGAII.java
//
// Author:
// Antonio J. Nebro <antonio@lcc.uma.es>
// Juan J. Durillo <durillo@lcc.uma.es>
//
// Copyright (c) 2011 Antonio J. Nebro, Juan J. Durillo
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
package jmetal.metaheuristics.nsgaII;
import jmetal.core.*;
import jmetal.encodings.variable.Permutation;
import jmetal.operators.localSearch.LocalSearch;
import jmetal.operators.localSearch.MutationLocalSearch;
import jmetal.operators.mutation.MutationFactory;
import jmetal.qualityIndicator.QualityIndicator;
import jmetal.util.*;
import jmetal.util.comparators.CrowdingComparator;
import problema.MainGreedy;
import problema.Problema;
import java.io.IOException;
import java.util.HashMap;
/**
* Implementation of NSGA-II.
* This implementation of NSGA-II makes use of a QualityIndicator object
* to obtained the convergence speed of the algorithm. This version is used
* in the paper:
* A.J. Nebro, J.J. Durillo, C.A. Coello Coello, F. Luna, E. Alba
* "A Study of Convergence Speed in Multi-Objective Metaheuristics."
* To be presented in: PPSN'08. Dortmund. September 2008.
*/
public class NSGAII extends Algorithm {
/**
* Constructor
* @param problem Problem to solve
*/
public NSGAII(Problem problem) {
super (problem) ;
} // NSGAII
/**
* Runs the NSGA-II 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;
int maxGenerations;
int generations;
QualityIndicator indicators; // QualityIndicator object
int requiredEvaluations; // Use in the example of use of the
// indicators object (see below)
SolutionSet population;
SolutionSet offspringPopulation;
SolutionSet union;
Operator mutationOperator;
Operator crossoverOperator;
Operator selectionOperator;
Distance distance = new Distance();
//Read the parameters
populationSize = ((Integer) getInputParameter("populationSize")).intValue();
maxGenerations = ((Integer) getInputParameter("maxGenerations")).intValue();
indicators = (QualityIndicator) getInputParameter("indicators");
//Initialize the variables
population = new SolutionSet(populationSize);
generations = 0;
//Read the operators
mutationOperator = operators_.get("mutation");
crossoverOperator = operators_.get("crossover");
selectionOperator = operators_.get("selection");
// Se inicializa con greedy con varios parametros y mutaciones
Problema problema = (Problema)problem_;
for(Solution s : problema.getSolucionesGreedy(populationSize)){
population.add(s);
}
//Operator localSearch = operators_.get("localSearch");
//population.printFeasibleFUN("./evolucion/"+generations+"fun.txt");
// Generations
while (generations < maxGenerations) {
// Create the offSpring solutionSet
offspringPopulation = new SolutionSet(populationSize);
Solution[] parents = new Solution[2];
for (int i = 0; i < (populationSize / 2); i++) {
//obtain parents
parents[0] = (Solution) selectionOperator.execute(population);
parents[1] = (Solution) selectionOperator.execute(population);
Solution[] offSpring = (Solution[]) crossoverOperator.execute(parents);
mutationOperator.execute(offSpring[0]);
mutationOperator.execute(offSpring[1]);
problem_.evaluate(offSpring[0]);
problem_.evaluateConstraints(offSpring[0]);
problem_.evaluate(offSpring[1]);
problem_.evaluateConstraints(offSpring[1]);
offspringPopulation.add(offSpring[0]);
offspringPopulation.add(offSpring[1]);
} // for
// Create the solutionSet union of solutionSet and offSpring
union = ((SolutionSet) population).union(offspringPopulation);
// Ranking the union
Ranking ranking = new Ranking(union);
int remain = populationSize;
int index = 0;
SolutionSet front = null;
population.clear();
// Obtain the next front
front = ranking.getSubfront(index);
while ((remain > 0) && (remain >= front.size())) {
//Assign crowding distance to individuals
distance.crowdingDistanceAssignment(front, problem_.getNumberOfObjectives());
//Add the individuals of this front
for (int k = 0; k < front.size(); k++) {
population.add(front.get(k));
} // for
//Decrement remain
remain = remain - front.size();
//Obtain the next front
index++;
if (remain > 0) {
front = ranking.getSubfront(index);
} // if
} // while
// Remain is less than front(index).size, insert only the best one
if (remain > 0) { // front contains individuals to insert
distance.crowdingDistanceAssignment(front, problem_.getNumberOfObjectives());
front.sort(new CrowdingComparator());
for (int k = 0; k < remain; k++) {
population.add(front.get(k));
} // for
remain = 0;
} // if
/**
if(generations % 200 == 0 || generations == maxGenerations){
//ranking = new Ranking(population);
//ranking.getSubfront(0).printFeasibleFUN("FUN_NSGAII") ;
population.printFeasibleFUN("./evolucion/"+generations+"fun.txt");
}
**/
generations++;
} // while
//System.out.println("Total generaciones: " + generations);
// Return the first non-dominated front
Ranking ranking = new Ranking(population);
//ranking.getSubfront(0).printFeasibleFUN("FUN_NSGAII") ;
return ranking.getSubfront(0);
//return hof;
} // execute
} // NSGA-II