Cartesian_c.h

#ifndef Cartesian_h
#define Cartesian_h
#include "../ECF_base.h"
#include "../Genotype.h"
#include "Node.h"
#include "Function.h"
 
 
namespace Cartesian {

 
class FunctionSet;
typedef std::shared_ptr<FunctionSet> FunctionSetP;
 

class Cartesian : public Genotype
{
public:
    Cartesian(void);
    ~Cartesian(void);
 
    Cartesian(const Cartesian& other) = default;

    bool initialize(StateP state);

    Cartesian* copy();

    std::vector<CrossoverOpP> getCrossoverOp();

    std::vector<MutationOpP> getMutationOp();

    void registerParameters(StateP state);

    void read(XMLNode &xCart);

    void write(XMLNode &xCart);

    uint getGenomeSize();

    void buildRandomGenome();

    void evaluate(std::vector<double>& inputData, std::vector<double>& results);

    uint randomNodeInputConnection(uint column);

    uint randomOutputConnection();

    void getActiveFunctionNodes(std::vector<uint>&);
 
protected:
    void addRecursivelyActiveFunctionNodes(std::vector<bool>& activeFlags, uint node);
 
public:
    StateP state_;                  
    FunctionSetP functionSet_;      
    std::vector<Node> nodes_;       
    std::vector<uint> outputs_;     
    std::vector<double> constants_; 
 
    // user defined parameters
    uint nVariables_;               
    uint nConstants_;               
    uint nOutputs_;                 
    uint nRows_;                    
    uint nCols_;                    
    uint nLevelsBack_;              
    uint nFunctions_;               
 
    // derived parameters
    uint nInputs_;                  
    uint maxArity_;                 
};
 
}
typedef std::shared_ptr<Cartesian::Cartesian> CartesianP;
 
#endif // Cartesian_h