IT++ Logo
filter.h
Go to the documentation of this file.
1
29#ifndef FILTER_H
30#define FILTER_H
31
32#include <itpp/base/vec.h>
33#include <itpp/itexports.h>
34
35namespace itpp
36{
37
53template <class T1, class T2, class T3>
54class Filter
55{
56public:
58 Filter() {}
60 virtual T3 operator()(const T1 Sample) { return filter(Sample); }
62 virtual Vec<T3> operator()(const Vec<T1> &v);
64 virtual ~Filter() {}
65protected:
70 virtual T3 filter(const T1 Sample) = 0;
71};
72
97template <class T1, class T2, class T3>
98class MA_Filter : public Filter<T1, T2, T3>
99{
100public:
102 explicit MA_Filter();
104 explicit MA_Filter(const Vec<T2> &b);
106 virtual ~MA_Filter() { }
108 Vec<T2> get_coeffs() const { return coeffs; }
110 void set_coeffs(const Vec<T2> &b);
112 void clear() { mem.clear(); }
116 void set_state(const Vec<T3> &state);
117
118private:
119 virtual T3 filter(const T1 Sample);
120
121 Vec<T3> mem;
122 Vec<T2> coeffs;
123 int inptr;
124 bool init;
125};
126
151template <class T1, class T2, class T3>
152class AR_Filter : public Filter<T1, T2, T3>
153{
154public:
156 explicit AR_Filter();
158 explicit AR_Filter(const Vec<T2> &a);
160 virtual ~AR_Filter() { }
162 Vec<T2> get_coeffs() const { return coeffs; }
164 void set_coeffs(const Vec<T2> &a);
166 void clear() { mem.clear(); }
168 Vec<T3> get_state() const;
170 void set_state(const Vec<T3> &state);
171
172private:
173 virtual T3 filter(const T1 Sample);
174
175 Vec<T3> mem;
176 Vec<T2> coeffs;
177 Vec<T2> a0;
178 int inptr;
179 bool init;
180};
181
182
209template <class T1, class T2, class T3>
210class ARMA_Filter : public Filter<T1, T2, T3>
211{
212public:
214 explicit ARMA_Filter();
216 explicit ARMA_Filter(const Vec<T2> &b, const Vec<T2> &a);
218 virtual ~ARMA_Filter() { }
220 Vec<T2> get_coeffs_a() const { return acoeffs; }
222 Vec<T2> get_coeffs_b() const { return bcoeffs; }
224 void get_coeffs(Vec<T2> &b, Vec<T2> &a) const { b = bcoeffs; a = acoeffs; }
226 void set_coeffs(const Vec<T2> &b, const Vec<T2> &a);
228 void clear() { mem.clear(); }
230 Vec<T3> get_state() const;
232 void set_state(const Vec<T3> &state);
233
234private:
235 virtual T3 filter(const T1 Sample);
236
237 Vec<T3> mem;
238 Vec<T2> acoeffs, bcoeffs;
239 int inptr;
240 bool init;
241};
242
243
244
268ITPP_EXPORT vec filter(const vec &b, const vec &a, const vec &input);
269ITPP_EXPORT cvec filter(const vec &b, const vec &a, const cvec &input);
270ITPP_EXPORT cvec filter(const cvec &b, const cvec &a, const cvec &input);
271ITPP_EXPORT cvec filter(const cvec &b, const cvec &a, const vec &input);
272
273ITPP_EXPORT vec filter(const vec &b, const int one, const vec &input);
274ITPP_EXPORT cvec filter(const vec &b, const int one, const cvec &input);
275ITPP_EXPORT cvec filter(const cvec &b, const int one, const cvec &input);
276ITPP_EXPORT cvec filter(const cvec &b, const int one, const vec &input);
277
278ITPP_EXPORT vec filter(const int one, const vec &a, const vec &input);
279ITPP_EXPORT cvec filter(const int one, const vec &a, const cvec &input);
280ITPP_EXPORT cvec filter(const int one, const cvec &a, const cvec &input);
281ITPP_EXPORT cvec filter(const int one, const cvec &a, const vec &input);
282
283
284ITPP_EXPORT vec filter(const vec &b, const vec &a, const vec &input, const vec &state_in, vec &state_out);
285ITPP_EXPORT cvec filter(const vec &b, const vec &a, const cvec &input, const cvec &state_in, cvec &state_out);
286ITPP_EXPORT cvec filter(const cvec &b, const cvec &a, const cvec &input, const cvec &state_in, cvec &state_out);
287ITPP_EXPORT cvec filter(const cvec &b, const cvec &a, const vec &input, const cvec &state_in, cvec &state_out);
288
289ITPP_EXPORT vec filter(const vec &b, const int one, const vec &input, const vec &state_in, vec &state_out);
290ITPP_EXPORT cvec filter(const vec &b, const int one, const cvec &input, const cvec &state_in, cvec &state_out);
291ITPP_EXPORT cvec filter(const cvec &b, const int one, const cvec &input, const cvec &state_in, cvec &state_out);
292ITPP_EXPORT cvec filter(const cvec &b, const int one, const vec &input, const cvec &state_in, cvec &state_out);
293
294ITPP_EXPORT vec filter(const int one, const vec &a, const vec &input, const vec &state_in, vec &state_out);
295ITPP_EXPORT cvec filter(const int one, const vec &a, const cvec &input, const cvec &state_in, cvec &state_out);
296ITPP_EXPORT cvec filter(const int one, const cvec &a, const cvec &input, const cvec &state_in, cvec &state_out);
297ITPP_EXPORT cvec filter(const int one, const cvec &a, const vec &input, const cvec &state_in, cvec &state_out);
306ITPP_EXPORT vec fir1(int N, double cutoff);
307
308//----------------------------------------------------------------------------
309// Implementation of templated functions starts here
310//----------------------------------------------------------------------------
311
312//---------------------- class Filter ----------------------------
313
314template <class T1, class T2, class T3>
316{
317 Vec<T3> y(x.length());
318
319 for (int i = 0; i < x.length(); i++) {
320 y[i] = filter(x[i]);
321 }
322
323 return y;
324}
325
326//-------------------------- class MA_Filter ---------------------------------
327
328template <class T1, class T2, class T3>
330{
331 inptr = 0;
332 init = false;
333}
334
335template <class T1, class T2, class T3>
340
341
342template <class T1, class T2, class T3>
344{
345 it_assert(b.size() > 0, "MA_Filter: size of filter is 0!");
346
347 coeffs = b;
348 mem.set_size(coeffs.size(), false);
349 mem.clear();
350 inptr = 0;
351 init = true;
352}
353
354template <class T1, class T2, class T3>
356{
357 it_assert(init == true, "MA_Filter: filter coefficients are not set!");
358
359 int offset = inptr;
360 Vec<T3> state(mem.size());
361
362 for (int n = 0; n < mem.size(); n++) {
363 state(n) = mem(offset);
364 offset = (offset + 1) % mem.size();
365 }
366
367 return state;
368}
369
370template <class T1, class T2, class T3>
372{
373 it_assert(init == true, "MA_Filter: filter coefficients are not set!");
374 it_assert(state.size() == mem.size(), "MA_Filter: Invalid state vector!");
375
376 mem = state;
377 inptr = 0;
378}
379
380template <class T1, class T2, class T3>
382{
383 it_assert(init == true, "MA_Filter: Filter coefficients are not set!");
384 T3 s = 0;
385
386 mem(inptr) = Sample;
387 int L = mem.length() - inptr;
388
389 for (int i = 0; i < L; i++) {
390 s += coeffs(i) * mem(inptr + i);
391 }
392 for (int i = 0; i < inptr; i++) {
393 s += coeffs(L + i) * mem(i);
394 }
395
396 inptr--;
397 if (inptr < 0)
398 inptr += mem.length();
399
400 return s;
401}
402
403//---------------------- class AR_Filter ----------------------------------
404
405template <class T1, class T2, class T3>
407{
408 inptr = 0;
409 init = false;
410}
411
412template <class T1, class T2, class T3>
417
418template <class T1, class T2, class T3>
420{
421 it_assert(a.size() > 0, "AR_Filter: size of filter is 0!");
422 it_assert(a(0) != T2(0), "AR_Filter: a(0) cannot be 0!");
423
424 a0.set_size(1);//needed to keep the first coefficient for future reuse
425 a0(0) = a(0);
426 coeffs = a / a0(0);
427
428 mem.set_size(coeffs.size() - 1, false);
429 mem.clear();
430 inptr = 0;
431 init = true;
432}
433
434
435template <class T1, class T2, class T3>
437{
438 it_assert(init == true, "AR_Filter: filter coefficients are not set!");
439
440 int offset = inptr;
441 Vec<T3> state(mem.size());
442
443 for (int n = 0; n < mem.size(); n++) {
444 state(n) = mem(offset);
445 offset = (offset + 1) % mem.size();
446 }
447
448 return state;
449}
450
451template <class T1, class T2, class T3>
453{
454 it_assert(init == true, "AR_Filter: filter coefficients are not set!");
455 it_assert(state.size() == mem.size(), "AR_Filter: Invalid state vector!");
456
457 mem = state;
458 inptr = 0;
459}
460
461template <class T1, class T2, class T3>
463{
464 it_assert(init == true, "AR_Filter: Filter coefficients are not set!");
465 T3 s = Sample;
466
467 if (mem.size() == 0)
468 return (s / a0(0));
469
470 int L = mem.size() - inptr;
471 for (int i = 0; i < L; i++) {
472 s -= mem(i + inptr) * coeffs(i + 1); // All coeffs except a(0)
473 }
474 for (int i = 0; i < inptr; i++) {
475 s -= mem(i) * coeffs(L + i + 1); // All coeffs except a(0)
476 }
477
478 inptr--;
479 if (inptr < 0)
480 inptr += mem.size();
481 mem(inptr) = s;
482
483 return (s / a0(0));
484}
485
486
487//---------------------- class ARMA_Filter ----------------------------------
488template <class T1, class T2, class T3>
490{
491 inptr = 0;
492 init = false;
493}
494
495template <class T1, class T2, class T3>
497{
498 set_coeffs(b, a);
499}
500
501template <class T1, class T2, class T3>
503{
504 it_assert(a.size() > 0 && b.size() > 0, "ARMA_Filter: size of filter is 0!");
505 it_assert(a(0) != T2(0), "ARMA_Filter: a(0) cannot be 0!");
506
507 acoeffs = a / a(0);
508 bcoeffs = b / a(0);
509
510 mem.set_size(std::max(a.size(), b.size()) - 1, false);
511 mem.clear();
512 inptr = 0;
513 init = true;
514}
515
516template <class T1, class T2, class T3>
518{
519 it_assert(init == true, "ARMA_Filter: filter coefficients are not set!");
520
521 int offset = inptr;
522 Vec<T3> state(mem.size());
523
524 for (int n = 0; n < mem.size(); n++) {
525 state(n) = mem(offset);
526 offset = (offset + 1) % mem.size();
527 }
528
529 return state;
530}
531
532template <class T1, class T2, class T3>
534{
535 it_assert(init == true, "ARMA_Filter: filter coefficients are not set!");
536 it_assert(state.size() == mem.size(), "ARMA_Filter: Invalid state vector!");
537
538 mem = state;
539 inptr = 0;
540}
541
542template <class T1, class T2, class T3>
544{
545 it_assert(init == true, "ARMA_Filter: Filter coefficients are not set!");
546 T3 z = Sample;
547 T3 s;
548
549 for (int i = 0; i < acoeffs.size() - 1; i++) { // All AR-coeff except a(0).
550 z -= mem((i + inptr) % mem.size()) * acoeffs(i + 1);
551 }
552 s = z * bcoeffs(0);
553
554 for (int i = 0; i < bcoeffs.size() - 1; i++) { // All MA-coeff except b(0).
555 s += mem((i + inptr) % mem.size()) * bcoeffs(i + 1);
556 }
557
558 inptr--;
559 if (inptr < 0)
560 inptr += mem.size();
561 mem(inptr) = z;
562
563 mem(inptr) = z; // Store in the internal state.
564
565 return s;
566}
567
569
570// ----------------------------------------------------------------------
571// Instantiations
572// ----------------------------------------------------------------------
573ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT MA_Filter<double, double, double>;
574ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT MA_Filter< double, std::complex<double>,
575 std::complex<double> >;
576ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT MA_Filter< std::complex<double>, double,
577 std::complex<double> >;
578ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT MA_Filter< std::complex<double>, std::complex<double>,
579 std::complex<double> >;
580
581ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT AR_Filter<double, double, double>;
582ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT AR_Filter< double, std::complex<double>,
583 std::complex<double> >;
584ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT AR_Filter< std::complex<double>,
585 double, std::complex<double> >;
586ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT AR_Filter< std::complex<double>, std::complex<double>,
587 std::complex<double> >;
588
589ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT ARMA_Filter<double, double, double>;
590ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT ARMA_Filter< double, std::complex<double>,
591 std::complex<double> >;
592ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT ARMA_Filter< std::complex<double>,
593 double, std::complex<double> >;
594ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT ARMA_Filter< std::complex<double>, std::complex<double>,
595 std::complex<double> >;
596
598
599} // namespace itpp
600
601#endif // #ifndef FILTER_H
Autoregressive Moving Average (ARMA) Filter Base Class.
Definition filter.h:211
void get_coeffs(Vec< T2 > &b, Vec< T2 > &a) const
Filter coefficient access function.
Definition filter.h:224
virtual ~ARMA_Filter()
Class destructor.
Definition filter.h:218
void clear()
Clears the filter memory.
Definition filter.h:228
Vec< T3 > get_state() const
Get state of filter.
Definition filter.h:517
Vec< T2 > get_coeffs_b() const
Filter b coefficient access function.
Definition filter.h:222
ARMA_Filter()
Class constructor.
Definition filter.h:489
void set_state(const Vec< T3 > &state)
Set state of filter.
Definition filter.h:533
void set_coeffs(const Vec< T2 > &b, const Vec< T2 > &a)
Set the filter coefficients (and order)
Definition filter.h:502
Vec< T2 > get_coeffs_a() const
Filter a coefficient access function.
Definition filter.h:220
Autoregressive (AR) Filter Base Class.
Definition filter.h:153
Vec< T2 > get_coeffs() const
Filter coefficient access function.
Definition filter.h:162
void set_coeffs(const Vec< T2 > &a)
Set the filter coefficients (and order)
Definition filter.h:419
Vec< T3 > get_state() const
Get state of filter.
Definition filter.h:436
void set_state(const Vec< T3 > &state)
Set state of filter.
Definition filter.h:452
virtual ~AR_Filter()
Class destructor.
Definition filter.h:160
AR_Filter()
Class constructor.
Definition filter.h:406
void clear()
Clears the filter memory.
Definition filter.h:166
General array class.
Definition array.h:105
int size() const
Returns the number of data elements in the array object.
Definition array.h:155
void set_size(int n, bool copy=false)
Resizing an Array<T>.
Definition array.h:257
int length() const
Returns the number of data elements in the array object.
Definition array.h:157
Virtual Filter Base Class.
Definition filter.h:55
virtual Vec< T3 > operator()(const Vec< T1 > &v)
Filter a vector.
Definition filter.h:315
virtual ~Filter()
Virtual destructor.
Definition filter.h:64
virtual T3 filter(const T1 Sample)=0
Pure virtual filter function. This is where the real filtering is done. Implement this function to cr...
virtual T3 operator()(const T1 Sample)
Filter a single sample.
Definition filter.h:60
Filter()
Default constructor.
Definition filter.h:58
Moving Average Filter Base Class.
Definition filter.h:99
void set_coeffs(const Vec< T2 > &b)
Set the filter coefficients.
Definition filter.h:343
void set_state(const Vec< T3 > &state)
Set state of filter.
Definition filter.h:371
MA_Filter()
Class default constructor.
Definition filter.h:329
MA_Filter(const Vec< T2 > &b)
Class constructor setting the coefficients in the filter.
Definition filter.h:336
virtual ~MA_Filter()
Class destructor.
Definition filter.h:106
Vec< T2 > get_coeffs() const
Filter coefficient access function.
Definition filter.h:108
Vec< T3 > get_state() const
Get state of filter.
Definition filter.h:355
void clear()
Clears the filter memory.
Definition filter.h:112
void clear()
Set the vector to the all zero vector.
Definition vec.h:280
#define it_assert(t, s)
Abort if t is not true.
Definition itassert.h:94
vec fir1(int N, double cutoff)
Design a Nth order FIR filter with cut-off frequency cutoff using the window method.
Definition filter.cpp:243
vec filter(const vec &b, const vec &a, const vec &input)
ARMA filter function.
Definition filter.cpp:39
itpp namespace
Definition itmex.h:37
Templated Vector Class Definitions.

Generated on Tue Aug 17 2021 10:59:15 for IT++ by Doxygen 1.9.8