#include <ComPackFlatFloat.h>

Inheritance diagram for ComPackFlatFloat:

Public Member Functions
	ComPackFlatFloat (const double, const double, size_t)

virtual	~ComPackFlatFloat ()

StatusCode	pack (const double, d_ULong &) const

StatusCode	unpack (const d_ULong, double &) const

void	testMe (size_t, double &)

Public Member Functions inherited from ComPackBase< double >
	ComPackBase ()

	ComPackBase (double minval, double maxval, d_ULong bitrange)

	ComPackBase (const ComPackBase &)

virtual	~ComPackBase ()

virtual StatusCode	pack (const double, d_ULong &) const=0

virtual StatusCode	unpack (const d_ULong, double &) const=0

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 36 of file ComPackFlatFloat.h.

Constructor & Destructor Documentation

◆ ComPackFlatFloat()

ComPackFlatFloat::ComPackFlatFloat	(	const double	val_one,
		const double	val_two,
		size_t	bits
	)

Definition at line 59 of file ComPackFlatFloat.cxx.

{
  if (val_one>val_two) {
    _minVal=val_two; 
    _maxVal=val_one;
  } else {
    _minVal=val_one; 
    _maxVal=val_two;
  }
 
// this is a stupid test.  I wanted to packa a number in nano-seconds,
// and it refused.  I've removed the test dnb 11/17/00
//  const double epsilon = 0.0001;
  const double epsilon = 0.0;
  if (( _maxVal - _minVal )<=epsilon) {
    cout <<" ErrMsg(fatal) "  << "Error : Range is zero!" << endl;
    abort();
  }
  _valRange = _maxVal - _minVal;
 
  if (bits > _maxlongbits ) {
    bits = _maxlongbits;
    cout << " ErrMsg(fatal) "<< "Warning : Number of bits truncated! "
    << "Reason  : Number of bits too large for " << _maxlongbits << " bit packing operations! "
    << "This is probably caused by a serious typo somewhere!" << endl;
    abort();
  }
  _bitRange = bits;
  _bitMask = (1<<_bitRange) - 1;
  if ( 0 == _bitMask) { // check for wrap around
    _bitMask--;
  }
// preset packing.
  _pacfac = (1<<_bitRange)/_valRange;
  _upacfac = 1.0/_pacfac;
}

◆ ~ComPackFlatFloat()

ComPackFlatFloat::~ComPackFlatFloat ( )

virtual

Definition at line 96 of file ComPackFlatFloat.cxx.

96{}

Member Function Documentation

◆ pack()

ComPackBase< double >::StatusCode ComPackFlatFloat::pack	(	const double	theval,
		d_ULong &	packedval
	)		const

Definition at line 99 of file ComPackFlatFloat.cxx.

{
  StatusCode retval(TAG_OK);
  double dpack = (theval-_minVal)*_pacfac;
  packedval = (d_ULong)dpack;
  if (dpack>_bitMask) { 
    packedval = _bitMask;
    retval = TAG_VAL_ROUND_DOWN;
  } else if (dpack<0) {
    packedval = 0; // clamp
    retval = TAG_VAL_ROUND_UP;
  }
  return retval;
}

Referenced by testMe().

◆ testMe()

void ComPackFlatFloat::testMe	(	size_t	numsteps,
		double &	toterror
	)

Definition at line 122 of file ComPackFlatFloat.cxx.

{
  if ( 0 == numsteps) return;
  toterror = 0.;
  const double incstep = double (_valRange) / double (numsteps);
  for ( double i = _minVal; i<= _maxVal; i+=incstep)
    {
      d_ULong tagVal;
      pack ( i, tagVal );
      double unTagVal;
      unpack ( tagVal, unTagVal );
      cout << i << " is converted to :" << tagVal << ". Upon unpacking :" << unTagVal << endl;
      toterror += fabs ( i-unTagVal );
    }
}

◆ unpack()

ComPackBase< double >::StatusCode ComPackFlatFloat::unpack	(	const d_ULong	val,
		double &	unpackedval
	)		const

virtual

Implements ComPackBase< double >.

Definition at line 115 of file ComPackFlatFloat.cxx.

{
  unpackedval = ((val&_bitMask)+0.5)*_upacfac + _minVal;
  return TAG_OK;
}