rotgen/src/block_model.cpp

//==================================================================================================
/*
  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
  //==================================================================================================
  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(); }

  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(); }

  SOURCENAME CLASSNAME::transpose() const
  {
    SOURCENAME 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;
  }

  SOURCENAME CLASSNAME::adjoint() const {
    SOURCENAME result;
    result.storage()->assign(storage_->data.adjoint().eval());
    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;
  }

  SOURCENAME CLASSNAME::matrix_addition(CLASSNAME const& rhs) const
  {
    SOURCENAME result;
    result.storage()->assign(storage_->data + rhs.storage_->data);
    return result;
  }

  SOURCENAME CLASSNAME::matrix_subtraction(CLASSNAME const& rhs) const
  {
    SOURCENAME result;
    result.storage()->assign(storage_->data - rhs.storage_->data);
    return result;
  }

  SOURCENAME CLASSNAME::matrix_multiplication(CLASSNAME const& rhs) const
  {
    SOURCENAME result;
    result.storage()->assign(storage_->data * rhs.storage_->data);
    return result;
  }

  SOURCENAME CLASSNAME::matrix_multiplication(TYPE s) const
  {
    SOURCENAME result;
    result.storage()->assign(storage_->data * s);
    return result;
  }

  SOURCENAME CLASSNAME::matrix_division(TYPE s) const
  {
    SOURCENAME result;
    result.storage()->assign(storage_->data / s);
    return result;
  }