OSnLNode.h

Go to the documentation of this file.

/* $Id: OSnLNode.h 5284 2017-12-08 13:52:50Z stefan $ */
#ifndef OSNLNODE_H
#define OSNLNODE_H
 
#include "OSConfig.h"
#include "OSGeneral.h"
#include "OSErrorClass.h"
#include <iostream>
#include <vector>
#include <map>
 
#ifdef OS_HAS_CPPAD
# include <cppad/cppad.hpp>
typedef CppAD::AD<double>  ADdouble;
typedef CppAD::vector<ADdouble> ADvector;
#else
typedef double  ADdouble;
typedef std::vector<ADdouble> ADvector;
#endif
 
class OSnLNode;
class OSnLMNode;
class OSMatrix;
 
class ExprNode
{
public:
 
    int inodeInt;
 
    int inodeType;
 
    unsigned int inumberOfChildren;
 
    unsigned int inumberOfMatrixChildren;
 
    OSnLNode **m_mChildren;
 
    OSnLMNode **m_mMatrixChildren;
 
 
    ExprNode();
 
    virtual ~ExprNode();
 
 
    virtual std::string getTokenNumber();
 
    virtual std::string getTokenName() = 0;
 
    virtual std::string getNonlinearExpressionInXML();
 
    virtual std::vector<ExprNode*> getPrefixFromExpressionTree();
 
    virtual std::vector<ExprNode*> preOrderOSnLNodeTraversal( std::vector<ExprNode*> *prefixVector);
 
    virtual std::vector<ExprNode*> getPostfixFromExpressionTree();
 
    virtual std::vector<ExprNode*> postOrderOSnLNodeTraversal( std::vector<ExprNode*> *postfixVector);
 
    virtual ExprNode *cloneExprNode() = 0;
 
    virtual bool IsEqual(ExprNode *that);
};//end ExprNode
 
 
class OSnLNode: public ExprNode
{
public:
    double m_dFunctionValue;
 
    ADdouble m_ADTape;
 
 
    OSnLNode();
 
    virtual ~OSnLNode();
 
 
    virtual void getVariableIndexMap(std::map<int, int> *varIdx);
 
    virtual double calculateFunction(double *x) = 0;
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD) = 0;
 
    OSnLNode* createExpressionTreeFromPrefix(std::vector<ExprNode*> nlNodeVec);
 
    virtual std::vector<ExprNode*> getPrefixFromExpressionTree();
 
    virtual std::vector<ExprNode*> preOrderOSnLNodeTraversal( std::vector<ExprNode*> *prefixVector);
 
    OSnLNode* createExpressionTreeFromPostfix(std::vector<ExprNode*> nlNodeVec);
 
    virtual std::vector<ExprNode*> getPostfixFromExpressionTree();
 
    virtual std::vector<ExprNode*> postOrderOSnLNodeTraversal( std::vector<ExprNode*> *postfixVector);
 
    virtual OSnLNode* copyNodeAndDescendants();
 
    bool IsEqual(OSnLNode *that);
};//end OSnLNode
 
 
class OSnLNodePlus : public OSnLNode
{
public:
    OSnLNodePlus();
 
    ~OSnLNodePlus();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
 
    virtual OSnLNode *cloneExprNode();
 
};//end OSnLNodePlus
 
class OSnLNodeSum : public OSnLNode
{
public:
    OSnLNodeSum();
 
    ~OSnLNodeSum();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodeSum
 
class OSnLNodeMax : public OSnLNode
{
public:
    OSnLNodeMax();
 
    ~OSnLNodeMax();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodeMax
 
class OSnLNodeMin : public OSnLNode
{
public:
    OSnLNodeMin();
 
    ~OSnLNodeMin();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
 
};//end OSnLNodeMin
 
 
class OSnLNodeMinus : public OSnLNode
{
public:
    OSnLNodeMinus();
 
    ~OSnLNodeMinus();
 
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodeMinus
 
 
class OSnLNodeNegate : public OSnLNode
{
public:
    OSnLNodeNegate();
 
    ~OSnLNodeNegate();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodeNegate
 
 
class OSnLNodeTimes : public OSnLNode
{
public:
    OSnLNodeTimes();
 
    ~OSnLNodeTimes();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
 
};//end OSnLNodeTimes
 
 
class OSnLNodeDivide : public OSnLNode
{
public:
    OSnLNodeDivide();
 
    ~OSnLNodeDivide();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodeDivide
 
 
class OSnLNodePower : public OSnLNode
{
public:
    OSnLNodePower();
 
    ~OSnLNodePower();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodePower
 
 
class OSnLNodeProduct : public OSnLNode
{
public:
    OSnLNodeProduct();
 
    ~OSnLNodeProduct();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodeProduct
 
 
class OSnLNodeLn : public OSnLNode
{
public:
    OSnLNodeLn();
 
    ~OSnLNodeLn();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodeLn
 
 
class OSnLNodeSqrt : public OSnLNode
{
public:
    OSnLNodeSqrt();
 
    ~OSnLNodeSqrt();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodeSqrt
 
 
class OSnLNodeSquare : public OSnLNode
{
public:
    OSnLNodeSquare();
 
    ~OSnLNodeSquare();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodeSquare
 
 
class OSnLNodeCos : public OSnLNode
{
public:
    OSnLNodeCos();
 
    ~OSnLNodeCos();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodeCos
 
 
class OSnLNodeSin : public OSnLNode
{
public:
    OSnLNodeSin();
 
    ~OSnLNodeSin();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodeSin
 
 
class OSnLNodeExp : public OSnLNode
{
public:
    OSnLNodeExp();
 
    ~OSnLNodeExp();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
 
    virtual OSnLNode *cloneExprNode();
};//end OSnLNodeExp
 
 
class OSnLNodeAbs : public OSnLNode
{
public:
    OSnLNodeAbs();
 
    ~OSnLNodeAbs();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodeAbs
 
 
class OSnLNodeErf : public OSnLNode
{
public:
    OSnLNodeErf();
 
    ~OSnLNodeErf();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodeErf
 
 
class OSnLNodeIf : public OSnLNode
{
public:
    OSnLNodeIf();
 
    ~OSnLNodeIf();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodeIf
 
 
class OSnLNodeNumber : public OSnLNode
{
public:
    double value;
 
    std::string type;
 
    std::string id;
 
    OSnLNodeNumber();
 
    ~OSnLNodeNumber();
 
    virtual std::string getTokenName();
 
    virtual std::string getTokenNumber();
 
    virtual std::string getNonlinearExpressionInXML();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual OSnLNode* copyNodeAndDescendants();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
 
    virtual bool IsEqual(OSnLNodeNumber *that);
};//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 *cloneExprNode();
 
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *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 *cloneExprNode();
 
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *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 *cloneExprNode();
 
    virtual OSnLNode* copyNodeAndDescendants();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
 
    virtual bool IsEqual(OSnLNodeVariable *that);
};//end OSnLNodeVariable
 
 
class OSnLNodeAllDiff : public OSnLNode
{
public:
    OSnLNodeAllDiff();
 
    ~OSnLNodeAllDiff();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual OSnLNode *cloneExprNode();
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
};//end OSnLNodeAllDiff
 
 
class OSnLNodeMatrixDeterminant : public OSnLNode
{
public:
    OSnLNodeMatrixDeterminant();
 
    ~OSnLNodeMatrixDeterminant();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
 
    virtual OSnLNode *cloneExprNode();
 
};//end OSnLNodeMatrixDeterminant
 
class OSnLNodeMatrixTrace : public OSnLNode
{
public:
    OSnLNodeMatrixTrace();
 
    ~OSnLNodeMatrixTrace();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
 
    virtual OSnLNode *cloneExprNode();
};//end OSnLNodeMatrixToScalar
 
class OSnLNodeMatrixToScalar : public OSnLNode
{
public:
    OSnLNodeMatrixToScalar();
 
    ~OSnLNodeMatrixToScalar();
 
    virtual std::string getTokenName();
 
    virtual double calculateFunction( double *x);
 
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
 
    virtual OSnLNode *cloneExprNode();
};//end OSnLNodeMatrixToScalar
 
 
class OSnLMNode: public ExprNode
{
public:
 
    OSnLMNode();
 
    virtual ~OSnLMNode();
 
 
    OSnLMNode* createExpressionTreeFromPrefix(std::vector<ExprNode*> nlNodeVec);
 
    std::vector<ExprNode*> getPrefixFromExpressionTree();
 
    std::vector<ExprNode*> preOrderOSnLNodeTraversal( std::vector<ExprNode*> *prefixVector);
 
    OSnLMNode* createExpressionTreeFromPostfix(std::vector<ExprNode*> nlNodeVec);
 
    std::vector<ExprNode*> getPostfixFromExpressionTree();
 
    std::vector<ExprNode*> postOrderOSnLNodeTraversal( std::vector<ExprNode*> *postfixVector);
 
 
    virtual OSnLMNode* copyNodeAndDescendants();
 
    bool IsEqual(OSnLMNode *that);
};//end OSnLMNode
 
class OSnLMNodeMatrixPlus : public OSnLMNode
{
public:
    OSnLMNodeMatrixPlus();
 
    ~OSnLMNodeMatrixPlus();
 
    virtual std::string getTokenName();
 
//    virtual std::string getTokenNumber();
 
//    virtual std::string getNonlinearExpressionInXML();
 
    virtual OSnLMNode *cloneExprNode();
};//end OSnLMNodeMatrixPlus
 
class OSnLMNodeMatrixSum : public OSnLMNode
{
public:
    OSnLMNodeMatrixSum();
 
    ~OSnLMNodeMatrixSum();
 
    virtual std::string getTokenName();
 
//    virtual std::string getTokenNumber();
 
//    virtual std::string getNonlinearExpressionInXML();
    virtual OSnLMNode *cloneExprNode();
 
#if 0
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
#endif
 
};//end OSnLMNodeMatrixPlus
 
class OSnLMNodeMatrixMinus : public OSnLMNode
{
public:
    OSnLMNodeMatrixMinus();
 
    ~OSnLMNodeMatrixMinus();
 
    virtual std::string getTokenName();
 
//    virtual std::string getTokenNumber();
 
//    virtual std::string getNonlinearExpressionInXML();
 
    virtual OSnLMNode *cloneExprNode();
};//end OSnLMNodeMatrixMinus
 
class OSnLMNodeMatrixNegate : public OSnLMNode
{
public:
    OSnLMNodeMatrixNegate();
 
    ~OSnLMNodeMatrixNegate();
 
    virtual std::string getTokenName();
 
//    virtual std::string getTokenNumber();
 
//    virtual std::string getNonlinearExpressionInXML();
 
 
    virtual OSnLMNode *cloneExprNode();
};//end OSnLMNodeMatrixNegate
 
class OSnLMNodeMatrixTimes : public OSnLMNode
{
public:
    OSnLMNodeMatrixTimes();
 
    ~OSnLMNodeMatrixTimes();
 
    virtual std::string getTokenName();
 
//    virtual std::string getTokenNumber();
 
//    virtual std::string getNonlinearExpressionInXML();
 
    virtual OSnLMNode *cloneExprNode();
};//end OSnLMNodeMatrixTimes
 
class OSnLMNodeMatrixInverse : public OSnLMNode
{
public:
    OSnLMNodeMatrixInverse();
 
    ~OSnLMNodeMatrixInverse();
 
    virtual std::string getTokenName();
 
//    virtual std::string getTokenNumber();
 
//    virtual std::string getNonlinearExpressionInXML();
 
    virtual OSnLMNode *cloneExprNode();
};//end OSnLMNodeMatrixInverse
 
class OSnLMNodeMatrixTranspose : public OSnLMNode
{
public:
    OSnLMNodeMatrixTranspose();
 
    ~OSnLMNodeMatrixTranspose();
 
    virtual std::string getTokenName();
 
//    virtual std::string getTokenNumber();
 
//    virtual std::string getNonlinearExpressionInXML();
 
    virtual OSnLMNode *cloneExprNode();
};//end OSnLMNodeMatrixTranspose
 
class OSnLMNodeMatrixScalarTimes : public OSnLMNode
{
public:
    OSnLMNodeMatrixScalarTimes();
 
    ~OSnLMNodeMatrixScalarTimes();
 
    virtual std::string getTokenName();
 
//    virtual std::string getTokenNumber();
 
//    virtual std::string getNonlinearExpressionInXML();
 
    virtual OSnLMNode *cloneExprNode();
};//end OSnLMNodeMatrixScalarTimes
 
class OSnLMNodeMatrixDotTimes : public OSnLMNode
{
public:
    OSnLMNodeMatrixDotTimes();
 
    ~OSnLMNodeMatrixDotTimes();
 
    virtual std::string getTokenName();
 
//    virtual std::string getTokenNumber();
 
//    virtual std::string getNonlinearExpressionInXML();
 
    virtual OSnLMNode *cloneExprNode();
};//end OSnLMNodeMatrixDotTimes
 
class OSnLMNodeIdentityMatrix : public OSnLMNode
{
public:
    OSnLMNodeIdentityMatrix();
 
    ~OSnLMNodeIdentityMatrix();
 
    virtual std::string getTokenName();
 
//    virtual std::string getTokenNumber();
 
//    virtual std::string getNonlinearExpressionInXML();
 
    virtual OSnLMNode *cloneExprNode();
};//end OSnLMNodeIdentityMatrix
 
class OSnLMNodeMatrixLowerTriangle : public OSnLMNode
{
public:
    bool includeDiagonal;
 
    OSnLMNodeMatrixLowerTriangle();
 
    ~OSnLMNodeMatrixLowerTriangle();
 
    virtual std::string getTokenName();
 
//    virtual std::string getTokenNumber();
 
    virtual std::string getNonlinearExpressionInXML();
 
    virtual OSnLMNode *cloneExprNode();
 
    virtual OSnLMNode* copyNodeAndDescendants();
 
    virtual bool IsEqual(OSnLMNodeMatrixLowerTriangle *that);
};//end OSnLMNodeMatrixLowerTriangle
 
class OSnLMNodeMatrixUpperTriangle : public OSnLMNode
{
public:
    bool includeDiagonal;
 
    OSnLMNodeMatrixUpperTriangle();
 
    ~OSnLMNodeMatrixUpperTriangle();
 
    virtual std::string getTokenName();
 
//    virtual std::string getTokenNumber();
 
    virtual std::string getNonlinearExpressionInXML();
 
    virtual OSnLMNode *cloneExprNode();
 
    virtual OSnLMNode* copyNodeAndDescendants();
 
    virtual bool IsEqual(OSnLMNodeMatrixUpperTriangle *that);
};//end OSnLMNodeMatrixUpperTriangle
 
 
class OSnLMNodeMatrixDiagonal : public OSnLMNode
{
public:
    OSnLMNodeMatrixDiagonal();
 
    ~OSnLMNodeMatrixDiagonal();
 
    virtual std::string getTokenName();
 
//    virtual std::string getTokenNumber();
 
//    virtual std::string getNonlinearExpressionInXML();
 
    virtual OSnLMNode *cloneExprNode();
};//end OSnLMNodeMatrixDiagonal
 
class OSnLMNodeDiagonalMatrixFromVector : public OSnLMNode
{
public:
    OSnLMNodeDiagonalMatrixFromVector();
 
    ~OSnLMNodeDiagonalMatrixFromVector();
 
    virtual std::string getTokenName();
 
//    virtual std::string getTokenNumber();
 
//    virtual std::string getNonlinearExpressionInXML();
 
    virtual OSnLMNode *cloneExprNode();
};//end OSnLMNodeDiagonalMatrixFromVector
 
 
class OSnLMNodeMatrixSubmatrixAt : public OSnLMNode
{
public:
    OSnLMNodeMatrixSubmatrixAt();
 
    ~OSnLMNodeMatrixSubmatrixAt();
 
    virtual std::string getTokenName();
 
//    virtual std::string getTokenNumber();
 
//    virtual std::string getNonlinearExpressionInXML();
 
    virtual OSnLMNode *cloneExprNode();
};//end OSnLMNodeMatrixSubmatrixAt
 
 
class OSnLMNodeMatrixReference : public OSnLMNode
{
public:
     int idx;
 
    OSnLMNodeMatrixReference();
 
    ~OSnLMNodeMatrixReference();
 
    virtual std::string getTokenName();
 
    virtual std::string getTokenNumber();
 
    virtual std::string getNonlinearExpressionInXML();
 
#if 0
    virtual double calculateFunction( double *x);
#endif
 
    virtual OSnLMNode *cloneExprNode();
 
    virtual OSnLMNode* copyNodeAndDescendants();
 
#if 0
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
#endif
 
    virtual bool IsEqual(OSnLMNodeMatrixReference *that);
};//end OSnLMNodeMatrixReference
 
 
class OSnLMNodeMatrixVar : public OSnLMNode
{
public:
     int idx;
 
    OSnLMNodeMatrixVar();
 
    ~OSnLMNodeMatrixVar();
 
    virtual std::string getTokenName();
 
    virtual std::string getTokenNumber();
 
    virtual std::string getNonlinearExpressionInXML();
 
#if 0
    virtual double calculateFunction( double *x);
#endif
 
    virtual OSnLMNode *cloneExprNode();
 
    virtual OSnLMNode* copyNodeAndDescendants();
 
#if 0
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
#endif
 
    virtual bool IsEqual(OSnLMNodeMatrixVar *that);
};//end OSnLMNodeMatrixVar
 
 
class OSnLMNodeMatrixObj : public OSnLMNode
{
public:
     int idx;
 
    OSnLMNodeMatrixObj();
 
    ~OSnLMNodeMatrixObj();
 
    virtual std::string getTokenName();
 
    virtual std::string getTokenNumber();
 
    virtual std::string getNonlinearExpressionInXML();
 
#if 0
    virtual double calculateFunction( double *x);
#endif
 
    virtual OSnLMNode *cloneExprNode();
 
    virtual OSnLMNode* copyNodeAndDescendants();
 
#if 0
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
#endif
 
    virtual bool IsEqual(OSnLMNodeMatrixObj *that);
};//end OSnLMNodeMatrixObj
 
 
class OSnLMNodeMatrixCon : public OSnLMNode
{
public:
     int idx;
 
    OSnLMNodeMatrixCon();
 
    ~OSnLMNodeMatrixCon();
 
    virtual std::string getTokenName();
 
    virtual std::string getTokenNumber();
 
    virtual std::string getNonlinearExpressionInXML();
 
#if 0
    virtual double calculateFunction( double *x);
#endif
 
    virtual OSnLMNode *cloneExprNode();
 
    virtual OSnLMNode* copyNodeAndDescendants();
 
#if 0
    virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD);
#endif
 
    virtual bool IsEqual(OSnLMNodeMatrixCon *that);
};//end OSnLMNodeMatrixCon
 
 
class OSnLMNodeMatrixProduct : public OSnLMNode
{
public:
    OSnLMNodeMatrixProduct();
 
    ~OSnLMNodeMatrixProduct();
 
    virtual std::string getTokenName();
 
    //virtual double calculateFunction( double *x);
 
    virtual OSnLMNode *cloneExprNode();
 
    //virtual ADdouble constructADTape(std::map<int, int> *ADIdx, ADvector *XAD); 
};//end OSnLNodeProduct
 
 
 
/*
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