IT++ Logo Newcom Logo

filter.cpp

Go to the documentation of this file.
00001 
00033 #include <itpp/base/filter.h>
00034 #include <itpp/base/window.h>
00035 #include <itpp/base/matfunc.h>
00036 
00037 
00038 namespace itpp {
00039 
00040 
00041   vec filter(const vec &b, const vec &a, const vec &input)
00042   { 
00043     ARMA_Filter<double, double, double> f(b, a);
00044     return f(input);
00045   }
00046 
00047   cvec filter(const vec &b, const vec &a, const cvec &input)
00048   {
00049     ARMA_Filter<std::complex<double>,double,std::complex<double> > f(b, a);
00050     return f(input);
00051   }
00052 
00053   cvec filter(const cvec &b, const cvec &a, const cvec &input)
00054   {
00055     ARMA_Filter<std::complex<double>,std::complex<double>,std::complex<double> > f(b, a);
00056     return f(input);
00057   }
00058 
00059   cvec filter(const cvec &b, const cvec &a, const vec &input)
00060   {
00061     ARMA_Filter<double,std::complex<double>,std::complex<double> > f(b, a);
00062     return f(input);
00063   }
00064 
00065 
00066   vec filter(const vec &b, const int one, const vec &input)
00067   {
00068     it_assert(one == 1, "filter(): in a MA filter a=1");
00069     MA_Filter<double, double, double> f(b);
00070     return f(input);
00071   }
00072 
00073   cvec filter(const vec &b, const int one, const cvec &input)
00074   {
00075     it_assert(one == 1, "filter(): in a MA filter a=1");
00076     MA_Filter<std::complex<double>,double,std::complex<double> > f(b);
00077     return f(input);
00078   }
00079 
00080   cvec filter(const cvec &b, const int one, const cvec &input)
00081   {
00082     it_assert(one == 1, "filter(): in a MA filter a=1");
00083     MA_Filter<std::complex<double>,std::complex<double>,std::complex<double> > f(b);
00084     return f(input); }
00085 
00086   cvec filter(const cvec &b, const int one, const vec &input)
00087   {
00088     it_assert(one == 1, "filter(): in a MA filter a=1");
00089     MA_Filter<double,std::complex<double>,std::complex<double> > f(b);
00090     return f(input);
00091   }
00092 
00093 
00094   vec filter(const int one, const vec &a, const vec &input)
00095   {
00096     it_assert(one == 1, "filter(): in a AR filter b=1");
00097     AR_Filter<double, double, double> f(a);
00098     return f(input);
00099   }
00100 
00101   cvec filter(const int one, const vec &a, const cvec &input)
00102   {
00103     it_assert(one == 1, "filter(): in a AR filter b=1");
00104     AR_Filter<std::complex<double>,double,std::complex<double> > f(a);
00105     return f(input);
00106   }
00107 
00108   cvec filter(const int one, const cvec &a, const cvec &input)
00109   {
00110     it_assert(one == 1, "filter(): in a AR filter b=1");
00111     AR_Filter<std::complex<double>,std::complex<double>,std::complex<double> > f(a);
00112     return f(input);
00113   }
00114 
00115   cvec filter(const int one, const cvec &a, const vec &input)
00116   {
00117     it_assert(one == 1, "filter(): in a AR filter b=1");
00118     AR_Filter<double,std::complex<double>,std::complex<double> > f(a);
00119     return f(input);
00120   }
00121 
00122 
00123 
00124 
00125 
00126   vec filter(const vec &b, const vec &a, const vec &input, const vec &state_in, vec &state_out)
00127   { 
00128     ARMA_Filter<double, double, double> f(b, a);
00129     f.set_state(state_in);
00130     vec output = f(input);
00131     state_out = f.get_state();
00132     return output;
00133   }
00134 
00135   cvec filter(const vec &b, const vec &a, const cvec &input, const cvec &state_in, cvec &state_out)
00136   {
00137     ARMA_Filter<std::complex<double>,double,std::complex<double> > f(b, a);
00138     f.set_state(state_in);
00139     cvec output = f(input);
00140     state_out = f.get_state();
00141     return output;
00142   }
00143 
00144   cvec filter(const cvec &b, const cvec &a, const cvec &input, const cvec &state_in, cvec &state_out)
00145   {
00146     ARMA_Filter<std::complex<double>,std::complex<double>,std::complex<double> > f(b, a);
00147     f.set_state(state_in);
00148     cvec output = f(input);
00149     state_out = f.get_state();
00150     return output;
00151   }
00152 
00153   cvec filter(const cvec &b, const cvec &a, const vec &input, const cvec &state_in, cvec &state_out)
00154   {
00155     ARMA_Filter<double,std::complex<double>,std::complex<double> > f(b, a);
00156     f.set_state(state_in);
00157     cvec output = f(input);
00158     state_out = f.get_state();
00159     return output;
00160   }
00161 
00162 
00163   vec filter(const vec &b, const int one, const vec &input, const vec &state_in, vec &state_out)
00164   {
00165     it_assert(one == 1, "filter(): in a MA filter a=1");
00166     MA_Filter<double, double, double> f(b);
00167     f.set_state(state_in);
00168     vec output = f(input);
00169     state_out = f.get_state();
00170     return output;
00171   }
00172 
00173   cvec filter(const vec &b, const int one, const cvec &input, const cvec &state_in, cvec &state_out)
00174   {
00175     it_assert(one == 1, "filter(): in a MA filter a=1");
00176     MA_Filter<std::complex<double>,double,std::complex<double> > f(b);
00177     f.set_state(state_in);
00178     cvec output = f(input);
00179     state_out = f.get_state();
00180     return output;
00181   }
00182 
00183   cvec filter(const cvec &b, const int one, const cvec &input, const cvec &state_in, cvec &state_out)
00184   {
00185     it_assert(one == 1, "filter(): in a MA filter a=1");
00186     MA_Filter<std::complex<double>,std::complex<double>,std::complex<double> > f(b);
00187     f.set_state(state_in);
00188     cvec output = f(input);
00189     state_out = f.get_state();
00190     return output;
00191   }
00192 
00193   cvec filter(const cvec &b, const int one, const vec &input, const cvec &state_in, cvec &state_out)
00194   {
00195     it_assert(one == 1, "filter(): in a MA filter a=1");
00196     MA_Filter<double,std::complex<double>,std::complex<double> > f(b);
00197     f.set_state(state_in);
00198     cvec output = f(input);
00199     state_out = f.get_state();
00200     return output;
00201   }
00202 
00203 
00204   vec filter(const int one, const vec &a, const vec &input, const vec &state_in, vec &state_out)
00205   {
00206     it_assert(one == 1, "filter(): in a AR filter b=1");
00207     AR_Filter<double, double, double> f(a);
00208     f.set_state(state_in);
00209     vec output = f(input);
00210     state_out = f.get_state();
00211     return output;
00212   }
00213 
00214   cvec filter(const int one, const vec &a, const cvec &input, const cvec &state_in, cvec &state_out)
00215   {
00216     it_assert(one == 1, "filter(): in a AR filter b=1");
00217     AR_Filter<std::complex<double>,double,std::complex<double> > f(a);
00218     f.set_state(state_in);
00219     cvec output = f(input);
00220     state_out = f.get_state();
00221     return output;
00222   }
00223 
00224   cvec filter(const int one, const cvec &a, const cvec &input, const cvec &state_in, cvec &state_out)
00225   {
00226     it_assert(one == 1, "filter(): in a AR filter b=1");
00227     AR_Filter<std::complex<double>,std::complex<double>,std::complex<double> > f(a);
00228     f.set_state(state_in);
00229     cvec output = f(input);
00230     state_out = f.get_state();
00231     return output;
00232   }
00233 
00234   cvec filter(const int one, const cvec &a, const vec &input, const cvec &state_in, cvec &state_out)
00235   {
00236     it_assert(one == 1, "filter(): in a AR filter b=1");
00237     AR_Filter<double,std::complex<double>,std::complex<double> > f(a);
00238     f.set_state(state_in);
00239     cvec output = f(input);
00240     state_out = f.get_state();
00241     return output;
00242   }
00243 
00244   vec fir1(int N, double cutoff)
00245   {
00246     vec a(N+1),h=hamming(N+1);
00247 
00248     for (int i=0;i<length(a);i++) {
00249       a[i]=h[i]*sinc(cutoff*(i-N/2.0));
00250     }
00251     a/=sum(a);
00252     return a;
00253   }
00254 
00255   //-----------------------------------------------------------------------
00256   //  class Filter
00257   //-----------------------------------------------------------------------
00258 
00259   //template class Filter<double,double,double>;
00260   //template class Filter<double,std::complex<double>,std::complex<double> >;
00261   //template class Filter<std::complex<double>,double,std::complex<double> >;
00262   //template class Filter<std::complex<double>,std::complex<double>,std::complex<double> >;
00263 
00264   //-----------------------------------------------------------------------
00265   //  class MA_Filter
00266   //-----------------------------------------------------------------------
00267 
00268   template class MA_Filter<double,double,double>;
00269   template class MA_Filter<double,std::complex<double>,std::complex<double> >;
00270   template class MA_Filter<std::complex<double>,double,std::complex<double> >;
00271   template class MA_Filter<std::complex<double>,std::complex<double>,std::complex<double> >;
00272 
00273   //-----------------------------------------------------------------------
00274   //  class AR_Filter
00275   //-----------------------------------------------------------------------
00276 
00277   template class AR_Filter<double,double,double>;
00278   template class AR_Filter<double,std::complex<double>,std::complex<double> >;
00279   template class AR_Filter<std::complex<double>,double,std::complex<double> >;
00280   template class AR_Filter<std::complex<double>,std::complex<double>,std::complex<double> >;
00281 
00282   //-----------------------------------------------------------------------
00283   //  class ARMA_Filter
00284   //-----------------------------------------------------------------------
00285 
00286   template class ARMA_Filter<double,double,double>;
00287   template class ARMA_Filter<double,std::complex<double>,std::complex<double> >;
00288   template class ARMA_Filter<std::complex<double>,double,std::complex<double> >;
00289   template class ARMA_Filter<std::complex<double>,std::complex<double>,std::complex<double> >;
00290 
00291 } // namespace itpp
SourceForge Logo

Generated on Sat Aug 25 23:40:23 2007 for IT++ by Doxygen 1.5.2