Search  

---

C:/temp/src/j2k/Beta/Math/Float.hpp

Go to the documentation of this file.

#ifndef __J2K__Float_HPP__
#define __J2K__Float_HPP__

#include <j2k/Fred/Number/MathStat.hpp>
#include <j2k/Fred/Number/MCNumber.hpp>
#include <stdlib.h>

// Double definition

class Float {
//: public Object {
  public:
    inline Float() : value(0), status( Valid ) {
       verify();
    }

    inline Float(float v) : value(v), status( Valid ) { 
       verify();
    }

    inline Float(float v, enum MathState s) : value(v), status( s ) {
       verify();
    }

    inline Float(const char *s) {
      status = getState( s );
      value  = atof( s );

      if ( (int)status < 3 ) { // Change state, only if not Invalid
        verify();       
      }
    }

    Float(const Float& F)
      : value( F.value ), status( F.status ) { }

    inline virtual ~Float() { }

    friend ostream& operator<<(ostream& os, Float& F) {
      unsigned int state = (unsigned int)(F.status);
      if ( state < 3 ) {
        return os << F.value;
      } else if ( state < J2K_MAX_MathState ) {
        return os << MathStateTxt[ state ];
      }

      // Something weird occured, if this get executed !
      abort();  
      return os << "";

    }

    // operator overloads

    inline operator Float() const {
       return (Float)value;
    }

    friend Float operator<<(const Float& l, const Float& r);
    friend Float operator>>(const Float& l, const Float& r);
    friend Float operator|( const Float& l, const Float& r);
    friend Float operator&( const Float& l, const Float& r);
    friend Float operator^( const Float& l, const Float& r);

    inline Float operator~() {
      return Float( ~value );
    }

    // Use macro to define all possible choice
    // for arithmetic and compare functions

    MC_Number_Verify( Float, 0.0 )
    MC_Number_Operators1( Float, float )
    MC_Number_Operators2( Float, float, long   )
    MC_Number_Operators2( Float, float, float  )
    MC_Number_Operators2( Float, float, double )
    
/*
    // Object methods
    Object *Copy() const;

    void Serialize(Serializer &) const;
    void Deserialize(Deserializer &);

    unsigned int hash() const;
    String toString() const;

    declareSerializable(Float);
  protected:
    bool Equals(const Object &o) const;
    bool lessThan(const Object &o) const;
    bool lessThanEquals(const Object &o) const;
*/

  private:
    Float value;
    enum MathState status;
};

inline Float operator<<(const Float& l,const Float& r) {
    return Float(l.value<<r.value);
}

inline Float operator>>(const Float& l,const Float& r) {
    return Float(l.value>>r.value);
}

inline Float operator|(const Float& l,const Float& r) {
    return Float(l.value|r.value);
}

inline Float operator&(const Float& l,const Float& r) {
    return Float(l.value&r.value);
}

inline Float operator^(const Float& l,const Float& r) {
    return Float(l.value^r.value);
}

#endif

---