Merge branch 'feat/x-files' into 'main'

Use X-macros to generate all combinations of supported Eigen Matrix types

Co-authored-by: Joel Falcou <joel.falcou@lri.fr>

See merge request oss/rotgen!8

src/matrix_model.cpp

@@ -0,0 +1,222 @@
+//==================================================================================================
+/*
+  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
+*/
+//==================================================================================================
+
+//==================================================================================================
+// Internal payload
+//==================================================================================================
+struct MATRIX::payload
+{
+  using data_type = Eigen::Matrix<TYPE,Eigen::Dynamic,Eigen::Dynamic,STORAGE_ORDER>;
+
+  data_type data;
+  payload(std::size_t r=0, std::size_t c=0) : data(r, c) {}
+  payload(std::initializer_list<std::initializer_list<TYPE>> init) : data(init) {}
+  payload(data_type&& matrix) : data(std::move(matrix)) {}
+};
+
+//==================================================================================================
+// Constructors & Special Members
+//==================================================================================================
+MATRIX::MATRIX(std::size_t r, std::size_t c) : storage_(std::make_unique<payload>(r,c)) {}
+
+MATRIX::MATRIX(std::initializer_list<std::initializer_list<TYPE>> init)
+              : storage_(std::make_unique<payload>(init))
+{}
+
+MATRIX::MATRIX(std::size_t r, std::size_t c,std::initializer_list<TYPE> init)
+: MATRIX(r,c)
+{
+  auto first = init.begin();
+  for(std::size_t i=0; i < init.size(); i++)
+    (*this)(i) = first[i];
+}
+
+MATRIX::MATRIX(MATRIX const& o)
+              : MATRIX(o.rows(),o.cols())
+{
+  storage_->data = o.storage_->data;
+}
+
+MATRIX::MATRIX(MATRIX&&) noexcept            = default;
+
+
+MATRIX&  MATRIX::operator=(MATRIX const& o)
+{
+  if (this != &o) storage_->data = o.storage_->data;
+  return *this;
+}
+
+MATRIX& MATRIX::operator=(MATRIX&&) noexcept = default;
+
+MATRIX::~MATRIX()                                   = default;
+
+//==================================================================================================
+// Matrix API
+//==================================================================================================
+std::size_t MATRIX::rows() const { return static_cast<std::size_t>(storage_->data.rows()); }
+std::size_t MATRIX::cols() const { return static_cast<std::size_t>(storage_->data.cols()); }
+std::size_t MATRIX::size() const { return static_cast<std::size_t>(storage_->data.size()); }
+
+void MATRIX::resize(std::size_t new_rows, std::size_t new_cols)
+{
+  storage_->data.resize(new_rows, new_cols);
+}
+
+void MATRIX::conservativeResize(std::size_t new_rows, std::size_t new_cols)
+{
+  storage_->data.conservativeResize(new_rows, new_cols);
+}
+
+TYPE&       MATRIX::operator()(std::size_t i, std::size_t j)       { return storage_->data(i,j); }
+TYPE const& MATRIX::operator()(std::size_t i, std::size_t j) const { return storage_->data(i,j); }
+
+TYPE&       MATRIX::operator()(std::size_t index)       { return storage_->data(index); }
+TYPE const& MATRIX::operator()(std::size_t index) const { return storage_->data(index); }
+
+const TYPE* MATRIX::data() const { return storage_->data.data(); }
+
+MATRIX MATRIX::transpose() const
+{
+  MATRIX result(*this);
+  result.storage_->data.transposeInPlace();
+  return result;
+
+}
+
+MATRIX MATRIX::conjugate() const
+{
+  MATRIX result(*this);
+  result.storage_->data = storage_->data.conjugate();
+  return result;
+}
+
+MATRIX MATRIX::adjoint() const
+{
+  MATRIX result(*this);
+  result.storage_->data.adjointInPlace();
+  return result;
+}
+
+void MATRIX::transposeInPlace()
+{
+  storage_->data.transposeInPlace();
+}
+
+void MATRIX::adjointInPlace()
+{
+  storage_->data.adjointInPlace();
+}
+
+TYPE MATRIX::sum()    const { return storage_->data.sum(); }
+TYPE MATRIX::prod()   const { return storage_->data.prod(); }
+TYPE MATRIX::mean()   const { return storage_->data.mean(); }
+TYPE MATRIX::trace()  const { return storage_->data.trace(); }
+
+TYPE MATRIX::minCoeff() const { return storage_->data.minCoeff(); }
+TYPE MATRIX::maxCoeff() const { return storage_->data.maxCoeff(); }
+
+TYPE MATRIX::minCoeff(std::ptrdiff_t* row, std::ptrdiff_t* col) const { return storage_->data.minCoeff(row, col); }
+TYPE MATRIX::maxCoeff(std::ptrdiff_t* row, std::ptrdiff_t* col) const { return storage_->data.maxCoeff(row, col); }
+
+TYPE MATRIX::squaredNorm()  const { return storage_->data.squaredNorm(); }
+TYPE MATRIX::norm()         const { return storage_->data.norm(); }
+
+TYPE MATRIX::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,MATRIX const& m)
+{
+  return os << m.storage_->data;
+}
+
+bool operator==(MATRIX const& lhs, MATRIX const& rhs)
+{
+  return lhs.storage_->data == rhs.storage_->data;
+}
+
+MATRIX& MATRIX::operator+=(MATRIX const& rhs)
+{
+  storage_->data += rhs.storage_->data;
+  return *this;
+}
+
+MATRIX& MATRIX::operator-=(MATRIX const& rhs)
+{
+  storage_->data -= rhs.storage_->data;
+  return *this;
+}
+
+MATRIX MATRIX::operator-() const
+{
+  MATRIX result(*this);
+  result.storage_->data = -result.storage_->data;
+  return result;
+}
+
+MATRIX& MATRIX::operator*=(MATRIX const& rhs)
+{
+  storage_->data *= rhs.storage_->data;
+  return *this;
+}
+
+MATRIX& MATRIX::operator*=(TYPE s)
+{
+  storage_->data *= s;
+  return *this;
+}
+
+MATRIX& MATRIX::operator/=(TYPE s)
+{
+  storage_->data /= s;
+  return *this;
+}
+
+//==================================================================================================
+// Static functions
+//==================================================================================================
+
+MATRIX MATRIX::Zero(std::size_t rows, std::size_t cols)
+{
+  MATRIX m;
+  m.storage_ = std::make_unique<payload>(payload::data_type::Zero(rows, cols));
+  return m;
+}
+
+MATRIX MATRIX::Constant(std::size_t rows, std::size_t cols, TYPE value)
+{
+  MATRIX m;
+  m.storage_ = std::make_unique<payload>(payload::data_type::Constant(rows, cols, value));
+  return m;
+}
+
+MATRIX MATRIX::Random(std::size_t rows, std::size_t cols)
+{
+  MATRIX m;
+  m.storage_ = std::make_unique<payload>(payload::data_type::Random(rows, cols));
+  return m;
+}
+
+MATRIX MATRIX::Identity(std::size_t rows, std::size_t cols)
+{
+  MATRIX m;
+  m.storage_ = std::make_unique<payload>(payload::data_type::Identity(rows, cols));
+  return m;
+}