Reorganize internals

See merge request oss/rotgen!36

src/matrix/model.cpp

@@ -0,0 +1,267 @@
+//==================================================================================================
+/*
+  ROTGEN - Runtime Overlay for Eigen
+  Copyright : CODE RECKONS
+  SPDX-License-Identifier: BSL-1.0
+*/
+//==================================================================================================
+
+//==================================================================================================
+/*
+  This file is a X-File to generate various matrix_impl_* definitions variant
+*/
+//==================================================================================================
+
+//==================================================================================================
+// 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(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::operator=(CLASSNAME const& o)
+{
+  if (this != &o) storage_->data = o.storage_->data;
+  return *this;
+}
+
+CLASSNAME& CLASSNAME::operator=(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(); }
+
+void CLASSNAME::resize(std::size_t new_rows, std::size_t new_cols)
+{
+  storage_->data.resize(new_rows, new_cols);
+}
+
+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 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
+{
+  CLASSNAME result(*this);
+  result.storage_->data.normalize();
+  return result;
+}
+
+TRANSCLASSNAME CLASSNAME::transpose() const
+{
+  TRANSCLASSNAME result;
+  result.storage()->data = storage_->data.transpose();
+  return result;
+}
+
+CLASSNAME CLASSNAME::conjugate() const
+{
+  CLASSNAME result(*this);
+  result.storage_->data = storage_->data.conjugate();
+  return result;
+}
+
+TRANSCLASSNAME CLASSNAME::adjoint() const
+{
+  TRANSCLASSNAME result;
+  result.storage()->data = storage_->data.adjoint();
+  return result;
+}
+
+void CLASSNAME::normalize()
+{
+  storage_->data.normalize();
+}
+
+void CLASSNAME::transposeInPlace()
+{
+  storage_->data.transposeInPlace();
+}
+
+void CLASSNAME::adjointInPlace()
+{
+  storage_->data.adjointInPlace();
+}
+
+CLASSNAME CLASSNAME::cwiseAbs() const
+{
+  CLASSNAME result(*this);
+  result.storage_->data = storage_->data.cwiseAbs();
+  return result;
+}
+
+CLASSNAME CLASSNAME::cwiseAbs2() const
+{
+  CLASSNAME result(*this);
+  result.storage_->data = storage_->data.cwiseAbs2();
+  return result;
+}
+
+CLASSNAME CLASSNAME::cwiseInverse() const
+{
+  CLASSNAME result(*this);
+  result.storage_->data = storage_->data.cwiseInverse();
+  return result;
+}
+
+CLASSNAME CLASSNAME::cwiseSqrt() const
+{
+  CLASSNAME result(*this);
+  result.storage_->data = storage_->data.cwiseSqrt();
+  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::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>();
+}
+
+//==================================================================================================
+// 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;
+}
+
+CLASSNAME& CLASSNAME::operator+=(CLASSNAME 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-() const
+{
+  CLASSNAME result(*this);
+  result.storage_->data = -result.storage_->data;
+  return result;
+}
+
+CLASSNAME& CLASSNAME::operator*=(CLASSNAME 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;
+}
+
+//==================================================================================================
+// Static functions
+//==================================================================================================
+
+CLASSNAME CLASSNAME::Ones(std::size_t rows, std::size_t cols)
+{
+  CLASSNAME m;
+  m.storage_ = std::make_unique<payload>(payload::data_type::Ones(rows, cols));
+  return m;
+}
+
+CLASSNAME CLASSNAME::Zero(std::size_t rows, std::size_t cols)
+{
+  CLASSNAME m;
+  m.storage_ = std::make_unique<payload>(payload::data_type::Zero(rows, cols));
+  return m;
+}
+
+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));
+  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));
+  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));
+  return m;
+}