CORE_Real.h

Go to the documentation of this file.

#ifndef CORE_REAL_H
#define CORE_REAL_H

#include "CORE_Object.h"
#include "CORE_Pointers.h"

#include <boost/lexical_cast.hpp>

#include <boost/algorithm/string.hpp>

DEFINE_SPTR(CORE_Real);

class CORE_Real : public  CORE_Object {

    // ATTRIBUTES
private:
    tReal mReal;
    static tString mSystemDigitalDot;

    //ASSOCIATIONS
  
private:
  

  
    //CONSTRUCTOR
 
public:
    CORE_Real(); 
    CORE_Real(const tReal& i);
  
    //DESTRUCTOR
protected:
    virtual ~CORE_Real();

    // NEW METHODS
public:
    static inline SP::CORE_Real New() {
        SP::CORE_Real ret(new CORE_Real(),CORE_Real::Delete());
        return ret;
    }; 
    static inline SP::CORE_Real New(const tReal& i) {
        SP::CORE_Real ret(new CORE_Real(i),CORE_Real::Delete());
        return ret;
    };

    // SET METHODS
public:
    inline void setReal(const tReal& r) {mReal=r;};
    inline void setReal(const tString&  r) {
        setReal(parseReal(r));
    };

    // GET METHODS
public:
    tReal getReal() const {return mReal;};
  
    // OTHERS METHODS
public:
    tString toString() const {return toString(mReal);};
    
    static tString toString(const tLDouble& i,const tFlag& n);  
    
    static tString toString(const tDouble& i,const tFlag& n) {
        return toString((tLDouble)i,n);
    };
    static tString toString(const tFloat& i,const tFlag& n) {
        return toString((tLDouble)i,n);
    };
  
  
  
  
    inline static tString toString(const tFloat& r){
        try {
            return boost::lexical_cast<tString>(r);
        } catch(std::exception& e) {
            return "nan";
        }
        return "nan";
    };
    inline static tString toString(const tDouble& r){ 
        try {
            return boost::lexical_cast<tString>(r);
        } catch(std::exception& e) {
            return "nan";
        }
        return "nan";
    };
    inline static tString toString(const tLDouble& r) {
        try {
            return boost::lexical_cast<tString>(r);
        } catch(std::exception& e) {
            return "nan";
        }
        return "nan";
    }
    inline static tBoolean isReal(const tString& str) {
        tString ret(str);
        boost::trim(ret);
        try {
            boost::lexical_cast<tLDouble>(ret);
            return true;
        } catch(std::exception& e) {
            
            return false;
        }
        return false;
       
    }
    static tString roundToString(const tReal& r,
                                 const tReal& eps);
  
    static void shellSort(tReal a[],const tUIndex& N);
  
    inline static tLDouble parseReal(const tString& str) {
        tString ret(str);
        boost::trim(ret);
        try {
            return boost::lexical_cast<tLDouble>(ret);
        } catch(std::exception& e) {
            
            return 0;
        }
        return 0;
    }
  
  
    static void solveEq2(const tReal& a,const tReal& b,const tReal& c,
                         vector<tReal>& x);
    static void solveEq3(const tReal& a,const tReal& b,const tReal& c,const tReal& d,
                         vector<tReal>& x);
    
    // VIRTUAl METHODS
public:
    
    // PRIVATE METHODS
private:
    inline static int sgn(const tReal& x) {
        return ((x==0)?0:((x>0)?1:-1));   
    }
    inline static tReal surround(const tReal& x) {
        return sgn(x)*floor(0.5+fabs(x)/EPS)*EPS;
    }
};

#endif // end of ifndef