Reorganize internals

See merge request oss/rotgen!36
2025-10-12 19:01:13 +02:00 · 2025-10-12 19:01:13 +02:00 · ffa9309332
commit ffa9309332
parent 6521f68c95
55 changed files with 585 additions and 495 deletions
--- a/src/map/generate.cpp
+++ b/src/map/generate.cpp
@ -0,0 +1,74 @@
+//==================================================================================================
+/*
+  ROTGEN - Runtime Overlay for Eigen
+  Copyright : CODE RECKONS
+  SPDX-License-Identifier: BSL-1.0
+*/
+//==================================================================================================
+#define SIZE 64
+#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)
+#include "model.cpp"
+#undef CLASSNAME
+#undef TRANSCLASSNAME
+#undef TRANSSOURCENAME
+#undef CLASSCONSTNAME
+#undef SOURCENAME
+#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)
+#include "model.cpp"
+#undef CLASSNAME
+#undef TRANSCLASSNAME
+#undef TRANSSOURCENAME
+#undef SOURCENAME
+#undef CLASSCONSTNAME
+#undef STORAGE_ORDER
+
+#undef SIZE
+#undef TYPE
+
+#define SIZE 32
+#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)
+#include "model.cpp"
+#undef CLASSNAME
+#undef TRANSCLASSNAME
+#undef TRANSSOURCENAME
+#undef CLASSCONSTNAME
+#undef SOURCENAME
+#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)
+#include "model.cpp"
+#undef CLASSNAME
+#undef TRANSCLASSNAME
+#undef TRANSSOURCENAME
+#undef CLASSCONSTNAME
+#undef SOURCENAME
+#undef STORAGE_ORDER
+
+#undef SIZE
+#undef TYPE
--- a/src/map/impl.cpp
+++ b/src/map/impl.cpp
@ -0,0 +1,31 @@
+//==================================================================================================
+/*
+  ROTGEN - Runtime Overlay for Eigen
+  Copyright : CODE RECKONS
+  SPDX-License-Identifier: BSL-1.0
+*/
+//==================================================================================================
+#include <rotgen/detail/generators.hpp>
+#include <rotgen/container/map/dynamic/impl.hpp>
+#include <rotgen/detail/payload.hpp>
+#include <Eigen/Dense>
+#include <Eigen/LU>
+
+namespace rotgen
+{
+  #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
+}
+
+#include "operators.cpp"
--- a/src/map/model.cpp
+++ b/src/map/model.cpp
@ -0,0 +1,394 @@
+//==================================================================================================
+/*
+  ROTGEN - Runtime Overlay for Eigen
+  Copyright : CODE RECKONS
+  SPDX-License-Identifier: BSL-1.0
+*/
+//==================================================================================================
+
+//==================================================================================================
+/*
+  This file is a X-File to generate various map_impl_* definitions variant
+*/
+//==================================================================================================
+
+//==================================================================================================
+// Internal payload
+//==================================================================================================
+
+  //==================================================================================================
+  // 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(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;
+  }
+
+  TRANSSOURCENAME CLASSNAME::transpose() const
+  {
+    TRANSSOURCENAME 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;
+  }
+
+  TRANSSOURCENAME CLASSNAME::adjoint() const
+  {
+    TRANSSOURCENAME 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;
+  }
+
+#if !defined(USE_CONST)
+  void CLASSNAME::normalize()
+  {
+    storage_->data.normalize();
+  }
+
+  void CLASSNAME::transposeInPlace()
+  {
+    storage_->data.transposeInPlace();
+  }
+
+  void CLASSNAME::adjointInPlace()
+  {
+    storage_->data.adjointInPlace();
+  }
+#endif
+
+  TYPE CLASSNAME::dot(CLASSNAME const& rhs) const
+  {
+    return storage_->data.reshaped().dot(rhs.storage()->data.reshaped());
+  }
+
+  TYPE CLASSNAME::dot(TRANSCLASSNAME const& rhs) const
+  {
+    return storage_->data.reshaped().dot(rhs.storage()->data.reshaped());
+  }
+
+  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;
+  }
--- a/src/map/operators.cpp
+++ b/src/map/operators.cpp
@ -0,0 +1,37 @@
+//==================================================================================================
+/*
+  ROTGEN - Runtime Overlay for Eigen
+  Copyright : CODE RECKONS
+  SPDX-License-Identifier: BSL-1.0
+*/
+//==================================================================================================
+
+#include <rotgen/container/map/dynamic/impl.hpp>
+#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); }  \
+/**/
+
+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; }
+  }
+  ROTGEN_IMPL_OP(==, equal    , bool);
+  ROTGEN_IMPL_OP(!=, not_equal, bool);
+}