• Main Page
  • Modules
  • Classes
  • Files
  • File List

D:/Projekt/ECF_trunk/ECF/AlgHybridOrthogonalCrossover.cpp

00001 #include "ECF_base.h"
00002 #include "ECF_derived.h"
00003 #include "ECF_macro.h"
00004 
00005 
00006 /* *******************Opis algoritma**********************/
00007 /*1. odabrati ortogonalno polje prikladne dimenzije (svaka dimenzija problema je jedan faktor(stupac) ortogonalnog polja)
00008    2.  slučajnim izborom (ili nekom drugom metodom)  odabrati n roditelja koji sudjeluju u reprodukciji
00009    3. podijeliti roditelje na faktore
00010    4. kreirati m potomaka (parametar ortogonalnog polja) na način da se razmijenjuju faktori između roditelja prema rasporedu u ort. polju - polje ima moguće vrijednosti 1 i 2 što označava od kojeg se roditelja uzima
00011        pojedini dio
00012    5. mutirati svaki potomak sa vjerojatnošću pm
00013    6. odrediti fitness svih potomaka i između njih prema nekom kriteriju odabrati j potomaka koji postaju dio nove generacije
00014    primjer 2-2 križanja (n-j križanje)
00015 /* *****************************************************/
00016 
00017 HybridOrthogonalCrossover::HybridOrthogonalCrossover()
00018 {
00019     // define algorithm name
00020     name_ = "HybridOrthogonalCrossover";
00021 
00022     // create selection operators needed
00023     selRandomOp = static_cast<SelectionOperatorP> (new SelRandomOp);
00024     selWorstOp = static_cast<SelectionOperatorP> (new SelWorstOp);
00025     selBestOp = static_cast<SelectionOperatorP> (new SelBestOp);
00026 }
00027 
00028 
00029 void HybridOrthogonalCrossover::registerParameters(StateP state)
00030 {
00031     registerParameter(state, "hybcrxprob", (voidP) new uint(3), ECF::UINT);
00032     registerParameter(state, "preservebestparent", (voidP) new uint(3), ECF::UINT);
00033 }
00034 
00035 
00036 bool HybridOrthogonalCrossover::initialize(StateP state)
00037 {
00038     // read parameter values
00039     voidP hybcrxprobp = getParameterValue(state, "hybcrxprob");
00040     nCrxProb_ = *((uint*) hybcrxprobp.get());
00041 
00042     voidP preservebestparentp = getParameterValue(state, "preservebestparent");
00043     elitism = *((uint*) preservebestparentp.get());
00044 
00045     // initialize all operators
00046     selRandomOp->initialize(state);
00047     selWorstOp->initialize(state);
00048     selBestOp->initialize(state);
00049 
00050     return true;
00051 }
00052 
00053 
00054 bool HybridOrthogonalCrossover::advanceGeneration(StateP state, DemeP deme)
00055 {
00056     // hardcoded orthogonal array, instead should be implemented algorithm for finding values for indices of array
00057     uint oa[8][6]={{1,1,1,1,1,1},{1,1,1,2,2,2},{1,2,2,1,1,2},{1,2,2,2,2,1},{2,1,2,1,2,1},{2,1,2,2,1,2},{2,2,1,1,2,2},{2,2,1,2,1,1}};
00058     uint m=8; // number of experiments
00059     uint k=6; // number of factors/dimensions
00060     uint parentNumber=2;
00061 
00062 
00063     // DJ: dodao da se jedna iteracija ponavlja deme.size puta
00064     for(uint iIter = 0; iIter < deme->size(); iIter++) {
00065 
00066         std::vector<IndividualP> parents;
00067         std::vector<IndividualP> offspring;
00068 
00069         for (uint i = 0; i <  parentNumber; i++)    {
00070             if (nCrxProb_ > 0)  { // take parentNumber parents, each with probability pc
00071                 uint chooseParentNum = state->getRandomizer()->getRandomInteger(deme->size());
00072                 double prob = state->getRandomizer()->getRandomDouble();
00073                 if ( prob > nCrxProb_)
00074                     parents.push_back(deme->at(i));
00075                 // DJ: dodao ovaj else jer inace ne stavi nikoga u parents
00076                 else    // take parentNumber parents randomly
00077                     parents.push_back(selRandomOp->select(*deme));
00078             }
00079             else    // take parentNumber parents randomly
00080                 parents.push_back(selRandomOp->select(*deme));
00081         }
00082 
00083         IndividualP parent1, parent2;
00084 
00085         parent1 = parents[0];
00086         parent2 = parents[1];
00087 
00088         IndividualP child = (IndividualP) parent1->copy();
00089 
00090          for (uint w = 0; w < m; w++)   {   //number of experiments
00091             for (uint z = 0; z < parent1->size(); z++)  {
00092                 if (oa[w][z]==1)  // take factor from parent 1
00093                     child->at(z) = (GenotypeP) parent1->getGenotype(z)->copy();
00094                 else // take factor from parent 2
00095                     child->at(z) = (GenotypeP) parent2->getGenotype(z)->copy();
00096             }
00097             mutate(child);
00098             evaluate(child);
00099             offspring.push_back(child);
00100          }
00101 
00102         IndividualP theBest = selBestOp->select(offspring);
00103 
00104         if (elitism == 0)   {
00105             replaceWith(parent1, theBest);
00106             IndividualP theWorst = selWorstOp->select(offspring);
00107             replaceWith(theBest, theWorst);
00108             theBest = selBestOp->select(offspring);
00109             replaceWith(parent2, theBest);
00110         }
00111         else    {
00112             replaceWith(parent1, theBest);  //best of offsprings
00113             theBest = selBestOp->select(parents); //best of parents
00114             replaceWith(parent2, theBest);
00115         }
00116 
00117     }
00118 
00119     return true;
00120 }

Generated on Wed Sep 21 2011 13:46:51 for ECF by  doxygen 1.7.1