Shark Machine Learning Library
IndividualMOO.cpp
Go to the documentation of this file.00001 // ====================================================================== 00040 // 00041 // Authors message 00042 //====================================================================== 00043 /* Thank you very much for your interest to MOO-EALib. 00044 00045 Since our company's name was changed on 1st, January, 2003, 00046 my E-mail address in the source codes were also changed. 00047 The current E-mail address (6th,Feb.,2004) is as follows: 00048 00049 tatsuya.okabe@honda-ri.de. 00050 00051 If you cannot contact me with the above E-mail address, 00052 you can also use the following E-mail address: 00053 00054 t_okabe_de@hotmail.com. 00055 00056 If you have any questions, please don't hesitate to 00057 ask me. It's my pleasure. 00058 00059 Best Regards, 00060 Tatsuya Okabe 00061 00062 ********************************************************* 00063 Tatsuya Okabe 00064 Honda Research Institute Europe GmbH 00065 Carl-Legien-Strasse 30, 63073 Offenbach/Main, Germany 00066 Tel: +49-69-89011-745 00067 Fax: +49-69-89011-749 00068 **********************************************************/ 00069 00070 00071 #include <MOO-EALib/IndividualMOO.h> 00072 #include <EALib/Individual.h> 00073 #include <typeinfo> 00074 00075 00076 using namespace std; 00077 00078 00079 // ---------------------------------------------------------------------------- 00080 // TO-IM-001 00081 IndividualMOO::IndividualMOO() 00082 : Individual() 00083 { 00084 MOOFitness.resize( 1, 0 ); 00085 UnpenalizedMOOFitness.resize( 1, 0 ); 00086 setMOORank(0); 00087 setMOOShare(0.0); 00088 } 00089 // ---------------------------------------------------------------------------- 00090 00091 // ---------------------------------------------------------------------------- 00092 // TO-IM-002 00093 IndividualMOO::IndividualMOO(unsigned n) 00094 : Individual(n) 00095 { 00096 MOOFitness.resize( 1, 0 ); 00097 UnpenalizedMOOFitness.resize( 1, 0 ); 00098 setMOORank(0); 00099 setMOOShare(0.0); 00100 } 00101 // ---------------------------------------------------------------------------- 00102 00103 // ---------------------------------------------------------------------------- 00104 // TO-IM-003 00105 IndividualMOO::IndividualMOO(unsigned n, const Chromosome& chrom1) 00106 : Individual(n, chrom1) 00107 { 00108 MOOFitness.resize( 1, 0 ); 00109 UnpenalizedMOOFitness.resize( 1, 0 ); 00110 setMOORank(0); 00111 setMOOShare(0.0); 00112 } 00113 // ---------------------------------------------------------------------------- 00114 00115 // ---------------------------------------------------------------------------- 00116 // TO-IM-004 00117 IndividualMOO::IndividualMOO(const Chromosome& chrom1) 00118 : Individual(chrom1) 00119 { 00120 MOOFitness.resize( 1, 0 ); 00121 UnpenalizedMOOFitness.resize( 1, 0 ); 00122 setMOORank(0); 00123 setMOOShare(0.0); 00124 } 00125 // ---------------------------------------------------------------------------- 00126 00127 // ---------------------------------------------------------------------------- 00128 // TO-IM-005 00129 IndividualMOO::IndividualMOO(const Chromosome& chrom1, 00130 const Chromosome& chrom2) 00131 : Individual(chrom1, chrom2) 00132 { 00133 MOOFitness.resize( 1, 0 ); 00134 UnpenalizedMOOFitness.resize( 1, 0 ); 00135 setMOORank(0); 00136 setMOOShare(0.0); 00137 } 00138 // ---------------------------------------------------------------------------- 00139 00140 // ---------------------------------------------------------------------------- 00141 // TO-IM-006 00142 IndividualMOO::IndividualMOO(const Chromosome& chrom1, 00143 const Chromosome& chrom2, 00144 const Chromosome& chrom3) 00145 : Individual(chrom1, chrom2, chrom3) 00146 { 00147 MOOFitness.resize( 1, 0 ); 00148 UnpenalizedMOOFitness.resize( 1, 0 ); 00149 setMOORank(0); 00150 setMOOShare(0.0); 00151 } 00152 // ---------------------------------------------------------------------------- 00153 00154 // ---------------------------------------------------------------------------- 00155 // TO-IM-007 00156 IndividualMOO::IndividualMOO(const Chromosome& chrom1, 00157 const Chromosome& chrom2, 00158 const Chromosome& chrom3, 00159 const Chromosome& chrom4) 00160 : Individual(chrom1, chrom2, chrom3, chrom4) 00161 { 00162 MOOFitness.resize( 1, 0 ); 00163 UnpenalizedMOOFitness.resize( 1, 0 ); 00164 setMOORank(0); 00165 setMOOShare(0.0); 00166 } 00167 // ---------------------------------------------------------------------------- 00168 00169 // ---------------------------------------------------------------------------- 00170 // TO-IM-008 00171 IndividualMOO::IndividualMOO(const Chromosome& chrom1, 00172 const Chromosome& chrom2, 00173 const Chromosome& chrom3, 00174 const Chromosome& chrom4, 00175 const Chromosome& chrom5) 00176 : Individual(chrom1, chrom2, chrom3, chrom4, chrom5) 00177 { 00178 MOOFitness.resize( 1, 0 ); 00179 UnpenalizedMOOFitness.resize( 1, 0 ); 00180 setMOORank(0); 00181 setMOOShare(0.0); 00182 } 00183 // ---------------------------------------------------------------------------- 00184 00185 // ---------------------------------------------------------------------------- 00186 // TO-IM-009 00187 IndividualMOO::IndividualMOO(const Chromosome& chrom1, 00188 const Chromosome& chrom2, 00189 const Chromosome& chrom3, 00190 const Chromosome& chrom4, 00191 const Chromosome& chrom5, 00192 const Chromosome& chrom6) 00193 : Individual(chrom1, chrom2, chrom3, chrom4, chrom5, chrom6) 00194 { 00195 MOOFitness.resize( 1, 0 ); 00196 UnpenalizedMOOFitness.resize( 1, 0 ); 00197 setMOORank(0); 00198 setMOOShare(0.0); 00199 } 00200 // ---------------------------------------------------------------------------- 00201 00202 // ---------------------------------------------------------------------------- 00203 // TO-IM-010 00204 IndividualMOO::IndividualMOO(const Chromosome& chrom1, 00205 const Chromosome& chrom2, 00206 const Chromosome& chrom3, 00207 const Chromosome& chrom4, 00208 const Chromosome& chrom5, 00209 const Chromosome& chrom6, 00210 const Chromosome& chrom7) 00211 : Individual(chrom1, chrom2, chrom3, chrom4, chrom5, chrom6, chrom7) 00212 { 00213 MOOFitness.resize( 1, 0 ); 00214 UnpenalizedMOOFitness.resize( 1, 0 ); 00215 setMOORank(0); 00216 setMOOShare(0.0); 00217 } 00218 // ---------------------------------------------------------------------------- 00219 00220 // ---------------------------------------------------------------------------- 00221 // TO-IM-011 00222 IndividualMOO::IndividualMOO(const Chromosome& chrom1, 00223 const Chromosome& chrom2, 00224 const Chromosome& chrom3, 00225 const Chromosome& chrom4, 00226 const Chromosome& chrom5, 00227 const Chromosome& chrom6, 00228 const Chromosome& chrom7, 00229 const Chromosome& chrom8) 00230 : Individual(chrom1, chrom2, chrom3, chrom4, chrom5, chrom6, chrom7, chrom8) 00231 { 00232 MOOFitness.resize( 1, 0 ); 00233 UnpenalizedMOOFitness.resize( 1, 0 ); 00234 setMOORank(0); 00235 setMOOShare(0.0); 00236 } 00237 // ---------------------------------------------------------------------------- 00238 00239 // ---------------------------------------------------------------------------- 00240 // TO-IM-012 00241 IndividualMOO::IndividualMOO(const vector< Chromosome* >& chrom1) 00242 : Individual(chrom1) 00243 { 00244 MOOFitness.resize( 1, 0 ); 00245 UnpenalizedMOOFitness.resize( 1, 0 ); 00246 setMOORank(0); 00247 setMOOShare(0.0); 00248 } 00249 // ---------------------------------------------------------------------------- 00250 00251 // ---------------------------------------------------------------------------- 00252 // TO-IM-013 00253 IndividualMOO::IndividualMOO(const Individual& indiv1) 00254 : Individual(indiv1) 00255 { 00256 MOOFitness.resize( 1, 0 ); 00257 UnpenalizedMOOFitness.resize( 1, 0 ); 00258 setMOORank(0); 00259 setMOOShare(0.0); 00260 } 00261 // ---------------------------------------------------------------------------- 00262 00263 // ---------------------------------------------------------------------------- 00264 // TO-IM-014 00265 IndividualMOO::IndividualMOO(const IndividualMOO& indmoo) 00266 : Individual(dynamic_cast< const Individual& >(indmoo)) 00267 { 00268 unsigned i; 00269 // copy data 00270 MOOFitness.resize(indmoo.MOOFitness.size()); 00271 for (i = indmoo.MOOFitness.size(); i--;) 00272 { 00273 setMOOFitness(i, indmoo.MOOFitness[i]); 00274 } 00275 UnpenalizedMOOFitness.resize(indmoo.UnpenalizedMOOFitness.size()); 00276 for (i = indmoo.UnpenalizedMOOFitness.size(); i--;) 00277 { 00278 setUnpenalizedMOOFitness(i, indmoo.UnpenalizedMOOFitness[i]); 00279 } 00280 setMOORank(indmoo.MOORank); 00281 setMOOShare(indmoo.MOOShare); 00282 fitness = indmoo.fitness; 00283 scaledFitness = indmoo.scaledFitness; 00284 evalFlg = indmoo.evalFlg; 00285 feasible = indmoo.feasible; 00286 selProb = indmoo.selProb; 00287 numCopies = indmoo.numCopies; 00288 elitist = indmoo.elitist; 00289 age = indmoo.age; 00290 } 00291 // ---------------------------------------------------------------------------- 00292 00293 // ---------------------------------------------------------------------------- 00294 // TO-IM-015 00295 IndividualMOO::~IndividualMOO() 00296 { } 00297 00298 // ---------------------------------------------------------------------------- 00299 00300 // ---------------------------------------------------------------------------- 00301 // TO-IM-021 00302 unsigned IndividualMOO::totalSize() const 00303 { 00304 return Individual::totalSize(); 00305 } 00306 // ---------------------------------------------------------------------------- 00307 00308 // ---------------------------------------------------------------------------- 00309 // TO-IM-047 00310 void IndividualMOO::setEvalFlg(bool flg) 00311 { 00312 if (flg) 00313 { 00314 Individual::setEvaluationFlag(); 00315 } 00316 else 00317 { 00318 Individual::clearEvaluationFlag(); 00319 } 00320 } 00321 // ---------------------------------------------------------------------------- 00322 00323 // ---------------------------------------------------------------------------- 00324 // ---------------------------------------------------------------------------- 00325 // SW-IM-050 00326 void IndividualMOO::setLearnTime(unsigned lt) 00327 { 00328 Individual::setLearnTime(lt); 00329 } 00330 // ---------------------------------------------------------------------------- 00331 00332 // ---------------------------------------------------------------------------- 00333 // SW-IM-051 00334 unsigned IndividualMOO::getLearnTime() const 00335 { 00336 return Individual::getLearnTime(); 00337 } 00338 // ---------------------------- 00339 00340 // ---------------------------------------------------------------------------- 00341 // TO-IM-060 00342 void IndividualMOO::setNoOfObj(unsigned n) 00343 { 00344 MOOFitness.resize(n); 00345 UnpenalizedMOOFitness.resize(n); 00346 initializeMOOFitness(0.0); 00347 initializeUnpenalizedMOOFitness(0.0); 00348 } 00349 // ---------------------------------------------------------------------------- 00350 00351 // ---------------------------------------------------------------------------- 00352 // TO-IM-061 00353 unsigned IndividualMOO::getNoOfObj() const 00354 { 00355 return MOOFitness.size(); 00356 } 00357 // ---------------------------------------------------------------------------- 00358 00359 // ---------------------------------------------------------------------------- 00360 // TO-IM-062 00361 void IndividualMOO::setMOORank(unsigned n) 00362 { 00363 MOORank = n; 00364 } 00365 // ---------------------------------------------------------------------------- 00366 00367 // ---------------------------------------------------------------------------- 00368 // TO-IM-063 00369 unsigned IndividualMOO::getMOORank() const 00370 { 00371 return MOORank; 00372 } 00373 // ---------------------------------------------------------------------------- 00374 00375 // ---------------------------------------------------------------------------- 00376 // TO-IM-064 00377 void IndividualMOO::setMOOShare(double n) 00378 { 00379 MOOShare = n; 00380 } 00381 // ---------------------------------------------------------------------------- 00382 00383 // ---------------------------------------------------------------------------- 00384 // TO-IM-065 00385 double IndividualMOO::getMOOShare() const 00386 { 00387 return MOOShare; 00388 } 00389 // ---------------------------------------------------------------------------- 00390 00391 // ---------------------------------------------------------------------------- 00392 // Tommy 00393 const std::vector<double> & IndividualMOO::getMOOFitnessValues( bool unpenalized ) const { 00394 return (unpenalized ? getUnpenalizedMOOFitnessValues() : getMOOFitnessValues()); 00395 } 00396 00397 std::vector<double> & IndividualMOO::getMOOFitnessValues(bool unpenalized) { 00398 return (unpenalized ? getUnpenalizedMOOFitnessValues() : getMOOFitnessValues()); 00399 } 00400 00401 // ---------------------------------------------------------------------------- 00402 // TO-IM-066 00403 void IndividualMOO::setMOOFitness(unsigned nof, double fit) 00404 { 00405 RANGE_CHECK(nof < MOOFitness.size()) 00406 MOOFitness[nof] = fit; 00407 } 00408 // ---------------------------------------------------------------------------- 00409 00410 // ---------------------------------------------------------------------------- 00411 // TO-IM-067 00412 double IndividualMOO::getMOOFitness(unsigned nof) 00413 { 00414 RANGE_CHECK(nof < MOOFitness.size()) 00415 return MOOFitness[nof]; 00416 } 00417 // ---------------------------------------------------------------------------- 00418 00419 // ---------------------------------------------------------------------------- 00420 // TO-IM-068 00421 void IndividualMOO::setMOOFitnessValues(double f0) 00422 { 00423 RANGE_CHECK(0 < MOOFitness.size()) 00424 MOOFitness[0] = f0; 00425 } 00426 // ---------------------------------------------------------------------------- 00427 00428 // ---------------------------------------------------------------------------- 00429 // TO-IM-069 00430 void IndividualMOO::setMOOFitnessValues(double f0, double f1) 00431 { 00432 RANGE_CHECK(1 < MOOFitness.size()) 00433 MOOFitness[0] = f0; 00434 MOOFitness[1] = f1; 00435 } 00436 // ---------------------------------------------------------------------------- 00437 00438 // ---------------------------------------------------------------------------- 00439 // TO-IM-070 00440 void IndividualMOO::setMOOFitnessValues(double f0, double f1, 00441 double f2) 00442 { 00443 RANGE_CHECK(2 < MOOFitness.size()) 00444 MOOFitness[0] = f0; 00445 MOOFitness[1] = f1; 00446 MOOFitness[2] = f2; 00447 } 00448 // ---------------------------------------------------------------------------- 00449 00450 // ---------------------------------------------------------------------------- 00451 // TO-IM-071 00452 void IndividualMOO::setMOOFitnessValues(double f0, double f1, 00453 double f2, double f3) 00454 { 00455 RANGE_CHECK(3 < MOOFitness.size()) 00456 MOOFitness[0] = f0; 00457 MOOFitness[1] = f1; 00458 MOOFitness[2] = f2; 00459 MOOFitness[3] = f3; 00460 } 00461 // ---------------------------------------------------------------------------- 00462 00463 // ---------------------------------------------------------------------------- 00464 // TO-IM-072 00465 void IndividualMOO::setMOOFitnessValues(double f0, double f1, 00466 double f2, double f3, 00467 double f4) 00468 { 00469 RANGE_CHECK(4 < MOOFitness.size()) 00470 MOOFitness[0] = f0; 00471 MOOFitness[1] = f1; 00472 MOOFitness[2] = f2; 00473 MOOFitness[3] = f3; 00474 MOOFitness[4] = f4; 00475 } 00476 // ---------------------------------------------------------------------------- 00477 00478 // ---------------------------------------------------------------------------- 00479 // TO-IM-073 00480 void IndividualMOO::setMOOFitnessValues(double f0, double f1, 00481 double f2, double f3, 00482 double f4, double f5) 00483 { 00484 RANGE_CHECK(5 < MOOFitness.size()) 00485 MOOFitness[0] = f0; 00486 MOOFitness[1] = f1; 00487 MOOFitness[2] = f2; 00488 MOOFitness[3] = f3; 00489 MOOFitness[4] = f4; 00490 MOOFitness[5] = f5; 00491 } 00492 // ---------------------------------------------------------------------------- 00493 00494 // ---------------------------------------------------------------------------- 00495 // TO-IM-074 00496 void IndividualMOO::setMOOFitnessValues(double f0, double f1, 00497 double f2, double f3, 00498 double f4, double f5, 00499 double f6) 00500 { 00501 RANGE_CHECK(6 < MOOFitness.size()) 00502 MOOFitness[0] = f0; 00503 MOOFitness[1] = f1; 00504 MOOFitness[2] = f2; 00505 MOOFitness[3] = f3; 00506 MOOFitness[4] = f4; 00507 MOOFitness[5] = f5; 00508 MOOFitness[6] = f6; 00509 } 00510 // ---------------------------------------------------------------------------- 00511 00512 // ---------------------------------------------------------------------------- 00513 // TO-IM-075 00514 void IndividualMOO::setMOOFitnessValues(double f0, double f1, 00515 double f2, double f3, 00516 double f4, double f5, 00517 double f6, double f7) 00518 { 00519 RANGE_CHECK(7 < MOOFitness.size()) 00520 MOOFitness[0] = f0; 00521 MOOFitness[1] = f1; 00522 MOOFitness[2] = f2; 00523 MOOFitness[3] = f3; 00524 MOOFitness[4] = f4; 00525 MOOFitness[5] = f5; 00526 MOOFitness[6] = f6; 00527 MOOFitness[7] = f7; 00528 } 00529 // ---------------------------------------------------------------------------- 00530 00531 // ---------------------------------------------------------------------------- 00532 // TO-IM-076 00533 void IndividualMOO::setMOOFitnessValues(vector< double >& fit) 00534 { 00535 RANGE_CHECK(fit.size() == MOOFitness.size()) 00536 for (unsigned i = fit.size(); i--;) 00537 { 00538 MOOFitness[i] = fit[i]; 00539 } 00540 } 00541 // ---------------------------------------------------------------------------- 00542 00543 // ---------------------------------------------------------------------------- 00544 // TO-IM-077 00545 const vector<double> & IndividualMOO::getMOOFitnessValues() const { 00546 return MOOFitness; 00547 } 00548 00549 vector< double >& IndividualMOO::getMOOFitnessValues() { 00550 return MOOFitness; 00551 } 00552 // ---------------------------------------------------------------------------- 00553 00554 // ---------------------------------------------------------------------------- 00555 // TO-IM-078 00556 void IndividualMOO::initializeMOOFitness(double x) 00557 { 00558 for (unsigned i = MOOFitness.size(); i--;) 00559 { 00560 MOOFitness[i] = x; 00561 } 00562 } 00563 // ---------------------------------------------------------------------------- 00564 00565 // ---------------------------------------------------------------------------- 00566 // SR-IM-079 00567 void IndividualMOO::setUnpenalizedMOOFitness(unsigned nof, double fit) 00568 { 00569 RANGE_CHECK(nof < UnpenalizedMOOFitness.size()) 00570 UnpenalizedMOOFitness[nof] = fit; 00571 } 00572 // ---------------------------------------------------------------------------- 00573 00574 // ---------------------------------------------------------------------------- 00575 // SR-IM-080 00576 double IndividualMOO::getUnpenalizedMOOFitness(unsigned nof) 00577 { 00578 RANGE_CHECK(nof < UnpenalizedMOOFitness.size()) 00579 return UnpenalizedMOOFitness[nof]; 00580 } 00581 // ---------------------------------------------------------------------------- 00582 00583 // ---------------------------------------------------------------------------- 00584 // SR-IM-081 00585 void IndividualMOO::setUnpenalizedMOOFitnessValues(double f0) 00586 { 00587 RANGE_CHECK(0 < UnpenalizedMOOFitness.size()) 00588 UnpenalizedMOOFitness[0] = f0; 00589 } 00590 // ---------------------------------------------------------------------------- 00591 00592 // ---------------------------------------------------------------------------- 00593 // SR-IM-082 00594 void IndividualMOO::setUnpenalizedMOOFitnessValues(double f0, double f1) 00595 { 00596 RANGE_CHECK(1 < UnpenalizedMOOFitness.size()) 00597 UnpenalizedMOOFitness[0] = f0; 00598 UnpenalizedMOOFitness[1] = f1; 00599 } 00600 // ---------------------------------------------------------------------------- 00601 00602 // ---------------------------------------------------------------------------- 00603 // SR-IM-083 00604 void IndividualMOO::setUnpenalizedMOOFitnessValues(double f0, double f1, 00605 double f2) 00606 { 00607 RANGE_CHECK(2 < UnpenalizedMOOFitness.size()) 00608 UnpenalizedMOOFitness[0] = f0; 00609 UnpenalizedMOOFitness[1] = f1; 00610 UnpenalizedMOOFitness[2] = f2; 00611 } 00612 // ---------------------------------------------------------------------------- 00613 00614 // ---------------------------------------------------------------------------- 00615 // SR-IM-084 00616 void IndividualMOO::setUnpenalizedMOOFitnessValues(double f0, double f1, 00617 double f2, double f3) 00618 { 00619 RANGE_CHECK(3 < UnpenalizedMOOFitness.size()) 00620 UnpenalizedMOOFitness[0] = f0; 00621 UnpenalizedMOOFitness[1] = f1; 00622 UnpenalizedMOOFitness[2] = f2; 00623 UnpenalizedMOOFitness[3] = f3; 00624 } 00625 // ---------------------------------------------------------------------------- 00626 00627 // ---------------------------------------------------------------------------- 00628 // SR-IM-085 00629 void IndividualMOO::setUnpenalizedMOOFitnessValues(double f0, double f1, 00630 double f2, double f3, 00631 double f4) 00632 { 00633 RANGE_CHECK(4 < UnpenalizedMOOFitness.size()) 00634 UnpenalizedMOOFitness[0] = f0; 00635 UnpenalizedMOOFitness[1] = f1; 00636 UnpenalizedMOOFitness[2] = f2; 00637 UnpenalizedMOOFitness[3] = f3; 00638 UnpenalizedMOOFitness[4] = f4; 00639 } 00640 // ---------------------------------------------------------------------------- 00641 00642 // ---------------------------------------------------------------------------- 00643 // SR-IM-086 00644 void IndividualMOO::setUnpenalizedMOOFitnessValues(double f0, double f1, 00645 double f2, double f3, 00646 double f4, double f5) 00647 { 00648 RANGE_CHECK(5 < UnpenalizedMOOFitness.size()) 00649 UnpenalizedMOOFitness[0] = f0; 00650 UnpenalizedMOOFitness[1] = f1; 00651 UnpenalizedMOOFitness[2] = f2; 00652 UnpenalizedMOOFitness[3] = f3; 00653 UnpenalizedMOOFitness[4] = f4; 00654 UnpenalizedMOOFitness[5] = f5; 00655 } 00656 // ---------------------------------------------------------------------------- 00657 00658 // ---------------------------------------------------------------------------- 00659 // SR-IM-087 00660 void IndividualMOO::setUnpenalizedMOOFitnessValues(double f0, double f1, 00661 double f2, double f3, 00662 double f4, double f5, 00663 double f6) 00664 { 00665 RANGE_CHECK(6 < UnpenalizedMOOFitness.size()) 00666 UnpenalizedMOOFitness[0] = f0; 00667 UnpenalizedMOOFitness[1] = f1; 00668 UnpenalizedMOOFitness[2] = f2; 00669 UnpenalizedMOOFitness[3] = f3; 00670 UnpenalizedMOOFitness[4] = f4; 00671 UnpenalizedMOOFitness[5] = f5; 00672 UnpenalizedMOOFitness[6] = f6; 00673 } 00674 // ---------------------------------------------------------------------------- 00675 00676 // ---------------------------------------------------------------------------- 00677 // SR-IM-088 00678 void IndividualMOO::setUnpenalizedMOOFitnessValues(double f0, double f1, 00679 double f2, double f3, 00680 double f4, double f5, 00681 double f6, double f7) 00682 { 00683 RANGE_CHECK(7 < UnpenalizedMOOFitness.size()) 00684 UnpenalizedMOOFitness[0] = f0; 00685 UnpenalizedMOOFitness[1] = f1; 00686 UnpenalizedMOOFitness[2] = f2; 00687 UnpenalizedMOOFitness[3] = f3; 00688 UnpenalizedMOOFitness[4] = f4; 00689 UnpenalizedMOOFitness[5] = f5; 00690 UnpenalizedMOOFitness[6] = f6; 00691 UnpenalizedMOOFitness[7] = f7; 00692 } 00693 // ---------------------------------------------------------------------------- 00694 00695 // ---------------------------------------------------------------------------- 00696 // SR-IM-089 00697 void IndividualMOO::setUnpenalizedMOOFitnessValues(vector< double >& fit) 00698 { 00699 RANGE_CHECK(fit.size() < UnpenalizedMOOFitness.size()) 00700 for (unsigned i = fit.size(); i--;) 00701 { 00702 UnpenalizedMOOFitness[i] = fit[i]; 00703 } 00704 } 00705 // ---------------------------------------------------------------------------- 00706 00707 // ---------------------------------------------------------------------------- 00708 // SR-IM-090 00709 const vector<double> & IndividualMOO::getUnpenalizedMOOFitnessValues() const { 00710 return UnpenalizedMOOFitness; 00711 } 00712 00713 vector<double> & IndividualMOO::getUnpenalizedMOOFitnessValues() { 00714 return UnpenalizedMOOFitness; 00715 } 00716 // ---------------------------------------------------------------------------- 00717 00718 // ---------------------------------------------------------------------------- 00719 // SR-IM-091 00720 void IndividualMOO::initializeUnpenalizedMOOFitness(double x) 00721 { 00722 for (unsigned i = UnpenalizedMOOFitness.size(); i--;) 00723 { 00724 UnpenalizedMOOFitness[i] = x; 00725 } 00726 } 00727 // ---------------------------------------------------------------------------- 00728 00729 // ---------------------------------------------------------------------------- 00730 // TO-IM-100 00731 Chromosome& IndividualMOO::operator [ ](unsigned i) 00732 { 00733 return Individual::operator [ ](i); 00734 } 00735 // ---------------------------------------------------------------------------- 00736 00737 // ---------------------------------------------------------------------------- 00738 // TO-IM-101 00739 const Chromosome& IndividualMOO::operator [ ](unsigned i) const 00740 { 00741 return Individual::operator [ ](i); 00742 } 00743 // ---------------------------------------------------------------------------- 00744 00745 // ---------------------------------------------------------------------------- 00746 // TO-IM-102 00747 IndividualMOO& IndividualMOO::operator = (const IndividualMOO& indmoo) 00748 { 00749 // 00750 // replaced by Stefan Wiegand (INI) 14.1.2004 00751 // 00752 unsigned i; 00753 00754 for (i = size(); i--;) 00755 delete *(begin() + i); 00756 00757 vector< Chromosome * >::operator = (indmoo); 00758 00759 for (i = size(); i--;) 00760 *(begin() + i) = indmoo[ i ].clone(); 00761 00762 #ifdef EALIB_REGISTER_INDIVIDUAL 00763 for (i = size(); i--;) 00764 (*(begin() + i))->registerIndividual(*this, i); 00765 #endif 00766 00767 if (MOOFitness.size() != indmoo.MOOFitness.size()) 00768 setNoOfObj(indmoo.MOOFitness.size()); 00769 00770 fitness = indmoo.fitness; 00771 scaledFitness = indmoo.scaledFitness; 00772 evalFlg = indmoo.evalFlg; 00773 feasible = indmoo.feasible; 00774 selProb = indmoo.selProb; 00775 numCopies = indmoo.numCopies; 00776 elitist = indmoo.elitist; 00777 age = indmoo.age; 00778 learnTime = indmoo.getLearnTime(); 00779 MOORank = indmoo.MOORank; 00780 MOOShare = indmoo.MOOShare; 00781 00782 for (i = getNoOfObj(); i--;) 00783 { 00784 MOOFitness[i] = indmoo.MOOFitness[i]; 00785 } 00786 00787 for (i = getNoOfObj(); i--;) 00788 { 00789 UnpenalizedMOOFitness[i] = indmoo.UnpenalizedMOOFitness[i]; 00790 } 00791 00792 return *this; 00793 } 00794 // ---------------------------------------------------------------------------- 00795 00796 // ---------------------------------------------------------------------------- 00797 // TO-IM-103 00798 bool IndividualMOO::operator == (const IndividualMOO& indmoo) const 00799 { 00800 unsigned i; 00801 if (size() == indmoo.size()) 00802 { 00803 // ***** check Chromosome 00804 for (i = size(); i--;) 00805 { 00806 if (!((*this)[i] == indmoo[i])) 00807 { 00808 return false; 00809 } 00810 } 00811 // ***** check MOO fitness 00812 if (MOOFitness.size() != indmoo.MOOFitness.size() || UnpenalizedMOOFitness.size() != indmoo.UnpenalizedMOOFitness.size()) 00813 { 00814 return false; 00815 } 00816 00817 for (i = MOOFitness.size(); i--;) 00818 { 00819 if (!(MOOFitness[i] == indmoo.MOOFitness[i])) 00820 { 00821 return false; 00822 } 00823 } 00824 00825 for (i = UnpenalizedMOOFitness.size(); i--;) 00826 { 00827 if (!(UnpenalizedMOOFitness[i] == indmoo.UnpenalizedMOOFitness[i])) 00828 { 00829 return false; 00830 } 00831 } 00832 00833 // ***** check internal variables 00834 if (fitness == indmoo.fitness && 00835 scaledFitness == indmoo.scaledFitness && 00836 evalFlg == indmoo.evalFlg && 00837 feasible == indmoo.feasible && 00838 selProb == indmoo.selProb && 00839 numCopies == indmoo.numCopies && 00840 elitist == indmoo.elitist && 00841 age == indmoo.age && 00842 MOORank == indmoo.MOORank && 00843 MOOShare == indmoo.MOOShare) 00844 { 00845 return true; 00846 } 00847 } 00848 return false; 00849 } 00850 // ---------------------------------------------------------------------------- 00851 00852 // ---------------------------------------------------------------------------- 00853 // TO-IM-104 00854 IndividualMOO& IndividualMOO::operator = (const Individual& ind) 00855 { 00856 // 00857 // replaced by Stefan Wiegand (INI) 14.1.2004 00858 // 00859 unsigned i; 00860 00861 for (i = size(); i--;) 00862 delete *(begin() + i); 00863 00864 vector< Chromosome * >::operator = (ind); 00865 00866 for (i = size(); i--;) 00867 *(begin() + i) = ind[ i ].clone(); 00868 00869 #ifdef EALIB_REGISTER_INDIVIDUAL 00870 for (i = size(); i--;) 00871 (*(begin() + i))->registerIndividual(*this, i); 00872 #endif 00873 00874 setNoOfObj(1); 00875 initializeMOOFitness(0); 00876 initializeUnpenalizedMOOFitness(0); 00877 00878 00879 fitness = ind.fitnessValue(); 00880 scaledFitness = ind.getScaledFitness(); 00881 evalFlg = ind.needEvaluation(); 00882 feasible = ind.isFeasible(); 00883 selProb = ind.selectionProbability(); 00884 numCopies = ind.numberOfCopies(); 00885 elitist = ind.isElitist(); 00886 age = ind.getAge(); 00887 learnTime = ind.getLearnTime(); 00888 MOORank = 0; 00889 MOOShare = 0; 00890 00891 return *this; 00892 } 00893 // ---------------------------------------------------------------------------- 00894 00895 // ---------------------------------------------------------------------------- 00896 // TO-IM-110 00897 void IndividualMOO::replace(unsigned i, const Chromosome& chrom) 00898 { 00899 Individual::replace(i, chrom); 00900 } 00901 // ---------------------------------------------------------------------------- 00902 00903 // ---------------------------------------------------------------------------- 00904 // TO-IM-111 00905 void IndividualMOO::insert(unsigned i, const Chromosome& chrom) 00906 { 00907 Individual::insert(i, chrom); 00908 } 00909 // ---------------------------------------------------------------------------- 00910 00911 // ---------------------------------------------------------------------------- 00912 // TO-IM-112 00913 void IndividualMOO::append(const Chromosome& chrom) 00914 { 00915 //Individual::append( chrom ); 00916 vector< Chromosome * >::push_back(chrom.clone()); 00917 } 00918 // ---------------------------------------------------------------------------- 00919 00920 // ---------------------------------------------------------------------------- 00921 // TO-IM-113 00922 void IndividualMOO::remove (unsigned i) 00923 { 00924 Individual::remove (i); 00925 } 00926 // ---------------------------------------------------------------------------- 00927 00928 // ---------------------------------------------------------------------------- 00929 // TO-IM-114 00930 void IndividualMOO::remove (unsigned i, unsigned j) 00931 { 00932 Individual::remove (i, j); 00933 } 00934 // ---------------------------------------------------------------------------- 00935 00936 // ---------------------------------------------------------------------------- 00937 // TO-IM-200 00938 double IndividualMOO::aggregation(const vector< double >& weight) 00939 { 00940 if (MOOFitness.size() > weight.size()) 00941 { 00942 cout << "\n ***** The size is not match in TO-IM-200 *****\n" << endl; 00943 return 0.0; 00944 } 00945 double sum = 0.0; 00946 for (unsigned i = MOOFitness.size(); i--;) 00947 { 00948 sum += getMOOFitness(i) * weight[ i ]; 00949 } 00950 setFitness(sum); 00951 return sum; 00952 } 00953 // ---------------------------------------------------------------------------- 00954 00955 // ---------------------------------------------------------------------------- 00956 // TO-IM-201 00957 double IndividualMOO::simplesum() 00958 { 00959 double sum = 0.0; 00960 for (unsigned i = MOOFitness.size(); i--;) 00961 { 00962 sum += getMOOFitness(i); 00963 } 00964 setFitness(sum); 00965 return sum; 00966 } 00967 // ---------------------------------------------------------------------------- 00968 00969 // ---------------------------------------------------------------------------- 00970 // TO-IM-500 00971 void IndividualMOO::printIM() 00972 { 00973 unsigned i; 00974 cout << "\n\n********** IndividualMOO **********\n"; 00975 cout << "No. of Chromosomes : " << size() << "\n"; 00976 cout << "Variable ( fitness ) : " << fitness << "\n"; 00977 cout << "Variable ( scaledFitness ) : " << scaledFitness << "\n"; 00978 cout << "Variable ( evalFlg ) : " << evalFlg << "\n"; 00979 cout << "Variable ( feasible ) : " << feasible << "\n"; 00980 cout << "Variable ( selProb ) : " << selProb << "\n"; 00981 cout << "Variable ( numCopies ) : " << numCopies << "\n"; 00982 cout << "Variable ( elitist ) : " << elitist << "\n"; 00983 cout << "Variable ( age ) : " << age << "\n"; 00984 cout << "Variable ( MOOShare ) : " << MOOShare << "\n"; 00985 cout << "Variable ( MOORank ) : " << MOORank << "\n"; 00986 cout << "No. of fitness functions : " << MOOFitness.size() 00987 << "\n"; 00988 for (i = 0; i < MOOFitness.size(); i++) 00989 { 00990 cout << "Value of fitness function : " << MOOFitness[i] 00991 << " ( fun. = " << i << " )\n"; 00992 } 00993 00994 for (i = 0; i < UnpenalizedMOOFitness.size(); i++) 00995 { 00996 cout << "Value of penalized fitness function : " << UnpenalizedMOOFitness[i] 00997 << " ( fun. = " << i << " )\n"; 00998 } 00999 01000 if (size() != 0) 01001 { 01002 for (unsigned i = 0; i < size(); i++) 01003 { 01004 cout << "No. Of Alleles : " << (*this)[i].size() 01005 << " ( Chr. = " << i << " )\n"; 01006 } 01007 } 01008 cout << endl; 01009 } 01010 // ---------------------------------------------------------------------------- 01011 01012 // ---------------------------------------------------------------------------- 01013 // SW-IM-600 01014 int IndividualMOO::pvm_pkind() 01015 { 01016 //cout << "\t IndividualMOO_pk" << endl; 01017 01018 unsigned i; 01019 01020 unsigned *s = new unsigned; 01021 *s = this->size(); 01022 pvm_pkuint(s, 1, 1); 01023 delete s; 01024 01025 for (i = 0; i < this->size(); i++) 01026 ((*this)[i]).pvm_pkchrom(); 01027 01028 uint u[8]; 01029 u[0] = feasible; 01030 u[1] = elitist; 01031 u[2] = evalFlg; 01032 u[3] = numCopies; 01033 u[4] = age; 01034 u[5] = learnTime; 01035 u[6] = MOORank; 01036 u[7] = getNoOfObj(); 01037 pvm_pkuint(u, 8, 1); 01038 01039 double *g = new double[2*getNoOfObj()]; 01040 unsigned jj = 0; 01041 for (;jj < getNoOfObj();jj++) 01042 g[jj] = MOOFitness[jj]; 01043 for (;jj < 2*getNoOfObj();jj++) 01044 g[jj] = UnpenalizedMOOFitness[jj]; 01045 pvm_pkdouble(g, 2*getNoOfObj(), 1); 01046 delete[] g; 01047 01048 double f[4]; 01049 f[0] = fitness; 01050 f[1] = scaledFitness; 01051 f[2] = selProb; 01052 f[3] = MOOShare; 01053 pvm_pkdouble(f, 4, 1); 01054 01055 return 1; 01056 } 01057 // ---------------------------------------------------------------------------- 01058 01059 // ---------------------------------------------------------------------------- 01060 // SW-IM-601 01061 int IndividualMOO::pvm_upkind() 01062 { 01063 //cout << "\t Individual_upk" << endl; 01064 01065 unsigned i; 01066 01067 unsigned *s = new unsigned; 01068 pvm_upkuint(s, 1, 1); 01069 if (this->size() != *s) throw SHARKEXCEPTION("[IndividualMOO::pvm_upkind] unexpected size"); 01070 delete s; 01071 01072 for (i = 0; i < this->size(); i++) 01073 ((*this)[i]).pvm_upkchrom(); 01074 01075 uint *o = new uint; 01076 uint u[8]; 01077 pvm_upkuint(u, 8, 1); 01078 feasible = u[0] ? 1 : 0; 01079 elitist = u[1] ? 1 : 0; 01080 evalFlg = u[2] ? 1 : 0; 01081 numCopies = u[3]; 01082 age = u[4]; 01083 learnTime = u[5]; 01084 MOORank = u[6]; 01085 *o = u[7]; 01086 01087 setNoOfObj(*o); 01088 01089 double *g = new double[2 * getNoOfObj()]; 01090 pvm_upkdouble(g, 2 * getNoOfObj(), 1); 01091 unsigned jj = 0; 01092 for (;jj < getNoOfObj();jj++) 01093 MOOFitness[jj] = g[jj]; 01094 for (;jj < 2 * getNoOfObj();jj++) 01095 UnpenalizedMOOFitness[jj] = g[jj]; 01096 delete[] g; 01097 delete[] o; 01098 01099 double f[4]; 01100 pvm_upkdouble(f, 4, 1); 01101 fitness = f[0]; 01102 scaledFitness = f[1]; 01103 selProb = f[2]; 01104 MOOShare = f[3]; 01105 01106 return 1; 01107 } 01108 // ---------------------------------------------------------------------------- 01109 01110 01111 01112 01113 01114