xreal.h

Go to the documentation of this file.

#ifndef  STARLAB_XREAL_H
#  define  STARLAB_XREAL_H


//                                              (SLWM, 5/00).

//
//         Permitted/defined operations:
//
//              initialized to 0 by default
//              xreal = xreal
//              xreal = int
//              xreal = real
//              int = xreal; Int(xreal), (int) xreal
//              real = xreal; Real(xreal), (real) xreal
//              -xreal
//              xreal +/-/+=/-= xreal
//              xreal +/-/+=/-= int
//              xreal +/-/+=/-= real
//              logical ==, !=, <, <=, >, >=
//              <<, >>
//

//#define TWO64 (pow(2.0, 64))  // too inefficient!

#define TWO64   (18446744073709551616.0)
#define TWO63   ( 9223372036854775808.0)
#define TWO64I  (5.42101086242752217e-20)
#define TWO63M  ( 9223372036854775807)
#define TWO63N  (-9223372036854775808)

typedef long long               xint_t;
typedef unsigned long long      xfrac_t;

class xreal {

    private:
        xint_t i;                                       
        xfrac_t f;                                      

    public:

        // Constructors:

        xreal();                                        
//      xreal(xreal y);                                 ///< x = y
        xreal(xint_t ii, xfrac_t ff);
        xreal(int ii);                                  
        xreal(real x);                                  

        // Accessors:

        xint_t get_i() {return i;}
        xfrac_t get_f() {return f;}
        real get_frac() {return TWO64I*f;}

        // Conversions:

        int to_int() {return i;}                        
        real to_real();                                 

        void print(ostream& s = cerr,
                   bool newline = false);               

        xreal::operator int() {return to_int();}
        xreal::operator real() {return to_real();}

        // Unary -, binary +, -, +=, -= (don't check for over/underflow):

        xreal  operator -  ();
        xreal  operator +  (const xreal y);
        xreal  operator -  (const xreal y);
        xreal& operator += (const xreal y);
        xreal& operator -= (const xreal y);
        xreal  operator +  (const real y);
        xreal  operator -  (const real y);
        xreal& operator += (const real y);
        xreal& operator -= (const real y);

        // Logical operators ==, !=, <, <=, >, >=:
        // (see also mixed operators below)

        bool operator == (const xreal y);
        bool operator != (const xreal y);
        bool operator <  (const xreal y);
        bool operator <= (const xreal y);
        bool operator >  (const xreal y);
        bool operator >= (const xreal y);

        friend istream & operator >> (ostream & , xreal &);
};

inline ostream & operator << (ostream & s, xreal x)
{
    return s << (real)x;        // probably what we want most of the time
                                // -- use x.xprint() for complete ouptut
}

istream & operator >> (istream & s, xreal & x);

// Various real/xreal comparisons (rule: always promote to xreal).

inline bool operator == (xreal x, real y) {return (x == (xreal)y);}
inline bool operator == (real x, xreal y) {return ((xreal)x == y);}
inline bool operator != (xreal x, real y) {return (x != (xreal)y);}
inline bool operator != (real x, xreal y) {return ((xreal)x != y);}
inline bool operator <  (xreal x, real y) {return (x < (xreal)y);}
inline bool operator <  (real x, xreal y) {return ((xreal)x < y);}
inline bool operator >  (xreal x, real y) {return (x > (xreal)y);}
inline bool operator >  (real x, xreal y) {return ((xreal)x > y);}
inline bool operator <= (xreal x, real y) {return (x <= (xreal)y);}
inline bool operator <= (real x, xreal y) {return ((xreal)x <= y);}
inline bool operator >= (xreal x, real y) {return (x >= (xreal)y);}
inline bool operator >= (real x, xreal y) {return ((xreal)x >= y);}

// Exclude the following definitions in favor of explicit casts if needed:
//
// inline real operator + (xreal x, real y) {return (real)(x + (xreal)y);}
// inline real operator - (xreal x, real y) {return (real)(x - (xreal)y);}

void put_real_number(ostream & s, char * label, xreal x);

#endif

---