Merge pull request #25 from mike919192/rename

mike919192 · web-flow · commit 223b3e4e53ea · 2024-07-26T13:38:55.000-04:00
Make naming more consistent
diff --git a/include/sdsp/casc2orderIIR.h b/include/sdsp/casc2orderIIR.h
@@ -6,7 +6,7 @@
 namespace sdsp
 {
 template <size_t M>
-class casc2orderIIR {
+class casc_2o_IIR {
 private:
     int pos{ 0 };
 
@@ -20,12 +20,12 @@ class casc2orderIIR {
     FilterType fType{ FilterType::None };
 
 public:
-    casc2orderIIR()
+    casc_2o_IIR()
     {
         static_assert(M % 2 == 0, "M must be even!");
     }
 
-    void copy_coeff_from(const casc2orderIIR<M> &otherFilter)
+    void copy_coeff_from(const casc_2o_IIR<M> &otherFilter)
     {
         gain = otherFilter.gain;
         bCoeff = otherFilter.bCoeff;
@@ -34,7 +34,7 @@ class casc2orderIIR {
     }
 
     template <typename Iter>
-    void Process(Iter begin, Iter end)
+    void process(Iter begin, Iter end)
     {
         constexpr int order{ 2 };
         constexpr int j1{ 1 };
@@ -79,7 +79,7 @@ class casc2orderIIR {
         mem = y;
     }
 
-    void SetBPCoeff(double f0, double fs, double Q, double gainIn = 1.0)
+    void set_bp_coeff(double f0, double fs, double Q, double gainIn = 1.0)
     {
         gain = gainIn;
         double q2{ 2 * Q };
@@ -137,7 +137,7 @@ class casc2orderIIR {
         }
     }
 
-    void SetHPCoeff(double f0, double fs, double gainIn = 1.0)
+    void set_hp_coeff(double f0, double fs, double gainIn = 1.0)
     {
         gain = gainIn;
         fType = FilterType::HighPass;
@@ -165,7 +165,7 @@ class casc2orderIIR {
         }
     }
 
-    void SetLPCoeff(double f0, double fs, double gainIn = 1.0)
+    void set_lp_coeff(double f0, double fs, double gainIn = 1.0)
     {
         gain = gainIn;
         fType = FilterType::LowPass;
@@ -194,7 +194,7 @@ class casc2orderIIR {
     }
 
     // preload the filter memory for steady state input equal to value parameter
-    void PreloadFilter(double value)
+    void preload_filter(double value)
     {
         double preload_value = value * gain;
         std::array<std::array<double, 3>, M + 1> memVals{ 0 };
@@ -215,7 +215,7 @@ class casc2orderIIR {
 };
 
 template <size_t M>
-class casc_2o_IIR {
+class casc_2o_IIR_base {
 protected:
     int pos{ 0 };
 
@@ -264,7 +264,7 @@ class casc_2o_IIR {
 };
 
 template <size_t M>
-class casc_2o_IIR_lp : casc_2o_IIR<M> {
+class casc_2o_IIR_lp : casc_2o_IIR_base<M> {
 public:
     casc_2o_IIR_lp()
     {
@@ -322,7 +322,7 @@ class casc_2o_IIR_lp : casc_2o_IIR<M> {
 };
 
 template <size_t M>
-class casc_2o_IIR_hp : casc_2o_IIR<M> {
+class casc_2o_IIR_hp : casc_2o_IIR_base<M> {
 public:
     casc_2o_IIR_hp()
     {
@@ -380,7 +380,7 @@ class casc_2o_IIR_hp : casc_2o_IIR<M> {
 };
 
 template <size_t M>
-class casc_2o_IIR_bp : casc_2o_IIR<M> {
+class casc_2o_IIR_bp : casc_2o_IIR_base<M> {
 public:
     casc_2o_IIR_bp()
     {
diff --git a/test/testIIR.cpp b/test/testIIR.cpp
@@ -34,21 +34,21 @@ TEST_CASE("Filter test")
         std::string path = "../../../test_data/impulse_response";
         for (const auto &entry : std::filesystem::directory_iterator(path)) {
             auto [readImpulse, fType, fs, f0, Q] = csvreadImpulse2(entry.path().string());
-            sdsp::casc2orderIIR<4> df;
+            sdsp::casc_2o_IIR<4> df;
 
             if (fType == sdsp::FilterType::LowPass) {
-                df.SetLPCoeff(f0, fs);
+                df.set_lp_coeff(f0, fs);
             } else if (fType == sdsp::FilterType::HighPass) {
-                df.SetHPCoeff(f0, fs);
+                df.set_hp_coeff(f0, fs);
             } else if (fType == sdsp::FilterType::BandPass) {
-                df.SetBPCoeff(f0, fs, Q);
+                df.set_bp_coeff(f0, fs, Q);
             } else {
                 throw std::runtime_error("Unknown filter type");
             }
-            sdsp::casc2orderIIR<4> df2 = df;
+            sdsp::casc_2o_IIR<4> df2 = df;
             std::vector<double> data(readImpulse.size());
             data.at(0) = 1.0;
-            df.Process(data.begin(), data.end());
+            df.process(data.begin(), data.end());
 
             std::vector<double> error(readImpulse.size());
 
@@ -65,11 +65,11 @@ TEST_CASE("Filter test")
             constexpr unsigned int blockSize{ 32 };
             unsigned int index{ 0 };
             for (index = 0; index <= data2.size() - blockSize; index += blockSize) {
-                df2.Process(std::next(data2.begin(), index), std::next(data2.begin(), index + blockSize));
+                df2.process(std::next(data2.begin(), index), std::next(data2.begin(), index + blockSize));
             }
 
             if (index < data2.size()) {
-                df2.Process(std::next(data2.begin(), index), data2.end());
+                df2.process(std::next(data2.begin(), index), data2.end());
             }
 
             REQUIRE(data == data2);
@@ -86,14 +86,14 @@ TEST_CASE("Filter test")
         std::array<double, 1024> impulse2{ 0 };
         impulse2.at(0) = 1.0;
 
-        sdsp::casc2orderIIR<4> df;
-        df.SetLPCoeff(f0, fs);
+        sdsp::casc_2o_IIR<4> df;
+        df.set_lp_coeff(f0, fs);
 
-        sdsp::casc2orderIIR<4> df2;
-        df2.SetLPCoeff(f0, fs, 2.0);
+        sdsp::casc_2o_IIR<4> df2;
+        df2.set_lp_coeff(f0, fs, 2.0);
 
-        df.Process(impulse1.begin(), impulse1.end());
-        df2.Process(impulse2.begin(), impulse2.end());
+        df.process(impulse1.begin(), impulse1.end());
+        df2.process(impulse2.begin(), impulse2.end());
 
         auto times_two = [](double &n) { n = 2.0 * n; };
         std::for_each(impulse1.begin(), impulse1.end(), times_two);
@@ -117,14 +117,14 @@ TEST_CASE("Filter test")
         std::array<double, 1024> impulse2{ 0 };
         impulse2.at(0) = 1.0;
 
-        sdsp::casc2orderIIR<4> df;
-        df.SetHPCoeff(f0, fs);
+        sdsp::casc_2o_IIR<4> df;
+        df.set_hp_coeff(f0, fs);
 
-        sdsp::casc2orderIIR<4> df2;
-        df2.SetHPCoeff(f0, fs, 2.0);
+        sdsp::casc_2o_IIR<4> df2;
+        df2.set_hp_coeff(f0, fs, 2.0);
 
-        df.Process(impulse1.begin(), impulse1.end());
-        df2.Process(impulse2.begin(), impulse2.end());
+        df.process(impulse1.begin(), impulse1.end());
+        df2.process(impulse2.begin(), impulse2.end());
 
         auto times_two = [](double &n) { n = 2.0 * n; };
         std::for_each(impulse1.begin(), impulse1.end(), times_two);
@@ -149,14 +149,14 @@ TEST_CASE("Filter test")
         std::array<double, 1024> impulse2{ 0 };
         impulse2.at(0) = 1.0;
 
-        sdsp::casc2orderIIR<4> df;
-        df.SetBPCoeff(f0, fs, Q);
+        sdsp::casc_2o_IIR<4> df;
+        df.set_bp_coeff(f0, fs, Q);
 
-        sdsp::casc2orderIIR<4> df2;
-        df2.SetBPCoeff(f0, fs, Q, 2.0);
+        sdsp::casc_2o_IIR<4> df2;
+        df2.set_bp_coeff(f0, fs, Q, 2.0);
 
-        df.Process(impulse1.begin(), impulse1.end());
-        df2.Process(impulse2.begin(), impulse2.end());
+        df.process(impulse1.begin(), impulse1.end());
+        df2.process(impulse2.begin(), impulse2.end());
 
         auto times_two = [](double &n) { n = 2.0 * n; };
         std::for_each(impulse1.begin(), impulse1.end(), times_two);
@@ -180,10 +180,10 @@ TEST_CASE("Filter test")
         {
             std::array<double, 1024> steadyLP;
             steadyLP.fill(steadyValue);
-            sdsp::casc2orderIIR<4> lpFilter;
-            lpFilter.SetLPCoeff(f0, fs);
-            lpFilter.PreloadFilter(steadyValue);
-            lpFilter.Process(steadyLP.begin(), steadyLP.end());
+            sdsp::casc_2o_IIR<4> lpFilter;
+            lpFilter.set_lp_coeff(f0, fs);
+            lpFilter.preload_filter(steadyValue);
+            lpFilter.process(steadyLP.begin(), steadyLP.end());
             auto calcError = [steadyValue](double &n) { n = std::abs(n - steadyValue); };
             std::for_each(steadyLP.begin(), steadyLP.end(), calcError);
             double maxErrorLP = *std::max_element(steadyLP.begin(), steadyLP.end());
@@ -193,10 +193,10 @@ TEST_CASE("Filter test")
         {
             std::array<double, 1024> steadyHP;
             steadyHP.fill(steadyValue);
-            sdsp::casc2orderIIR<4> hpFilter;
-            hpFilter.SetHPCoeff(f0, fs);
-            hpFilter.PreloadFilter(steadyValue);
-            hpFilter.Process(steadyHP.begin(), steadyHP.end());
+            sdsp::casc_2o_IIR<4> hpFilter;
+            hpFilter.set_hp_coeff(f0, fs);
+            hpFilter.preload_filter(steadyValue);
+            hpFilter.process(steadyHP.begin(), steadyHP.end());
             auto calcError = [](double &n) { n = std::abs(n); };
             std::for_each(steadyHP.begin(), steadyHP.end(), calcError);
             double maxErrorHP = *std::max_element(steadyHP.begin(), steadyHP.end());
@@ -206,10 +206,10 @@ TEST_CASE("Filter test")
         {
             std::array<double, 1024> steadyBP;
             steadyBP.fill(steadyValue);
-            sdsp::casc2orderIIR<4> bpFilter;
-            bpFilter.SetBPCoeff(f0, fs, Q);
-            bpFilter.PreloadFilter(steadyValue);
-            bpFilter.Process(steadyBP.begin(), steadyBP.end());
+            sdsp::casc_2o_IIR<4> bpFilter;
+            bpFilter.set_bp_coeff(f0, fs, Q);
+            bpFilter.preload_filter(steadyValue);
+            bpFilter.process(steadyBP.begin(), steadyBP.end());
             auto calcError = [](double &n) { n = std::abs(n); };
             std::for_each(steadyBP.begin(), steadyBP.end(), calcError);
             double maxErrorBP = *std::max_element(steadyBP.begin(), steadyBP.end());
@@ -470,8 +470,8 @@ TEST_CASE("Filter benchmarks")
         constexpr double f0{ 10e3 };
         // constexpr double Q {1.1};
 
-        sdsp::casc2orderIIR<4> df;
-        df.SetLPCoeff(f0, fs);
+        sdsp::casc_2o_IIR<4> df;
+        df.set_lp_coeff(f0, fs);
 
         sdsp::casc_2o_IIR_lp<4> df2;
         df2.set_coeff(f0, fs);
@@ -482,7 +482,7 @@ TEST_CASE("Filter benchmarks")
         BENCHMARK("Runtime configurable LP filter benchmark")
         {
             std::array<double, 4096> data2 = data;
-            df.Process(data2.begin(), data2.end());
+            df.process(data2.begin(), data2.end());
             return data2;
         };
 
@@ -501,8 +501,8 @@ TEST_CASE("Filter benchmarks")
         constexpr double f0{ 10e3 };
         // constexpr double Q {1.1};
 
-        sdsp::casc2orderIIR<4> df;
-        df.SetHPCoeff(f0, fs);
+        sdsp::casc_2o_IIR<4> df;
+        df.set_hp_coeff(f0, fs);
 
         sdsp::casc_2o_IIR_hp<4> df2;
         df2.set_coeff(f0, fs);
@@ -513,7 +513,7 @@ TEST_CASE("Filter benchmarks")
         BENCHMARK("Runtime configurable HP filter benchmark")
         {
             std::array<double, 4096> data2 = data;
-            df.Process(data2.begin(), data2.end());
+            df.process(data2.begin(), data2.end());
             return data2;
         };
 
@@ -532,8 +532,8 @@ TEST_CASE("Filter benchmarks")
         constexpr double f0{ 10e3 };
         constexpr double Q{ 1.1 };
 
-        sdsp::casc2orderIIR<4> df;
-        df.SetBPCoeff(f0, fs, Q);
+        sdsp::casc_2o_IIR<4> df;
+        df.set_bp_coeff(f0, fs, Q);
 
         sdsp::casc_2o_IIR_bp<4> df2;
         df2.set_coeff(f0, fs, Q);
@@ -544,7 +544,7 @@ TEST_CASE("Filter benchmarks")
         BENCHMARK("Runtime configurable BP filter benchmark")
         {
             std::array<double, 4096> data2 = data;
-            df.Process(data2.begin(), data2.end());
+            df.process(data2.begin(), data2.end());
             return data2;
         };
 

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`	`namespace sdsp`
`7`	`7`	`{`
`8`	`8`	`template <size_t M>`
`9`		`-class casc2orderIIR {`
	`9`	`+class casc_2o_IIR {`
`10`	`10`	`private:`
`11`	`11`	`int pos{ 0 };`
`12`	`12`
`@@ -20,12 +20,12 @@ class casc2orderIIR {`
`20`	`20`	`FilterType fType{ FilterType::None };`
`21`	`21`
`22`	`22`	`public:`
`23`		`- casc2orderIIR()`
	`23`	`+ casc_2o_IIR()`
`24`	`24`	`{`
`25`	`25`	`static_assert(M % 2 == 0, "M must be even!");`
`26`	`26`	`}`
`27`	`27`
`28`		`- void copy_coeff_from(const casc2orderIIR<M> &otherFilter)`
	`28`	`+ void copy_coeff_from(const casc_2o_IIR<M> &otherFilter)`
`29`	`29`	`{`
`30`	`30`	`gain = otherFilter.gain;`
`31`	`31`	`bCoeff = otherFilter.bCoeff;`
`@@ -34,7 +34,7 @@ class casc2orderIIR {`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`template <typename Iter>`
`37`		`- void Process(Iter begin, Iter end)`
	`37`	`+ void process(Iter begin, Iter end)`
`38`	`38`	`{`
`39`	`39`	`constexpr int order{ 2 };`
`40`	`40`	`constexpr int j1{ 1 };`
`@@ -79,7 +79,7 @@ class casc2orderIIR {`
`79`	`79`	`mem = y;`
`80`	`80`	`}`
`81`	`81`
`82`		`- void SetBPCoeff(double f0, double fs, double Q, double gainIn = 1.0)`
	`82`	`+ void set_bp_coeff(double f0, double fs, double Q, double gainIn = 1.0)`
`83`	`83`	`{`
`84`	`84`	`gain = gainIn;`
`85`	`85`	`double q2{ 2 * Q };`
`@@ -137,7 +137,7 @@ class casc2orderIIR {`
`137`	`137`	`}`
`138`	`138`	`}`
`139`	`139`
`140`		`- void SetHPCoeff(double f0, double fs, double gainIn = 1.0)`
	`140`	`+ void set_hp_coeff(double f0, double fs, double gainIn = 1.0)`
`141`	`141`	`{`
`142`	`142`	`gain = gainIn;`
`143`	`143`	`fType = FilterType::HighPass;`
`@@ -165,7 +165,7 @@ class casc2orderIIR {`
`165`	`165`	`}`
`166`	`166`	`}`
`167`	`167`
`168`		`- void SetLPCoeff(double f0, double fs, double gainIn = 1.0)`
	`168`	`+ void set_lp_coeff(double f0, double fs, double gainIn = 1.0)`
`169`	`169`	`{`
`170`	`170`	`gain = gainIn;`
`171`	`171`	`fType = FilterType::LowPass;`
`@@ -194,7 +194,7 @@ class casc2orderIIR {`
`194`	`194`	`}`
`195`	`195`
`196`	`196`	`// preload the filter memory for steady state input equal to value parameter`
`197`		`- void PreloadFilter(double value)`
	`197`	`+ void preload_filter(double value)`
`198`	`198`	`{`
`199`	`199`	`double preload_value = value * gain;`
`200`	`200`	`std::array<std::array<double, 3>, M + 1> memVals{ 0 };`
`@@ -215,7 +215,7 @@ class casc2orderIIR {`
`215`	`215`	`};`
`216`	`216`
`217`	`217`	`template <size_t M>`
`218`		`-class casc_2o_IIR {`
	`218`	`+class casc_2o_IIR_base {`
`219`	`219`	`protected:`
`220`	`220`	`int pos{ 0 };`
`221`	`221`
`@@ -264,7 +264,7 @@ class casc_2o_IIR {`
`264`	`264`	`};`
`265`	`265`
`266`	`266`	`template <size_t M>`
`267`		`-class casc_2o_IIR_lp : casc_2o_IIR<M> {`
	`267`	`+class casc_2o_IIR_lp : casc_2o_IIR_base<M> {`
`268`	`268`	`public:`
`269`	`269`	`casc_2o_IIR_lp()`
`270`	`270`	`{`
`@@ -322,7 +322,7 @@ class casc_2o_IIR_lp : casc_2o_IIR<M> {`
`322`	`322`	`};`
`323`	`323`
`324`	`324`	`template <size_t M>`
`325`		`-class casc_2o_IIR_hp : casc_2o_IIR<M> {`
	`325`	`+class casc_2o_IIR_hp : casc_2o_IIR_base<M> {`
`326`	`326`	`public:`
`327`	`327`	`casc_2o_IIR_hp()`
`328`	`328`	`{`
`@@ -380,7 +380,7 @@ class casc_2o_IIR_hp : casc_2o_IIR<M> {`
`380`	`380`	`};`
`381`	`381`
`382`	`382`	`template <size_t M>`
`383`		`-class casc_2o_IIR_bp : casc_2o_IIR<M> {`
	`383`	`+class casc_2o_IIR_bp : casc_2o_IIR_base<M> {`
`384`	`384`	`public:`
`385`	`385`	`casc_2o_IIR_bp()`
`386`	`386`	`{`