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
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue