main.cpp

#include <ecf/ECF.h>
//#include "GEPSymbRegEvalOp.h"
#include "GPSymbRegEvalOp.h"
#include "FileDataWriter.h"
#include "WriteBest.h"
 
#include "Sqrt.h"
#include "Log.h"
 
#include "IATree.h"
#include "IAAdd.h"
#include "IASub.h"
#include "IAMul.h"
#include "IADiv.h"
#include "IASin.h"
#include "IACos.h"
#include "IASqrt.h"
#include "IALog.h"
#include "IATerminal.h"
 
 
 
int main(int argc, char **argv)
{
    StateP state (new State);
 
    // set the evaluation operator
    GPSymbRegEvalOp *op = new GPSymbRegEvalOp;
    DataWriter dataWriter;
    op->dataWriter = &dataWriter;
    state->setEvalOp(op);
 
    TreeP tree = (TreeP) new Tree::Tree;
    Tree::Primitives::PrimitiveP sqrtPrimitive = (Tree::Primitives::PrimitiveP) new Tree::Primitives::Sqrt;
    tree->addFunction(sqrtPrimitive);
    Tree::Primitives::PrimitiveP logPrimitive = (Tree::Primitives::PrimitiveP) new Tree::Primitives::Log;
    tree->addFunction(logPrimitive);
    state->addGenotype(tree);
 
    Tree::IATreeP iaTree(new Tree::IATree);
    // create new functions and add them to function set
    Tree::PrimitiveP iaAdd(new IAAdd);
    iaTree->addFunction(iaAdd);
    Tree::PrimitiveP iaSub(new IASub);
    iaTree->addFunction(iaSub);
    Tree::PrimitiveP iaMul(new IAMul);
    iaTree->addFunction(iaMul);
    Tree::PrimitiveP iaDiv(new IADiv);
    iaTree->addFunction(iaDiv);
    Tree::PrimitiveP iaSin(new IASin);
    iaTree->addFunction(iaSin);
    Tree::PrimitiveP iaCos(new IACos);
    iaTree->addFunction(iaCos);
    Tree::PrimitiveP iaSqrt(new IASqrt);
    iaTree->addFunction(iaSqrt);
    Tree::PrimitiveP iaLog(new IALog);
    iaTree->addFunction(iaLog);
 
    // custom type terminals
    for(uint i = 0; i < 20; i++) {
        Tree::PrimitiveP myTerm = (Tree::PrimitiveP) new IATerminal;
        std::string name = "x" + uint2str(i);
        myTerm->setName(name);
        iaTree->addTerminal(myTerm);
    }
 
    state->addGenotype(iaTree);
 
    // add writeout of best individual each generation
    state->addOperator((OperatorP) new WriteBest);
 
    // initialize & run
    state->initialize(argc, argv);
 
    if (argc >= 4) {
        // read best solution from the file (argv[2]), evaluate it on test data and save to out file (argv[3])
        XMLNode xInd = XMLNode::parseFile(argv[2], "Individual");
        IndividualP ind = (IndividualP) new Individual(state);
        ind->read(xInd);
        // std::cout << ind->toString();
 
        // print linear scaling parameters
        op->printParams = true;
        std::string testOutFile(argv[3]);
        FileDataWriter fileDataWriter(testOutFile);
        op->dataWriter = &fileDataWriter;
        state->getEvalOp()->evaluate(ind);
        dataWriter.close();
    } else {
        // run experiment
        state->run();
 
        // after the evolution: show best evolved ant's behaviour on learning trails
        std::vector<IndividualP> hof = state->getHoF()->getBest();
        IndividualP ind = hof[0];
        // std::cout << ind->toString();
        
        // print linear scaling parameters
        op->printParams = true;
        state->getEvalOp()->evaluate(ind);
    }
    
    return 0;
}