Rtrsmra_Data_t_scalar.h

Go to the documentation of this file.

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

#ifndef _RTRSMRA_DATA_T_SCALAR_H
#define _RTRSMRA_DATA_T_SCALAR_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,scalar>
template <typename Data_t>
class Rtrsmra<Data_t,scalar> {

   public:
     
      typedef Data_t DataType;
      static const int ArrayDim = 0;

      Rtrsmra( const int msize = 8);
      Rtrsmra( const Rtrsmra& rhs );
      virtual ~Rtrsmra();
      virtual void remalloc( const int msize = 8);
      virtual void clear();
      void assign( const Data_t data ) { *_data = data; }
      void zero() { *_data = 0; }
      Rtrsmra<Data_t,scalar>& operator=( const Data_t data );
      operator Data_t() { return *_data; }
      virtual void rtwt();
      int operator ++() { rtwt(); return 0; }
      int operator ++(int) { rtwt(); return 0; }
      int mmax() { return _mmax; }
      virtual void rtiwt();
      int operator --() { rtiwt(); return 0; }
      int operator --(int) { rtiwt(); return 0; }
      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 m ) { return scal0(m); }
      virtual Data_t scal0( const int m );
      virtual Data_t scalrs( const int m ) { return scal1(m); }
      virtual Data_t scal1( const int m );
      virtual Data_t wav( const int m ) { return wav0(m); }
      virtual Data_t wav0( const int m );
      virtual Data_t wavrs( const int m ) { return wav1(m); }
      virtual Data_t wav1( const int m );
      virtual Data_t ave( const int m ) { return ave0(m); }
      virtual Data_t ave0( const int m );
      virtual Data_t avers( const int m ) { return ave1(m); }
      virtual Data_t ave1( const int m );
      virtual Data_t chg( const int m ) { return chg0(m); }
      virtual Data_t chg0( const int m );
      virtual Data_t chgrs( const int m ) { return chg1(m); }
      virtual Data_t chg1( const int m );
      virtual int imcycle();
      virtual void scal( const int m, Data_t tmp );
      virtual void wav( const int m, Data_t tmp );
      virtual void detectge( const Data_t* thresh, int* hit );
      virtual void detectgt( const Data_t* thresh, int* hit );
      virtual void detectle( const Data_t* thresh, int* hit );
      virtual void detectlt( const Data_t* thresh, int* hit );

   protected:
      int _Msize;
      int _mmax;
      int _mrastep;
      Data_t* _mracoef;
      Data_t* _mracoefrs;
      Data_t* _data;

};

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

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

   _data = new Data_t;
   *_data = 0;
}

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

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

   _data = new Data_t;
   *_data = rhs._data;
}

template <typename Data_t>
inline Rtrsmra<Data_t,scalar>::~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,scalar>::remalloc( const int msize) 
{
   _Msize = msize;
   _mmax = msize-1;
   _mrastep = -1;
   if (_mracoef) delete [] _mracoef; _mracoef = 0;
   _mracoef = new Data_t[ _Msize*2 ];
   for( int i = 0; i< _Msize*2; i++ ) { _mracoef[i] = 0; }

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

   if (_data) delete _data; _data = 0;
   _data = new Data_t;
   *_data = 0;
}

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

template <typename Data_t>
inline Rtrsmra<Data_t,scalar>& 
  Rtrsmra<Data_t,scalar>::operator=( const Data_t data ) 
{
   assign(data);
   return *this;
}

template <typename Data_t>
inline void Rtrsmra<Data_t,scalar>::rtwt() 
{
#ifdef STORM_USEC
   rtrsmrartrswt( 
     _Msize, _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; }
   float tmp = *_data;
   int m = 1;
   float tmpold, tmps, tmpw;
   while ( m <= mcycle ) {
      tmpold = _mracoef[ 2*(m-1) ];
      tmps = (tmpold+tmp) * INVSQRT2;
      tmpw = (tmpold-tmp) * INVSQRT2;
      _mracoef[ 2*(m-1) ] = tmp;
      _mracoef[ 2*m + 1 ] = tmpw;
      tmp = tmps;
      m++;
   }
   if ( m == mcyclers ) {
      tmpold = _mracoef[ 2*(m-1) ];
      tmps = (tmpold+tmp) * INVSQRT2;
      tmpw = (tmpold-tmp) * INVSQRT2;
      _mracoefrs[ 2*m ] = tmps;
      _mracoefrs[ 2*m + 1 ] = tmpw;
   }
   _mracoef[ 2*(m-1) ] = tmp;
#endif
}

template <typename Data_t>
inline void Rtrsmra<Data_t,scalar>::rtiwt() {}

template <typename Data_t>
inline int Rtrsmra<Data_t,scalar>::mcycle0() 
{
   int mcycle = 0;
#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,scalar>::mcycle1() 
{
   int mcyclers = 0;
#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,scalar>::scal0( const int m ) 
{
   Data_t scalcoef;
#ifdef STORM_USEC
   rtrsmrascalcoef( 
     _Msize, _mmax, _mrastep, 
     _mracoef, _mracoefrs, 
     m, scalcoef
   );
#else
//   if ( ( m >= 0 ) && ( m <= _mmax ) ) { 
      scalcoef = _mracoef[ 2*m ]; 
//   } else { 
//      scalcoef = 1.0/0; 
//   }
#endif
   return scalcoef;
}

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

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

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

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

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

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

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

template <typename Data_t>
inline int Rtrsmra<Data_t,scalar>::imcycle() { return 0; }

template <typename Data_t>
inline void Rtrsmra<Data_t,scalar>::scal( const int m, Data_t tmp ) {}

template <typename Data_t>
inline void Rtrsmra<Data_t,scalar>::wav( const int m, Data_t tmp ) {}

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

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

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

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

#endif // _RTRSMRA_DATA_T_SCALAR_H

---