rotgen/test/unit/matrix/constructors.cpp

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

#include "unit/tests.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(), rotgen::Index{0});
  TTS_EQUAL(matrix.cols(), rotgen::Index{0});
};

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(), rotgen::Index{4});
  TTS_EQUAL(matrix.cols(), rotgen::Index{9});
};

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(), rotgen::Index{10});
  TTS_EQUAL(matrix.cols(), rotgen::Index{5});
};

TTS_CASE_TPL("Static matrix constructor with row and columns", float, double)

<typename T>(tts::type<T>)
{
  rotgen::matrix<T, 1, 2> v2 = {6, 11};
  rotgen::matrix<T, 2, 1> w2 = {6, 11};

  TTS_EQUAL(v2(0), T{6});
  TTS_EQUAL(v2(1), T{11});

  TTS_EQUAL(w2(0), T{6});
  TTS_EQUAL(w2(1), T{11});

  rotgen::matrix<T, 1, 3> v3 = {6, 11, 125};
  rotgen::matrix<T, 3, 1> w3 = {6, 11, 125};

  TTS_EQUAL(v3(0), T{6});
  TTS_EQUAL(v3(1), T{11});
  TTS_EQUAL(v3(2), T{125});

  TTS_EQUAL(w3(0), T{6});
  TTS_EQUAL(w3(1), T{11});
  TTS_EQUAL(w3(2), T{125});
};

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 (rotgen::Index r = 0; r < a.rows(); r++)
    for (rotgen::Index 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 (rotgen::Index r = 0; r < a.rows(); r++)
    for (rotgen::Index 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(), rotgen::Index{0});
  TTS_EQUAL(b.cols(), rotgen::Index{0});
};

TTS_CASE_TPL("Copy constructor from const matrix", rotgen::tests::types)

<typename T, typename O>(tts::type<tts::types<T, O>>)
{
  rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> const a(2, 2);
  auto b = a;
  TTS_EQUAL(b.rows(), rotgen::Index{2});
  TTS_EQUAL(b.cols(), rotgen::Index{2});
};

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(), rotgen::Index{2});
  TTS_EQUAL(b.cols(), rotgen::Index{5});
};

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(), rotgen::Index{3});
  TTS_EQUAL(b.cols(), rotgen::Index{3});
  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(), rotgen::Index{2});
  TTS_EQUAL(b.cols(), rotgen::Index{2});
};

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(), rotgen::Index{1});
  TTS_EQUAL(b1.cols(), rotgen::Index{1});
  TTS_EQUAL(b1(0), 3.5);

  rotgen::matrix<T, 5, 1, rotgen::ColMajor> b9{0.25, 0.5, 1, 2, 4};
  TTS_EQUAL(b9.rows(), rotgen::Index{5});
  TTS_EQUAL(b9.cols(), rotgen::Index{1});

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

  rotgen::matrix<T, 1, 3, rotgen::RowMajor> b13{1.2, 2.3, 3.4};
  TTS_EQUAL(b13.rows(), rotgen::Index{1});
  TTS_EQUAL(b13.cols(), rotgen::Index{3});
  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(), rotgen::Index{1});
  TTS_EQUAL(b1.cols(), rotgen::Index{1});
  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(), rotgen::Index{2});
  TTS_EQUAL(b23.cols(), rotgen::Index{3});
  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));
};