• Main Page
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

Chromosome.cpp

Go to the documentation of this file.
00001 
00009 #include <Chromosome.h>
00010 
00018 Chromosome::Chromosome(MultiobjectiveProblem * problem, Random * random) {
00019   problem_        = problem ;
00020   numberOfGenes_  = problem->numberOfVariables_ ;
00021   gene_           = new Gene*[numberOfGenes_] ;
00022   bitLength_      = 0 ;
00023   
00024   if (gene_ == NULL) {
00025     cerr << "Chromosome::Chromosome->Error when asking for memory" << endl ;
00026     exit(-1) ;
00027   } // if
00028   
00029   int i ;
00030   for (i = 0; i < numberOfGenes_ ; i++) {
00031     switch (problem_->variableType_[i]) {
00032     case BINARY:
00033       gene_[i] = new BinaryGene(problem->bitsPerVariable_[i], random) ;
00034       bitLength_ += problem->bitsPerVariable_[i] ;
00035       break ;
00036     case REAL:
00037       gene_[i] = new RealGene(problem_->lowerLimit_[i], 
00038                               problem_->upperLimit_[i],
00039                               random) ;
00040       break ;
00041     case BINARY_REAL:
00042       gene_[i] = new BinaryRealGene(problem->bitsPerVariable_[i],
00043                                     problem_->lowerLimit_[i], 
00044                                     problem_->upperLimit_[i],
00045                                     random) ;
00046       bitLength_ += problem->bitsPerVariable_[i] ;
00047       break ;
00048     case BINARY_GRAY_REAL:
00049       gene_[i] = new BinaryGrayRealGene(problem->bitsPerVariable_[i], 
00050                                         problem_->lowerLimit_[i], 
00051                                         problem_->upperLimit_[i],
00052                                         random) ;
00053       bitLength_ += problem->bitsPerVariable_[i] ;
00054       break ;
00055     case INTEGER:
00056       gene_[i] = new IntegerGene((int) problem_->lowerLimit_[i], 
00057                                  (int) problem_->upperLimit_[i],
00058                                  random) ;
00059       break ;
00060     case BINARY_INTEGER:
00061       gene_[i] = new BinaryIntegerGene(problem->bitsPerVariable_[i],
00062                                        (int) problem_->lowerLimit_[i], 
00063                                        (int)problem_->upperLimit_[i],
00064                                        random) ;
00065       bitLength_ += problem->bitsPerVariable_[i] ;
00066       break ;
00067     case BINARY_GRAY_INTEGER:
00068       gene_[i] = new BinaryGrayIntegerGene(problem->bitsPerVariable_[i], 
00069                                            (int)problem_->lowerLimit_[i], 
00070                                            (int)problem_->upperLimit_[i],
00071                                             random) ;
00072       bitLength_ += problem->bitsPerVariable_[i] ;
00073       break ;      
00074     default: 
00075       cerr << "Chromosome::Chromosome->variable type " 
00076            << problem_->variableType_[i] << " unknown" << endl ;
00077       exit(-1) ;
00078     } // switch
00079   } // for
00080 
00081 #ifdef __MPI__
00082 this->calculateSize() ;
00083 #endif    
00084 } // Chromosome::Chromosome
00085 
00092 Chromosome::Chromosome(Chromosome & chromosome) {
00093   problem_        = chromosome.problem_       ;
00094   numberOfGenes_  = chromosome.numberOfGenes_ ;
00095   gene_           = new Gene*[numberOfGenes_] ;
00096   bitLength_      = chromosome.bitLength_     ;
00097   
00098   if (gene_ == NULL) {
00099     cerr << "Chromosome::Chromosome->Error when asking for memory" << endl ;
00100     exit(-1) ;
00101   } // if
00102 
00103   int i ;
00104   for (i = 0; i < numberOfGenes_ ; i++) {
00105     switch (problem_->variableType_[i]) {
00106     case BINARY:
00107       gene_[i] = new BinaryGene((BinaryGene*)chromosome.gene_[i]) ;
00108       break ;
00109     case REAL:
00110       gene_[i] = new RealGene((RealGene*)chromosome.gene_[i]) ;
00111       break ;
00112     case BINARY_REAL:
00113       gene_[i] = new BinaryRealGene((BinaryRealGene*)chromosome.gene_[i]) ;
00114       break ;
00115     case BINARY_GRAY_REAL:
00116       gene_[i] =new BinaryGrayRealGene((BinaryGrayRealGene*)chromosome.gene_[i]);
00117       break ;
00118     case INTEGER:
00119       gene_[i] = new IntegerGene((IntegerGene*)chromosome.gene_[i]) ;
00120       break ;
00121     case BINARY_INTEGER:
00122       gene_[i] = new BinaryIntegerGene((BinaryIntegerGene*)chromosome.gene_[i]) ;
00123       break ;
00124     case BINARY_GRAY_INTEGER:
00125       gene_[i] =new BinaryGrayIntegerGene((BinaryGrayIntegerGene*)chromosome.gene_[i]);
00126       break ;
00127     default: 
00128       cerr << "Chromosome::Chromosome->variable type " 
00129            << problem_->variableType_[i] << " unknown" << endl ;
00130       exit(-1) ;
00131     } // switch
00132   } // for
00133 
00134 #ifdef __MPI__
00135 this->calculateSize() ;
00136 #endif    
00137 } // Chromosome::Chromosome
00138 
00145 Chromosome::Chromosome(Chromosome * chromosome) {
00146   problem_        = chromosome->problem_        ;
00147   numberOfGenes_  = chromosome->numberOfGenes_  ;
00148   gene_           = new Gene*[numberOfGenes_]   ;
00149   bitLength_      = chromosome->bitLength_      ;
00150 
00151   if (gene_ == NULL) {
00152     cerr << "Chromosome::Chromosome->Error when asking for memory" << endl ;
00153     exit(-1) ;
00154   } // if
00155 
00156   int i ;
00157   for (i = 0; i < numberOfGenes_ ; i++) {
00158     switch (problem_->variableType_[i]) {
00159     case BINARY:
00160       gene_[i] = new BinaryGene((BinaryGene*)chromosome->gene_[i]) ;
00161       break ;
00162     case REAL:
00163       gene_[i] = new RealGene((RealGene*)chromosome->gene_[i]) ;
00164       break ;
00165     case BINARY_REAL:
00166       gene_[i] = new BinaryRealGene((BinaryRealGene*)chromosome->gene_[i]) ;
00167       break ;
00168     case BINARY_GRAY_REAL:
00169       gene_[i] = new BinaryGrayRealGene((BinaryGrayRealGene*)chromosome->gene_[i]);
00170       break ;
00171     case INTEGER:
00172       gene_[i] = new IntegerGene((IntegerGene*)chromosome->gene_[i]) ;
00173       break ;
00174     case BINARY_INTEGER:
00175       gene_[i] = new BinaryIntegerGene((BinaryIntegerGene*)chromosome->gene_[i]) ;
00176       break ;
00177     case BINARY_GRAY_INTEGER:
00178       gene_[i] = new BinaryGrayIntegerGene((BinaryGrayIntegerGene*)chromosome->gene_[i]);
00179       break ;
00180     default: 
00181       cerr << "Chromosome::Chromosome->variable type " 
00182            << problem_->variableType_[i] << " unknown" << endl ;
00183       exit(-1) ;
00184     } // switch
00185   } // for
00186 
00187 #ifdef __MPI__
00188 this->calculateSize() ;
00189 #endif    
00190 } // Chromosome::Chromosome
00191 
00197 Chromosome::~Chromosome() {
00198   int i ;
00199   for (i = 0; i < numberOfGenes_; i++)
00200 //    delete gene_[i] ;  
00201     switch (problem_->variableType_[i]) {
00202     case BINARY:
00203       delete (BinaryGene *)gene_[i] ;
00204       break ;
00205     case REAL:
00206       delete (RealGene *)gene_[i] ;
00207       break ;
00208     case BINARY_REAL:
00209       delete (BinaryRealGene *)gene_[i] ;
00210       break ;
00211     case BINARY_GRAY_REAL:
00212       delete (BinaryGrayRealGene *)gene_[i] ;
00213       break ;
00214     case INTEGER:
00215       delete (IntegerGene *)gene_[i] ;
00216       break ;
00217     case BINARY_INTEGER:
00218       delete (BinaryIntegerGene *)gene_[i] ;
00219       break ;
00220     case BINARY_GRAY_INTEGER:
00221       delete (BinaryGrayIntegerGene *)gene_[i] ;
00222       break ;
00223     default: 
00224       cerr << "Chromosome::~Chromosome->variable type " 
00225            << problem_->variableType_[i] << " unknown" << endl ;
00226       exit(-1) ;
00227     } // switch
00228     
00229   delete [] gene_ ;  
00230 } // Chromosome::~Chromosome
00231 
00232 
00233 Chromosome & Chromosome::operator=(Chromosome & chromosome) {
00234   problem_        = chromosome.problem_        ;
00235   numberOfGenes_  = chromosome.numberOfGenes_  ;
00236   bitLength_      = chromosome.bitLength_      ;  
00237   int i ;
00238   for (i = 0; i < numberOfGenes_ ; i++) {
00239     switch (problem_->variableType_[i]) {
00240     case BINARY:
00241       *((BinaryGene *)gene_[i]) = *((BinaryGene*)chromosome.gene_[i]) ;
00242       break ;
00243     case REAL:
00244       *((RealGene *)gene_[i]) = *((RealGene*)chromosome.gene_[i]) ;
00245       break ;
00246     case BINARY_REAL:
00247       *((BinaryRealGene *)gene_[i]) = *((BinaryRealGene*)chromosome.gene_[i]);
00248       break ;
00249     case BINARY_GRAY_REAL:
00250       *((BinaryGrayRealGene *)gene_[i])=*((BinaryGrayRealGene*)chromosome.gene_[i]);
00251       break ;
00252     case INTEGER:
00253       *((IntegerGene *)gene_[i]) = *((IntegerGene*)chromosome.gene_[i]) ;
00254       break ;
00255     case BINARY_INTEGER:
00256       *((BinaryIntegerGene *)gene_[i]) = *((BinaryIntegerGene*)chromosome.gene_[i]);
00257       break ;
00258     case BINARY_GRAY_INTEGER:
00259       *((BinaryGrayIntegerGene *)gene_[i])=*((BinaryGrayIntegerGene*)chromosome.gene_[i]);
00260       break ;
00261     default: 
00262       cerr << "Chromosome->operator= -> variable type " 
00263            << problem_->variableType_[i] << " unknown" << endl ;
00264       exit(-1) ;
00265     } // switch
00266   } // for  
00267   
00268   return *this ;
00269 } // Chromosome::operator=
00270 
00271 bool Chromosome::operator==(Chromosome & chromosome) {
00272   //problem_        = chromosome.problem_        ;
00273   //numberOfGenes_  = chromosome.numberOfGenes_  ;
00274   //bitLength_      = chromosome.bitLength_      ;  
00275   int i ;
00276   for (i = 0; i < numberOfGenes_ ; i++) {
00277     switch (problem_->variableType_[i]) {
00278     case BINARY:
00279       if (*((BinaryGene *)gene_[i]) != *((BinaryGene*)chromosome.gene_[i]))
00280         return false ;
00281       break ;
00282     case REAL:
00283       if (*((RealGene *)gene_[i]) != *((RealGene*)chromosome.gene_[i]))
00284         return false ;
00285       break ;
00286     case BINARY_REAL:
00287       if (*((BinaryRealGene *)gene_[i]) != *((BinaryRealGene*)chromosome.gene_[i]))
00288         return false ;
00289       break ;
00290     case BINARY_GRAY_REAL:
00291       if (*((BinaryGrayRealGene *)gene_[i]) !=*((BinaryGrayRealGene*)chromosome.gene_[i]))
00292         return false ;
00293       break ;
00294     case INTEGER:
00295       if (*((IntegerGene *)gene_[i]) != *((IntegerGene*)chromosome.gene_[i]))
00296         return false ;
00297       break ;
00298     case BINARY_INTEGER:
00299       if (*((BinaryIntegerGene *)gene_[i]) != *((BinaryIntegerGene*)chromosome.gene_[i]))
00300         return false ;
00301       break ;
00302     case BINARY_GRAY_INTEGER:
00303       if (*((BinaryGrayIntegerGene *)gene_[i]) !=*((BinaryGrayIntegerGene*)chromosome.gene_[i]))
00304         return false ;
00305       break ;
00306     default: 
00307       cerr << "Chromosome->operator== -> variable type " 
00308            << problem_->variableType_[i] << " unknown" << endl ;
00309       exit(-1) ;
00310     } // switch
00311   } // for  
00312   
00313   return true ;
00314 } // Chromosome::operator==
00315 
00316 
00317 bool Chromosome::operator!=(Chromosome & chromosome) {
00318   //problem_        = chromosome.problem_        ;
00319   //numberOfGenes_  = chromosome.numberOfGenes_  ;
00320   //bitLength_      = chromosome.bitLength_      ;  
00321   int i ;
00322   for (i = 0; i < numberOfGenes_ ; i++) {
00323     switch (problem_->variableType_[i]) {
00324     case BINARY:
00325       if (*((BinaryGene *)gene_[i]) != *((BinaryGene*)chromosome.gene_[i]))
00326         return true ;
00327       break ;
00328     case REAL:
00329       if (*((RealGene *)gene_[i]) != *((RealGene*)chromosome.gene_[i]))
00330         return true ;
00331       break ;
00332     case BINARY_REAL:
00333       if (*((BinaryRealGene *)gene_[i]) != *((BinaryRealGene*)chromosome.gene_[i]))
00334         return true ;
00335       break ;
00336     case BINARY_GRAY_REAL:
00337       if (*((BinaryGrayRealGene *)gene_[i]) !=*((BinaryGrayRealGene*)chromosome.gene_[i]))
00338         return true ;
00339       break ;
00340     case INTEGER:
00341       if (*((IntegerGene *)gene_[i]) != *((IntegerGene*)chromosome.gene_[i]))
00342         return true ;
00343       break ;
00344     case BINARY_INTEGER:
00345       if (*((BinaryIntegerGene *)gene_[i]) != *((BinaryIntegerGene*)chromosome.gene_[i]))
00346         return true ;
00347       break ;
00348     case BINARY_GRAY_INTEGER:
00349       if (*((BinaryGrayIntegerGene *)gene_[i]) !=*((BinaryGrayIntegerGene*)chromosome.gene_[i]))
00350         return true ;
00351       break ;
00352     default: 
00353       cerr << "Chromosome->operator== -> variable type " 
00354            << problem_->variableType_[i] << " unknown" << endl ;
00355       exit(-1) ;
00356     } // switch
00357   } // for  
00358   
00359   return false ;
00360 } // Chromosome::operator!=
00361 
00362 ostream& operator<< (ostream& outputStream, Chromosome& chromosome) {
00363   int i ;
00364   
00365   outputStream << "Number of Genes: " << chromosome.numberOfGenes_ << endl ;
00366   for (i = 0; i < chromosome.numberOfGenes_; i++)
00367     if (chromosome.gene_[i]->geneType_ == BINARY) {
00368       outputStream << "BitLength: " << chromosome.bitLength_ << endl ;
00369       outputStream << *(BinaryGene*)(chromosome.gene_[i]) ;
00370     } // if
00371     else if (chromosome.gene_[i]->geneType_ == REAL)
00372       outputStream << *(RealGene*)(chromosome.gene_[i]) ;
00373     else if (chromosome.gene_[i]->geneType_ == INTEGER)
00374       outputStream << *(IntegerGene*)(chromosome.gene_[i]) ;
00375     else if (chromosome.gene_[i]->geneType_ == BINARY_REAL) {
00376       outputStream << "BitLength: " << chromosome.bitLength_ << endl ;
00377       outputStream << *(BinaryRealGene*)(chromosome.gene_[i]) ;
00378     } // else if
00379     else if (chromosome.gene_[i]->geneType_ == BINARY_GRAY_REAL) {
00380       outputStream << "BitLength: " << chromosome.bitLength_ << endl ;
00381       outputStream << *(BinaryGrayRealGene*)(chromosome.gene_[i]) ;
00382     } // else if
00383     else if (chromosome.gene_[i]->geneType_ == BINARY_INTEGER) {
00384       outputStream << "BitLength: " << chromosome.bitLength_ << endl ;
00385       outputStream << *(BinaryIntegerGene*)(chromosome.gene_[i]) ;
00386     } // else if
00387     else if (chromosome.gene_[i]->geneType_ == BINARY_GRAY_INTEGER) {
00388       outputStream << "BitLength: " << chromosome.bitLength_ << endl ;
00389       outputStream << *(BinaryGrayIntegerGene*)(chromosome.gene_[i]) ;
00390     } // else if
00391     else { 
00392       cerr << "Chromosome: operator<< -> variable type "
00393            << chromosome.gene_[i]->geneType_ << " unknown" << endl ;
00394       exit(-1) ;
00395     } // else
00396   outputStream << endl ;
00397 
00398   return outputStream ;
00399 } // operator<< 
00400 

Our Software

orangebox Mallba

orangebox ssGA

orangebox JGDS

orangebox xxGA

orangebox JCell

orangebox MHTB

orangebox DEME

orangebox JMetal

orangebox More...

orangebox Go Back