SymbRegEvalOp.cpp

#include <cmath>
#include <ecf/ECF.h>
#include "SymbRegEvalOp.h"
 
 
// called only once, before the evolution – generates training data
bool SymbRegEvalOp::initialize(StateP state)
{
 
    state->getGenerationNo();
 
    nSamples = 20;
    T = 0.1;
    double v_0 = 3.0;
    double t = 0;
    double h_0 = 0;
    for(uint i = 0; i < nSamples; i++) {
        time.push_back(t);
        height.push_back(0.5 * 9.81 * t * t + v_0 * t + h_0);
        t += T;
    }
    return true;
}
 
 
FitnessP SymbRegEvalOp::evaluate(IndividualP individual)
{
/*
    static int nesto = 0;
    MOFitnessP mofit (new MOFitness);
    mofit->push_back((FitnessP) new FitnessMax);
    mofit->back()->setValue(0);
    mofit->push_back((FitnessP) new FitnessMin);
    mofit->back()->setValue(2 + nesto);
    nesto++;
    return mofit;
*/
 
    // 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 error = 0, value = 0;
    double result1, result2;
 
    // execute once for the first time step
    tree->setTerminalValue("t", &time[0]);
    tree->execute(&result1);
 
    for(uint i = 1; i < nSamples; i++) {
        //tree->setTerminalValue("h", &value);
 
        double valueEuler = value + T * result1;
 
        // get the y value of the current tree
        tree->setTerminalValue("t", &time[i]);
        tree->execute(&result2);
 
        // integrate (trapezoid scheme)
        value += 0.5 * T * (result1 + result2);
 
        // update results
        result1 = result2;
 
        // add the difference
        error += fabs(height[i] - value);
    }
    fitness->setValue(error);
 
    return fitness;
}