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

Merge branch 'functional-unit-tests' into 'main'

Browse source 
Testing functional API only (oss/rotgen#17)

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

See merge request oss/rotgen!42
This commit is contained in:
Jules Pénuchot 2025-10-17 17:20:47 +02:00
commit ee7f86721c
11 changed files with 192 additions and 192 deletions
Download patch file Download diff file Expand all files Collapse all files

25
include/rotgen/functions/functions.hpp
View file

@ -218,17 +218,20 @@ namespace rotgen
//-----------------------------------------------------------------------------------------------
// Reductions
//-----------------------------------------------------------------------------------------------
auto trace(concepts::entity auto const& arg)
auto trace(auto const& arg)
requires requires { arg.trace(); }
{
return arg.trace();
}
auto squaredNorm(concepts::entity auto const& arg)
auto squaredNorm(auto const& arg)
requires requires { arg.squaredNorm(); }
{
return arg.squaredNorm();
}
auto norm(concepts::entity auto const& arg)
auto norm(auto const& arg)
requires requires { arg.norm(); }
{
return arg.norm();
}
@ -239,12 +242,14 @@ namespace rotgen
return arg.sum();
}
auto prod(concepts::entity auto const& arg)
auto prod(auto const& arg)
requires requires { arg.prod(); }
{
return arg.prod();
}
auto mean(concepts::entity auto const& arg)
auto mean(auto const& arg)
requires requires { arg.mean(); }
{
return arg.mean();
}
@ -272,17 +277,15 @@ namespace rotgen
}
template<std::integral IndexType>
auto maxCoeff(concepts::entity auto const& arg,
IndexType* row,
IndexType* col)
auto maxCoeff(auto const& arg, IndexType* row, IndexType* col)
requires(requires { arg.maxCoeff(row, col); })
{
return arg.maxCoeff(row, col);
}
template<std::integral IndexType>
auto minCoeff(concepts::entity auto const& arg,
IndexType* row,
IndexType* col)
auto minCoeff(auto const& arg, IndexType* row, IndexType* col)
requires(requires { arg.minCoeff(row, col); })
{
return arg.minCoeff(row, col);
}

5
test/CMakeLists.txt
View file

@ -14,6 +14,11 @@ target_compile_options(rotgen_test INTERFACE -std=c++20 -Werror -Wall -Wextra -W
target_include_directories( rotgen_test INTERFACE ${PROJECT_SOURCE_DIR}/test)
target_link_libraries(rotgen_test INTERFACE rotgen Eigen3::Eigen)
target_compile_definitions(rotgen_test INTERFACE
TTS_MAIN
TTS_CUSTOM_DRIVER_FUNCTION=rotgen_main
)
##======================================================================================================================
## Unit Tests registration
##======================================================================================================================

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

@ -5,9 +5,11 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include "unit/tests.hpp"
#include <rotgen/rotgen.hpp>
#include "rotgen/functions/functions.hpp"
#include "unit/tests.hpp"
void test_value(auto const& matrix,
auto value,
rotgen::Index i0,
@ -57,7 +59,7 @@ TTS_CASE_TPL("Test dynamic block::setZero",
rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract(m, i0, j0, ni, nj);
input.setZero();
rotgen::setZero(input);
test_value(m, T{0}, i0, j0, ni, nj);
using input_type = decltype(rotgen::extract(m, i0, j0, ni, nj));
@ -66,7 +68,7 @@ TTS_CASE_TPL("Test dynamic block::setZero",
}
};
TTS_CASE_TPL("Test static block:setZero",
TTS_CASE_TPL("Test static block::setZero",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
{
@ -80,7 +82,7 @@ TTS_CASE_TPL("Test static block:setZero",
rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract<D::ni, D::nj>(m, i0, j0);
input.setZero();
rotgen::setZero(input);
test_value(m, T{0}, i0, j0, D::ni, D::nj);
using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0));
@ -103,7 +105,7 @@ TTS_CASE_TPL("Test dynamic block::setOnes",
rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract(m, i0, j0, ni, nj);
input.setOnes();
rotgen::setOnes(input);
test_value(m, T{1}, i0, j0, ni, nj);
using input_type = decltype(rotgen::extract(m, i0, j0, ni, nj));
@ -112,7 +114,7 @@ TTS_CASE_TPL("Test dynamic block::setOnes",
}
};
TTS_CASE_TPL("Test static block:setOnes",
TTS_CASE_TPL("Test static block::setOnes",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
{
@ -126,7 +128,7 @@ TTS_CASE_TPL("Test static block:setOnes",
rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract<D::ni, D::nj>(m, i0, j0);
input.setOnes();
rotgen::setOnes(input);
test_value(m, T{1}, i0, j0, D::ni, D::nj);
using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0));
@ -149,7 +151,7 @@ TTS_CASE_TPL("Test dynamic block::setConstant",
rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract(m, i0, j0, ni, nj);
input.setConstant(T{13.37f});
rotgen::setConstant(input, T{13.37f});
test_value(m, T{13.37f}, i0, j0, ni, nj);
using input_type = decltype(rotgen::extract(m, i0, j0, ni, nj));
@ -158,7 +160,7 @@ TTS_CASE_TPL("Test dynamic block::setConstant",
}
};
TTS_CASE_TPL("Test static block:setConstant",
TTS_CASE_TPL("Test static block::setConstant",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
{
@ -172,7 +174,7 @@ TTS_CASE_TPL("Test static block:setConstant",
rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract<D::ni, D::nj>(m, i0, j0);
input.setConstant(T{13.37f});
rotgen::setConstant(input, T{13.37f});
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));
@ -195,7 +197,7 @@ TTS_CASE_TPL("Test dynamic block::setIdentity",
rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract(m, i0, j0, ni, nj);
input.setIdentity();
rotgen::setIdentity(input);
test_identity(m, i0, j0, ni, nj);
using input_type = decltype(rotgen::extract(m, i0, j0, ni, nj));
@ -204,7 +206,7 @@ TTS_CASE_TPL("Test dynamic block::setIdentity",
}
};
TTS_CASE_TPL("Test static block:setIdentity",
TTS_CASE_TPL("Test static block::setIdentity",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
{
@ -218,7 +220,7 @@ TTS_CASE_TPL("Test static block:setIdentity",
rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract<D::ni, D::nj>(m, i0, j0);
input.setIdentity();
rotgen::setIdentity(input);
test_identity(m, i0, j0, D::ni, D::nj);
using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0));
@ -241,7 +243,7 @@ TTS_CASE_TPL("Test dynamic block::setRandom",
rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract(m, i0, j0, ni, nj);
input.setRandom();
rotgen::setRandom(input);
test_random(m, i0, j0, ni, nj);
using input_type = decltype(rotgen::extract(m, i0, j0, ni, nj));
@ -250,7 +252,7 @@ TTS_CASE_TPL("Test dynamic block::setRandom",
}
};
TTS_CASE_TPL("Test static block:setRandom",
TTS_CASE_TPL("Test static block::setRandom",
rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
{
@ -264,7 +266,7 @@ TTS_CASE_TPL("Test static block:setRandom",
rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract<D::ni, D::nj>(m, i0, j0);
input.setRandom();
rotgen::setRandom(input);
test_random(m, i0, j0, D::ni, D::nj);
using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0));

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

@ -5,81 +5,85 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#pragma once
#include <rotgen/rotgen.hpp>
#include "tts.hpp"
#include <Eigen/Dense>
#include <vector>
#include <tuple>
namespace rotgen::tests
{
template<typename T> void check_shape_functions(T original)
template<typename T> void check_shape_functions(T rotgen_input)
{
using mat_t =
using eigen_mat_t =
matrix<typename T::value_type, Dynamic, Dynamic, T::storage_order>;
mat_t result(original.cols(), original.rows());
prepare([&](auto r, auto c) { return original(c, r); }, result);
eigen_mat_t eigen_result(rotgen_input.cols(), rotgen_input.rows());
prepare([&](auto r, auto c) { return rotgen_input(c, r); }, eigen_result);
TTS_EQUAL(transpose(original), result);
TTS_EQUAL(conjugate(original), original);
TTS_EQUAL(adjoint(original), result);
TTS_EQUAL(transpose(rotgen_input), eigen_result);
TTS_EQUAL(conjugate(rotgen_input), rotgen_input);
TTS_EQUAL(adjoint(rotgen_input), eigen_result);
if constexpr (T::is_defined_static)
{
if constexpr (T::RowsAtCompileTime == T::ColsAtCompileTime)
{
mat_t ref = original;
transposeInPlace(original);
TTS_EQUAL(original, result);
eigen_mat_t ref = rotgen_input;
transposeInPlace(rotgen_input);
TTS_EQUAL(rotgen_input, eigen_result);
adjointInPlace(original);
TTS_EQUAL(original, ref);
adjointInPlace(rotgen_input);
TTS_EQUAL(rotgen_input, ref);
}
}
else
{
if (original.rows() == original.cols())
if (rotgen_input.rows() == rotgen_input.cols())
{
mat_t ref = original;
transposeInPlace(original);
TTS_EQUAL(original, result);
eigen_mat_t eigen_ref = rotgen_input;
transposeInPlace(rotgen_input);
TTS_EQUAL(rotgen_input, eigen_result);
adjointInPlace(original);
TTS_EQUAL(original, ref);
adjointInPlace(rotgen_input);
TTS_EQUAL(rotgen_input, eigen_ref);
}
}
if constexpr (!rotgen::use_expression_templates)
{
TTS_EXPECT(verify_rotgen_reentrance(original.transpose()));
TTS_EXPECT(verify_rotgen_reentrance(original.conjugate()));
TTS_EXPECT(verify_rotgen_reentrance(original.adjoint()));
TTS_EXPECT(verify_rotgen_reentrance(transpose(rotgen_input)));
TTS_EXPECT(verify_rotgen_reentrance(conjugate(rotgen_input)));
TTS_EXPECT(verify_rotgen_reentrance(adjoint(rotgen_input)));
}
}
template<typename T> void check_reduction_functions(T const& input)
template<typename T> void check_reduction_functions(T const& rotgen_input)
{
using EigenMatrix =
using eigen_mat_t =
Eigen::Matrix<typename T::value_type, Eigen::Dynamic, Eigen::Dynamic>;
EigenMatrix ref(input.rows(), input.cols());
prepare([&](auto r, auto c) { return input(r, c); }, ref);
eigen_mat_t eigen_ref(rotgen_input.rows(), rotgen_input.cols());
prepare([&](auto r, auto c) { return rotgen_input(r, c); }, eigen_ref);
TTS_ULP_EQUAL(sum(input), ref.sum(), 2);
TTS_ULP_EQUAL(prod(input), ref.prod(), 2);
TTS_ULP_EQUAL(mean(input), ref.mean(), 2);
TTS_EQUAL(trace(input), ref.trace());
TTS_EQUAL(minCoeff(input), ref.minCoeff());
TTS_EQUAL(maxCoeff(input), ref.maxCoeff());
TTS_ULP_EQUAL(sum(rotgen_input), eigen_ref.sum(), 2);
TTS_ULP_EQUAL(prod(rotgen_input), eigen_ref.prod(), 2);
TTS_ULP_EQUAL(mean(rotgen_input), eigen_ref.mean(), 2);
TTS_EQUAL(trace(rotgen_input), eigen_ref.trace());
TTS_EQUAL(minCoeff(rotgen_input), eigen_ref.minCoeff());
TTS_EQUAL(maxCoeff(rotgen_input), eigen_ref.maxCoeff());
{
int row, col, ref_row, ref_col;
TTS_EQUAL(minCoeff(input, &row, &col), ref.minCoeff(&ref_row, &ref_col));
TTS_EQUAL(minCoeff(rotgen_input, &row, &col),
eigen_ref.minCoeff(&ref_row, &ref_col));
TTS_EQUAL(row, ref_row);
TTS_EQUAL(col, ref_col);
TTS_EQUAL(maxCoeff(input, &row, &col), ref.maxCoeff(&ref_row, &ref_col));
TTS_EQUAL(maxCoeff(rotgen_input, &row, &col),
eigen_ref.maxCoeff(&ref_row, &ref_col));
TTS_EQUAL(row, ref_row);
TTS_EQUAL(col, ref_col);
}

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

@ -5,89 +5,60 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#pragma once
#include <rotgen/rotgen.hpp>
#include "tts.hpp"
#include <Eigen/Dense>
#include <vector>
#include <tuple>
namespace rotgen::tests
{
template<typename T> void check_cwise_functions(T const& input)
template<typename T> void check_cwise_functions(T const& rotgen_input)
{
using EigenMatrix =
using eigen_mat_t =
Eigen::Matrix<typename T::value_type, Eigen::Dynamic, Eigen::Dynamic>;
using mat_t =
using rotgen_mat_t =
matrix<typename T::value_type, Dynamic, Dynamic, T::storage_order>;
TTS_WHEN("Unary Cwise operations")
{
EigenMatrix e_ref(input.rows(), input.cols());
prepare([&](auto r, auto c) { return input(r, c); }, e_ref);
eigen_mat_t eigen_ref(rotgen_input.rows(), rotgen_input.cols());
prepare([&](auto r, auto c) { return rotgen_input(r, c); }, eigen_ref);
mat_t ref(input.rows(), input.cols());
TTS_AND_THEN(".cwiseAbs")
{
e_ref = e_ref.cwiseAbs();
prepare([&](auto r, auto c) { return e_ref(r, c); }, ref);
TTS_EQUAL(input.cwiseAbs(), ref);
}
TTS_AND_THEN(".cwiseAbs2")
{
e_ref = e_ref.cwiseAbs2();
prepare([&](auto r, auto c) { return e_ref(r, c); }, ref);
TTS_EQUAL(input.cwiseAbs2(), ref);
}
TTS_AND_THEN(".cwiseInverse")
{
e_ref = e_ref.cwiseInverse();
prepare([&](auto r, auto c) { return e_ref(r, c); }, ref);
TTS_EQUAL(input.cwiseInverse(), ref);
}
TTS_AND_THEN(".cwiseSqrt")
{
e_ref = e_ref.cwiseAbs().cwiseSqrt();
auto mat = input.cwiseAbs();
auto proper_input = mat.cwiseSqrt();
for (rotgen::Index r = 0; r < input.rows(); ++r)
for (rotgen::Index c = 0; c < input.cols(); ++c)
TTS_ULP_EQUAL(proper_input(r, c), e_ref(r, c), 1);
}
rotgen_mat_t rotgen_ref(rotgen_input.rows(), rotgen_input.cols());
TTS_AND_THEN("abs()")
{
e_ref = e_ref.cwiseAbs();
prepare([&](auto r, auto c) { return e_ref(r, c); }, ref);
TTS_EQUAL(rotgen::abs(input), ref);
eigen_ref = eigen_ref.cwiseAbs();
prepare([&](auto r, auto c) { return eigen_ref(r, c); }, rotgen_ref);
TTS_EQUAL(rotgen::abs(rotgen_input), rotgen_ref);
}
TTS_AND_THEN("abs2()")
{
e_ref = e_ref.cwiseAbs2();
prepare([&](auto r, auto c) { return e_ref(r, c); }, ref);
TTS_EQUAL(rotgen::abs2(input), ref);
eigen_ref = eigen_ref.cwiseAbs2();
prepare([&](auto r, auto c) { return eigen_ref(r, c); }, rotgen_ref);
TTS_EQUAL(rotgen::abs2(rotgen_input), rotgen_ref);
}
TTS_AND_THEN("rec")
{
e_ref = e_ref.cwiseInverse();
prepare([&](auto r, auto c) { return e_ref(r, c); }, ref);
TTS_EQUAL(rotgen::rec(input), ref);
eigen_ref = eigen_ref.cwiseInverse();
prepare([&](auto r, auto c) { return eigen_ref(r, c); }, rotgen_ref);
TTS_EQUAL(rotgen::rec(rotgen_input), rotgen_ref);
}
TTS_AND_THEN("sqrt")
{
e_ref = e_ref.cwiseAbs().cwiseSqrt();
auto mat = input.cwiseAbs();
eigen_ref = eigen_ref.cwiseAbs().cwiseSqrt();
auto mat = rotgen::abs(rotgen_input);
auto proper_input = rotgen::sqrt(mat);
for (rotgen::Index r = 0; r < input.rows(); ++r)
for (rotgen::Index c = 0; c < input.cols(); ++c)
TTS_ULP_EQUAL(proper_input(r, c), e_ref(r, c), 1);
for (rotgen::Index r = 0; r < rotgen_input.rows(); ++r)
for (rotgen::Index c = 0; c < rotgen_input.cols(); ++c)
TTS_ULP_EQUAL(proper_input(r, c), eigen_ref(r, c), 1);
}
}
}

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

@ -5,42 +5,47 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#pragma once
#include <rotgen/rotgen.hpp>
#include "tts.hpp"
#include <Eigen/Dense>
#include <vector>
#include <tuple>
namespace rotgen::tests
{
template<typename T> void check_norms_functions(T const& input)
template<typename T> void check_norms_functions(T const& rotgen_input)
{
using EigenMatrix =
using eigen_mat_t =
Eigen::Matrix<typename T::value_type, Eigen::Dynamic, Eigen::Dynamic>;
EigenMatrix ref(input.rows(), input.cols());
eigen_mat_t eigen_ref(rotgen_input.rows(), rotgen_input.cols());
prepare([&](auto r, auto c) { return input(r, c); }, ref);
prepare([&](auto row, auto col) { return rotgen_input(row, col); },
eigen_ref);
TTS_EQUAL(rotgen::norm(input), ref.norm());
TTS_EQUAL(rotgen::squaredNorm(input), ref.squaredNorm());
TTS_EQUAL(rotgen::lpNorm<1>(input), ref.template lpNorm<1>());
TTS_EQUAL(rotgen::lpNorm<2>(input), ref.template lpNorm<2>());
TTS_EQUAL(rotgen::lpNorm<rotgen::Infinity>(input),
ref.template lpNorm<Eigen::Infinity>());
TTS_EQUAL(rotgen::norm(rotgen_input), eigen_ref.norm());
TTS_EQUAL(rotgen::squaredNorm(rotgen_input), eigen_ref.squaredNorm());
TTS_EQUAL(rotgen::lpNorm<1>(rotgen_input), eigen_ref.template lpNorm<1>());
TTS_EQUAL(rotgen::lpNorm<2>(rotgen_input), eigen_ref.template lpNorm<2>());
TTS_EQUAL(rotgen::lpNorm<rotgen::Infinity>(rotgen_input),
eigen_ref.template lpNorm<Eigen::Infinity>());
if constexpr (T::IsVectorAtCompileTime)
{
EigenMatrix e_norm = ref.normalized();
using mat_t = rotgen::matrix<typename T::value_type, rotgen::Dynamic,
rotgen::Dynamic, T::storage_order>;
mat_t norm_ref(input.rows(), input.cols());
prepare([&](auto r, auto c) { return e_norm(r, c); }, norm_ref);
eigen_mat_t eigen_normalized = eigen_ref.normalized();
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());
prepare([&](auto row, auto col) { return eigen_normalized(row, col); },
rotgen_norm_ref);
TTS_EQUAL(rotgen::normalized(input), norm_ref);
TTS_EQUAL(rotgen::normalized(rotgen_input), rotgen_norm_ref);
auto f_norm = input;
rotgen::normalize(f_norm);
TTS_EQUAL(f_norm, norm_ref);
auto rotgen_f_norm = rotgen_input;
rotgen::normalize(rotgen_f_norm);
TTS_EQUAL(rotgen_f_norm, rotgen_norm_ref);
}
}
}

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

@ -5,11 +5,13 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#pragma once
#include <rotgen/rotgen.hpp>
#include <Eigen/Dense>
#include <vector>
#include <tuple>
#include <vector>
namespace rotgen::tests
{

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

@ -5,61 +5,68 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include "unit/tests.hpp"
#include <rotgen/rotgen.hpp>
#include "unit/tests.hpp"
TTS_CASE_TPL("rowwise API", rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, O>>)
{
using e_t = Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, O::value>;
e_t ref = e_t::Random(4, 4);
auto ref_rw = ref.rowwise();
using eigen_mat_t =
Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, O::value>;
eigen_mat_t eigen_ref = eigen_mat_t::Random(4, 4);
auto eigen_ref_rw = eigen_ref.rowwise();
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> mat(4, 4);
rotgen::tests::prepare([&](auto r, auto c) { return ref(r, c); }, mat);
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> rotgen_mat(4,
4);
rotgen::tests::prepare([&](auto r, auto c) { return eigen_ref(r, c); },
rotgen_mat);
auto rw = rotgen::rowwise(mat);
auto rotgen_rw = rotgen::rowwise(rotgen_mat);
for (rotgen::Index i = 0; i < mat.rows(); ++i)
TTS_EQUAL(rw.sum()(i), ref_rw.sum()(i));
for (rotgen::Index i = 0; i < mat.rows(); ++i)
TTS_EQUAL(rw.mean()(i), ref_rw.mean()(i));
for (rotgen::Index i = 0; i < mat.rows(); ++i)
TTS_EQUAL(rw.prod()(i), ref_rw.prod()(i));
for (rotgen::Index i = 0; i < mat.rows(); ++i)
TTS_EQUAL(rw.maxCoeff()(i), ref_rw.maxCoeff()(i));
for (rotgen::Index i = 0; i < mat.rows(); ++i)
TTS_EQUAL(rw.minCoeff()(i), ref_rw.minCoeff()(i));
for (rotgen::Index i = 0; i < mat.rows(); ++i)
TTS_EQUAL(rw.squaredNorm()(i), ref_rw.squaredNorm()(i));
for (rotgen::Index i = 0; i < mat.rows(); ++i)
TTS_EQUAL(rw.norm()(i), ref_rw.norm()(i));
for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
TTS_EQUAL(rotgen::sum(rotgen_rw)(i), eigen_ref_rw.sum()(i));
for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
TTS_EQUAL(rotgen::mean(rotgen_rw)(i), eigen_ref_rw.mean()(i));
for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
TTS_EQUAL(rotgen::prod(rotgen_rw)(i), eigen_ref_rw.prod()(i));
for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
TTS_EQUAL(rotgen::maxCoeff(rotgen_rw)(i), eigen_ref_rw.maxCoeff()(i));
for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
TTS_EQUAL(rotgen::minCoeff(rotgen_rw)(i), eigen_ref_rw.minCoeff()(i));
for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
TTS_EQUAL(rotgen::squaredNorm(rotgen_rw)(i), eigen_ref_rw.squaredNorm()(i));
for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++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>>)
{
using e_t = Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, O::value>;
e_t ref = e_t::Random(4, 4);
auto ref_rw = ref.colwise();
using eigen_mat_t =
Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, O::value>;
eigen_mat_t eigen_ref = eigen_mat_t::Random(4, 4);
auto eigen_ref_rw = eigen_ref.colwise();
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> mat(4, 4);
rotgen::tests::prepare([&](auto r, auto c) { return ref(r, c); }, mat);
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> rotgen_mat(4,
4);
rotgen::tests::prepare([&](auto r, auto c) { return eigen_ref(r, c); },
rotgen_mat);
auto rw = rotgen::colwise(mat);
auto rotgen_rw = rotgen::colwise(rotgen_mat);
for (rotgen::Index i = 0; i < mat.cols(); ++i)
TTS_EQUAL(rw.sum()(i), ref_rw.sum()(i));
for (rotgen::Index i = 0; i < mat.cols(); ++i)
TTS_EQUAL(rw.mean()(i), ref_rw.mean()(i));
for (rotgen::Index i = 0; i < mat.cols(); ++i)
TTS_EQUAL(rw.prod()(i), ref_rw.prod()(i));
for (rotgen::Index i = 0; i < mat.cols(); ++i)
TTS_EQUAL(rw.maxCoeff()(i), ref_rw.maxCoeff()(i));
for (rotgen::Index i = 0; i < mat.cols(); ++i)
TTS_EQUAL(rw.minCoeff()(i), ref_rw.minCoeff()(i));
for (rotgen::Index i = 0; i < mat.cols(); ++i)
TTS_EQUAL(rw.squaredNorm()(i), ref_rw.squaredNorm()(i));
for (rotgen::Index i = 0; i < mat.cols(); ++i)
TTS_EQUAL(rw.norm()(i), ref_rw.norm()(i));
for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
TTS_EQUAL(rotgen::sum(rotgen_rw)(i), eigen_ref_rw.sum()(i));
for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
TTS_EQUAL(rotgen::mean(rotgen_rw)(i), eigen_ref_rw.mean()(i));
for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
TTS_EQUAL(rotgen::prod(rotgen_rw)(i), eigen_ref_rw.prod()(i));
for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
TTS_EQUAL(rotgen::maxCoeff(rotgen_rw)(i), eigen_ref_rw.maxCoeff()(i));
for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
TTS_EQUAL(rotgen::minCoeff(rotgen_rw)(i), eigen_ref_rw.minCoeff()(i));
for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
TTS_EQUAL(rotgen::squaredNorm(rotgen_rw)(i), eigen_ref_rw.squaredNorm()(i));
for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
TTS_EQUAL(rotgen::norm(rotgen_rw)(i), eigen_ref_rw.norm()(i));
};

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

@ -33,14 +33,14 @@ TTS_CASE_TPL("Resizing dynamic matrix",
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;
a.resize(3, 2);
rotgen::resize(a, 3, 2);
TTS_EQUAL(a.rows(), rotgen::Index(3));
TTS_EQUAL(a.cols(), 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);
a.resize(2, 2);
rotgen::resize(a, 2, 2);
TTS_EQUAL(a.rows(), rotgen::Index(2));
TTS_EQUAL(a.cols(), rotgen::Index(2));
};
@ -55,7 +55,7 @@ TTS_CASE_TPL("Dynamix matrix conservative resizing",
for (rotgen::Index r = 0; r < a.rows(); ++r)
for (rotgen::Index c = 0; c < a.cols(); ++c) a(r, c) = i++;
a.conservativeResize(2, 3);
rotgen::conservativeResize(a, 2, 3);
TTS_EQUAL(a.rows(), rotgen::Index(2));
TTS_EQUAL(a.cols(), rotgen::Index(3));
@ -63,36 +63,36 @@ TTS_CASE_TPL("Dynamix matrix conservative resizing",
for (rotgen::Index r = 0; r < a.rows(); ++r)
for (rotgen::Index c = 0; c < a.cols(); ++c) TTS_EQUAL(a(r, c), i++);
a.conservativeResize(3, 2);
rotgen::conservativeResize(a, 3, 2);
TTS_EQUAL(a.rows(), rotgen::Index(3));
TTS_EQUAL(a.cols(), 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]);
a.conservativeResize(4, 4);
rotgen::conservativeResize(a, 4, 4);
TTS_EQUAL(a.rows(), rotgen::Index(4));
TTS_EQUAL(a.cols(), rotgen::Index(4));
TTS_EQUAL(a(0, 0), 1);
TTS_EQUAL(a(3, 3), 0);
a.conservativeResize(2, 2);
rotgen::conservativeResize(a, 2, 2);
TTS_EQUAL(a.rows(), rotgen::Index(2));
TTS_EQUAL(a.cols(), rotgen::Index(2));
TTS_EQUAL(a(0, 0), 1);
TTS_EQUAL(a(1, 1), 5);
a.conservativeResize(1, 2);
rotgen::conservativeResize(a, 1, 2);
TTS_EQUAL(a.rows(), rotgen::Index(1));
TTS_EQUAL(a.cols(), rotgen::Index(2));
TTS_EQUAL(a(0, 0), 1);
TTS_EQUAL(a(0, 1), 2);
a.conservativeResize(0, 0);
rotgen::conservativeResize(a, 0, 0);
TTS_EQUAL(a.rows(), rotgen::Index(0));
TTS_EQUAL(a.cols(), rotgen::Index(0));
a.conservativeResize(3, 3);
rotgen::conservativeResize(a, 3, 3);
TTS_EQUAL(a.rows(), rotgen::Index(3));
TTS_EQUAL(a.cols(), rotgen::Index(3));
};

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

@ -5,10 +5,11 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include "unit/tests.hpp"
#include "unit/common/arithmetic.hpp"
#include <rotgen/rotgen.hpp>
#include "unit/common/arithmetic.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>>)

4
test/unit/tests.hpp
View file

@ -5,8 +5,8 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#define TTS_MAIN
#define TTS_CUSTOM_DRIVER_FUNCTION rotgen_main
#pragma once
#include "tts.hpp"
#include "unit/common/references.hpp"
#include <rotgen/config.hpp>