rotgen/test/basic/functions.cpp

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

TTS_CASE("Function size")
{
  rotgen::matrix<double> empty_matrix;
  rotgen::matrix<double> matrix(3,4);
  rotgen::matrix<double> row_vector(9,1);
  rotgen::matrix<double> column_vector(1,5);

  TTS_EQUAL(empty_matrix.size(), 0ULL);
  TTS_EQUAL(matrix.size(), 12ULL);
  TTS_EQUAL(row_vector.size(), 9ULL);
  TTS_EQUAL(column_vector.size(), 5ULL);
};

TTS_CASE("Resizing dynamic matrix")
{
  rotgen::matrix<double> a(2, 3);

  for(std::size_t r=0;r<a.rows();++r)
    for(std::size_t c=0;c<a.cols();++c)
      a(r,c)   = 42 + 2*c + r;

  a.resize(3, 2);
  TTS_EQUAL(a.rows(), 3ULL);
  TTS_EQUAL(a.cols(), 2ULL);

  for(std::size_t r=0;r<a.rows();++r)
    for(std::size_t c=0;c<a.cols();++c)
      TTS_GREATER(a(r,c),0);

  a.resize(2,2);
  TTS_EQUAL(a.rows(), 2ULL);
  TTS_EQUAL(a.cols(), 2ULL);

  for(std::size_t r=0;r<a.rows();++r)
    for(std::size_t c=0;c<a.cols();++c)
      TTS_EQUAL(a(r,c),0);
};

TTS_CASE("Resizing static matrix")
{
  rotgen::matrix<double, 3, 3> a;
  TTS_EXPECT_NOT_COMPILES(a, { a.resize(4, 5); });
};

TTS_CASE("Dynamix matrix conservative resizing")
{
  rotgen::matrix<double> a(2, 3);

  int i = 1;
  for(std::size_t r=0;r<a.rows();++r)
    for(std::size_t c=0;c<a.cols();++c)
      a(r, c) = i++;

  a.conservativeResize(2, 3);
  TTS_EQUAL(a.rows(), 2ULL);
  TTS_EQUAL(a.cols(), 3ULL);

  i = 1;
  for(std::size_t r=0;r<a.rows();++r)
    for(std::size_t c=0;c<a.cols();++c)
      TTS_EQUAL(a(r,c),i++);

  a.conservativeResize(3, 2);
  TTS_EQUAL(a.rows(), 3ULL);
  TTS_EQUAL(a.cols(), 2ULL);
  int expected[3][2] = { {1, 2}, {4, 5}, {0, 0} };
  for(std::size_t r = 0; r < 3; ++r)
    for(std::size_t c = 0; c < 2; ++c)
      TTS_EQUAL(a(r, c), expected[r][c]);

  a.conservativeResize(4, 4);
  TTS_EQUAL(a.rows(), 4ULL);
  TTS_EQUAL(a.cols(), 4ULL);
  TTS_EQUAL(a(0,0), 1);
  TTS_EQUAL(a(3,3), 0);

  a.conservativeResize(2, 2);
  TTS_EQUAL(a.rows(), 2ULL);
  TTS_EQUAL(a.cols(), 2ULL);
  TTS_EQUAL(a(0,0), 1);
  TTS_EQUAL(a(1,1), 5);

  a.conservativeResize(1, 2);
  TTS_EQUAL(a.rows(), 1ULL);
  TTS_EQUAL(a.cols(), 2ULL);
  TTS_EQUAL(a(0,0), 1);
  TTS_EQUAL(a(0,1), 2);

  a.conservativeResize(0, 0);
  TTS_EQUAL(a.rows(), 0ULL);
  TTS_EQUAL(a.cols(), 0ULL);

  a.conservativeResize(3, 3);
  TTS_EQUAL(a.rows(), 3ULL);
  TTS_EQUAL(a.cols(), 3ULL);
  for(std::size_t r=0;r<a.rows();++r)
    for(std::size_t c=0;c<a.cols();++c)
      TTS_EQUAL(a(r,c),0);
};

TTS_CASE("Static matrix conservative resizing")
{
  rotgen::matrix<double, 3, 3> a;
  TTS_EXPECT_NOT_COMPILES(a, { a.conservativeResize(4, 5); });
};

TTS_CASE("Test coefficient accessors")
{
  rotgen::matrix<double> a(3, 5);

  for(std::size_t r=0;r<a.rows();++r)
    for(std::size_t c=0;c<a.cols();++c)
      a(r, c) = r + 2 * c + 3;

  TTS_EQUAL(a(0,0), 3);
  TTS_EQUAL(a(1,1), 6);
  TTS_EQUAL(a(1,0), 4);
  TTS_EQUAL(a(2,2), 9);
  TTS_EQUAL(a(2,4), 13);

  a(1, 1) = 42;
  TTS_EQUAL(a(1,1), 42);

  double& ref = a(2, 2);
  ref = 17;
  assert(a(2, 2) == 17);
};

TTS_CASE("Test one index coefficient accessors")
{
  rotgen::matrix<double> a(2, 4);

  int i = 1;
  for(std::size_t c=0;c<a.cols();++c)
    for(std::size_t r=0;r<a.rows();++r)
      a(r, c) = i++;

  i = 1;
  for(std::size_t r=0;r<a.rows()*a.cols();++r)
    TTS_EQUAL(a(r), i++);

  double& ref = a(2);
  ref = 999.1;
  assert(a(2) == 999.1);

  rotgen::matrix<double, 2, 3> b (2, 3);

  i = 1;
  for(std::size_t c=0;c<b.cols()*b.rows(); ++c)
    a(c) = i++;

  i = 1;
  for(std::size_t c=0;c<b.cols();++c)
    for(std::size_t r=0;r<b.rows();++r)
      TTS_EQUAL(a(r, c), i++);
};