From a6105fa9ffefe4374c9dc0b0322b168f0454c94b Mon Sep 17 00:00:00 2001 From: Vincent Samy Date: Fri, 26 Oct 2018 10:31:14 +0900 Subject: [PATCH] Some renaming. --- include/Butterworth.inl | 6 ++--- include/GenericFilter.inl | 2 +- include/MovingAverage.h | 4 +-- include/polynome_functions.h | 4 +-- tests/ButterworthFilterTests.cpp | 40 ++++++++++++++++++++++-------- tests/DigitalFilterTests.cpp | 24 +++++++++--------- tests/GenericFilterTests.cpp | 8 +++--- tests/MovingAverageFilterTests.cpp | 16 ++++++------ 8 files changed, 62 insertions(+), 42 deletions(-) diff --git a/include/Butterworth.inl b/include/Butterworth.inl index 4f12f92..9697b2c 100644 --- a/include/Butterworth.inl +++ b/include/Butterworth.inl @@ -48,17 +48,17 @@ void Butterworth::computeDigitalRep() T pi = static_cast(M_PI); // Continuous pre-warped frequency T fpw = (m_fs / pi) * std::tan(pi * m_fc / m_fs); - T scaleFactor = T(2) * pi * fpw; + T scaleFactor = 2 * pi * fpw; auto thetaK = [pi, order = m_order](size_t k) -> T { - return (T(2) * k - T(1)) * pi / (T(2) * order); + return (2 * k - 1) * pi / (2 * order); }; // Compute poles std::complex scalePole; for (size_t k = 1; k <= m_order; ++k) { scalePole = scaleFactor * std::complex(-std::sin(thetaK(k)), std::cos(thetaK(k))); - scalePole /= T(2) * m_fs; + scalePole /= 2 * m_fs; m_poles[k - 1] = (T(1) + scalePole) / (T(1) - scalePole); } diff --git a/include/GenericFilter.inl b/include/GenericFilter.inl index bda771c..b3f9490 100644 --- a/include/GenericFilter.inl +++ b/include/GenericFilter.inl @@ -70,7 +70,7 @@ void GenericFilter::normalize() if (std::abs(a0) < 1e-8) // Divide by zero throw std::invalid_argument("By filtering value for coefficient a0. Should be superior to 1e-8"); - if (std::abs(a0 - T(1)) < 1e-8) + if (std::abs(a0 - 1) < 1e-8) return; for (T& a : m_aCoeff) diff --git a/include/MovingAverage.h b/include/MovingAverage.h index 0183a9d..fb90a07 100644 --- a/include/MovingAverage.h +++ b/include/MovingAverage.h @@ -9,11 +9,11 @@ class MovingAverage : public GenericFilter { public: MovingAverage() = default; MovingAverage(size_t windowSize) - : GenericFilter({ T(1) }, std::vector(windowSize, T(1) / windowSize)) + : GenericFilter({ 1 }, std::vector(windowSize, T(1) / windowSize)) { } - void setWindowSize(size_t windowSize) { setCoeff({ T(1) }, std::vector(windowSize, T(1) / windowSize)); } + void setWindowSize(size_t windowSize) { setCoeff({ 1 }, std::vector(windowSize, 1 / windowSize)); } size_t windowSize() const noexcept { return m_bCoeff.size(); } }; diff --git a/include/polynome_functions.h b/include/polynome_functions.h index d97f4a2..72c4e3a 100644 --- a/include/polynome_functions.h +++ b/include/polynome_functions.h @@ -18,8 +18,8 @@ struct VietaAlgo { template std::vector VietaAlgo::polyCoeffFromRoot(const std::vector& poles) { - std::vector coeff(poles.size() + 1, T(0)); - coeff[0] = T(1); + std::vector coeff(poles.size() + 1, 0); + coeff[0] = 1; for (size_t i = 0; i < poles.size(); ++i) { for (size_t k = i + 1; k > 0; --k) { coeff[k] = coeff[k] - poles[i] * coeff[k - 1]; diff --git a/tests/ButterworthFilterTests.cpp b/tests/ButterworthFilterTests.cpp index 262b99a..0f455b9 100644 --- a/tests/ButterworthFilterTests.cpp +++ b/tests/ButterworthFilterTests.cpp @@ -21,10 +21,10 @@ DISABLE_CONVERSION_WARNING_END BOOST_FIXTURE_TEST_CASE(BUTTERWORTH_FILTER_FLOAT, System) { - auto gf = fratio::Butterworthf(order, fc, fs); + auto bf = fratio::Butterworthf(order, fc, fs); std::vector aCoeff, bCoeff, filteredData; - gf.getCoeff(aCoeff, bCoeff); + bf.getCoeff(aCoeff, bCoeff); BOOST_REQUIRE_EQUAL(aCoeff.size(), aCoeffRes.size()); BOOST_REQUIRE_EQUAL(bCoeff.size(), bCoeffRes.size()); @@ -36,23 +36,33 @@ BOOST_FIXTURE_TEST_CASE(BUTTERWORTH_FILTER_FLOAT, System) } for (float d : data) - filteredData.push_back(gf.stepFilter(d)); + filteredData.push_back(bf.stepFilter(d)); for (size_t i = 0; i < filteredData.size(); ++i) BOOST_CHECK_SMALL(std::abs(filteredData[i] - results[i]), 1e-4f); - gf.resetFilter(); - filteredData = gf.filter(data); + bf.resetFilter(); + filteredData = bf.filter(data); + for (size_t i = 0; i < filteredData.size(); ++i) + BOOST_CHECK_SMALL(std::abs(filteredData[i] - results[i]), 1e-4f); + + auto bf2 = fratio::Butterworthf(); + + bf2.setFilterParameters(order, fc, fs); + filteredData.resize(0); + for (float d : data) + filteredData.push_back(bf2.stepFilter(d)); + for (size_t i = 0; i < filteredData.size(); ++i) BOOST_CHECK_SMALL(std::abs(filteredData[i] - results[i]), 1e-4f); } BOOST_FIXTURE_TEST_CASE(BUTTERWORTH_FILTER_DOUBLE, System) { - auto gf = fratio::Butterworthd(order, fc, fs); + auto bf = fratio::Butterworthd(order, fc, fs); std::vector aCoeff, bCoeff, filteredData; - gf.getCoeff(aCoeff, bCoeff); + bf.getCoeff(aCoeff, bCoeff); BOOST_REQUIRE_EQUAL(aCoeff.size(), aCoeffRes.size()); BOOST_REQUIRE_EQUAL(bCoeff.size(), bCoeffRes.size()); @@ -64,13 +74,23 @@ BOOST_FIXTURE_TEST_CASE(BUTTERWORTH_FILTER_DOUBLE, System) } for (double d : data) - filteredData.push_back(gf.stepFilter(d)); + filteredData.push_back(bf.stepFilter(d)); for (size_t i = 0; i < filteredData.size(); ++i) BOOST_CHECK_SMALL(std::abs(filteredData[i] - results[i]), 1e-14); - gf.resetFilter(); - filteredData = gf.filter(data); + bf.resetFilter(); + filteredData = bf.filter(data); + for (size_t i = 0; i < filteredData.size(); ++i) + BOOST_CHECK_SMALL(std::abs(filteredData[i] - results[i]), 1e-14); + + auto bf2 = fratio::Butterworthd(); + + bf2.setFilterParameters(order, fc, fs); + filteredData.resize(0); + for (float d : data) + filteredData.push_back(bf2.stepFilter(d)); + for (size_t i = 0; i < filteredData.size(); ++i) BOOST_CHECK_SMALL(std::abs(filteredData[i] - results[i]), 1e-14); } diff --git a/tests/DigitalFilterTests.cpp b/tests/DigitalFilterTests.cpp index 0d2b283..a1e6f78 100644 --- a/tests/DigitalFilterTests.cpp +++ b/tests/DigitalFilterTests.cpp @@ -18,40 +18,40 @@ DISABLE_CONVERSION_WARNING_END BOOST_FIXTURE_TEST_CASE(DIGITAL_FILTER_FLOAT, System) { - auto gf = fratio::DigitalFilterf(aCoeff, bCoeff); - BOOST_REQUIRE_EQUAL(aCoeff.size(), gf.aOrder()); - BOOST_REQUIRE_EQUAL(bCoeff.size(), gf.bOrder()); + auto df = fratio::DigitalFilterf(aCoeff, bCoeff); + BOOST_REQUIRE_EQUAL(aCoeff.size(), df.aOrder()); + BOOST_REQUIRE_EQUAL(bCoeff.size(), df.bOrder()); std::vector filteredData; for (float d : data) - filteredData.push_back(gf.stepFilter(d)); + filteredData.push_back(df.stepFilter(d)); for (size_t i = 0; i < filteredData.size(); ++i) BOOST_CHECK_SMALL(std::abs(filteredData[i] - results[i]), 1e-6f); - gf.resetFilter(); - filteredData = gf.filter(data); + df.resetFilter(); + filteredData = df.filter(data); for (size_t i = 0; i < filteredData.size(); ++i) BOOST_CHECK_SMALL(std::abs(filteredData[i] - results[i]), 1e-6f); } BOOST_FIXTURE_TEST_CASE(DIGITAL_FILTER_DOUBLE, System) { - auto gf = fratio::DigitalFilterd(aCoeff, bCoeff); - BOOST_REQUIRE_EQUAL(aCoeff.size(), gf.aOrder()); - BOOST_REQUIRE_EQUAL(bCoeff.size(), gf.bOrder()); + auto df = fratio::DigitalFilterd(aCoeff, bCoeff); + BOOST_REQUIRE_EQUAL(aCoeff.size(), df.aOrder()); + BOOST_REQUIRE_EQUAL(bCoeff.size(), df.bOrder()); std::vector filteredData; for (double d : data) - filteredData.push_back(gf.stepFilter(d)); + filteredData.push_back(df.stepFilter(d)); for (size_t i = 0; i < filteredData.size(); ++i) BOOST_CHECK_SMALL(std::abs(filteredData[i] - results[i]), 1e-14); - gf.resetFilter(); - filteredData = gf.filter(data); + df.resetFilter(); + filteredData = df.filter(data); for (size_t i = 0; i < filteredData.size(); ++i) BOOST_CHECK_SMALL(std::abs(filteredData[i] - results[i]), 1e-14); } diff --git a/tests/GenericFilterTests.cpp b/tests/GenericFilterTests.cpp index c527c2a..1ba3906 100644 --- a/tests/GenericFilterTests.cpp +++ b/tests/GenericFilterTests.cpp @@ -9,8 +9,8 @@ BOOST_AUTO_TEST_CASE(FilterThrows) BOOST_REQUIRE_THROW(fratio::DigitalFilterd({ 1., 2. }, {}), std::runtime_error); BOOST_REQUIRE_THROW(fratio::DigitalFilterd({ 0. }, { 1. }), std::invalid_argument); - auto gf = fratio::DigitalFilterd(); - BOOST_REQUIRE_THROW(gf.setCoeff({}, { 1., 2. }), std::runtime_error); - BOOST_REQUIRE_THROW(gf.setCoeff({ 1., 2. }, {}), std::runtime_error); - BOOST_REQUIRE_THROW(gf.setCoeff({ 0. }, { 1. }), std::invalid_argument); + auto df = fratio::DigitalFilterd(); + BOOST_REQUIRE_THROW(df.setCoeff({}, { 1., 2. }), std::runtime_error); + BOOST_REQUIRE_THROW(df.setCoeff({ 1., 2. }, {}), std::runtime_error); + BOOST_REQUIRE_THROW(df.setCoeff({ 0. }, { 1. }), std::invalid_argument); } diff --git a/tests/MovingAverageFilterTests.cpp b/tests/MovingAverageFilterTests.cpp index 81b887d..fea7437 100644 --- a/tests/MovingAverageFilterTests.cpp +++ b/tests/MovingAverageFilterTests.cpp @@ -12,32 +12,32 @@ struct System { BOOST_FIXTURE_TEST_CASE(MOVING_AVERAGE_FLOAT, System) { - auto ma = fratio::MovingAveragef(windowSize); + auto maf = fratio::MovingAveragef(windowSize); std::vector filteredData; for (float d : data) - filteredData.push_back(ma.stepFilter(d)); + filteredData.push_back(maf.stepFilter(d)); for (size_t i = 0; i < filteredData.size(); ++i) BOOST_CHECK_SMALL(std::abs(filteredData[i] - results[i]), 1e-6f); - ma.resetFilter(); - filteredData = ma.filter(data); + maf.resetFilter(); + filteredData = maf.filter(data); for (size_t i = 0; i < filteredData.size(); ++i) BOOST_CHECK_SMALL(std::abs(filteredData[i] - results[i]), 1e-6f); } BOOST_FIXTURE_TEST_CASE(MOVING_AVERAGE_DOUBLE, System) { - auto ma = fratio::MovingAveraged(windowSize); + auto maf = fratio::MovingAveraged(windowSize); std::vector filteredData; for (double d : data) - filteredData.push_back(ma.stepFilter(d)); + filteredData.push_back(maf.stepFilter(d)); for (size_t i = 0; i < filteredData.size(); ++i) BOOST_CHECK_SMALL(std::abs(filteredData[i] - results[i]), 1e-14); - ma.resetFilter(); - filteredData = ma.filter(data); + maf.resetFilter(); + filteredData = maf.filter(data); for (size_t i = 0; i < filteredData.size(); ++i) BOOST_CHECK_SMALL(std::abs(filteredData[i] - results[i]), 1e-14); }