---

boundednumber.h

Go to the documentation of this file.

#ifndef __BOUNDEDNUMBER_H__
#define __BOUNDEDNUMBER_H__

#include <cmath>
#include <cassert>
#include <algorithm>

#include "genericalgs.h"
#include "bounded.h"


namespace Bounded {


  
template<class T>
struct Crop {  T operator() (T l, T u, T x) { return Generic::crop(l,u,x); }  };

 
template<class T>
struct Wrap {  T operator() (T l, T u, T x) { return Generic::wrap(l,u,x); }  };




/* Forward declarations to allow Float and Integer to convert to
   and from one another */
template<class, LargeInt, LargeInt, class> class Integer;
template<class, LargeInt, LargeInt, class> class Float;


 
#define MAX_UNSIGNED(T) ((sizeof(T)<<8)-1)

 
  
template<class T, LargeInt MaxVal=LargeInt(MAX_UNSIGNED(T)),
         LargeInt MinVal=0, class Boundary=Crop<LargeInt> >
class Integer {
private:
  typedef T value_type; 
  value_type n;         
  typedef Integer self;

  inline const LargeInt crop(const LargeInt x)
    {  return Boundary()(Min,Max,x); }

  inline value_type set(const LargeInt x)
    {  return n=value_type(Boundary()(Min,Max,x));  }

  //  template<class X> friend X operator+(const X &A, const X &B);
  
public:
  static const value_type Min=MinVal; 
  static const value_type Max=MaxVal; 
  Integer()               : n(set(0))   { } 
  Integer(value_type val) : n(set(val)) { } 
  Integer(const self& other)
    : n(other.n)                        { } 
  template<class OT, LargeInt OMaxVal, LargeInt OMinVal, class OBoundary>
  Integer(const Float<OT,OMaxVal,OMinVal,OBoundary>& other)
    : n(set(value_type(Max*other.mag())))  { }

  void operator= (const LargeInt& val) {  set(val);  assert(n<=Max); }

  self& operator*=(const LargeFloat m) {  set(LargeInt(n*m));  return *this; }
  
  self operator+(const self &B) const {
    self tmp;
    tmp.set(n+B.n);
    return tmp;
  }

  
  Magnitude mag() const { assert(n<=Max); return LargeFloat(n)/LargeFloat(Max);  }

  value_type raw() const { assert(n<=Max); return n;  }
};


 
template<class T, LargeInt MaxVal=1, LargeInt MinVal=0, class Boundary=Crop<LargeFloat> >
class Float {
private:
  typedef T value_type; 
  value_type n;         
  inline const LargeFloat crop(const LargeFloat x)
    {  return Boundary()(Min,Max,x); }
  
public:
  static const value_type Min; 
  static const value_type Max; 
  Float()               : n(crop(0))   { } 
  Float(value_type val) : n(crop(val)) { } 
  Float(const Float<T,MaxVal,MinVal,Boundary>& other)
    : n(other.n)                       { } 
  template<class OT, LargeInt OMaxVal, LargeInt OMinVal, class OBoundary>
  Float(const Integer<OT,OMaxVal,OMinVal, OBoundary>& other)
    : n(crop(value_type(Max*(other.mag()))))  { }
    
  void operator= (const LargeFloat& val) {  n=value_type(crop(val)); assert(n>=Min&&n<=Max); }
  
  Magnitude mag() const { assert(n>=Min&&n<=Max); return LargeFloat(n)/LargeFloat(Max);  }

  value_type raw() const { assert(n>=Min&&n<=Max); return n;  }
};


template<class T, LargeInt MaxVal, LargeInt MinVal, class Boundary>
const T Float<T,MaxVal,MinVal,Boundary>::Min=MinVal;
template<class T, LargeInt MaxVal, LargeInt MinVal, class Boundary>
const T Float<T,MaxVal,MinVal,Boundary>::Max=MaxVal;

 
} /* namespace Bounded */

#endif /* __BOUNDEDNUMBER_H__ */

---