EALib: Individual.cpp Source File

00001 
00041 #include "EALib/Individual.h"
00042 #include "SharkDefs.h"
00043 
00044 using namespace std;
00045 
00046 //===========================================================================
00047 //
00048 // constructors
00049 //
00050 Individual::Individual(unsigned n) : vector<Chromosome*>(n),
00051 fitness( 0 ),
00052 scaledFitness( 0 ),
00053 evalFlg( true ),
00054 feasible( 0 ),
00055 selProb( 0 ),
00056 numCopies( 0 ),
00057 elitist( false ),
00058 age( 0 ),
00059 learnTime( 0 ) {
00060     for (unsigned i = 0; i < size(); i++ )
00061         *(begin() + i) = new ChromosomeT< char >;
00062 }
00063 
00064 Individual::Individual(unsigned n, const Chromosome& chrom )  : vector<Chromosome*>(n),
00065 fitness( 0 ),
00066 scaledFitness( 0 ),
00067 evalFlg( true ),
00068 feasible( 0 ),
00069 selProb( 0 ),
00070 numCopies( 0 ),
00071 elitist( false ),
00072 age( 0 ),
00073 learnTime( 0 ) {
00074     for (unsigned i = 0; i < size(); i++ )
00075         *(begin() + i) = chrom.clone();
00076 }
00077 
00078 Individual::Individual(const Chromosome& chrom0)  : vector<Chromosome*>( 1 ),
00079 fitness( 0 ),
00080 scaledFitness( 0 ),
00081 evalFlg( true ),
00082 feasible( 0 ),
00083 selProb( 0 ),
00084 numCopies( 0 ),
00085 elitist( false ),
00086 age( 0 ),
00087 learnTime( 0 ) {
00088     *(begin()) = chrom0.clone();
00089 }
00090 
00091 Individual::Individual(const Chromosome& chrom0,
00092                        const Chromosome& chrom1)  : vector<Chromosome*>(2),
00093 fitness( 0 ),
00094 scaledFitness( 0 ),
00095 evalFlg( true ),
00096 feasible( 0 ),
00097 selProb( 0 ),
00098 numCopies( 0 ),
00099 elitist( false ),
00100 age( 0 ),
00101 learnTime( 0 ) {
00102     *(begin()) = chrom0.clone();
00103     *(begin() + 1) = chrom1.clone();
00104 }
00105 
00106 Individual::Individual(const Chromosome& chrom0,
00107                        const Chromosome& chrom1,
00108                        const Chromosome& chrom2)  : vector<Chromosome*>( 3 ),
00109 fitness( 0 ),
00110 scaledFitness( 0 ),
00111 evalFlg( true ),
00112 feasible( 0 ),
00113 selProb( 0 ),
00114 numCopies( 0 ),
00115 elitist( false ),
00116 age( 0 ),
00117 learnTime( 0 ) {
00118     *(begin()) = chrom0.clone();
00119     *(begin() + 1) = chrom1.clone();
00120     *(begin() + 2) = chrom2.clone();
00121 }
00122 
00123 Individual::Individual(const Chromosome& chrom0,
00124                        const Chromosome& chrom1,
00125                        const Chromosome& chrom2,
00126                        const Chromosome& chrom3)  : vector<Chromosome*>(4),
00127 fitness( 0 ),
00128 scaledFitness( 0 ),
00129 evalFlg( true ),
00130 feasible( 0 ),
00131 selProb( 0 ),
00132 numCopies( 0 ),
00133 elitist( false ),
00134 age( 0 ),
00135 learnTime( 0 ) {
00136     *(begin()) = chrom0.clone();
00137     *(begin() + 1) = chrom1.clone();
00138     *(begin() + 2) = chrom2.clone();
00139     *(begin() + 3) = chrom3.clone();
00140 }
00141 
00142 Individual::Individual(const Chromosome& chrom0,
00143                        const Chromosome& chrom1,
00144                        const Chromosome& chrom2,
00145                        const Chromosome& chrom3,
00146                        const Chromosome& chrom4)  : vector<Chromosome*>(5),
00147 fitness( 0 ),
00148 scaledFitness( 0 ),
00149 evalFlg( true ),
00150 feasible( 0 ),
00151 selProb( 0 ),
00152 numCopies( 0 ),
00153 elitist( false ),
00154 age( 0 ),
00155 learnTime( 0 ) {
00156     *(begin()) = chrom0.clone();
00157     *(begin() + 1) = chrom1.clone();
00158     *(begin() + 2) = chrom2.clone();
00159     *(begin() + 3) = chrom3.clone();
00160     *(begin() + 4) = chrom4.clone();
00161 }
00162 
00163 Individual::Individual(const Chromosome& chrom0,
00164                        const Chromosome& chrom1,
00165                        const Chromosome& chrom2,
00166                        const Chromosome& chrom3,
00167                        const Chromosome& chrom4,
00168                        const Chromosome& chrom5)  : vector<Chromosome*>(6),
00169 fitness( 0 ),
00170 scaledFitness( 0 ),
00171 evalFlg( true ),
00172 feasible( 0 ),
00173 selProb( 0 ),
00174 numCopies( 0 ),
00175 elitist( false ),
00176 age( 0 ),
00177 learnTime( 0 ) {
00178     *(begin()) = chrom0.clone();
00179     *(begin() + 1) = chrom1.clone();
00180     *(begin() + 2) = chrom2.clone();
00181     *(begin() + 3) = chrom3.clone();
00182     *(begin() + 4) = chrom4.clone();
00183     *(begin() + 5) = chrom5.clone();
00184 }
00185 
00186 Individual::Individual(const Chromosome& chrom0,
00187                        const Chromosome& chrom1,
00188                        const Chromosome& chrom2,
00189                        const Chromosome& chrom3,
00190                        const Chromosome& chrom4,
00191                        const Chromosome& chrom5,
00192                        const Chromosome& chrom6)  : vector<Chromosome*>(7),
00193 fitness( 0 ),
00194 scaledFitness( 0 ),
00195 evalFlg( true ),
00196 feasible( 0 ),
00197 selProb( 0 ),
00198 numCopies( 0 ),
00199 elitist( false ),
00200 age( 0 ),
00201 learnTime( 0 ) {
00202     *(begin()) = chrom0.clone();
00203     *(begin() + 1) = chrom1.clone();
00204     *(begin() + 2) = chrom2.clone();
00205     *(begin() + 3) = chrom3.clone();
00206     *(begin() + 4) = chrom4.clone();
00207     *(begin() + 5) = chrom5.clone();
00208     *(begin() + 6) = chrom6.clone();
00209 }
00210 
00211 Individual::Individual(const Chromosome& chrom0,
00212                        const Chromosome& chrom1,
00213                        const Chromosome& chrom2,
00214                        const Chromosome& chrom3,
00215                        const Chromosome& chrom4,
00216                        const Chromosome& chrom5,
00217                        const Chromosome& chrom6,
00218                        const Chromosome& chrom7)  : vector<Chromosome*>(8),
00219 fitness( 0 ),
00220 scaledFitness( 0 ),
00221 evalFlg( true ),
00222 feasible( 0 ),
00223 selProb( 0 ),
00224 numCopies( 0 ),
00225 elitist( false ),
00226 age( 0 ),
00227 learnTime( 0 ) {
00228     *(begin()) = chrom0.clone();
00229     *(begin() + 1) = chrom1.clone();
00230     *(begin() + 2) = chrom2.clone();
00231     *(begin() + 3) = chrom3.clone();
00232     *(begin() + 4) = chrom4.clone();
00233     *(begin() + 5) = chrom5.clone();
00234     *(begin() + 6) = chrom6.clone();
00235     *(begin() + 7) = chrom7.clone();
00236 }
00237 
00238 Individual::Individual(const vector< Chromosome * >& chrom)  : vector<Chromosome*>( chrom ),
00239 fitness( 0 ),
00240 scaledFitness( 0 ),
00241 evalFlg( true ),
00242 feasible( 0 ),
00243 selProb( 0 ),
00244 numCopies( 0 ),
00245 elitist( false ),
00246 age( 0 ),
00247 learnTime( 0 ) {
00248 }
00249 
00250 Individual::Individual(const Individual& indiv)  : vector<Chromosome*>( indiv.size() ),
00251 fitness( indiv.fitness ),
00252 scaledFitness( indiv.scaledFitness ),
00253 evalFlg( indiv.evalFlg ),
00254 feasible( indiv.feasible ),
00255 selProb( indiv.selProb ),
00256 numCopies( indiv.numCopies ),
00257 elitist( indiv.elitist ),
00258 age( indiv.age ),
00259 learnTime( indiv.learnTime ) {
00260     for( unsigned int i = 0; i < size(); i++ )
00261         *(begin() + i) = indiv[ i ].clone();
00262 }
00263 
00264 //===========================================================================
00265 //
00266 // destructor
00267 //
00268 Individual::~Individual() {
00269     for( unsigned int i = 0; i < size(); i++ )
00270         delete *(begin() + i);
00271 }
00272 
00273 //===========================================================================
00274 
00275 unsigned Individual::totalSize() const
00276 {
00277     unsigned s = 0;
00278     for (unsigned i = size(); i--; s += (*(begin() + i))->size());
00279     return s;
00280 }
00281 
00282 //===========================================================================
00283 // changed by Marc Toussaint and Stefan Wiegand (INI) 20.11.2002
00284 Individual& Individual::operator = (const Individual& indiv)
00285 {
00286     unsigned i;
00287 
00288     for (i = size(); i--;)
00289         delete *(begin() + i);
00290     vector< Chromosome * >::operator = (indiv);
00291     for (i = size(); i--;)
00292         *(begin() + i) = indiv[ i ].clone();
00293 
00294     fitness       = indiv.fitness;
00295     scaledFitness = indiv.scaledFitness;
00296     evalFlg       = indiv.evalFlg;
00297     feasible      = indiv.feasible;
00298     selProb       = indiv.selProb;
00299     numCopies     = indiv.numCopies;
00300     elitist       = indiv.elitist;
00301     age           = indiv.age;
00302     learnTime     = indiv.learnTime;
00303 
00304     return *this;
00305 }
00306 
00307 //===========================================================================
00308 
00309 void Individual::replace(unsigned i, const Chromosome& chrom)
00310 {
00311     RANGE_CHECK(i < size())
00312     delete *(begin() + i);
00313     *(begin() + i) = chrom.clone();
00314 }
00315 
00316 void Individual::insert(unsigned i, const Chromosome& chrom)
00317 {
00318     RANGE_CHECK(i <= size())
00319     vector< Chromosome * >::insert(begin() + i, chrom.clone());
00320 }
00321 
00322 void Individual::append(const Chromosome& chrom)
00323 {
00324     vector< Chromosome * >::push_back(chrom.clone());
00325 }
00326 
00327 void Individual::remove(unsigned i)
00328 {
00329     RANGE_CHECK(i < size())
00330     delete *(begin() + i);
00331     vector< Chromosome * >::erase(begin() + i);
00332 }
00333 
00334 void Individual::remove(unsigned i, unsigned k)
00335 {
00336     if (i <= k) {
00337         RANGE_CHECK(k < size())
00338         for (unsigned j = i; j < k; j++)
00339             delete *(begin() + j);
00340         vector< Chromosome * >::erase(begin() + i, begin() + k);
00341     }
00342 }
00343 
00344 //===========================================================================
00345 
00346 bool Individual::operator == (const Individual& ind) const
00347 {
00348     if (size() == ind.size()) {
00349         for (unsigned i = 0; i < size(); ++i)
00350             if (!((*this)[ i ] == ind[ i ])) return false;
00351 
00352         return fitness       == ind.fitness       &&
00353                scaledFitness == ind.scaledFitness &&
00354                evalFlg       == ind.evalFlg       &&
00355                feasible      == ind.feasible      &&
00356                selProb       == ind.selProb       &&
00357                numCopies     == ind.numCopies     &&
00358                elitist       == ind.elitist       &&
00359                age           == ind.age           &&
00360                learnTime     == ind.learnTime    ;
00361     }
00362     return false;
00363 }
00364 
00365 bool Individual::operator < (const Individual& ind) const
00366 {
00367     if (size() == ind.size()) {
00368         bool less = false;
00369 
00370         for (unsigned i = 0; i < size(); ++i)
00371             if (ind[ i ] < (*this)[ i ])
00372                 return false;
00373             else if (! less && (*this)[ i ] < ind[ i ])
00374                 less = true;
00375 
00376         return less/*                             &&
00377                        fitness       <= ind.fitness       &&
00378                        scaledFitness <= ind.scaledFitness &&
00379                        evalFlg       <= ind.evalFlg       &&
00380                        feasible      <= ind.feasible      &&
00381                        selProb       <= ind.selProb       &&
00382                        numCopies     <= ind.numCopies     &&
00383                        elitist       <= ind.elitist       &&
00384                        age           <= ind.age*/;
00385     }
00386 
00387     return size() < ind.size();
00388 }
00389 
00390 //===========================================================================
00391 // added by Marc Toussaint and Stefan Wiegand (INI) 20.11.2002
00392 
00393 int Individual::pvm_pkind()
00394 {
00395     //cout << "\t Individual_pk" << endl;
00396 
00397     unsigned i;
00398 
00399     unsigned *s = new unsigned;
00400     *s = this->size();
00401     pvm_pkuint(s, 1, 1);
00402     delete s;
00403 
00404     for (i = 0; i < this->size(); i++)
00405         ((*this)[i]).pvm_pkchrom();
00406 
00407     unsigned int u[6];
00408     u[0] = feasible;
00409     u[1] = elitist;
00410     u[2] = evalFlg;
00411     u[3] = numCopies;
00412     u[4] = age;
00413     u[5] = learnTime;
00414     pvm_pkuint(u, 6, 1);
00415 
00416     /*double *f = new double[displVal.size()+3];
00417     unsigned jj = 0;
00418     for (;jj < displVal.size();jj++)
00419         f[jj]   = getDisplVal(jj);
00420     f[jj]   = fitness;
00421     f[++jj] = scaledFitness;
00422     f[++jj] = selProb;
00423     pvm_pkdouble(f, displVal.size() + 3, 1);
00424     delete[] f;*/
00425     
00426     double f[3];
00427     f[0] = fitness;
00428     f[1] = scaledFitness;
00429     f[2] = selProb;
00430     pvm_pkdouble(f, 3, 1);
00431 
00432     return 1;
00433 }
00434 
00435 int Individual::pvm_upkind()
00436 {
00437     //cout << "\t Individual_upk" << endl;
00438 
00439     unsigned i;
00440 
00441     unsigned *s = new unsigned;
00442     pvm_upkuint(s, 1, 1);
00443     if (this->size() != *s) {
00444 
00445       throw SHARKEXCEPTION("EALib/Individual.cpp: the individual which has called pvm_upkind() is of unexpected size!\nPlease initialize this individual prototypically with chromosomes of appropriate type.");
00446     }
00447     delete s;
00448 
00449     for (i = 0; i < this->size(); i++)
00450         ((*this)[i]).pvm_upkchrom();
00451 
00452     unsigned u[6];
00453     pvm_upkuint(u, 7, 1);
00454     feasible  = (u[0] != 0);
00455     elitist   = (u[1] != 0);
00456     evalFlg   = (u[2] != 0);
00457     numCopies = u[3];
00458     age       = u[4];
00459     learnTime = u[5];
00460 
00461     /*double *f = new double[noDisplVal+3];
00462     pvm_upkdouble(f, noDisplVal + 3, 1);
00463     unsigned jj = 0;
00464     for (;jj < noDisplVal ;jj++)
00465         setDisplVal(jj, f[jj]);
00466     fitness       = f[jj];
00467     scaledFitness = f[++jj];
00468     selProb       = f[++jj];
00469     delete[] f;*/
00470     double f[3];
00471     pvm_upkdouble( f, 3, 1);
00472     fitness       = f[0];
00473     scaledFitness = f[1];
00474     selProb       = f[2];
00475 
00476     return 1;
00477 }
00478 
00479 //===========================================================================
00480