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

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

00001 #include "ECF.h"
00002 
00003 // Za svaki primjer je potrebno:
00004 // a) definirati odgovarajuci EvaluateOp objekt koji se primjenjuje za evaluaciju jedinke
00005 // b) definirati genotip (po zelji i druge parametre) u konf fajlu
00006 //
00007 // Svaki primjer ima posebnu funkciju main() - otkomentirati
00008 
00009 
00010 // 0. primjer: kako ispitati fitnes jedinke (spremljene u ind.txt)
00011 
00012 
00013 
00014 
00015 
00016 // 1. primjer: GA OneMax problem
00017 /*
00018 #include "examples/GAonemax/OneMaxEvalOp.h"
00019 int main(int argc, char **argv)
00020 {
00021     argc = 2;   // hard coded za lakse isprobavanje :)
00022     argv[1] = "./examples/GAOneMax/parametri.txt";
00023 
00024     StateP state (new State);
00025 
00026     //state->setEvalOp(static_cast<EvaluateOpP> (new OneMaxEvalOp));
00027     state->setEvalOp(new OneMaxEvalOp);
00028 
00029     state->initialize(argc, argv);
00030     state->run();
00031 
00032     return 0;
00033 }
00034 */
00035 
00036 
00037 
00038 
00039 
00040 // 2. primjer: GA minimizacija funkcije
00041 
00042 #include "examples/GAFunctionMin/FunctionMinEvalOp.h"
00043 int main(int argc, char **argv)
00044 {
00045 //  argc = 2;
00046 //  argv[1] = "./examples/GAFunctionMin/parametri.txt";
00047 
00048     // PSO algoritam:
00049     //argv[1] = "./examples/GAFunctionMin/parameters_DE.txt";
00050 
00051     StateP state (new State);
00052     state->setEvalOp(new FunctionMinEvalOp);
00053 
00054     state->initialize(argc, argv);
00055     state->run();
00056 
00057 
00058 //
00059 //  ispis populacije u txt fajl, za potrebe landscape analysis  */
00060 //
00061 /*  ofstream fajl("popis.txt");
00062     for(uint i = 0; i < state->getPopulation()->getLocalDeme()->getSize(); i++) {
00063         IndividualP ind = state->getPopulation()->getLocalDeme()->at(i);
00064         fajl << ind->fitness->getValue() << "\t";
00065         FloatingPointP fp = boost::static_pointer_cast<FloatingPoint::FloatingPoint> (ind->getGenotype());
00066         for(uint dim = 0; dim < fp->realValue.size(); dim++)
00067             fajl << fp->realValue[dim] << "\t";
00068         fp = boost::static_pointer_cast<FloatingPoint::FloatingPoint> (ind->getGenotype(2));
00069         fajl << fp->realValue[0];
00070         fajl << "\n";
00071     }
00072 */
00073     return 0;
00074 }
00075 
00076 
00077 
00078 
00079 
00080 
00081 namespace Tree {
00082 
00083 // primjer tipa podataka
00084 struct my_type
00085 {
00086     double v;
00087     bool b;
00088 };
00089 
00090 // terminal za doticni tip
00091 class MyTerminal : public Primitives::Primitive
00092 {
00093 public:
00094     my_type value_;
00095 
00096     MyTerminal()
00097     {
00098         nArguments_ = 0;
00099     }
00100     void execute(void* result, Tree& tree)
00101     {
00102         my_type& res = *(my_type*)result;
00103         res = value_;
00104     }
00105     void setValue(void* value)
00106     {
00107         value_ = *(my_type*)value;
00108     }
00109     ~MyTerminal()
00110     {   }
00111 };
00112 
00113 // primjer funkcije za korisnicki tip podataka
00114 class MyFunc : public Primitives::Primitive
00115 {
00116 public:
00117     MyFunc()
00118     {
00119         nArguments_ = 2;
00120         name_ = "func";
00121     }
00122     void execute(void* result, Tree& tree)
00123     {
00124         my_type first, second;
00125         my_type& func = *(my_type*)result;
00126 
00127         getNextArgument(&first, tree);
00128         getNextArgument(&second, tree);
00129         
00130         func.b = first.b && second.b;
00131         func.v = first.v + second.v;
00132     }
00133     ~MyFunc()
00134     {   }
00135 };
00136 
00137 }
00138 
00139 
00140 
00141 // 3. primjer: GP simbolicka regresija
00142 /*
00143 #include "examples/GPSymbReg/SymbRegEvalOp.h"
00144 #include "examples/GPSymbReg/zbr.h"
00145 int main(int argc, char **argv)
00146 {
00147 //  argc = 2;
00148 //  argv[1] = "./examples/GPSymbReg/parametri.txt";
00149 
00150     StateP state = static_cast<StateP> (new State);
00151 
00152     state->setEvalOp(static_cast<EvaluateOpP> (new SymbRegEvalOp));
00153 
00154     // primjer: dodavanje korisnickog operatora
00155 //  MyOpP myOp = (MyOpP) (new MyOp);
00156 //  state->addOperator(myOp);
00157 
00158     // primjer: dodavanje korisnickog algoritma
00159 //  MyAlgP myAlg = (MyAlgP) (new MyAlg);
00160 //  state->addAlgorithm(myAlg);
00161 
00162     // primjer: dodavanje korisnickog genotipa
00163 //  MyGenotypeP myGenotype = (MyGenotypeP) (new MyGenotype);
00164 //  state->addGenotype(myGenotype);
00165 
00166     // primjer: dodavanje korisnicke funkcije za stablo
00167     TreeP tree = (TreeP) new Tree::Tree;
00168     Tree::PrimitiveP zbr = (Tree::PrimitiveP) new Tree::Ad;
00169     tree->addFunction(zbr);
00170 
00171 Tree::PrimitiveP myFunc = (Tree::PrimitiveP) new Tree::MyFunc;
00172 tree->addFunction(myFunc);
00173 
00174 Tree::PrimitiveP myTerm = (Tree::PrimitiveP) new Tree::MyTerminal;
00175 myTerm->setName("term");
00176 tree->addTerminal(myTerm);
00177 
00178 
00179     state->addGenotype(tree);
00180 
00181     //for(int i = 0; i < 100; i++) {
00182         state->initialize(argc, argv);
00183         state->run();
00184     //}
00185 
00186     //std::vector<IndividualP> vec = state->getPopulation()->hof_->getBest();
00187     //IndividualP ind = vec[0];
00188     //state->getAlgorithm()->evaluate(ind);
00189     //XMLNode out;
00190     //ind->write(out);
00191     //std::cout << out.createXMLString() << std::endl;
00192 
00193     std::vector<IndividualP> vec = state->getPopulation()->getHof()->getBest();
00194     IndividualP ind = vec[0];
00195     XMLNode xml2 = XMLNode::parseString("<Individual size=""1"" gen=""77""><FitnessMin value=""4.26326e-14""/><Tree size=""36"">+ + * * X * X X - * X X + X X + sin X * X * X X / - * X X X / / X X + X X </Tree></Individual>", "Individual");
00196     ind->read(xml2);
00197     state->getAlgorithm()->evaluate(ind);
00198     std::cout << ind->toString();
00199 
00200     return 0;
00201 }
00202 */
00203 
00204 
00205 //4. primjer: GA problem trgovackog putnika, 29 gradova
00206 /*
00207 #include "examples/GATSP/TSPEvalOp.h"
00208 int main(int argc, char **argv)
00209 {
00210 //  argc = 2;
00211 //  argv[1] = "./examples/GATSP/parameters.txt";
00212 
00213     StateP state = static_cast<StateP> (new State);
00214 
00215     state->setEvalOp(static_cast<EvaluateOpP> (new TSPEvalOp));
00216 
00217     state->initialize(argc, argv);
00218     //state->getFitnessObject();
00219 
00220     state->run();
00221 
00222     return 0;
00223 }
00224 */
00225 
00226 
00227 
00228 //5. primjer: GA problem aproksimacije funkcije
00229 /*
00230 #include "examples/GAApprox/ApproxEvalOp.h"
00231 int main(int argc, char **argv)
00232 {
00233 //  argc = 2;
00234 //  argv[1] = "./examples/GAApprox/parameters.txt";
00235 
00236     StateP state(new State);
00237 
00238     state->setEvalOp(EvaluateOpP (new AproxEvalOp));
00239 
00240     state->initialize(argc, argv);
00241     state->run();
00242 
00243     return 0;
00244 }
00245 */
00246 
00247 
00248 
00249 //6. primjer: GP evolucija pravila rasporedjivanja
00250 /*
00251 #include "examples/GPScheduling/SchedulingEvalOp.h"
00252 int main(int argc, char **argv)
00253 {
00254     argc = 2;
00255     //argv[1] = "./examples/GPScheduling/parameters.txt";
00256     argv[1] = "./parameters.txt";
00257 
00258     StateP state = static_cast<StateP> (new State);
00259 
00260     state->setEvalOp(static_cast<EvaluateOpP> (new SchedulingEvalOp));
00261 
00262     state->initialize(argc, argv);
00263     state->run();
00264 
00265 //  XMLNode xInd = XMLNode::parseFile("./ind.txt", "Individual");
00266 //  IndividualP ind = (IndividualP) new Individual(state);
00267 //  ind->read(xInd);
00268 //  state->getAlgorithm()->evaluate(ind);
00269 //  std::cout << ind->toString();
00270 
00271     return 0;
00272 }
00273 */
00274 
00275 
00276 //7. primjer: XCS
00277 /*
00278 #include "examples/XCSmux/MuxEvalOp.h"
00279 #include "examples/XCSmaze/SingleObjMazeEnv.h"
00280 #include "examples/XCSmaze/SeqObjMazeEnv.h"
00281 #include "examples/XCSmaze/TwoObjMazeEnv.h"
00282 #include "examples/XCSmaze/ThreeObjMazeEnv.h"
00283 
00284 int main(int argc, char **argv)
00285 {
00286     argc = 2;
00287     StateP state = static_cast<StateP> (new State);
00288     MazeEnvP maze;
00289 
00290     //Multistep:
00291 
00292     //  - sigle-objective maze:
00293         //argv[1] = "examples/XCSmaze/single-obj params.txt";
00294         //maze = static_cast<MazeEnvP> (new SingleObjMazeEnv(state));
00295         //maze->setMazeFile("examples/XCSmaze/Environments/single-objective/Maze1.txt");
00296 
00297     //  - multi-objective maze:
00298         //argv[1] = "examples/XCSmaze/seq-obj params.txt";
00299         //maze = static_cast<MazeEnvP> (new SeqObjMazeEnv(state));
00300         //maze->setMazeFile("examples/XCSmaze/Environments/multi-objective/Maze1k.txt");
00301     
00302         argv[1] = "examples/XCSmaze/three-obj params.txt";
00303         maze = static_cast<MazeEnvP> (new ThreeObjMazeEnv(state,0));
00304         maze->setMazeFile("examples/XCSmaze/Environments/multi-objective/Maze1em.txt");
00305     
00306     maze->setResultsFile("examples/XCSmaze/Maze1k results.txt");
00307     state->setEvalOp(maze);
00308     
00309     //Singlestep:
00310 
00311     //  - 6-multiplexor problem:
00312     //  argv[1] = "./examples/XCSmux/parametri.txt";
00313     //  state->setEvalOp(static_cast<EvaluateOpP> (new MuxEvalOp(state)));
00314 
00315     state->initialize(argc, argv);
00316 
00317     state->run();
00318 
00319     int a;
00320     cin >> a;
00321     return 0;
00322 }
00323 */
00324 
00325 
00326 
00327 //8. primjer: Kartezijski GP - feedforward
00328 /*
00329 #include "examples/CGPFeedForward/FeedForwardEvalOp.h"
00330 using namespace cart;
00331 
00332 int main(int argc, char **argv)
00333 {
00334     argc = 2;
00335     argv[1] = "./examples/CGPFeedForward/parametri.txt";
00336 
00337     StateP state (new State);
00338 
00339     //izabrati koji tip
00340     //state->setEvalOp(new cart::FeedForwardEvalOpInt);
00341     state->setEvalOp(static_cast<EvaluateOpP> (new cart::FeedForwardEvalOpDouble));
00342     //state->setEvalOp(static_cast<EvaluateOpP> (new cart::CircuitEvalOpUint));
00343 
00344     state->initialize(argc, argv);
00345     state->run();
00346 
00347     return 0;
00348 }
00349 */

Generated on Sat Jul 12 2014 07:29:31 for ECF by  doxygen 1.7.1