Feat/non member functions

Co-authored-by: Karen <kkaspar@codereckons.com>
Co-authored-by: Joel FALCOU <jfalcou@codereckons.com>

See merge request oss/rotgen!7

test/unit/free_functions/arithmetic_functions.cpp

@@ -0,0 +1,122 @@
+//==================================================================================================
+/*
+  ROTGEN - Runtime Overlay for Eigen
+  Copyright : CODE RECKONS
+  SPDX-License-Identifier: BSL-1.0
+*/
+//==================================================================================================
+#define TTS_MAIN
+#include <rotgen/matrix.hpp>
+#include "tts.hpp"
+#include <Eigen/Dense>
+#include "rotgen/functions.hpp"
+
+template <typename MatrixType>
+struct MatrixDescriptor
+{
+  std::size_t rows, cols;
+  std::function<void(MatrixType &, std::size_t, std::size_t)> init_fn;
+};
+
+template <typename MatrixType>
+void test_matrix_unary_ops(std::size_t rows, std::size_t cols,
+                           const std::function<void(MatrixType &, std::size_t, std::size_t)> &init_fn)
+{
+
+  MatrixType original(rows, cols);
+  MatrixType transposed_matrix(cols, rows);
+
+  for (std::size_t r = 0; r < rows; ++r)
+    for (std::size_t c = 0; c < cols; ++c)
+      init_fn(original, r, c);
+
+  for (std::size_t r = 0; r < rows; ++r)
+    for (std::size_t c = 0; c < cols; ++c)
+      transposed_matrix(c, r) = original(r, c);
+
+  TTS_EQUAL(rotgen::transpose(original), transposed_matrix);
+  TTS_EQUAL(rotgen::conjugate(original), original);
+  TTS_EQUAL(rotgen::adjoint(original), transposed_matrix);
+
+  rotgen::transposeInPlace(original);
+  TTS_EQUAL(original, transposed_matrix);
+
+  rotgen::transposeInPlace(original);
+  rotgen::adjointInPlace(original);
+  TTS_EQUAL(original, transposed_matrix);
+}
+
+template <typename MatrixType>
+void test_matrix_scalar_reductions(std::size_t rows, std::size_t cols,
+                                   const std::function<void(MatrixType&, std::size_t, std::size_t)>& init_fn)
+{
+  using EigenMatrix = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>;
+
+  MatrixType original(rows, cols);
+  EigenMatrix ref(rows, cols);
+
+  for (std::size_t r = 0; r < rows; ++r)
+    for (std::size_t c = 0; c < cols; ++c)
+    {
+      init_fn(original, r, c);
+      ref(r, c) = original(r, c);
+    }
+
+  TTS_EQUAL(rotgen::sum(original), ref.sum());
+  TTS_EQUAL(rotgen::prod(original), ref.prod());
+  TTS_EQUAL(rotgen::mean(original), ref.mean());
+  TTS_EQUAL(rotgen::maxCoeff(original), ref.maxCoeff());
+  TTS_EQUAL(rotgen::minCoeff(original), ref.minCoeff());
+  TTS_EQUAL(rotgen::trace(original), ref.trace());
+
+  std::ptrdiff_t row, col, ref_row, ref_col;
+
+  double cmin = rotgen::minCoeff(original, &row, &col);
+  double rmin = ref.minCoeff(&ref_row, &ref_col);
+
+  TTS_EQUAL(cmin, rmin);
+  TTS_EQUAL(row, ref_row);
+  TTS_EQUAL(col, ref_col);
+
+  double cmax = rotgen::maxCoeff(original, &row, &col);
+  double rmax = ref.maxCoeff(&ref_row, &ref_col);
+
+  TTS_EQUAL(cmax, rmax);
+  TTS_EQUAL(row, ref_row);
+  TTS_EQUAL(col, ref_col);
+}
+
+TTS_CASE("Matrix unary operations: transpose, adjoint, conjugate")
+{
+  std::vector<MatrixDescriptor<rotgen::matrix<double>>> test_matrices = {
+      {3, 3, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = r + 3 * c - 2.5; }},
+      {4, 9, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = r*r + 3.12 * c + 6.87; }},
+      {2, 7, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = 1.1 * (r - c); }},
+      {1, 5, [](auto &m, std::size_t r, std::size_t c) { m(r, c) = 9.99; }},
+      {4, 2, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = 0.0; }},
+      {3, 3, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = (r == c) ? 1.0 : 0.0; }},
+      {2, 2, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = (r + c) * 1e-10; }},
+      {2, 2, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = (r + 1) * 1e+10; }},
+  };
+
+  for (auto const &desc : test_matrices)
+    test_matrix_unary_ops<rotgen::matrix<double>>(desc.rows, desc.cols, desc.init_fn);
+};
+
+TTS_CASE("Basic arithmetic reduction operations")
+{
+  std::vector<MatrixDescriptor<rotgen::matrix<double>>> test_matrices = {
+    {3, 3, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = r + c; }},
+    {3, 3, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = 0.0; }},
+    {2, 4, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = -r -c*c - 1234; }},
+    {4, 4, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = 7.0; }},
+    {1, 1, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = 42.0; }},
+    {4, 2, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = std::sin(r + c); }},
+    {1, 5, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = -1.5 * r + 2.56 * c; }},
+    {5, 7, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = (r == c ? 1.0 : 0.0); }},
+  };
+
+  for (const auto& [rows, cols, init_fn] : test_matrices)
+    test_matrix_scalar_reductions<rotgen::matrix<double>>(rows, cols, init_fn);
+};
+