Node.h

Go to the documentation of this file.

#ifndef NODE_H
#define NODE_H
// Node
#include <vector>
#include <string>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>

using namespace std;

#include "Tree.h"

extern bool verbose;
extern bool outputAll;
extern bool globalUp;
extern bool rinputs;
extern bool calc;

void ipause();

class NodeList;//

class Node {
public:
    Node();
    virtual ~Node(){};
    Node &setValue(bool v){init = v; current = v; previous = v; return *this;};
    bool getValue(){return previous;};
    void setMut ( string m );
        void setName(string m){name = m;};
        void setMutRate(int i){mutRate = i;bMutRate=i;};
    virtual bool evaluate(NodeList &nl, int t)=0;
        virtual string getType(void)=0;
        virtual void reset(void)=0;
protected:
        bool init;
        string name;
        int mutRate;
        int bMutRate;
    string mutation;
    bool current;   // Current value at this time
    bool previous;  // Prior value value before this time
    int timeT;       // Last time this node was updated
};

class InputNode : public Node {
public:
    InputNode();
    virtual bool evaluate(NodeList &nl, int t);
        virtual string getType(void){return "Input";};
        virtual void reset(void);
    //bool evaluate_nonnoisy(NodeList &nl, int t);
    InputNode &setStart(int s) {start.push_back(s); return *this;};
    InputNode &setDosage(int d) {dosage.push_back(d); return *this;};
    InputNode &setDuration(int d) {duration.push_back(d); return *this;};
    InputNode &setInjectionValue() {injectionValue = !previous; return *this;};
        void setLevels(int,int);
    void checkDosages(void);
    void reverseParams(void);
    void printParams(void);
    void setNoise( bool );
    void setManual( bool );
    void setInputBitString( const string &, NodeList & );
    void setRange(int i, int j){high=i;low=j;};
    int getDos(void){return dosage[0];};
        //vector<> getInputBits( void );
private:
    int high, low;
    vector<int> start;    // Index to times to start different dosages
    vector<int> dosage;   // Percent chemical is present during time duration
    vector<int> duration; // Length of time dosage is available
    vector<bool> amount;   // Amount injected so far - vector of values of the window size
    string inputBitStr; //manually set input feed
    int NC_amount;      //Amount to keep track of for non-noisy inputs
    void amountInit( int );
    bool injectionValue;
    bool noisy;
    bool manual; //input bit string has been provided
        int on;

        //backup stuff
        bool set;
    vector<int> bstart;    // Index to times to start different dosages
    vector<int> bdosage;   // Percent chemical is present during time duration
    vector<int> bduration; // Length of time dosage is available
};

class OutputNode : public Node {
public:
    OutputNode();
    OutputNode &setSource(int s) {source = s; return *this;};
    virtual bool evaluate(NodeList &nl, int t);
        virtual string getType(void){return "Output";};
        virtual void reset(void){timeT=0; current = init; previous = init;};
private:
    int source;
};

class Mutant {
public:
    Mutant( const string & n, const string &m)
    {   
        name = n;
        mutation = m;
    };
    string getType (void) { return mutation; };
    string getName (void) { return name; };    
private:
    string name;
    string mutation;
};


class BooleanNode : public Node {
public:
    BooleanNode();
    virtual bool evaluate(NodeList &nl, int t);
        virtual void reset(void){timeT=0; current = init; previous = init;mutRate=bMutRate;};
        virtual string getType(void){return "Bool";};
        void mutate(int,int, string);
    BooleanNode &addDecision(string s);
    BooleanNode &addSource(int item);
        void simplify(void){path.simplify();};
        void setH(void){path.setH(sources.size()), mutTree.setH(sources.size());};
    BooleanNode &setTarget(bool b){target=b; return *this;};
private:
        Tree path;
        Tree mutTree;
    vector<int> sources;    // index into list of nodes
    int sourceSize() {return static_cast<int>(sources.size());};
    vector<int> table;
    int tableSize() {return static_cast<int>(table.size());};
    bool target;
};

class DelayNode : public Node {
public:
    DelayNode(int d=1);
    ~DelayNode();
    DelayNode(const DelayNode &r);
    const DelayNode &operator =(const DelayNode &);
    virtual bool evaluate(NodeList &nl, int t);
        virtual string getType(void){return "Delay";};
        virtual void reset(void){timeT=0; current = init; previous = init;};
    DelayNode &setDelay(int d);
    DelayNode &setSource(int s){source=s; return *this;};
private:
    int source;             // index into list of nodes
    int delay;
    int *pipeline;
};

class SustainNode : public Node {
public:
    SustainNode(int d=1);
    virtual bool evaluate(NodeList &nl, int t);
        virtual string getType(void){return "Sustain";};
        virtual void reset(void){timeT=0; current = init; previous = init;};
    SustainNode &setDuration(int d) {duration = d; return *this;};
    SustainNode &setSource(int s) {source=s; return *this;};
private:
    int source;
    int duration;
    int start;
};
#endif

---