rotgen/test/unit/matrix/arithmetic_functions.cpp

//==================================================================================================
/*
  ROTGEN - Runtime Overlay for Eigen
  Copyright : CODE RECKONS
  SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include "unit/tests.hpp"
#include <rotgen/matrix.hpp>
#include <Eigen/Dense>

template<typename MatrixType>
void test_matrix_unary_ops(std::size_t rows, std::size_t cols, auto const &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)
      original(r,c) = init_fn(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(original.transpose(), transposed_matrix);
  TTS_EQUAL(original.conjugate(), original);
  TTS_EQUAL(original.adjoint(), transposed_matrix);

  original.transposeInPlace();
  TTS_EQUAL(original, transposed_matrix);

  original.transposeInPlace();
  original.adjointInPlace();
  TTS_EQUAL(original, transposed_matrix);
}

TTS_CASE_TPL("Test transpotion related operations", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
  std::vector<rotgen::tests::matrix_descriptor> test_matrices =
  {
    {3, 3, [](auto r, auto c) { return r + 3 * c - 2.5; }},
    {4, 9, [](auto r, auto c) { return r*r + 3.12 * c + 6.87; }},
    {2, 7, [](auto r, auto c) { return 1.1 * (r - c); }},
    {1, 5, [](auto  , auto  ) { return 9.99; }},
    {4, 2, [](auto  , auto  ) { return 0.0; }},
    {3, 3, [](auto r, auto c) { return (r == c) ? 1.0 : 0.0; }},
    {2, 2, [](auto r, auto c) { return (r + c) * 1e-10; }},
    {2, 2, [](auto r, auto  ) { return (r + 1) * 1e+10; }}
  };

  for (const auto& [rows, cols, fn] : test_matrices)
  {
    test_matrix_unary_ops<rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value>>(rows, cols, fn);
  }
};

template <typename MatrixType>
void test_matrix_reductions(std::size_t rows, std::size_t cols, auto const& init_fn)
{
  using EigenMatrix = Eigen::Matrix<typename MatrixType::scalar_type, 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)
      ref(r, c) = original(r,c) = init_fn(r, c);

  TTS_EQUAL(original.sum(), ref.sum());
  TTS_EQUAL(original.prod(), ref.prod());
  TTS_EQUAL(original.mean(), ref.mean());
  TTS_EQUAL(original.maxCoeff(), ref.maxCoeff());
  TTS_EQUAL(original.minCoeff(), ref.minCoeff());
  TTS_EQUAL(original.trace(), ref.trace());

  std::ptrdiff_t row, col, ref_row, ref_col;

  double cmin = original.minCoeff(&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 = original.maxCoeff(&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_TPL("Test reductions", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
  std::vector<rotgen::tests::matrix_descriptor> test_matrices =
  {
    {3, 3, [](auto r, auto c) {return r + c; }},
    {3, 3, [](auto  , auto  ) {return 0.0; }},
    {2, 4, [](auto r, auto c) {return -r -c*c - 1234; }},
    {4, 4, [](auto  , auto  ) {return 7.0; }},
    {1, 1, [](auto  , auto  ) {return 42.0; }},
    {4, 2, [](auto r, auto c) {return std::sin(r + c); }},
    {1, 5, [](auto r, auto c) {return -1.5 * r + 2.56 * c; }},
    {5, 7, [](auto r, auto c) {return (r == c ? 1.0 : 0.0); }}
  };

  for (const auto& [rows, cols, fn] : test_matrices)
  {
    test_matrix_reductions<rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value>>(rows, cols, fn);
  }
};