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

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

CLASSNAME& CLASSNAME::operator=(CLASSNAME&& o)
{
  if (this != &o) storage_->data = std::move(o.storage_->data);
  return *this;
}
#endif

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

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

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

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

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

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

SOURCENAME CLASSNAME::_cwiseMin(TYPE rhs) const
{
  SOURCENAME result;
  result.storage()->assign(storage_->data.cwiseMin(rhs).eval());
  return result;
}

SOURCENAME CLASSNAME::_cwiseMax(TYPE rhs) const
{
  SOURCENAME result;
  result.storage()->assign(storage_->data.cwiseMax(rhs).eval());
  return result;
}

SOURCENAME CLASSNAME::_inverse() const
{
  SOURCENAME result;
  result.storage()->assign(storage_->data.inverse().eval());
  return result;
}

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

void CLASSNAME::_transposeInPlace()
{
  storage_->data.transposeInPlace();
}

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

TYPE CLASSNAME::_dot(CLASSNONCONSTNAME const& rhs) const
{
  return storage_->data.reshaped().dot(rhs.storage()->data.reshaped());
}

TYPE CLASSNAME::_dot(CLASSCONSTNAME const& rhs) const
{
  return storage_->data.reshaped().dot(rhs.storage()->data.reshaped());
}

TYPE CLASSNAME::_dot(TRANSCLASSNONCONSTNAME const& rhs) const
{
  return storage_->data.reshaped().dot(rhs.storage()->data.reshaped());
}

TYPE CLASSNAME::_dot(TRANSCLASSCONSTNAME const& rhs) const
{
  return storage_->data.reshaped().dot(rhs.storage()->data.reshaped());
}

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

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+=(CLASSCONSTNAME const& rhs)
{
  storage_->data += rhs.storage()->data;
  return *this;
}

CLASSNAME& CLASSNAME::operator+=(TRANSCLASSNONCONSTNAME const& rhs)
{
  storage_->data.reshaped() += rhs.storage()->data.reshaped();
  return *this;
}

CLASSNAME& CLASSNAME::operator+=(TRANSCLASSCONSTNAME const& rhs)
{
  storage_->data.reshaped() += rhs.storage()->data.reshaped();
  return *this;
}

CLASSNAME& CLASSNAME::operator-=(CLASSNAME const& rhs)
{
  storage_->data -= rhs.storage()->data;
  return *this;
}

CLASSNAME& CLASSNAME::operator-=(CLASSCONSTNAME const& rhs)
{
  storage_->data -= rhs.storage()->data;
  return *this;
}

CLASSNAME& CLASSNAME::operator-=(TRANSCLASSNONCONSTNAME const& rhs)
{
  storage_->data.reshaped() -= rhs.storage()->data.reshaped();
  return *this;
}

CLASSNAME& CLASSNAME::operator-=(TRANSCLASSCONSTNAME const& rhs)
{
  storage_->data.reshaped() -= rhs.storage()->data.reshaped();
  return *this;
}

CLASSNAME& CLASSNAME::operator*=(CLASSNAME const& rhs)
{
  storage_->data *= rhs.storage()->data;
  return *this;
}

CLASSNAME& CLASSNAME::operator*=(CLASSCONSTNAME const& rhs)
{
  storage_->data *= rhs.storage()->data;
  return *this;
}

CLASSNAME& CLASSNAME::operator*=(TRANSCLASSNONCONSTNAME const& rhs)
{
  storage_->data *= rhs.storage()->data;
  return *this;
}

CLASSNAME& CLASSNAME::operator*=(TRANSCLASSCONSTNAME 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::_add(TRANSCLASSNAME 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::_sub(TRANSCLASSNAME 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(TRANSCLASSNAME 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;
}