Main Page   Class Hierarchy   Compound List   File List   Compound Members   File Members  

support Class Reference

Various support functions for compression and bit width estimation. More...

#include <support.h>

List of all members.

Public Methods

 support ()
 declare but do not define the constructor. More...

 ~support ()
 declare but do not define the destructor. More...

 support (const support &rhs)
 declare but never define copy constructor. More...

size_t UnsignedValWidth (const size_t val)
 Calculate the number of bits needed to represent an unsigned value. More...


Static Public Methods

size_t valWidth (const int val)
 Calculate the number of bits needed to represent an integer value. More...

size_t vecWidth (const int *vec, const size_t N)
 Calculate the minimum number of bits needed to represent the values in an integer vector. More...

void roundToInt (int *intVec, const double *realVec, const size_t len)
 Round an array of doubles to three decimal places and multiply by 1000, resulting in an integer that reflects the double value. More...

void decimalToInt (int *intVec, const double *realVec, const size_t len)
 Convert a decimalized array of doubles (e.g., where there are two base ten fractional digits (e.g., 6.02, 3.14, 1.15) into integer form. More...


Static Private Methods

size_t nearestPower2Width_ (size_t val)
int roundVal_ (const double val)
 Represent a real value with three fractional digits in integer form. More...


Detailed Description

Various support functions for compression and bit width estimation.

These functions are the object oriented version of global functions. They are all pure functions (e.g., no state in the function or in the class) and static.

Bit width calculation

In compression applications an attempt is made to represent a data set in a minimal number of bits. For these applications it must also be possible to decompress the data. If the values in the data set are stored in bit fields of different widths, information about these fields must be stored as well.

Unlike compression algorithms, where decompresson must be taken into account, this code simple calculates the sum of the bit fields needed to represent a set of signed integer values. This is useful for estimating how closely a wavelet transform approximated a data set.

Double to integer conversion

The compression algorith uses integer to integer lossless wavelet transforms. Since the financial data I am interested in is in real form, it needs to be converted to integer. This is done preserving three fractional digits.

The constructors and destructor are declared but not defined, which will result in a link error if an instance of this class is created (which is not the intent in the design).

Definition at line 70 of file support.h.


Constructor & Destructor Documentation

support::support ( )
 

declare but do not define the constructor.

support::~support ( )
 

declare but do not define the destructor.

support::support ( const support & rhs )
 

declare but never define copy constructor.


Member Function Documentation

size_t support::UnsignedValWidth ( const size_t val )
 

Calculate the number of bits needed to represent an unsigned value.

Definition at line 165 of file support.cpp.

00166 {
00167   size_t width = nearestPower2Width_( val );
00168 
00169   return width;
00170 } // valWidth

void support::decimalToInt ( int * intVec,
const double * realVec,
const size_t len ) [static]
 

Convert a decimalized array of doubles (e.g., where there are two base ten fractional digits (e.g., 6.02, 3.14, 1.15) into integer form.

This is done my multiplying by 100 and truncating. No rounding is done, since this function assumes that here are only two significant fractional digits. The roundToInt function can be used for rounding.

Definition at line 113 of file support.cpp.

Referenced by main().

00116 {
00117   if (intVec != 0 && realVec != 0) {
00118     for (size_t i = 0; i < len; i++) {
00119       intVec[i] = (int)(realVec[i] * 100.0);
00120     }
00121   }
00122 } // roundToInt

size_t support::nearestPower2Width_ ( size_t val ) [static, private]
 

Definition at line 127 of file support.cpp.

Referenced by UnsignedValWidth(), and valWidth().

00128 {
00129   size_t width = 0;
00130   if (val > 0) {
00131     width = 1;
00132     size_t power = 1;
00133     while (power < val && width < 32) {
00134       power = power << 1;
00135       width++;
00136     }
00137   }
00138     
00139   return width;
00140 } // nearestPower2Width_

void support::roundToInt ( int * intVec,
const double * realVec,
const size_t len ) [static]
 

Round an array of doubles to three decimal places and multiply by 1000, resulting in an integer that reflects the double value.

For equity time series this kind of rounding is useful for "old style" pre-decimalization time series where the fractional values represent increments by 1/16. This kind of rounding is also useful for adjusted time series (e.g., the time series is adjusted by a split and/or dividends are reinvested).

Since this function results in an integer vector with integer values reflecting three decimal places, this function should not be used for decimalized values (which only have two decimal places).

Definition at line 93 of file support.cpp.

00096 {
00097   if (intVec != 0 && realVec != 0) {
00098     for (size_t i = 0; i < len; i++) {
00099       intVec[i] = roundVal_( realVec[i] );
00100     }
00101   }
00102 } // roundToInt

int support::roundVal_ ( const double val ) [static, private]
 

Represent a real value with three fractional digits in integer form.

To accomplish this the real number is rounded and then multiplied by 1000.0.

The rounding used is so proper rounding:

  • If the digit in the fourth place is greater than 5, the digit in the third place is incremented by one.
  • If the digit in the fourth place is less than 5, the third digit is left unchanged.
  • If the digit in the fourth place is 5 and the digit in the third place is odd, the third digit is incremented.

Proper rounding is unbiased (that is, in a random sample of numbers the same number of values are rounded up as are rounded down).

Some examples:

     12.4567 is rounded to 12.457 and converted to the integer
     12457.

     42.1234 is rounded to 42.123 and converted to the integer
     42123.

     127.1235 is rounded to 127.124 and converted to the integer
     127124.
  

While this function does what I intended, it does seem to do it in a lot of operations. There is probably a faster way to do this by directly manipulating IEEE floating point. While this might be faster, it is more complex.

Definition at line 51 of file support.cpp.

Referenced by roundToInt().

00052 { 
00053   int intPart =  static_cast<int>(val); 
00054   double fracPart = val - intPart; 
00055   int threeDigits = fracPart * 1000.0; 
00056   int fourDigits = fracPart * 10000.0; 
00057   int forthDigit = fourDigits % 10; 
00058   int thirdDigit = threeDigits % 10;
00059 
00060   double roundVal = 0.001;
00061   if (forthDigit < 5) {
00062     roundVal = 0.0;
00063   }
00064   else if (forthDigit == 5) {
00065     if ((thirdDigit & 0x1) == 0) {
00066       roundVal = 0.0;
00067     }
00068   }
00069   double newVal = val + roundVal;
00070   double intRslt = newVal * 1000.0;
00071   return intRslt;
00072 } // roundVal_

size_t support::valWidth ( const int val ) [static]
 

Calculate the number of bits needed to represent an integer value.

A sign bit is added, so that positive numbers always have a leading zero and negative numbers have a leading one.

Definition at line 150 of file support.cpp.

Referenced by vecWidth().

00151 {
00152   size_t wholeNum = (val < 0) ? -val : val;
00153   size_t width = 1 + nearestPower2Width_( wholeNum );
00154 
00155   return width;
00156 } // valWidth

size_t support::vecWidth ( const int * vec,
const size_t N ) [static]
 

Calculate the minimum number of bits needed to represent the values in an integer vector.

Definition at line 177 of file support.cpp.

Referenced by calcPacketWidth(), costwidth::costCalc(), delta_calc(), main(), and wave_calc().

00178 {
00179   size_t totalWidth = 0;
00180   if (vec != 0) {
00181     for (size_t i = 0; i < N; i++) {
00182       totalWidth += valWidth( vec[i] );
00183     }
00184   }
00185   return totalWidth;
00186 } // vecWidth( int *)


The documentation for this class was generated from the following files:
Generated at Sat Aug 10 13:23:39 2002 for Wavelet Packet Transform and Lossless Compression by doxygen1.2.8.1 written by Dimitri van Heesch, © 1997-2001