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