---

rollingCompress.cpp File Reference

This file contains code to test rolling compression on a financial time series. More...

#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"

Go to the source code of this file.

Functions
void	copy (int *destVec, int *srcVec, const size_t N)
	Make a copy of an integer array. More...
size_t	calcPacketWidth (packdata_list< int > &bestBasisList)
	Calculate the number of bits needed to represent the result of the wavelet packet transform. More...
size_t	packet_calc (const int *intVec, const int N)
	Wavelet packet calculation. More...
void	rollingCompressWindow (int *intVec, const size_t N, const size_t winSize)
	Iterate over the input vector and copy a window of data into a temporary array. More...
void	printTS (const double *ts, const size_t N)
	Print the original floating point time series. More...
double*	calcReturnSeries (double *ret, const double *ts, const size_t N, const size_t period)
	Calculate a simple return time series over period trading days. More...
int	main ()
	Read in a set of equity time series file. More...

---

Detailed Description

This file contains code to test rolling compression on a financial time series.

Here a power of two window is chosen, which is smaller that the time series. For example, the time series might contain 563 values and a window of 64 elements might be chosen.

Wavelet packet compression is applied to the window at the start of the data set, resulting in the number of bits needed to represent the windowed data set. The window is then moved forward one element and the algorithm is applied again. If the data set size is N and the Window set size is W, this will result in (N - W) points.

The amount of compression in the window region reflects how close the wavelet packet function fits the data set. If a forecasting function is related to the wavelet function, the amount of compression in the region also reflects the accuracy of the forecasting function. To test this, a simple linear interpolation function is used.

The documentation in this file is formatted for doxygen (see www.doxyeng.org).

Copyright and Use

You may use this source code without limitation and without fee as long as you include: This software was written and is copyrighted by Ian Kaplan, Bear Products International, www.bearcave.com, 2002.

This software is provided "as is", without any warranty or claim as to its usefulness. Anyone who uses this source code uses it at their own risk. Nor is any support provided by Ian Kaplan and Bear Products International.

Please send any bug fixes or suggested source changes to:

     iank@bearcave.com

Author:

Ian Kaplan

Definition in file rollingCompress.cpp.

---

Function Documentation

size_t calcPacketWidth ( packdata_list< int > & bestBasisList )

Calculate the number of bits needed to represent the result of the wavelet packet transform. The result of this version of the wavelet packet transform is a list of vectors, where each vector represents a best basis fit for a particular region of the signal. The result returned here is an obvious lower bound, since in practice a vector would consist of a fixed set of values. Also the length of the vector would have to be included, along with the width the the length values. Definition at line 93 of file rollingCompress.cpp. Referenced by packet_calc(). { 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

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

Calculate a simple return time series over period trading days. Definition at line 196 of file rollingCompress.cpp. { } // calcReturnSeries

void copy ( int * destVec, int * srcVec, const size_t N )

Make a copy of an integer array. Note that the function allocates memory, but does not deallocate it. Definition at line 70 of file rollingCompress.cpp. Referenced by main(), and rollingCompressWindow(). { for (size_t i = 0; i < N; i++) { destVec[i] = srcVec[i]; } } // copy

int main ( )

Read in a set of equity time series file. Calculate the number of bits needed to represent the data without compression and after wavelet and wavelet packet compression. Definition at line 210 of file rollingCompress.cpp. { 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; }

size_t packet_calc ( const int * intVec, const int N )

Wavelet packet calculation. The function returns the minimal total number of bits needed to represent the data when compressed using the wavelet packet algorithm. Definition at line 119 of file rollingCompress.cpp. Referenced by main(), and rollingCompressWindow(). { // 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 printTS ( const double * ts, const size_t N )

Print the original floating point time series. Definition at line 183 of file rollingCompress.cpp. { for (size_t i = 0; i < N; i++) { printf("%7.4f\n", ts[i] ); } } // printTS

void rollingCompressWindow ( int * intVec, const size_t N, const size_t winSize )

Iterate over the input vector and copy a window of data into a temporary array. Calculate the percentage commpression after wavelet packet compression and print this value. Percentage compression gives a normalized value. If the absolute number of bits is used, as the stock price gets smaller (or larger) it requires fewer (or more) bits. Using this value would be misleading, since it depends on the time series values. Definition at line 162 of file rollingCompress.cpp. Referenced by main(). { 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

---