main.cpp

#include <ecf/ECF.h>
 
 
 
// the evaluation operator
//
class PrimeEvalOp : public EvaluateOp
{
public:
    FitnessP evaluate(IndividualP individual);
    bool initialize(StateP);
    std::vector<long int> domain;
    std::vector<long 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;
    //nSamples = 1928614;
    uint rec = nSamples;
    long 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
        long int result;
        tree->execute(&result);
        // interpret result
        double key = 1;
        if(abs(result) <= 1)
            key = 0;
        // count the errors
        value += abs(codomain[i] - key);
 
        /*if(codomain[i] == 0 && key == 1)
        {
            value += 1;
        }
        else if(codomain[i] == 1 && key == 0)
        {
            value += 1928614;
        }*/
 
    }
    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)
    {
        long int first, second;
        long int& division = *(long 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)
    {
        long int& arg = *(long int*)result;
        getNextArgument(&arg, tree);
 
        if(arg > 0)
            arg = (long 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)
    {
        long int first, second;
        long int& modulo = *(long 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;
}
 
 
 
int isPrime6k1_sp(unsigned long long int number)
{
    if (number == 0)
    {
        return 0;
    }
    else if (number == 1)
    {
        return 0;
    }
    else if (number < 4)
    {
        return 1;
    }
    else if (number % 2 == 0)
    {
        return 0;
    }
    else if (number < 9)
    {
        return true;
    }
    else if (number%3==0)
    {
        return 0;
    }
    else
    {
        unsigned long long int up_range;
        up_range = (unsigned long long int) sqrt(1. * number);
 
        unsigned long long int tmp = 5;
 
        while (tmp<=up_range)
        {
            if (number%tmp==0)
            {
                return 0;
            }
            if (number%(tmp+2)==0)
            {
                return 0;
            }
 
            tmp = tmp + 6;
        }
 
        return 1;
    }
}
 
 
// 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<long int>);
    tree->addFunction(mul);
    Tree::PrimitiveP div (new DivInt);
    tree->addFunction(div);
    Tree::PrimitiveP add (new Tree::Primitives::AddT<long int>);
    tree->addFunction(add);
    Tree::PrimitiveP sub (new Tree::Primitives::SubT<long 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();
 
 
    printf("\n\n");
    showTree(best);
    printf("\n\n");
 
 
    long int i;
    for(i=32582658; i < 260000000; i++)
    {
        if( isPrime6k1_sp(i) == 1 )
        {
            if( !(isPrime6k1_sp(2*i+1) == 1 && i % 4 == 3) )
            {
                best->setTerminalValue("X", &i);
                // get the y value of the current tree
                long int result;
                best->execute(&result);
                // interpret result
                double key = 1;
                if(abs(result) <= 1)
                    key = 0;
                // count the errors
                if( key == 1)
                {
                    printf("%ld\n", i);
                }
            }
        }
 
        if(i % 100000 == 0)
            cout << ".";
 
    }
 
 
    return 0;
}