---

rollingCompress.cpp

Go to the documentation of this file.

#include <stdio.h>

#include "invpacktree_int.h"
#include "packtree_int.h"
#include "support.h"
#include "delta.h"
#include "line_int.h"
#include "costwidth.h"
#include "yahooTS.h"


void copy( int *destVec, int *srcVec, const size_t N )
{
  for (size_t i = 0; i < N; i++)
  {
    destVec[i] = srcVec[i];
  }
} // copy



size_t calcPacketWidth( packdata_list<int> &bestBasisList )
{
  packdata_list<int>::handle h;
  size_t totalWidth = 0;

  for (h = bestBasisList.first(); h != 0; h = bestBasisList.next( h )) {
    packdata<int> *node = bestBasisList.get_item( h );
    const size_t len = node->length();
    const int *vec = node->getData();
    int nodeWidth = support::vecWidth( vec, len );
    totalWidth += nodeWidth;
  }

  return totalWidth;
} // calcPacketWidth



size_t packet_calc( const int *intVec, 
                    const int N )
{
  // The "line" wavelet transform (e.g., line with slope)
  line_int<packcontainer_int> line;

  // calculate the wavelet packet tree, using the line wavelet transform
  packtree_int tree( intVec, N, &line );

  // get the root of the wavelet packet transform tree
  packnode<int> *treeRoot = tree.getRoot();

  // Assign a cost on the basis of bit width
  costwidth cost( treeRoot );

  // Calculate the "best basis" function from the tree
  tree.bestBasis();

  // Get the best basis list.  This will be a list of
  // nodes consisting of the best basis set.  This set is
  // obtained by traversing the tree, top down, left to
  // right.
  packdata_list<int> bestBasis = tree.getBestBasisList();

  // Sum the cost values (width for each node in the best basis
  // list
  size_t width = calcPacketWidth( bestBasis );

  return width;
} // packet_calc


void rollingCompressWindow(int *intVec, 
                           const size_t N,
                           const size_t winSize )
{
  int *window = new int[ winSize ];

  for (size_t i = 0; i < N - winSize; i++) {
    copy( window, &intVec[i], winSize );
    const size_t windowWidth = support::vecWidth( window, winSize );
    const size_t packetWidth = packet_calc( window, winSize );
    const float compPercent = (1.0 - ((float)packetWidth/(float)windowWidth)) * 100.0;
    printf("%7.4f\n", compPercent );
  }

  delete [] window;
} // rollingCompressWindow


void printTS(const double *ts, const size_t N )
{
  for (size_t i = 0; i < N; i++) {
    printf("%7.4f\n", ts[i] );
  }
} // printTS



double *calcReturnSeries( double *ret, 
                          const double *ts, 
                          const size_t N,
                          const size_t period )
{
} // calcReturnSeries


int main()
{
  const char *files[] = { "aa",    // Alcoa Aluminium
                          "amat",  // Applied Materials
                          "ba",    // Boeing
                          "cof",   // Capital One
                          "ge",    // General Electric
                          "ibm",   // IBM Corp.
                          "intc",  // Intel
                          "mmm",   // 3M
                          "mrk",   // Merck
                          "wmt",   // Wal-Mart
                          0        // The null pointer
                        };

  const size_t N = 563;
  const size_t winSize = 64;
  const char *fileName = "amat";
  double realVec[ N ];
  int intVec[ N ];
  int window[ winSize ];

  // an instance of yahooTS with the path to the data directory
  const char *dataDirPath = "..\\data\\equities\\";
  yahooTS ts( dataDirPath );

  size_t n = N;
  if (! ts.getTS( fileName, realVec, n, yahooTS::Close )) {
    printf("error reading file %s\n", fileName );
    return 0;
  }

  if (n != N) {
    printf("Error: %d out of %d data elements read\n", n, N );
    return 0;
  }
    
  support::decimalToInt( intVec, realVec, N );

  rollingCompressWindow( intVec, N, winSize );

  return 0;
}

---