ComPackExpFloat Class Reference

#include <ComPackExpFloat.h>

Inheritance diagram for ComPackExpFloat:

Public Member Functions
	ComPackExpFloat (unsigned nbits, unsigned maxexponent, double start, double stop, bool center=false)
virtual	~ComPackExpFloat ()
virtual StatusCode	pack (const double, d_ULong &) const
virtual StatusCode	unpack (const d_ULong, double &) const
void	print (std::ostream &os) const
Public Member Functions inherited from ComPackBase< double >
	ComPackBase ()
	ComPackBase (double minval, double maxval, d_ULong bitrange)
	ComPackBase (const ComPackBase &)
virtual	~ComPackBase ()
virtual const double &	getMinVal () const
virtual const double &	getMaxVal () const
virtual const double &	getRange () const
d_ULong	bitRange () const
d_ULong	bitMask () const
ComPackBase &	operator= (const ComPackBase &)

Additional Inherited Members
Public Types inherited from ComPackBaseBase
enum	StatusCode {   TAG_OK , TAG_BAD , TAG_RANGE_ERROR , TAG_VAL_ROUND_DOWN ,   TAG_VAL_ROUND_UP }
Protected Types inherited from ComPackBase< double >
enum
Protected Attributes inherited from ComPackBase< double >
double	_minVal
double	_maxVal
double	_valRange
d_ULong	_bitRange
d_ULong	_bitMask

Detailed Description

Definition at line 35 of file ComPackExpFloat.h.

Constructor & Destructor Documentation

ComPackExpFloat()

ComPackExpFloat::ComPackExpFloat	(	unsigned	nbits,
		unsigned	maxexponent,
		double	start,
		double	stop,
		bool	center = false )

Definition at line 31 of file ComPackExpFloat.cxx.

                               :
  ComPackBase<double>(start,stop,nbits),
  _maxexp(maxexponent) {
  if(_maxexp > 62 ) {
    std::cout<<"ErrMsg(fatal) "<< "Can't pack exponents larger than 62" << endl;
    abort();
  }
  static double invln2(1.0/log(2.0));
  long long one(1);
// compute how many bits used by exponent
  _mansft = _maxexp>0?(unsigned)(log(double(_maxexp))*invln2+1.01):0;
  _expmsk = (1<<_mansft)-1;
  _maxman = (1<<(_bitRange-_mansft));
  _manmsk = _maxman-1;
  double invmaxman = 1.0/_maxman;
  long long maxnorm = (one<<(maxexponent+1))-1;
// correct the range if we're centering the bins
  if(center) {
    long long norm = one<<maxexponent;
    double alpha = 1.0/((double)maxnorm*_maxman*2.0 - (norm + 1.0));
    _minVal -= _valRange*alpha;
    _maxVal += _valRange*norm*alpha;
    _valRange = _maxVal - _minVal;
//    cout << "alpha = " << alpha << " norm = " << norm << endl;
  }
// finish the calculations
  _invrange = maxnorm/_valRange;
  double invmaxnorm = _valRange/maxnorm;
  double manoff = (0.5 * invmaxman+1.0) * invmaxnorm;
  double valoff = _minVal -  invmaxnorm;
  double manfac = invmaxnorm * invmaxman;
// pre-compute some factors and store them in an array
  _expfac = new double[_maxexp+1];
  _expoff = new double[_maxexp+1];
  for(unsigned iexp=0;iexp<=_maxexp;iexp++){
    double expf = (one<<iexp);
    _expoff[iexp] = valoff + manoff*expf;
    _expfac[iexp] = manfac*expf;
  }
}

~ComPackExpFloat()

ComPackExpFloat::~ComPackExpFloat ( )

virtual

Definition at line 76 of file ComPackExpFloat.cxx.

{
  delete [] _expfac;
  delete [] _expoff;
}

Member Function Documentation

pack()

ComPackBase< double >::StatusCode ComPackExpFloat::pack ( const double value, d_ULong & packdata ) const

virtual

Implements ComPackBase< double >.

Definition at line 83 of file ComPackExpFloat.cxx.

                                                                   {
  static double invln2(1.0/log(2.0));
  static long long one(1);
  ComPackBase<double>::StatusCode retval(TAG_OK);
// first, figure out the exponent
  double renorm = 1.0+(value-_minVal)*_invrange;
  if(renorm<1.0){
    renorm=1.0;
    retval = TAG_VAL_ROUND_UP;
  }
  unsigned iexp = unsigned(log(renorm)*invln2);
  unsigned iman(0);
  if(iexp<=_maxexp){
    long long expon = one<<iexp;
    iman = (unsigned)( _maxman*(renorm/expon - 1.0) );
// deal with floating-point rounding, which could give a 'non-physical' result
    if(iman==_maxman){
      if(iexp==_maxexp)
    iman=_maxman-1;
      else {
    iman=0;
    iexp++;
      }
    }
  } else {
    iexp=_maxexp;
    iman = _maxman-1;
    retval = TAG_VAL_ROUND_DOWN;
  }
  packdata = (iexp&_expmsk) | (iman&_manmsk)<<_mansft;
  return retval;
}

print()

void ComPackExpFloat::print

(

std::ostream &

os

)

const

Definition at line 125 of file ComPackExpFloat.cxx.

                                        {
  os << "Exponential packer for range " << _minVal << " to " << _maxVal << endl;
  os << "Maximum exponent = " << _maxexp << endl;
  os << "Maximum mantissa = " << _maxman << endl;
  os << "Mantissa storage shift, mask = " << _mansft << " , " << _manmsk << endl;
}

unpack()

ComPackBase< double >::StatusCode ComPackExpFloat::unpack ( const d_ULong packdata, double & value ) const

virtual

Implements ComPackBase< double >.

Definition at line 117 of file ComPackExpFloat.cxx.

                                                                     {
  size_t iman = (packdata>>_mansft)&_manmsk;
  size_t iexp = packdata&_expmsk;
  value = _expoff[iexp] + iman * _expfac[iexp];
  return TAG_OK;
}

---

The documentation for this class was generated from the following files:

• ComPackExpFloat.h
• ComPackExpFloat.cxx