//==================================================================================================
/*
  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;
  }
  #endif

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

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

#if !defined(USE_CONST)
  void CLASSNAME::transposeInPlace()
  {
    storage_->data.transposeInPlace();
  }

  void CLASSNAME::adjointInPlace()
  {
    storage_->data.adjointInPlace();
  }
#endif

  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 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-=(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*=(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::sub(CLASSNAME 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(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;
  }