rotgen/test/basic/constructors.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("Default matrix dynamic constructor")
{
  rotgen::matrix<double> matrix;

  TTS_EQUAL(matrix.rows(), 0ULL);
  TTS_EQUAL(matrix.cols(), 0ULL);
};

TTS_CASE("Default matrix static constructor")
{
  rotgen::matrix<double, 4, 9> matrix;

  TTS_EQUAL(matrix.rows(), 4ULL);
  TTS_EQUAL(matrix.cols(), 9ULL);
};

TTS_CASE("Dynamic matrix constructor with row and columns")
{
  rotgen::matrix<float> matrix(10, 5);

  TTS_EQUAL(matrix.rows(), 10ULL);
  TTS_EQUAL(matrix.cols(), 5ULL);
};

TTS_CASE("Static matrix constructor with row and columns")
{
  rotgen::matrix<double, 6, 11> matrix(6, 11);

  TTS_EQUAL(matrix.rows(), 6ULL);
  TTS_EQUAL(matrix.cols(), 11ULL);
};

TTS_CASE("Copy constructor produces identical but independent matrix")
{
  rotgen::matrix<double> a(3, 3);

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

  rotgen::matrix<double> b = a;

  TTS_EQUAL(b.rows(), a.rows());
  TTS_EQUAL(b.cols(), a.cols());

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

  TTS_EQUAL(b(0, 0), 0.0);
  TTS_EQUAL(b(1, 0), 1.0);
  TTS_EQUAL(b(2, 1), 3.0);

  a(0,0) = 42.0;
  TTS_NOT_EQUAL(b(0,0), a(0,0));
};

TTS_CASE("Copy constructor on default matrix")
{
  rotgen::matrix<double> a;
  rotgen::matrix<double> b = a;
  TTS_EQUAL(b.rows(), 0ULL);
  TTS_EQUAL(b.cols(), 0ULL);
};

TTS_CASE("Copy constructor from const matrix")
{
  const rotgen::matrix<double> a(2, 2);
  auto b = a;
  TTS_EQUAL(b.rows(), 2ULL);
  TTS_EQUAL(b.cols(), 2ULL);
};

TTS_CASE("Copy constructor on static matrix")
{
  rotgen::matrix<double, 2, 5> a;
  rotgen::matrix<double, 2, 5> b = a;
  TTS_EQUAL(b.rows(), 2ULL);
  TTS_EQUAL(b.cols(), 5ULL);
};

/*
TTS_CASE("Copy constructor on static/dynamic matrix")
{
  rotgen::matrix<double, 11, 4> a;
  rotgen::matrix<double> b = a;
  TTS_EQUAL(b.rows(), 11);
  TTS_EQUAL(b.cols(), 4);
};

TTS_CASE("Copy constructor on dynamic/static matrix")
{
  rotgen::matrix<double> a(5, 7);
  rotgen::matrix<double, 5, 7> b = a;
  TTS_EQUAL(b.rows(), 5);
  TTS_EQUAL(b.cols(), 7);
};*/

TTS_CASE("Move constructor transfers contents")
{
  rotgen::matrix<double> a(3, 3);
  a(1,1) = 7;
  auto ptr = a.data();

 rotgen::matrix<double> b = std::move(a);

  TTS_EQUAL(b(1,1), 7);
  TTS_EQUAL(b.rows(), 3ULL);
  TTS_EQUAL(b.cols(), 3ULL);
  TTS_EXPECT(b.data() == ptr);
//  TTS_EXPECT(a.data() == nullptr);
};

TTS_CASE("Move constructor from Rvalue")
{
  rotgen::matrix<double> b = rotgen::matrix<double>(2, 2);
  TTS_EQUAL(b.rows(), 2ULL);
  TTS_EQUAL(b.cols(), 2ULL);
};

TTS_CASE("Constructor from Initializer list")
{
  rotgen::matrix<double,1,1> b1 = {3.5};
  TTS_EQUAL(b1.rows(), 1ULL);
  TTS_EQUAL(b1.cols(), 1ULL);
  TTS_EQUAL(b1(0)    , 3.5);

  rotgen::matrix<double,5,1> b9 = {0.01, 0.1, 1, 10, 100};
  TTS_EQUAL(b9.rows(), 5ULL);
  TTS_EQUAL(b9.cols(), 1ULL);

  int i = 0.01;
  for(std::size_t r=0;r<b9.rows();++r) {
    TTS_EQUAL(b9(r,1), i);
    i *= 10;
  }

  rotgen::matrix<double,1,3> b13 = {1.2,2.3,3.4};
  TTS_EQUAL(b13.rows(), 1ULL);
  TTS_EQUAL(b13.cols(), 3ULL);
  TTS_EQUAL(b13(0)    , 1.2);
  TTS_EQUAL(b13(1)    , 2.3);
  TTS_EQUAL(b13(2)    , 3.4);
};

TTS_CASE("Constructor from Initializer list of rows")
{
  rotgen::matrix<double> b1 = {{3.5}};
  TTS_EQUAL(b1.rows(), 1ULL);
  TTS_EQUAL(b1.cols(), 1ULL);
  TTS_EQUAL(b1(0,0)  , 3.5);

  rotgen::matrix<double> b23  = { {1.2,2.3,3.4}
    , {10,200,3000}
  };
  TTS_EQUAL(b23.rows(), 2ULL);
  TTS_EQUAL(b23.cols(), 3ULL);
  TTS_EQUAL(b23(0,0)    , 1.2);
  TTS_EQUAL(b23(0,1)    , 2.3);
  TTS_EQUAL(b23(0,2)    , 3.4);
  TTS_EQUAL(b23(1,0)    , 10);
  TTS_EQUAL(b23(1,1)    , 200);
  TTS_EQUAL(b23(1,2)    , 3000);
};