Rtrsmra_Data_t_array.h

Go to the documentation of this file.

//Rtrsmra_Data_t_array.h
//////////////////////////////////////////////////////////////////////
//          (c) Copyright 2001-2002 Brown Deer Technology, LLC.
//                        All rights reserved.
//////////////////////////////////////////////////////////////////////

#ifndef _RTRSMRA_DATA_T_ARRAY_H
#define _RTRSMRA_DATA_T_ARRAY_H

#ifdef USE_STD
#include <cmath>
using namespace std;
#else
#include <math.h>
#endif

#include "stormdef.h"
#define INVSQRT2 STORMDEF_MATHCONST_INVSQRT2

// partial specialization Rtrsmra<Data_t,array>
template <typename Data_t>
class Rtrsmra<Data_t,array> {

   public:

      typedef Data_t DataType;
      static const int ArrayDim = 1;

      Rtrsmra( const int asize = 1, const int msize = 8 );
      Rtrsmra( const Rtrsmra &rhs );
      virtual ~Rtrsmra();
      virtual void remalloc( const int asize = 1, const int msize = 8 );
      virtual void clear();
      void assign( const Data_t data );
      void assign( const Data_t* data );
      void assign( const int a0, const int a1, const Data_t* data);
      void zero();
      Data_t& operator[]( const int a ) { return _data[a]; }
      virtual void rtwt();
      virtual void rtiwt() {}
      int operator ++() { rtwt(); return 0; }
      int operator ++(int) { rtwt(); return 0; }
      int operator --() { rtiwt(); return 0; }
      int operator --(int) { rtiwt(); return 0; }
      int amax() { return _amax; }
      int mmax() { return _mmax; }
      int mrastep() { return _mrastep; }
      int mrastep( const int mrastep ) { _mrastep = mrastep; } //DEBUG
      virtual int mcycle() { return mcycle0(); }
      virtual int mcycle0();
      virtual int mcyclers() { return mcycle1(); }
      virtual int mcycle1();
      bool isvalid0(const int m) { return ( m < mcycle0() ) ; }
      bool isvalid(const int m) { return ( m < mcycle() ) ; }
      bool isvalid1(const int m) { return ( m < mcycle1() ) ; }
      bool isvalidrs(const int m) { return ( m < mcyclers() ) ; }
      virtual Data_t scal( const int a, const int m ) { return scal0(a,m); }
      virtual Data_t scal0( const int a, const int m );
      virtual Data_t wav( const int a, const int m ) { return wav0(a,m); }
      virtual Data_t wav0( const int a, const int m );
      virtual Data_t ave( const int a, const int m ) { return ave0(a,m); }
      virtual Data_t ave0( const int a, const int m );
      virtual Data_t chg( const int a, const int m ) { return chg0(a,m); }
      virtual Data_t chg0( const int a, const int m );
      virtual Data_t scalrs( const int a, const int m ) { return scal1(a,m); }
      virtual Data_t scal1( const int a, const int m );
      virtual Data_t wavrs( const int a, const int m ) { return wav1(a,m); }
      virtual Data_t wav1( const int a, const int m );
      virtual Data_t avers( const int a, const int m ) { return ave1(a,m); }
      virtual Data_t ave1( const int a, const int m );
      virtual Data_t chgrs( const int a, const int m ) { return chg1(a,m); }
      virtual Data_t chg1( const int a, const int m );
      virtual int imcycle() { return 0; }
      virtual void scal( const int a, const int m, Data_t tmp ) {}
      virtual void wav( const int a, const int m, Data_t tmp ) {}
      virtual void detectlt( const Data_t* thresh, int* hit );
      virtual void detectle( const Data_t* thresh, int* hit );
      virtual void detectgt( const Data_t* thresh, int* hit );
      virtual void detectge( const Data_t* thresh, int* hit );

   protected:

      int _Asize;
      int _Msize;
      int _amax;
      int _mmax;
      int _mrastep;
      Data_t* _mracoef;
      Data_t* _mracoefrs;
      Data_t* _data;

};

template <typename Data_t>
inline Rtrsmra<Data_t,array>::Rtrsmra( const int asize, const int msize ) 
  : _Asize(asize), _Msize(msize), _amax(asize-1), _mmax(msize-1), _mrastep(-1)
{
   _mracoef = new Data_t[ _Asize* _Msize*2 ];
   for( int i = 0; i < _Asize*_Msize*2; i++ ) { _mracoef[i] = 0; }

   _mracoefrs = new Data_t[ _Asize*_Msize*2 ];
   for( int i = 0; i < _Asize*_Msize*2; i++ ) { _mracoefrs[i] = 0; }

   _data = new Data_t[ _Asize ];
   for( int i = 0; i< _Asize; i++ ) { _data[i] = 0; }
}

template <typename Data_t>
inline Rtrsmra<Data_t,array>::Rtrsmra( const Rtrsmra<Data_t,array> &rhs ) 
  : _Asize( rhs._Asize ), _Msize( rhs._Msize ), 
    _amax( rhs._amax ), _mmax( rhs._mmax ), 
    _mrastep( rhs._mrastep )
{
   _mracoef = new Data_t[ _Asize* _Msize*2 ];
   for( int i = 0; i < _Asize*_Msize*2; i++ ) { 
      _mracoef[i] = rhs._mracoef[i]; 
   }

   _mracoefrs = new Data_t[ _Asize*_Msize*2 ];
   for(int i = 0; i < _Asize*_Msize*2; i++) {
      _mracoefrs[i] = rhs._mracoefrs[i];
   }

   _data = new Data_t[ _Asize ];
   for( int i = 0; i< _Asize; i++ ) { _data[i] = rhs._data[i]; }
}

template <typename Data_t>
inline Rtrsmra<Data_t,array>::~Rtrsmra() 
{
   if ( _data != 0 ) { delete [] _data; _data = 0; }
   if ( _mracoefrs != 0 ) { delete [] _mracoefrs; _mracoefrs = 0; }
   if ( _mracoef != 0 ) { delete [] _mracoef; _mracoef = 0; }
}

template <typename Data_t>
inline void Rtrsmra<Data_t,array>::remalloc( const int asize, const int msize )
{
   _Asize = asize;
   _Msize = msize;
   _amax = asize-1;
   _mmax = msize-1;
   _mrastep = -1;
   if (_mracoef) delete [] _mracoef; _mracoef = 0;
   _mracoef = new Data_t[ _Asize*_Msize*2 ];
   for( int i = 0; i < _Asize*_Msize*2; i++ ) { _mracoef[i] = 0; }

   if (_mracoefrs) delete [] _mracoefrs; _mracoefrs = 0;
    _mracoefrs = new Data_t[ _Asize*_Msize*2 ];
    for( int i = 0; i < _Asize*_Msize*2; i++ ) { _mracoefrs[i] = 0; }

   if (_data) delete [] _data; _data = 0;
   _data = new Data_t[ _Asize ];
   for( int i = 0; i < _Asize; i++ ) { _data[i] = 0; }
}

template <typename Data_t>
inline void Rtrsmra<Data_t,array>::clear() 
{
   _mrastep = -1;
   for( int i = 0; i < _Asize*_Msize*2; i++ ) { _mracoef[i] = 0; }
   for( int i = 0; i < _Asize*_Msize*2; i++ ) { _mracoefrs[i] = 0; }
   for( int i = 0; i < _Asize; i++ ) { _data[i] = 0; }
}

template <typename Data_t>
inline void Rtrsmra<Data_t,array>::assign( const Data_t data )
{
   for( int a = 0; a <= _amax; a++ ) {
      _data[a] = data;
   }
}

template <typename Data_t>
inline void Rtrsmra<Data_t,array>::assign( const Data_t *data )
{
   for( int a = 0; a <= _amax; a++ ) {
      _data[a] = *data[a];
   }
}

template <typename Data_t>
inline void Rtrsmra<Data_t,array>::assign( const int a0, const int a1,
  const Data_t* data
  )
{
   if ( ( a0 <= a1 ) && ( a0 >= 0 ) && ( a0 <= _amax )
     && ( a1 >= 0 ) && ( a1 <= _amax ) ) {
      for( int a = a0; a <= a1; a++) { _data[a] = data[a]; }
   }
}

template <typename Data_t>
inline void Rtrsmra<Data_t,array>::zero()
{
   for( int a = 0; a <= _amax; a++ ) {
      _data[a] = 0;
   }
}

template <typename Data_t>
inline void Rtrsmra<Data_t,array>::rtwt() 
{
#ifdef STORM_USEC
   rtrsmrartrswt( 
     _Asize, _Msize, 
     _amax, _mmax, _mrastep, 
     _mracoef, _mracoefrs, 
     _data 
   );
#else
   _mrastep++;
   int mcycle = 0;
   while ( ( _mrastep & (1<<mcycle) ) && ( mcycle < _mmax ) ) { mcycle++; }
   int mcyclers = mcycle + 1;
   if ( ( _mrastep < (1<<mcyclers) ) || ( mcyclers > _mmax ) ) { mcyclers = 0; }
   for( int a=0; a <= _amax; a++ ) {
      Data_t tmp = _data[a];
      int m = 1;
      Data_t tmpold,tmps,tmpw;
      while ( m <= mcycle ) {
         tmpold = _mracoef[ _Msize*2*a + 2*(m-1) ];
         tmps = (tmpold+tmp) * INVSQRT2;
         tmpw = (tmpold-tmp) * INVSQRT2;
         _mracoef[ _Msize*2*a + 2*(m-1) ] = tmp;
         _mracoef[ _Msize*2*a + 2*m + 1 ] = tmpw;
         tmp = tmps;
         m++;
      }
      if ( m == mcyclers ) {
         tmpold = _mracoef[ _Msize*2*a + 2*(m-1) ];
         tmps = (tmpold+tmp) * INVSQRT2;
         tmpw = (tmpold-tmp) * INVSQRT2;
         _mracoefrs[ _Msize*2*a + 2*m ] = tmps;
         _mracoefrs[ _Msize*2*a + 2*m + 1 ] = tmpw;
      }
      _mracoef[ _Msize*2*a + 2*(m-1) ] = tmp;
   }
#endif
}

template <typename Data_t>
inline int Rtrsmra<Data_t,array>::mcycle0() 
{
   int mcycle;
#ifdef STORM_USEC
   rtrsmramcycle( _Msize, _mmax, _mrastep, mcycle);
#else
   while ( ( _mrastep & (1<<mcycle) ) && ( mcycle < _mmax ) ) { mcycle++; }
#endif
   return mcycle;
}

template <typename Data_t>
inline int Rtrsmra<Data_t,array>::mcycle1() 
{
   int mcyclers;
#ifdef STORM_USEC
   rtrsmramcyclers( _Msize, _mmax, _mrastep, mcyclers );
#else
   while ( ( _mrastep & (1<<mcyclers) ) && ( mcyclers < _mmax ) ) { 
      mcyclers++; 
   }
   mcyclers++;
   if ( ( _mrastep < (1<<mcyclers) ) || ( mcyclers > _mmax ) ) { mcyclers = 0; }
#endif
   return mcyclers;
}

template <typename Data_t>
inline Data_t Rtrsmra<Data_t,array>::scal0( const int a, const int m ) 
{
   Data_t scalcoef;
#ifdef STORM_USEC
   rtrsmrascalcoef( 
     _Asize, _Msize, 
     _amax, _mmax, _mrastep, 
     _mracoef, _mracoefrs, 
     a, m, scalcoef
   );
#else
//   if ( ( a >= 0 ) && ( a <= _amax ) && ( m >= 0 ) && ( m <= _mmax ) ) {
      scalcoef = _mracoef[ _Msize*2*a + 2 *m ];
//   } else {
//      scalcoef = 1.0/0;
//   }
#endif
   return scalcoef;
}

template <typename Data_t>
inline Data_t Rtrsmra<Data_t,array>::wav0( const int a, const int m ) 
{
   Data_t wavcoef;
#ifdef STORM_USEC
   rtrsmrawavcoef( 
     _Asize, _Msize, 
     _amax, _mmax, _mrastep, 
     _mracoef, _mracoefrs, 
     a, m, wavcoef
   );
#else
//   if ( ( a >= 0 ) && ( a <= _amax ) && ( m >= 0 ) && ( m <= _mmax ) ) {
      wavcoef = _mracoef[ _Msize*2*a + 2*m + 1 ];
//   } else {
//      wavcoef = 1.0/0;
//   }
#endif
   return wavcoef;
}

template <typename Data_t>
inline Data_t Rtrsmra<Data_t,array>::ave0( const int a, const int m ) 
{
   Data_t scala;
#ifdef STORM_USEC
   rtrsmrascala( 
     _Asize, _Msize, 
     _amax, _mmax, _mrastep, 
     _mracoef, _mracoefrs, 
     a, m, scala
   );
#else
//   if ( ( a >= 0 ) && ( a <= _amax ) && ( m >= 0 ) && ( m <= _mmax ) ) {
      scala = _mracoef[ _Msize*2*a + 2*m ] * pow(INVSQRT2,m);
//   } else {
//      scala = 1.0/0;
//   }
#endif
   return scala;
}

template <typename Data_t>
inline Data_t Rtrsmra<Data_t,array>::chg0( const int a, const int m ) 
{
   Data_t wavd;
#ifdef STORM_USEC
   rtrsmrawavd( 
     _Asize, _Msize, 
     _amax, _mmax, _mrastep, 
     _mracoef, _mracoefrs, 
     a, m, wavd 
   );
#else
//   if ( ( a >= 0 ) && ( a <= _amax ) && ( m >= 0 ) && ( m <= _mmax ) ) {
      wavd = _mracoef[ _Msize*2*a + 2*m + 1 ] * pow(INVSQRT2,m);
//   } else {
//      wavd = 1.0/0;
//   }
#endif
   return wavd;
}

template <typename Data_t>
inline Data_t Rtrsmra<Data_t,array>::scal1( const int a, const int m ) 
{
   Data_t scalcoefrs;
#ifdef STORM_USEC
   rtrsmrascalcoefrs( 
     _Asize, _Msize, 
     _amax, _mmax, _mrastep, 
     _mracoef, _mracoefrs, 
     a, m, scalcoefrs
   );
#else
//   if ( ( a >= 0 ) && ( a <= _amax ) && ( m >= 0 ) && ( m <= _mmax ) ) {
      scalcoefrs = _mracoefrs[ _Msize*2*a + 2*m ];
//   } else {
//      scalcoefrs = 1.0/0.0;
//   }
#endif
   return scalcoefrs;
}

template <typename Data_t>
inline Data_t Rtrsmra<Data_t,array>::wav1( const int a, const int m ) 
{
   Data_t wavcoefrs;
#ifdef STORM_USEC
   rtrsmrawavcoefrs( 
     _Asize, _Msize, 
     _amax, _mmax, _mrastep, 
     _mracoef, _mracoefrs, 
     a, m, wavcoefrs
   );
#else
//   if ( ( a >= 0 ) && ( a <= _amax ) && (m >=0 ) && ( m <= _mmax ) ) {
      wavcoefrs = _mracoefrs[ _Msize*2*a + 2*m + 1 ];
//   } else {
//      wavcoefrs = 1.0/0;
//   }
#endif
   return wavcoefrs;
}

template <typename Data_t>
inline Data_t Rtrsmra<Data_t,array>::ave1( const int a, const int m ) 
{
   Data_t scalars;
#ifdef STORM_USEC
   rtrsmrascalars( _Asize, _Msize, 
     _amax, _mmax, _mrastep, 
     _mracoef, _mracoefrs, 
     a, m, scalars
   );
#else
//   if ( ( a >= 0 ) && ( a <= _amax ) && ( m >= 0 ) && ( m <= _mmax ) ) {
      scalars = _mracoefrs[ _Msize*2*a + 2*m ] * pow(INVSQRT2,m);
//   } else {
//      scalars = 1.0/0;
//   }
#endif
   return scalars;
}

template <typename Data_t>
inline Data_t Rtrsmra<Data_t,array>::chg1( const int a, const int m ) 
{
   Data_t wavdrs;
#ifdef STORM_USEC
   rtrsmrawavdrs( _Asize, _Msize, 
     _amax, _mmax, _mrastep, 
     _mracoef, _mracoefrs, 
     a, m, wavdrs 
   );
#else
//   if ( ( a >= 0 ) && ( a <= _amax ) && ( m >= 0 ) && ( m <= _mmax ) ) {
      wavdrs = _mracoefrs[ _Msize*2*a + 2*m + 1 ] * pow(INVSQRT2,m);
//   } else {
//      wavdrs = 1.0/0;
//   }
#endif
   return wavdrs;
}

template <typename Data_t>
inline void Rtrsmra<Data_t,array>::detectlt( const Data_t* thresh, int* hit ) 
{
#ifdef STORM_USEC
   rtrsdetectlt( _Asize, _Msize, 
     _amax, _mmax, _mrastep, 
     _mracoef, _mracoefrs, 
     thresh, hit
   );
#else
   for( int m = 0; m <= _mmax; m++ ) {
      hit[m] = 0;
      for( int a=0; a <= _amax; a++ ) {
         if ( abs( _mracoef[ _Msize*2*a + 2*m + 1 ]
           + _mracoefrs[ _Msize*2*a + 2*m + 1 ] ) < thresh[m] ) { hit[m]++; }
      }
   }
#endif
}

template <typename Data_t>
inline void Rtrsmra<Data_t,array>::detectle( const Data_t* thresh, int* hit ) 
{
#ifdef STORM_USEC
   rtrsdetectle( _Asize, _Msize, 
     _amax, _mmax, _mrastep, 
     _mracoef, _mracoefrs, 
     thresh, hit
   );
#else
   for(int m=0; m <= _mmax; m++) {      
      hit[m]=0;
      for(int a=0; a <= _amax; a++) {
         if (abs(_mracoef[ _Msize*2*a + 2*m + 1 ]
           +_mracoefrs[_Msize*2*a + 2*m + 1 ] ) <= thresh[m] ) { hit[m]++; }
      }
   }
#endif
}

template <typename Data_t>
inline void Rtrsmra<Data_t,array>::detectgt( const Data_t* thresh, int* hit ) 
{
#ifdef STORM_USEC
   rtrsdetectgt( 
     _Asize, _Msize, 
     _amax, _mmax, _mrastep, 
     _mracoef, _mracoefrs, 
     thresh, hit
   );
#else
   for( int m = 0; m <= _mmax; m++ ) {
      hit[m] = 0;
      for( int a = 0; a <= _amax; a++ ) {
         if ( abs( _mracoef[ _Msize*2*a + 2*m + 1 ]
           + _mracoefrs[_Msize*2*a + 2*m + 1 ] ) > thresh[m] ) { hit[m]++; }
      }
   }
#endif
}

template <typename Data_t>
inline void Rtrsmra<Data_t,array>::detectge( const Data_t* thresh, int* hit ) 
{
#ifdef STORM_USEC
   rtrsdetectge( 
     _Asize, _Msize, 
     _amax, _mmax, _mrastep, 
     _mracoef, _mracoefrs, 
     thresh, hit
   );
#else
   for( int m = 0; m <= _mmax; m++ ) {
      hit[m] = 0;
      for( int a = 0; a <= _amax; a++ ) {
         if ( abs( _mracoef[ _Msize*2*a + 2*m + 1 ]
           + _mracoefrs[_Msize*2*a + 2*m + 1 ] ) >= thresh[m] ) { hit[m]++; }
      }
   }
#endif
}

#endif // _RTRSMRA_DATA_T_ARRAY_H

---