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

Fix a lot of ref issues reagrding extarction, rvalueness and proper use of temporary memory.

Browse source
This commit is contained in:
Joel Falcou 2025-10-28 20:12:33 +01:00
parent d5c41bf43e
commit 379d77ebef
50 changed files with 2945 additions and 1397 deletions
Download patch file Download diff file Expand all files Collapse all files

1
test/CMakeLists.txt
View file

@ -26,6 +26,7 @@ rotgen_glob_unit(QUIET PATTERN "unit/*.cpp" INTERFACE rotgen_test)
rotgen_glob_unit(QUIET PATTERN "unit/matrix/*.cpp" INTERFACE rotgen_test)
rotgen_glob_unit(QUIET PATTERN "unit/block/*.cpp" INTERFACE rotgen_test)
rotgen_glob_unit(QUIET PATTERN "unit/map/*.cpp" INTERFACE rotgen_test)
rotgen_glob_unit(QUIET PATTERN "unit/meta/*.cpp" INTERFACE rotgen_test)
rotgen_glob_unit(QUIET PATTERN "unit/functions/*.cpp" INTERFACE rotgen_test)
##======================================================================================================================

15
test/integration/extract.cpp
View file

@ -5,12 +5,13 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include "unit/tests.hpp"
#include <rotgen/rotgen.hpp>
TTS_CASE_TPL("Chains of extraction",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
#include "unit/tests.hpp"
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();
@ -44,6 +45,9 @@ TTS_CASE_TPL("Chains of extraction",
setConstant(bbbb, 0.125);
TTS_EQUAL(a(3, 3), 0.125);
bool verbose = ::tts::arguments()[{"--verbose"}];
if (verbose) std::cout << a << "\n\n";
};
auto ref_extract(rotgen::ref<rotgen::matrix<float>> m)
@ -66,9 +70,10 @@ TTS_CASE("Extraction of ref/ref const")
for (rotgen::Index r = 0; r < 3; r++)
for (rotgen::Index c = 0; c < 4; c++) TTS_EQUAL(m(r, c), 1.f);
auto sliced = ref_cextract(m);
rotgen::extract(m, 3, 4, 4, 3) =
rotgen::setConstant<rotgen::matrix<float, 4, 3>>(5);
auto sliced = ref_cextract(m);
for (rotgen::Index r = 0; r < 4; r++)
for (rotgen::Index c = 0; c < 3; c++) TTS_EQUAL(sliced(r, c), 5.f);
};

49
test/integration/outer_stride.cpp
View file

@ -5,8 +5,9 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include "unit/tests.hpp"
#include <rotgen/rotgen.hpp>
#include "unit/tests.hpp"
#include <iostream>
TTS_CASE_TPL("outer_stride<0> interactions",
@ -54,49 +55,3 @@ TTS_CASE_TPL("outer_stride<0> interactions",
TTS_EQUAL(dp, sp);
}
};
void process_ref(rotgen::ref<rotgen::matrix<float> const>) {}
void process_ref(rotgen::ref<rotgen::matrix<double> const>) {}
void process_ref(
rotgen::ref<
rotgen::
matrix<float, rotgen::Dynamic, rotgen::Dynamic, rotgen::RowMajor> const>)
{
}
void process_ref(
rotgen::ref<
rotgen::
matrix<double, rotgen::Dynamic, rotgen::Dynamic, rotgen::RowMajor> const>)
{
}
TTS_CASE_TPL("Extraction of outer_stride<?> blocks",
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>;
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);
rotgen::map<mat_t, 0, rotgen::outer_stride<>> dp(&padded[0], 4, 3,
rotgen::outer_stride(5));
TTS_EXPECT_COMPILES(sp, { process_ref(extract(sp, 0, 0, 3, 2)); });
TTS_EXPECT_COMPILES(dp, { process_ref(extract(dp, 0, 0, 3, 2)); });
}
else
{
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);
rotgen::map<mat_t, 0, rotgen::outer_stride<>> dp(&padded[0], 4, 3,
rotgen::outer_stride(4));
TTS_EXPECT_COMPILES(sp, { process_ref(extract(sp, 0, 0, 3, 2)); });
TTS_EXPECT_COMPILES(dp, { process_ref(extract(dp, 0, 0, 3, 2)); });
}
};

34
test/integration/ref_magic.cpp
View file

@ -5,9 +5,10 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include "unit/tests.hpp"
#include <rotgen/rotgen.hpp>
#include "unit/tests.hpp"
template<int size = rotgen::Dynamic,
typename Scalar = float,
int maxSize = size>
@ -63,3 +64,34 @@ TTS_CASE("Reference of reference check")
TTS_EQUAL(v2[0], sum2);
TTS_EQUAL(v3[0], sum3);
};
int f(rotgen::ref<rotgen::matrix<float, 1, 3, rotgen::RowMajor>>)
{
return +2;
}
template<int N>
int g(rotgen::ref<rotgen::matrix<float, -1, N, rotgen::ColMajor>>)
{
return +1;
}
template<int N>
int g(rotgen::ref<rotgen::matrix<float, -1, N, rotgen::RowMajor>>)
requires(N > 1)
{
return -1;
}
TTS_CASE("Reference overload on stroage order check")
{
rotgen::matrix<float> mat_dyn(1, 3);
rotgen::matrix<float, -1, 3, rotgen::ColMajor> mat_col(1, 3);
rotgen::matrix<float, -1, 3, rotgen::RowMajor> mat_row(1, 3);
TTS_EQUAL(f(mat_dyn), +2);
TTS_EQUAL(g<3>(mat_dyn), +1);
TTS_EQUAL(g<3>(mat_col), +1);
TTS_EQUAL(g<3>(mat_row), -1);
};

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

@ -5,9 +5,10 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include "unit/tests.hpp"
#include <rotgen/rotgen.hpp>
#include "unit/tests.hpp"
template<typename EigenType, typename F>
void for_each_element(EigenType const& m, F&& f)
{
@ -137,68 +138,81 @@ void test_dynamic_block_extraction(
auto blocks = std::make_tuple(
// --- CONST TESTS
std::make_tuple(c_block_main, matrix_construct.i0, matrix_construct.j0,
matrix_construct.ni, matrix_construct.nj),
matrix_construct.ni, matrix_construct.nj, rotgen::Dynamic,
rotgen::Dynamic),
std::make_tuple(c_block_top_left_corner, 0, 0, matrix_construct.ni,
matrix_construct.nj),
matrix_construct.nj, rotgen::Dynamic, rotgen::Dynamic),
std::make_tuple(c_block_top_right_corner, 0,
matrix.cols() - matrix_construct.nj, matrix_construct.ni,
matrix_construct.nj),
matrix_construct.nj, rotgen::Dynamic, rotgen::Dynamic),
std::make_tuple(c_block_bottom_left_corner,
matrix.rows() - matrix_construct.ni, 0, matrix_construct.ni,
matrix_construct.nj),
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,
matrix_construct.nj),
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, matrix.cols(),
rotgen::Dynamic, MatrixType::ColsAtCompileTime),
std::make_tuple(c_block_middle_rows, matrix_construct.i0, 0,
matrix_construct.ni, matrix.cols()),
matrix_construct.ni, matrix.cols(), rotgen::Dynamic,
MatrixType::ColsAtCompileTime),
std::make_tuple(c_block_bottom_rows, matrix.rows() - matrix_construct.ni, 0,
matrix_construct.ni, matrix.cols()),
std::make_tuple(c_block_left_cols, 0, 0, matrix.rows(),
matrix_construct.nj),
matrix_construct.ni, matrix.cols(), rotgen::Dynamic,
MatrixType::ColsAtCompileTime),
std::make_tuple(c_block_left_cols, 0, 0, matrix.rows(), matrix_construct.nj,
MatrixType::RowsAtCompileTime, rotgen::Dynamic),
std::make_tuple(c_block_middle_cols, 0, matrix_construct.j0, matrix.rows(),
matrix_construct.nj),
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),
matrix.rows(), matrix_construct.nj,
MatrixType::RowsAtCompileTime, rotgen::Dynamic),
// --- REGULAR TESTS
std::make_tuple(block_main, matrix_construct.i0, matrix_construct.j0,
matrix_construct.ni, matrix_construct.nj),
matrix_construct.ni, matrix_construct.nj, rotgen::Dynamic,
rotgen::Dynamic),
std::make_tuple(block_top_left_corner, 0, 0, matrix_construct.ni,
matrix_construct.nj),
matrix_construct.nj, rotgen::Dynamic, rotgen::Dynamic),
std::make_tuple(block_top_right_corner, 0,
matrix.cols() - matrix_construct.nj, matrix_construct.ni,
matrix_construct.nj),
matrix_construct.nj, rotgen::Dynamic, rotgen::Dynamic),
std::make_tuple(block_bottom_left_corner,
matrix.rows() - matrix_construct.ni, 0, matrix_construct.ni,
matrix_construct.nj),
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,
matrix_construct.nj),
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, matrix.cols(),
rotgen::Dynamic, MatrixType::ColsAtCompileTime),
std::make_tuple(block_middle_rows, matrix_construct.i0, 0,
matrix_construct.ni, matrix.cols()),
matrix_construct.ni, matrix.cols(), rotgen::Dynamic,
MatrixType::ColsAtCompileTime),
std::make_tuple(block_bottom_rows, matrix.rows() - matrix_construct.ni, 0,
matrix_construct.ni, matrix.cols()),
std::make_tuple(block_left_cols, 0, 0, matrix.rows(), matrix_construct.nj),
matrix_construct.ni, matrix.cols(), rotgen::Dynamic,
MatrixType::ColsAtCompileTime),
std::make_tuple(block_left_cols, 0, 0, matrix.rows(), matrix_construct.nj,
MatrixType::RowsAtCompileTime, rotgen::Dynamic),
std::make_tuple(block_middle_cols, 0, matrix_construct.j0, matrix.rows(),
matrix_construct.nj),
matrix_construct.nj, MatrixType::RowsAtCompileTime,
rotgen::Dynamic),
std::make_tuple(block_right_cols, 0, matrix.cols() - matrix_construct.nj,
matrix.rows(), matrix_construct.nj));
matrix.rows(), matrix_construct.nj,
MatrixType::RowsAtCompileTime, rotgen::Dynamic));
std::apply(
[&](auto&&... block_entries) {
(([&] {
auto&& [block, i_offset, j_offset, ni, nj] = block_entries;
auto&& [block, i_offset, j_offset, ni, nj, rows_ct, cols_ct] =
block_entries;
using block_t = std::remove_reference_t<decltype(block)>;
TTS_EQUAL(block_t::RowsAtCompileTime, rotgen::Dynamic);
TTS_EQUAL(block_t::ColsAtCompileTime, rotgen::Dynamic);
TTS_EQUAL(block_t::RowsAtCompileTime, rows_ct);
TTS_EQUAL(block_t::ColsAtCompileTime, cols_ct);
TTS_EQUAL(block_t::storage_order, MatrixType::storage_order);
validate_block_behavior(matrix, block, i_offset, j_offset, ni, nj);
@ -346,7 +360,7 @@ TTS_CASE_TPL(
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, 1>;
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, rotgen::RowMajor>;
std::vector<rotgen::tests::matrix_block_test_case<mat_t>> cases = {
{{6, 11, [](rotgen::Index i, rotgen::Index j) { return T(i * 10 + j); }},
@ -381,7 +395,7 @@ 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>>)
{
using mat_t = rotgen::matrix<T, 4, 5, O::value, 0>;
using mat_t = rotgen::matrix<T, 4, 5, rotgen::ColMajor>;
std::vector<rotgen::tests::matrix_block_test_case<mat_t>> cases = {
{{4, 5, [](auto i, auto j) { return T(2 * i + j * j * j - 42); }},
@ -447,7 +461,7 @@ TTS_CASE_TPL("Check vector-only extractions",
if constexpr (O::value == rotgen::RowMajor)
{
using mat_t = rotgen::matrix<T, 1, rotgen::Dynamic, O::value>;
using mat_t = rotgen::matrix<T, 1, rotgen::Dynamic>;
mat_t m(1, 11);
for (rotgen::Index i = 0; i < 11; ++i) m(i) = 1 + i;
@ -473,7 +487,7 @@ TTS_CASE_TPL("Check vector-only extractions",
}
else
{
using mat_t = rotgen::matrix<T, rotgen::Dynamic, 1, O::value>;
using mat_t = rotgen::matrix<T, rotgen::Dynamic, 1>;
mat_t m(11, 1);
for (rotgen::Index i = 0; i < 11; ++i) m(i) = 1 + i;

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

@ -5,10 +5,11 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include "unit/tests.hpp"
#include <rotgen/rotgen.hpp>
#include <vector>
#include "unit/tests.hpp"
#include <Eigen/Core>
#include <vector>
auto generate_data(int rows, int cols)
{
@ -26,7 +27,7 @@ using r_mat_t = rotgen::matrix<float, rotgen::Dynamic, rotgen::Dynamic, O>;
template<int O>
using e_mat_t = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, O>;
template<typename M, typename S = rotgen::stride>
template<typename M, typename S = rotgen::stride<0, 0>>
using r_map_t = rotgen::map<M, 0, S>;
template<typename M, typename S = Eigen::Stride<0, 0>>
using e_map_t = Eigen::Map<M, 0, S>;
@ -56,7 +57,7 @@ TTS_CASE("Validate Column Major Map with specific outer stride behavior")
auto buffer = generate_data(rows, cols);
r_map_t<r_mat_t<rotgen::ColMajor>, rotgen::outer_stride<>> r_map(
buffer.data(), rows, cols, rotgen::outer_stride(rows + 1));
buffer.data(), rows, cols, rotgen::outer_stride<>(rows + 1));
TTS_EQUAL(r_map.innerStride(), 1);
TTS_EQUAL(r_map.outerStride(), 4);
@ -75,8 +76,8 @@ TTS_CASE("Validate Column Major Map with specific inner stride behavior")
auto cols = 4;
auto buffer = generate_data(rows, cols);
r_map_t<r_mat_t<rotgen::ColMajor>> r_map(buffer.data(), rows, cols,
rotgen::stride(rows, 2));
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);
@ -116,7 +117,7 @@ TTS_CASE("Validate Row Major Map with specific outer stride behavior")
auto buffer = generate_data(rows, cols);
r_map_t<r_mat_t<rotgen::RowMajor>, rotgen::outer_stride<>> r_map(
buffer.data(), rows, cols, rotgen::outer_stride(cols + 1));
buffer.data(), rows, cols, rotgen::outer_stride<>(cols + 1));
TTS_EQUAL(r_map.innerStride(), 1);
TTS_EQUAL(r_map.outerStride(), 5);
@ -135,8 +136,8 @@ TTS_CASE("Validate Row Major Map with specific inner stride behavior")
auto cols = 4;
auto buffer = generate_data(rows, cols);
r_map_t<r_mat_t<rotgen::RowMajor>, rotgen::stride> r_map(
buffer.data(), rows, cols, rotgen::stride(2, cols));
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);

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

@ -5,12 +5,13 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include "unit/tests.hpp"
#include <rotgen/rotgen.hpp>
TTS_CASE_TPL("Default matrix dynamic constructor",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
#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;
@ -18,9 +19,9 @@ TTS_CASE_TPL("Default matrix dynamic constructor",
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>>)
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;
@ -29,8 +30,9 @@ TTS_CASE_TPL("Default matrix static constructor",
};
TTS_CASE_TPL("Dynamic matrix constructor with row and columns",
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>>)
{
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> matrix(10, 5);
@ -38,12 +40,12 @@ TTS_CASE_TPL("Dynamic matrix constructor with row and columns",
TTS_EQUAL(matrix.cols(), rotgen::Index{5});
};
TTS_CASE_TPL("Static matrix constructor with row and columns",
float,
double)<typename T>(tts::type<T>)
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);
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});
@ -51,8 +53,8 @@ TTS_CASE_TPL("Static matrix constructor with row and columns",
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);
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});
@ -64,8 +66,9 @@ TTS_CASE_TPL("Static matrix constructor with row and columns",
};
TTS_CASE_TPL("Copy constructor produces identical but independent 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>>)
{
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> a(3, 3);
@ -88,9 +91,9 @@ TTS_CASE_TPL("Copy constructor produces identical but independent matrix",
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>>)
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;
@ -98,9 +101,9 @@ TTS_CASE_TPL("Copy constructor on default matrix",
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>>)
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;
@ -108,9 +111,9 @@ TTS_CASE_TPL("Copy constructor from const matrix",
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>>)
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;
@ -118,9 +121,9 @@ TTS_CASE_TPL("Copy constructor on static matrix",
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>>)
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;
@ -128,9 +131,9 @@ TTS_CASE_TPL("Copy constructor on static/dynamic matrix",
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>>)
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;
@ -138,9 +141,9 @@ TTS_CASE_TPL("Copy constructor on dynamic/static matrix",
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>>)
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;
@ -155,9 +158,9 @@ TTS_CASE_TPL("Move constructor transfers contents",
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>>)
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);
@ -165,9 +168,9 @@ TTS_CASE_TPL("Move constructor from Rvalue",
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>>)
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});
@ -193,9 +196,9 @@ TTS_CASE_TPL("Constructor from Initializer list",
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>>)
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});

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

@ -7,7 +7,6 @@
//==================================================================================================
#include <rotgen/rotgen.hpp>
#include "unit/common/arithmetic.hpp"
#include "unit/tests.hpp"
TTS_CASE_TPL("Test dynamic matrix inverse",
@ -17,52 +16,50 @@ TTS_CASE_TPL("Test dynamic matrix inverse",
using mat_t = rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>;
auto eps = std::numeric_limits<T>::epsilon();
auto const cases = rotgen::tests::generate_matrix_references();
for (auto const& [r, c, fn] : cases)
for (int n = 2; n < 15; n *= 1.5)
{
if (r == c)
{
auto input = mat_t::Random(r, c);
auto inv = rotgen::inverse(input);
auto input = 10 * rotgen::setRandom<mat_t>(n, n);
auto inv = rotgen::inverse(input);
auto rec = input * inv;
auto id = mat_t::Identity(rotgen::rows(rec), rotgen::cols(rec));
auto error = rec - id;
auto rec = input * inv;
auto id = mat_t::Identity(rotgen::rows(rec), rotgen::cols(rec));
auto error = rec - id;
TTS_LESS_EQUAL(rotgen::maxCoeff(rotgen::abs(error)) / eps, 64.)
<< "Result:\n"
<< rec << "\n"
<< "Residuals:\n"
<< error << "\n";
}
TTS_LESS_EQUAL(rotgen::maxCoeff(rotgen::abs(error)) / eps, 256.)
<< "Result:\n"
<< rec << "\n"
<< "Residuals:\n"
<< error << "\n";
}
};
template<typename T, typename O, int N> void check_static_inverse()
{
using mat_t = rotgen::matrix<T, N, N, O::value>;
auto eps = std::numeric_limits<T>::epsilon();
auto input = rotgen::setRandom<mat_t>();
auto inv = rotgen::inverse(input);
auto rec = input * inv;
auto id = mat_t::Identity(rotgen::rows(rec), rotgen::cols(rec));
auto error = rec - id;
TTS_LESS_EQUAL(rotgen::maxCoeff(rotgen::abs(error)) / eps, 256.)
<< "Result:\n"
<< rec << "\n"
<< "Residuals:\n"
<< error << "\n";
}
TTS_CASE_TPL("Test static 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();
auto const cases = rotgen::tests::generate_static_matrix_references();
auto process = [&]<typename D>(D const&) {
if constexpr (D::rows == D::cols)
{
auto input = rotgen::matrix<T, D::rows, D::cols, O::value>::Random();
auto inv = rotgen::inverse(input);
auto rec = input * inv;
auto id = mat_t::Identity(rotgen::rows(rec), rotgen::cols(rec));
auto error = rec - id;
TTS_LESS_EQUAL(rotgen::maxCoeff(rotgen::abs(error)) / eps, 64.)
<< "Result:\n"
<< rec << "\n"
<< "Residuals:\n"
<< error << "\n";
}
};
std::apply([&](auto const&... d) { (process(d), ...); }, cases);
check_static_inverse<T, O, 2>();
check_static_inverse<T, O, 3>();
check_static_inverse<T, O, 4>();
check_static_inverse<T, O, 6>();
check_static_inverse<T, O, 9>();
check_static_inverse<T, O, 13>();
};

211
test/unit/meta/properties.cpp Normal file
View file

@ -0,0 +1,211 @@
//==================================================================================================
/*
ROTGEN - Runtime Overlay for Eigen
Copyright : CODE RECKONS
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include <rotgen/rotgen.hpp>
#include "unit/tests.hpp"
#include <Eigen/Core>
template<typename RType, typename EType> void check_size_properties()
{
TTS_CONSTEXPR_EQUAL(RType::RowsAtCompileTime, EType::RowsAtCompileTime)
<< tts::typename_<RType> << " vs " << tts::typename_<EType> << "\n";
TTS_CONSTEXPR_EQUAL(RType::ColsAtCompileTime, EType::ColsAtCompileTime)
<< tts::typename_<RType> << " vs " << tts::typename_<EType> << "\n";
TTS_CONSTEXPR_EQUAL(RType::MaxRowsAtCompileTime, EType::MaxRowsAtCompileTime)
<< tts::typename_<RType> << " vs " << tts::typename_<EType> << "\n";
TTS_CONSTEXPR_EQUAL(RType::MaxColsAtCompileTime, EType::MaxColsAtCompileTime)
<< tts::typename_<RType> << " vs " << tts::typename_<EType> << "\n";
TTS_CONSTEXPR_EQUAL(RType::IsVectorAtCompileTime,
EType::IsVectorAtCompileTime)
<< tts::typename_<RType> << " vs " << tts::typename_<EType> << "\n";
TTS_CONSTEXPR_EQUAL(RType::InnerStrideAtCompileTime,
EType::InnerStrideAtCompileTime)
<< tts::typename_<RType> << " vs " << tts::typename_<EType> << "\n";
TTS_CONSTEXPR_EQUAL(RType::OuterStrideAtCompileTime,
EType::OuterStrideAtCompileTime)
<< tts::typename_<RType> << " vs " << tts::typename_<EType> << "\n";
}
TTS_CASE("Compile-Time informations conformance w/r to Eigen - matrix")
{
using namespace rotgen;
using namespace Eigen;
check_size_properties<matrixXf, MatrixXf>();
check_size_properties<matrix<float, -1, -1, 0, 3, 3>,
Matrix<float, -1, -1, 0, 3, 3>>();
check_size_properties<matrix<float, 4, 9>, Matrix<float, 4, 9>>();
check_size_properties<vector4f, Vector4f>();
check_size_properties<matrix<float, 1, -1>, Matrix<float, 1, -1>>();
check_size_properties<row_vector4f, RowVector4f>();
check_size_properties<matrix<float, -1, 1>, Matrix<float, -1, 1>>();
// RowMajor / ColMajor
{
TTS_CONSTEXPR_EQUAL(matrixXf::IsRowMajor, MatrixXf::IsRowMajor);
TTS_CONSTEXPR_EQUAL((matrix<float, -1, -1, rotgen::RowMajor>::IsRowMajor),
(Matrix<float, -1, -1, Eigen::RowMajor>::IsRowMajor));
TTS_CONSTEXPR_EQUAL((matrix<float, -1, 7, rotgen::RowMajor>::IsRowMajor),
(Matrix<float, -1, 7, Eigen::RowMajor>::IsRowMajor));
TTS_CONSTEXPR_EQUAL((matrix<float, 7, -1, rotgen::RowMajor>::IsRowMajor),
(Matrix<float, 7, -1, Eigen::RowMajor>::IsRowMajor));
TTS_CONSTEXPR_EQUAL((matrix<float, 9, 1>::IsRowMajor),
(Matrix<float, 9, 1>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(row_vectorXf::IsRowMajor, RowVectorXf::IsRowMajor);
TTS_CONSTEXPR_EQUAL((matrix<float, 1, 9>::IsRowMajor),
(Matrix<float, 1, 9>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(vectorXf::IsRowMajor, VectorXf::IsRowMajor);
}
};
TTS_CASE("Compile-Time informations conformance w/r to Eigen - map")
{
using namespace rotgen;
using namespace Eigen;
check_size_properties<map<matrixXf>, Map<MatrixXf>>();
check_size_properties<map<matrix<float, -1, -1, 0, 3, 3>>,
Map<Matrix<float, -1, -1, 0, 3, 3>>>();
check_size_properties<map<matrix<float, -1, -1, 0, 3, 3>>,
Map<Matrix<float, -1, -1, 0, 3, 3>>>();
check_size_properties<map<matrix<float, 4, 9>>, Map<Matrix<float, 4, 9>>>();
check_size_properties<map<vector4f>, Map<Vector4f>>();
check_size_properties<map<matrix<float, 1, -1>>, Map<Matrix<float, 1, -1>>>();
check_size_properties<map<row_vector4f>, Map<RowVector4f>>();
check_size_properties<map<matrix<float, -1, 1>>, Map<Matrix<float, -1, 1>>>();
// Row/Col Major
{
TTS_CONSTEXPR_EQUAL((map<matrixXf>::IsRowMajor),
(Map<MatrixXf>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(
(map<matrix<float, -1, -1, rotgen::RowMajor>>::IsRowMajor),
(Map<Matrix<float, -1, -1, Eigen::RowMajor>>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(
(map<matrix<float, -1, -1, rotgen::ColMajor>>::IsRowMajor),
(Map<Matrix<float, -1, -1, Eigen::ColMajor>>::IsRowMajor));
TTS_CONSTEXPR_EQUAL((map<vectorXf>::IsRowMajor),
(Map<VectorXf>::IsRowMajor));
TTS_CONSTEXPR_EQUAL((map<row_vectorXf>::IsRowMajor),
(Map<RowVectorXf>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(
(map<matrix<float, -1, 5, rotgen::RowMajor>>::IsRowMajor),
(Map<Matrix<float, -1, 5, Eigen::RowMajor>>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(
(map<matrix<float, -1, 7, rotgen::ColMajor>>::IsRowMajor),
(Map<Matrix<float, -1, 7, Eigen::ColMajor>>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(
(map<matrix<float, 5, -1, rotgen::RowMajor>>::IsRowMajor),
(Map<Matrix<float, 5, -1, Eigen::RowMajor>>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(
(map<matrix<float, 7, -1, rotgen::ColMajor>>::IsRowMajor),
(Map<Matrix<float, 7, -1, Eigen::ColMajor>>::IsRowMajor));
}
};
TTS_CASE("Compile-Time informations conformance w/r to Eigen - block")
{
using namespace rotgen;
using namespace Eigen;
check_size_properties<block<matrixXf>, Block<MatrixXf>>();
check_size_properties<block<matrix<float, 2, 4>>,
Block<Matrix<float, 2, 4>>>();
check_size_properties<block<matrixXf, 3, 6>, Block<MatrixXf, 3, 6>>();
check_size_properties<block<matrix<float, 8, 8>, 3, 6>,
Block<Matrix<float, 8, 8>, 3, 6>>();
check_size_properties<block<matrixXf, 1, 6>, Block<MatrixXf, 1, 6>>();
check_size_properties<block<matrix<float, 8, 8>, 1, 6>,
Block<Matrix<float, 8, 8>, 1, 6>>();
check_size_properties<block<matrixXf, 7, 1>, Block<MatrixXf, 7, 1>>();
check_size_properties<block<matrix<float, 8, 8>, 7, 1>,
Block<Matrix<float, 8, 8>, 7, 1>>();
check_size_properties<block<map<matrixXf>>, Block<Map<MatrixXf>>>();
check_size_properties<block<map<matrix<float, 2, 4>>>,
Block<Map<Matrix<float, 2, 4>>>>();
check_size_properties<block<map<matrixXf>, 3, 6>,
Block<Map<MatrixXf>, 3, 6>>();
check_size_properties<block<map<matrix<float, 8, 8>>, 3, 6>,
Block<Map<Matrix<float, 8, 8>>, 3, 6>>();
check_size_properties<block<map<matrixXf>, 1, 6>,
Block<Map<MatrixXf>, 1, 6>>();
check_size_properties<block<map<matrix<float, 8, 8>>, 1, 6>,
Block<Map<Matrix<float, 8, 8>>, 1, 6>>();
check_size_properties<block<map<matrixXf>, 7, 1>,
Block<Map<MatrixXf>, 7, 1>>();
check_size_properties<block<map<matrix<float, 8, 8>>, 7, 1>,
Block<Map<Matrix<float, 8, 8>>, 7, 1>>();
// Row/Col Major
{
TTS_CONSTEXPR_EQUAL((block<matrixXf>::IsRowMajor),
(Block<MatrixXf>::IsRowMajor));
TTS_CONSTEXPR_EQUAL((block<matrixXf, 1, 8>::IsRowMajor),
(Block<MatrixXf, 1, 8>::IsRowMajor));
TTS_CONSTEXPR_EQUAL((block<matrixXf, 8, 1>::IsRowMajor),
(Block<MatrixXf, 8, 1>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(
(block<matrix<float, -1, -1, rotgen::RowMajor>>::IsRowMajor),
(Block<Matrix<float, -1, -1, Eigen::RowMajor>>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(
(block<matrix<float, -1, -1, rotgen::ColMajor>>::IsRowMajor),
(Block<Matrix<float, -1, -1, Eigen::ColMajor>>::IsRowMajor));
TTS_CONSTEXPR_EQUAL((block<vectorXf>::IsRowMajor),
(Block<VectorXf>::IsRowMajor));
TTS_CONSTEXPR_EQUAL((block<row_vectorXf>::IsRowMajor),
(Block<RowVectorXf>::IsRowMajor));
TTS_CONSTEXPR_EQUAL((block<vectorXf, 1, 8>::IsRowMajor),
(Block<VectorXf, 1, 8>::IsRowMajor));
TTS_CONSTEXPR_EQUAL((block<row_vectorXf, 8, 1>::IsRowMajor),
(Block<RowVectorXf, 8, 1>::IsRowMajor));
}
};
TTS_CASE("Compile-Time informations conformance w/r to Eigen - ref")
{
using namespace rotgen;
using namespace Eigen;
check_size_properties<ref<matrixXf>, Ref<MatrixXf>>();
check_size_properties<ref<matrix<float, -1, -1, 0, 3, 3>>,
Ref<Matrix<float, -1, -1, 0, 3, 3>>>();
check_size_properties<ref<matrix<float, 4, 9>>, Ref<Matrix<float, 4, 9>>>();
check_size_properties<ref<vector4f>, Ref<Vector4f>>();
check_size_properties<ref<matrix<float, 1, -1>>, Ref<Matrix<float, 1, -1>>>();
check_size_properties<ref<row_vector4f>, Ref<RowVector4f>>();
check_size_properties<ref<matrix<float, -1, 1>>, Ref<Matrix<float, -1, 1>>>();
// Row/Col Major
{
TTS_CONSTEXPR_EQUAL((ref<matrixXf>::IsRowMajor),
(Ref<MatrixXf>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(
(ref<matrix<float, -1, -1, rotgen::RowMajor>>::IsRowMajor),
(Ref<Matrix<float, -1, -1, Eigen::RowMajor>>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(
(ref<matrix<float, -1, -1, rotgen::ColMajor>>::IsRowMajor),
(Ref<Matrix<float, -1, -1, Eigen::ColMajor>>::IsRowMajor));
TTS_CONSTEXPR_EQUAL((ref<vectorXf>::IsRowMajor),
(Ref<VectorXf>::IsRowMajor));
TTS_CONSTEXPR_EQUAL((ref<row_vectorXf>::IsRowMajor),
(Ref<RowVectorXf>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(
(ref<matrix<float, -1, 5, rotgen::RowMajor>>::IsRowMajor),
(Ref<Matrix<float, -1, 5, Eigen::RowMajor>>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(
(ref<matrix<float, -1, 7, rotgen::ColMajor>>::IsRowMajor),
(Ref<Matrix<float, -1, 7, Eigen::ColMajor>>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(
(ref<matrix<float, 5, -1, rotgen::RowMajor>>::IsRowMajor),
(Ref<Matrix<float, 5, -1, Eigen::RowMajor>>::IsRowMajor));
TTS_CONSTEXPR_EQUAL(
(ref<matrix<float, 7, -1, rotgen::ColMajor>>::IsRowMajor),
(Ref<Matrix<float, 7, -1, Eigen::ColMajor>>::IsRowMajor));
}
};

193
test/unit/meta/ref.cpp Normal file
View file

@ -0,0 +1,193 @@
//==================================================================================================
/*
ROTGEN - Runtime Overlay for Eigen
Copyright : CODE RECKONS
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include <rotgen/rotgen.hpp>
#include "unit/tests.hpp"
using row_matrixXf = rotgen::matrix<float, -1, -1, rotgen::RowMajor>;
template<typename Ref, typename Generator> void check_acceptance(Generator f)
{
auto in = f();
rotgen::matrixXf data;
bool verbose = ::tts::arguments()[{"--verbose"}];
auto acceptor = [&](rotgen::ref<Ref> v, auto ptr) {
// Check that ref is not a copy
TTS_EQUAL(v.data(), ptr);
// Setup the data correctly
data.resize(v.rows(), v.cols());
rotgen::setRandom(data);
// Assign through the ref
v = data;
if (verbose) std::cout << "V:\n" << v << std::endl << std::endl;
};
auto constant_acceptor = [&](rotgen::ref<Ref const> v) {
return minCoeff(v);
};
acceptor(in, in.data());
data.resize(in.rows(), in.cols());
TTS_EQUAL(in, data);
TTS_EQUAL(constant_acceptor(in), minCoeff(data)) << in << "\n"
<< data << "\n";
}
TTS_CASE_TPL("Assert ref construction rules - Vector cases",
rotgen::vectorXf,
rotgen::vector2f,
rotgen::row_vectorXf,
rotgen::row_vector2f)
<typename T>(::tts::type<T>)
{
TTS_WHEN("Call a function accepting a ref<" << ::tts::typename_<T> << "> ...")
{
rotgen::matrixXf mc(2, 1);
rotgen::vectorXf vc(2);
rotgen::matrixXf mr(1, 2);
row_matrixXf mrr(1, 2);
rotgen::row_vectorXf vr(2);
rotgen::vector2f vcf;
rotgen::row_vector2f vrf;
TTS_AND_THEN("with a vector-like matrix")
{
check_acceptance<T>([&]() { return mc; });
check_acceptance<T>([&]() { return vc; });
check_acceptance<T>([&]() { return mr; });
check_acceptance<T>([&]() { return mrr; });
check_acceptance<T>([&]() { return vr; });
check_acceptance<T>([&]() { return vcf; });
check_acceptance<T>([&]() { return vrf; });
}
TTS_AND_THEN("with a vector-like block")
{
check_acceptance<T>([&]() { return rotgen::head(vc, 2); });
check_acceptance<T>([&]() { return rotgen::head(vr, 2); });
check_acceptance<T>([&]() { return rotgen::head(vcf, 2); });
check_acceptance<T>([&]() { return rotgen::head(vrf, 2); });
check_acceptance<T>([&]() { return rotgen::head<2>(vc); });
check_acceptance<T>([&]() { return rotgen::head<2>(vr); });
check_acceptance<T>([&]() { return rotgen::head<2>(vcf); });
check_acceptance<T>([&]() { return rotgen::head<2>(vrf); });
}
TTS_AND_THEN("with a vector-like map")
{
rotgen::map<rotgen::matrixXf> mmc(vc.data(), 2, 1);
rotgen::map<rotgen::matrixXf> mmr(vc.data(), 1, 2);
rotgen::map<row_matrixXf> mmrr(vc.data(), 1, 2);
rotgen::map<rotgen::vectorXf> mvc(vc.data(), vc.size());
rotgen::map<rotgen::row_vectorXf> mvr(vr.data(), vr.size());
rotgen::map<rotgen::vector2f> mvcf(vc.data());
rotgen::map<rotgen::row_vector2f> mvrf(vr.data());
check_acceptance<T>([&]() { return mmc; });
check_acceptance<T>([&]() { return mvc; });
check_acceptance<T>([&]() { return mvr; });
check_acceptance<T>([&]() { return mmr; });
check_acceptance<T>([&]() { return mmrr; });
check_acceptance<T>([&]() { return mvcf; });
check_acceptance<T>([&]() { return mvrf; });
}
TTS_AND_THEN("with a vector-like ref")
{
rotgen::ref<row_matrixXf> mmrr(mrr);
rotgen::ref<rotgen::vectorXf> mvc(mc);
rotgen::ref<rotgen::row_vectorXf> mvr(mc);
rotgen::ref<rotgen::vector2f> mvcf(mc);
rotgen::ref<rotgen::row_vector2f> mvrf(mc);
check_acceptance<T>([&]() { return mvc; });
check_acceptance<T>([&]() { return mvr; });
check_acceptance<T>([&]() { return mmrr; });
check_acceptance<T>([&]() { return mvcf; });
check_acceptance<T>([&]() { return mvrf; });
}
}
};
TTS_CASE("Assert ref construction rules Matrix cases")
{
using MatC = rotgen::matrix<float, -1, -1, rotgen::ColMajor>;
using MatR = rotgen::matrix<float, -1, -1, rotgen::RowMajor>;
TTS_WHEN("Call a function accepting a ref<"
<< ::tts::typename_<MatC> << "> ...")
{
rotgen::matrixXf mc(2, 1);
rotgen::matrixXf mr(1, 2);
rotgen::matrixXf mn(4, 2);
row_matrixXf mnr(4, 2);
rotgen::matrix<float, 2, 1> mcf(2, 1);
rotgen::matrix<float, 1, 2> mrf(1, 2);
rotgen::matrix<float, 4, 2> mnf(4, 2);
TTS_AND_THEN("with a matrix")
{
check_acceptance<MatC>([&]() { return mc; });
check_acceptance<MatC>([&]() { return mr; });
check_acceptance<MatC>([&]() { return mn; });
check_acceptance<MatC>([&]() { return mcf; });
check_acceptance<MatC>([&]() { return mrf; });
check_acceptance<MatC>([&]() { return mnf; });
TTS_EXPECT_COMPILES(mnr, { rotgen::ref<MatC const>{mnr}; });
}
TTS_AND_THEN("with a map")
{
rotgen::map<rotgen::matrixXf> mmc(mc.data(), 2, 1);
rotgen::map<rotgen::matrixXf> mmr(mc.data(), 1, 2);
rotgen::map<row_matrixXf> mmrr(mc.data(), 1, 2);
rotgen::map<row_matrixXf> mmnr(mnr.data(), 4, 2);
rotgen::map<rotgen::vectorXf> mvc(mc.data(), mc.size());
rotgen::map<rotgen::row_vectorXf> mvr(mr.data(), mr.size());
rotgen::map<rotgen::vector2f> mvcf(mc.data());
rotgen::map<rotgen::row_vector2f> mvrf(mr.data());
check_acceptance<MatC>([&]() { return mmc; });
check_acceptance<MatC>([&]() { return mmr; });
check_acceptance<MatC>([&]() { return mvc; });
check_acceptance<MatC>([&]() { return mvr; });
check_acceptance<MatC>([&]() { return mvcf; });
check_acceptance<MatC>([&]() { return mvrf; });
TTS_EXPECT_COMPILES(mmnr, { rotgen::ref<MatC const>{mmnr}; });
TTS_EXPECT_COMPILES(mmrr, { rotgen::ref<MatC const>{mmrr}; });
}
}
TTS_WHEN("Call a function accepting a ref<"
<< ::tts::typename_<MatR> << "> ...")
{
row_matrixXf mc(2, 1);
row_matrixXf mr(1, 2);
row_matrixXf mn(4, 2);
rotgen::matrix<float, 2, 1> mcf(2, 1);
rotgen::matrix<float, 1, 2> mrf(1, 2);
rotgen::matrix<float, 4, 2, rotgen::RowMajor> mnf(4, 2);
TTS_AND_THEN("with a matrix")
{
check_acceptance<MatR>([&]() { return mc; });
check_acceptance<MatR>([&]() { return mr; });
check_acceptance<MatR>([&]() { return mn; });
check_acceptance<MatR>([&]() { return mcf; });
check_acceptance<MatR>([&]() { return mrf; });
check_acceptance<MatR>([&]() { return mnf; });
}
}
};