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

Testing functional API only (oss/rotgen#17)

Browse source 
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
parent 6fa95fb22d
commit 4a7aa08cdb
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 // Reductions
//----------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------
auto trace(concepts::entity auto const& arg) auto trace(auto const& arg)
requires requires { arg.trace(); }
{ {
return arg.trace(); return arg.trace();
} }
auto squaredNorm(concepts::entity auto const& arg) auto squaredNorm(auto const& arg)
requires requires { arg.squaredNorm(); }
{ {
return arg.squaredNorm(); return arg.squaredNorm();
} }
auto norm(concepts::entity auto const& arg) auto norm(auto const& arg)
requires requires { arg.norm(); }
{ {
return arg.norm(); return arg.norm();
} }
@ -239,12 +242,14 @@ namespace rotgen
return arg.sum(); return arg.sum();
} }
auto prod(concepts::entity auto const& arg) auto prod(auto const& arg)
requires requires { arg.prod(); }
{ {
return arg.prod(); return arg.prod();
} }
auto mean(concepts::entity auto const& arg) auto mean(auto const& arg)
requires requires { arg.mean(); }
{ {
return arg.mean(); return arg.mean();
} }
@ -272,17 +277,15 @@ namespace rotgen
} }
template<std::integral IndexType> template<std::integral IndexType>
auto maxCoeff(concepts::entity auto const& arg, auto maxCoeff(auto const& arg, IndexType* row, IndexType* col)
IndexType* row, requires(requires { arg.maxCoeff(row, col); })
IndexType* col)
{ {
return arg.maxCoeff(row, col); return arg.maxCoeff(row, col);
} }
template<std::integral IndexType> template<std::integral IndexType>
auto minCoeff(concepts::entity auto const& arg, auto minCoeff(auto const& arg, IndexType* row, IndexType* col)
IndexType* row, requires(requires { arg.minCoeff(row, col); })
IndexType* col)
{ {
return 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_include_directories( rotgen_test INTERFACE ${PROJECT_SOURCE_DIR}/test)
target_link_libraries(rotgen_test INTERFACE rotgen Eigen3::Eigen) 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 ## Unit Tests registration
##====================================================================================================================== ##======================================================================================================================

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

@ -5,9 +5,11 @@
SPDX-License-Identifier: BSL-1.0 SPDX-License-Identifier: BSL-1.0
*/ */
//================================================================================================== //==================================================================================================
#include "unit/tests.hpp"
#include <rotgen/rotgen.hpp> #include <rotgen/rotgen.hpp>
#include "rotgen/functions/functions.hpp"
#include "unit/tests.hpp"
void test_value(auto const& matrix, void test_value(auto const& matrix,
auto value, auto value,
rotgen::Index i0, rotgen::Index i0,
@ -57,7 +59,7 @@ TTS_CASE_TPL("Test dynamic block::setZero",
rotgen::tests::prepare(rows, cols, fn, m); rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract(m, i0, j0, ni, nj); auto input = rotgen::extract(m, i0, j0, ni, nj);
input.setZero(); rotgen::setZero(input);
test_value(m, T{0}, i0, j0, ni, nj); test_value(m, T{0}, i0, j0, ni, nj);
using input_type = decltype(rotgen::extract(m, 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>( rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, 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); rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract<D::ni, D::nj>(m, i0, j0); 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); test_value(m, T{0}, i0, j0, D::ni, D::nj);
using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0)); 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); rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract(m, i0, j0, ni, nj); auto input = rotgen::extract(m, i0, j0, ni, nj);
input.setOnes(); rotgen::setOnes(input);
test_value(m, T{1}, i0, j0, ni, nj); test_value(m, T{1}, i0, j0, ni, nj);
using input_type = decltype(rotgen::extract(m, 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>( rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, 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); rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract<D::ni, D::nj>(m, i0, j0); 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); test_value(m, T{1}, i0, j0, D::ni, D::nj);
using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0)); 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); rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract(m, i0, j0, ni, nj); 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); test_value(m, T{13.37f}, i0, j0, ni, nj);
using input_type = decltype(rotgen::extract(m, 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>( rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, 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); rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract<D::ni, D::nj>(m, i0, j0); 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); 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)); 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); rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract(m, i0, j0, ni, nj); auto input = rotgen::extract(m, i0, j0, ni, nj);
input.setIdentity(); rotgen::setIdentity(input);
test_identity(m, i0, j0, ni, nj); test_identity(m, i0, j0, ni, nj);
using input_type = decltype(rotgen::extract(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>( rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, 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); rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract<D::ni, D::nj>(m, i0, j0); 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); test_identity(m, i0, j0, D::ni, D::nj);
using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0)); 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); rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract(m, i0, j0, ni, nj); auto input = rotgen::extract(m, i0, j0, ni, nj);
input.setRandom(); rotgen::setRandom(input);
test_random(m, i0, j0, ni, nj); test_random(m, i0, j0, ni, nj);
using input_type = decltype(rotgen::extract(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>( rotgen::tests::types)<typename T, typename O>(
tts::type<tts::types<T, 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); rotgen::tests::prepare(rows, cols, fn, m);
auto input = rotgen::extract<D::ni, D::nj>(m, i0, j0); 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); test_random(m, i0, j0, D::ni, D::nj);
using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0)); 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 SPDX-License-Identifier: BSL-1.0
*/ */
//================================================================================================== //==================================================================================================
#pragma once
#include <rotgen/rotgen.hpp> #include <rotgen/rotgen.hpp>
#include "tts.hpp"
#include <Eigen/Dense> #include <Eigen/Dense>
#include <vector>
#include <tuple>
namespace rotgen::tests 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>; matrix<typename T::value_type, Dynamic, Dynamic, T::storage_order>;
mat_t result(original.cols(), original.rows()); eigen_mat_t eigen_result(rotgen_input.cols(), rotgen_input.rows());
prepare([&](auto r, auto c) { return original(c, r); }, result); prepare([&](auto r, auto c) { return rotgen_input(c, r); }, eigen_result);
TTS_EQUAL(transpose(original), result); TTS_EQUAL(transpose(rotgen_input), eigen_result);
TTS_EQUAL(conjugate(original), original); TTS_EQUAL(conjugate(rotgen_input), rotgen_input);
TTS_EQUAL(adjoint(original), result); TTS_EQUAL(adjoint(rotgen_input), eigen_result);
if constexpr (T::is_defined_static) if constexpr (T::is_defined_static)
{ {
if constexpr (T::RowsAtCompileTime == T::ColsAtCompileTime) if constexpr (T::RowsAtCompileTime == T::ColsAtCompileTime)
{ {
mat_t ref = original; eigen_mat_t ref = rotgen_input;
transposeInPlace(original); transposeInPlace(rotgen_input);
TTS_EQUAL(original, result); TTS_EQUAL(rotgen_input, eigen_result);
adjointInPlace(original); adjointInPlace(rotgen_input);
TTS_EQUAL(original, ref); TTS_EQUAL(rotgen_input, ref);
} }
} }
else else
{ {
if (original.rows() == original.cols()) if (rotgen_input.rows() == rotgen_input.cols())
{ {
mat_t ref = original; eigen_mat_t eigen_ref = rotgen_input;
transposeInPlace(original); transposeInPlace(rotgen_input);
TTS_EQUAL(original, result); TTS_EQUAL(rotgen_input, eigen_result);
adjointInPlace(original); adjointInPlace(rotgen_input);
TTS_EQUAL(original, ref); TTS_EQUAL(rotgen_input, eigen_ref);
} }
} }
if constexpr (!rotgen::use_expression_templates) if constexpr (!rotgen::use_expression_templates)
{ {
TTS_EXPECT(verify_rotgen_reentrance(original.transpose())); TTS_EXPECT(verify_rotgen_reentrance(transpose(rotgen_input)));
TTS_EXPECT(verify_rotgen_reentrance(original.conjugate())); TTS_EXPECT(verify_rotgen_reentrance(conjugate(rotgen_input)));
TTS_EXPECT(verify_rotgen_reentrance(original.adjoint())); 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>; 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 r, auto c) { return rotgen_input(r, c); }, eigen_ref);
TTS_ULP_EQUAL(sum(input), ref.sum(), 2); TTS_ULP_EQUAL(sum(rotgen_input), eigen_ref.sum(), 2);
TTS_ULP_EQUAL(prod(input), ref.prod(), 2); TTS_ULP_EQUAL(prod(rotgen_input), eigen_ref.prod(), 2);
TTS_ULP_EQUAL(mean(input), ref.mean(), 2); TTS_ULP_EQUAL(mean(rotgen_input), eigen_ref.mean(), 2);
TTS_EQUAL(trace(input), ref.trace()); TTS_EQUAL(trace(rotgen_input), eigen_ref.trace());
TTS_EQUAL(minCoeff(input), ref.minCoeff()); TTS_EQUAL(minCoeff(rotgen_input), eigen_ref.minCoeff());
TTS_EQUAL(maxCoeff(input), ref.maxCoeff()); TTS_EQUAL(maxCoeff(rotgen_input), eigen_ref.maxCoeff());
{ {
int row, col, ref_row, ref_col; 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(row, ref_row);
TTS_EQUAL(col, ref_col); 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(row, ref_row);
TTS_EQUAL(col, ref_col); TTS_EQUAL(col, ref_col);
} }

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

@ -5,89 +5,60 @@
SPDX-License-Identifier: BSL-1.0 SPDX-License-Identifier: BSL-1.0
*/ */
//================================================================================================== //==================================================================================================
#pragma once
#include <rotgen/rotgen.hpp> #include <rotgen/rotgen.hpp>
#include "tts.hpp"
#include <Eigen/Dense> #include <Eigen/Dense>
#include <vector>
#include <tuple>
namespace rotgen::tests 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>; 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>; matrix<typename T::value_type, Dynamic, Dynamic, T::storage_order>;
TTS_WHEN("Unary Cwise operations") TTS_WHEN("Unary Cwise operations")
{ {
EigenMatrix e_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); }, e_ref); prepare([&](auto r, auto c) { return rotgen_input(r, c); }, eigen_ref);
mat_t ref(input.rows(), input.cols()); rotgen_mat_t rotgen_ref(rotgen_input.rows(), rotgen_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);
}
TTS_AND_THEN("abs()") TTS_AND_THEN("abs()")
{ {
e_ref = e_ref.cwiseAbs(); eigen_ref = eigen_ref.cwiseAbs();
prepare([&](auto r, auto c) { return e_ref(r, c); }, ref); prepare([&](auto r, auto c) { return eigen_ref(r, c); }, rotgen_ref);
TTS_EQUAL(rotgen::abs(input), ref); TTS_EQUAL(rotgen::abs(rotgen_input), rotgen_ref);
} }
TTS_AND_THEN("abs2()") TTS_AND_THEN("abs2()")
{ {
e_ref = e_ref.cwiseAbs2(); eigen_ref = eigen_ref.cwiseAbs2();
prepare([&](auto r, auto c) { return e_ref(r, c); }, ref); prepare([&](auto r, auto c) { return eigen_ref(r, c); }, rotgen_ref);
TTS_EQUAL(rotgen::abs2(input), ref); TTS_EQUAL(rotgen::abs2(rotgen_input), rotgen_ref);
} }
TTS_AND_THEN("rec") TTS_AND_THEN("rec")
{ {
e_ref = e_ref.cwiseInverse(); eigen_ref = eigen_ref.cwiseInverse();
prepare([&](auto r, auto c) { return e_ref(r, c); }, ref); prepare([&](auto r, auto c) { return eigen_ref(r, c); }, rotgen_ref);
TTS_EQUAL(rotgen::rec(input), ref); TTS_EQUAL(rotgen::rec(rotgen_input), rotgen_ref);
} }
TTS_AND_THEN("sqrt") TTS_AND_THEN("sqrt")
{ {
e_ref = e_ref.cwiseAbs().cwiseSqrt(); eigen_ref = eigen_ref.cwiseAbs().cwiseSqrt();
auto mat = input.cwiseAbs(); auto mat = rotgen::abs(rotgen_input);
auto proper_input = rotgen::sqrt(mat); auto proper_input = rotgen::sqrt(mat);
for (rotgen::Index r = 0; r < input.rows(); ++r) for (rotgen::Index r = 0; r < rotgen_input.rows(); ++r)
for (rotgen::Index c = 0; c < input.cols(); ++c) for (rotgen::Index c = 0; c < rotgen_input.cols(); ++c)
TTS_ULP_EQUAL(proper_input(r, c), e_ref(r, c), 1); 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 SPDX-License-Identifier: BSL-1.0
*/ */
//================================================================================================== //==================================================================================================
#pragma once
#include <rotgen/rotgen.hpp> #include <rotgen/rotgen.hpp>
#include "tts.hpp"
#include <Eigen/Dense> #include <Eigen/Dense>
#include <vector>
#include <tuple>
namespace rotgen::tests 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>; 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::norm(rotgen_input), eigen_ref.norm());
TTS_EQUAL(rotgen::squaredNorm(input), ref.squaredNorm()); TTS_EQUAL(rotgen::squaredNorm(rotgen_input), eigen_ref.squaredNorm());
TTS_EQUAL(rotgen::lpNorm<1>(input), ref.template lpNorm<1>()); TTS_EQUAL(rotgen::lpNorm<1>(rotgen_input), eigen_ref.template lpNorm<1>());
TTS_EQUAL(rotgen::lpNorm<2>(input), ref.template lpNorm<2>()); TTS_EQUAL(rotgen::lpNorm<2>(rotgen_input), eigen_ref.template lpNorm<2>());
TTS_EQUAL(rotgen::lpNorm<rotgen::Infinity>(input), TTS_EQUAL(rotgen::lpNorm<rotgen::Infinity>(rotgen_input),
ref.template lpNorm<Eigen::Infinity>()); eigen_ref.template lpNorm<Eigen::Infinity>());
if constexpr (T::IsVectorAtCompileTime) if constexpr (T::IsVectorAtCompileTime)
{ {
EigenMatrix e_norm = ref.normalized(); eigen_mat_t eigen_normalized = eigen_ref.normalized();
using mat_t = rotgen::matrix<typename T::value_type, rotgen::Dynamic, using rotgen_mat_t =
rotgen::Dynamic, T::storage_order>; rotgen::matrix<typename T::value_type, rotgen::Dynamic, rotgen::Dynamic,
mat_t norm_ref(input.rows(), input.cols()); T::storage_order>;
prepare([&](auto r, auto c) { return e_norm(r, c); }, norm_ref); 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; auto rotgen_f_norm = rotgen_input;
rotgen::normalize(f_norm); rotgen::normalize(rotgen_f_norm);
TTS_EQUAL(f_norm, norm_ref); 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 SPDX-License-Identifier: BSL-1.0
*/ */
//================================================================================================== //==================================================================================================
#pragma once
#include <rotgen/rotgen.hpp> #include <rotgen/rotgen.hpp>
#include <Eigen/Dense> #include <Eigen/Dense>
#include <vector>
#include <tuple> #include <tuple>
#include <vector>
namespace rotgen::tests namespace rotgen::tests
{ {

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

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

4
test/unit/tests.hpp
View file

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