filter tests

Author: ProExpertProg

cpp/test/CMakeLists.txt

@@ -18,9 +18,10 @@ function(add_viriato_test FILE)
     add_viriato_test_impl(${NAME} ${FILE} ${ARGN})
 endfunction()
 
+add_viriato_test(exporter.cpp)
+add_viriato_test(filter.cpp)
 add_viriato_test(grid.cpp)
 add_viriato_test(transformer.cpp)
-add_viriato_test(exporter.cpp)
 
 add_viriato_test(naive-energies.cpp)
 add_viriato_test(naive-moments.cpp)

cpp/test/filter.cpp

@@ -0,0 +1,36 @@
+#include "Filter.hpp"
+#include "grid.hpp"
+
+#include "util.hpp"
+
+#include <gtest/gtest.h>
+
+namespace ahr {
+
+template <typename TestedFilter> class TestFilter : public ::testing::Test {
+protected:
+  Grid grid{5, 9, 16};
+  HouLiFilter filter{grid};
+  TestedFilter filter_t{grid};
+};
+
+using Types = ::testing::Types<HouLiFilterCached, HouLiFilterCached1D>;
+TYPED_TEST_SUITE(TestFilter, Types);
+
+TYPED_TEST(TestFilter, Filter) {
+  auto buf = this->grid.cBufXY();
+  auto buf_t = this->grid.cBufXY();
+
+  // initialize buffers
+  this->grid.for_each_kxky([&](Dim kx, Dim ky) {
+    buf(kx, ky) = {std::sin(2 * pi * kx), std::cos(2 * pi * ky)};
+    buf_t(kx, ky) = {std::sin(2 * pi * kx), std::cos(2 * pi * ky)};
+  });
+
+  this->filter(buf);
+  this->filter_t(buf_t);
+
+  ASSERT_THAT(buf_t.to_mdspan(), MdspanElementsAllClose(buf.to_mdspan(), 1e-16, 1e-15));
+}
+
+} // namespace ahr

cpp/test/util.hpp

@@ -2,8 +2,8 @@
 
 #include <fftw-cpp/fftw-cpp.h>
 #include <gmock/gmock.h>
-#include <tuple>
 #include <iomanip>
+#include <tuple>
 
 // Function to slice the tuple
 template <std::size_t Start, std::size_t End, typename Tuple, std::size_t... Indices>
@@ -21,11 +21,19 @@ template <std::size_t Start, typename... Args> auto slice(const std::tuple<Args.
   return slice<Start, sizeof...(Args)>(t);
 }
 
+template <typename T> T absdiff_no_overflow(T a, T b) { return std::max(a, b) - std::min(a, b); }
+
+template <typename T> T absdiff_no_overflow(std::complex<T> a, std::complex<T> b) {
+  auto const real_diff = absdiff_no_overflow(a.real(), b.real());
+  auto const imag_diff = absdiff_no_overflow(a.imag(), b.imag());
+  return std::abs(std::complex<T>{real_diff, imag_diff});
+}
+
 using ::testing::PrintToString;
 MATCHER_P3(AllClose, val, rel_tol, abs_tol,
            PrintToString(val) + " ±" + PrintToString(abs_tol) + " (±" +
                PrintToString(double(rel_tol) * std::abs(val)) + ")") {
-  auto diff = std::max(arg, val) - std::min(arg, val);
+  auto diff = absdiff_no_overflow(val, arg);
   double tolerance_diff = double(diff) - double(abs_tol) - double(rel_tol) * std::abs(val);
   return tolerance_diff <= 0;
 }