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
|
|
@ -8,27 +8,28 @@
|
|||
#include "unit/tests.hpp"
|
||||
#include <rotgen/rotgen.hpp>
|
||||
|
||||
TTS_CASE_TPL("System solver using QR", rotgen::tests::types)
|
||||
<typename T, typename O>( tts::type< tts::types<T,O>> )
|
||||
TTS_CASE_TPL("System solver using QR",
|
||||
rotgen::tests::types)<typename T, typename O>(
|
||||
tts::type<tts::types<T, O>>)
|
||||
{
|
||||
rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic>
|
||||
a { { 2.3, -1, 0.1}
|
||||
, {-1.6, 2.6, -1}
|
||||
, { 0.3, -1, 2}
|
||||
};
|
||||
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic> a{{2.3, -1, 0.1},
|
||||
{-1.6, 2.6, -1},
|
||||
{0.3, -1, 2}};
|
||||
|
||||
rotgen::matrix<T,rotgen::Dynamic,1> b(3,1);
|
||||
b(0) = b(2) = 1; b(1) = 0;
|
||||
rotgen::matrix<T, rotgen::Dynamic, 1> b(3, 1);
|
||||
b(0) = b(2) = 1;
|
||||
b(1) = 0;
|
||||
|
||||
rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic> r(3,1), error;
|
||||
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic> r(3, 1), error;
|
||||
|
||||
auto x = rotgen::extract(r,0,0,3,1);
|
||||
auto x = rotgen::extract(r, 0, 0, 3, 1);
|
||||
rotgen::solver::qr(x, a, b);
|
||||
|
||||
error = a * r - b;
|
||||
auto eps = std::numeric_limits<T>::epsilon();
|
||||
|
||||
TTS_LESS(rotgen::maxCoeff(rotgen::abs(error)) / eps, 5)
|
||||
<< "Result:\n" << r << "\n"
|
||||
<< "Residuals:\n" << error << "\n";
|
||||
};
|
||||
TTS_LESS(rotgen::maxCoeff(rotgen::abs(error)) / eps, 5) << "Result:\n"
|
||||
<< r << "\n"
|
||||
<< "Residuals:\n"
|
||||
<< error << "\n";
|
||||
};
|
||||
|
|
|
|||
|
|
@ -8,47 +8,58 @@
|
|||
#include "unit/tests.hpp"
|
||||
#include <rotgen/rotgen.hpp>
|
||||
|
||||
TTS_CASE_TPL("rowwise API", rotgen::tests::types)
|
||||
<typename T, typename O>( tts::type< tts::types<T,O>> )
|
||||
TTS_CASE_TPL("rowwise API", rotgen::tests::types)<typename T, typename O>(
|
||||
tts::type<tts::types<T, O>>)
|
||||
{
|
||||
using e_t = Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic,O::value>;
|
||||
e_t ref = e_t::Random(4,4);
|
||||
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();
|
||||
|
||||
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> mat(4, 4);
|
||||
rotgen::tests::prepare([&](auto r, auto c) { return ref(r, c); }, mat);
|
||||
|
||||
auto rw = rotgen::rowwise(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 < 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));
|
||||
};
|
||||
|
||||
TTS_CASE_TPL("colwise API", rotgen::tests::types)
|
||||
<typename T, typename O>( tts::type< tts::types<T,O>> )
|
||||
TTS_CASE_TPL("colwise API", rotgen::tests::types)<typename T, typename O>(
|
||||
tts::type<tts::types<T, O>>)
|
||||
{
|
||||
using e_t = Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic,O::value>;
|
||||
e_t ref = e_t::Random(4,4);
|
||||
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();
|
||||
|
||||
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> mat(4, 4);
|
||||
rotgen::tests::prepare([&](auto r, auto c) { return ref(r, c); }, mat);
|
||||
|
||||
auto rw = rotgen::colwise(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 < 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));
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -10,27 +10,28 @@
|
|||
#include <functional>
|
||||
#include <array>
|
||||
|
||||
template <typename MatrixType>
|
||||
struct MatrixDescriptor
|
||||
template<typename MatrixType> struct MatrixDescriptor
|
||||
{
|
||||
std::size_t rows, cols;
|
||||
std::function<void(MatrixType &, std::size_t, std::size_t)> init_fn;
|
||||
std::function<void(MatrixType&, std::size_t, std::size_t)> init_fn;
|
||||
};
|
||||
|
||||
template <typename MatrixType, std::size_t N>
|
||||
void test_matrix_sizes(std::size_t rows, std::size_t cols,
|
||||
const std::function<void(MatrixType &, std::size_t, std::size_t)> &init_fn,
|
||||
const std::array<std::pair<int, int>, N>& resize_dimensions)
|
||||
template<typename MatrixType, std::size_t N>
|
||||
void test_matrix_sizes(
|
||||
std::size_t rows,
|
||||
std::size_t cols,
|
||||
std::function<void(MatrixType&, std::size_t, std::size_t)> const& init_fn,
|
||||
std::array<std::pair<int, int>, N> const& resize_dimensions)
|
||||
{
|
||||
MatrixType matrix(rows, cols);
|
||||
|
||||
for (std::size_t r = 0; r < rows; ++r)
|
||||
for (std::size_t c = 0; c < cols; ++c)
|
||||
init_fn(matrix, r, c);
|
||||
for (std::size_t c = 0; c < cols; ++c) init_fn(matrix, r, c);
|
||||
|
||||
TTS_EQUAL(rotgen::size(matrix), rows*cols);
|
||||
TTS_EQUAL(rotgen::size(matrix), rows * cols);
|
||||
|
||||
for (std::size_t i = 0; i < N; ++i) {
|
||||
for (std::size_t i = 0; i < N; ++i)
|
||||
{
|
||||
int r = resize_dimensions[i].first;
|
||||
int c = resize_dimensions[i].second;
|
||||
|
||||
|
|
@ -38,24 +39,22 @@ void test_matrix_sizes(std::size_t rows, std::size_t cols,
|
|||
|
||||
TTS_EQUAL(rotgen::rows(matrix), static_cast<size_t>(r));
|
||||
TTS_EQUAL(rotgen::cols(matrix), static_cast<size_t>(c));
|
||||
TTS_EQUAL(rotgen::size(matrix), static_cast<size_t>(r*c));
|
||||
TTS_EQUAL(rotgen::size(matrix), static_cast<size_t>(r * c));
|
||||
}
|
||||
|
||||
rotgen::conservativeResize(matrix, rows, cols);
|
||||
TTS_EQUAL(rotgen::size(matrix), rows*cols);
|
||||
TTS_EQUAL(rotgen::size(matrix), rows * cols);
|
||||
|
||||
int i = 1;
|
||||
for(std::size_t r=0;r<rows;++r)
|
||||
for(std::size_t c=0;c<cols;++c)
|
||||
matrix(r, c) = i++;
|
||||
for (std::size_t r = 0; r < rows; ++r)
|
||||
for (std::size_t c = 0; c < cols; ++c) matrix(r, c) = i++;
|
||||
|
||||
rotgen::conservativeResize(matrix, rows + 3, cols + 2);
|
||||
TTS_EQUAL(rotgen::size(matrix), (rows + 3)*(cols + 2));
|
||||
TTS_EQUAL(rotgen::size(matrix), (rows + 3) * (cols + 2));
|
||||
|
||||
i = 1;
|
||||
for(std::size_t r=0;r<rows;++r)
|
||||
for(std::size_t c=0;c<cols;++c)
|
||||
TTS_EQUAL(matrix(r,c),i++);
|
||||
for (std::size_t r = 0; r < rows; ++r)
|
||||
for (std::size_t c = 0; c < cols; ++c) TTS_EQUAL(matrix(r, c), i++);
|
||||
}
|
||||
|
||||
TTS_CASE("Matrix size-related operations")
|
||||
|
|
@ -63,18 +62,37 @@ TTS_CASE("Matrix size-related operations")
|
|||
std::vector<MatrixDescriptor<rotgen::matrix<double>>> test_matrices = {
|
||||
{3, 3, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = r + c; }},
|
||||
{2, 3, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = 0.0; }},
|
||||
{2, 7, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = -r*r*r - c*c - 1.23; }},
|
||||
{17, 3, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = r*c + 0.98; }},
|
||||
{2, 7,
|
||||
[](auto& m, std::size_t r, std::size_t c) {
|
||||
m(r, c) = -r * r * r - c * c - 1.23;
|
||||
}},
|
||||
{17, 3,
|
||||
[](auto& m, std::size_t r, std::size_t c) { m(r, c) = r * c + 0.98; }},
|
||||
{1, 1, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = 42.0; }},
|
||||
{10, 11, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = std::tan(r + c); }},
|
||||
{1, 5, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = -1.5*r + 2.56*c + 3.33; }},
|
||||
{7, 1, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = (r == c ? 1.0 : 0.0); }},
|
||||
{0, 0, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = (r == c ? 1.0 : 0.0); }},
|
||||
{10, 11,
|
||||
[](auto& m, std::size_t r, std::size_t c) { m(r, c) = std::tan(r + c); }},
|
||||
{1, 5,
|
||||
[](auto& m, std::size_t r, std::size_t c) {
|
||||
m(r, c) = -1.5 * r + 2.56 * c + 3.33;
|
||||
}},
|
||||
{7, 1,
|
||||
[](auto& m, std::size_t r, std::size_t c) {
|
||||
m(r, c) = (r == c ? 1.0 : 0.0);
|
||||
}},
|
||||
{0, 0,
|
||||
[](auto& m, std::size_t r, std::size_t c) {
|
||||
m(r, c) = (r == c ? 1.0 : 0.0);
|
||||
}},
|
||||
};
|
||||
|
||||
for (const auto& [rows, cols, init_fn] : test_matrices)
|
||||
test_matrix_sizes<rotgen::matrix<double>>(rows, cols, init_fn, std::array{
|
||||
std::pair{1, 2}, std::pair{11, 17}, std::pair{4, 5},
|
||||
std::pair{9, 1}, std::pair{3, 8}, std::pair{22, 0},
|
||||
});
|
||||
for (auto const& [rows, cols, init_fn] : test_matrices)
|
||||
test_matrix_sizes<rotgen::matrix<double>>(rows, cols, init_fn,
|
||||
std::array{
|
||||
std::pair{1, 2},
|
||||
std::pair{11, 17},
|
||||
std::pair{4, 5},
|
||||
std::pair{9, 1},
|
||||
std::pair{3, 8},
|
||||
std::pair{22, 0},
|
||||
});
|
||||
};
|
||||
|
|
|
|||
|
|
@ -8,23 +8,24 @@
|
|||
#include "unit/tests.hpp"
|
||||
#include <rotgen/rotgen.hpp>
|
||||
|
||||
TTS_CASE_TPL("SVD decomposition - Dynamic case", rotgen::tests::types)
|
||||
<typename T, typename O>( tts::type< tts::types<T,O>> )
|
||||
TTS_CASE_TPL("SVD decomposition - Dynamic case",
|
||||
rotgen::tests::types)<typename T, typename O>(
|
||||
tts::type<tts::types<T, O>>)
|
||||
{
|
||||
int rank, i = 5;
|
||||
auto eps = std::numeric_limits<T>::epsilon();
|
||||
|
||||
auto m = rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value>::Random(5,5);
|
||||
auto m =
|
||||
rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value>::Random(5, 5);
|
||||
auto decomp = rotgen::svd(m);
|
||||
|
||||
do
|
||||
{
|
||||
rank = decomp.rank();
|
||||
do {
|
||||
rank = decomp.rank();
|
||||
|
||||
auto u = decomp.U(rank);
|
||||
auto d = decomp.singular_values(rank);
|
||||
auto u = decomp.U(rank);
|
||||
auto d = decomp.singular_values(rank);
|
||||
auto dd = decomp.D(rank);
|
||||
auto v = decomp.V(rank);
|
||||
auto v = decomp.V(rank);
|
||||
|
||||
TTS_EQUAL(rank, i);
|
||||
|
||||
|
|
@ -32,34 +33,36 @@ TTS_CASE_TPL("SVD decomposition - Dynamic case", rotgen::tests::types)
|
|||
auto error = m - rec;
|
||||
|
||||
TTS_LESS_EQUAL(rotgen::maxCoeff(rotgen::abs(error)) / eps, 16.)
|
||||
<< "Result:\n" << rec << "\n"
|
||||
<< "Residuals:\n" << error << "\n";
|
||||
<< "Result:\n"
|
||||
<< rec << "\n"
|
||||
<< "Residuals:\n"
|
||||
<< error << "\n";
|
||||
|
||||
// Reduce rank by duplicating one column
|
||||
i--;
|
||||
col(m,i) = col(m,0);
|
||||
col(m, i) = col(m, 0);
|
||||
decomp = rotgen::svd(m);
|
||||
|
||||
}while(rank != 1);
|
||||
} while (rank != 1);
|
||||
};
|
||||
|
||||
TTS_CASE_TPL("SVD decomposition - Static case", rotgen::tests::types)
|
||||
<typename T, typename O>( tts::type< tts::types<T,O>> )
|
||||
TTS_CASE_TPL("SVD decomposition - Static case",
|
||||
rotgen::tests::types)<typename T, typename O>(
|
||||
tts::type<tts::types<T, O>>)
|
||||
{
|
||||
int rank, i = 5;
|
||||
auto eps = std::numeric_limits<T>::epsilon();
|
||||
|
||||
auto m = rotgen::matrix<T,5,5,O::value>::Random();
|
||||
auto m = rotgen::matrix<T, 5, 5, O::value>::Random();
|
||||
auto decomp = rotgen::svd(m);
|
||||
|
||||
do
|
||||
{
|
||||
rank = decomp.rank();
|
||||
do {
|
||||
rank = decomp.rank();
|
||||
|
||||
auto u = decomp.U(rank);
|
||||
auto d = decomp.singular_values(rank);
|
||||
auto u = decomp.U(rank);
|
||||
auto d = decomp.singular_values(rank);
|
||||
auto dd = decomp.D(rank);
|
||||
auto v = decomp.V(rank);
|
||||
auto v = decomp.V(rank);
|
||||
|
||||
TTS_EQUAL(rank, i);
|
||||
|
||||
|
|
@ -67,13 +70,15 @@ TTS_CASE_TPL("SVD decomposition - Static case", rotgen::tests::types)
|
|||
auto error = m - rec;
|
||||
|
||||
TTS_LESS_EQUAL(rotgen::maxCoeff(rotgen::abs(error)) / eps, 16.)
|
||||
<< "Result:\n" << rec << "\n"
|
||||
<< "Residuals:\n" << error << "\n";
|
||||
<< "Result:\n"
|
||||
<< rec << "\n"
|
||||
<< "Residuals:\n"
|
||||
<< error << "\n";
|
||||
|
||||
// Reduce rank by duplicating one column
|
||||
i--;
|
||||
col(m,i) = col(m,0);
|
||||
col(m, i) = col(m, 0);
|
||||
decomp = rotgen::svd(m);
|
||||
|
||||
}while(rank != 1);
|
||||
};
|
||||
} while (rank != 1);
|
||||
};
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue