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

Merge branch 'feat/x-files' into 'main'

Browse source 
Use X-macros to generate all combinations of supported Eigen Matrix types

Co-authored-by: Joel Falcou <joel.falcou@lri.fr>

See merge request oss/rotgen!8
This commit is contained in:
Joel Falcou 2025-05-26 14:49:20 +02:00
parent a76020e274
commit 8647639c0d
24 changed files with 1176 additions and 1111 deletions
Download patch file Download diff file Expand all files Collapse all files

164
test/unit/basic/functions.cpp Normal file
View file

@ -0,0 +1,164 @@
//==================================================================================================
/*
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("Function size", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> empty_matrix;
rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> matrix(3,4);
rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> row_vector(9,1);
rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> 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_TPL("Resizing dynamic matrix", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> 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);
};
TTS_CASE_TPL("Resizing static matrix", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
rotgen::matrix<double, 3, 3> a;
TTS_EXPECT_NOT_COMPILES(a, { a.resize(4, 5); });
};
TTS_CASE_TPL("Dynamix matrix conservative resizing", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> 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} };
for(std::size_t r = 0; r < 2; ++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);
};
TTS_CASE_TPL("Static matrix conservative resizing", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
rotgen::matrix<double, 3, 3> a;
TTS_EXPECT_NOT_COMPILES(a, { a.conservativeResize(4, 5); });
};
TTS_CASE_TPL("Test coefficient accessors", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> 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);
T& ref = a(2, 2);
ref = 17;
assert(a(2, 2) == 17);
};
TTS_CASE_TPL("Test one index coefficient accessors", rotgen::tests::types)
<typename T, typename O>( tts::type< tts::types<T,O>> )
{
rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value> a(2, 4);
int i = 1;
if constexpr(!O::value)
{
for(std::size_t c=0;c<a.cols();++c)
for(std::size_t r=0;r<a.rows();++r)
a(r, c) = i++;
}
else
{
for(std::size_t r=0;r<a.rows();++r)
for(std::size_t c=0;c<a.cols();++c)
a(r, c) = i++;
}
i = 1;
for(std::size_t r=0;r<a.rows()*a.cols();++r)
TTS_EQUAL(a(r), i++) << a;
T& ref = a(2);
ref = 999.5;
TTS_EQUAL(a(2), 999.5);
};