/home/coin/SVN-release/CoinAll-1.1.0/OS/src/OSCommonInterfaces/OSnLNode.h

Go to the documentation of this file.

#ifndef OSNLNODE_H
#define OSNLNODE_H
#include<iostream>
#include<vector>
#include <map> 
#include<cppad/cppad.hpp>

 enum OP_CODES{
        OS_PLUS = 1001,
        OS_SUM = 1002,
        OS_MINUS = 1003,
        OS_NEGATE = 1004,
        OS_TIMES = 1005,
        OS_DIVIDE = 1006,
        OS_POWER = 1009,
        OS_PRODUCT = 1010,
        OS_ABS = 2001,
        OS_SQUARE = 2005,
        OS_SQRT = 2006,
        OS_LN = 2007,
        OS_EXP = 2010,
        OS_SIN = 3001,
        OS_COS = 3002,
        OS_MIN = 4010,
        OS_MAX = 4011,
        OS_NUMBER = 5001,
        OS_PI = 5003,
        OS_E = 5004,
        OS_VARIABLE = 6001,
        OS_IF = 7001,
        OS_ALLDIF = 7016
};

using CppAD::AD;
using CppAD::vector;

class OSnLNode{  

public: 

        
        std::string snodeName;
        
        int inumberOfChildren;  

        int inodeInt;

        int inodeType;
        
        OSnLNode **m_mChildren;
        
        double m_dFunctionValue;
        

        AD<double> m_CppADTape;

        virtual std::string getTokenNumber();
        
        virtual std::string getTokenName();
        
        virtual  std::string getNonlinearExpressionInXML();

        OSnLNode* createExpressionTreeFromPostfix(std::vector<OSnLNode*> nlNodeVec);


        OSnLNode* createExpressionTreeFromPrefix(std::vector<OSnLNode*> nlNodeVec);
        
        std::vector<OSnLNode*> getPrefixFromExpressionTree();
        
        std::vector<OSnLNode*> preOrderOSnLNodeTraversal( std::vector<OSnLNode*> *prefixVector);
        
        std::vector<OSnLNode*> getPostfixFromExpressionTree();

        std::vector<OSnLNode*> postOrderOSnLNodeTraversal( std::vector<OSnLNode*> *postfixVector);

        virtual void getVariableIndexMap(std::map<int, int> *varIdx);
        

        virtual double calculateFunction(double *x) = 0;
        
                
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD) = 0;

        virtual OSnLNode *cloneOSnLNode() = 0;
        

        
        OSnLNode();

        virtual ~OSnLNode();
        
};//end OSnLNode

class OSnLNodePlus : public OSnLNode{  
public:
        OSnLNodePlus();

        ~OSnLNodePlus();
        
        virtual double calculateFunction( double *x);
        
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        
        virtual OSnLNode *cloneOSnLNode() ;

};//end OSnLNodePlus

class OSnLNodeSum : public OSnLNode{  
public:
        OSnLNodeSum();

        ~OSnLNodeSum();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
                 
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        
        


};//end OSnLNodeSum

class OSnLNodeMax : public OSnLNode{  
public:
        OSnLNodeMax();

        ~OSnLNodeMax();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
        
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        


};//end OSnLNodeMax

class OSnLNodeMin : public OSnLNode{  
public:
        OSnLNodeMin();

        ~OSnLNodeMin();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
        
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        


};//end OSnLNodeMin


class OSnLNodeMinus : public OSnLNode{  
public:
        OSnLNodeMinus();

        ~OSnLNodeMinus();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
                 
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        


};//end OSnLNodeMinus

class OSnLNodeNegate : public OSnLNode{  
public:
        OSnLNodeNegate();

        ~OSnLNodeNegate();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
        
                 
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);


};//end OSnLNodeNegate


class OSnLNodeTimes : public OSnLNode{  
public:
        OSnLNodeTimes();

        ~OSnLNodeTimes();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
         
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        


};//end OSnLNodeTimes


class OSnLNodeDivide : public OSnLNode{  
public:
        OSnLNodeDivide();

        ~OSnLNodeDivide();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
                 
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);

};//end OSnLNodeDivide

class OSnLNodePower : public OSnLNode{  
public:
        OSnLNodePower();

        ~OSnLNodePower();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
                 
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        


};//end OSnLNodePower

class OSnLNodeProduct : public OSnLNode{  
public:
        OSnLNodeProduct();

        ~OSnLNodeProduct();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
         
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        


};//end OSnLNodeProduct


class OSnLNodeLn : public OSnLNode{  
public:
        OSnLNodeLn();

        ~OSnLNodeLn();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
                 
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        

        

};//end OSnLNodeLn

class OSnLNodeSqrt : public OSnLNode{  
public:
        OSnLNodeSqrt();

        ~OSnLNodeSqrt();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;      
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        

        

};//end OSnLNodeSqrt

class OSnLNodeSquare : public OSnLNode{  
public:
        OSnLNodeSquare();

        ~OSnLNodeSquare();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
         
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);

};//end OSnLNodeSquare

class OSnLNodeCos : public OSnLNode{  
public:
        OSnLNodeCos();

        ~OSnLNodeCos();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
         
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);

};//end OSnLNodeCos

class OSnLNodeSin : public OSnLNode{  
public:
        OSnLNodeSin();

        ~OSnLNodeSin();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
         
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);

};//end OSnLNodeSin

class OSnLNodeExp : public OSnLNode{  
public:
        OSnLNodeExp();

        ~OSnLNodeExp();
        
        virtual double calculateFunction( double *x);
        
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        
        virtual OSnLNode *cloneOSnLNode() ;

};//end OSnLNodeExp

class OSnLNodeAbs : public OSnLNode{  
public:
        OSnLNodeAbs();

        ~OSnLNodeAbs();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
                 
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        


};//end OSnLNodeAbs

class OSnLNodeIf : public OSnLNode{  
public:
        OSnLNodeIf();

        ~OSnLNodeIf();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
                 
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);  
        


};//end OSnLNodeIf

class OSnLNodeNumber : public OSnLNode{  
public:
        
        double value;
        std::string type;
        std::string id;

        OSnLNodeNumber();

        ~OSnLNodeNumber();
        
        virtual std::string getTokenNumber();
        
        
        virtual std::string getTokenName();
        
        virtual std::string getNonlinearExpressionInXML();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
        
                 
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        


};//end OSnLNodeNumber


class OSnLNodeE : public OSnLNode{  
public:

        OSnLNodeE();

        ~OSnLNodeE();
        
        virtual std::string getTokenNumber();
        
        
        virtual std::string getTokenName();
        
        virtual std::string getNonlinearExpressionInXML();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
        
                 
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        


};//end OSnLNodeE

class OSnLNodePI : public OSnLNode{  
public:

        OSnLNodePI();

        ~OSnLNodePI();
        
        virtual std::string getTokenNumber();
        
        
        virtual std::string getTokenName();
        
        virtual std::string getNonlinearExpressionInXML();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
        
                 
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        


};//end OSnLNodePI


class OSnLNodeVariable : public OSnLNode{  
public:

        double coef;
        
        int idx;

        OSnLNodeVariable();

        ~OSnLNodeVariable();
        
        virtual void getVariableIndexMap(std::map<int, int> *varIdx);
        
        virtual std::string getTokenNumber();
        
        
        virtual std::string getTokenName();
        
        virtual std::string getNonlinearExpressionInXML();
        
        virtual double calculateFunction( double *x);

        virtual OSnLNode *cloneOSnLNode() ;
                 
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);  
        


};//end OSnLNodeVariable

class OSnLNodeAllDiff : public OSnLNode{  
public:
        OSnLNodeAllDiff();

        ~OSnLNodeAllDiff();
        
        virtual double calculateFunction( double *x);
        
        virtual OSnLNode *cloneOSnLNode() ;
                 
        virtual AD<double> constructCppADTape(std::map<int, int> *cppADIdx, CppAD::vector< AD<double> > *XAD);
        


};//end OSnLNodeAllDiff

/* 
TO DO:

1.  Allow for a variable node with a child

2.  When we create the Expression Tree from postfix, do we check if the coefficient of a variable is 1?
*/
#endif

---