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

Adding clang-format configuration file and formatting all source files

Browse source 
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 2025-10-14 16:19:03 +02:00
parent e92e824a18
commit 648dd768ee
94 changed files with 6778 additions and 4722 deletions
Download patch file Download diff file Expand all files Collapse all files

34
src/block/generate.cpp
View file

@ -9,10 +9,10 @@
#define TYPE double
#define STORAGE_ORDER Eigen::ColMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME,SIZE,_col)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_col)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_row)
#define MAPNAME ROTGEN_MATRIX_NAME(BASEMAP,SIZE,_col)
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _col)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#define MAPNAME ROTGEN_MATRIX_NAME(BASEMAP, SIZE, _col)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSSOURCENAME
@ -21,10 +21,10 @@
#undef STORAGE_ORDER
#define STORAGE_ORDER Eigen::RowMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME,SIZE,_row)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_row)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_col)
#define MAPNAME ROTGEN_MATRIX_NAME(BASEMAP,SIZE,_row)
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _row)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#define MAPNAME ROTGEN_MATRIX_NAME(BASEMAP, SIZE, _row)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSSOURCENAME
@ -39,10 +39,10 @@
#define TYPE float
#define STORAGE_ORDER Eigen::ColMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME,SIZE,_col)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_col)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_row)
#define MAPNAME ROTGEN_MATRIX_NAME(BASEMAP,SIZE,_col)
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _col)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#define MAPNAME ROTGEN_MATRIX_NAME(BASEMAP, SIZE, _col)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSSOURCENAME
@ -51,10 +51,10 @@
#undef STORAGE_ORDER
#define STORAGE_ORDER Eigen::RowMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME,SIZE,_row)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_row)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_col)
#define MAPNAME ROTGEN_MATRIX_NAME(BASEMAP,SIZE,_row)
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _row)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#define MAPNAME ROTGEN_MATRIX_NAME(BASEMAP, SIZE, _row)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSSOURCENAME
@ -63,4 +63,4 @@
#undef STORAGE_ORDER
#undef SIZE
#undef TYPE
#undef TYPE

32
src/block/impl.cpp
View file

@ -13,21 +13,21 @@
namespace rotgen
{
#define USE_CONST
#define CONST const
#define BASENAME block_const_impl
#define BASEMAP map_const_impl
#include "generate.cpp"
#undef BASENAME
#undef BASEMAP
#undef USE_CONST
#undef CONST
#define USE_CONST
#define CONST const
#define BASENAME block_const_impl
#define BASEMAP map_const_impl
#include "generate.cpp"
#undef BASENAME
#undef BASEMAP
#undef USE_CONST
#undef CONST
#define CONST
#define BASENAME block_impl
#define BASEMAP map_impl
#include "generate.cpp"
#undef BASENAME
#undef BASEMAP
#undef CONST
#define CONST
#define BASENAME block_impl
#define BASEMAP map_impl
#include "generate.cpp"
#undef BASENAME
#undef BASEMAP
#undef CONST
}

900
src/block/model.cpp
View file

@ -17,518 +17,528 @@
//==================================================================================================
struct CLASSNAME::payload
{
using stride_type = Eigen::Stride<Eigen::Dynamic,Eigen::Dynamic>;
using matrix_type = Eigen::Matrix<TYPE,Eigen::Dynamic,Eigen::Dynamic,STORAGE_ORDER>;
using stride_type = Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>;
using matrix_type =
Eigen::Matrix<TYPE, Eigen::Dynamic, Eigen::Dynamic, STORAGE_ORDER>;
using matrix_block_type = Eigen::Block<matrix_type CONST>;
using matrix_storage_t = std::pair<matrix_block_type, matrix_type CONST*>;
using map_type = Eigen::Map<matrix_type CONST,Eigen::Unaligned,stride_type>;
using map_block_type = Eigen::Block<map_type CONST>;
using map_storage_t = std::pair<map_block_type, map_type CONST*>;
using data_type = std::variant<matrix_storage_t, map_storage_t>;
using matrix_storage_t = std::pair<matrix_block_type, matrix_type CONST*>;
using map_type = Eigen::Map<matrix_type CONST, Eigen::Unaligned, stride_type>;
using map_block_type = Eigen::Block<map_type CONST>;
using map_storage_t = std::pair<map_block_type, map_type CONST*>;
using data_type = std::variant<matrix_storage_t, map_storage_t>;
data_type data;
rotgen::Index abs_i0 = 0; // absolute start row in original matrix
rotgen::Index abs_j0 = 0; // absolute start col in original matrix
rotgen::Index rel_i0 = 0; // relative start row in original matrix
rotgen::Index rel_j0 = 0; // relative start col in original matrix
data_type data;
rotgen::Index abs_i0 = 0; // absolute start row in original matrix
rotgen::Index abs_j0 = 0; // absolute start col in original matrix
rotgen::Index rel_i0 = 0; // relative start row in original matrix
rotgen::Index rel_j0 = 0; // relative start col in original matrix
template <typename Func>
void apply(Func f) { std::visit([&](auto& blk) { return f(blk.first); }, data); }
template<typename Func> void apply(Func f)
{
std::visit([&](auto& blk) { return f(blk.first); }, data);
}
template <typename Func>
void apply(Func f) const { std::visit([&](auto const& blk) { return f(blk.first); }, data); }
template<typename Func> void apply(Func f) const
{
std::visit([&](auto const& blk) { return f(blk.first); }, data);
}
payload (data_type const& o) : data(o) {}
payload(data_type const& o) : data(o) {}
payload (SOURCENAME CONST& o, rotgen::Index i0, rotgen::Index j0, rotgen::Index ni, rotgen::Index nj)
: data(matrix_storage_t{matrix_block_type{o.storage()->data,i0,j0,ni,nj},&o.storage()->data})
, abs_i0(i0), abs_j0(j0), rel_i0(i0), rel_j0(j0)
{}
payload(SOURCENAME CONST& o,
rotgen::Index i0,
rotgen::Index j0,
rotgen::Index ni,
rotgen::Index nj)
: data(
matrix_storage_t{matrix_block_type{o.storage()->data, i0, j0, ni, nj},
&o.storage()->data}),
abs_i0(i0), abs_j0(j0), rel_i0(i0), rel_j0(j0)
{
}
payload (MAPNAME CONST& o, rotgen::Index i0, rotgen::Index j0, rotgen::Index ni, rotgen::Index nj)
: data(map_storage_t{map_block_type{o.storage()->data,i0,j0,ni,nj},&o.storage()->data})
, abs_i0(i0), abs_j0(j0), rel_i0(i0), rel_j0(j0)
{}
payload(MAPNAME CONST& o,
rotgen::Index i0,
rotgen::Index j0,
rotgen::Index ni,
rotgen::Index nj)
: data(map_storage_t{map_block_type{o.storage()->data, i0, j0, ni, nj},
&o.storage()->data}),
abs_i0(i0), abs_j0(j0), rel_i0(i0), rel_j0(j0)
{
}
};
//==================================================================================================
// Constructors & Special Members
//==================================================================================================
CLASSNAME::CLASSNAME(SOURCENAME CONST& r, Index i0, Index j0, Index ni, Index nj)
: storage_(std::make_unique<payload>(r, i0,j0,ni,nj))
{}
//==================================================================================================
// Constructors & Special Members
//==================================================================================================
CLASSNAME::CLASSNAME(
SOURCENAME CONST& r, Index i0, Index j0, Index ni, Index nj)
: storage_(std::make_unique<payload>(r, i0, j0, ni, nj))
{
}
CLASSNAME::CLASSNAME(MAPNAME CONST& r, Index i0, Index j0, Index ni, Index nj)
: storage_(std::make_unique<payload>(r, i0,j0,ni,nj))
{}
CLASSNAME::CLASSNAME(MAPNAME CONST& r, Index i0, Index j0, Index ni, Index nj)
: storage_(std::make_unique<payload>(r, i0, j0, ni, nj))
{
}
// We're building a block from a block - So we have to dig around the internals
CLASSNAME::CLASSNAME(payload const& o, Index i0, Index j0, Index ni, Index nj)
{
// Compute absolute indices from the parent stored block
Index abs_i0 = 0;
Index abs_j0 = 0;
std::visit( [&](auto const& blk)
{
abs_i0 = blk.first.startRow() + i0;
abs_j0 = blk.first.startCol() + j0;
}
, o.data
);
// We're building a block from a block - So we have to dig around the internals
CLASSNAME::CLASSNAME(payload const& o, Index i0, Index j0, Index ni, Index nj)
{
// Compute absolute indices from the parent stored block
Index abs_i0 = 0;
Index abs_j0 = 0;
std::visit(
[&](auto const& blk) {
abs_i0 = blk.first.startRow() + i0;
abs_j0 = blk.first.startCol() + j0;
},
o.data);
// Build a payload::data_type that holds the child block using absolute indices
payload::data_type new_data =
std::visit([&]<typename T>(T const& blk) -> payload::data_type
{
auto& [parent_block, ref] = blk;
using block_type = typename T::first_type;
return T{ block_type{ *ref, abs_i0, abs_j0, ni, nj }, ref };
}, o.data);
// Build a payload::data_type that holds the child block using absolute
// indices
payload::data_type new_data = std::visit(
[&]<typename T>(T const& blk) -> payload::data_type {
auto& [parent_block, ref] = blk;
using block_type = typename T::first_type;
return T{block_type{*ref, abs_i0, abs_j0, ni, nj}, ref};
},
o.data);
storage_ = std::make_unique<payload>(new_data);
storage_->abs_i0 = abs_i0;
storage_->abs_j0 = abs_j0;
storage_->rel_i0 = i0;
storage_->rel_j0 = j0;
}
storage_ = std::make_unique<payload>(new_data);
storage_->abs_i0 = abs_i0;
storage_->abs_j0 = abs_j0;
storage_->rel_i0 = i0;
storage_->rel_j0 = j0;
}
CLASSNAME::CLASSNAME(CLASSNAME const& o)
CLASSNAME::CLASSNAME(CLASSNAME const& o)
: storage_(std::make_unique<payload>(o.storage_->data))
{}
{
}
CLASSNAME::CLASSNAME(CLASSNAME&&) noexcept = default;
CLASSNAME::CLASSNAME(CLASSNAME&&) noexcept = default;
#if !defined(USE_CONST)
CLASSNAME& CLASSNAME::operator=(CLASSNAME const& o)
{
if (this != &o) { storage_->data = o.storage_->data; }
return *this;
}
#if !defined(USE_CONST)
CLASSNAME& CLASSNAME::operator=(CLASSNAME const& o)
{
if (this != &o) { storage_->data = o.storage_->data; }
return *this;
}
CLASSNAME& CLASSNAME::operator=(CLASSNAME&& o) noexcept
{
if (this != &o) { storage_->data = std::move(o.storage_->data); }
return *this;
}
#endif
CLASSNAME& CLASSNAME::operator=(CLASSNAME&& o) noexcept
{
if (this != &o) { storage_->data = std::move(o.storage_->data); }
return *this;
}
#endif
CLASSNAME::~CLASSNAME() = default;
CLASSNAME::~CLASSNAME() = default;
#if !defined(USE_CONST)
void CLASSNAME::assign(SOURCENAME const& m)
{
storage_->apply([&](auto& blk) { blk = m.storage()->data; });
}
#endif
#if !defined(USE_CONST)
void CLASSNAME::assign(SOURCENAME const& m)
{
storage_->apply([&](auto& blk)
{
blk = m.storage()->data;
});
}
#endif
//==================================================================================================
// Matrix API
//==================================================================================================
rotgen::Index CLASSNAME::rows() const
{
rotgen::Index that;
storage_->apply([&](auto const& blk) { that = blk.rows(); });
return that;
}
//==================================================================================================
// Matrix API
//==================================================================================================
rotgen::Index CLASSNAME::rows() const
{
rotgen::Index that;
storage_->apply([&](const auto& blk) { that = blk.rows(); });
return that;
}
rotgen::Index CLASSNAME::cols() const
{
rotgen::Index that;
storage_->apply([&](auto const& blk) { that = blk.cols(); });
return that;
}
rotgen::Index CLASSNAME::cols() const
{
rotgen::Index that;
storage_->apply([&](const auto& blk) { that = blk.cols(); });
return that;
}
rotgen::Index CLASSNAME::size() const
{
rotgen::Index that;
storage_->apply([&](auto const& blk) { that = blk.size(); });
return that;
}
rotgen::Index CLASSNAME::size() const
{
rotgen::Index that;
storage_->apply([&](const auto& blk) { that = blk.size(); });
return that;
}
rotgen::Index CLASSNAME::innerStride() const
{
rotgen::Index that;
storage_->apply([&](auto const& blk) { that = blk.innerStride(); });
return that;
}
rotgen::Index CLASSNAME::innerStride() const
{
rotgen::Index that;
storage_->apply([&](const auto& blk) { that = blk.innerStride(); });
return that;
}
rotgen::Index CLASSNAME::outerStride() const
{
rotgen::Index that;
storage_->apply([&](auto const& blk) { that = blk.outerStride(); });
return that;
}
rotgen::Index CLASSNAME::outerStride() const
{
rotgen::Index that;
storage_->apply([&](const auto& blk) { that = blk.outerStride(); });
return that;
}
rotgen::Index CLASSNAME::startRow() const
{
return storage_->rel_i0;
}
rotgen::Index CLASSNAME::startRow() const
{
return storage_->rel_i0;
}
rotgen::Index CLASSNAME::startCol() const
{
return storage_->rel_j0;
}
rotgen::Index CLASSNAME::startCol() const
{
return storage_->rel_j0;
}
// Element access by (i,j)
#if !defined(USE_CONST)
TYPE& CLASSNAME::operator()(Index i, Index j)
{
TYPE* ptr = nullptr;
storage_->apply([&](auto& blk) { ptr = &blk(i, j); });
return *ptr;
}
#endif
// Element access by (i,j)
#if !defined(USE_CONST)
TYPE& CLASSNAME::operator()(Index i, Index j)
{
TYPE* ptr = nullptr;
storage_->apply([&](auto& blk) { ptr = &blk(i,j); });
return *ptr;
}
#endif
TYPE CLASSNAME::operator()(Index i, Index j) const
{
TYPE ptr;
storage_->apply([&](auto const& blk) { ptr = blk(i, j); });
return ptr;
}
TYPE CLASSNAME::operator()(Index i, Index j) const
{
TYPE ptr;
storage_->apply([&](auto const& blk) { ptr = blk(i,j); });
return ptr;
}
// Element access by linear index
#if !defined(USE_CONST)
TYPE& CLASSNAME::operator()(Index index)
{
TYPE* ptr = nullptr;
storage_->apply([&](auto& blk) { ptr = blk.data() + index; });
return *ptr;
}
#endif
// Element access by linear index
#if !defined(USE_CONST)
TYPE& CLASSNAME::operator()(Index index)
{
TYPE* ptr = nullptr;
storage_->apply([&](auto& blk) { ptr = blk.data() + index; });
return *ptr;
}
#endif
TYPE CLASSNAME::operator()(Index index) const
{
TYPE ptr;
storage_->apply([&](auto const& blk) { ptr = *(blk.data() + index); });
return ptr;
}
TYPE CLASSNAME::operator()(Index index) const
{
TYPE ptr;
storage_->apply([&](auto const& blk) { ptr = *(blk.data() + index); });
return ptr;
}
// Raw pointer access
#if !defined(USE_CONST)
TYPE* CLASSNAME::data()
{
TYPE* ptr = nullptr;
storage_->apply([&](auto& blk) { ptr = blk.data(); });
return ptr;
}
#endif
// Raw pointer access
#if !defined(USE_CONST)
TYPE* CLASSNAME::data()
{
TYPE* ptr = nullptr;
storage_->apply([&](auto& blk) { ptr = blk.data(); });
return ptr;
}
#endif
TYPE const* CLASSNAME::data() const
{
TYPE const* ptr = nullptr;
storage_->apply([&](auto const& blk) { ptr = blk.data(); });
return ptr;
}
TYPE const* CLASSNAME::data() const
{
TYPE const* ptr = nullptr;
storage_->apply([&](auto const& blk) { ptr = blk.data(); });
return ptr;
}
//==================================================================================================
// Matrix operations
//==================================================================================================
SOURCENAME CLASSNAME::normalized() const
{
SOURCENAME result;
storage_->apply([&](auto const& blk) {
result.storage()->assign(blk.normalized().eval());
});
return result;
}
//==================================================================================================
// Matrix operations
//==================================================================================================
SOURCENAME CLASSNAME::normalized() const
{
SOURCENAME result;
storage_->apply([&](const auto& blk) { result.storage()->assign(blk.normalized().eval()); });
return result;
}
SOURCENAME CLASSNAME::transpose() const
{
SOURCENAME result;
storage_->apply(
[&](auto const& blk) { result.storage()->assign(blk.transpose().eval()); });
return result;
}
SOURCENAME CLASSNAME::transpose() const
{
SOURCENAME result;
storage_->apply([&](const auto& blk) { result.storage()->assign(blk.transpose().eval()); });
return result;
}
SOURCENAME CLASSNAME::conjugate() const
{
SOURCENAME result;
storage_->apply(
[&](auto const& blk) { result.storage()->assign(blk.conjugate().eval()); });
return result;
}
SOURCENAME CLASSNAME::conjugate() const
{
SOURCENAME result;
storage_->apply([&](const auto& blk) { result.storage()->assign(blk.conjugate().eval()); });
return result;
}
SOURCENAME CLASSNAME::adjoint() const
{
SOURCENAME result;
storage_->apply(
[&](auto const& blk) { result.storage()->assign(blk.adjoint().eval()); });
return result;
}
SOURCENAME CLASSNAME::adjoint() const
{
SOURCENAME result;
storage_->apply([&](const auto& blk) { result.storage()->assign(blk.adjoint().eval()); });
return result;
}
SOURCENAME CLASSNAME::cwiseAbs() const
{
SOURCENAME result;
storage_->apply(
[&](auto const& blk) { result.storage()->assign(blk.cwiseAbs().eval()); });
return result;
}
SOURCENAME CLASSNAME::cwiseAbs() const
{
SOURCENAME result;
storage_->apply([&](const auto& blk) { result.storage()->assign(blk.cwiseAbs().eval()); });
return result;
}
SOURCENAME CLASSNAME::cwiseAbs2() const
{
SOURCENAME result;
storage_->apply(
[&](auto const& blk) { result.storage()->assign(blk.cwiseAbs2().eval()); });
return result;
}
SOURCENAME CLASSNAME::cwiseAbs2() const
{
SOURCENAME result;
storage_->apply([&](const auto& blk) { result.storage()->assign(blk.cwiseAbs2().eval()); });
return result;
}
SOURCENAME CLASSNAME::cwiseInverse() const
{
SOURCENAME result;
storage_->apply([&](auto const& blk) {
result.storage()->assign(blk.cwiseInverse().eval());
});
return result;
}
SOURCENAME CLASSNAME::cwiseInverse() const
{
SOURCENAME result;
storage_->apply([&](const auto& blk) { result.storage()->assign(blk.cwiseInverse().eval()); });
return result;
}
SOURCENAME CLASSNAME::cwiseSqrt() const
{
SOURCENAME result;
storage_->apply(
[&](auto const& blk) { result.storage()->assign(blk.cwiseSqrt().eval()); });
return result;
}
SOURCENAME CLASSNAME::cwiseSqrt() const
{
SOURCENAME result;
storage_->apply([&](const auto& blk) { result.storage()->assign(blk.cwiseSqrt().eval()); });
return result;
}
#if !defined(USE_CONST)
void CLASSNAME::normalize()
{
storage_->apply([](auto& blk) { blk.normalize(); });
}
#if !defined(USE_CONST)
void CLASSNAME::normalize()
{
storage_->apply([](auto& blk) { blk.normalize(); });
}
void CLASSNAME::transposeInPlace()
{
storage_->apply([](auto& blk) { blk.transposeInPlace(); });
}
void CLASSNAME::transposeInPlace()
{
storage_->apply([](auto& blk) { blk.transposeInPlace(); });
}
void CLASSNAME::adjointInPlace()
{
storage_->apply([](auto& blk) { blk.adjointInPlace(); });
}
#endif
void CLASSNAME::adjointInPlace()
{
storage_->apply([](auto& blk) { blk.adjointInPlace(); });
}
#endif
//==================================================================================================
// Reductions
//==================================================================================================
TYPE CLASSNAME::sum() const
{
TYPE val{};
storage_->apply([&](auto const& blk) { val = blk.sum(); });
return val;
}
//==================================================================================================
// Reductions
//==================================================================================================
TYPE CLASSNAME::sum() const
{
TYPE val{};
storage_->apply([&](const auto& blk) { val = blk.sum(); });
return val;
}
TYPE CLASSNAME::prod() const
{
TYPE val{};
storage_->apply([&](auto const& blk) { val = blk.prod(); });
return val;
}
TYPE CLASSNAME::prod() const
{
TYPE val{};
storage_->apply([&](const auto& blk) { val = blk.prod(); });
return val;
}
TYPE CLASSNAME::mean() const
{
TYPE val{};
storage_->apply([&](auto const& blk) { val = blk.mean(); });
return val;
}
TYPE CLASSNAME::mean() const
{
TYPE val{};
storage_->apply([&](const auto& blk) { val = blk.mean(); });
return val;
}
TYPE CLASSNAME::trace() const
{
TYPE val{};
storage_->apply([&](auto const& blk) { val = blk.trace(); });
return val;
}
TYPE CLASSNAME::trace() const
{
TYPE val{};
storage_->apply([&](const auto& blk) { val = blk.trace(); });
return val;
}
TYPE CLASSNAME::minCoeff() const
{
TYPE val{};
storage_->apply([&](auto const& blk) { val = blk.minCoeff(); });
return val;
}
TYPE CLASSNAME::minCoeff() const
{
TYPE val{};
storage_->apply([&](const auto& blk) { val = blk.minCoeff(); });
return val;
}
TYPE CLASSNAME::maxCoeff() const
{
TYPE val{};
storage_->apply([&](auto const& blk) { val = blk.maxCoeff(); });
return val;
}
TYPE CLASSNAME::maxCoeff() const
{
TYPE val{};
storage_->apply([&](const auto& blk) { val = blk.maxCoeff(); });
return val;
}
TYPE CLASSNAME::minCoeff(Index* row, Index* col) const
{
TYPE val{};
storage_->apply([&](auto const& blk) { val = blk.minCoeff(row, col); });
return val;
}
TYPE CLASSNAME::minCoeff(Index* row, Index* col) const
{
TYPE val{};
storage_->apply([&](const auto& blk) { val = blk.minCoeff(row, col); });
return val;
}
TYPE CLASSNAME::maxCoeff(Index* row, Index* col) const
{
TYPE val{};
storage_->apply([&](auto const& blk) { val = blk.maxCoeff(row, col); });
return val;
}
TYPE CLASSNAME::maxCoeff(Index* row, Index* col) const
{
TYPE val{};
storage_->apply([&](const auto& blk) { val = blk.maxCoeff(row, col); });
return val;
}
TYPE CLASSNAME::squaredNorm() const
{
TYPE val{};
storage_->apply([&](auto const& blk) { val = blk.squaredNorm(); });
return val;
}
TYPE CLASSNAME::squaredNorm() const
{
TYPE val{};
storage_->apply([&](const auto& blk) { val = blk.squaredNorm(); });
return val;
}
TYPE CLASSNAME::norm() const
{
TYPE val{};
storage_->apply([&](auto const& blk) { val = blk.norm(); });
return val;
}
TYPE CLASSNAME::norm() const
{
TYPE val{};
storage_->apply([&](const auto& blk) { val = blk.norm(); });
return val;
}
TYPE CLASSNAME::lpNorm(int p) const
{
TYPE val{};
storage_->apply([&](auto const& blk) {
if (p == 1) val = blk.template lpNorm<1>();
else if (p == 2) val = blk.template lpNorm<2>();
else val = blk.template lpNorm<Eigen::Infinity>();
});
return val;
}
TYPE CLASSNAME::lpNorm(int p) const
{
TYPE val{};
storage_->apply([&](const auto& blk)
{
if (p == 1) val = blk.template lpNorm<1>();
else if (p == 2) val = blk.template lpNorm<2>();
else val = blk.template lpNorm<Eigen::Infinity>();
});
return val;
}
//==================================================================================================
// Operators
//==================================================================================================
ROTGEN_EXPORT std::ostream& operator<<(std::ostream& os, CLASSNAME const& m)
{
m.storage_->apply([&](auto const& blk) { os << blk; });
return os;
}
//==================================================================================================
// Operators
//==================================================================================================
ROTGEN_EXPORT std::ostream& operator<<(std::ostream& os, CLASSNAME const& m)
{
m.storage_->apply([&](const auto& blk) { os << blk; });
return os;
}
ROTGEN_EXPORT std::ostream& operator<<(std::ostream& os,
format<CLASSNAME> const& m)
{
m.matrix_.storage_->apply(
[&](auto const& blk) { os << blk.format(m.format_.storage()->instance); });
return os;
}
ROTGEN_EXPORT std::ostream& operator<<(std::ostream& os,format<CLASSNAME> const& m)
{
m.matrix_.storage_->apply([&](const auto& blk) { os << blk.format(m.format_.storage()->instance); });
return os;
}
ROTGEN_EXPORT bool operator==(CLASSNAME const& lhs, CLASSNAME const& rhs)
{
return std::visit(
[](auto const& lhs_blk, auto const& rhs_blk) {
return lhs_blk.first == rhs_blk.first;
},
lhs.storage_->data, rhs.storage_->data);
}
ROTGEN_EXPORT bool operator==(CLASSNAME const& lhs, CLASSNAME const& rhs)
{
return std::visit ( [](auto const& lhs_blk, auto const& rhs_blk) { return lhs_blk.first == rhs_blk.first; }
, lhs.storage_->data
, rhs.storage_->data
);
}
ROTGEN_EXPORT bool operator!=(CLASSNAME const& lhs, CLASSNAME const& rhs)
{
return std::visit(
[](auto const& lhs_blk, auto const& rhs_blk) {
return lhs_blk.first != rhs_blk.first;
},
lhs.storage_->data, rhs.storage_->data);
}
ROTGEN_EXPORT bool operator!=(CLASSNAME const& lhs, CLASSNAME const& rhs)
{
return std::visit ( [](auto const& lhs_blk, auto const& rhs_blk) { return lhs_blk.first != rhs_blk.first; }
, lhs.storage_->data
, rhs.storage_->data
);
}
SOURCENAME CLASSNAME::operator-() const
{
SOURCENAME result;
storage_->apply([&](auto const& blk) { result.storage()->assign(blk); });
return -result;
}
#if !defined(USE_CONST)
CLASSNAME& CLASSNAME::operator+=(CLASSNAME const& rhs)
{
std::visit(
[](auto& lhs_blk, auto const& rhs_blk) { lhs_blk.first += rhs_blk.first; },
storage_->data, rhs.storage_->data);
return *this;
}
SOURCENAME CLASSNAME::operator-() const
{
SOURCENAME result;
storage_->apply([&](const auto& blk) { result.storage()->assign(blk); });
return -result;
}
CLASSNAME& CLASSNAME::operator-=(CLASSNAME const& rhs)
{
std::visit(
[](auto& lhs_blk, auto const& rhs_blk) { lhs_blk.first -= rhs_blk.first; },
storage_->data, rhs.storage_->data);
return *this;
}
#if !defined(USE_CONST)
CLASSNAME& CLASSNAME::operator+=(CLASSNAME const& rhs)
{
std::visit( [](auto& lhs_blk, auto const& rhs_blk) { lhs_blk.first += rhs_blk.first; }
, storage_->data
, rhs.storage_->data
);
return *this;
}
CLASSNAME& CLASSNAME::operator*=(CLASSNAME const& rhs)
{
std::visit(
[](auto& lhs_blk, auto const& rhs_blk) { lhs_blk.first *= rhs_blk.first; },
storage_->data, rhs.storage_->data);
return *this;
}
CLASSNAME& CLASSNAME::operator-=(CLASSNAME const& rhs)
{
std::visit( [](auto& lhs_blk, auto const& rhs_blk) { lhs_blk.first -= rhs_blk.first; }
, storage_->data
, rhs.storage_->data
);
return *this;
}
CLASSNAME& CLASSNAME::operator*=(TYPE s)
{
storage_->apply([&](auto& blk) { blk *= s; });
return *this;
}
CLASSNAME& CLASSNAME::operator*=(CLASSNAME const& rhs)
{
std::visit( [](auto& lhs_blk, auto const& rhs_blk) { lhs_blk.first *= rhs_blk.first; }
, storage_->data
, rhs.storage_->data
);
return *this;
}
CLASSNAME& CLASSNAME::operator/=(TYPE s)
{
storage_->apply([&](auto& blk) { blk /= s; });
return *this;
}
#endif
CLASSNAME& CLASSNAME::operator*=(TYPE s)
{
storage_->apply([&](auto& blk) { blk *= s; });
return *this;
}
SOURCENAME CLASSNAME::add(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(std::visit(
[](auto const& lhs_blk, auto const& rhs_blk) {
return (lhs_blk.first + rhs_blk.first).eval();
},
storage_->data, rhs.storage_->data));
return result;
}
CLASSNAME& CLASSNAME::operator/=(TYPE s)
{
storage_->apply([&](auto& blk) { blk /= s; });
return *this;
}
#endif
SOURCENAME CLASSNAME::sub(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(std::visit(
[](auto const& lhs_blk, auto const& rhs_blk) {
return (lhs_blk.first - rhs_blk.first).eval();
},
storage_->data, rhs.storage_->data));
return result;
}
SOURCENAME CLASSNAME::add(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign( std::visit( [](auto const& lhs_blk, auto const& rhs_blk)
{
return (lhs_blk.first + rhs_blk.first).eval();
}
, storage_->data
, rhs.storage_->data
)
);
return result;
}
SOURCENAME CLASSNAME::mul(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(std::visit(
[](auto const& lhs_blk, auto const& rhs_blk) {
return (lhs_blk.first * rhs_blk.first).eval();
},
storage_->data, rhs.storage_->data));
return result;
}
SOURCENAME CLASSNAME::sub(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign( std::visit( [](auto const& lhs_blk, auto const& rhs_blk)
{
return (lhs_blk.first - rhs_blk.first).eval();
}
, storage_->data
, rhs.storage_->data
)
);
return result;
}
SOURCENAME CLASSNAME::mul(TYPE s) const
{
SOURCENAME result;
result.storage()->assign(
std::visit([s](auto const& lhs_blk) { return (lhs_blk.first * s).eval(); },
storage_->data));
return result;
}
SOURCENAME CLASSNAME::mul(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign( std::visit( [](auto const& lhs_blk, auto const& rhs_blk)
{
return (lhs_blk.first * rhs_blk.first).eval();
}
, storage_->data
, rhs.storage_->data
)
);
return result;
}
SOURCENAME CLASSNAME::mul(TYPE s) const
{
SOURCENAME result;
result.storage()->assign( std::visit( [s](auto const& lhs_blk)
{
return (lhs_blk.first * s).eval();
}
, storage_->data
)
);
return result;
}
SOURCENAME CLASSNAME::div(TYPE s) const
{
SOURCENAME result;
result.storage()->assign( std::visit( [s](auto const& lhs_blk)
{
return (lhs_blk.first / s).eval();
}
, storage_->data
)
);
return result;
}
SOURCENAME CLASSNAME::div(TYPE s) const
{
SOURCENAME result;
result.storage()->assign(
std::visit([s](auto const& lhs_blk) { return (lhs_blk.first / s).eval(); },
storage_->data));
return result;
}

22
src/format.cpp
View file

@ -14,14 +14,18 @@
namespace rotgen
{
ioformat::ioformat( int p, int f
, std::string const& cs, std::string const& rsp
, std::string const& rp, std::string const& rs
, std::string const& mp, std::string const& ms
, char fill
)
: storage_(std::make_unique<payload>(p,f,cs,rsp,rp,rs,mp,ms,fill))
{}
ioformat::ioformat(int p,
int f,
std::string const& cs,
std::string const& rsp,
std::string const& rp,
std::string const& rs,
std::string const& mp,
std::string const& ms,
char fill)
: storage_(std::make_unique<payload>(p, f, cs, rsp, rp, rs, mp, ms, fill))
{
}
ioformat::~ioformat() = default;
}
}

5
src/info.cpp
View file

@ -12,7 +12,8 @@ namespace rotgen::detail
{
ROTGEN_EXPORT std::ostream& dynamic_info(std::ostream& os)
{
if constexpr(rotgen::is_forcing_dynamic_status) return os << "[ROTGEN] - Fully Dynamic mode with:" << std::endl;
if constexpr (rotgen::is_forcing_dynamic_status)
return os << "[ROTGEN] - Fully Dynamic mode with:" << std::endl;
else return os << "[ROTGEN] - Flexible mode with:" << std::endl;
}
}
}

40
src/map/generate.cpp
View file

@ -9,11 +9,11 @@
#define TYPE double
#define STORAGE_ORDER Eigen::ColMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME,SIZE,_col)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(BASENAME,SIZE,_row)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_row)
#define CLASSCONSTNAME ROTGEN_MATRIX_NAME(map_const_impl,SIZE,_col)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_col)
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _col)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _row)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#define CLASSCONSTNAME ROTGEN_MATRIX_NAME(map_const_impl, SIZE, _col)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSCLASSNAME
@ -23,11 +23,11 @@
#undef STORAGE_ORDER
#define STORAGE_ORDER Eigen::RowMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME,SIZE,_row)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(BASENAME,SIZE,_col)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_col)
#define CLASSCONSTNAME ROTGEN_MATRIX_NAME(map_const_impl,SIZE,_row)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_row)
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _row)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _col)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#define CLASSCONSTNAME ROTGEN_MATRIX_NAME(map_const_impl, SIZE, _row)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSCLASSNAME
@ -43,11 +43,11 @@
#define TYPE float
#define STORAGE_ORDER Eigen::ColMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME,SIZE,_col)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(BASENAME,SIZE,_row)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_row)
#define CLASSCONSTNAME ROTGEN_MATRIX_NAME(map_const_impl,SIZE,_col)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_col)
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _col)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _row)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#define CLASSCONSTNAME ROTGEN_MATRIX_NAME(map_const_impl, SIZE, _col)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSCLASSNAME
@ -57,11 +57,11 @@
#undef STORAGE_ORDER
#define STORAGE_ORDER Eigen::RowMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME,SIZE,_row)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(BASENAME,SIZE,_col)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_col)
#define CLASSCONSTNAME ROTGEN_MATRIX_NAME(map_const_impl,SIZE,_row)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_row)
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _row)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _col)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#define CLASSCONSTNAME ROTGEN_MATRIX_NAME(map_const_impl, SIZE, _row)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSCLASSNAME

24
src/map/impl.cpp
View file

@ -13,19 +13,19 @@
namespace rotgen
{
#define USE_CONST
#define CONST const
#define BASENAME map_const_impl
#include "generate.cpp"
#undef BASENAME
#undef USE_CONST
#undef CONST
#define USE_CONST
#define CONST const
#define BASENAME map_const_impl
#include "generate.cpp"
#undef BASENAME
#undef USE_CONST
#undef CONST
#define CONST
#define BASENAME map_impl
#include "generate.cpp"
#undef BASENAME
#undef CONST
#define CONST
#define BASENAME map_impl
#include "generate.cpp"
#undef BASENAME
#undef CONST
}
#include "operators.cpp"

758
src/map/model.cpp
View file

@ -16,379 +16,465 @@
// Internal payload
//==================================================================================================
//==================================================================================================
// Constructors & Special Members
//==================================================================================================
CLASSNAME::CLASSNAME(TYPE CONST* ptr, Index r, Index c) : storage_(std::make_unique<payload>(ptr,r,c))
{}
//==================================================================================================
// Constructors & Special Members
//==================================================================================================
CLASSNAME::CLASSNAME(TYPE CONST* ptr, Index r, Index c)
: storage_(std::make_unique<payload>(ptr, r, c))
{
}
CLASSNAME::CLASSNAME(TYPE CONST* ptr, Index r, Index c, stride s)
: storage_(std::make_unique<payload>(ptr,r,c,payload::stride_type{s.outer(),s.inner()}))
{}
CLASSNAME::CLASSNAME(TYPE CONST* ptr, Index r, Index c, stride s)
: storage_(std::make_unique<payload>(
ptr, r, c, payload::stride_type{s.outer(), s.inner()}))
{
}
CLASSNAME::CLASSNAME(CLASSNAME const& o) : storage_(std::make_unique<payload>(o.storage_->data))
{}
#if !defined(USE_CONST)
CLASSNAME& CLASSNAME::operator=(CLASSNAME const& o)
{
if (this != &o) storage_->data = o.storage_->data;
return *this;
}
CLASSNAME& CLASSNAME::operator=(CLASSNAME&& o)
{
if (this != &o) storage_->data = std::move(o.storage_->data);
return *this;
}
#endif
CLASSNAME::CLASSNAME(CLASSNAME&&) noexcept = default;
CLASSNAME::~CLASSNAME() = default;
//==================================================================================================
// Matrix API
//==================================================================================================
rotgen::Index CLASSNAME::rows() const { return storage_->data.rows(); }
rotgen::Index CLASSNAME::cols() const { return storage_->data.cols(); }
rotgen::Index CLASSNAME::size() const { return storage_->data.size(); }
rotgen::Index CLASSNAME::innerStride() const { return storage_->data.innerStride(); }
rotgen::Index CLASSNAME::outerStride() const { return storage_->data.outerStride(); }
const TYPE* CLASSNAME::data() const { return storage_->data.data(); }
#if !defined(USE_CONST)
TYPE* CLASSNAME::data() { return storage_->data.data(); }
TYPE& CLASSNAME::operator()(Index i, Index j) { return storage_->data(i,j); }
TYPE& CLASSNAME::operator()(Index i) { return storage_->data.data()[i]; }
#endif
TYPE CLASSNAME::operator()(Index i, Index j) const { return storage_->data(i,j); }
TYPE CLASSNAME::operator()(Index i) const { return storage_->data.data()[i]; }
SOURCENAME CLASSNAME::normalized() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.normalized().eval());
return result;
}
SOURCENAME CLASSNAME::transpose() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.transpose().eval());
return result;
}
SOURCENAME CLASSNAME::conjugate() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.conjugate().eval());
return result;
}
SOURCENAME CLASSNAME::adjoint() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.adjoint().eval());
return result;
}
SOURCENAME CLASSNAME::cwiseAbs() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseAbs().eval());
return result;
}
SOURCENAME CLASSNAME::cwiseAbs2() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseAbs2().eval());
return result;
}
SOURCENAME CLASSNAME::cwiseInverse() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseInverse().eval());
return result;
}
SOURCENAME CLASSNAME::cwiseSqrt() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseSqrt().eval());
return result;
}
SOURCENAME CLASSNAME::cwiseMin(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseMin(rhs.storage()->data).eval());
return result;
}
SOURCENAME CLASSNAME::cwiseMax(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseMax(rhs.storage()->data).eval());
return result;
}
SOURCENAME CLASSNAME::cwiseProduct(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseProduct(rhs.storage()->data).eval());
return result;
}
SOURCENAME CLASSNAME::cwiseQuotient(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseQuotient(rhs.storage()->data).eval());
return result;
}
SOURCENAME CLASSNAME::cwiseMin(TYPE rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseMin(rhs).eval());
return result;
}
SOURCENAME CLASSNAME::cwiseMax(TYPE rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseMax(rhs).eval());
return result;
}
SOURCENAME CLASSNAME::inverse() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.inverse().eval());
return result;
}
CLASSNAME::CLASSNAME(CLASSNAME const& o)
: storage_(std::make_unique<payload>(o.storage_->data))
{
}
#if !defined(USE_CONST)
void CLASSNAME::normalize()
{
storage_->data.normalize();
}
CLASSNAME& CLASSNAME::operator=(CLASSNAME const& o)
{
if (this != &o) storage_->data = o.storage_->data;
return *this;
}
void CLASSNAME::transposeInPlace()
{
storage_->data.transposeInPlace();
}
void CLASSNAME::adjointInPlace()
{
storage_->data.adjointInPlace();
}
CLASSNAME& CLASSNAME::operator=(CLASSNAME&& o)
{
if (this != &o) storage_->data = std::move(o.storage_->data);
return *this;
}
#endif
TYPE CLASSNAME::dot(CLASSNAME const& rhs) const
{
return storage_->data.reshaped().dot(rhs.storage()->data.reshaped());
}
CLASSNAME::CLASSNAME(CLASSNAME&&) noexcept = default;
TYPE CLASSNAME::dot(TRANSCLASSNAME const& rhs) const
{
return storage_->data.reshaped().dot(rhs.storage()->data.reshaped());
}
CLASSNAME::~CLASSNAME() = default;
TYPE CLASSNAME::sum() const { return storage_->data.sum(); }
TYPE CLASSNAME::prod() const { return storage_->data.prod(); }
TYPE CLASSNAME::mean() const { return storage_->data.mean(); }
TYPE CLASSNAME::trace() const { return storage_->data.trace(); }
//==================================================================================================
// Matrix API
//==================================================================================================
rotgen::Index CLASSNAME::rows() const
{
return storage_->data.rows();
}
TYPE CLASSNAME::minCoeff() const { return storage_->data.minCoeff(); }
TYPE CLASSNAME::maxCoeff() const { return storage_->data.maxCoeff(); }
rotgen::Index CLASSNAME::cols() const
{
return storage_->data.cols();
}
TYPE CLASSNAME::minCoeff(Index* row, Index* col) const { return storage_->data.minCoeff(row, col); }
TYPE CLASSNAME::maxCoeff(Index* row, Index* col) const { return storage_->data.maxCoeff(row, col); }
rotgen::Index CLASSNAME::size() const
{
return storage_->data.size();
}
TYPE CLASSNAME::squaredNorm() const { return storage_->data.squaredNorm(); }
TYPE CLASSNAME::norm() const { return storage_->data.norm(); }
rotgen::Index CLASSNAME::innerStride() const
{
return storage_->data.innerStride();
}
TYPE CLASSNAME::lpNorm(int p) const
{
if (p == 1) return storage_->data.lpNorm<1>();
else if (p == 2) return storage_->data.lpNorm<2>();
else return storage_->data.lpNorm<Eigen::Infinity>();
}
rotgen::Index CLASSNAME::outerStride() const
{
return storage_->data.outerStride();
}
#if !defined(USE_CONST)
void CLASSNAME::setZero()
{
storage_->data.setZero();
}
const TYPE* CLASSNAME::data() const
{
return storage_->data.data();
}
void CLASSNAME::setOnes()
{
storage_->data.setOnes();
}
#if !defined(USE_CONST)
TYPE* CLASSNAME::data()
{
return storage_->data.data();
}
void CLASSNAME::setIdentity()
{
storage_->data.setIdentity();
}
TYPE& CLASSNAME::operator()(Index i, Index j)
{
return storage_->data(i, j);
}
void CLASSNAME::setRandom()
{
storage_->data.setRandom();
}
TYPE& CLASSNAME::operator()(Index i)
{
return storage_->data.data()[i];
}
#endif
void CLASSNAME::setConstant(TYPE s)
{
storage_->data.setConstant(s);
}
#endif
TYPE CLASSNAME::operator()(Index i, Index j) const
{
return storage_->data(i, j);
}
//==================================================================================================
// Solvers
//==================================================================================================
SOURCENAME CLASSNAME::qr_solve(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data.colPivHouseholderQr().solve(rhs.storage_->data).eval());
return result;
}
TYPE CLASSNAME::operator()(Index i) const
{
return storage_->data.data()[i];
}
//==================================================================================================
// Operators
//==================================================================================================
ROTGEN_EXPORT std::ostream& operator<<(std::ostream& os,CLASSNAME const& m)
{
return os << m.storage_->data;
}
SOURCENAME CLASSNAME::normalized() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.normalized().eval());
return result;
}
ROTGEN_EXPORT std::ostream& operator<<(std::ostream& os,format<CLASSNAME> const& m)
{
return os << m.matrix_.storage_->data.format(m.format_.storage()->instance);
}
SOURCENAME CLASSNAME::transpose() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.transpose().eval());
return result;
}
ROTGEN_EXPORT bool operator==(CLASSNAME const& lhs, CLASSNAME const& rhs)
{
return lhs.storage_->data == rhs.storage_->data;
}
SOURCENAME CLASSNAME::conjugate() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.conjugate().eval());
return result;
}
ROTGEN_EXPORT bool operator!=(CLASSNAME const& lhs, CLASSNAME const& rhs)
{
return lhs.storage_->data != rhs.storage_->data;
}
SOURCENAME CLASSNAME::adjoint() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.adjoint().eval());
return result;
}
SOURCENAME CLASSNAME::operator-() const
{
SOURCENAME result;
result.storage()->assign(storage_->data);
return -result;
}
SOURCENAME CLASSNAME::cwiseAbs() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseAbs().eval());
return result;
}
#if !defined(USE_CONST)
CLASSNAME& CLASSNAME::operator+=(CLASSNAME const& rhs)
{
storage_->data += rhs.storage_->data;
return *this;
}
SOURCENAME CLASSNAME::cwiseAbs2() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseAbs2().eval());
return result;
}
CLASSNAME& CLASSNAME::operator+=(CLASSCONSTNAME const& rhs)
{
storage_->data += rhs.storage()->data;
return *this;
}
SOURCENAME CLASSNAME::cwiseInverse() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseInverse().eval());
return result;
}
CLASSNAME& CLASSNAME::operator-=(CLASSNAME const& rhs)
{
storage_->data -= rhs.storage_->data;
return *this;
}
SOURCENAME CLASSNAME::cwiseSqrt() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseSqrt().eval());
return result;
}
CLASSNAME& CLASSNAME::operator-=(CLASSCONSTNAME const& rhs)
{
storage_->data -= rhs.storage()->data;
return *this;
}
SOURCENAME CLASSNAME::cwiseMin(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseMin(rhs.storage()->data).eval());
return result;
}
CLASSNAME& CLASSNAME::operator*=(CLASSNAME const& rhs)
{
storage_->data *= rhs.storage_->data;
return *this;
}
SOURCENAME CLASSNAME::cwiseMax(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseMax(rhs.storage()->data).eval());
return result;
}
CLASSNAME& CLASSNAME::operator*=(CLASSCONSTNAME const& rhs)
{
storage_->data *= rhs.storage()->data;
return *this;
}
SOURCENAME CLASSNAME::cwiseProduct(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(
storage_->data.cwiseProduct(rhs.storage()->data).eval());
return result;
}
CLASSNAME& CLASSNAME::operator*=(TYPE s)
{
storage_->data *= s;
return *this;
}
SOURCENAME CLASSNAME::cwiseQuotient(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(
storage_->data.cwiseQuotient(rhs.storage()->data).eval());
return result;
}
CLASSNAME& CLASSNAME::operator/=(TYPE s)
{
storage_->data /= s;
return *this;
}
#endif
SOURCENAME CLASSNAME::cwiseMin(TYPE rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseMin(rhs).eval());
return result;
}
SOURCENAME CLASSNAME::add(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data + rhs.storage_->data);
return result;
}
SOURCENAME CLASSNAME::cwiseMax(TYPE rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data.cwiseMax(rhs).eval());
return result;
}
SOURCENAME CLASSNAME::add(TRANSCLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data + rhs.storage()->data);
return result;
}
SOURCENAME CLASSNAME::inverse() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.inverse().eval());
return result;
}
SOURCENAME CLASSNAME::sub(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data - rhs.storage_->data);
return result;
}
#if !defined(USE_CONST)
void CLASSNAME::normalize()
{
storage_->data.normalize();
}
SOURCENAME CLASSNAME::sub(TRANSCLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data - rhs.storage()->data);
return result;
}
void CLASSNAME::transposeInPlace()
{
storage_->data.transposeInPlace();
}
SOURCENAME CLASSNAME::mul(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data * rhs.storage_->data);
return result;
}
void CLASSNAME::adjointInPlace()
{
storage_->data.adjointInPlace();
}
#endif
SOURCENAME CLASSNAME::mul(TRANSCLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data * rhs.storage()->data);
return result;
}
TYPE CLASSNAME::dot(CLASSNAME const& rhs) const
{
return storage_->data.reshaped().dot(rhs.storage()->data.reshaped());
}
SOURCENAME CLASSNAME::mul(TYPE s) const
{
SOURCENAME result;
result.storage()->assign(storage_->data * s);
return result;
}
TYPE CLASSNAME::dot(TRANSCLASSNAME const& rhs) const
{
return storage_->data.reshaped().dot(rhs.storage()->data.reshaped());
}
SOURCENAME CLASSNAME::div(TYPE s) const
{
SOURCENAME result;
result.storage()->assign(storage_->data / s);
return result;
}
TYPE CLASSNAME::sum() const
{
return storage_->data.sum();
}
TYPE CLASSNAME::prod() const
{
return storage_->data.prod();
}
TYPE CLASSNAME::mean() const
{
return storage_->data.mean();
}
TYPE CLASSNAME::trace() const
{
return storage_->data.trace();
}
TYPE CLASSNAME::minCoeff() const
{
return storage_->data.minCoeff();
}
TYPE CLASSNAME::maxCoeff() const
{
return storage_->data.maxCoeff();
}
TYPE CLASSNAME::minCoeff(Index* row, Index* col) const
{
return storage_->data.minCoeff(row, col);
}
TYPE CLASSNAME::maxCoeff(Index* row, Index* col) const
{
return storage_->data.maxCoeff(row, col);
}
TYPE CLASSNAME::squaredNorm() const
{
return storage_->data.squaredNorm();
}
TYPE CLASSNAME::norm() const
{
return storage_->data.norm();
}
TYPE CLASSNAME::lpNorm(int p) const
{
if (p == 1) return storage_->data.lpNorm<1>();
else if (p == 2) return storage_->data.lpNorm<2>();
else return storage_->data.lpNorm<Eigen::Infinity>();
}
#if !defined(USE_CONST)
void CLASSNAME::setZero()
{
storage_->data.setZero();
}
void CLASSNAME::setOnes()
{
storage_->data.setOnes();
}
void CLASSNAME::setIdentity()
{
storage_->data.setIdentity();
}
void CLASSNAME::setRandom()
{
storage_->data.setRandom();
}
void CLASSNAME::setConstant(TYPE s)
{
storage_->data.setConstant(s);
}
#endif
//==================================================================================================
// Solvers
//==================================================================================================
SOURCENAME CLASSNAME::qr_solve(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(
storage_->data.colPivHouseholderQr().solve(rhs.storage_->data).eval());
return result;
}
//==================================================================================================
// Operators
//==================================================================================================
ROTGEN_EXPORT std::ostream& operator<<(std::ostream& os, CLASSNAME const& m)
{
return os << m.storage_->data;
}
ROTGEN_EXPORT std::ostream& operator<<(std::ostream& os,
format<CLASSNAME> const& m)
{
return os << m.matrix_.storage_->data.format(m.format_.storage()->instance);
}
ROTGEN_EXPORT bool operator==(CLASSNAME const& lhs, CLASSNAME const& rhs)
{
return lhs.storage_->data == rhs.storage_->data;
}
ROTGEN_EXPORT bool operator!=(CLASSNAME const& lhs, CLASSNAME const& rhs)
{
return lhs.storage_->data != rhs.storage_->data;
}
SOURCENAME CLASSNAME::operator-() const
{
SOURCENAME result;
result.storage()->assign(storage_->data);
return -result;
}
#if !defined(USE_CONST)
CLASSNAME& CLASSNAME::operator+=(CLASSNAME const& rhs)
{
storage_->data += rhs.storage_->data;
return *this;
}
CLASSNAME& CLASSNAME::operator+=(CLASSCONSTNAME const& rhs)
{
storage_->data += rhs.storage()->data;
return *this;
}
CLASSNAME& CLASSNAME::operator-=(CLASSNAME const& rhs)
{
storage_->data -= rhs.storage_->data;
return *this;
}
CLASSNAME& CLASSNAME::operator-=(CLASSCONSTNAME const& rhs)
{
storage_->data -= rhs.storage()->data;
return *this;
}
CLASSNAME& CLASSNAME::operator*=(CLASSNAME const& rhs)
{
storage_->data *= rhs.storage_->data;
return *this;
}
CLASSNAME& CLASSNAME::operator*=(CLASSCONSTNAME const& rhs)
{
storage_->data *= rhs.storage()->data;
return *this;
}
CLASSNAME& CLASSNAME::operator*=(TYPE s)
{
storage_->data *= s;
return *this;
}
CLASSNAME& CLASSNAME::operator/=(TYPE s)
{
storage_->data /= s;
return *this;
}
#endif
SOURCENAME CLASSNAME::add(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data + rhs.storage_->data);
return result;
}
SOURCENAME CLASSNAME::add(TRANSCLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data + rhs.storage()->data);
return result;
}
SOURCENAME CLASSNAME::sub(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data - rhs.storage_->data);
return result;
}
SOURCENAME CLASSNAME::sub(TRANSCLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data - rhs.storage()->data);
return result;
}
SOURCENAME CLASSNAME::mul(CLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data * rhs.storage_->data);
return result;
}
SOURCENAME CLASSNAME::mul(TRANSCLASSNAME const& rhs) const
{
SOURCENAME result;
result.storage()->assign(storage_->data * rhs.storage()->data);
return result;
}
SOURCENAME CLASSNAME::mul(TYPE s) const
{
SOURCENAME result;
result.storage()->assign(storage_->data * s);
return result;
}
SOURCENAME CLASSNAME::div(TYPE s) const
{
SOURCENAME result;
result.storage()->assign(storage_->data / s);
return result;
}

81
src/map/operators.cpp
View file

@ -10,28 +10,75 @@
#include <rotgen/detail/payload.hpp>
#include <Eigen/Dense>
#define ROTGEN_IMPL_OP(OP,FN,RET) \
RET operator OP(map_const_impl32_col const& a, map_impl32_col const& b ) { return FN(a, b); } \
RET operator OP(map_const_impl32_col const& a, map_impl32_row const& b ) { return FN(a, b); } \
RET operator OP(map_const_impl32_col const& a, map_const_impl32_row const& b ) { return FN(a, b); } \
RET operator OP(map_const_impl32_row const& a, map_impl32_row const& b ) { return FN(a, b); } \
RET operator OP(map_const_impl32_row const& a, map_impl32_col const& b ) { return FN(a, b); } \
RET operator OP(map_impl32_col const& a, map_impl32_row const& b ) { return FN(a, b); } \
RET operator OP(map_const_impl64_col const& a, map_impl64_col const& b ) { return FN(a, b); } \
RET operator OP(map_const_impl64_col const& a, map_impl64_row const& b ) { return FN(a, b); } \
RET operator OP(map_const_impl64_col const& a, map_const_impl64_row const& b ) { return FN(a, b); } \
RET operator OP(map_const_impl64_row const& a, map_impl64_row const& b ) { return FN(a, b); } \
RET operator OP(map_const_impl64_row const& a, map_impl64_col const& b ) { return FN(a, b); } \
RET operator OP(map_impl64_col const& a, map_impl64_row const& b ) { return FN(a, b); } \
#define ROTGEN_IMPL_OP(OP, FN, RET) \
RET operator OP(map_const_impl32_col const& a, map_impl32_col const& b) \
{ \
return FN(a, b); \
} \
RET operator OP(map_const_impl32_col const& a, map_impl32_row const& b) \
{ \
return FN(a, b); \
} \
RET operator OP(map_const_impl32_col const& a, \
map_const_impl32_row const& b) \
{ \
return FN(a, b); \
} \
RET operator OP(map_const_impl32_row const& a, map_impl32_row const& b) \
{ \
return FN(a, b); \
} \
RET operator OP(map_const_impl32_row const& a, map_impl32_col const& b) \
{ \
return FN(a, b); \
} \
RET operator OP(map_impl32_col const& a, map_impl32_row const& b) \
{ \
return FN(a, b); \
} \
RET operator OP(map_const_impl64_col const& a, map_impl64_col const& b) \
{ \
return FN(a, b); \
} \
RET operator OP(map_const_impl64_col const& a, map_impl64_row const& b) \
{ \
return FN(a, b); \
} \
RET operator OP(map_const_impl64_col const& a, \
map_const_impl64_row const& b) \
{ \
return FN(a, b); \
} \
RET operator OP(map_const_impl64_row const& a, map_impl64_row const& b) \
{ \
return FN(a, b); \
} \
RET operator OP(map_const_impl64_row const& a, map_impl64_col const& b) \
{ \
return FN(a, b); \
} \
RET operator OP(map_impl64_col const& a, map_impl64_row const& b) \
{ \
return FN(a, b); \
}
/**/
namespace rotgen
{
namespace
{
bool equal(auto const& a, auto const& b) { return a.storage()->data == b.storage()->data; }
bool not_equal(auto const& a, auto const& b) { return a.storage()->data != b.storage()->data; }
bool equal(auto const& a, auto const& b)
{
return a.storage()->data == b.storage()->data;
}
bool not_equal(auto const& a, auto const& b)
{
return a.storage()->data != b.storage()->data;
}
}
ROTGEN_IMPL_OP(==, equal , bool);
ROTGEN_IMPL_OP(==, equal, bool);
ROTGEN_IMPL_OP(!=, not_equal, bool);
}
}

72
src/matrix/impl.cpp
View file

@ -13,47 +13,47 @@
namespace rotgen
{
#define SIZE 64
#define TYPE double
#define STORAGE_ORDER Eigen::ColMajor
#define SIZE 64
#define TYPE double
#define STORAGE_ORDER Eigen::ColMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_col)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_row)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSCLASSNAME
#undef STORAGE_ORDER
#define CLASSNAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSCLASSNAME
#undef STORAGE_ORDER
#define STORAGE_ORDER Eigen::RowMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_row)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_col)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSCLASSNAME
#undef STORAGE_ORDER
#define STORAGE_ORDER Eigen::RowMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSCLASSNAME
#undef STORAGE_ORDER
#undef SIZE
#undef TYPE
#undef SIZE
#undef TYPE
#define SIZE 32
#define TYPE float
#define STORAGE_ORDER Eigen::ColMajor
#define SIZE 32
#define TYPE float
#define STORAGE_ORDER Eigen::ColMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_col)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_row)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSCLASSNAME
#undef STORAGE_ORDER
#define CLASSNAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSCLASSNAME
#undef STORAGE_ORDER
#define STORAGE_ORDER Eigen::RowMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_row)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_col)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSCLASSNAME
#undef STORAGE_ORDER
#define STORAGE_ORDER Eigen::RowMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSCLASSNAME
#undef STORAGE_ORDER
#undef SIZE
#undef TYPE
#undef SIZE
#undef TYPE
}

166
src/matrix/model.cpp
View file

@ -15,31 +15,35 @@
//==================================================================================================
// Constructors & Special Members
//==================================================================================================
CLASSNAME::CLASSNAME() : storage_(std::make_unique<payload>(0,0)) {}
CLASSNAME::CLASSNAME(std::size_t r, std::size_t c) : storage_(std::make_unique<payload>(r,c)) {}
CLASSNAME::CLASSNAME() : storage_(std::make_unique<payload>(0, 0)) {}
CLASSNAME::CLASSNAME(std::initializer_list<std::initializer_list<TYPE>> init)
: storage_(std::make_unique<payload>(init))
{}
CLASSNAME::CLASSNAME(std::size_t r, std::size_t c,std::initializer_list<TYPE> init)
: CLASSNAME(r,c)
CLASSNAME::CLASSNAME(std::size_t r, std::size_t c)
: storage_(std::make_unique<payload>(r, c))
{
auto first = init.begin();
for(std::size_t i=0; i < init.size(); i++)
(*this)(i) = first[i];
}
CLASSNAME::CLASSNAME(CLASSNAME const& o)
: CLASSNAME(o.rows(),o.cols())
CLASSNAME::CLASSNAME(std::initializer_list<std::initializer_list<TYPE>> init)
: storage_(std::make_unique<payload>(init))
{
}
CLASSNAME::CLASSNAME(std::size_t r,
std::size_t c,
std::initializer_list<TYPE> init)
: CLASSNAME(r, c)
{
auto first = init.begin();
for (std::size_t i = 0; i < init.size(); i++) (*this)(i) = first[i];
}
CLASSNAME::CLASSNAME(CLASSNAME const& o) : CLASSNAME(o.rows(), o.cols())
{
storage_->data = o.storage_->data;
}
CLASSNAME::CLASSNAME(CLASSNAME&&) noexcept = default;
CLASSNAME::CLASSNAME(CLASSNAME&&) noexcept = default;
CLASSNAME& CLASSNAME::operator=(CLASSNAME const& o)
CLASSNAME& CLASSNAME::operator=(CLASSNAME const& o)
{
if (this != &o) storage_->data = o.storage_->data;
return *this;
@ -47,14 +51,25 @@ CLASSNAME& CLASSNAME::operator=(CLASSNAME const& o)
CLASSNAME& CLASSNAME::operator=(CLASSNAME&&) noexcept = default;
CLASSNAME::~CLASSNAME() = default;
CLASSNAME::~CLASSNAME() = default;
//==================================================================================================
// Matrix API
//==================================================================================================
rotgen::Index CLASSNAME::rows() const { return storage_->data.rows(); }
rotgen::Index CLASSNAME::cols() const { return storage_->data.cols(); }
rotgen::Index CLASSNAME::size() const { return storage_->data.size(); }
rotgen::Index CLASSNAME::rows() const
{
return storage_->data.rows();
}
rotgen::Index CLASSNAME::cols() const
{
return storage_->data.cols();
}
rotgen::Index CLASSNAME::size() const
{
return storage_->data.size();
}
void CLASSNAME::resize(std::size_t new_rows, std::size_t new_cols)
{
@ -66,14 +81,35 @@ void CLASSNAME::conservativeResize(std::size_t new_rows, std::size_t new_cols)
storage_->data.conservativeResize(new_rows, new_cols);
}
TYPE& CLASSNAME::operator()(std::size_t i, std::size_t j) { return storage_->data(i,j); }
TYPE const& CLASSNAME::operator()(std::size_t i, std::size_t j) const { return storage_->data(i,j); }
TYPE& CLASSNAME::operator()(std::size_t i, std::size_t j)
{
return storage_->data(i, j);
}
TYPE& CLASSNAME::operator()(std::size_t index) { return storage_->data(index); }
TYPE const& CLASSNAME::operator()(std::size_t index) const { return storage_->data(index); }
TYPE const& CLASSNAME::operator()(std::size_t i, std::size_t j) const
{
return storage_->data(i, j);
}
const TYPE* CLASSNAME::data() const { return storage_->data.data(); }
TYPE* CLASSNAME::data() { return storage_->data.data(); }
TYPE& CLASSNAME::operator()(std::size_t index)
{
return storage_->data(index);
}
TYPE const& CLASSNAME::operator()(std::size_t index) const
{
return storage_->data(index);
}
const TYPE* CLASSNAME::data() const
{
return storage_->data.data();
}
TYPE* CLASSNAME::data()
{
return storage_->data.data();
}
CLASSNAME CLASSNAME::normalized() const
{
@ -146,36 +182,73 @@ CLASSNAME CLASSNAME::cwiseSqrt() const
return result;
}
TYPE CLASSNAME::sum() const { return storage_->data.sum(); }
TYPE CLASSNAME::prod() const { return storage_->data.prod(); }
TYPE CLASSNAME::mean() const { return storage_->data.mean(); }
TYPE CLASSNAME::trace() const { return storage_->data.trace(); }
TYPE CLASSNAME::sum() const
{
return storage_->data.sum();
}
TYPE CLASSNAME::minCoeff() const { return storage_->data.minCoeff(); }
TYPE CLASSNAME::maxCoeff() const { return storage_->data.maxCoeff(); }
TYPE CLASSNAME::prod() const
{
return storage_->data.prod();
}
TYPE CLASSNAME::minCoeff(Index* row, Index* col) const { return storage_->data.minCoeff(row, col); }
TYPE CLASSNAME::maxCoeff(Index* row, Index* col) const { return storage_->data.maxCoeff(row, col); }
TYPE CLASSNAME::mean() const
{
return storage_->data.mean();
}
TYPE CLASSNAME::squaredNorm() const { return storage_->data.squaredNorm(); }
TYPE CLASSNAME::norm() const { return storage_->data.norm(); }
TYPE CLASSNAME::trace() const
{
return storage_->data.trace();
}
TYPE CLASSNAME::minCoeff() const
{
return storage_->data.minCoeff();
}
TYPE CLASSNAME::maxCoeff() const
{
return storage_->data.maxCoeff();
}
TYPE CLASSNAME::minCoeff(Index* row, Index* col) const
{
return storage_->data.minCoeff(row, col);
}
TYPE CLASSNAME::maxCoeff(Index* row, Index* col) const
{
return storage_->data.maxCoeff(row, col);
}
TYPE CLASSNAME::squaredNorm() const
{
return storage_->data.squaredNorm();
}
TYPE CLASSNAME::norm() const
{
return storage_->data.norm();
}
TYPE CLASSNAME::lp_norm(int p) const
{
if (p == 1) return storage_->data.lpNorm<1>();
else if (p == 2) return storage_->data.lpNorm<2>();
else return storage_->data.lpNorm<Eigen::Infinity>();
if (p == 1) return storage_->data.lpNorm<1>();
else if (p == 2) return storage_->data.lpNorm<2>();
else return storage_->data.lpNorm<Eigen::Infinity>();
}
//==================================================================================================
// Operators
//==================================================================================================
ROTGEN_EXPORT std::ostream& operator<<(std::ostream& os,CLASSNAME const& m)
ROTGEN_EXPORT std::ostream& operator<<(std::ostream& os, CLASSNAME const& m)
{
return os << m.storage_->data;
}
ROTGEN_EXPORT std::ostream& operator<<(std::ostream& os,format<CLASSNAME> const& m)
ROTGEN_EXPORT std::ostream& operator<<(std::ostream& os,
format<CLASSNAME> const& m)
{
return os << m.matrix_.storage_->data.format(m.format_.storage()->instance);
}
@ -248,20 +321,23 @@ CLASSNAME CLASSNAME::Zero(std::size_t rows, std::size_t cols)
CLASSNAME CLASSNAME::Constant(std::size_t rows, std::size_t cols, TYPE value)
{
CLASSNAME m;
m.storage_ = std::make_unique<payload>(payload::data_type::Constant(rows, cols, value));
m.storage_ =
std::make_unique<payload>(payload::data_type::Constant(rows, cols, value));
return m;
}
CLASSNAME CLASSNAME::Random(std::size_t rows, std::size_t cols)
{
CLASSNAME m;
m.storage_ = std::make_unique<payload>(payload::data_type::Random(rows, cols));
m.storage_ =
std::make_unique<payload>(payload::data_type::Random(rows, cols));
return m;
}
CLASSNAME CLASSNAME::Identity(std::size_t rows, std::size_t cols)
{
CLASSNAME m;
m.storage_ = std::make_unique<payload>(payload::data_type::Identity(rows, cols));
m.storage_ =
std::make_unique<payload>(payload::data_type::Identity(rows, cols));
return m;
}
}

72
src/svd/impl.cpp
View file

@ -15,47 +15,47 @@
namespace rotgen
{
#define SIZE 64
#define TYPE double
#define STORAGE_ORDER Eigen::ColMajor
#define SIZE 64
#define TYPE double
#define STORAGE_ORDER Eigen::ColMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(svd_impl,SIZE,_col)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_col)
#include "model.cpp"
#undef CLASSNAME
#undef SOURCENAME
#undef STORAGE_ORDER
#define CLASSNAME ROTGEN_MATRIX_NAME(svd_impl, SIZE, _col)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#include "model.cpp"
#undef CLASSNAME
#undef SOURCENAME
#undef STORAGE_ORDER
#define STORAGE_ORDER Eigen::RowMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(svd_impl,SIZE,_row)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_row)
#include "model.cpp"
#undef CLASSNAME
#undef SOURCENAME
#undef STORAGE_ORDER
#define STORAGE_ORDER Eigen::RowMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(svd_impl, SIZE, _row)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#include "model.cpp"
#undef CLASSNAME
#undef SOURCENAME
#undef STORAGE_ORDER
#undef SIZE
#undef TYPE
#undef SIZE
#undef TYPE
#define SIZE 32
#define TYPE float
#define STORAGE_ORDER Eigen::ColMajor
#define SIZE 32
#define TYPE float
#define STORAGE_ORDER Eigen::ColMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(svd_impl,SIZE,_col)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_col)
#include "model.cpp"
#undef CLASSNAME
#undef SOURCENAME
#undef STORAGE_ORDER
#define CLASSNAME ROTGEN_MATRIX_NAME(svd_impl, SIZE, _col)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#include "model.cpp"
#undef CLASSNAME
#undef SOURCENAME
#undef STORAGE_ORDER
#define STORAGE_ORDER Eigen::RowMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(svd_impl,SIZE,_row)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl,SIZE,_row)
#include "model.cpp"
#undef CLASSNAME
#undef SOURCENAME
#undef STORAGE_ORDER
#define STORAGE_ORDER Eigen::RowMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(svd_impl, SIZE, _row)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#include "model.cpp"
#undef CLASSNAME
#undef SOURCENAME
#undef STORAGE_ORDER
#undef SIZE
#undef TYPE
#undef SIZE
#undef TYPE
}

52
src/svd/model.cpp
View file

@ -17,28 +17,32 @@
//==================================================================================================
struct CLASSNAME::payload
{
using matrix_type = Eigen::Matrix<TYPE,Eigen::Dynamic,Eigen::Dynamic,STORAGE_ORDER>;
using matrix_type =
Eigen::Matrix<TYPE, Eigen::Dynamic, Eigen::Dynamic, STORAGE_ORDER>;
Eigen::JacobiSVD<matrix_type> data;
payload(SOURCENAME const& src, int options) : data(src.storage()->data,options) {}
payload(SOURCENAME const& src, int options)
: data(src.storage()->data, options)
{
}
};
//==================================================================================================
// Constructors & Special Members
//==================================================================================================
CLASSNAME::CLASSNAME(SOURCENAME const& m, int options)
: storage_(std::make_unique<payload>(m,options))
{}
CLASSNAME::CLASSNAME(CLASSNAME const& o)
: storage_(std::make_unique<payload>(*o.storage_))
: storage_(std::make_unique<payload>(m, options))
{
}
CLASSNAME::CLASSNAME(CLASSNAME&&) noexcept = default;
CLASSNAME::CLASSNAME(CLASSNAME const& o)
: storage_(std::make_unique<payload>(*o.storage_))
{
}
CLASSNAME& CLASSNAME::operator=(CLASSNAME const& o)
CLASSNAME::CLASSNAME(CLASSNAME&&) noexcept = default;
CLASSNAME& CLASSNAME::operator=(CLASSNAME const& o)
{
if (this != &o) storage_->data = o.storage_->data;
return *this;
@ -52,60 +56,64 @@ CLASSNAME& CLASSNAME::operator=(CLASSNAME&& o) noexcept
CLASSNAME::~CLASSNAME() = default;
int CLASSNAME::rank() const { return storage_->data.rank(); }
int CLASSNAME::rank() const
{
return storage_->data.rank();
}
SOURCENAME CLASSNAME::U() const
SOURCENAME CLASSNAME::U() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.matrixU());
return result;
}
SOURCENAME CLASSNAME::U(int r) const
SOURCENAME CLASSNAME::U(int r) const
{
SOURCENAME result;
result.storage()->assign( storage_->data.matrixU().leftCols(r) );
result.storage()->assign(storage_->data.matrixU().leftCols(r));
return result;
}
SOURCENAME CLASSNAME::singular_values() const
SOURCENAME CLASSNAME::singular_values() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.singularValues());
return result;
}
SOURCENAME CLASSNAME::singular_values(int r) const
SOURCENAME CLASSNAME::singular_values(int r) const
{
SOURCENAME result;
result.storage()->assign(storage_->data.singularValues().head(r));
return result;
}
SOURCENAME CLASSNAME::D() const
SOURCENAME CLASSNAME::D() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.singularValues().asDiagonal());
return result;
}
SOURCENAME CLASSNAME::D(int r) const
SOURCENAME CLASSNAME::D(int r) const
{
SOURCENAME result;
result.storage()->assign(storage_->data.singularValues().head(r).asDiagonal());
result.storage()->assign(
storage_->data.singularValues().head(r).asDiagonal());
return result;
}
SOURCENAME CLASSNAME::V() const
SOURCENAME CLASSNAME::V() const
{
SOURCENAME result;
result.storage()->assign(storage_->data.matrixV());
return result;
}
SOURCENAME CLASSNAME::V(int r) const
SOURCENAME CLASSNAME::V(int r) const
{
SOURCENAME result;
result.storage()->assign( storage_->data.matrixV().leftCols(r) );
result.storage()->assign(storage_->data.matrixV().leftCols(r));
return result;
}