rotgen/test/unit/matrix/constructors.cpp

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

TTS_CASE_TPL("Default matrix dynamic constructor", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
  rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> matrix;

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

TTS_CASE_TPL("Default matrix static constructor", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
  rotgen::matrix<T,4,9,O::value> matrix;

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

TTS_CASE_TPL("Dynamic matrix constructor with row and columns", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
  rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> matrix(10, 5);

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

TTS_CASE_TPL("Static matrix constructor with row and columns", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
  rotgen::matrix<T,6,11,O::value> matrix(6, 11);

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

TTS_CASE_TPL("Copy constructor produces identical but independent matrix", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
  rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> 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<T,rotgen::Dynamic,rotgen::Dynamic,O::value> 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_TPL("Copy constructor on default matrix", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
  rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> a;
  rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> b = a;
  TTS_EQUAL(b.rows(), 0ULL);
  TTS_EQUAL(b.cols(), 0ULL);
};

TTS_CASE_TPL("Copy constructor from const matrix", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
  const rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> a(2, 2);
  auto b = a;
  TTS_EQUAL(b.rows(), 2ULL);
  TTS_EQUAL(b.cols(), 2ULL);
};

TTS_CASE_TPL("Copy constructor on static matrix", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
   rotgen::matrix<T, 2, 5> a;
   rotgen::matrix<T, 2, 5> b = a;
  TTS_EQUAL(b.rows(), 2ULL);
  TTS_EQUAL(b.cols(), 5ULL);
};

/*
TTS_CASE_TPL("Copy constructor on static/dynamic matrix", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
  rotgen::matrix<T, 11, 4,O::value> a;
  rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> b = a;
  TTS_EQUAL(b.rows(), 11);
  TTS_EQUAL(b.cols(), 4);
};

TTS_CASE_TPL("Copy constructor on dynamic/static matrix", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
  rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> a(5, 7);
  rotgen::matrix<T, 5, 7,O::value> b = a;
  TTS_EQUAL(b.rows(), 5);
  TTS_EQUAL(b.cols(), 7);
};*/

TTS_CASE_TPL("Move constructor transfers contents", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
  rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> a(3, 3);
  a(1,1) = 7;
  auto ptr = a.data();

 rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> 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_CASE_TPL("Move constructor from Rvalue", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
  rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> b = rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value>(2, 2);
  TTS_EQUAL(b.rows(), 2ULL);
  TTS_EQUAL(b.cols(), 2ULL);
};

TTS_CASE_TPL("Constructor from Initializer list", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
  rotgen::matrix<T,1,1,O::value> b1 = {3.5};
  TTS_EQUAL(b1.rows(), 1ULL);
  TTS_EQUAL(b1.cols(), 1ULL);
  TTS_EQUAL(b1(0)    , 3.5);

  rotgen::matrix<T,5,1,O::value> b9 = {0.25, 0.5, 1, 2, 4};
  TTS_EQUAL(b9.rows(), 5ULL);
  TTS_EQUAL(b9.cols(), 1ULL);

  T i = 0.25;
  for(std::size_t r=0;r<b9.rows();++r) {
    TTS_EQUAL(b9(r,0), i);
    i *= 2;
  }

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

TTS_CASE_TPL("Constructor from Initializer list of rows", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
  rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> b1 = {{3.5}};
  TTS_EQUAL(b1.rows(), 1ULL);
  TTS_EQUAL(b1.cols(), 1ULL);
  TTS_EQUAL(b1(0,0)  , T(3.5));

  rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> 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)    , T(1.2));
  TTS_EQUAL(b23(0,1)    , T(2.3));
  TTS_EQUAL(b23(0,2)    , T(3.4));
  TTS_EQUAL(b23(1,0)    , T(10));
  TTS_EQUAL(b23(1,1)    , T(200));
  TTS_EQUAL(b23(1,2)    , T(3000));
};