codereckons/rotgen
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

First batch of rotgen implementation: constructors, basic infrastructure

Browse source
This commit is contained in:
Karen Kaspar 2025-05-16 16:01:17 +02:00 • committed by Joel Falcou
parent 2554a83890
commit afd504d679
9 changed files with 428 additions and 10 deletions
Download patch file Download diff file Expand all files Collapse all files

175
test/basic/constructors.cpp Normal file
View file

@ -0,0 +1,175 @@
//==================================================================================================
/*
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);
};