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

D:/Projekt/ECF_trunk/examples/EvoCrypt/Boolean/citanje_GP.cpp

00001 #include <ecf/ECF.h>
00002 #include "EvalOp.h"
00003 #include <iostream>
00004 #include <fstream>
00005 #include <string.h>
00006 
00007 
00008 extern "C" int balans(int *tt, int n);
00009 extern "C" int anf_ai (int *tt, int n);
00010 extern "C" int anf_deg (int *tt, int n);
00011 extern "C" int wt_nl (int *tt, int n);
00012 extern "C" int wt_spektar(int *tt, int n);
00013 extern "C" int autokorelacija_rf(int *tt, int n);
00014 extern "C" int autokorelacija_max(int *tt, int n);
00015 
00016 
00017 
00018 
00019 // custom terminal class - boolean vector
00020 class BoolV : public Tree::Primitives::Primitive
00021 {
00022 public:
00023     std::vector<bool> value_;
00024 
00025     BoolV()
00026     {
00027         nArguments_ = 0;
00028     }
00029     void execute(void* result, Tree::Tree& tree)
00030     {
00031         std::vector<bool>& res = *(std::vector<bool>*)result;
00032         res = value_;
00033     }
00034     void setValue(void* value)
00035     {
00036         value_ = *(std::vector<bool>*)value;
00037     }
00038     ~BoolV()
00039     {   }
00040 };
00041 
00042 
00043 //
00044 // logicke funkcije
00045 //
00046 
00047 class Or: public Tree::Primitives::Primitive
00048 {
00049 public:
00050     Or()
00051     {
00052         nArguments_ = 2;
00053         name_ = "OR";
00054     }
00055 
00056     void execute(void* result, Tree::Tree& tree)
00057     {
00058         std::vector<bool>& or = *(std::vector<bool>*)result;
00059         uint size = (uint) or.size();
00060 
00061         std::vector<bool> arg1(size), arg2(size);
00062 
00063         getNextArgument(&arg1, tree);
00064         getNextArgument(&arg2, tree);
00065 
00066         for(uint i = 0; i < size; i++)
00067             or[i] = arg1[i] || arg2[i];
00068     }
00069 
00070     ~Or()
00071     {   }
00072 };
00073 
00074 
00075 class Xor: public Tree::Primitives::Primitive
00076 {
00077 public:
00078     Xor()
00079     {
00080         nArguments_ = 2;
00081         name_ = "XOR";
00082     }
00083 
00084     void execute(void* result, Tree::Tree& tree)
00085     {
00086         std::vector<bool>& xor = *(std::vector<bool>*)result;
00087         uint size = (uint) xor.size();
00088 
00089         std::vector<bool> arg1(size), arg2(size);
00090 
00091         getNextArgument(&arg1, tree);
00092         getNextArgument(&arg2, tree);
00093 
00094         for(uint i = 0; i < size; i++)
00095             xor[i] = (arg1[i] && !arg2[i]) || (!arg1[i] && arg2[i]);
00096     }
00097 
00098     ~Xor()
00099     {   }
00100 };
00101 
00102 
00103 
00104 class And: public Tree::Primitives::Primitive
00105 {
00106 public:
00107     And()
00108     {
00109         nArguments_ = 2;
00110         name_ = "AND";
00111     }
00112 
00113     void execute(void* result, Tree::Tree& tree)
00114     {
00115         std::vector<bool>& and = *(std::vector<bool>*)result;
00116         uint size = (uint) and.size();
00117 
00118         std::vector<bool> arg1(size), arg2(size);
00119 
00120         getNextArgument(&arg1, tree);
00121         getNextArgument(&arg2, tree);
00122 
00123         for(uint i = 0; i < size; i++)
00124             and[i] = arg1[i] && arg2[i];
00125     }
00126 
00127     ~And()
00128     {   }
00129 };
00130 
00131 
00132 class Not: public Tree::Primitives::Primitive
00133 {
00134 public:
00135     Not()
00136     {
00137         nArguments_ = 1;
00138         name_ = "NOT";
00139     }
00140 
00141     void execute(void* result, Tree::Tree& tree)
00142     {
00143         std::vector<bool>& not = *(std::vector<bool>*)result;
00144         uint size = (uint) not.size();
00145 
00146         std::vector<bool> arg1(size);
00147         getNextArgument(&arg1, tree);
00148 
00149         for(uint i = 0; i < size; i++)
00150             not[i] = !arg1[i];
00151     }
00152 
00153     ~Not()
00154     {   }
00155 };
00156 
00157 
00158 class If: public Tree::Primitives::Primitive
00159 {
00160 public:
00161     If()
00162     {
00163         nArguments_ = 3;
00164         name_ = "IF";
00165     }
00166 
00167     void execute(void* result, Tree::Tree& tree)
00168     {
00169         std::vector<bool>& res = *(std::vector<bool>*)result;
00170         uint size = (uint) res.size();
00171 
00172         std::vector<bool> arg(size), res1(size), res2(size);
00173         getNextArgument(&arg, tree);
00174         getNextArgument(&res1, tree);
00175         getNextArgument(&res2, tree);
00176 
00177         for(uint i = 0; i < size; i++)
00178             if(arg[i]) {
00179                 res[i] = res1[i];
00180             } else {
00181                 res[i] = res2[i];
00182             }
00183     }
00184 
00185     ~If()
00186     {   }
00187 };
00188 
00189 
00190 // 
00191 // glavni program za citanje logova
00192 //
00193 int main(int argc, char **argv)
00194 {
00195 
00196     argc = 2;
00197     argv[1] = "parameters.txt";
00198 
00199     ifstream par("parameters.txt");
00200     if(!par) {
00201         std::cout << "nema parameters.txt!\n";
00202         return 1;
00203     }
00204     par.close();
00205 
00206     StateP state (new State);
00207 
00208     // crate evaluation operator
00209     EvalOp* e = new EvalOp;
00210     state->setEvalOp(e);
00211     
00212     // create tree genotype
00213     TreeP tree (new Tree::Tree);
00214     
00215     // create new functions and add them to function set 
00216     Tree::PrimitiveP ifl (new If);
00217     tree->addFunction(ifl);
00218     Tree::PrimitiveP or (new Or);
00219     tree->addFunction(or);
00220     Tree::PrimitiveP and (new And);
00221     tree->addFunction(and);
00222     Tree::PrimitiveP not (new Not);
00223     tree->addFunction(not);
00224     Tree::PrimitiveP xor (new Xor);
00225     tree->addFunction(xor);
00226 
00227     // custom type terminals
00228     for(uint i = 0; i < 8; i++) {
00229         Tree::PrimitiveP myTerm = (Tree::PrimitiveP) new BoolV;
00230         std::string name = "v" + uint2str(i);
00231         myTerm->setName(name);
00232         tree->addTerminal(myTerm);
00233     }
00234 
00235     // register genotype with our primitives
00236     state->addGenotype(tree);
00237 
00238     // initialize
00239     if(!state->initialize(argc, argv))
00240         return 1;
00241 
00242 
00243 //
00244 // citaj pragove, logove, evaluiraj stablo, ispisi TT i zabiljezi pragove
00245 //
00246     ifstream prag("pragovi.txt");
00247     if(!prag) {
00248         std::cout << "nema pragovi.txt!\n";
00249         return 1;
00250     }
00251     std::vector<int> pragovi, postignuto;
00252     int p, fajlova = 0;
00253     while(prag >> p) {
00254         pragovi.push_back(p);
00255         postignuto.push_back(0);
00256     }
00257 
00258 
00259     string logBase = "log_";
00260     string logExt = ".txt";
00261     int logStartNum = 1;
00262     int logEndNum = 0;
00263 
00264     stringstream input;
00265     string line;
00266     cout << " -- Korijen imena log fajla (enter - \"" << logBase << "\") : ";
00267     getline(cin, line);
00268     if(line != "") {
00269         input << line << endl;
00270         input >> logBase;
00271         input.str("");
00272     }
00273 
00274     cout << " -- Pocetni broj (enter - 01) : ";
00275     getline(cin, line);
00276     if(line != "") {
00277         input << line << endl;
00278         input >> logStartNum;
00279         input.str("");
00280     }
00281 
00282     cout << " -- Krajnji broj (enter - dok ima fajlova) : ";
00283     getline(cin, line);
00284     if(line != "") {
00285         input << line << endl;
00286         input >> logEndNum;
00287         input.str("");
00288     }
00289 
00290     cout << " -- Ekstenzija (enter - \"" << logExt << "\") : ";
00291     getline(cin, line);
00292     if(line != "") {
00293         input << line << endl;
00294         input >> logExt;
00295         input.str("");
00296     }
00297 
00298     int logNum = logStartNum;
00299     stringstream fileName;
00300     bool cont;
00301 
00302     do {
00303         fileName.str("");
00304         fileName << logBase;
00305         fileName.width(2);
00306         fileName.fill('0');
00307         fileName << logNum << logExt;
00308 
00309         cout << "Ime fajla: " << fileName.str() << endl;
00310 
00311         ifstream logFile(fileName.str().c_str());
00312         if(!logFile) {
00313             cout << " : nema!!" << endl;
00314             cont = false;
00315             break;
00316         }
00317 
00318         cout << " : otvoren!" << endl;
00319 
00320         // read individual from file
00321         XMLNode xHof = XMLNode::parseFile(fileName.str().c_str(), "HallOfFame");
00322         XMLNode xInd = xHof.getChildNode(0);
00323         IndividualP ind = (IndividualP) new Individual(state);
00324         ind->read(xInd);
00325         //std::cout << ind->toString();
00326 
00327         int vars;
00328         std::vector<int> tt = e->getTT(ind, vars);
00329         std::vector<int> rezultati;
00330         rezultati.resize(pragovi.size());
00331 
00332         std::cout << "TT: ";
00333         for(uint i = 0; i < tt.size(); i++)
00334             std::cout << tt[i];
00335         std::cout << "\n";
00336 
00337 
00338         rezultati[0] = balans(&tt[0], vars);
00339         rezultati[1] = anf_ai (&tt[0], vars);
00340         rezultati[2] = anf_deg (&tt[0], vars);
00341         rezultati[3] = wt_nl (&tt[0], vars);
00342         rezultati[4] = wt_spektar(&tt[0], vars);
00343         rezultati[5] = autokorelacija_rf(&tt[0], vars);
00344         rezultati[6] = autokorelacija_max(&tt[0], vars);
00345 
00346         std::cout << "Kriteriji: ";
00347         for(uint i = 0; i < rezultati.size(); i++) {
00348             std::cout << rezultati[i] << " ";
00349             if(rezultati[i] >= pragovi[i])
00350                 postignuto[i]++;
00351         }
00352         std::cout << std::endl;
00353         fajlova++;
00354 
00355 
00356         logNum++;
00357         cont = false;
00358         if(logEndNum >= logNum || logFile)
00359             cont = true;
00360 
00361     } while(cont);
00362 
00363     std::cout << "ukupno logova: " << fajlova << "\n";
00364     std::cout << "Postoci pragova: \n";
00365     for(uint i = 0; i < pragovi.size(); i++)
00366         std::cout << 1. * postignuto[i] / fajlova << " ";
00367     std::cout << std::endl;
00368 
00369     system("pause");
00370 
00371     return 0;
00372 }

Generated on Thu Jul 13 2017 11:37:55 for ECF by  doxygen 1.7.1