Cartesian_genotype.h

#ifndef ECF_CARTESIAN_CARTESIAN_GENOTYPE_H
#define ECF_CARTESIAN_CARTESIAN_GENOTYPE_H
#include <vector>
#include <set>
#include <ECF_base.h>
#include <Genotype.h>
#include "CartesianGene.h"
namespace cartesian
{
    class FunctionSet;
    typedef boost::shared_ptr<FunctionSet> FunctionSetP;
    class Cartesian : public std::vector<CartesianGene>, public Genotype
    {
    public:
        Cartesian(void);
        ~Cartesian(void){};
 
        bool initialize(StateP state);
        Cartesian* copy();
 
        vector<CrossoverOpP> getCrossoverOp();
 
        vector<MutationOpP> getMutationOp();
 
        void registerParameters(StateP state);
 
        void read(XMLNode &xCart);
 
        void write(XMLNode &xCart);
 
        uint getRowNumber(uint index);
 
        uint getGenomeSize();
 
        uint randomConnectionGenerator(uint rowNumber);
 
        std::set<uint> allPossibleConnection(uint rowNumber);
 
        void buildRandomGenome();
 
        std::vector<uint> getActiveTrail(uint output_number);
 
        std::vector<std::vector<uint> > getActiveTrails();
 
        void evaluate(const vector<double>& inputData, vector<double>& results);
 
        int get_random_int(int from, int to);
 
        double get_random_double(int from, int to);
 
        static double static_random_double(int from, int to);
 
    public:
        StateP state_;                  
 
        // user defined parameters
        uint nVariables;                
        uint nConstants;                
        uint nOutputs;                  
        uint nRows;                     
        uint nCols;                     
        uint nLevelsBack;               
        uint nFunctions;                
 
        // derived parameters
        uint nInputs;                   
        uint maxArity;                  
 
        FunctionSetP functionSet_;
 
    };
}
typedef boost::shared_ptr<cartesian::Cartesian> CartesianP;
#endif //ECF_CARTESIAN_CARTESIAN_GENOTYPE_H