Diff: IIR_Cascade.hpp

Revision:

1:69a8b728e8d2

Parent:

0:d2f279439aaf

Child:

2:2533ed0150e7

diff -r d2f279439aaf -r 69a8b728e8d2 IIR_Cascade.hpp
--- a/IIR_Cascade.hpp	Thu Sep 03 00:42:10 2015 +0000
+++ b/IIR_Cascade.hpp	Fri Sep 11 07:34:10 2015 +0000
@@ -1,55 +1,53 @@
 //----------------------------------------------------------------
 //  縦続形 IIR フィルタ（Biquad クラスを使用）
 //  Class for IIR filter of cascade structure using Biquad class
-//  2015/09/03, Copyright (c) 2015 MIKAMI, Naoki
+//  2015/09/11, Copyright (c) 2015 MIKAMI, Naoki
 //----------------------------------------------------------------
 
 #ifndef IIR_CASCADE_HPP
 #define IIR_CASCADE_HPP
 
+#include "mbed.h"
 #include "Biquad.hpp"
 
 namespace Mikami
 {
+    // IIR filter -- Cascade structure
     template<int order> class IirCascade
     {
     public:
-    
-        // constructor
-        IirCascade(const Biquad::Coefs ck[], float g0) : g0_(g0) 
+        IirCascade() {}
+        IirCascade(float g0, const Biquad::Coefs ck[])
+        { SetCoefs(g0, ck); }
+
+        void SetCoefs(float g0, const Biquad::Coefs ck[])
         {
-            for (int n=0; n<order/2; n++)
-                hk_[n] = new Biquad(ck[n]);
-            Clear();
-        }
-    
-        // destructor
-        ~IirCascade()
-        {
-            for  (int n=0; n<order/2; n++) delete hk_[n];
-        }
-        
-        // clear internal buffer
-        void Clear()
-        {
-            for (int k=0; k<order/2; k++) hk_[k]->Clear();
+            g0_ = g0;
+            for (int k=0; k<order/2; k++)
+                hk_[k].SetCoefs(ck[k]);
         }
 
-        // execute filter
         float Execute(float xn)
         {
             float yn = g0_*xn;
-            for (int k=0; k<order/2; k++) yn = hk_[k]->Execute(yn);
+            for (int k=0; k<order/2; k++)
+                yn = hk_[k].Execute(yn);
+                
             return yn;
         }
-
+        
+        void Clear()
+        {
+            for (int k=0; k<order/2; k++)
+                hk_[k].Clear();
+        }
     private:
-        Biquad* hk_[order/2];   // biquad IIR filter
-        const float g0_;        // gain factor
+        Biquad hk_[order/2];    // Elements of cascade structure
+        float g0_;              // gain factor
 
         // disallow copy constructor and assignment operator
         IirCascade(const IirCascade&);
-        IirCascade& operator = (const IirCascade&);
-   };
+        IirCascade& operator=(const IirCascade&);
+    };
 }
-#endif  // IIR_CASCADE_HPP 
+#endif  // IIR_CASCADE_HPP