Initial NBData, added FFT

engine/NBData/tests/CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.26.0)
+
+if (NB_BUILD_TESTS)
+    enable_testing()
+    include(GoogleTest)
+
+    add_executable(TestData
+        ./testFFT.cpp
+    )
+    target_link_libraries(TestData
+        NBData
+        GTest::gtest_main
+    )
+    gtest_discover_tests(TestData)
+
+    add_executable(FFTSpeedTest
+        ./fftspeedtest.cpp
+    )
+    target_link_libraries(FFTSpeedTest
+        NBData
+    )
+endif()

engine/NBData/tests/fftspeedtest.cpp

@@ -0,0 +1,5 @@
+#include <NBData/FFT.hpp>
+
+int main() {
+    return 0;
+}

engine/NBData/tests/testComplex.cpp

@@ -0,0 +1,27 @@
+#include <gtest/gtest.h>
+
+#include <NBData/ComplexNumbers.hpp>
+
+template<typename A, typename B>
+void COMPLEX_EQ(const nb::Complex<A>& a, const nb::Complex<B>& b) {
+    ASSERT_EQ(a.r, b.r);
+    ASSERT_EQ(a.i, b.i);
+}
+
+template<typename A, typename B>
+void COMPLEX_ALMOST_EQ(const nb::Complex<A>& a, const nb::Complex<B>& b) {
+    ASSERT_FLOAT_EQ(a.r, b.r);
+    ASSERT_FLOAT_EQ(a.i, b.i);
+}
+
+TEST(ComplexNumberTests, TestConstruction) {
+    COMPLEX_ALMOST_EQ(nb::Complex(), nb::Complex(0,0));
+    COMPLEX_ALMOST_EQ(nb::Complex(5.0), nb::Complex(5, 0));
+    COMPLEX_ALMOST_EQ(1.5_j, nb::Complex(0.0, 1.5));
+}
+
+TEST(ComplexNumberTests, TestAdd) {
+    auto x = nb::Complex(1.0) - nb::Complex(2.0, 1.0);
+    ASSERT_FLOAT_EQ(x.r, -1);
+    ASSERT_FLOAT_EQ(x.i, -1);
+}

engine/NBData/tests/testFFT.cpp

@@ -0,0 +1,68 @@
+#include <gtest/gtest.h>
+
+#include <NBData/FFT.hpp>
+
+using namespace nb;
+
+template<typename A, typename B>
+void COMPLEX_EQ(const std::complex<A>& a, const std::complex<B>& b) {
+    ASSERT_EQ(a.real(), b.real());
+    ASSERT_EQ(a.imag(), b.imag());
+}
+
+template<typename A, typename B>
+void COMPLEX_FLOAT_EQ(
+    const std::complex<A>& a,
+    const std::complex<B>& b,
+    const long double epsilon=0
+) {
+    if (epsilon) {
+        ASSERT_NEAR(a.real(), b.real(), epsilon);
+        ASSERT_NEAR(a.imag(), b.imag(), epsilon);
+    } else {
+        ASSERT_FLOAT_EQ(a.real(), b.real());
+        ASSERT_FLOAT_EQ(a.imag(), b.imag());
+    }
+}
+
+template<typename A, typename B>
+void COMPLEX_EQ_VEC(
+    const std::vector<std::complex<A>>& a,
+    const std::vector<std::complex<A>>& b
+) {
+    if (a.size() != b.size()) { FAIL(); }
+    for (int i = 0; i < a.size(); ++i) {
+        COMPLEX_EQ(a[i], b[i]);
+    }
+}
+
+template<typename A, typename B>
+void COMPLEX_FLOAT_EQ_VEC(
+    const std::vector<std::complex<A>>& a,
+    const std::vector<std::complex<B>>& b,
+    const long double epsilon
+) {
+    if (a.size() != b.size()) { FAIL(); }
+    for (int i = 0; i < a.size(); ++i) {
+        COMPLEX_FLOAT_EQ(a[i], b[i], epsilon);
+    }
+}
+
+TEST(FFTTest, TestFFT) {
+    std::vector<std::vector<std::complex<double>>> input = {
+        {1.0, 0.5, 0},
+        {1,1,1,1,1,1,1,1},
+
+    };
+    std::vector<std::vector<std::complex<double>>> expected = {
+        {1.5,1.f-0.5if,0.5,1.f+0.5if},
+        {8, 0, 0, 0, 0, 0, 0, 0}
+    };
+    for (int i = 0; i < input.size(); ++i) {
+        COMPLEX_FLOAT_EQ_VEC(
+            nb::fft2(input[i]),
+            expected[i],
+             1e-10
+        );
+    }
+}