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

#include <ecf/ECF.h>
#include "EvalOp.h"
#include <iostream>
#include <fstream>
#include <string.h>


extern "C" int balans(int *tt, int n);
extern "C" int anf_ai (int *tt, int n);
extern "C" int anf_deg (int *tt, int n);
extern "C" int wt_nl (int *tt, int n);
extern "C" int wt_spektar(int *tt, int n);
extern "C" int autokorelacija_rf(int *tt, int n);
extern "C" int autokorelacija_max(int *tt, int n);




// custom terminal class - boolean vector
class BoolV : public Tree::Primitives::Primitive
{
public:
    std::vector<bool> value_;

    BoolV()
    {
        nArguments_ = 0;
    }
    void execute(void* result, Tree::Tree& tree)
    {
        std::vector<bool>& res = *(std::vector<bool>*)result;
        res = value_;
    }
    void setValue(void* value)
    {
        value_ = *(std::vector<bool>*)value;
    }
    ~BoolV()
    {   }
};


//
// logicke funkcije
//

class Or: public Tree::Primitives::Primitive
{
public:
    Or()
    {
        nArguments_ = 2;
        name_ = "OR";
    }

    void execute(void* result, Tree::Tree& tree)
    {
        std::vector<bool>& or = *(std::vector<bool>*)result;
        uint size = (uint) or.size();

        std::vector<bool> arg1(size), arg2(size);

        getNextArgument(&arg1, tree);
        getNextArgument(&arg2, tree);

        for(uint i = 0; i < size; i++)
            or[i] = arg1[i] || arg2[i];
    }

    ~Or()
    {   }
};


class Xor: public Tree::Primitives::Primitive
{
public:
    Xor()
    {
        nArguments_ = 2;
        name_ = "XOR";
    }

    void execute(void* result, Tree::Tree& tree)
    {
        std::vector<bool>& xor = *(std::vector<bool>*)result;
        uint size = (uint) xor.size();

        std::vector<bool> arg1(size), arg2(size);

        getNextArgument(&arg1, tree);
        getNextArgument(&arg2, tree);

        for(uint i = 0; i < size; i++)
            xor[i] = (arg1[i] && !arg2[i]) || (!arg1[i] && arg2[i]);
    }

    ~Xor()
    {   }
};



class And: public Tree::Primitives::Primitive
{
public:
    And()
    {
        nArguments_ = 2;
        name_ = "AND";
    }

    void execute(void* result, Tree::Tree& tree)
    {
        std::vector<bool>& and = *(std::vector<bool>*)result;
        uint size = (uint) and.size();

        std::vector<bool> arg1(size), arg2(size);

        getNextArgument(&arg1, tree);
        getNextArgument(&arg2, tree);

        for(uint i = 0; i < size; i++)
            and[i] = arg1[i] && arg2[i];
    }

    ~And()
    {   }
};


class Not: public Tree::Primitives::Primitive
{
public:
    Not()
    {
        nArguments_ = 1;
        name_ = "NOT";
    }

    void execute(void* result, Tree::Tree& tree)
    {
        std::vector<bool>& not = *(std::vector<bool>*)result;
        uint size = (uint) not.size();

        std::vector<bool> arg1(size);
        getNextArgument(&arg1, tree);

        for(uint i = 0; i < size; i++)
            not[i] = !arg1[i];
    }

    ~Not()
    {   }
};


class If: public Tree::Primitives::Primitive
{
public:
    If()
    {
        nArguments_ = 3;
        name_ = "IF";
    }

    void execute(void* result, Tree::Tree& tree)
    {
        std::vector<bool>& res = *(std::vector<bool>*)result;
        uint size = (uint) res.size();

        std::vector<bool> arg(size), res1(size), res2(size);
        getNextArgument(&arg, tree);
        getNextArgument(&res1, tree);
        getNextArgument(&res2, tree);

        for(uint i = 0; i < size; i++)
            if(arg[i]) {
                res[i] = res1[i];
            } else {
                res[i] = res2[i];
            }
    }

    ~If()
    {   }
};


// 
// glavni program za citanje logova
//
int main(int argc, char **argv)
{

    argc = 2;
    argv[1] = "parameters.txt";

    ifstream par("parameters.txt");
    if(!par) {
        std::cout << "nema parameters.txt!\n";
        return 1;
    }
    par.close();

    StateP state (new State);

    // crate evaluation operator
    EvalOp* e = new EvalOp;
    state->setEvalOp(e);
    
    // create tree genotype
    TreeP tree (new Tree::Tree);
    
    // create new functions and add them to function set 
    Tree::PrimitiveP ifl (new If);
    tree->addFunction(ifl);
    Tree::PrimitiveP or (new Or);
    tree->addFunction(or);
    Tree::PrimitiveP and (new And);
    tree->addFunction(and);
    Tree::PrimitiveP not (new Not);
    tree->addFunction(not);
    Tree::PrimitiveP xor (new Xor);
    tree->addFunction(xor);

    // custom type terminals
    for(uint i = 0; i < 8; i++) {
        Tree::PrimitiveP myTerm = (Tree::PrimitiveP) new BoolV;
        std::string name = "v" + uint2str(i);
        myTerm->setName(name);
        tree->addTerminal(myTerm);
    }

    // register genotype with our primitives
    state->addGenotype(tree);

    // initialize
    if(!state->initialize(argc, argv))
        return 1;


//
// citaj pragove, logove, evaluiraj stablo, ispisi TT i zabiljezi pragove
//
    ifstream prag("pragovi.txt");
    if(!prag) {
        std::cout << "nema pragovi.txt!\n";
        return 1;
    }
    std::vector<int> pragovi, postignuto;
    int p, fajlova = 0;
    while(prag >> p) {
        pragovi.push_back(p);
        postignuto.push_back(0);
    }


    string logBase = "log_";
    string logExt = ".txt";
    int logStartNum = 1;
    int logEndNum = 0;

    stringstream input;
    string line;
    cout << " -- Korijen imena log fajla (enter - \"" << logBase << "\") : ";
    getline(cin, line);
    if(line != "") {
        input << line << endl;
        input >> logBase;
        input.str("");
    }

    cout << " -- Pocetni broj (enter - 01) : ";
    getline(cin, line);
    if(line != "") {
        input << line << endl;
        input >> logStartNum;
        input.str("");
    }

    cout << " -- Krajnji broj (enter - dok ima fajlova) : ";
    getline(cin, line);
    if(line != "") {
        input << line << endl;
        input >> logEndNum;
        input.str("");
    }

    cout << " -- Ekstenzija (enter - \"" << logExt << "\") : ";
    getline(cin, line);
    if(line != "") {
        input << line << endl;
        input >> logExt;
        input.str("");
    }

    int logNum = logStartNum;
    stringstream fileName;
    bool cont;

    do {
        fileName.str("");
        fileName << logBase;
        fileName.width(2);
        fileName.fill('0');
        fileName << logNum << logExt;

        cout << "Ime fajla: " << fileName.str() << endl;

        ifstream logFile(fileName.str().c_str());
        if(!logFile) {
            cout << " : nema!!" << endl;
            cont = false;
            break;
        }

        cout << " : otvoren!" << endl;

        // read individual from file
        XMLNode xHof = XMLNode::parseFile(fileName.str().c_str(), "HallOfFame");
        XMLNode xInd = xHof.getChildNode(0);
        IndividualP ind = (IndividualP) new Individual(state);
        ind->read(xInd);
        //std::cout << ind->toString();

        int vars;
        std::vector<int> tt = e->getTT(ind, vars);
        std::vector<int> rezultati;
        rezultati.resize(pragovi.size());

        std::cout << "TT: ";
        for(uint i = 0; i < tt.size(); i++)
            std::cout << tt[i];
        std::cout << "\n";


        rezultati[0] = balans(&tt[0], vars);
        rezultati[1] = anf_ai (&tt[0], vars);
        rezultati[2] = anf_deg (&tt[0], vars);
        rezultati[3] = wt_nl (&tt[0], vars);
        rezultati[4] = wt_spektar(&tt[0], vars);
        rezultati[5] = autokorelacija_rf(&tt[0], vars);
        rezultati[6] = autokorelacija_max(&tt[0], vars);

        std::cout << "Kriteriji: ";
        for(uint i = 0; i < rezultati.size(); i++) {
            std::cout << rezultati[i] << " ";
            if(rezultati[i] >= pragovi[i])
                postignuto[i]++;
        }
        std::cout << std::endl;
        fajlova++;


        logNum++;
        cont = false;
        if(logEndNum >= logNum || logFile)
            cont = true;

    } while(cont);

    std::cout << "ukupno logova: " << fajlova << "\n";
    std::cout << "Postoci pragova: \n";
    for(uint i = 0; i < pragovi.size(); i++)
        std::cout << 1. * postignuto[i] / fajlova << " ";
    std::cout << std::endl;

    system("pause");

    return 0;
}