main_moj.cpp

#include <ecf/ECF.h>
 
 
 
// the evaluation operator
//
class PrimeEvalOp : public EvaluateOp
{
public:
    FitnessP evaluate(IndividualP individual);
    bool initialize(StateP);
    std::vector<int> domain;
    std::vector<int> codomain;
    uint nSamples;
};
 
 
// called only once, before the evolution – reads training data
bool PrimeEvalOp::initialize(StateP state)
{
    // open data
    ifstream input("list.txt");
    // how many samples
    nSamples = 1000;
    uint rec = nSamples;
    int x, y;
 
    while(rec--) {
        input >> x >> y;
        domain.push_back(x);
        codomain.push_back(y);
    }
 
    return true;
 
    // the original sample training data
/*  nSamples = 10;
    int x = 0;
    for(uint i = 0; i < nSamples; i++) {
        domain.push_back(x);
        codomain.push_back(2*x + (int) sqrt(1.*x) + x%3);
        x += 2;
    }
    return true;
*/
}
 
 
FitnessP PrimeEvalOp::evaluate(IndividualP individual)
{
    // we try to minimize the function value, so we use FitnessMin fitness (for minimization problems)
    FitnessP fitness (new FitnessMin);
 
    // get the genotype we defined in the configuration file
    Tree::Tree* tree = (Tree::Tree*) individual->getGenotype().get();
    // (you can also use boost smart pointers:)
    //TreeP tree = boost::static_pointer_cast<Tree::Tree> (individual->getGenotype());
 
    double value = 0;
    for(uint i = 0; i < nSamples; i++) {
        // for each test data instance, the x value (domain) must be set
        tree->setTerminalValue("X", &domain[i]);
        // get the y value of the current tree
        int result;
        tree->execute(&result);
        // interpret result
        double key = 1;
        if(abs(result) <= 1)
            key = 0;
        // count the errors
        value += abs(codomain[i] - key);
    }
    fitness->setValue(value);
 
    return fitness;
}
 
 
 
 
// integer functions for tree elements
//
 
//
// inherit the Div primitive to define handling integers
//
class DivInt : public Tree::Primitives::Div
{
public:
    void execute(void* result, Tree::Tree &tree)
    {
        int first, second;
        int& division = *(int*)result;
        getNextArgument(&first, tree);
        getNextArgument(&second, tree);
 
        // T must be auto castable to double!
        division = abs(second) > 0.000000001 ? first / second : 1;
    }
};
 
 
// 
// square root function for integers
//
class Sqrt : public Tree::Primitives::Primitive
{
public:
    Sqrt()
    {
        nArguments_ = 1;
        name_ = "sqrt";
    }
    void execute(void* result, Tree::Tree& tree)
    {
        int& arg = *(int*)result;
        getNextArgument(&arg, tree);
 
        if(arg > 0)
            arg = (int) sqrt(1. * arg);
        else
            arg = 0;
    }
    ~Sqrt()
    {   }
};
 
 
// 
// modulo function for integers
//
class Mod : public Tree::Primitives::Primitive
{
public:
    Mod()
    {
        nArguments_ = 2;
        name_ = "%";
    }
    void execute(void* result, Tree::Tree& tree)
    {
        int first, second;
        int& modulo = *(int*)result;
        getNextArgument(&first, tree);
        getNextArgument(&second, tree);
 
        modulo = first;
        if(second != 0)
            modulo = first % second;
    }
    ~Mod()
    {   }
};
 
 
 
 
uint showTree(Tree::Tree* tree, uint iNode = 0, uint prefix = 0)
{
    Tree::PrimitiveP prim = tree->at(iNode)->primitive_;
    int arity = prim->getNumberOfArguments();
 
    if(arity == 0) {
        cout << prim->getName();
    }
    else if(prim->getName() == "pow") {
        cout << "pow(";
            iNode++;
            iNode = showTree(tree, iNode, prefix);
        cout << ",";
            iNode++;
            iNode = showTree(tree, iNode, prefix);
        cout << ")";
    }
    else if(arity == 2) {
        cout << "(";
            iNode++;
            iNode = showTree(tree, iNode, prefix);
        cout << prim->getName();
            iNode++;
            iNode = showTree(tree, iNode, prefix);
        cout << ")";
    }
    else {
        cout << prim->getName();
        cout << "(";
        for(int child = 0; child < arity; child++) {
            iNode++;
            iNode = showTree(tree, iNode, prefix);
        }
        cout << ")";
    }
    return iNode;
}
 
 
 
 
// main program
//
int main(int argc, char **argv)
{
    StateP state (new State);
 
    // set the evaluation operator
    state->setEvalOp(new PrimeEvalOp);
 
    // create tree genotype
    TreeP tree (new Tree::Tree);
 
    // create functions for integer variables and add them to function set
    Tree::PrimitiveP mul (new Tree::Primitives::MulT<int>);
    tree->addFunction(mul);
    Tree::PrimitiveP div (new DivInt);
    tree->addFunction(div);
    Tree::PrimitiveP add (new Tree::Primitives::AddT<int>);
    tree->addFunction(add);
    Tree::PrimitiveP sub (new Tree::Primitives::SubT<int>);
    tree->addFunction(sub);
    Tree::PrimitiveP sqrt (new Sqrt);
    tree->addFunction(sqrt);
    Tree::PrimitiveP mod (new Mod);
    tree->addFunction(mod);
 
    // register genotype with our primitives
    state->addGenotype(tree);
 
    state->initialize(argc, argv);
    state->run();
 
    Tree::Tree* best = (Tree::Tree*) state->getHoF()->getBest().at(0)->getGenotype().get();
    showTree(best);
 
 
    return 0;
}