Adding clang-format configuration file and formatting all source files
Co-authored-by: Jules Pénuchot <jules@penuchot.com> Co-authored-by: Joel FALCOU <jfalcou@codereckons.com> See merge request oss/rotgen!41
This commit is contained in:
Jules Pénuchot
parent
e92e824a18
commit
648dd768ee
94 changed files with 6778 additions and 4722 deletions
|
|
@ -12,21 +12,21 @@
|
|||
|
||||
namespace rotgen::tests
|
||||
{
|
||||
template<typename T>
|
||||
void check_shape_functions(T original)
|
||||
template<typename T> void check_shape_functions(T original)
|
||||
{
|
||||
using mat_t = matrix<typename T::value_type,Dynamic,Dynamic,T::storage_order>;
|
||||
using 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);
|
||||
prepare([&](auto r, auto c) { return original(c, r); }, result);
|
||||
|
||||
TTS_EQUAL(transpose(original) , result );
|
||||
TTS_EQUAL(conjugate(original) , original);
|
||||
TTS_EQUAL(adjoint(original) , result );
|
||||
TTS_EQUAL(transpose(original), result);
|
||||
TTS_EQUAL(conjugate(original), original);
|
||||
TTS_EQUAL(adjoint(original), 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;
|
||||
transposeInPlace(original);
|
||||
|
|
@ -49,37 +49,37 @@ namespace rotgen::tests
|
|||
}
|
||||
}
|
||||
|
||||
if constexpr(!rotgen::use_expression_templates)
|
||||
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(original.transpose()));
|
||||
TTS_EXPECT(verify_rotgen_reentrance(original.conjugate()));
|
||||
TTS_EXPECT(verify_rotgen_reentrance(original.adjoint()));
|
||||
}
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void check_reduction_functions(const T& input)
|
||||
template<typename T> void check_reduction_functions(T const& input)
|
||||
{
|
||||
using EigenMatrix = Eigen::Matrix<typename T::value_type, Eigen::Dynamic, Eigen::Dynamic>;
|
||||
using EigenMatrix =
|
||||
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);
|
||||
prepare([&](auto r, auto c) { return input(r, c); }, 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(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());
|
||||
|
||||
{
|
||||
int row, col, ref_row, ref_col;
|
||||
|
||||
TTS_EQUAL(minCoeff(input,&row, &col), ref.minCoeff(&ref_row, &ref_col));
|
||||
TTS_EQUAL(minCoeff(input, &row, &col), 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(input, &row, &col), ref.maxCoeff(&ref_row, &ref_col));
|
||||
TTS_EQUAL(row, ref_row);
|
||||
TTS_EQUAL(col, ref_col);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,81 +12,82 @@
|
|||
|
||||
namespace rotgen::tests
|
||||
{
|
||||
template<typename T>
|
||||
void check_cwise_functions(const T& input)
|
||||
template<typename T> void check_cwise_functions(T const& input)
|
||||
{
|
||||
using EigenMatrix = Eigen::Matrix<typename T::value_type, Eigen::Dynamic, Eigen::Dynamic>;
|
||||
using mat_t = matrix<typename T::value_type,Dynamic,Dynamic,T::storage_order>;
|
||||
using EigenMatrix =
|
||||
Eigen::Matrix<typename T::value_type, Eigen::Dynamic, Eigen::Dynamic>;
|
||||
using 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);
|
||||
prepare([&](auto r, auto c) { return input(r, c); }, e_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);
|
||||
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);
|
||||
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);
|
||||
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 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);
|
||||
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()")
|
||||
{
|
||||
e_ref = e_ref.cwiseAbs();
|
||||
prepare([&](auto r, auto c) { return e_ref(r,c); }, ref);
|
||||
prepare([&](auto r, auto c) { return e_ref(r, c); }, ref);
|
||||
TTS_EQUAL(rotgen::abs(input), ref);
|
||||
}
|
||||
|
||||
TTS_AND_THEN("abs2()")
|
||||
{
|
||||
e_ref = e_ref.cwiseAbs2();
|
||||
prepare([&](auto r, auto c) { return e_ref(r,c); }, ref);
|
||||
prepare([&](auto r, auto c) { return e_ref(r, c); }, ref);
|
||||
TTS_EQUAL(rotgen::abs2(input), ref);
|
||||
}
|
||||
|
||||
TTS_AND_THEN("rec")
|
||||
{
|
||||
e_ref = e_ref.cwiseInverse();
|
||||
prepare([&](auto r, auto c) { return e_ref(r,c); }, ref);
|
||||
prepare([&](auto r, auto c) { return e_ref(r, c); }, ref);
|
||||
TTS_EQUAL(rotgen::rec(input), ref);
|
||||
}
|
||||
|
||||
TTS_AND_THEN("sqrt")
|
||||
{
|
||||
e_ref = e_ref.cwiseAbs().cwiseSqrt();
|
||||
auto mat = input.cwiseAbs();
|
||||
auto mat = input.cwiseAbs();
|
||||
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 < input.rows(); ++r)
|
||||
for (rotgen::Index c = 0; c < input.cols(); ++c)
|
||||
TTS_ULP_EQUAL(proper_input(r, c), e_ref(r, c), 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,27 +12,29 @@
|
|||
|
||||
namespace rotgen::tests
|
||||
{
|
||||
template<typename T>
|
||||
void check_norms_functions(const T& input)
|
||||
template<typename T> void check_norms_functions(T const& input)
|
||||
{
|
||||
using EigenMatrix = Eigen::Matrix<typename T::value_type, Eigen::Dynamic, Eigen::Dynamic>;
|
||||
using EigenMatrix =
|
||||
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);
|
||||
prepare([&](auto r, auto c) { return input(r, c); }, 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(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>());
|
||||
|
||||
if constexpr(T::IsVectorAtCompileTime)
|
||||
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>;
|
||||
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);
|
||||
prepare([&](auto r, auto c) { return e_norm(r, c); }, norm_ref);
|
||||
|
||||
TTS_EQUAL(rotgen::normalized(input), norm_ref);
|
||||
|
||||
|
|
|
|||
|
|
@ -15,26 +15,25 @@ namespace rotgen::tests
|
|||
{
|
||||
struct matrix_descriptor
|
||||
{
|
||||
rotgen::Index rows, cols;
|
||||
std::function<double(std::size_t,std::size_t)> init_fn;
|
||||
rotgen::Index rows, cols;
|
||||
std::function<double(std::size_t, std::size_t)> init_fn;
|
||||
};
|
||||
|
||||
template<rotgen::Index Rows, rotgen::Index Cols>
|
||||
template<rotgen::Index Rows, rotgen::Index Cols>
|
||||
struct static_matrix_descriptor
|
||||
{
|
||||
static constexpr rotgen::Index rows = Rows;
|
||||
static constexpr rotgen::Index cols = Cols;
|
||||
std::function<double(std::size_t,std::size_t)> init_fn;
|
||||
std::function<double(std::size_t, std::size_t)> init_fn;
|
||||
};
|
||||
|
||||
template<typename MatrixType>
|
||||
struct matrix_block_test_case
|
||||
template<typename MatrixType> struct matrix_block_test_case
|
||||
{
|
||||
matrix_descriptor matrix_desc;
|
||||
rotgen::Index i0, j0, ni, nj;
|
||||
rotgen::Index i0, j0, ni, nj;
|
||||
};
|
||||
|
||||
template<typename MatrixType, rotgen::Index NI, rotgen::Index NJ>
|
||||
template<typename MatrixType, rotgen::Index NI, rotgen::Index NJ>
|
||||
struct static_matrix_block_test_case
|
||||
{
|
||||
matrix_descriptor matrix_desc;
|
||||
|
|
@ -43,25 +42,25 @@ namespace rotgen::tests
|
|||
rotgen::Index i0, j0;
|
||||
};
|
||||
|
||||
void prepare(rotgen::Index rows, rotgen::Index cols, auto const &init_fn, auto& output)
|
||||
void prepare(rotgen::Index rows,
|
||||
rotgen::Index cols,
|
||||
auto const& init_fn,
|
||||
auto& output)
|
||||
{
|
||||
for (rotgen::Index r = 0; r < rows; ++r)
|
||||
for (rotgen::Index c = 0; c < cols; ++c)
|
||||
output(r,c) = init_fn(r, c);
|
||||
for (rotgen::Index c = 0; c < cols; ++c) output(r, c) = init_fn(r, c);
|
||||
}
|
||||
|
||||
void prepare(auto fn, auto& output)
|
||||
{
|
||||
for (rotgen::Index r = 0; r < output.rows(); ++r)
|
||||
for (rotgen::Index c = 0; c < output.cols(); ++c)
|
||||
output(r,c) = fn(r, c);
|
||||
for (rotgen::Index c = 0; c < output.cols(); ++c) output(r, c) = fn(r, c);
|
||||
}
|
||||
|
||||
auto generate_matrix_references()
|
||||
{
|
||||
auto fn = [](auto r, auto c) { return r + 3 * c - 2.5; };
|
||||
std::vector<rotgen::tests::matrix_descriptor> cases =
|
||||
{
|
||||
std::vector<rotgen::tests::matrix_descriptor> cases = {
|
||||
// Singular matrix
|
||||
{1, 1, fn},
|
||||
// Square matrix below MAX_SIZE
|
||||
|
|
@ -81,8 +80,7 @@ namespace rotgen::tests
|
|||
// Thick matrix at MAX_SIZE
|
||||
{2, 8, fn},
|
||||
// Thick matrix above MAX_SIZE
|
||||
{3, 10, fn}
|
||||
};
|
||||
{3, 10, fn}};
|
||||
|
||||
return cases;
|
||||
}
|
||||
|
|
@ -90,102 +88,96 @@ namespace rotgen::tests
|
|||
auto generate_static_matrix_references()
|
||||
{
|
||||
auto fn = [](auto r, auto c) { return r + 3 * c - 2.5; };
|
||||
std::tuple cases =
|
||||
{
|
||||
// Singular matrix
|
||||
static_matrix_descriptor< 1, 1>{fn},
|
||||
// Square matrix below MAX_SIZE
|
||||
static_matrix_descriptor< 3, 3>{fn},
|
||||
// Square matrix at MAX_SIZE
|
||||
static_matrix_descriptor< 4, 4>{fn},
|
||||
// Square matrix above MAX_SIZE
|
||||
static_matrix_descriptor< 7, 7>{fn},
|
||||
// Tall matrix below MAX_SIZE
|
||||
static_matrix_descriptor< 5, 2>{fn},
|
||||
// Tall matrix at MAX_SIZE
|
||||
static_matrix_descriptor< 8, 2>{fn},
|
||||
// Tall matrix above MAX_SIZE
|
||||
static_matrix_descriptor<10, 3>{fn},
|
||||
// Thick matrix below MAX_SIZE
|
||||
static_matrix_descriptor< 2, 5>{fn},
|
||||
// Thick matrix at MAX_SIZE
|
||||
static_matrix_descriptor< 2, 8>{fn},
|
||||
// Thick matrix above MAX_SIZE
|
||||
static_matrix_descriptor< 3,10>{fn}
|
||||
};
|
||||
std::tuple cases = {// Singular matrix
|
||||
static_matrix_descriptor<1, 1>{fn},
|
||||
// Square matrix below MAX_SIZE
|
||||
static_matrix_descriptor<3, 3>{fn},
|
||||
// Square matrix at MAX_SIZE
|
||||
static_matrix_descriptor<4, 4>{fn},
|
||||
// Square matrix above MAX_SIZE
|
||||
static_matrix_descriptor<7, 7>{fn},
|
||||
// Tall matrix below MAX_SIZE
|
||||
static_matrix_descriptor<5, 2>{fn},
|
||||
// Tall matrix at MAX_SIZE
|
||||
static_matrix_descriptor<8, 2>{fn},
|
||||
// Tall matrix above MAX_SIZE
|
||||
static_matrix_descriptor<10, 3>{fn},
|
||||
// Thick matrix below MAX_SIZE
|
||||
static_matrix_descriptor<2, 5>{fn},
|
||||
// Thick matrix at MAX_SIZE
|
||||
static_matrix_descriptor<2, 8>{fn},
|
||||
// Thick matrix above MAX_SIZE
|
||||
static_matrix_descriptor<3, 10>{fn}};
|
||||
|
||||
return cases;
|
||||
}
|
||||
|
||||
template<typename T, typename O>
|
||||
auto generate_block_references()
|
||||
template<typename T, typename O> auto generate_block_references()
|
||||
{
|
||||
rotgen::tests::matrix_descriptor base{16,16,[](auto r, auto c) { return r + 3 * c - 2.5; }};
|
||||
rotgen::tests::matrix_descriptor base{
|
||||
16, 16, [](auto r, auto c) { return r + 3 * c - 2.5; }};
|
||||
|
||||
using mat_t = rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value>;
|
||||
using mat_t = rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>;
|
||||
|
||||
std::vector<rotgen::tests::matrix_block_test_case<mat_t>> cases =
|
||||
{
|
||||
std::vector<rotgen::tests::matrix_block_test_case<mat_t>> cases = {
|
||||
// Singular blocks
|
||||
{base, 0, 0, 1, 1},
|
||||
{base, 3, 2, 1, 1},
|
||||
{base, 4,11, 1, 1},
|
||||
{base,15,15, 1, 1},
|
||||
{base, 4, 11, 1, 1},
|
||||
{base, 15, 15, 1, 1},
|
||||
// Square block below MAX_SIZE
|
||||
{base,7,9, 3, 3},
|
||||
{base, 7, 9, 3, 3},
|
||||
// Square block at MAX_SIZE
|
||||
{base,6,3, 4, 4},
|
||||
{base, 6, 3, 4, 4},
|
||||
// Square block above MAX_SIZE
|
||||
{base,6,3, 6, 6},
|
||||
{base, 6, 3, 6, 6},
|
||||
// Tall block below MAX_SIZE
|
||||
{base,6,3, 5, 2},
|
||||
{base, 6, 3, 5, 2},
|
||||
// Tall block at MAX_SIZE
|
||||
{base,6,3, 8, 2},
|
||||
{base, 6, 3, 8, 2},
|
||||
// Tall block above MAX_SIZE
|
||||
{base,6,3, 7, 3},
|
||||
{base, 6, 3, 7, 3},
|
||||
// Thick block below MAX_SIZE
|
||||
{base,6,3, 2, 5},
|
||||
{base, 6, 3, 2, 5},
|
||||
// Thick block at MAX_SIZE
|
||||
{base,6,3, 2, 8},
|
||||
{base, 6, 3, 2, 8},
|
||||
// Thick block above MAX_SIZE
|
||||
{base,6,3, 3, 7}
|
||||
};
|
||||
{base, 6, 3, 3, 7}};
|
||||
|
||||
return cases;
|
||||
}
|
||||
template<typename T, typename O>
|
||||
auto generate_static_block_references()
|
||||
|
||||
template<typename T, typename O> auto generate_static_block_references()
|
||||
{
|
||||
rotgen::tests::matrix_descriptor base{16,16,[](auto r, auto c) { return r + 3 * c - 2.5; }};
|
||||
rotgen::tests::matrix_descriptor base{
|
||||
16, 16, [](auto r, auto c) { return r + 3 * c - 2.5; }};
|
||||
|
||||
using mat_t = rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value>;
|
||||
using mat_t = rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>;
|
||||
|
||||
std::tuple cases =
|
||||
{
|
||||
std::tuple cases = {
|
||||
// Singular blocks
|
||||
static_matrix_block_test_case<mat_t, 1, 1>{base, 0, 0},
|
||||
static_matrix_block_test_case<mat_t, 1, 1>{base, 3, 2},
|
||||
static_matrix_block_test_case<mat_t, 1, 1>{base, 4,11},
|
||||
static_matrix_block_test_case<mat_t, 1, 1>{base,15,15},
|
||||
static_matrix_block_test_case<mat_t, 1, 1>{base, 4, 11},
|
||||
static_matrix_block_test_case<mat_t, 1, 1>{base, 15, 15},
|
||||
// Square block below MAX_SIZE
|
||||
static_matrix_block_test_case<mat_t, 3, 3>{base,7,9},
|
||||
static_matrix_block_test_case<mat_t, 3, 3>{base, 7, 9},
|
||||
// Square block at MAX_SIZE
|
||||
static_matrix_block_test_case<mat_t, 4, 4>{base,6,3},
|
||||
static_matrix_block_test_case<mat_t, 4, 4>{base, 6, 3},
|
||||
// Square block above MAX_SIZE
|
||||
static_matrix_block_test_case<mat_t, 6, 6>{base,6,3},
|
||||
static_matrix_block_test_case<mat_t, 6, 6>{base, 6, 3},
|
||||
// Tall block below MAX_SIZE
|
||||
static_matrix_block_test_case<mat_t, 5, 2>{base,6,3},
|
||||
static_matrix_block_test_case<mat_t, 5, 2>{base, 6, 3},
|
||||
// Tall block at MAX_SIZE
|
||||
static_matrix_block_test_case<mat_t, 8, 2>{base,6,3},
|
||||
static_matrix_block_test_case<mat_t, 8, 2>{base, 6, 3},
|
||||
// Tall block above MAX_SIZE
|
||||
static_matrix_block_test_case<mat_t, 7, 3>{base,6,3},
|
||||
static_matrix_block_test_case<mat_t, 7, 3>{base, 6, 3},
|
||||
// Thick block below MAX_SIZE
|
||||
static_matrix_block_test_case<mat_t, 2, 5>{base,6,3},
|
||||
static_matrix_block_test_case<mat_t, 2, 5>{base, 6, 3},
|
||||
// Thick block at MAX_SIZE
|
||||
static_matrix_block_test_case<mat_t, 2, 8>{base,6,3},
|
||||
static_matrix_block_test_case<mat_t, 2, 8>{base, 6, 3},
|
||||
// Thick block above MAX_SIZE
|
||||
static_matrix_block_test_case<mat_t, 3, 7>{base,6,3}
|
||||
};
|
||||
static_matrix_block_test_case<mat_t, 3, 7>{base, 6, 3}};
|
||||
|
||||
return cases;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue