MATH_RootExpression.h

Go to the documentation of this file.

#ifndef MATH_RootExpression_H
#define MATH_RootExpression_H

#include "MATH_ParentExpression.h"
#include "CORE_Exception.h"

#include "MATH_Environment.h"
#include "MATH_Variable.h"
DEFINE_SPTR(MATH_ExpressionClassFactory);
DEFINE_SPTR(MATH_NodeExpression);

DEFINE_SPTR(MATH_RootExpression);
DEFINE_SVPTR(MATH_RootExpression);
class MATH_RootExpression : public MATH_ParentExpression {
    SP_OBJECT(MATH_RootExpression);
    // ATTRIBUTES
  
  
private:
  
    SP::MATH_Variable mValue;
    
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    MATH_RootExpression(void);
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~MATH_RootExpression(void);   
  
  
public:
    
    static inline SP::MATH_RootExpression New() {
        SP::MATH_RootExpression p(new MATH_RootExpression(),MATH_RootExpression::Delete());
        p->setThis(p);
        return p;
    }

    //OPERATOR
    
    inline const double& operator[](const int& index) const {
        return (*mValue.get())[index];
    }  
   
    
    // SET methods 
  
 
    
    // GET methods 

    inline const double* getValues() const {
        return &(*mValue.get())[0];
    }
    inline const double& getValue(const int& index) const {
        return (*mValue.get())[index];
    }
 
    
    // GET methods
    virtual const MATH_RootExpression* getRootNode() const {
        return this;
    }
public:
    // OTHERS methods
    virtual int evaluate(const tFlag& action,MATH_Environment& symbols,MATH_Variable& var) const {
        return MATH_ParentExpression::evaluate(action,symbols,var);
    }
    virtual double  evaluate()   {
        SP::MATH_Environment env=MATH_Environment::New();
        return evaluate(ALGEBRIC,*env.get());
    }
    virtual double evaluate(MATH_Environment& env)  {
        return evaluate(ALGEBRIC,env);
    }
    virtual double evaluate(SP::MATH_Environment env)  {
        if (env.get()!=null) return evaluate(ALGEBRIC,*env.get());
        return evaluate();
    }
    virtual double evaluate(const tFlag& action)   {
        SP::MATH_Environment env=MATH_Environment::New();
        return evaluate(action,*env.get());
    }
    virtual double evaluate(const tFlag& action,MATH_Environment& symbols)   {
        evaluate(action,symbols,*mValue.get());
        return (*mValue.get())[0];
    }
    virtual double evaluate(const tFlag& action,SP::MATH_Environment symbols)  {
        if (symbols.get()!=null) return evaluate(action,*symbols.get());
        else return evaluate(action);
    }

 
    tBoolean  parse(const tString& expr,MATH_Environment& symbols);
    
    tBoolean parse(const tString& expr) {
        SP::MATH_Environment env=MATH_Environment::New();
        return parse(expr,*env.get());
    }
    
    tString parse(const tString& expr,MATH_Environment& env,int& retCode);

    virtual SP::MATH_ExpressionClassFactory newClassFactoryInstance() const;
    
    virtual tString toString() const;

private:
    void replaceEPowerByTenPower(tString& expr) const;
    void deleteBlanks(tString& expr) const;
};

#endif