IIR_Cascade.hpp

00001 //------------------------------------------------------------------------------
00002 //  縦続形 IIR フィルタのクラス
00003 //  2015/03/16, Copyright (c) 2015 MIKAMI, Naoki
00004 //------------------------------------------------------------------------------
00005 
00006 #ifndef IIR_CASCADE_HPP
00007 #define IIR_CASCADE_HPP
00008 
00009 #include "Biquad.hpp"
00010 
00011 namespace Mikami
00012 {
00013     template<int order> class IIR_Cascade
00014     {
00015     public:
00016     
00017         // コンストラクタ
00018         IIR_Cascade(const Biquad::Coefs ck[], float g0) : g0_(g0) 
00019         {
00020             for (int n=0; n<order/2; n++)
00021                 hk_[n] = new Biquad(ck[n]);
00022             Clear();
00023         }
00024     
00025 //        ~IIR_Cascade() { delete[] hk_; }
00026         
00027         // 過去の計算結果を格納する配列のクリア
00028         void Clear()
00029         {
00030             for (int k=0; k<order/2; k++) hk_[k]->Clear();
00031         }
00032 
00033         // フィルタ処理の実行
00034         float Execute(float xn)
00035         {
00036             float yn = g0_*xn;
00037             for (int k=0; k<order/2; k++) yn = hk_[k]->Execute(yn);
00038             return yn;
00039         }
00040 
00041     private:
00042         Biquad* hk_[order/2];   // 2 次の IIR フィルタ
00043         const float g0_;        // 利得定数
00044     };
00045 }
00046 /*
00047 template<int order> class IIR_Cascade
00048 {
00049 public:
00050     struct Coefs { float a1, a2, b1, b2; }; // フィルタ係数のための構造体
00051     
00052     // コンストラクタ
00053     IIR_Cascade(const Coefs ck[], float g0) : ck_(ck), g0_(g0) 
00054     {
00055         Clear();
00056     }
00057     
00058     // 過去の計算結果を格納する配列のクリア
00059     void Clear()
00060     {
00061         for (int k=0; k<order/2; k++)  // 過去の入力信号が格納される配列をクリア
00062         {
00063             uk_[k].u1 = 0;
00064             uk_[k].u2 = 0;
00065         }
00066     }
00067 
00068     // フィルタ処理の実行
00069     float Execute(float xn)
00070     {
00071         float yn = g0_*xn;
00072         for (int k=0; k<order/2; k++)
00073         {
00074             // 差分方程式に対応する計算
00075             float un = ck_[k].a1*uk_[k].u1 + ck_[k].a2*uk_[k].u2 + yn;
00076             yn = un + ck_[k].b1*uk_[k].u1 + ck_[k].b2*uk_[k].u2;
00077             // 計算結果の移動
00078             uk_[k].u2 = uk_[k].u1;
00079             uk_[k].u1 = un;
00080         }
00081         return yn;
00082     }
00083 
00084 private:
00085     struct Un { float u1, u2; };    // 過去の計算結果格納のための構造体
00086     Un uk_[order/2];                // 過去の計算結果を格納する配列
00087     const Coefs *const ck_;         // フィルタの係数
00088     const float g0_;                // 利得定数
00089 };
00090 */
00091 #endif  // IIR_CASCADE_HPP