SR2k4 Assembler: Rtmra_Data_t_array.h Source File

00001 // Rtmra_Data_t_array.h
00002 //////////////////////////////////////////////////////////////////////
00003 //          (c) Copyright 2000-2002 Brown Deer Technology, LLC.
00004 //                        All rights reserved.
00005 //////////////////////////////////////////////////////////////////////
00006 
00007 #ifndef _RTMRA_DATA_T_ARRAY_H
00008 #define _RTMRA_DATA_T_ARRAY_H
00009 
00010 #ifdef USE_STD
00011 #include <cmath>
00012 using namespace std;
00013 #else
00014 #include <math.h>
00015 #endif
00016 
00017 #include "stormdef.h"
00018 #define INVSQRT2 STORMDEF_MATHCONST_INVSQRT2
00019 
00020 // partial specialization Rtmra<Data_t,array>
00021 template <typename Data_t>
00022 class Rtmra<Data_t,array> {
00023 
00024    public:
00025 
00026       typedef Data_t DataType;
00027       static const int ArrayDim = 1;
00028 
00029       Rtmra( const int asize = 1, const int msize = 8 );
00030       virtual ~Rtmra();
00031       virtual void remalloc( const int asize = 1, const int msize = 8 );
00032       virtual void clear();
00033       void assign( const Data_t data );
00034       void assign( const int a0, const int a1, const Data_t* data);
00035       Data_t& operator[]( const int a ) { return _data[a]; }
00036       virtual void rtwt();
00037       virtual void rtiwt();
00038       virtual void rtjiwt();
00039       int operator ++() { rtwt(); return 0; }
00040       int operator ++(int) { rtwt(); return 0; }
00041       int operator --() { rtiwt(); return 0; }
00042       int operator --(int) { rtiwt(); return 0; }
00043       int amax() { return _amax; }
00044       int mmax() { return _mmax; }
00045       int mrastep() { return _mrastep; }
00046       void mrastep( const int mrastep ) { _mrastep = mrastep; } //DEBUG
00047       virtual int mcycle();
00048       bool isvalid(const int m) { return ( m < mcycle() ) ; }
00049       virtual Data_t scal( const int a, const int m );
00050       virtual Data_t wav( const int a, const int m );
00051       virtual Data_t ave( const int a, const int m );
00052       virtual Data_t chg( const int a, const int m );
00053       virtual int imcycle();
00054       virtual void scal( const int a, const int m, Data_t scalcoef);
00055       virtual void wav( const int a, const int m, Data_t wavcoef);
00056 
00057    protected:
00058 
00059       int _Asize;
00060       int _Msize;
00061       int _amax;
00062       int _mmax;
00063       int _mrastep;
00064       Data_t* _mracoef;
00065       Data_t* _data;
00066 
00067 };
00068 
00069 template <typename Data_t>
00070 inline Rtmra<Data_t,array>::Rtmra( const int asize, const int msize ) 
00071   : _Asize(asize), _Msize(msize), _amax(asize-1), _mmax(msize-1), _mrastep(-1)
00072 {
00073    _mracoef = new Data_t[ _Asize*_Msize*2 ];
00074    _data = new Data_t[ _Asize ];
00075    for( int i = 0; i< _Asize*_Msize*2; i++) { _mracoef[i] = 0; }
00076    for( int i = 0; i< _Asize; i++) { _data[i] = 0; }
00077 }
00078 
00079 template <typename Data_t>
00080 inline Rtmra<Data_t,array>::~Rtmra() 
00081 {
00082    delete [] _mracoef; _mracoef = 0;
00083    delete [] _data; _data = 0;
00084 }
00085 
00086 template <typename Data_t>
00087 inline void Rtmra<Data_t,array>::remalloc(const int asize , const int msize)
00088 {
00089    _Asize = asize;
00090    _Msize = msize;
00091    _amax = asize-1;
00092    _mmax = msize-1;
00093    _mrastep = -1;
00094    if (_mracoef) delete [] _mracoef; _mracoef = 0;
00095    if (_data) delete [] _data; _data = 0;
00096    _mracoef = new Data_t[ _Asize*_Msize*2 ];
00097    _data = new Data_t[ _Asize ];
00098    for( int i = 0; i < _Asize*_Msize*2; i++ ) { _mracoef[i] = 0; }
00099    for( int i = 0; i < _Asize; i++) { _data[i] = 0; }
00100 }
00101 
00102 template <typename Data_t>
00103 inline void Rtmra<Data_t,array>::clear() 
00104 {
00105    _mrastep = -1;
00106    for( int i = 0; i < _Asize*_Msize*2; i++ ) { _mracoef[i] = 0; }
00107    for( int i = 0; i < _Asize; i++ ) { _data[i] = 0; }
00108 }
00109 
00110 template <typename Data_t>
00111 inline void Rtmra<Data_t,array>::assign( const Data_t data ) 
00112 { 
00113    for( int a = 0; a <= _amax; a++ ) { 
00114       _data[a] = data; 
00115    }
00116 }
00117 
00118 template <typename Data_t>
00119 inline void Rtmra<Data_t,array>::assign( 
00120   const int a0, 
00121   const int a1, 
00122   const Data_t* data 
00123 ) 
00124 { 
00125    if ( ( a0 <= a1 ) && ( a0 >= 0 ) && ( a0 <= _amax ) 
00126      && ( a1 >= 0 ) && ( a1 <= _amax ) ) {
00127       for( int a = a0; a <= a1; a++) { _data[a] = data[a]; }
00128    }
00129 }
00130 
00131 template <typename Data_t>
00132 inline void Rtmra<Data_t,array>::rtwt() 
00133 {
00134 #ifdef STORM_USEC
00135    rtmrartwt( 
00136      _Asize, _Msize, 
00137      _amax, _mmax, 
00138      _mrastep, _mracoef, 
00139      _data 
00140    );
00141 #else
00142    _mrastep++;
00143    int mcycle = 0;
00144    while ( ( _mrastep & (1 << mcycle) ) && ( mcycle < _mmax ) ) { mcycle++; }
00145    int m;
00146    Data_t tmp,tmpold;
00147    for(int a = 0; a <= _amax; a++) {
00148       tmp = _data[a];
00149       m = 1;
00150       while ( m <= mcycle ) {
00151          tmpold = _mracoef[ _Msize*2*a + 2*(m-1) ];
00152          _mracoef[ _Msize*2*a + 2*(m-1) ] = tmp;
00153          _mracoef[ _Msize*2*a + 2*m + 1 ] = (tmpold-tmp) * INVSQRT2;
00154          tmp = (tmpold+tmp) * INVSQRT2;
00155          m++;
00156       }
00157       _mracoef[ _Msize*2*a + 2*(m-1) ] = tmp;
00158    }
00159 #endif
00160 }
00161 
00162 template <typename Data_t>
00163 inline void Rtmra<Data_t,array>::rtiwt() 
00164 {
00165 #ifdef STORM_USEC
00166    rtmrartiwt( 
00167      _Asize, _Msize, 
00168      _amax, _mmax,
00169      _mrastep, _mracoef, 
00170      _data 
00171    );
00172 #else
00173    _mrastep++;
00174    int itmp = ( 1 << _mmax) - 1;
00175    itmp = itmp - ( itmp & _mrastep );
00176    int imcycle = 0;
00177    while ( ( itmp & ( 1 << imcycle ) ) && ( imcycle < _mmax ) ) { imcycle++; }
00178    int m;
00179    for(int a = 0; a <= _amax; a++ ) {
00180       m = imcycle;
00181       if ( m < _mmax ) {
00182          _mracoef[ _Msize*2*a + 2*m ] = 
00183            ( _mracoef[ _Msize*2*a + 2*(m+1) ]
00184            - _mracoef[ _Msize*2*a + 2*(m+1) + 1 ] ) * INVSQRT2;
00185       }
00186       m--;
00187       while ( m >= 0 ) {
00188         _mracoef[ _Msize*2*a + 2*m ] = 
00189           ( _mracoef[ _Msize*2*a + 2*(m+1) ]
00190           + _mracoef[ _Msize*2*a + 2*(m+1) + 1 ] ) * INVSQRT2;
00191         m--;
00192       }
00193       _data[a] = _mracoef[a];
00194    }
00195 #endif
00196 }
00197 
00198 template <typename Data_t>
00199 inline void Rtmra<Data_t,array>::rtjiwt() 
00200 {
00201 //#ifdef STORM_USEC
00202    rtmrartjiwt( 
00203      _Asize, _Msize, 
00204      _amax, _mmax,
00205      _mrastep, _mracoef, 
00206      _data 
00207    );
00208 //#else
00209 //   _mrastep++;
00210 //   int itmp = ( 1 << _mmax) - 1;
00211 //   itmp = itmp - ( itmp & _mrastep );
00212 //   int imcycle = 0;
00213 //   while ( ( itmp & ( 1 << imcycle ) ) && ( imcycle < _mmax ) ) { imcycle++; }
00214 //   int m;
00215 //   for(int a = 0; a <= _amax; a++ ) {
00216 //      m = imcycle;
00217 //      if ( m < _mmax ) {
00218 //         _mracoef[ _Msize*2*a + 2*m ] = 
00219 //           ( _mracoef[ _Msize*2*a + 2*(m+1) ]
00220 //         - _mracoef[ _Msize*2*a + 2*(m+1) + 1 ] ) * INVSQRT2;
00221 //      }
00222 //      m--;
00223 //      while ( m >= 0 ) {
00224 //      _mracoef[ _Msize*2*a + 2*m ] = 
00225 //          ( _mracoef[ _Msize*2*a + 2*(m+1) ]
00226 //        + _mracoef[ _Msize*2*a + 2*(m+1) + 1 ] ) * INVSQRT2;
00227 //      m--;
00228 //      }
00229 //      _data[a] = _mracoef[a];
00230 //   }
00231 //#endif
00232 }
00233 
00234 template <typename Data_t>
00235 inline int Rtmra<Data_t,array>::mcycle() 
00236 {
00237    int mcycle = 0;
00238 #ifdef STORM_USEC
00239    rtmramcycle( _Msize, _mmax, _mrastep, mcycle);
00240 #else
00241    while ( ( _mrastep & (1<<mcycle) ) && ( mcycle < _mmax ) ) { mcycle++; }
00242 #endif
00243    return mcycle;
00244 }
00245 
00246 template <typename Data_t>
00247 inline Data_t Rtmra<Data_t,array>::scal( const int a, const int m ) 
00248 {
00249    Data_t scalcoef;
00250 #ifdef STORM_USEC
00251    rtmrascalcoef( 
00252      _Asize, _Msize, 
00253      _amax, _mmax, 
00254      _mrastep, _mracoef, 
00255      a, m, scalcoef
00256    );
00257 #else
00258 //   if ( ( a >= 0 ) && ( a <= _amax ) && ( m >= 0 ) && ( m <= _mmax ) ) { 
00259       scalcoef = _mracoef[ _Msize*2*a + 2*m ]; 
00260 //   } 
00261 //   else { 
00262 //      scalcoef = 1.0/0; 
00263 //   }
00264 #endif
00265    return scalcoef;
00266 }
00267 
00268 template <typename Data_t>
00269 inline Data_t Rtmra<Data_t,array>::wav( const int a, const int m ) 
00270 {
00271    Data_t wavcoef;
00272 #ifdef STORM_USEC
00273    rtmrawavcoef( 
00274      _Asize, _Msize, 
00275      _amax, _mmax, 
00276      _mrastep, _mracoef, 
00277      a, m, wavcoef
00278    );
00279 #else
00280 //   if ( ( a >= 0 ) && ( a <= _amax ) && ( m >= 0 ) && ( m <= _mmax) ) {
00281       wavcoef = _mracoef[ _Msize*2*a +  2*m + 1 ];
00282 //   } 
00283 //   else { 
00284 //      wavcoef = 1.0/0; 
00285 //   }
00286 #endif
00287    return wavcoef;
00288 }
00289 
00290 template <typename Data_t>
00291 inline Data_t Rtmra<Data_t,array>::ave( const int a, const int m ) 
00292 {
00293    Data_t scala;
00294 #ifdef STORM_USEC
00295    rtmrascala( 
00296      _Asize, _Msize, 
00297      _amax, _mmax, 
00298      _mrastep, _mracoef, 
00299      a, m, scala
00300    );
00301 #else
00302 //   if ( ( a >= 0 ) && ( a <= _amax ) && ( m >= 0 ) && ( m <= _mmax ) ) { 
00303       scala = _mracoef[ _Msize*2*a + 2*m ] * pow(INVSQRT2,m);
00304 //   } else { scala=1.0/0; }
00305 #endif
00306    return scala;
00307 }
00308 
00309 template <typename Data_t>
00310 inline Data_t Rtmra<Data_t,array>::chg( const int a, const int m ) 
00311 {
00312    Data_t wavd;
00313 #ifdef STORM_USEC
00314    rtmrawavd( 
00315      _Asize, _Msize, 
00316      _amax, _mmax, 
00317      _mrastep, _mracoef, 
00318      a, m, wavd
00319    );
00320 #else
00321 //   if ( ( a >= 0 ) && ( a <= _amax ) && ( m >= 0 ) && ( m <= _mmax ) ) {
00322       wavd = _mracoef[ _Msize*2*a + 2*m + 1 ] * pow(INVSQRT2,m);
00323 //   } 
00324 //   else { 
00325 //      wavd = 1.0/0; 
00326 //   }
00327 #endif
00328    return wavd;
00329 }
00330 
00331 template <typename Data_t>
00332 inline int Rtmra<Data_t,array>::imcycle() 
00333 {
00334    int imcycle=0;
00335 #ifdef STORM_USEC
00336    rtmraimcycle( _Msize, _mmax, _mrastep, imcycle);
00337 #else
00338    int itmp = (1<<_mmax) - 1;
00339    itmp = itmp - ( itmp & ( _mrastep +1 ) );
00340    while ( ( itmp & (1<<imcycle) ) && ( imcycle < _mmax ) ) { imcycle++; }
00341 #endif
00342    return imcycle;
00343 }
00344 
00345 template <typename Data_t>
00346 inline void 
00347 Rtmra<Data_t,array>::scal( const int a, const int m, Data_t scalcoef ) 
00348 {
00349 #ifdef STORM_USEC
00350    rtmraputscalcoef( 
00351      _Asize, _Msize, 
00352      _amax, _mmax, 
00353      _mrastep, _mracoef, 
00354      a, m, scalcoef
00355    );
00356 #else
00357 //   if ( ( a >= 0 ) && ( a <= _amax ) && ( m >= 0 ) && (m <= _mmax ) ) { 
00358       _mracoef[ _Msize*2*a + 2*m ] = scalcoef; 
00359 //   }
00360 #endif
00361 }
00362 
00363 template <typename Data_t>
00364 inline void 
00365 Rtmra<Data_t,array>::wav( const int a, const int m, Data_t wavcoef ) 
00366 {
00367 #ifdef STORM_USEC
00368    rtmraputwavcoef( 
00369      _Asize, _Msize, 
00370      _amax, _mmax, 
00371      _mrastep, _mracoef, 
00372      a, m, wavcoef
00373    );
00374 #else
00375 //   if ( ( a >= 0 ) && ( a <= _amax ) && ( m >= 0 ) && ( m <= _mmax ) ) { 
00376       _mracoef[ _Msize*2*a + 2*m + 1] = wavcoef; 
00377 //   }
00378 #endif
00379 }
00380 
00381 template <>
00382 inline void Rtmra<int,array>::rtwt() 
00383 {
00384 #ifdef STORM_USEC
00385    rtmrartwt( 
00386      _Asize, _Msize, 
00387      _amax, _mmax, 
00388      _mrastep, _mracoef, 
00389      _data 
00390    );
00391 #else
00392    _mrastep++;
00393    int mcycle = 0;
00394    while ( ( _mrastep & (1 << mcycle) ) && ( mcycle < _mmax ) ) { mcycle++; }
00395    int m;
00396    int tmp,tmpold;
00397    for(int a = 0; a <= _amax; a++) {
00398       tmp = _data[a];
00399       m = 1;
00400       while ( m <= mcycle ) {
00401          tmpold = _mracoef[ _Msize*2*a + 2*(m-1) ];
00402          _mracoef[ _Msize*2*a + 2*(m-1) ] = tmp;
00403          _mracoef[ _Msize*2*a + 2*m + 1 ] = (tmpold-tmp);
00404          tmp = (tmpold+tmp) >> 1;
00405          m++;
00406       }
00407       _mracoef[ _Msize*2*a + 2*(m-1) ] = tmp;
00408    }
00409 #endif
00410 }
00411 
00412 template <>
00413 inline void Rtmra<int,array>::rtiwt() 
00414 {
00415 #ifdef STORM_USEC
00416    rtmrartiwt( 
00417      _Asize, _Msize, 
00418      _amax, _mmax,
00419      _mrastep, _mracoef, 
00420      _data 
00421    );
00422 #else
00423    _mrastep++;
00424    int itmp = ( 1 << _mmax) - 1;
00425    itmp = itmp - ( itmp & _mrastep );
00426    int imcycle = 0;
00427    while ( ( itmp & ( 1 << imcycle ) ) && ( imcycle < _mmax ) ) { imcycle++; }
00428    int m;
00429    for(int a = 0; a <= _amax; a++ ) {
00430       m = imcycle;
00431       if ( m < _mmax ) {
00432          _mracoef[ _Msize*2*a + 2*m ] = _mracoef[ _Msize*2*a + 2*(m+1) ]
00433            - ( _mracoef[ _Msize*2*a + 2*(m+1) + 1 ] >> 1 );
00434       }
00435       m--;
00436       while ( m >= 0 ) {
00437          _mracoef[ _Msize*2*a + 2*m ] = _mracoef[ _Msize*2*a + 2*(m+1) ]
00438            + ( ( _mracoef[ _Msize*2*a + 2*(m+1) + 1 ] + 1 ) >> 1 );
00439          m--;
00440       }
00441       _data[a] = _mracoef[a];
00442    }
00443 #endif
00444 }
00445 
00446 #endif // _RTMRA_DATA_T_ARRAY_H
00447