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

Resolve "[API-#2] Pseudo-privatization of rotgen entity member functions"

Browse source 
Closes #18

Co-authored-by: Jules Pénuchot <jules@penuchot.com>

See merge request oss/rotgen!50
This commit is contained in:
Jules Pénuchot 2025-12-17 20:48:00 +01:00 • committed by Joel Falcou
parent 6489697c05
commit e151e136d6
52 changed files with 2212 additions and 1556 deletions
Download patch file Download diff file Expand all files Collapse all files

20
test/integration/extract.cpp
View file

@ -14,34 +14,34 @@ TTS_CASE_TPL("Chains of extraction", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
constexpr int N = 8;
auto a = rotgen::matrix<T, N, N, O::value>::Random();
auto a = rotgen::setRandom<rotgen::matrix<T, N, N, O::value>>();
auto b = topLeftCorner(a, 5, 5);
TTS_EQUAL(b.startRow(), 0);
TTS_EQUAL(b.startCol(), 0);
TTS_EQUAL(startRow(b), 0);
TTS_EQUAL(startCol(b), 0);
setConstant(b, -7);
for (rotgen::Index r = 0; r < 5; r++)
for (rotgen::Index c = 0; c < 5; c++) TTS_EQUAL(a(r, c), -7);
auto bb = bottomRightCorner(b, 3, 3);
TTS_EQUAL(bb.startRow(), 2);
TTS_EQUAL(bb.startCol(), 2);
TTS_EQUAL(startRow(bb), 2);
TTS_EQUAL(startCol(bb), 2);
setConstant(bb, 42);
for (rotgen::Index r = 2; r < 5; r++)
for (rotgen::Index c = 2; c < 5; c++) TTS_EQUAL(a(r, c), 42);
auto bbb = row(bb, 1);
TTS_EQUAL(bbb.startRow(), 1);
TTS_EQUAL(bbb.startCol(), 0);
TTS_EQUAL(startRow(bbb), 1);
TTS_EQUAL(startCol(bbb), 0);
setConstant(bbb, 99.5);
for (rotgen::Index c = 3; c < 5; c++) TTS_EQUAL(a(3, c), 99.5);
auto bbbb = col(bbb, 1);
TTS_EQUAL(bbbb.startRow(), 0);
TTS_EQUAL(bbbb.startCol(), 1);
TTS_EQUAL(startRow(bbbb), 0);
TTS_EQUAL(startCol(bbbb), 1);
setConstant(bbbb, 0.125);
TTS_EQUAL(a(3, 3), 0.125);
@ -94,7 +94,7 @@ TTS_CASE("Compound operators on extractions")
setConstant(n, 10);
setConstant(reference, 10);
for (int i = 0; i < m.cols(); i++) process_col(m, n, i);
for (int i = 0; i < cols(m); i++) process_col(m, n, i);
TTS_EQUAL(m, reference);
};

26
test/integration/outer_stride.cpp
View file

@ -10,29 +10,29 @@
#include "unit/tests.hpp"
#include <iostream>
TTS_CASE_TPL("outer_stride<0> interactions",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("outer_stride<0> interactions", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
using mat_t = rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>;
T contiguous[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
rotgen::map<mat_t, 0, rotgen::outer_stride<0>> m(&contiguous[0], 4, 3);
TTS_EQUAL(m.innerStride(), 1);
TTS_EQUAL(m.outerStride(), O::value == rotgen::ColMajor ? 4 : 3);
TTS_EQUAL(innerStride(m), 1);
TTS_EQUAL(outerStride(m), O::value == rotgen::ColMajor ? 4 : 3);
if constexpr (O::value == rotgen::ColMajor)
{
T padded[] = {1, 2, 3, 4, 99, 5, 6, 7, 8, 99, 9, 10, 11, 12};
rotgen::map<mat_t, 0, rotgen::outer_stride<5>> sp(&padded[0], 4, 3);
TTS_EQUAL(sp.innerStride(), 1);
TTS_EQUAL(sp.outerStride(), 5);
TTS_EQUAL(innerStride(sp), 1);
TTS_EQUAL(outerStride(sp), 5);
rotgen::map<mat_t, 0, rotgen::outer_stride<>> dp(&padded[0], 4, 3,
rotgen::outer_stride(5));
TTS_EQUAL(dp.innerStride(), 1);
TTS_EQUAL(dp.outerStride(), 5);
TTS_EQUAL(innerStride(dp), 1);
TTS_EQUAL(outerStride(dp), 5);
TTS_EQUAL(m, sp);
TTS_EQUAL(m, dp);
@ -42,13 +42,13 @@ TTS_CASE_TPL("outer_stride<0> interactions",
{
T padded[] = {1, 2, 3, 99, 4, 5, 6, 99, 7, 8, 9, 99, 10, 11, 12};
rotgen::map<mat_t, 0, rotgen::outer_stride<4>> sp(&padded[0], 4, 3);
TTS_EQUAL(sp.innerStride(), 1);
TTS_EQUAL(sp.outerStride(), 4);
TTS_EQUAL(innerStride(sp), 1);
TTS_EQUAL(outerStride(sp), 4);
rotgen::map<mat_t, 0, rotgen::outer_stride<>> dp(&padded[0], 4, 3,
rotgen::outer_stride(4));
TTS_EQUAL(dp.innerStride(), 1);
TTS_EQUAL(dp.outerStride(), 4);
TTS_EQUAL(innerStride(dp), 1);
TTS_EQUAL(outerStride(dp), 4);
TTS_EQUAL(m, sp);
TTS_EQUAL(m, dp);

6
test/integration/ref_magic.cpp
View file

@ -48,9 +48,9 @@ auto process(column_ref<> v)
TTS_CASE("Reference of reference check")
{
auto v1 = rotgen::matrix<float, 1, 1>::Ones();
auto v2 = rotgen::matrix<float, 2, 1>::Random();
auto v3 = rotgen::matrix<float, 3, 1>::Constant(6.66);
auto v1 = rotgen::setOnes<rotgen::matrix<float, 1, 1>>();
auto v2 = rotgen::setRandom<rotgen::matrix<float, 2, 1>>();
auto v3 = rotgen::setConstant<rotgen::matrix<float, 3, 1>>(6.66);
auto sum1 = v1(0);
auto sum2 = v2(0) + v2(1);

37
test/unit/block/basic_api.cpp
View file

@ -18,8 +18,9 @@ void fill(auto& m, int r, int c, auto data[])
for (int k = 0; k < r * c; ++k) m.data()[k] = data[k];
}
TTS_CASE_TPL("Function size", rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Function size", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
T data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
@ -28,44 +29,44 @@ TTS_CASE_TPL("Function size", rotgen::tests::types)<typename T, typename O>(
fill(dm, 1, 12, data);
auto b1 = rotgen::block<decltype(dm), rotgen::Dynamic, rotgen::Dynamic>(
dm, 0, 0, 1, 12);
TTS_EQUAL(b1.rows(), rotgen::Index{1});
TTS_EQUAL(b1.cols(), rotgen::Index{12});
TTS_EQUAL(rows(b1), rotgen::Index{1});
TTS_EQUAL(cols(b1), rotgen::Index{12});
// 1x5 dynamic block at (0,2)
auto b2 = rotgen::block<decltype(dm), rotgen::Dynamic, rotgen::Dynamic>(
dm, 0, 2, 1, 5);
TTS_EQUAL(b2.rows(), rotgen::Index{1});
TTS_EQUAL(b2.cols(), rotgen::Index{5});
TTS_EQUAL(rows(b2), rotgen::Index{1});
TTS_EQUAL(cols(b2), rotgen::Index{5});
// 3x2 dynamic block at (1,4) in 4x6
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> dm2(4, 6);
fill(dm2, 4, 6, data);
auto b3 = rotgen::block<decltype(dm2), rotgen::Dynamic, rotgen::Dynamic>(
dm2, 1, 4, 3, 2);
TTS_EQUAL(b3.rows(), rotgen::Index{3});
TTS_EQUAL(b3.cols(), rotgen::Index{2});
TTS_EQUAL(rows(b3), rotgen::Index{3});
TTS_EQUAL(cols(b3), rotgen::Index{2});
TTS_EQUAL(b3.size(), rotgen::Index{6});
// 3x4 static block
rotgen::matrix<T, 3, 4, O::value> sm;
fill(sm, 3, 4, data);
auto b4 = rotgen::block<decltype(sm), 3, 4>(sm, 0, 0);
TTS_EQUAL(b4.rows(), rotgen::Index{3});
TTS_EQUAL(b4.cols(), rotgen::Index{4});
TTS_EQUAL(rows(b4), rotgen::Index{3});
TTS_EQUAL(cols(b4), rotgen::Index{4});
TTS_EQUAL(b4.size(), rotgen::Index{12});
// 6x2 static block
rotgen::matrix<T, 6, 2, O::value> sm2;
fill(sm2, 6, 2, data);
auto b5 = rotgen::block<decltype(sm2), 6, 2>(sm2, 0, 0);
TTS_EQUAL(b5.rows(), rotgen::Index{6});
TTS_EQUAL(b5.cols(), rotgen::Index{2});
TTS_EQUAL(rows(b5), rotgen::Index{6});
TTS_EQUAL(cols(b5), rotgen::Index{2});
TTS_EQUAL(b5.size(), rotgen::Index{12});
};
TTS_CASE_TPL("Test coefficient accessors",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test coefficient accessors", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
using base = rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>;
@ -92,9 +93,9 @@ TTS_CASE_TPL("Test coefficient accessors",
TTS_EQUAL(b(2, 2), 17);
};
TTS_CASE_TPL("Test one index coefficient accessors",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test one index coefficient accessors", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto vs = [&]() {
if constexpr (O::value == rotgen::ColMajor)

140
test/unit/block/extract.cpp
View file

@ -13,15 +13,15 @@
template<typename EigenType, typename F>
void for_each_element(EigenType const& m, F&& f)
{
for (rotgen::Index i = 0; i < m.rows(); ++i)
for (rotgen::Index j = 0; j < m.cols(); ++j) f(i, j, m(i, j));
for (rotgen::Index i = 0; i < rows(m); ++i)
for (rotgen::Index j = 0; j < cols(m); ++j) f(i, j, m(i, j));
}
template<typename EigenType, typename F>
void for_each_element(EigenType& m, F&& f)
{
for (rotgen::Index i = 0; i < m.rows(); ++i)
for (rotgen::Index j = 0; j < m.cols(); ++j) f(i, j, m(i, j));
for (rotgen::Index i = 0; i < rows(m); ++i)
for (rotgen::Index j = 0; j < cols(m); ++j) f(i, j, m(i, j));
}
template<typename MatrixType, typename T>
@ -53,8 +53,8 @@ void validate_block_behavior(MatrixType& matrix,
rotgen::Index block_n)
{
using T = typename MatrixType::value_type;
TTS_EQUAL(block.rows(), block_m);
TTS_EQUAL(block.cols(), block_n);
TTS_EQUAL(rows(block), block_m);
TTS_EQUAL(cols(block), block_n);
TTS_EQUAL(block.size(), block_m * block_n);
// test block values
@ -144,31 +144,31 @@ void test_dynamic_block_extraction(
std::make_tuple(c_block_top_left_corner, 0, 0, matrix_construct.ni,
matrix_construct.nj, rotgen::Dynamic, rotgen::Dynamic),
std::make_tuple(c_block_top_right_corner, 0,
matrix.cols() - matrix_construct.nj, matrix_construct.ni,
cols(matrix) - matrix_construct.nj, matrix_construct.ni,
matrix_construct.nj, rotgen::Dynamic, rotgen::Dynamic),
std::make_tuple(c_block_bottom_left_corner,
matrix.rows() - matrix_construct.ni, 0, matrix_construct.ni,
rows(matrix) - matrix_construct.ni, 0, matrix_construct.ni,
matrix_construct.nj, rotgen::Dynamic, rotgen::Dynamic),
std::make_tuple(c_block_bottom_right_corner,
matrix.rows() - matrix_construct.ni,
matrix.cols() - matrix_construct.nj, matrix_construct.ni,
rows(matrix) - matrix_construct.ni,
cols(matrix) - matrix_construct.nj, matrix_construct.ni,
matrix_construct.nj, rotgen::Dynamic, rotgen::Dynamic),
std::make_tuple(c_block_top_rows, 0, 0, matrix_construct.ni, matrix.cols(),
std::make_tuple(c_block_top_rows, 0, 0, matrix_construct.ni, cols(matrix),
rotgen::Dynamic, MatrixType::ColsAtCompileTime),
std::make_tuple(c_block_middle_rows, matrix_construct.i0, 0,
matrix_construct.ni, matrix.cols(), rotgen::Dynamic,
matrix_construct.ni, cols(matrix), rotgen::Dynamic,
MatrixType::ColsAtCompileTime),
std::make_tuple(c_block_bottom_rows, matrix.rows() - matrix_construct.ni, 0,
matrix_construct.ni, matrix.cols(), rotgen::Dynamic,
std::make_tuple(c_block_bottom_rows, rows(matrix) - matrix_construct.ni, 0,
matrix_construct.ni, cols(matrix), rotgen::Dynamic,
MatrixType::ColsAtCompileTime),
std::make_tuple(c_block_left_cols, 0, 0, matrix.rows(), matrix_construct.nj,
std::make_tuple(c_block_left_cols, 0, 0, rows(matrix), matrix_construct.nj,
MatrixType::RowsAtCompileTime, rotgen::Dynamic),
std::make_tuple(c_block_middle_cols, 0, matrix_construct.j0, matrix.rows(),
std::make_tuple(c_block_middle_cols, 0, matrix_construct.j0, rows(matrix),
matrix_construct.nj, MatrixType::RowsAtCompileTime,
rotgen::Dynamic),
std::make_tuple(c_block_right_cols, 0, matrix.cols() - matrix_construct.nj,
matrix.rows(), matrix_construct.nj,
std::make_tuple(c_block_right_cols, 0, cols(matrix) - matrix_construct.nj,
rows(matrix), matrix_construct.nj,
MatrixType::RowsAtCompileTime, rotgen::Dynamic),
// --- REGULAR TESTS
@ -178,31 +178,31 @@ void test_dynamic_block_extraction(
std::make_tuple(block_top_left_corner, 0, 0, matrix_construct.ni,
matrix_construct.nj, rotgen::Dynamic, rotgen::Dynamic),
std::make_tuple(block_top_right_corner, 0,
matrix.cols() - matrix_construct.nj, matrix_construct.ni,
cols(matrix) - matrix_construct.nj, matrix_construct.ni,
matrix_construct.nj, rotgen::Dynamic, rotgen::Dynamic),
std::make_tuple(block_bottom_left_corner,
matrix.rows() - matrix_construct.ni, 0, matrix_construct.ni,
rows(matrix) - matrix_construct.ni, 0, matrix_construct.ni,
matrix_construct.nj, rotgen::Dynamic, rotgen::Dynamic),
std::make_tuple(block_bottom_right_corner,
matrix.rows() - matrix_construct.ni,
matrix.cols() - matrix_construct.nj, matrix_construct.ni,
rows(matrix) - matrix_construct.ni,
cols(matrix) - matrix_construct.nj, matrix_construct.ni,
matrix_construct.nj, rotgen::Dynamic, rotgen::Dynamic),
std::make_tuple(block_top_rows, 0, 0, matrix_construct.ni, matrix.cols(),
std::make_tuple(block_top_rows, 0, 0, matrix_construct.ni, cols(matrix),
rotgen::Dynamic, MatrixType::ColsAtCompileTime),
std::make_tuple(block_middle_rows, matrix_construct.i0, 0,
matrix_construct.ni, matrix.cols(), rotgen::Dynamic,
matrix_construct.ni, cols(matrix), rotgen::Dynamic,
MatrixType::ColsAtCompileTime),
std::make_tuple(block_bottom_rows, matrix.rows() - matrix_construct.ni, 0,
matrix_construct.ni, matrix.cols(), rotgen::Dynamic,
std::make_tuple(block_bottom_rows, rows(matrix) - matrix_construct.ni, 0,
matrix_construct.ni, cols(matrix), rotgen::Dynamic,
MatrixType::ColsAtCompileTime),
std::make_tuple(block_left_cols, 0, 0, matrix.rows(), matrix_construct.nj,
std::make_tuple(block_left_cols, 0, 0, rows(matrix), matrix_construct.nj,
MatrixType::RowsAtCompileTime, rotgen::Dynamic),
std::make_tuple(block_middle_cols, 0, matrix_construct.j0, matrix.rows(),
std::make_tuple(block_middle_cols, 0, matrix_construct.j0, rows(matrix),
matrix_construct.nj, MatrixType::RowsAtCompileTime,
rotgen::Dynamic),
std::make_tuple(block_right_cols, 0, matrix.cols() - matrix_construct.nj,
matrix.rows(), matrix_construct.nj,
std::make_tuple(block_right_cols, 0, cols(matrix) - matrix_construct.nj,
rows(matrix), matrix_construct.nj,
MatrixType::RowsAtCompileTime, rotgen::Dynamic));
std::apply(
@ -276,68 +276,68 @@ void test_static_block_extraction(
std::make_tuple(c_block_top_left_corner, 0, 0, matrix_construct.ni,
matrix_construct.nj, int(NI), int(NJ)),
std::make_tuple(c_block_top_right_corner, 0,
matrix.cols() - matrix_construct.nj, matrix_construct.ni,
cols(matrix) - matrix_construct.nj, matrix_construct.ni,
matrix_construct.nj, int(NI), int(NJ)),
std::make_tuple(c_block_bottom_left_corner,
matrix.rows() - matrix_construct.ni, 0, matrix_construct.ni,
rows(matrix) - matrix_construct.ni, 0, matrix_construct.ni,
matrix_construct.nj, int(NI), int(NJ)),
std::make_tuple(c_block_bottom_right_corner,
matrix.rows() - matrix_construct.ni,
matrix.cols() - matrix_construct.nj, matrix_construct.ni,
rows(matrix) - matrix_construct.ni,
cols(matrix) - matrix_construct.nj, matrix_construct.ni,
matrix_construct.nj, int(NI), int(NJ)),
std::make_tuple(c_block_top_rows, 0, 0, matrix_construct.ni, matrix.cols(),
std::make_tuple(c_block_top_rows, 0, 0, matrix_construct.ni, cols(matrix),
int(NI), rotgen::Dynamic),
std::make_tuple(c_block_middle_rows, i0, 0, matrix_construct.ni,
matrix.cols(), int(NI), rotgen::Dynamic),
std::make_tuple(c_block_bottom_rows, matrix.rows() - matrix_construct.ni, 0,
matrix_construct.ni, matrix.cols(), int(NI),
cols(matrix), int(NI), rotgen::Dynamic),
std::make_tuple(c_block_bottom_rows, rows(matrix) - matrix_construct.ni, 0,
matrix_construct.ni, cols(matrix), int(NI),
rotgen::Dynamic),
std::make_tuple(c_block_left_cols, 0, 0, matrix.rows(), matrix_construct.nj,
std::make_tuple(c_block_left_cols, 0, 0, rows(matrix), matrix_construct.nj,
rotgen::Dynamic, int(NJ)),
std::make_tuple(c_block_middle_cols, 0, j0, matrix.rows(),
std::make_tuple(c_block_middle_cols, 0, j0, rows(matrix),
matrix_construct.nj, rotgen::Dynamic, int(NJ)),
std::make_tuple(c_block_right_cols, 0, matrix.cols() - matrix_construct.nj,
matrix.rows(), matrix_construct.nj, rotgen::Dynamic,
std::make_tuple(c_block_right_cols, 0, cols(matrix) - matrix_construct.nj,
rows(matrix), matrix_construct.nj, rotgen::Dynamic,
int(NJ)),
std::make_tuple(c_block_row, i0, 0, 1, matrix.cols(), 1, rotgen::Dynamic),
std::make_tuple(c_block_col, 0, j0, matrix.rows(), 1, rotgen::Dynamic, 1),
std::make_tuple(c_block_row, i0, 0, 1, cols(matrix), 1, rotgen::Dynamic),
std::make_tuple(c_block_col, 0, j0, rows(matrix), 1, rotgen::Dynamic, 1),
// -- Block to NON CONST
std::make_tuple(block_main, i0, j0, matrix_construct.ni,
matrix_construct.nj, int(NI), int(NJ)),
std::make_tuple(block_top_left_corner, 0, 0, matrix_construct.ni,
matrix_construct.nj, int(NI), int(NJ)),
std::make_tuple(block_top_right_corner, 0,
matrix.cols() - matrix_construct.nj, matrix_construct.ni,
cols(matrix) - matrix_construct.nj, matrix_construct.ni,
matrix_construct.nj, int(NI), int(NJ)),
std::make_tuple(block_bottom_left_corner,
matrix.rows() - matrix_construct.ni, 0, matrix_construct.ni,
rows(matrix) - matrix_construct.ni, 0, matrix_construct.ni,
matrix_construct.nj, int(NI), int(NJ)),
std::make_tuple(block_bottom_right_corner,
matrix.rows() - matrix_construct.ni,
matrix.cols() - matrix_construct.nj, matrix_construct.ni,
rows(matrix) - matrix_construct.ni,
cols(matrix) - matrix_construct.nj, matrix_construct.ni,
matrix_construct.nj, int(NI), int(NJ)),
std::make_tuple(block_top_rows, 0, 0, matrix_construct.ni, matrix.cols(),
std::make_tuple(block_top_rows, 0, 0, matrix_construct.ni, cols(matrix),
int(NI), rotgen::Dynamic),
std::make_tuple(block_middle_rows, i0, 0, matrix_construct.ni,
matrix.cols(), int(NI), rotgen::Dynamic),
std::make_tuple(block_bottom_rows, matrix.rows() - matrix_construct.ni, 0,
matrix_construct.ni, matrix.cols(), int(NI),
std::make_tuple(block_middle_rows, i0, 0, matrix_construct.ni, cols(matrix),
int(NI), rotgen::Dynamic),
std::make_tuple(block_bottom_rows, rows(matrix) - matrix_construct.ni, 0,
matrix_construct.ni, cols(matrix), int(NI),
rotgen::Dynamic),
std::make_tuple(block_left_cols, 0, 0, matrix.rows(), matrix_construct.nj,
std::make_tuple(block_left_cols, 0, 0, rows(matrix), matrix_construct.nj,
rotgen::Dynamic, int(NJ)),
std::make_tuple(block_middle_cols, 0, j0, matrix.rows(),
matrix_construct.nj, rotgen::Dynamic, int(NJ)),
std::make_tuple(block_right_cols, 0, matrix.cols() - matrix_construct.nj,
matrix.rows(), matrix_construct.nj, rotgen::Dynamic,
std::make_tuple(block_middle_cols, 0, j0, rows(matrix), matrix_construct.nj,
rotgen::Dynamic, int(NJ)),
std::make_tuple(block_right_cols, 0, cols(matrix) - matrix_construct.nj,
rows(matrix), matrix_construct.nj, rotgen::Dynamic,
int(NJ)),
std::make_tuple(block_row, i0, 0, 1, matrix.cols(), 1, rotgen::Dynamic),
std::make_tuple(block_col, 0, j0, matrix.rows(), 1, rotgen::Dynamic, 1));
std::make_tuple(block_row, i0, 0, 1, cols(matrix), 1, rotgen::Dynamic),
std::make_tuple(block_col, 0, j0, rows(matrix), 1, rotgen::Dynamic, 1));
std::apply(
[&](auto&&... block_entries) {
@ -358,7 +358,9 @@ void test_static_block_extraction(
TTS_CASE_TPL(
"Check all dynamic block extractions on a dynamic row-major matrix",
rotgen::tests::types)<typename T, typename O>(tts::type<tts::types<T, O>>)
rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
using mat_t =
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, rotgen::RowMajor>;
@ -394,7 +396,9 @@ TTS_CASE_TPL(
TTS_CASE_TPL(
"Check all dynamic block extractions on a static column-major matrix",
rotgen::tests::types)<typename T, typename O>(tts::type<tts::types<T, O>>)
rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
using mat_t = rotgen::matrix<T, 4, 5, rotgen::ColMajor>;
@ -417,9 +421,9 @@ TTS_CASE_TPL(
}
};
TTS_CASE_TPL("Check all static block extractions",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Check all static block extractions", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
using mat_t = rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>;
@ -446,9 +450,9 @@ TTS_CASE_TPL("Check all static block extractions",
0});
};
TTS_CASE_TPL("Check vector-only extractions",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Check vector-only extractions", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto run_case = [](auto&& matrix, auto&& block, int i_offset, int j_offset,
int ni, int nj, auto const& rows_ct, auto const& cols_ct) {

80
test/unit/block/generators.cpp
View file

@ -48,9 +48,9 @@ void test_random(auto const& matrix,
}
}
TTS_CASE_TPL("Test dynamic block::setZero",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test dynamic block::setZero", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_block_references<T, O>();
for (auto const& [matrix_desc, i0, j0, ni, nj] : cases)
@ -64,14 +64,14 @@ TTS_CASE_TPL("Test dynamic block::setZero",
test_value(m, T{0}, i0, j0, ni, nj);
using input_type = decltype(rotgen::extract(m, i0, j0, ni, nj));
auto values = input_type::Zero(ni, nj);
auto values = rotgen::setZero<input_type>(ni, nj);
test_value(values, T{0}, 0, 0, ni, nj);
}
};
TTS_CASE_TPL("Test static block::setZero",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test static block::setZero", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_static_block_references<T, O>();
@ -87,16 +87,16 @@ TTS_CASE_TPL("Test static block::setZero",
test_value(m, T{0}, i0, j0, D::ni, D::nj);
using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0));
auto values = input_type::Zero();
auto values = rotgen::setZero<input_type>();
test_value(values, T{0}, 0, 0, D::ni, D::nj);
};
std::apply([&](auto const&... d) { (process(d), ...); }, cases);
};
TTS_CASE_TPL("Test dynamic block::setOnes",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test dynamic block::setOnes", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_block_references<T, O>();
for (auto const& [matrix_desc, i0, j0, ni, nj] : cases)
@ -110,14 +110,14 @@ TTS_CASE_TPL("Test dynamic block::setOnes",
test_value(m, T{1}, i0, j0, ni, nj);
using input_type = decltype(rotgen::extract(m, i0, j0, ni, nj));
auto values = input_type::Ones(ni, nj);
auto values = rotgen::setOnes<input_type>(ni, nj);
test_value(values, T{1}, 0, 0, ni, nj);
}
};
TTS_CASE_TPL("Test static block::setOnes",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test static block::setOnes", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_static_block_references<T, O>();
@ -133,16 +133,16 @@ TTS_CASE_TPL("Test static block::setOnes",
test_value(m, T{1}, i0, j0, D::ni, D::nj);
using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0));
auto values = input_type::Ones();
auto values = rotgen::setOnes<input_type>();
test_value(values, T{1}, 0, 0, D::ni, D::nj);
};
std::apply([&](auto const&... d) { (process(d), ...); }, cases);
};
TTS_CASE_TPL("Test dynamic block::setConstant",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test dynamic block::setConstant", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_block_references<T, O>();
for (auto const& [matrix_desc, i0, j0, ni, nj] : cases)
@ -156,14 +156,14 @@ TTS_CASE_TPL("Test dynamic block::setConstant",
test_value(m, T{13.37f}, i0, j0, ni, nj);
using input_type = decltype(rotgen::extract(m, i0, j0, ni, nj));
auto values = input_type::Constant(ni, nj, T{13.37f});
auto values = rotgen::setConstant<input_type>(ni, nj, T{13.37f});
test_value(values, T{13.37f}, 0, 0, ni, nj);
}
};
TTS_CASE_TPL("Test static block::setConstant",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test static block::setConstant", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_static_block_references<T, O>();
@ -179,16 +179,16 @@ TTS_CASE_TPL("Test static block::setConstant",
test_value(m, T{13.37f}, i0, j0, D::ni, D::nj);
using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0));
auto values = input_type::Constant(T{13.37f});
auto values = rotgen::setConstant<input_type>(T{13.37f});
test_value(values, T{13.37f}, 0, 0, D::ni, D::nj);
};
std::apply([&](auto const&... d) { (process(d), ...); }, cases);
};
TTS_CASE_TPL("Test dynamic block::setIdentity",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test dynamic block::setIdentity", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_block_references<T, O>();
for (auto const& [matrix_desc, i0, j0, ni, nj] : cases)
@ -202,14 +202,14 @@ TTS_CASE_TPL("Test dynamic block::setIdentity",
test_identity(m, i0, j0, ni, nj);
using input_type = decltype(rotgen::extract(m, i0, j0, ni, nj));
auto values = input_type::Identity(ni, nj);
auto values = rotgen::setIdentity<input_type>(ni, nj);
test_identity(values, 0, 0, ni, nj);
}
};
TTS_CASE_TPL("Test static block::setIdentity",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test static block::setIdentity", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_static_block_references<T, O>();
@ -225,16 +225,16 @@ TTS_CASE_TPL("Test static block::setIdentity",
test_identity(m, i0, j0, D::ni, D::nj);
using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0));
auto values = input_type::Identity();
auto values = rotgen::setIdentity<input_type>();
test_identity(values, 0, 0, D::ni, D::nj);
};
std::apply([&](auto const&... d) { (process(d), ...); }, cases);
};
TTS_CASE_TPL("Test dynamic block::setRandom",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test dynamic block::setRandom", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_block_references<T, O>();
for (auto const& [matrix_desc, i0, j0, ni, nj] : cases)
@ -248,14 +248,14 @@ TTS_CASE_TPL("Test dynamic block::setRandom",
test_random(m, i0, j0, ni, nj);
using input_type = decltype(rotgen::extract(m, i0, j0, ni, nj));
auto values = input_type::Random(ni, nj);
auto values = rotgen::setRandom<input_type>(ni, nj);
test_random(values, 0, 0, ni, nj);
}
};
TTS_CASE_TPL("Test static block::setRandom",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test static block::setRandom", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_static_block_references<T, O>();
@ -271,7 +271,7 @@ TTS_CASE_TPL("Test static block::setRandom",
test_random(m, i0, j0, D::ni, D::nj);
using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0));
auto values = input_type::Random();
auto values = rotgen::setRandom<input_type>();
test_random(values, 0, 0, D::ni, D::nj);
};

6
test/unit/common/arithmetic.hpp
View file

@ -21,7 +21,7 @@ namespace rotgen::tests
using eigen_mat_t =
matrix<typename T::value_type, Dynamic, Dynamic, T::storage_order>;
eigen_mat_t eigen_result(rotgen_input.cols(), rotgen_input.rows());
eigen_mat_t eigen_result(cols(rotgen_input), rows(rotgen_input));
prepare([&](auto r, auto c) { return rotgen_input(c, r); }, eigen_result);
TTS_EQUAL(transpose(rotgen_input), eigen_result);
@ -42,7 +42,7 @@ namespace rotgen::tests
}
else
{
if (rotgen_input.rows() == rotgen_input.cols())
if (rows(rotgen_input) == cols(rotgen_input))
{
eigen_mat_t eigen_ref = rotgen_input;
transposeInPlace(rotgen_input);
@ -66,7 +66,7 @@ namespace rotgen::tests
using eigen_mat_t =
Eigen::Matrix<typename T::value_type, Eigen::Dynamic, Eigen::Dynamic>;
eigen_mat_t eigen_ref(rotgen_input.rows(), rotgen_input.cols());
eigen_mat_t eigen_ref(rows(rotgen_input), cols(rotgen_input));
prepare([&](auto r, auto c) { return rotgen_input(r, c); }, eigen_ref);
TTS_ULP_EQUAL(sum(rotgen_input), eigen_ref.sum(), 2);

8
test/unit/common/cwise.hpp
View file

@ -25,10 +25,10 @@ namespace rotgen::tests
TTS_WHEN("Unary Cwise operations")
{
eigen_mat_t eigen_ref(rotgen_input.rows(), rotgen_input.cols());
eigen_mat_t eigen_ref(rows(rotgen_input), cols(rotgen_input));
prepare([&](auto r, auto c) { return rotgen_input(r, c); }, eigen_ref);
rotgen_mat_t rotgen_ref(rotgen_input.rows(), rotgen_input.cols());
rotgen_mat_t rotgen_ref(rows(rotgen_input), cols(rotgen_input));
TTS_AND_THEN("abs()")
{
@ -57,8 +57,8 @@ namespace rotgen::tests
auto mat = rotgen::abs(rotgen_input);
auto proper_input = rotgen::sqrt(mat);
for (rotgen::Index r = 0; r < rotgen_input.rows(); ++r)
for (rotgen::Index c = 0; c < rotgen_input.cols(); ++c)
for (rotgen::Index r = 0; r < rows(rotgen_input); ++r)
for (rotgen::Index c = 0; c < cols(rotgen_input); ++c)
TTS_ULP_EQUAL(proper_input(r, c), eigen_ref(r, c), 1);
}
}

4
test/unit/common/norms.hpp
View file

@ -20,7 +20,7 @@ namespace rotgen::tests
using eigen_mat_t =
Eigen::Matrix<typename T::value_type, Eigen::Dynamic, Eigen::Dynamic>;
eigen_mat_t eigen_ref(rotgen_input.rows(), rotgen_input.cols());
eigen_mat_t eigen_ref(rows(rotgen_input), cols(rotgen_input));
prepare([&](auto row, auto col) { return rotgen_input(row, col); },
eigen_ref);
@ -38,7 +38,7 @@ namespace rotgen::tests
using rotgen_mat_t =
rotgen::matrix<typename T::value_type, rotgen::Dynamic, rotgen::Dynamic,
T::storage_order>;
rotgen_mat_t rotgen_norm_ref(rotgen_input.rows(), rotgen_input.cols());
rotgen_mat_t rotgen_norm_ref(rows(rotgen_input), cols(rotgen_input));
prepare([&](auto row, auto col) { return eigen_normalized(row, col); },
rotgen_norm_ref);

9
test/unit/common/references.hpp
View file

@ -55,8 +55,13 @@ namespace rotgen::tests
void prepare(auto fn, auto& output)
{
for (rotgen::Index r = 0; r < output.rows(); ++r)
for (rotgen::Index c = 0; c < output.cols(); ++c) output(r, c) = fn(r, c);
for (rotgen::Index r = 0; r < rows(output); ++r)
{
for (rotgen::Index c = 0; c < cols(output); ++c)
{
output(r, c) = fn(r, c);
}
}
}
auto default_init_function = [](auto row, auto col) {

38
test/unit/functions/rowwise.cpp
View file

@ -10,8 +10,9 @@
#include "unit/common/references.hpp"
#include "unit/tests.hpp"
TTS_CASE_TPL("rowwise API", rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("rowwise API", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
using eigen_mat_t =
Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, O::value>;
@ -25,24 +26,25 @@ TTS_CASE_TPL("rowwise API", rotgen::tests::types)<typename T, typename O>(
auto rotgen_rw = rotgen::rowwise(rotgen_mat);
for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
for (rotgen::Index i = 0; i < rows(rotgen_mat); ++i)
TTS_EQUAL(rotgen::sum(rotgen_rw)(i), eigen_ref_rw.sum()(i));
for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
for (rotgen::Index i = 0; i < rows(rotgen_mat); ++i)
TTS_EQUAL(rotgen::mean(rotgen_rw)(i), eigen_ref_rw.mean()(i));
for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
for (rotgen::Index i = 0; i < rows(rotgen_mat); ++i)
TTS_EQUAL(rotgen::prod(rotgen_rw)(i), eigen_ref_rw.prod()(i));
for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
for (rotgen::Index i = 0; i < rows(rotgen_mat); ++i)
TTS_EQUAL(rotgen::maxCoeff(rotgen_rw)(i), eigen_ref_rw.maxCoeff()(i));
for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
for (rotgen::Index i = 0; i < rows(rotgen_mat); ++i)
TTS_EQUAL(rotgen::minCoeff(rotgen_rw)(i), eigen_ref_rw.minCoeff()(i));
for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
for (rotgen::Index i = 0; i < rows(rotgen_mat); ++i)
TTS_EQUAL(rotgen::squaredNorm(rotgen_rw)(i), eigen_ref_rw.squaredNorm()(i));
for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
for (rotgen::Index i = 0; i < rows(rotgen_mat); ++i)
TTS_EQUAL(rotgen::norm(rotgen_rw)(i), eigen_ref_rw.norm()(i));
};
TTS_CASE_TPL("colwise API", rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("colwise API", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
using eigen_mat_t =
Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, O::value>;
@ -56,18 +58,18 @@ TTS_CASE_TPL("colwise API", rotgen::tests::types)<typename T, typename O>(
auto rotgen_rw = rotgen::colwise(rotgen_mat);
for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
for (rotgen::Index i = 0; i < cols(rotgen_mat); ++i)
TTS_EQUAL(rotgen::sum(rotgen_rw)(i), eigen_ref_rw.sum()(i));
for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
for (rotgen::Index i = 0; i < cols(rotgen_mat); ++i)
TTS_EQUAL(rotgen::mean(rotgen_rw)(i), eigen_ref_rw.mean()(i));
for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
for (rotgen::Index i = 0; i < cols(rotgen_mat); ++i)
TTS_EQUAL(rotgen::prod(rotgen_rw)(i), eigen_ref_rw.prod()(i));
for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
for (rotgen::Index i = 0; i < cols(rotgen_mat); ++i)
TTS_EQUAL(rotgen::maxCoeff(rotgen_rw)(i), eigen_ref_rw.maxCoeff()(i));
for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
for (rotgen::Index i = 0; i < cols(rotgen_mat); ++i)
TTS_EQUAL(rotgen::minCoeff(rotgen_rw)(i), eigen_ref_rw.minCoeff()(i));
for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
for (rotgen::Index i = 0; i < cols(rotgen_mat); ++i)
TTS_EQUAL(rotgen::squaredNorm(rotgen_rw)(i), eigen_ref_rw.squaredNorm()(i));
for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
for (rotgen::Index i = 0; i < cols(rotgen_mat); ++i)
TTS_EQUAL(rotgen::norm(rotgen_rw)(i), eigen_ref_rw.norm()(i));
};

6
test/unit/functions/svd.cpp
View file

@ -16,8 +16,8 @@ TTS_CASE_TPL("SVD decomposition - Dynamic case", rotgen::tests::types)
int rank, i = 5;
auto eps = std::numeric_limits<T>::epsilon();
auto m =
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>::Random(5, 5);
auto m = rotgen::setRandom<
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>>(5, 5);
auto decomp = rotgen::svd(m);
do
@ -55,7 +55,7 @@ TTS_CASE_TPL("SVD decomposition - Static case", rotgen::tests::types)
int rank, i = 5;
auto eps = std::numeric_limits<T>::epsilon();
auto m = rotgen::matrix<T, 5, 5, O::value>::Random();
auto m = rotgen::setRandom<rotgen::matrix<T, 5, 5, O::value>>();
auto decomp = rotgen::svd(m);
do

4
test/unit/map/arithmetic_functions.cpp
View file

@ -36,7 +36,7 @@ TTS_CASE_TPL("Test static map transposition-like operations",
auto process = []<typename D>(D const& desc) {
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> base(D::rows,
D::cols);
rotgen::tests::prepare(base.rows(), base.cols(), desc.init_fn, base);
rotgen::tests::prepare(rows(base), cols(base), desc.init_fn, base);
rotgen::map<rotgen::matrix<T, D::rows, D::cols, O::value>> input(
base.data());
@ -72,7 +72,7 @@ TTS_CASE_TPL("Test static map reduction-like operations",
auto process = []<typename D>(D const& desc) {
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> base(D::rows,
D::cols);
rotgen::tests::prepare(base.rows(), base.cols(), desc.init_fn, base);
rotgen::tests::prepare(rows(base), cols(base), desc.init_fn, base);
rotgen::map<rotgen::matrix<T, D::rows, D::cols, O::value>> input(
base.data());

37
test/unit/map/basic_api.cpp
View file

@ -9,40 +9,41 @@
#include "unit/tests.hpp"
TTS_CASE_TPL("Function size", rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Function size", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
T data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
rotgen::map<rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>>
dyn_map(data, 1, 12);
TTS_EQUAL(dyn_map.rows(), rotgen::Index{1});
TTS_EQUAL(dyn_map.cols(), rotgen::Index{12});
TTS_EQUAL(rows(dyn_map), rotgen::Index{1});
TTS_EQUAL(cols(dyn_map), rotgen::Index{12});
rotgen::map<rotgen::matrix<T, 1, 12, rotgen::RowMajor>> s112_map(data);
TTS_EQUAL(s112_map.rows(), rotgen::Index{1});
TTS_EQUAL(s112_map.cols(), rotgen::Index{12});
TTS_EQUAL(rows(s112_map), rotgen::Index{1});
TTS_EQUAL(cols(s112_map), rotgen::Index{12});
TTS_EQUAL(s112_map.size(), rotgen::Index{12});
rotgen::map<rotgen::matrix<T, 12, 1, rotgen::ColMajor>> s121_map(data);
TTS_EQUAL(s121_map.rows(), rotgen::Index{12});
TTS_EQUAL(s121_map.cols(), rotgen::Index{1});
TTS_EQUAL(rows(s121_map), rotgen::Index{12});
TTS_EQUAL(cols(s121_map), rotgen::Index{1});
TTS_EQUAL(s121_map.size(), rotgen::Index{12});
rotgen::map<rotgen::matrix<T, 3, 4, O::value>> s34_map(data);
TTS_EQUAL(s34_map.rows(), rotgen::Index{3});
TTS_EQUAL(s34_map.cols(), rotgen::Index{4});
TTS_EQUAL(rows(s34_map), rotgen::Index{3});
TTS_EQUAL(cols(s34_map), rotgen::Index{4});
TTS_EQUAL(s34_map.size(), rotgen::Index{12});
rotgen::map<rotgen::matrix<T, 6, 2, O::value>> s62_map(data);
TTS_EQUAL(s62_map.rows(), rotgen::Index{6});
TTS_EQUAL(s62_map.cols(), rotgen::Index{2});
TTS_EQUAL(rows(s62_map), rotgen::Index{6});
TTS_EQUAL(cols(s62_map), rotgen::Index{2});
TTS_EQUAL(s62_map.size(), rotgen::Index{12});
};
TTS_CASE_TPL("Test coefficient accessors",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test coefficient accessors", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
using base = rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>;
@ -66,9 +67,9 @@ TTS_CASE_TPL("Test coefficient accessors",
TTS_EQUAL(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>>)
TTS_CASE_TPL("Test one index coefficient accessors", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
T data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

14
test/unit/map/cwise.cpp
View file

@ -11,9 +11,9 @@
#include "unit/common/references.hpp"
#include "unit/tests.hpp"
TTS_CASE_TPL("Test dynamic map cwise operations",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test dynamic map cwise operations", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_matrix_references();
for (auto const& [rows, cols, fn] : cases)
@ -28,16 +28,16 @@ TTS_CASE_TPL("Test dynamic map cwise operations",
}
};
TTS_CASE_TPL("Test static map cwise operations",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test static map cwise operations", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_static_matrix_references();
auto process = []<typename D>(D const& desc) {
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> base(D::rows,
D::cols);
rotgen::tests::prepare(base.rows(), base.cols(), desc.init_fn, base);
rotgen::tests::prepare(rows(base), cols(base), desc.init_fn, base);
rotgen::map<rotgen::matrix<T, D::rows, D::cols, O::value>> input(
base.data());

14
test/unit/map/norms.cpp
View file

@ -11,9 +11,9 @@
#include "unit/common/references.hpp"
#include "unit/tests.hpp"
TTS_CASE_TPL("Test dynamic map norm operations",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test dynamic map norm operations", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_matrix_references();
for (auto const& [rows, cols, fn] : cases)
@ -28,16 +28,16 @@ TTS_CASE_TPL("Test dynamic map norm operations",
}
};
TTS_CASE_TPL("Test static map norm operations",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test static map norm operations", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_static_matrix_references();
auto process = []<typename D>(D const& desc) {
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> base(D::rows,
D::cols);
rotgen::tests::prepare(base.rows(), base.cols(), desc.init_fn, base);
rotgen::tests::prepare(rows(base), cols(base), desc.init_fn, base);
rotgen::map<rotgen::matrix<T, D::rows, D::cols, O::value>> input(
base.data());

24
test/unit/map/strides.cpp
View file

@ -40,8 +40,8 @@ TTS_CASE("Validate Column Major Map with regular stride behavior")
r_map_t<r_mat_t<rotgen::ColMajor>> r_map(buffer.data(), rows, cols);
TTS_EQUAL(r_map.innerStride(), 1);
TTS_EQUAL(r_map.outerStride(), 3);
TTS_EQUAL(innerStride(r_map), 1);
TTS_EQUAL(outerStride(r_map), 3);
e_map_t<e_mat_t<Eigen::ColMajor>> e_map(buffer.data(), rows, cols);
@ -59,8 +59,8 @@ TTS_CASE("Validate Column Major Map with specific outer stride behavior")
r_map_t<r_mat_t<rotgen::ColMajor>, rotgen::outer_stride<>> r_map(
buffer.data(), rows, cols, rotgen::outer_stride<>(rows + 1));
TTS_EQUAL(r_map.innerStride(), 1);
TTS_EQUAL(r_map.outerStride(), 4);
TTS_EQUAL(innerStride(r_map), 1);
TTS_EQUAL(outerStride(r_map), 4);
e_map_t<e_mat_t<Eigen::ColMajor>, Eigen::OuterStride<>> e_map(
buffer.data(), rows, cols, Eigen::OuterStride<>(rows + 1));
@ -79,8 +79,8 @@ TTS_CASE("Validate Column Major Map with specific inner stride behavior")
r_map_t<r_mat_t<rotgen::ColMajor>, rotgen::dynamic_stride> r_map(
buffer.data(), rows, cols, rotgen::dynamic_stride(rows, 2));
TTS_EQUAL(r_map.innerStride(), 2);
TTS_EQUAL(r_map.outerStride(), 3);
TTS_EQUAL(innerStride(r_map), 2);
TTS_EQUAL(outerStride(r_map), 3);
e_map_t<e_mat_t<Eigen::ColMajor>,
Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>>
@ -100,8 +100,8 @@ TTS_CASE("Validate Row Major Map with regular stride behavior")
r_map_t<r_mat_t<rotgen::RowMajor>> r_map(buffer.data(), rows, cols);
TTS_EQUAL(r_map.innerStride(), 1);
TTS_EQUAL(r_map.outerStride(), 4);
TTS_EQUAL(innerStride(r_map), 1);
TTS_EQUAL(outerStride(r_map), 4);
e_map_t<e_mat_t<Eigen::RowMajor>> e_map(buffer.data(), rows, cols);
@ -119,8 +119,8 @@ TTS_CASE("Validate Row Major Map with specific outer stride behavior")
r_map_t<r_mat_t<rotgen::RowMajor>, rotgen::outer_stride<>> r_map(
buffer.data(), rows, cols, rotgen::outer_stride<>(cols + 1));
TTS_EQUAL(r_map.innerStride(), 1);
TTS_EQUAL(r_map.outerStride(), 5);
TTS_EQUAL(innerStride(r_map), 1);
TTS_EQUAL(outerStride(r_map), 5);
e_map_t<e_mat_t<Eigen::RowMajor>, Eigen::OuterStride<>> e_map(
buffer.data(), rows, cols, Eigen::OuterStride<>(cols + 1));
@ -139,8 +139,8 @@ TTS_CASE("Validate Row Major Map with specific inner stride behavior")
r_map_t<r_mat_t<rotgen::RowMajor>, rotgen::dynamic_stride> r_map(
buffer.data(), rows, cols, rotgen::dynamic_stride(2, cols));
TTS_EQUAL(r_map.innerStride(), 4);
TTS_EQUAL(r_map.outerStride(), 2);
TTS_EQUAL(innerStride(r_map), 4);
TTS_EQUAL(outerStride(r_map), 2);
e_map_t<e_mat_t<Eigen::RowMajor>,
Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>>

27
test/unit/matrix/arithmetic_functions.cpp
View file

@ -13,8 +13,9 @@
#include "unit/tests.hpp"
TTS_CASE_TPL("Test dynamic matrix transposition-like operations",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_matrix_references();
for (auto const& [rows, cols, fn] : cases)
@ -27,14 +28,15 @@ TTS_CASE_TPL("Test dynamic matrix transposition-like operations",
};
TTS_CASE_TPL("Test static matrix transposition-like operations",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_static_matrix_references();
auto process = []<typename D>(D const& desc) {
rotgen::matrix<T, D::rows, D::cols, O::value> input;
rotgen::tests::prepare(input.rows(), input.cols(), desc.init_fn, input);
rotgen::tests::prepare(rows(input), cols(input), desc.init_fn, input);
rotgen::tests::check_shape_functions(input);
};
@ -42,8 +44,9 @@ TTS_CASE_TPL("Test static matrix transposition-like operations",
};
TTS_CASE_TPL("Test dynamic matrix reduction-like operations",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_matrix_references();
for (auto const& [rows, cols, fn] : cases)
@ -56,21 +59,23 @@ TTS_CASE_TPL("Test dynamic matrix reduction-like operations",
};
TTS_CASE_TPL("Test static matrix reduction-like operations",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_static_matrix_references();
auto process = []<typename D>(D const& desc) {
rotgen::matrix<T, D::rows, D::cols, O::value> input;
rotgen::tests::prepare(input.rows(), input.cols(), desc.init_fn, input);
rotgen::tests::prepare(rows(input), cols(input), desc.init_fn, input);
rotgen::tests::check_reduction_functions(input);
};
std::apply([&](auto const&... d) { (process(d), ...); }, cases);
};
TTS_CASE_TPL("Test dot product", float, double)<typename T>(tts::type<T>){
TTS_CASE_TPL("Test dot product", float, double)
<typename T>(tts::type<T>){
{auto a = rotgen::setConstant<rotgen::matrix<T, 1, rotgen::Dynamic>>(1, 8, 2);
auto b = rotgen::setConstant<rotgen::matrix<T, 1, rotgen::Dynamic>>(1, 8, 2);

85
test/unit/matrix/basic_api.cpp
View file

@ -9,8 +9,9 @@
#include "unit/tests.hpp"
TTS_CASE_TPL("Function size", rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
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);
@ -25,87 +26,87 @@ TTS_CASE_TPL("Function size", rotgen::tests::types)<typename T, typename O>(
TTS_EQUAL(column_vector.size(), rotgen::Index{5});
};
TTS_CASE_TPL("Resizing dynamic matrix",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
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 (rotgen::Index r = 0; r < a.rows(); ++r)
for (rotgen::Index c = 0; c < a.cols(); ++c) a(r, c) = 42 + 2 * c + r;
for (rotgen::Index r = 0; r < rows(a); ++r)
for (rotgen::Index c = 0; c < cols(a); ++c) a(r, c) = 42 + 2 * c + r;
rotgen::resize(a, 3, 2);
TTS_EQUAL(a.rows(), rotgen::Index(3));
TTS_EQUAL(a.cols(), rotgen::Index(2));
TTS_EQUAL(rows(a), rotgen::Index(3));
TTS_EQUAL(cols(a), rotgen::Index(2));
for (rotgen::Index r = 0; r < a.rows(); ++r)
for (rotgen::Index c = 0; c < a.cols(); ++c) TTS_GREATER(a(r, c), 0);
for (rotgen::Index r = 0; r < rows(a); ++r)
for (rotgen::Index c = 0; c < cols(a); ++c) TTS_GREATER(a(r, c), 0);
rotgen::resize(a, 2, 2);
TTS_EQUAL(a.rows(), rotgen::Index(2));
TTS_EQUAL(a.cols(), rotgen::Index(2));
TTS_EQUAL(rows(a), rotgen::Index(2));
TTS_EQUAL(cols(a), rotgen::Index(2));
};
TTS_CASE_TPL("Dynamix matrix conservative resizing",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
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 (rotgen::Index r = 0; r < a.rows(); ++r)
for (rotgen::Index c = 0; c < a.cols(); ++c) a(r, c) = i++;
for (rotgen::Index r = 0; r < rows(a); ++r)
for (rotgen::Index c = 0; c < cols(a); ++c) a(r, c) = i++;
rotgen::conservativeResize(a, 2, 3);
TTS_EQUAL(a.rows(), rotgen::Index(2));
TTS_EQUAL(a.cols(), rotgen::Index(3));
TTS_EQUAL(rows(a), rotgen::Index(2));
TTS_EQUAL(cols(a), rotgen::Index(3));
i = 1;
for (rotgen::Index r = 0; r < a.rows(); ++r)
for (rotgen::Index c = 0; c < a.cols(); ++c) TTS_EQUAL(a(r, c), i++);
for (rotgen::Index r = 0; r < rows(a); ++r)
for (rotgen::Index c = 0; c < cols(a); ++c) TTS_EQUAL(a(r, c), i++);
rotgen::conservativeResize(a, 3, 2);
TTS_EQUAL(a.rows(), rotgen::Index(3));
TTS_EQUAL(a.cols(), rotgen::Index(2));
TTS_EQUAL(rows(a), rotgen::Index(3));
TTS_EQUAL(cols(a), rotgen::Index(2));
int expected[3][2] = {{1, 2}, {4, 5}};
for (rotgen::Index r = 0; r < 2; ++r)
for (rotgen::Index c = 0; c < 2; ++c) TTS_EQUAL(a(r, c), expected[r][c]);
rotgen::conservativeResize(a, 4, 4);
TTS_EQUAL(a.rows(), rotgen::Index(4));
TTS_EQUAL(a.cols(), rotgen::Index(4));
TTS_EQUAL(rows(a), rotgen::Index(4));
TTS_EQUAL(cols(a), rotgen::Index(4));
TTS_EQUAL(a(0, 0), 1);
TTS_EQUAL(a(3, 3), 0);
rotgen::conservativeResize(a, 2, 2);
TTS_EQUAL(a.rows(), rotgen::Index(2));
TTS_EQUAL(a.cols(), rotgen::Index(2));
TTS_EQUAL(rows(a), rotgen::Index(2));
TTS_EQUAL(cols(a), rotgen::Index(2));
TTS_EQUAL(a(0, 0), 1);
TTS_EQUAL(a(1, 1), 5);
rotgen::conservativeResize(a, 1, 2);
TTS_EQUAL(a.rows(), rotgen::Index(1));
TTS_EQUAL(a.cols(), rotgen::Index(2));
TTS_EQUAL(rows(a), rotgen::Index(1));
TTS_EQUAL(cols(a), rotgen::Index(2));
TTS_EQUAL(a(0, 0), 1);
TTS_EQUAL(a(0, 1), 2);
rotgen::conservativeResize(a, 0, 0);
TTS_EQUAL(a.rows(), rotgen::Index(0));
TTS_EQUAL(a.cols(), rotgen::Index(0));
TTS_EQUAL(rows(a), rotgen::Index(0));
TTS_EQUAL(cols(a), rotgen::Index(0));
rotgen::conservativeResize(a, 3, 3);
TTS_EQUAL(a.rows(), rotgen::Index(3));
TTS_EQUAL(a.cols(), rotgen::Index(3));
TTS_EQUAL(rows(a), rotgen::Index(3));
TTS_EQUAL(cols(a), rotgen::Index(3));
};
TTS_CASE_TPL("Test coefficient accessors",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
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 (rotgen::Index r = 0; r < a.rows(); ++r)
for (rotgen::Index c = 0; c < a.cols(); ++c) a(r, c) = r + 2 * c + 3;
for (rotgen::Index r = 0; r < rows(a); ++r)
for (rotgen::Index c = 0; c < cols(a); ++c) a(r, c) = r + 2 * c + 3;
TTS_EQUAL(a(0, 0), 3);
TTS_EQUAL(a(1, 1), 6);
@ -121,9 +122,9 @@ TTS_CASE_TPL("Test coefficient accessors",
TTS_EQUAL(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>>)
TTS_CASE_TPL("Test one index coefficient accessors", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto a = [&]() {
if constexpr (O::value == rotgen::ColMajor)

74
test/unit/matrix/constructors.cpp
View file

@ -15,8 +15,8 @@ TTS_CASE_TPL("Default matrix dynamic constructor", rotgen::tests::types)
{
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_EQUAL(rows(matrix), rotgen::Index{0});
TTS_EQUAL(cols(matrix), rotgen::Index{0});
};
TTS_CASE_TPL("Default matrix static constructor", rotgen::tests::types)
@ -25,8 +25,8 @@ TTS_CASE_TPL("Default matrix static constructor", rotgen::tests::types)
{
rotgen::matrix<T, 4, 9, O::value> matrix;
TTS_EQUAL(matrix.rows(), rotgen::Index{4});
TTS_EQUAL(matrix.cols(), rotgen::Index{9});
TTS_EQUAL(rows(matrix), rotgen::Index{4});
TTS_EQUAL(cols(matrix), rotgen::Index{9});
};
TTS_CASE_TPL("Dynamic matrix constructor with row and columns",
@ -36,8 +36,8 @@ TTS_CASE_TPL("Dynamic matrix constructor with row and columns",
{
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_EQUAL(rows(matrix), rotgen::Index{10});
TTS_EQUAL(cols(matrix), rotgen::Index{5});
};
TTS_CASE_TPL("Static matrix constructor with row and columns", float, double)
@ -72,16 +72,16 @@ TTS_CASE_TPL("Copy constructor produces identical but independent matrix",
{
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;
for (rotgen::Index r = 0; r < rows(a); r++)
for (rotgen::Index c = 0; c < cols(a); 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());
TTS_EQUAL(rows(b), rows(a));
TTS_EQUAL(cols(b), cols(a));
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));
for (rotgen::Index r = 0; r < rows(a); r++)
for (rotgen::Index c = 0; c < cols(a); c++) TTS_EQUAL(b(r, c), a(r, c));
TTS_EQUAL(b(0, 0), 0.0);
TTS_EQUAL(b(1, 0), 1.0);
@ -97,8 +97,8 @@ TTS_CASE_TPL("Copy constructor on default matrix", rotgen::tests::types)
{
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_EQUAL(rows(b), rotgen::Index{0});
TTS_EQUAL(cols(b), rotgen::Index{0});
};
TTS_CASE_TPL("Copy constructor from const matrix", rotgen::tests::types)
@ -107,8 +107,8 @@ TTS_CASE_TPL("Copy constructor from const matrix", rotgen::tests::types)
{
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_EQUAL(rows(b), rotgen::Index{2});
TTS_EQUAL(cols(b), rotgen::Index{2});
};
TTS_CASE_TPL("Copy constructor on static matrix", rotgen::tests::types)
@ -117,8 +117,8 @@ TTS_CASE_TPL("Copy constructor on static matrix", rotgen::tests::types)
{
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_EQUAL(rows(b), rotgen::Index{2});
TTS_EQUAL(cols(b), rotgen::Index{5});
};
TTS_CASE_TPL("Copy constructor on static/dynamic matrix", rotgen::tests::types)
@ -127,8 +127,8 @@ TTS_CASE_TPL("Copy constructor on static/dynamic matrix", rotgen::tests::types)
{
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_EQUAL(rows(b), 11);
TTS_EQUAL(cols(b), 4);
};
TTS_CASE_TPL("Copy constructor on dynamic/static matrix", rotgen::tests::types)
@ -137,8 +137,8 @@ TTS_CASE_TPL("Copy constructor on dynamic/static matrix", rotgen::tests::types)
{
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_EQUAL(rows(b), 5);
TTS_EQUAL(cols(b), 7);
};
TTS_CASE_TPL("Move constructor transfers contents", rotgen::tests::types)
@ -153,8 +153,8 @@ TTS_CASE_TPL("Move constructor transfers contents", rotgen::tests::types)
std::move(a);
TTS_EQUAL(b(1, 1), 7);
TTS_EQUAL(b.rows(), rotgen::Index{3});
TTS_EQUAL(b.cols(), rotgen::Index{3});
TTS_EQUAL(rows(b), rotgen::Index{3});
TTS_EQUAL(cols(b), rotgen::Index{3});
TTS_EXPECT(b.data() == ptr);
};
@ -164,8 +164,8 @@ TTS_CASE_TPL("Move constructor from Rvalue", rotgen::tests::types)
{
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_EQUAL(rows(b), rotgen::Index{2});
TTS_EQUAL(cols(b), rotgen::Index{2});
};
TTS_CASE_TPL("Constructor from Initializer list", rotgen::tests::types)
@ -173,24 +173,24 @@ 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(rows(b1), rotgen::Index{1});
TTS_EQUAL(cols(b1), 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});
TTS_EQUAL(rows(b9), rotgen::Index{5});
TTS_EQUAL(cols(b9), rotgen::Index{1});
T i = 0.25;
for (rotgen::Index r = 0; r < b9.rows(); ++r)
for (rotgen::Index r = 0; r < rows(b9); ++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(rows(b13), rotgen::Index{1});
TTS_EQUAL(cols(b13), rotgen::Index{3});
TTS_EQUAL(b13(0), T(1.2));
TTS_EQUAL(b13(1), T(2.3));
TTS_EQUAL(b13(2), T(3.4));
@ -201,16 +201,16 @@ 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(rows(b1), rotgen::Index{1});
TTS_EQUAL(cols(b1), 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(rows(b23), rotgen::Index{2});
TTS_EQUAL(cols(b23), 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));

14
test/unit/matrix/cwise.cpp
View file

@ -11,9 +11,9 @@
#include "unit/common/references.hpp"
#include "unit/tests.hpp"
TTS_CASE_TPL("Test dynamic matrix cwise operations",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test dynamic matrix cwise operations", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_matrix_references();
for (auto const& [rows, cols, fn] : cases)
@ -25,15 +25,15 @@ TTS_CASE_TPL("Test dynamic matrix cwise operations",
}
};
TTS_CASE_TPL("Test static matrix cwise operations",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test static matrix cwise operations", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_static_matrix_references();
auto process = []<typename D>(D const& desc) {
rotgen::matrix<T, D::rows, D::cols, O::value> input;
rotgen::tests::prepare(input.rows(), input.cols(), desc.init_fn, input);
rotgen::tests::prepare(rows(input), cols(input), desc.init_fn, input);
rotgen::tests::check_cwise_functions(input);
};

16
test/unit/matrix/inverse.cpp
View file

@ -10,9 +10,9 @@
#include "unit/common/references.hpp"
#include "unit/tests.hpp"
TTS_CASE_TPL("Test dynamic matrix inverse",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test dynamic matrix inverse", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
using mat_t = rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>;
auto eps = std::numeric_limits<T>::epsilon();
@ -23,7 +23,7 @@ TTS_CASE_TPL("Test dynamic matrix inverse",
auto inv = rotgen::inverse(input);
auto rec = input * inv;
auto id = mat_t::Identity(rotgen::rows(rec), rotgen::cols(rec));
auto id = rotgen::setIdentity<mat_t>(rotgen::rows(rec), rotgen::cols(rec));
auto error = rec - id;
TTS_LESS_EQUAL(rotgen::maxCoeff(rotgen::abs(error)) / eps, 256.)
@ -43,7 +43,7 @@ template<typename T, typename O, int N> void check_static_inverse()
auto inv = rotgen::inverse(input);
auto rec = input * inv;
auto id = mat_t::Identity(rotgen::rows(rec), rotgen::cols(rec));
auto id = rotgen::setIdentity<mat_t>(rotgen::rows(rec), rotgen::cols(rec));
auto error = rec - id;
TTS_LESS_EQUAL(rotgen::maxCoeff(rotgen::abs(error)) / eps, 256.)
@ -53,9 +53,9 @@ template<typename T, typename O, int N> void check_static_inverse()
<< error << "\n";
}
TTS_CASE_TPL("Test static matrix inverse",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test static matrix inverse", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
check_static_inverse<T, O, 2>();
check_static_inverse<T, O, 3>();

14
test/unit/matrix/norms.cpp
View file

@ -11,9 +11,9 @@
#include "unit/common/references.hpp"
#include "unit/tests.hpp"
TTS_CASE_TPL("Test dynamic matrix norm operations",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test dynamic matrix norm operations", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_matrix_references();
for (auto const& [rows, cols, fn] : cases)
@ -25,15 +25,15 @@ TTS_CASE_TPL("Test dynamic matrix norm operations",
}
};
TTS_CASE_TPL("Test static matrix norm operations",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Test static matrix norm operations", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
auto const cases = rotgen::tests::generate_static_matrix_references();
auto process = []<typename D>(D const& desc) {
rotgen::matrix<T, D::rows, D::cols, O::value> input;
rotgen::tests::prepare(input.rows(), input.cols(), desc.init_fn, input);
rotgen::tests::prepare(rows(input), cols(input), desc.init_fn, input);
rotgen::tests::check_norms_functions(input);
};

92
test/unit/matrix/operators.cpp
View file

@ -10,20 +10,20 @@
#include "unit/tests.hpp"
template<typename MatrixType>
void test_matrix_operations(rotgen::Index rows,
rotgen::Index cols,
void test_matrix_operations(rotgen::Index rr,
rotgen::Index cc,
auto a_init_fn,
auto b_init_fn,
auto ops,
auto self_ops)
{
MatrixType a(rows, cols);
MatrixType b(rows, cols);
MatrixType ref(rows, cols);
MatrixType a(rr, cc);
MatrixType b(rr, cc);
MatrixType ref(rr, cc);
for (rotgen::Index r = 0; r < rows; ++r)
for (rotgen::Index r = 0; r < rr; ++r)
{
for (rotgen::Index c = 0; c < cols; ++c)
for (rotgen::Index c = 0; c < cc; ++c)
{
a(r, c) = a_init_fn(r, c);
b(r, c) = b_init_fn(r, c);
@ -40,19 +40,19 @@ void test_matrix_operations(rotgen::Index rows,
}
template<typename MatrixType>
void test_scalar_operations(rotgen::Index rows,
rotgen::Index cols,
void test_scalar_operations(rotgen::Index rr,
rotgen::Index cc,
auto a_init_fn,
auto s,
auto ops,
auto self_ops)
{
MatrixType a(rows, cols);
MatrixType ref(rows, cols);
MatrixType a(rr, cc);
MatrixType ref(rr, cc);
for (rotgen::Index r = 0; r < rows; ++r)
for (rotgen::Index r = 0; r < rr; ++r)
{
for (rotgen::Index c = 0; c < cols; ++c)
for (rotgen::Index c = 0; c < cc; ++c)
{
a(r, c) = a_init_fn(r, c);
ref(r, c) = ops(a(r, c), s);
@ -68,17 +68,17 @@ void test_scalar_operations(rotgen::Index rows,
}
template<typename MatrixType>
void test_scalar_multiplications(rotgen::Index rows,
rotgen::Index cols,
void test_scalar_multiplications(rotgen::Index rr,
rotgen::Index cc,
auto fn,
auto s)
{
MatrixType a(rows, cols);
MatrixType ref(rows, cols);
MatrixType a(rr, cc);
MatrixType ref(rr, cc);
for (rotgen::Index r = 0; r < rows; ++r)
for (rotgen::Index r = 0; r < rr; ++r)
{
for (rotgen::Index c = 0; c < cols; ++c)
for (rotgen::Index c = 0; c < cc; ++c)
{
a(r, c) = fn(r, c);
ref(r, c) = a(r, c) * s;
@ -96,27 +96,27 @@ void test_scalar_multiplications(rotgen::Index rows,
}
template<typename MatrixType>
void test_matrix_multiplication(rotgen::Index rows,
rotgen::Index cols,
void test_matrix_multiplication(rotgen::Index rr,
rotgen::Index cc,
auto a_init_fn,
auto b_init_fn)
{
MatrixType a(rows, cols);
MatrixType b(cols, rows);
MatrixType ref(rows, rows);
MatrixType a(rr, cc);
MatrixType b(cc, rr);
MatrixType ref(rr, rr);
for (rotgen::Index r = 0; r < a.rows(); ++r)
for (rotgen::Index c = 0; c < a.cols(); ++c) a(r, c) = a_init_fn(r, c);
for (rotgen::Index r = 0; r < rows(a); ++r)
for (rotgen::Index c = 0; c < cols(a); ++c) a(r, c) = a_init_fn(r, c);
for (rotgen::Index r = 0; r < b.rows(); ++r)
for (rotgen::Index c = 0; c < b.cols(); ++c) b(r, c) = b_init_fn(r, c);
for (rotgen::Index r = 0; r < rows(b); ++r)
for (rotgen::Index c = 0; c < cols(b); ++c) b(r, c) = b_init_fn(r, c);
for (rotgen::Index i = 0; i < a.rows(); ++i)
for (rotgen::Index i = 0; i < rows(a); ++i)
{
for (rotgen::Index j = 0; j < b.cols(); ++j)
for (rotgen::Index j = 0; j < cols(b); ++j)
{
ref(i, j) = 0;
for (rotgen::Index k = 0; k < a.cols(); ++k)
for (rotgen::Index k = 0; k < cols(a); ++k)
ref(i, j) += a(i, k) * b(k, j);
}
}
@ -134,9 +134,9 @@ inline constexpr auto init_b = [](auto r, auto c) {
};
inline constexpr auto init_0 = [](auto, auto) { return 0; };
TTS_CASE_TPL("Check matrix addition",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Check matrix addition", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
using mat_t = rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>;
auto op = [](auto a, auto b) { return a + b; };
@ -153,9 +153,9 @@ TTS_CASE_TPL("Check matrix addition",
test_matrix_operations<mat_t>(5, 5, init_a, init_0, op, s_op);
};
TTS_CASE_TPL("Check matrix substraction",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Check matrix substraction", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
using mat_t = rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>;
auto op = [](auto a, auto b) { return a - b; };
@ -172,9 +172,9 @@ TTS_CASE_TPL("Check matrix substraction",
test_matrix_operations<mat_t>(5, 5, init_a, init_0, op, s_op);
};
TTS_CASE_TPL("Check matrix multiplications",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Check matrix multiplications", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
using mat_t = rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>;
auto init_id = [](auto r, auto c) { return r == c ? 1 : 0; };
@ -193,9 +193,9 @@ TTS_CASE_TPL("Check matrix multiplications",
test_matrix_multiplication<mat_t>(5, 5, init_a, init_0);
};
TTS_CASE_TPL("Check matrix multiplication with scalar",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Check matrix multiplication with scalar", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
using mat_t = rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>;
@ -209,9 +209,9 @@ TTS_CASE_TPL("Check matrix multiplication with scalar",
test_scalar_multiplications<mat_t>(1, 10, init_a, T{-0.5});
};
TTS_CASE_TPL("Check matrix division with scalar",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
TTS_CASE_TPL("Check matrix division with scalar", rotgen::tests::types)
<typename T, typename O>(tts::type<tts::types<T, O>>)
{
using mat_t = rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>;
auto op = [](auto a, auto b) { return a / b; };

4
test/unit/meta/ref.cpp
View file

@ -22,7 +22,7 @@ template<typename Ref, typename Generator> void check_acceptance(Generator f)
TTS_EQUAL(v.data(), ptr);
// Setup the data correctly
data.resize(v.rows(), v.cols());
data.resize(rows(v), cols(v));
rotgen::setRandom(data);
// Assign through the ref
@ -34,7 +34,7 @@ template<typename Ref, typename Generator> void check_acceptance(Generator f)
};
acceptor(in, in.data());
data.resize(in.rows(), in.cols());
data.resize(rows(in), cols(in));
TTS_EQUAL(in, data);
TTS_EQUAL(constant_acceptor(in), minCoeff(data)) << in << "\n"