Main Page | Namespace List | Class Hierarchy | Compound List | File List | Compound Members | File Members

Individual.cpp

Go to the documentation of this file.
00001 /*
00002  * @file    Individual.h
00003  * @author  Antonio Jesus Nebro Urbaneja
00004  * @version 1.0
00005  * @date    29 January 2004
00006  * @brief   Class representing an individual
00007  */
00008  
00009 #include <Individual.h>
00010 
00017 Individual::Individual(MultiobjectiveProblem * problem, Random * random) {
00018   int i ;
00019   
00020   problem_    = problem ; 
00021   random_     = random  ;
00022   chromosome_ = new Chromosome(problem_, random_) ;
00023   fitness_    = new double[problem_->numberOfFunctions_] ;
00024   
00025   if ((fitness_ == NULL) || (chromosome_ == NULL)) {
00026     cerr << "Individual::Individual-> error when asking for memory" << endl ;
00027     exit(-1) ;
00028   } // if
00029   
00030   for (i = 0; i <problem_->numberOfFunctions_; i++)
00031     fitness_[i] = 0.0 ;
00032 
00033 #ifdef __MPI__
00034 this->calculateSize() ;
00035 #endif        
00036 } // Individual::Individual
00037 
00044 Individual::Individual(Individual & individual) {
00045   int i ;
00046   
00047   problem_    = individual.problem_ ;
00048   chromosome_ = new Chromosome(individual.chromosome_) ;
00049   fitness_    = new double[individual.problem_->numberOfFunctions_] ;
00050   
00051   if ((fitness_ == NULL) || (chromosome_ == NULL)) {
00052     cerr << "Individual::Individual-> error when asking for memory" << endl ;
00053     exit(-1) ;
00054   } // if  
00055 
00056   for (i = 0; i <problem_->numberOfFunctions_; i++)
00057     fitness_[i] = individual.fitness_[i] ;
00058 
00059 #ifdef __MPI__
00060 this->calculateSize() ;
00061 #endif        
00062 } // Individual::Individual
00063 
00070 Individual::Individual(Individual * individual) {
00071   int i ;
00072   
00073   problem_    = individual->problem_ ;
00074   chromosome_ = new Chromosome(individual->chromosome_) ;
00075   fitness_    = new double[individual->problem_->numberOfFunctions_] ;
00076   
00077   if ((fitness_ == NULL) || (chromosome_ == NULL)) {
00078     cerr << "Individual::Individual-> error when asking for memory" << endl ;
00079     exit(-1) ;
00080   } // if  
00081 
00082   for (i = 0; i <problem_->numberOfFunctions_; i++)
00083     fitness_[i] = individual->fitness_[i] ;
00084 
00085 #ifdef __MPI__
00086 this->calculateSize() ;
00087 #endif        
00088 } // Individual::Individual
00089 
00095 Individual::~Individual() {
00096   delete chromosome_ ;  
00097   delete [] fitness_ ;
00098 #ifdef __MPI__
00099   delete [] messageBuffer_ ;
00100 #endif
00101 } // Individual::~Individual
00102 
00107 void Individual::setFitness(double * fitness) {
00108   int i ;
00109   for (i = 0; i < problem_->numberOfFunctions_; i++) {
00110     fitness_[i] = fitness[i] ;
00111 //cout << fitness_[i] << " ";
00112   } //for
00113 } // Individual::setFitness
00114 
00119 double * Individual::getFitness() const {
00120   return fitness_;
00121 } // getFitness
00122 
00123 int Individual::bitFlipMutation(double mutationProbability) {
00124   int i         ;
00125   int mutations ; 
00126   
00127   mutations = 0 ;
00128   for (i = 0; i < chromosome_->length_; i++) {
00129     mutations += chromosome_->gene_[i]->bitFlipMutation(mutationProbability) ;
00130   } // for
00131   
00132   return mutations ;
00133 } // Individual::bitFlipMutationn
00134 
00135 int Individual::uniformMutation(double mutationProbability, 
00136                                 double perturbation) {
00137   int i         ;
00138   int mutations ; 
00139   
00140   mutations = 0 ;
00141   for (i = 0; i < chromosome_->length_; i++) {
00142     mutations += chromosome_->gene_[i]->uniformMutation(mutationProbability, 
00143                                                        perturbation) ;
00144   } // for
00145   
00146   return mutations ;
00147 } // Individual::uniformMutation
00148 
00149 int Individual::randomMutation(double mutationProbability) {
00150   int i         ;
00151   int mutations ; 
00152   
00153   mutations = 0 ;
00154   for (i = 0; i < chromosome_->length_; i++) {
00155     mutations += chromosome_->gene_[i]->randomMutation(mutationProbability) ;
00156   } // for
00157   
00158   return mutations ;
00159 } // Individual::randomMutation
00160 
00161 
00170 int Individual::polynomialMutation(double mutationProbability, 
00171                                    double distributionIndex) {
00172   int i         ;
00173   int mutations ; 
00174    
00175   mutations = 0 ;
00176   for (i = 0; i < chromosome_->length_; i++) {
00177     mutations += chromosome_->gene_[i]->polynomialMutation(mutationProbability,
00178                                                           distributionIndex) ;
00179   } // for
00180   
00181   return mutations ;                                   
00182 } // Individual::polynomialMutation
00183 
00184 bool Individual::identicalFitness(Individual * individual) {
00185   int i ;
00186 
00187   for (i = 0; i < problem_->numberOfFunctions_; i++)
00188     if (fitness_[i] != individual->fitness_[i])
00189        return false ;
00190 
00191   return true ;  
00192 } // Individual::identicalFitness
00193 
00194 
00206 int Individual::constraintComparison(Individual * individual) {
00207   int constraintsFirstIndividual  ;
00208   int constraintsSecondIndividual ;        
00209   
00210   int result ;
00211   
00212   result = 0 ;
00213   constraintsFirstIndividual  = problem_->numberOfNonSatisfiedConstraints(
00214                                 this) ;
00215   constraintsSecondIndividual = problem_->numberOfNonSatisfiedConstraints(
00216                                 individual) ;
00217   if (constraintsFirstIndividual < constraintsSecondIndividual)
00218     result = 1 ;   // Current dominates 
00219   else if (constraintsFirstIndividual > constraintsSecondIndividual)
00220     result = -1 ;  // Current is dominated
00221   return result ;                                     
00222 } // Individual::constraintComparison                                  
00223 
00231 int Individual::dominanceTest(Individual * individual) {
00232   int i       ;                        
00233   int best    ;
00234   int last    ;                        
00235   int current ; 
00236   int result  ; 
00237   
00238   bool finished ;
00239 
00240   finished = false ;
00241  
00242   if (problem_->numberOfConstraints_ > 0) {
00243     result = this->constraintComparison(individual) ;
00244     if (result != 0)
00245       finished = true ;
00246   } // if
00247  
00248   last = 0 ;
00249   i    = 0 ; 
00250    
00251   while (!finished) {
00252     if (this->fitness_[i] < individual->fitness_[i])
00253       current = 1 ;
00254     else if (this->fitness_[i] > individual->fitness_[i])
00255       current = -1 ;
00256     else
00257       current = 0 ;
00258     
00259     if ((current != 0) && (current == -last)) {
00260       finished = true ;
00261       result   = 0    ;
00262     } // if
00263     //if ((current == 0) || (current == last)){
00264     else {
00265       last = current ;
00266       
00267       i ++ ;
00268       if (i == this->problem_->numberOfFunctions_) {
00269         finished = true ;    
00270         result   = last ;
00271       } // if
00272     } // else
00273   } // while 
00274   
00275   return result ;  
00276 } // Individual::dominanceTest
00277 
00278 
00279 Individual & Individual::operator=(Individual &individual) {
00280   int i ;
00281   
00282   problem_     = individual.problem_ ;
00283   *chromosome_ = *(individual.chromosome_) ;
00284   
00285   for (i = 0; i <problem_->numberOfFunctions_; i++)
00286     fitness_[i] = individual.fitness_[i] ;  
00287 } // Individual::operator=
00288 
00289 
00290 ostream& operator<< (ostream& outputStream, Individual& individual) {
00291   int i ;
00292   outputStream << *(individual.chromosome_) ;
00293   outputStream << "Fitness: " ;
00294   for (i = 0; i < individual.problem_->numberOfFunctions_; i++)
00295     outputStream << individual.fitness_[i] << " " ;
00296   outputStream << endl ;
00297 } // operator<< 
00298 
00299 void Individual::printFitness() {
00300   int i ;
00301   cout << "Fitness: " ;
00302   for (i = 0; i < problem_->numberOfFunctions_; i++)
00303     cout << fitness_[i] << " " ;
00304   cout << endl ;
00305 } // Individual::printFitness
00306 
00307 #ifdef __MPI__
00308 void Individual::send(int address) {
00309   MPI_Request request ;
00310   MPI_Isend(fitness_, 
00311            problem_->numberOfFunctions_,
00312            MPI_DOUBLE,
00313            address,
00314            1,
00315            MPI_COMM_WORLD,
00316            &request) ;
00317   chromosome_->send(address) ;             
00318 } // send
00319   
00320 void Individual::receive(int address) {
00321   MPI_Status status ;
00322    
00323   MPI_Recv(fitness_, 
00324            problem_->numberOfFunctions_,
00325            MPI_DOUBLE,
00326            address,
00327            1,
00328            MPI_COMM_WORLD,
00329            &status) ;    
00330   chromosome_->receive(address) ;
00331 }
00332   
00333 void Individual::calculateSize() {
00334   int size ;
00335   
00336   MPI_Pack_size(problem_->numberOfFunctions_, MPI_DOUBLE, MPI_COMM_WORLD, &size) ;
00337   dataSize_ = size ;
00338     
00339   chromosome_->calculateSize() ;
00340   dataSize_ += chromosome_->getSize() ;
00341   
00342   messageBuffer_ = new char[dataSize_] ;
00343   bufferOffset_  = 0 ;
00344 }
00345   
00346 int Individual::getSize() {
00347   return dataSize_ ;
00348 } // 
00349 
00350 void Individual::send2(int address) {
00351   MPI_Request request ;
00352   bufferOffset_ = 0 ;
00353   chromosome_->packData(messageBuffer_, &bufferOffset_, dataSize_) ;
00354   MPI_Pack(fitness_, 
00355            problem_->numberOfFunctions_, 
00356            MPI_DOUBLE, 
00357            messageBuffer_, 
00358            dataSize_, 
00359            &bufferOffset_, 
00360            MPI_COMM_WORLD) ;
00361 
00362   MPI_Isend(messageBuffer_, 
00363            bufferOffset_,
00364            MPI_PACKED,
00365            address,
00366            1,
00367            MPI_COMM_WORLD,
00368            &request) ;         
00369 } // send
00370   
00371 void Individual::receive2(int address) {
00372   MPI_Status status ;
00373    
00374   MPI_Recv(messageBuffer_, 
00375            dataSize_,
00376            MPI_PACKED,
00377            address,
00378            1,
00379            MPI_COMM_WORLD,
00380            &status) ;
00381                
00382   bufferOffset_ = 0 ;
00383   chromosome_->unpackData(messageBuffer_, &bufferOffset_, dataSize_) ;
00384   MPI_Unpack(messageBuffer_, 
00385              dataSize_, 
00386              &bufferOffset_, 
00387              fitness_, 
00388              problem_->numberOfFunctions_, 
00389              MPI_DOUBLE, 
00390              MPI_COMM_WORLD) ;
00391 }
00392 #endif    

Generated on Wed Feb 11 10:38:01 2004 for Paes by doxygen 1.3.3