Implements block typs and related functions - First part

Co-authored-by: Karen <kkaspar@codereckons.com>
Co-authored-by: Joel FALCOU <jfalcou@codereckons.com>

See merge request oss/rotgen!9

src/block_model.cpp

@@ -0,0 +1,172 @@
+//==================================================================================================
+/*
+  ROTGEN - Runtime Overlay for Eigen
+  Copyright : CODE RECKONS
+  SPDX-License-Identifier: BSL-1.0
+*/
+//==================================================================================================
+
+//==================================================================================================
+/*
+  This file is a X-File to generate various block_impl_* definitions variant
+*/
+//==================================================================================================
+
+//==================================================================================================
+// Internal payload
+//==================================================================================================
+struct CLASSNAME::payload
+{
+  using base_type = Eigen::Matrix<TYPE,Eigen::Dynamic,Eigen::Dynamic,STORAGE_ORDER>;
+  using data_type = Eigen::Block<base_type>;
+
+  data_type data;
+  payload (data_type const& o) : data(o) {}
+
+  payload (base_type& r, std::size_t i0, std::size_t j0, std::size_t ni, std::size_t nj)
+          : data(r,i0,j0,ni,nj)
+  {}
+};
+
+  //==================================================================================================
+  // Constructors & Special Members
+  //==================================================================================================
+  CLASSNAME::CLASSNAME(SOURCENAME& r, std::size_t i0, std::size_t j0, std::size_t ni, std::size_t nj)
+  : storage_(std::make_unique<payload>(r.storage()->data,i0,j0,ni,nj))
+  {}
+
+  CLASSNAME::CLASSNAME(CLASSNAME const& o) : storage_(std::make_unique<payload>(o.storage_->data))
+  {}
+
+  CLASSNAME&  CLASSNAME::operator=(CLASSNAME const& o)
+  {
+    if (this != &o) storage_->data = o.storage_->data;
+    return *this;
+  }
+
+  CLASSNAME::CLASSNAME(CLASSNAME&&) noexcept            = default;
+  CLASSNAME& CLASSNAME::operator=(CLASSNAME&&) noexcept = default;
+
+  CLASSNAME::~CLASSNAME() = default;
+
+  //==================================================================================================
+  // Matrix API
+  //==================================================================================================
+  std::size_t CLASSNAME::rows() const { return static_cast<std::size_t>(storage_->data.rows()); }
+  std::size_t CLASSNAME::cols() const { return static_cast<std::size_t>(storage_->data.cols()); }
+  std::size_t CLASSNAME::size() const { return static_cast<std::size_t>(storage_->data.size()); }
+
+  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(); }
+
+/*
+CLASSNAME CLASSNAME::transpose() const
+{
+  CLASSNAME result(*this);
+  result.storage_->data.transposeInPlace();
+  return result;
+
+}
+
+CLASSNAME CLASSNAME::conjugate() const
+{
+  CLASSNAME result(*this);
+  result.storage_->data = storage_->data.conjugate();
+  return result;
+}
+
+CLASSNAME CLASSNAME::adjoint() const
+{
+  CLASSNAME result(*this);
+  result.storage_->data.adjointInPlace();
+  return result;
+}
+
+void CLASSNAME::transposeInPlace()
+{
+  storage_->data.transposeInPlace();
+}
+
+void CLASSNAME::adjointInPlace()
+{
+  storage_->data.adjointInPlace();
+}
+*/
+
+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(std::ptrdiff_t* row, std::ptrdiff_t* col) const { return storage_->data.minCoeff(row, col); }
+TYPE CLASSNAME::maxCoeff(std::ptrdiff_t* row, std::ptrdiff_t* 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>();
+}
+
+//==================================================================================================
+// Operators
+//==================================================================================================
+std::ostream& operator<<(std::ostream& os,CLASSNAME const& m)
+{
+  return os << m.storage_->data;
+}
+
+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;
+}
+
+SOURCENAME CLASSNAME::operator-() const
+{
+  SOURCENAME result;
+  result.storage()->assign(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;
+}