IT++ Logo

filter.cpp

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

Generated on Sat Apr 19 10:41:57 2008 for IT++ by Doxygen 1.5.5