MATH_Variable.h

Go to the documentation of this file.

#ifndef MATH_Variable_H
#define MATH_Variable_H

#include "CORE_Object.h"
#include "CORE_ListPointers.h"

DEFINE_SPTR(MATH_Variable);
DEFINE_SVPTR(MATH_Variable);
class MATH_Variable : public CORE_Object  {
    SP_OBJECT(MATH_Variable);
    
    // ATTRIBUTES
public:
    static const tFlag BOUND_POINT[];
    static const tFlag BOUND_SIZE[];

    //TYPE
    static const tFlag UNDEFINED;
    static const tFlag REAL;
    static const tFlag BOOLEAN;
    static const tFlag INTEGER;
    static const tFlag STRING;
private:

    double *mAllValues;
    double *mValues;
    int mFirstIndex;
    int mCapacity;
    int mSize;
    int mType;
    
    
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    MATH_Variable(const int& cap);
    
    
    
    // DESTRUCTORS 
  
    
    virtual ~MATH_Variable(void);
    
private:

public:

   
    static inline SP::MATH_Variable New() {
        SP::MATH_Variable p(new MATH_Variable(512),MATH_Variable::Delete());
        p->setThis(p);
        return p;
    }
    static inline SP::MATH_Variable New(const int& cap) {
        SP::MATH_Variable p(new MATH_Variable(cap),MATH_Variable::Delete());
        p->setThis(p);
        return p;
    }
    

    //operator
    inline const double& operator[](const int& index) const {
        ASSERT_IN(mFirstIndex+index<mCapacity);
        return mValues[index];
    }
    inline double& operator[](const int& index)  {
        ASSERT_IN(mFirstIndex+index<mCapacity);
        return mValues[index];
    }
    
    
    // SET methods 

    virtual void copy(const MATH_Variable& v);

    inline void clear() {
        mFirstIndex=0;
        mSize=0;
        mValues=&mAllValues[0];
        mType=UNDEFINED;
    }
    tBoolean setSize(const int& n);

    inline void setFirstIndex(const int& index) {
        if (mFirstIndex+mSize>=mCapacity) setSize(mSize);
        mFirstIndex=index;
        mValues=&mAllValues[index];
    }
    inline void setStartIndex(const int& index) {
        if (mFirstIndex+mSize>=mCapacity) setSize(mSize);
        mFirstIndex=index;
        mValues=&mAllValues[index];
    }
    inline void setValue(const int& index,const double& v) {
        setSize(index+1);
        mValues[index]=v;
    }
    void setValue(const tString& symbol);
    inline void setValue(const double& v) {
        mType=REAL;
        setSize(1);
        mValues[0]=v;
    }
    inline void setValue(const double* v,const int& n) {
        mType=REAL;
        setSize(n);
        for (int i=0;i<n;i++) mValues[i]=v[i];
    }
    inline void setValue(const long double* v,const int& n) {
        mType=REAL;
        setSize(n);
        for (int i=0;i<n;i++) mValues[i]=(double)v[i];
    }
    inline void setValue(const int& v) {
        mType=INTEGER;
        setSize(1);
        mValues[0]=(double)v;
    }
    inline void setValue(const int* v,const int& n) {
        mType=INTEGER;
        setSize(n);
        for (int i=0;i<n;i++) mValues[i]=(double) v[i];
    }
    inline void setValue(const tBoolean& v) {
        mType=BOOLEAN;
        setSize(1);
        mValues[0]=((int)v)%2;
    }
    inline void setType(const tFlag& type) {
        mType=type;
    }
    // GET 
    inline void getValue(double* v,int& n)  const {
        n=(mSize<n)?mSize:n;
        for (int i=0;i<n;i++) v[i]=mValues[i];
    }
    inline void getValue(int* v,int& n)  const {
        n=(mSize<n)?mSize:n;
        for (int i=0;i<n;i++) v[i]=(int)mValues[i];
    }
    inline void getValue(const int& index,int& v)  const {
        double vd;
        vd=mValues[index];
        v=(int) vd;
    }
    inline void getValue(const int& index,double& v)  const {
        v=mValues[index];
    }
  
    inline void getValue(double& v)  const {
        getValue(0,v);
    }
    inline void getValue(int& v)  const {
        getValue(0,v);
    }
    inline void getValue(tString& v)  const {
        v.resize(mSize);
        for (int i=0;i<mSize;i++) {
            v[i]=(char) mValues[i];
        }
    }
    inline tFlag getType() const{
        return mType;
    }
    inline int getSize() const{
        return mSize;
    }

    inline int getFirstIndex() const {
        return mFirstIndex;
    }
    inline int getStartIndex() const {
        return mFirstIndex;
    }

    inline int getCapacity() const {
        return mCapacity;
    }

    // CONVERTER
    
    inline static tBoolean isNumericalType(const tFlag& type)  {
        return ((type==REAL)||(type==INTEGER)|| (type==BOOLEAN));
    };
    inline tBoolean isNumericalType()  const {
        return isNumericalType(mType);
    };
    inline tBoolean isBoolean()  const {
        return (mType==BOOLEAN);
    };
    inline tBoolean isInteger()  const {
        return (mType==INTEGER);
    };
    inline tBoolean isReal()  const {
        return (mType==REAL);
    };
    inline tBoolean isString()  const {
        return (mType==STRING);
    };

    tBoolean isEqual(const MATH_Variable& var,const tReal& eps) const;
    inline tBoolean isEqual(const MATH_Variable& var) const {
        return isEqual(var,1.e-12);
    }
    
    inline static int toInteger(const double& v)  {
        return (int) (round(v));
    };
    inline static tBoolean toBoolean(const double& v)  {
        return (tBoolean) (toInteger(v)%2);
    };
    
    virtual tString toString() const;
  
   
};

#endif