/**
* Assigns crowding distances to all solutions in a <code>SolutionSet</code>.
* @param solutionSet The <code>SolutionSet</code>.
* @param nObjs Number of objectives.
*/
void Distance::crowdingDistanceAssignment(SolutionSet * solutionSet, int nObjs) {
int size = solutionSet->size();
if (size == 0)
return;
if (size == 1) {
solutionSet->get(0)->setCrowdingDistance(std::numeric_limits<double>::max());
return;
} // if
if (size == 2) {
solutionSet->get(0)->setCrowdingDistance(std::numeric_limits<double>::max());
solutionSet->get(1)->setCrowdingDistance(std::numeric_limits<double>::max());
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
Comparator * c = new ObjectiveComparator(i);
front->sort(c);
delete c;
objetiveMinn = front->get(0)->getObjective(i);
objetiveMaxn = front->get(front->size()-1)->getObjective(i);
//Set de crowding distance
front->get(0)->setCrowdingDistance(std::numeric_limits<double>::max());
front->get(size-1)->setCrowdingDistance(std::numeric_limits<double>::max());
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
front->clear();
delete front;
} // crowdingDistanceAssignment
/*
* Runs the ssNSGA-II algorithm.
* @return a <code>SolutionSet</code> that is a set of non dominated solutions
* as a result of the algorithm execution
*/
SolutionSet * ssNSGAII::execute() {
int populationSize;
int maxEvaluations;
int evaluations;
int IntervalOptSubsModel;
// TODO: QualityIndicator indicators; // QualityIndicator object
int requiredEvaluations; // Use in the example of use of the
// indicators object (see below)
SolutionSet * population;
SolutionSet * offspringPopulation;
SolutionSet * unionSolution;
Operator * mutationOperator;
Operator * crossoverOperator;
Operator * selectionOperator;
Distance * distance = new Distance();
//Read the parameters
populationSize = *(int *) getInputParameter("populationSize");
maxEvaluations = *(int *) getInputParameter("maxEvaluations");
IntervalOptSubsModel = *(int *) getInputParameter("intervalupdateparameters");
// TODO: indicators = (QualityIndicator) getInputParameter("indicators");
//Initialize the variables
population = new SolutionSet(populationSize);
evaluations = 0;
requiredEvaluations = 0;
//Read the operators
mutationOperator = operators_["mutation"];
crossoverOperator = operators_["crossover"];
selectionOperator = operators_["selection"];
ApplicationTools::displayTask("Initial Population", true);
// Create the initial solutionSet
Solution * newSolution;
Phylogeny * p = (Phylogeny *) problem_;
for (int i = 0; i < populationSize; i++) {
newSolution = new Solution(problem_);
if(p->StartingOptRamas){
p->BranchLengthOptimization(newSolution,p->StartingMetodoOptRamas,p->StartingNumIterOptRamas,p->StartingTolerenciaOptRamas);
}
if(p->OptimizacionSubstModel)
p->OptimizarParamModeloSust(newSolution);
problem_->evaluate(newSolution);
problem_->evaluateConstraints(newSolution);
evaluations++;
population->add(newSolution);
} //for
ApplicationTools::displayTaskDone();
// Generations
while (evaluations < maxEvaluations) {
// Create the offSpring solutionSet
offspringPopulation = new SolutionSet(populationSize);
Solution ** parents = new Solution*[2];
if(evaluations%100==0){
cout << "Evaluating " << evaluations << endl;
}
//obtain parents
parents[0] = (Solution *) (selectionOperator->execute(population));
parents[1] = (Solution *) (selectionOperator->execute(population));
// crossover
Solution ** offSpring = (Solution **) (crossoverOperator->execute(parents));
// mutation
mutationOperator->execute(offSpring[0]);
((Phylogeny *)problem_)->Optimization(offSpring[0]); //Optimize and update the scores (Evaluate OffSpring)
// evaluation
//problem_->evaluate(offSpring[0]);
//problem_->evaluateConstraints(offSpring[0]);
// insert child into the offspring population
offspringPopulation->add(offSpring[0]);
evaluations ++;
delete[] offSpring;
delete[] parents;
// Create the solutionSet union of solutionSet and offSpring
unionSolution = population->join(offspringPopulation);
delete offspringPopulation;
// Ranking the union
Ranking * ranking = new Ranking(unionSolution);
int remain = populationSize;
int index = 0;
SolutionSet * front = NULL;
for (int i=0;i<population->size();i++) {
delete population->get(i);
}
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(new Solution(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());
Comparator * c = new CrowdingComparator();
front->sort(c);
delete c;
for (int k = 0; k < remain; k++) {
population->add(new Solution(front->get(k)));
} // for
remain = 0;
} // if
delete ranking;
delete unionSolution;
//Update Interval
if(evaluations%IntervalOptSubsModel==0 and IntervalOptSubsModel > 0){
Solution * sol; double Lk;
Phylogeny * p = (Phylogeny*) problem_;
//cout << "Updating and Optimizing Parameters.." << endl;
for(int i=0; i<population->size(); i++){
sol = population->get(i);
Lk= p->BranchLengthOptimization(sol,p->OptimizationMetodoOptRamas,p->OptimizationNumIterOptRamas,p->OptimizationTolerenciaOptRamas);
sol->setObjective(1,Lk*-1);
}
//cout << "Update Interval Done!!" << endl;
}
// This piece of code shows how to use the indicator object into the code
// of NSGA-II. In particular, it finds the number of evaluations required
// by the algorithm to obtain a Pareto front with a hypervolume higher
// than the hypervolume of the true Pareto front.
// TODO:
// if ((indicators != NULL) &&
// (requiredEvaluations == 0)) {
// double HV = indicators.getHypervolume(population);
// if (HV >= (0.98 * indicators.getTrueParetoFrontHypervolume())) {
// requiredEvaluations = evaluations;
// } // if
// } // if
} // while
delete distance;
// Return as output parameter the required evaluations
// TODO:
//setOutputParameter("evaluations", requiredEvaluations);
// Return the first non-dominated front
Ranking * ranking = new Ranking(population);
SolutionSet * result = new SolutionSet(ranking->getSubfront(0)->size());
for (int i=0;i<ranking->getSubfront(0)->size();i++) {
result->add(new Solution(ranking->getSubfront(0)->get(i)));
}
delete ranking;
delete population;
return result;
} // execute
/*
* Runs the ssNSGA-II algorithm.
* @return a <code>SolutionSet</code> that is a set of non dominated solutions
* as a result of the algorithm execution
*/
SolutionSet * ssNSGAII::execute() {
int populationSize;
int maxEvaluations;
int evaluations;
// TODO: QualityIndicator indicators; // QualityIndicator object
int requiredEvaluations; // Use in the example of use of the
// indicators object (see below)
SolutionSet * population;
SolutionSet * offspringPopulation;
SolutionSet * unionSolution;
Operator * mutationOperator;
Operator * crossoverOperator;
Operator * selectionOperator;
Distance * distance = new Distance();
//Read the parameters
populationSize = *(int *) getInputParameter("populationSize");
maxEvaluations = *(int *) getInputParameter("maxEvaluations");
// TODO: indicators = (QualityIndicator) getInputParameter("indicators");
//Initialize the variables
population = new SolutionSet(populationSize);
evaluations = 0;
requiredEvaluations = 0;
//Read the operators
mutationOperator = operators_["mutation"];
crossoverOperator = operators_["crossover"];
selectionOperator = operators_["selection"];
// Create the initial solutionSet
Solution * newSolution;
for (int i = 0; i < populationSize; i++) {
newSolution = new Solution(problem_);
problem_->evaluate(newSolution);
problem_->evaluateConstraints(newSolution);
evaluations++;
population->add(newSolution);
} //for
// Generations
while (evaluations < maxEvaluations) {
// Create the offSpring solutionSet
offspringPopulation = new SolutionSet(populationSize);
Solution ** parents = new Solution*[2];
//obtain parents
parents[0] = (Solution *) (selectionOperator->execute(population));
parents[1] = (Solution *) (selectionOperator->execute(population));
// crossover
Solution ** offSpring = (Solution **) (crossoverOperator->execute(parents));
// mutation
mutationOperator->execute(offSpring[0]);
// evaluation
problem_->evaluate(offSpring[0]);
problem_->evaluateConstraints(offSpring[0]);
// insert child into the offspring population
offspringPopulation->add(offSpring[0]);
evaluations ++;
delete[] offSpring;
delete[] parents;
// Create the solutionSet union of solutionSet and offSpring
unionSolution = population->join(offspringPopulation);
delete offspringPopulation;
// Ranking the union
Ranking * ranking = new Ranking(unionSolution);
int remain = populationSize;
int index = 0;
SolutionSet * front = NULL;
for (int i=0;i<population->size();i++) {
delete population->get(i);
}
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(new Solution(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());
Comparator * c = new CrowdingComparator();
front->sort(c);
delete c;
for (int k = 0; k < remain; k++) {
population->add(new Solution(front->get(k)));
} // for
remain = 0;
} // if
delete ranking;
delete unionSolution;
// This piece of code shows how to use the indicator object into the code
// of NSGA-II. In particular, it finds the number of evaluations required
// by the algorithm to obtain a Pareto front with a hypervolume higher
// than the hypervolume of the true Pareto front.
// TODO:
// if ((indicators != NULL) &&
// (requiredEvaluations == 0)) {
// double HV = indicators.getHypervolume(population);
// if (HV >= (0.98 * indicators.getTrueParetoFrontHypervolume())) {
// requiredEvaluations = evaluations;
// } // if
// } // if
} // while
delete distance;
// Return as output parameter the required evaluations
// TODO:
//setOutputParameter("evaluations", requiredEvaluations);
// Return the first non-dominated front
Ranking * ranking = new Ranking(population);
SolutionSet * result = new SolutionSet(ranking->getSubfront(0)->size());
for (int i=0;i<ranking->getSubfront(0)->size();i++) {
result->add(new Solution(ranking->getSubfront(0)->get(i)));
}
delete ranking;
delete population;
return result;
} // execute
/*
* Runs the GDE3 algorithm.
* @return a <code>SolutionSet</code> that is a set of non dominated solutions
* as a result of the algorithm execution
*/
SolutionSet * GDE3::execute() {
int populationSize;
int maxIterations;
int evaluations;
int iterations;
SolutionSet * population;
SolutionSet * offspringPopulation;
Distance * distance;
Comparator * dominance;
Operator * crossoverOperator;
Operator * selectionOperator;
distance = new Distance();
dominance = new DominanceComparator();
Solution ** parent;
//Read the parameters
populationSize = *(int *) getInputParameter("populationSize");
maxIterations = *(int *) getInputParameter("maxIterations");
//Initialize the variables
population = new SolutionSet(populationSize);
evaluations = 0;
iterations = 0;
//Read the operators
crossoverOperator = operators_["crossover"];
selectionOperator = operators_["selection"];
// Create the initial solutionSet
Solution * newSolution;
for (int i = 0; i < populationSize; i++) {
newSolution = new Solution(problem_);
problem_->evaluate(newSolution);
problem_->evaluateConstraints(newSolution);
evaluations++;
population->add(newSolution);
} //for
// Generations ...
while (iterations < maxIterations) {
// Create the offSpring solutionSet
offspringPopulation = new SolutionSet(populationSize * 2);
for (int i = 0; i < populationSize; i++){
// Obtain parents. Two parameters are required: the population and the
// index of the current individual
void ** object1 = new void*[2];
object1[0] = population;
object1[1] = &i;
parent = (Solution **) (selectionOperator->execute(object1));
delete[] object1;
Solution * child ;
// Crossover. Two parameters are required: the current individual and the
// array of parents
void ** object2 = new void*[2];
object2[0] = population->get(i);
object2[1] = parent;
child = (Solution *) (crossoverOperator->execute(object2));
delete[] object2;
delete[] parent;
problem_->evaluate(child) ;
problem_->evaluateConstraints(child);
evaluations++ ;
// Dominance test
int result ;
result = dominance->compare(population->get(i), child) ;
if (result == -1) { // Solution i dominates child
offspringPopulation->add(new Solution(population->get(i)));
delete child;
} // if
else if (result == 1) { // child dominates
offspringPopulation->add(child) ;
} // else if
else { // the two solutions are non-dominated
offspringPopulation->add(child) ;
offspringPopulation->add(new Solution(population->get(i)));
} // else
} // for
// Ranking the offspring population
Ranking * ranking = new Ranking(offspringPopulation);
int remain = populationSize;
int index = 0;
SolutionSet * front = NULL;
for (int i = 0; i < populationSize; i++) {
delete population->get(i);
}
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(new Solution(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
while (front->size() > remain) {
distance->crowdingDistanceAssignment(front,problem_->getNumberOfObjectives());
Comparator * crowdingComparator = new CrowdingComparator();
int indexWorst = front->indexWorst(crowdingComparator);
delete crowdingComparator;
delete front->get(indexWorst);
front->remove(indexWorst);
}
for (int k = 0; k < front->size(); k++) {
population->add(new Solution(front->get(k)));
}
remain = 0;
} // if
delete ranking;
delete offspringPopulation;
iterations ++ ;
} // while
delete dominance;
delete distance;
// Return the first non-dominated front
Ranking * ranking = new Ranking(population);
SolutionSet * result = new SolutionSet(ranking->getSubfront(0)->size());
for (int i=0;i<ranking->getSubfront(0)->size();i++) {
result->add(new Solution(ranking->getSubfront(0)->get(i)));
}
delete ranking;
delete population;
return result;
} // execute
