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

Fix a lot of ref issues reagrding extarction, rvalueness and proper use of temporary memory.

Browse source
This commit is contained in:
Joel Falcou 2025-10-28 20:12:33 +01:00
parent d5c41bf43e
commit 379d77ebef
50 changed files with 2945 additions and 1397 deletions
Download patch file Download diff file Expand all files Collapse all files

24
src/block/generate.cpp
View file

@ -10,24 +10,28 @@
#define STORAGE_ORDER Eigen::ColMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _col)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _row)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#define TRANSNAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#define MAPNAME ROTGEN_MATRIX_NAME(BASEMAP, SIZE, _col)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSSOURCENAME
#undef TRANSNAME
#undef TRANSCLASSNAME
#undef SOURCENAME
#undef MAPNAME
#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 SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#define TRANSNAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#define MAPNAME ROTGEN_MATRIX_NAME(BASEMAP, SIZE, _row)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSSOURCENAME
#undef TRANSNAME
#undef TRANSCLASSNAME
#undef SOURCENAME
#undef MAPNAME
#undef STORAGE_ORDER
@ -40,24 +44,28 @@
#define STORAGE_ORDER Eigen::ColMajor
#define CLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _col)
#define TRANSCLASSNAME ROTGEN_MATRIX_NAME(BASENAME, SIZE, _row)
#define SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#define TRANSNAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#define MAPNAME ROTGEN_MATRIX_NAME(BASEMAP, SIZE, _col)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSSOURCENAME
#undef TRANSNAME
#undef TRANSCLASSNAME
#undef SOURCENAME
#undef MAPNAME
#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 SOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _row)
#define TRANSSOURCENAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#define TRANSNAME ROTGEN_MATRIX_NAME(matrix_impl, SIZE, _col)
#define MAPNAME ROTGEN_MATRIX_NAME(BASEMAP, SIZE, _row)
#include "model.cpp"
#undef CLASSNAME
#undef TRANSSOURCENAME
#undef TRANSNAME
#undef TRANSCLASSNAME
#undef SOURCENAME
#undef MAPNAME
#undef STORAGE_ORDER

4
src/block/impl.cpp
View file

@ -5,9 +5,11 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include <rotgen/detail/generators.hpp>
#include <rotgen/container/block/dynamic/impl.hpp>
#include <rotgen/detail/generators.hpp>
#include <rotgen/detail/payload.hpp>
#include <Eigen/Dense>
#include <variant>

145
src/block/model.cpp
View file

@ -12,80 +12,65 @@
*/
//==================================================================================================
//==================================================================================================
// Internal payload
//==================================================================================================
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 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>;
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) const
{
std::visit([&](auto const& blk) { return f(blk.first); }, data);
}
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(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))
: storage_(
std::make_unique<payload>(r, i0, j0, ni, nj, matrix_t{}, source_t{}))
{
}
CLASSNAME::CLASSNAME(TRANSNAME CONST& r, Index i0, Index j0, Index ni, Index nj)
: storage_(
std::make_unique<payload>(r, i0, j0, ni, nj, matrix_t{}, trans_t{}))
{
}
CLASSNAME::CLASSNAME(MAPNAME CONST& r, Index i0, Index j0, Index ni, Index nj)
: storage_(std::make_unique<payload>(r, i0, j0, ni, nj))
: storage_(std::make_unique<payload>(r, i0, j0, ni, nj, map_t{}, source_t{}))
{
}
// 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)
CLASSNAME::CLASSNAME(
TRANSCLASSNAME CONST& p, Index i0, Index j0, Index ni, Index nj)
{
auto const& o = *(p.storage());
// 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);
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;
}
// We're building a block from a block - So we have to dig around the internals
CLASSNAME::CLASSNAME(CLASSNAME CONST& p, Index i0, Index j0, Index ni, Index nj)
{
auto const& o = *(p.storage());
// Compute absolute indices from the parent stored block
Index abs_i0 = 0;
Index abs_j0 = 0;
@ -495,50 +480,54 @@ CLASSNAME& CLASSNAME::operator/=(TYPE s)
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();
std::visit(
[&](auto const& lhs_blk, auto const& rhs_blk) {
result.storage()->assign((lhs_blk.first + rhs_blk.first).eval());
},
storage_->data, rhs.storage_->data));
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();
std::visit(
[&](auto const& lhs_blk, auto const& rhs_blk) {
result.storage()->assign((lhs_blk.first - rhs_blk.first).eval());
},
storage_->data, rhs.storage_->data));
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();
std::visit(
[&](auto const& lhs_blk, auto const& rhs_blk) {
result.storage()->assign((lhs_blk.first * rhs_blk.first).eval());
},
storage_->data, rhs.storage_->data));
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));
std::visit(
[&](auto const& lhs_blk) {
result.storage()->assign((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));
std::visit(
[&](auto const& lhs_blk) {
result.storage()->assign((lhs_blk.first / s).eval());
},
storage_->data);
return result;
}

4
src/map/impl.cpp
View file

@ -5,9 +5,11 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include <rotgen/detail/generators.hpp>
#include <rotgen/container/map/dynamic/impl.hpp>
#include <rotgen/detail/generators.hpp>
#include <rotgen/detail/payload.hpp>
#include <Eigen/Dense>
#include <Eigen/LU>

4
src/map/model.cpp
View file

@ -19,12 +19,14 @@
//==================================================================================================
// Constructors & Special Members
//==================================================================================================
CLASSNAME::CLASSNAME() {}
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)
CLASSNAME::CLASSNAME(TYPE CONST* ptr, Index r, Index c, dynamic_stride s)
: storage_(std::make_unique<payload>(
ptr, r, c, payload::stride_type{s.outer(), s.inner()}))
{

5
src/matrix/impl.cpp
View file

@ -5,10 +5,11 @@
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include <rotgen/detail/generators.hpp>
#include <rotgen/container/matrix/dynamic/impl.hpp>
#include <rotgen/detail/generators.hpp>
#include <rotgen/detail/payload.hpp>
#include <rotgen/config.hpp>
#include <Eigen/Dense>
namespace rotgen

33
src/matrix/model.cpp
View file

@ -300,10 +300,37 @@ CLASSNAME& CLASSNAME::operator/=(TYPE s)
return *this;
}
//==================================================================================================
// Static functions
//==================================================================================================
//==============================================================================
// Generators functions
//==============================================================================
void CLASSNAME::setOnes(std::size_t rows, std::size_t cols)
{
storage_->assign(payload::data_type::Ones(rows, cols).eval());
}
void CLASSNAME::setZero(std::size_t rows, std::size_t cols)
{
storage_->assign(payload::data_type::Zero(rows, cols).eval());
}
void CLASSNAME::setConstant(std::size_t rows, std::size_t cols, TYPE value)
{
storage_->assign(payload::data_type::Constant(rows, cols, value).eval());
}
void CLASSNAME::setRandom(std::size_t rows, std::size_t cols)
{
storage_->assign(payload::data_type::Random(rows, cols).eval());
}
void CLASSNAME::setIdentity(std::size_t rows, std::size_t cols)
{
storage_->assign(payload::data_type::Identity(rows, cols).eval());
}
//==============================================================================
// Static functions
//==============================================================================
CLASSNAME CLASSNAME::Ones(std::size_t rows, std::size_t cols)
{
CLASSNAME m;