Ssmo.cpp

Go to the documentation of this file.

#include <Ssmo.h>

Ssmo::Ssmo(MultiobjectiveProblem * problemToSolve, 
             MutationOperator      mutationOperator) :
             MoEA(problemToSolve, mutationOperator, NO_CROSSOVER) {
  problem_ = problemToSolve   ;
  
  distributionIndexForMutation_  = 20.0    ; // Between 0.5 and 100
  
  populationSize_             = 100   ;
  maximumPopulationSize_      = 200   ;
  qualityReferenceSetSize_    = 10    ;
  diversityReferenceSetSize_  = 10    ;
  maximumNumberOfIterations_  = 15    ;
  maximumNumberOfFitnessEvaluations_ = 20000 ;
  
  numberOfSubranges_          = 4  ;
  improvementIterations_      = 10 ;
  
  mutationProbability_ = problem_->calculateMutationProbability() ;

  random_.initrandom(time(NULL)) ;
  //random_.initrandom(2) ;
  random_.Rseed = random_.randreal2() ;
  random_.randomize() ;
  
  readConfigurationData() ;
  
  population_ = new Population("Population",
                               0, 
                               maximumPopulationSize_, 
                               &random_, 
                               problem_);
  dummyPopulation_ = new Population("DummyPopulation_",
                                    0, 
                                    maximumPopulationSize_, 
                                    &random_, 
                                    problem_);
  
  qualityReferenceSet_ = new Population("QualityReferenceSet",
                                        0, 
                                        qualityReferenceSetSize_, 
                                        &random_, 
                                        problem_)  ;
  diversityReferenceSet_ = new Population("DiversityReferenceSet",
                                          0, 
                                          diversityReferenceSetSize_, 
                                          &random_, 
                                          problem_)  ;
  
  improvedCombinedSolutions_ = new Population("ImprovedCombinedSolutions",
                                              0, 
                                              10000,
                                              &random_,
                                              problem_) ;

  combinedSolutions_ = new Population("CombinedSolutions",
                                      0, 
                                      10000,
                                      &random_,
                                      problem_) ;
  
  if (!population_ || !qualityReferenceSet_ || !diversityReferenceSet_ ||
      !improvedCombinedSolutions_ || !combinedSolutions_) {
    cerr << "Ssmo::Ssmo->Error creating populations" << endl ;
    exit(-1) ;
  } // if
} // Ssmo::Ssmo

Ssmo::~Ssmo() {
} // Paes::~Ssmo

void Ssmo::start()  {
  Individual * newIndividual      ;
  Individual * improvedIndividual ;
  
  cout << "Ssmo start method" << endl ;

  startTime_ = time(NULL) ;

  // STEP 1
  for (int i = 0; i < populationSize_; i++) {
    newIndividual = diversificationGeneration() ;
    problem_->evaluateConstraints(newIndividual) ;
    problem_->evaluate(newIndividual) ;
    numberOfFitnessEvaluations_ ++ ;

    improvedIndividual = improvement(newIndividual) ;
    addImprovedIndividual(population_, improvedIndividual) ;
  } // for

  // STEP 2
  int newIndividuals ;
  numberOfIterations_ = 0 ;
  
  while (numberOfFitnessEvaluations_ < maximumNumberOfFitnessEvaluations_) {
  //)for (int iterations = 0; 
  //     iterations < maximumNumberOfIterations_; 
  //     iterations++) {
    numberOfIterations_ ++ ;
    int subIterations = 0 ;  
 
    referenceSetUpdate(true) ;  
    removeIndividuals(population_, populationSize_) ;

    newIndividuals = subsetGeneration() ; 

    while (newIndividuals > 0) {
      int size = combinedSolutions_->getPopulationSize() ;

      for (int i = 0; i < size; i++) {
        if ((numberOfFitnessEvaluations_ % printFrequency_) == 0) {
          cout << "Evaluations: " << numberOfFitnessEvaluations_ 
              << "\t iteration: " << numberOfIterations_ << ","<< subIterations 
              << "\t Individuals: "  << newIndividuals << endl ;
          printToFiles("VAR", "FUN") ;        
        } // if
      
        newIndividual = (Individual *)combinedSolutions_->extractIth(0) ;     
      
        problem_->evaluate(newIndividual) ;
        problem_->evaluateConstraints(newIndividual) ;
        numberOfFitnessEvaluations_ ++ ;       

        improvedIndividual = improvement(newIndividual) ;
        improvedCombinedSolutions_->addIndividual(improvedIndividual) ;
      } // for 
      referenceSetUpdate(false) ;           
      newIndividuals = subsetGeneration() ;       

      subIterations++ ;
      if (numberOfFitnessEvaluations_ > maximumNumberOfFitnessEvaluations_)
        newIndividuals = 0 ;
    } // while
    
    while (qualityReferenceSet_->getPopulationSize() > 0) {
      Individual * individual ; 
      individual = (Individual*)qualityReferenceSet_->extractIth(0) ;
      individual->hasBeenSelected_ = false ;
      addImprovedIndividual(population_, individual) ;
    } // while
    int v = removeDominatedIndividuals(population_) ;    
    diversityReferenceSet_->removeAllIndividuals() ;
    
    while (population_->getPopulationSize() < (populationSize_ - 1)) {
      newIndividual = diversificationGeneration() ;

      problem_->evaluate(newIndividual) ;
      problem_->evaluateConstraints(newIndividual) ;
      numberOfFitnessEvaluations_ ++ ;

      improvedIndividual = improvement(newIndividual) ;
      addImprovedIndividual(population_, improvedIndividual) ;    
    } // while
  } // while
  removeDominatedIndividuals(population_) ;
  endTime_ = time(NULL) ;
  
  cout << "Fitness evaluations: " << numberOfFitnessEvaluations_ << endl ;
}  // Ssmo::start

void Ssmo::distanceToPopulation(Population * population,
                                Individual * individual) {
  // Intially, the distance of an individual is MAX_REAL. Otherwise, it is 
  // assumed that we are measuring the distance to more than one population 
  double minimumDistance = individual->distance_ ;

  for (int i = 0; i < population->getPopulationSize(); i++) {
    double tmp = 0.0 ;
    
    for (int j = 0; j < problem_->numberOfVariables_; j++)
      tmp += pow(individual->chromosome_->gene_[j]->getRealAllele() - 
                 population->getIth(i)->chromosome_->gene_[j]->getRealAllele(),
                 2) ;      
/*
    for (int j = 0; j < problem_->numberOfFunctions_; j++)
      tmp += pow(individual->fitness_[j] - 
                 population->getIth(i)->fitness_[j],
                 2) ;      
*/
                 
    if (minimumDistance > tmp)
      minimumDistance = tmp ;  
  } // for
  
  individual->distance_ = minimumDistance ;
} // Ssmo::distanceToPopulation

void Ssmo::addImprovedIndividual(Population * population, 
                                 Individual * individual) {
  if (!population_->thereIsAnEqualFitnessIndividual(individual, NULL)) {
    population->addIndividual(individual) ;

    if (population->getPopulationSize() == population->maximumPopulationSize_) {
      removeIndividuals(population_, populationSize_) ;
    } // if
  } // if
  else {
    delete individual ;
  } // else  
} // Ssmo::addImprovedIndividual


void Ssmo::printToFiles(char * genotypeFileName,
                        char * fitnessFileName) {
  population_->sortByFitness(0) ;                        
  cout << "----------------- " <<  population_->getPopulationSize() << endl ;
  printVariablesToFile(genotypeFileName, population_) ;
  printFunctionValuesToFile(fitnessFileName, population_) ;
} // Ssmo::printToFiles


void Ssmo::printStatistics() {
  cout << "   RESULTS" << endl ;
  cout << "-------------" << endl ;
  cout << "Time       : " << (long)(endTime_ - startTime_) << " seconds" << endl ;
  cout << "Iterations : " << numberOfIterations_ << endl ;
  cout << "Evaluations: " << numberOfFitnessEvaluations_ << endl ;
  cout << "Mutations: : " << numberOfMutations_ << endl ;
//
} // Ssmo::printStatistics

void Ssmo::readConfigurationData() {
  ifstream configurationFile ;
  
  configurationFile.open("Ssmo.cfg", ios::in) ;
  if (configurationFile.fail()) {
    cerr << "Ssmo::readConfigurationFile-> the file 'Ssmo.cfg' does "
         << "not exist" ;     
    cerr << endl ;
    exit(-1) ;
  } // if
  else
    cout << "Processing configuration file (Ssmo.cfg) ..." << endl ;

  string key ;
  string tmp ;
  string value ;
  
  configurationFile >> key ;

  while (!configurationFile.eof()) {
    configurationFile >> tmp ; // " the symbol = "

    if (key.compare("MAXIMUM_NUMBER_OF_ITERATIONS") == 0) {
      configurationFile >> maximumNumberOfIterations_ ;
      cout << key << "\t" << maximumNumberOfIterations_ << endl ;
    }    
    else if (key.compare("MAXIMUM_NUMBER_OF_EVALUATIONS") == 0) {
      configurationFile >> maximumNumberOfFitnessEvaluations_ ;
      cout << key << "\t" << maximumNumberOfFitnessEvaluations_ << endl ;
    }    
    else if (key.compare("POPULATION_SIZE") == 0) {
      configurationFile >> populationSize_ ;
      cout << key << "\t" << populationSize_ << endl ;
    }    
    else if (key.compare("MAXIMUM_POPULATION_SIZE") == 0) {
      configurationFile >> maximumPopulationSize_ ;
      cout << key << "\t" << maximumPopulationSize_ << endl ;
    }    
    else if (key.compare("QUALITY_REFERENCE_SET_SIZE") == 0) {
      configurationFile >> qualityReferenceSetSize_ ;
      cout << key << "\t" << qualityReferenceSetSize_ << endl ;
    }    
    else if (key.compare("DIVERSITY_REFERENCE_SET_SIZE") == 0) {
      configurationFile >> diversityReferenceSetSize_ ;
      cout << key << "\t" << diversityReferenceSetSize_ << endl ;
    }    
    else if (key.compare("DISTRIBUTION_INDEX_FOR_MUTATION") == 0) {
      configurationFile >> distributionIndexForMutation_ ;
      cout << key << "\t" << distributionIndexForMutation_ << endl ; 
    } 
    else if (key.compare("PRINT_FREQUENCY") == 0) {
      configurationFile >> printFrequency_ ;
      cout << key << "\t" << printFrequency_ << endl ;
    }     
    else if (key.compare("NUMBER_OF_SUBRANGES") == 0) {
      configurationFile >> numberOfSubranges_ ;
      cout << key << "\t" << numberOfSubranges_ << endl ;
    } 
    else if (key.compare("IMPROVEMENT_ITERATIONS") == 0) {
      configurationFile >> improvementIterations_ ;
      cout << key << "\t" << improvementIterations_ << endl ;
    } 
    configurationFile >> key ;
  } // while
  
  configurationFile.close() ;
} // Ssmo::readConfigurationData

---

Our Software

 Mallba

 ssGA

 JGDS

 xxGA

 JCell

 MHTB

 DEME

JMetal

More...

Go Back