SolutionSet *PhyloMOCHC::execute() {
int populationSize;
int iterations;
int maxEvaluations;
int convergenceValue;
int minimumDistance;
int evaluations;
int IntervalOptSubsModel;
double preservedPopulation;
double initialConvergenceCount;
bool condition = false;
SolutionSet *solutionSet, *offSpringPopulation, *newPopulation;
Comparator * crowdingComparator = new CrowdingComparator();
SolutionSet * population;
SolutionSet * offspringPopulation;
SolutionSet * unionSolution;
Operator * cataclysmicMutation;
Operator * crossover;
Operator * parentSelection;
//Read the parameters
populationSize = *(int *) getInputParameter("populationSize");
maxEvaluations = *(int *) getInputParameter("maxEvaluations");
IntervalOptSubsModel = *(int *) getInputParameter("intervalupdateparameters");
convergenceValue = *(int *) getInputParameter("convergenceValue");
initialConvergenceCount = *(double *)getInputParameter("initialConvergenceCount");
preservedPopulation = *(double *)getInputParameter("preservedPopulation");
//Read the operators
cataclysmicMutation = operators_["mutation"];
crossover = operators_["crossover"];
parentSelection = operators_["selection"];
iterations = 0;
evaluations = 0;
// calculating the maximum problem sizes ....
int size = 0;
Solution * sol = new Solution(problem_);
PhyloTree *Pt1 = (PhyloTree *)sol->getDecisionVariables()[0];
TreeTemplate<Node> * tree1 = Pt1->getTree();
BipartitionList* bipL1 = new BipartitionList(*tree1, true);
bipL1->removeTrivialBipartitions();
size = bipL1->getNumberOfBipartitions() * 2;
delete bipL1;
delete sol;
minimumDistance = (int) std::floor(initialConvergenceCount*size);
cout << "Minimun Distance " << minimumDistance << endl;
// Create the initial solutionSet
Solution * newSolution;
ApplicationTools::displayTask("Initial Population", true);
population = new SolutionSet(populationSize);
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();
while (!condition) {
cout << "Evaluating " << evaluations << endl;
offSpringPopulation = new SolutionSet(populationSize);
Solution **parents = new Solution*[2];
for (int i = 0; i < population->size()/2; i++) {
parents[0] = (Solution *) (parentSelection->execute(population));
parents[1] = (Solution *) (parentSelection->execute(population));
if (RFDistance(parents[0],parents[1])>= minimumDistance) {
Solution ** offSpring = (Solution **) (crossover->execute(parents));
((Phylogeny *)problem_)->Optimization(offSpring[0]); //Optimize and update the scores (Evaluate OffSpring)
((Phylogeny *)problem_)->Optimization(offSpring[1]);
/*problem_->evaluate(offSpring[0]);
problem_->evaluateConstraints(offSpring[0]);
problem_->evaluate(offSpring[1]);
problem_->evaluateConstraints(offSpring[1]);*/
evaluations+=2;
offSpringPopulation->add(offSpring[0]);
offSpringPopulation->add(offSpring[1]);
delete[] offSpring;
}
}
SolutionSet *join = population->join(offSpringPopulation);
delete offSpringPopulation;
newPopulation = rankingAndCrowdingSelection(join,populationSize);
delete join;
if (equals(*population,*newPopulation)) {
minimumDistance--;
}
if (minimumDistance <= -convergenceValue) {
minimumDistance = (int) (1.0/size * (1-1.0/size) * size);
int preserve = (int) std::floor(preservedPopulation*populationSize);
newPopulation->clear();
population->sort(crowdingComparator);
for (int i = 0; i < preserve; i++) {
newPopulation->add(new Solution(population->get(i)));
}
for (int i = preserve; i < populationSize; i++) {
Solution * solution = new Solution(population->get(i));
cataclysmicMutation->execute(solution);
problem_->evaluate(solution);
problem_->evaluateConstraints(solution);
newPopulation->add(solution);
}
}
//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<newPopulation->size(); i++){
sol = newPopulation->get(i);
Lk= p->BranchLengthOptimization(sol,p->OptimizationMetodoOptRamas,p->OptimizationNumIterOptRamas,p->OptimizationTolerenciaOptRamas);
sol->setObjective(1,Lk*-1);
}
cout << "Update Interval Done!!" << endl;
}
iterations++;
delete population;
population = newPopulation;
if (evaluations >= maxEvaluations) {
condition = true;
}
}
return population;
}
SolutionSet *MOCHC::execute() {
int populationSize;
int iterations;
int maxEvaluations;
int convergenceValue;
int minimumDistance;
int evaluations;
double preservedPopulation;
double initialConvergenceCount;
bool condition = false;
SolutionSet *solutionSet, *offSpringPopulation, *newPopulation;
Comparator * crowdingComparator = new CrowdingComparator();
SolutionSet * population;
SolutionSet * offspringPopulation;
SolutionSet * unionSolution;
Operator * cataclysmicMutation;
Operator * crossover;
Operator * parentSelection;
//Read the parameters
populationSize = *(int *) getInputParameter("populationSize");
maxEvaluations = *(int *) getInputParameter("maxEvaluations");
convergenceValue = *(int *) getInputParameter("convergenceValue");
initialConvergenceCount = *(double *)getInputParameter("initialConvergenceCount");
preservedPopulation = *(double *)getInputParameter("preservedPopulation");
//Read the operators
cataclysmicMutation = operators_["mutation"];
crossover = operators_["crossover"];
parentSelection = operators_["parentSelection"];
iterations = 0;
evaluations = 0;
// calculating the maximum problem sizes ....
Solution * sol = new Solution(problem_);
int size = 0;
for (int var = 0; var < problem_->getNumberOfVariables(); var++) {
Binary *binaryVar;
binaryVar = (Binary *)sol->getDecisionVariables()[var];
size += binaryVar->getNumberOfBits();
}
minimumDistance = (int) std::floor(initialConvergenceCount*size);
// Create the initial solutionSet
Solution * newSolution;
population = new SolutionSet(populationSize);
for (int i = 0; i < populationSize; i++) {
newSolution = new Solution(problem_);
problem_->evaluate(newSolution);
problem_->evaluateConstraints(newSolution);
evaluations++;
population->add(newSolution);
} //for
while (!condition) {
offSpringPopulation = new SolutionSet(populationSize);
Solution **parents = new Solution*[2];
for (int i = 0; i < population->size()/2; i++) {
parents[0] = (Solution *) (parentSelection->execute(population));
parents[1] = (Solution *) (parentSelection->execute(population));
if (hammingDistance(*parents[0],*parents[1])>= minimumDistance) {
Solution ** offSpring = (Solution **) (crossover->execute(parents));
problem_->evaluate(offSpring[0]);
problem_->evaluateConstraints(offSpring[0]);
problem_->evaluate(offSpring[1]);
problem_->evaluateConstraints(offSpring[1]);
evaluations+=2;
offSpringPopulation->add(offSpring[0]);
offSpringPopulation->add(offSpring[1]);
}
}
SolutionSet *join = population->join(offSpringPopulation);
delete offSpringPopulation;
newPopulation = rankingAndCrowdingSelection(join,populationSize);
delete join;
if (equals(*population,*newPopulation)) {
minimumDistance--;
}
if (minimumDistance <= -convergenceValue) {
minimumDistance = (int) (1.0/size * (1-1.0/size) * size);
int preserve = (int) std::floor(preservedPopulation*populationSize);
newPopulation->clear(); //do the new in c++ really hurts me(juanjo)
population->sort(crowdingComparator);
for (int i = 0; i < preserve; i++) {
newPopulation->add(new Solution(population->get(i)));
}
for (int i = preserve; i < populationSize; i++) {
Solution * solution = new Solution(population->get(i));
cataclysmicMutation->execute(solution);
problem_->evaluate(solution);
problem_->evaluateConstraints(solution);
newPopulation->add(solution);
}
}
iterations++;
delete population;
population = newPopulation;
if (evaluations >= maxEvaluations) {
condition = true;
}
}
return population;
}
