DenseBase.h

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_DENSEBASE_H
#define EIGEN_DENSEBASE_H

// IWYU pragma: private
#include "./InternalHeaderCheck.h"

namespace Eigen {

// The index type defined by EIGEN_DEFAULT_DENSE_INDEX_TYPE must be a signed type.
EIGEN_STATIC_ASSERT(NumTraits<DenseIndex>::IsSigned, THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE)


template <typename Derived>
class DenseBase
#ifndef EIGEN_PARSED_BY_DOXYGEN
    : public DenseCoeffsBase<Derived, internal::accessors_level<Derived>::value>
#else
    : public DenseCoeffsBase<Derived, DirectWriteAccessors>
#endif  // not EIGEN_PARSED_BY_DOXYGEN
{
 public:
  typedef Eigen::InnerIterator<Derived> InnerIterator;

  typedef typename internal::traits<Derived>::StorageKind StorageKind;

  typedef typename internal::traits<Derived>::StorageIndex StorageIndex;

  typedef typename internal::traits<Derived>::Scalar Scalar;

  typedef Scalar value_type;

  typedef typename NumTraits<Scalar>::Real RealScalar;
  typedef DenseCoeffsBase<Derived, internal::accessors_level<Derived>::value> Base;

  using Base::coeff;
  using Base::coeffByOuterInner;
  using Base::colIndexByOuterInner;
  using Base::cols;
  using Base::const_cast_derived;
  using Base::derived;
  using Base::rowIndexByOuterInner;
  using Base::rows;
  using Base::size;
  using Base::operator();
  using Base::operator[];
  using Base::colStride;
  using Base::innerStride;
  using Base::outerStride;
  using Base::rowStride;
  using Base::stride;
  using Base::w;
  using Base::x;
  using Base::y;
  using Base::z;
  typedef typename Base::CoeffReturnType CoeffReturnType;

  enum {

    RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
    ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
    SizeAtCompileTime = (internal::size_of_xpr_at_compile_time<Derived>::ret),
    MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
    MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
    MaxSizeAtCompileTime = internal::size_at_compile_time(internal::traits<Derived>::MaxRowsAtCompileTime,
                                                          internal::traits<Derived>::MaxColsAtCompileTime),
    IsVectorAtCompileTime =
        internal::traits<Derived>::RowsAtCompileTime == 1 || internal::traits<Derived>::ColsAtCompileTime == 1,
    NumDimensions = int(MaxSizeAtCompileTime) == 1 ? 0
                    : bool(IsVectorAtCompileTime)  ? 1
                                                   : 2,
    Flags = internal::traits<Derived>::Flags,
    IsRowMajor = int(Flags) & RowMajorBit, 
    InnerSizeAtCompileTime = int(IsVectorAtCompileTime) ? int(SizeAtCompileTime)
                             : int(IsRowMajor)          ? int(ColsAtCompileTime)
                                                        : int(RowsAtCompileTime),

    InnerStrideAtCompileTime = internal::inner_stride_at_compile_time<Derived>::ret,
    OuterStrideAtCompileTime = internal::outer_stride_at_compile_time<Derived>::ret
  };

  typedef typename internal::find_best_packet<Scalar, SizeAtCompileTime>::type PacketScalar;

  enum { IsPlainObjectBase = 0 };

  typedef Matrix<typename internal::traits<Derived>::Scalar, internal::traits<Derived>::RowsAtCompileTime,
                 internal::traits<Derived>::ColsAtCompileTime,
                 AutoAlign | (internal::traits<Derived>::Flags & RowMajorBit ? RowMajor : ColMajor),
                 internal::traits<Derived>::MaxRowsAtCompileTime, internal::traits<Derived>::MaxColsAtCompileTime>
      PlainMatrix;

  typedef Array<typename internal::traits<Derived>::Scalar, internal::traits<Derived>::RowsAtCompileTime,
                internal::traits<Derived>::ColsAtCompileTime,
                AutoAlign | (internal::traits<Derived>::Flags & RowMajorBit ? RowMajor : ColMajor),
                internal::traits<Derived>::MaxRowsAtCompileTime, internal::traits<Derived>::MaxColsAtCompileTime>
      PlainArray;

  typedef std::conditional_t<internal::is_same<typename internal::traits<Derived>::XprKind, MatrixXpr>::value,
                             PlainMatrix, PlainArray>
      PlainObject;

  EIGEN_DEVICE_FUNC constexpr Index outerSize() const {
    return IsVectorAtCompileTime ? 1 : int(IsRowMajor) ? this->rows() : this->cols();
  }

  EIGEN_DEVICE_FUNC constexpr Index innerSize() const {
    return IsVectorAtCompileTime ? this->size() : int(IsRowMajor) ? this->cols() : this->rows();
  }

  EIGEN_DEVICE_FUNC void resize(Index newSize) {
    EIGEN_ONLY_USED_FOR_DEBUG(newSize);
    eigen_assert(newSize == this->size() && "DenseBase::resize() does not actually allow to resize.");
  }
  EIGEN_DEVICE_FUNC void resize(Index rows, Index cols) {
    EIGEN_ONLY_USED_FOR_DEBUG(rows);
    EIGEN_ONLY_USED_FOR_DEBUG(cols);
    eigen_assert(rows == this->rows() && cols == this->cols() &&
                 "DenseBase::resize() does not actually allow to resize.");
  }

#ifndef EIGEN_PARSED_BY_DOXYGEN

  typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> ConstantReturnType;
  typedef CwiseNullaryOp<internal::scalar_zero_op<Scalar>, PlainObject> ZeroReturnType;
  EIGEN_DEPRECATED typedef CwiseNullaryOp<internal::linspaced_op<Scalar>, PlainObject> SequentialLinSpacedReturnType;
  typedef CwiseNullaryOp<internal::linspaced_op<Scalar>, PlainObject> RandomAccessLinSpacedReturnType;
  typedef CwiseNullaryOp<internal::equalspaced_op<Scalar>, PlainObject> RandomAccessEqualSpacedReturnType;
  typedef Matrix<typename NumTraits<typename internal::traits<Derived>::Scalar>::Real,
                 internal::traits<Derived>::ColsAtCompileTime, 1>
      EigenvaluesReturnType;

#endif  // not EIGEN_PARSED_BY_DOXYGEN

  template <typename OtherDerived>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const DenseBase<OtherDerived>& other);

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const DenseBase& other);

  template <typename OtherDerived>
  EIGEN_DEVICE_FUNC Derived& operator=(const EigenBase<OtherDerived>& other);

  template <typename OtherDerived>
  EIGEN_DEVICE_FUNC Derived& operator+=(const EigenBase<OtherDerived>& other);

  template <typename OtherDerived>
  EIGEN_DEVICE_FUNC Derived& operator-=(const EigenBase<OtherDerived>& other);

  template <typename OtherDerived>
  EIGEN_DEVICE_FUNC Derived& operator=(const ReturnByValue<OtherDerived>& func);

  template <typename OtherDerived>
  EIGEN_DEPRECATED EIGEN_DEVICE_FUNC Derived& lazyAssign(const DenseBase<OtherDerived>& other);

  EIGEN_DEVICE_FUNC CommaInitializer<Derived> operator<<(const Scalar& s);

  template <unsigned int Added, unsigned int Removed>
  EIGEN_DEPRECATED const Derived& flagged() const {
    return derived();
  }

  template <typename OtherDerived>
  EIGEN_DEVICE_FUNC CommaInitializer<Derived> operator<<(const DenseBase<OtherDerived>& other);

  typedef Transpose<Derived> TransposeReturnType;
  EIGEN_DEVICE_FUNC TransposeReturnType transpose();
  typedef Transpose<const Derived> ConstTransposeReturnType;
  EIGEN_DEVICE_FUNC const ConstTransposeReturnType transpose() const;
  EIGEN_DEVICE_FUNC void transposeInPlace();

  EIGEN_DEVICE_FUNC static const ConstantReturnType Constant(Index rows, Index cols, const Scalar& value);
  EIGEN_DEVICE_FUNC static const ConstantReturnType Constant(Index size, const Scalar& value);
  EIGEN_DEVICE_FUNC static const ConstantReturnType Constant(const Scalar& value);

  EIGEN_DEPRECATED_WITH_REASON("The method may result in accuracy loss. Use .EqualSpaced() instead.")
  EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType LinSpaced(Sequential_t, Index size, const Scalar& low,
                                                                           const Scalar& high);
  EIGEN_DEPRECATED_WITH_REASON("The method may result in accuracy loss. Use .EqualSpaced() instead.")
  EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType LinSpaced(Sequential_t, const Scalar& low,
                                                                           const Scalar& high);

  EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType LinSpaced(Index size, const Scalar& low,
                                                                           const Scalar& high);
  EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType LinSpaced(const Scalar& low, const Scalar& high);

  EIGEN_DEVICE_FUNC static const RandomAccessEqualSpacedReturnType EqualSpaced(Index size, const Scalar& low,
                                                                               const Scalar& step);
  EIGEN_DEVICE_FUNC static const RandomAccessEqualSpacedReturnType EqualSpaced(const Scalar& low, const Scalar& step);

  template <typename CustomNullaryOp>
  EIGEN_DEVICE_FUNC static const CwiseNullaryOp<CustomNullaryOp, PlainObject> NullaryExpr(Index rows, Index cols,
                                                                                          const CustomNullaryOp& func);
  template <typename CustomNullaryOp>
  EIGEN_DEVICE_FUNC static const CwiseNullaryOp<CustomNullaryOp, PlainObject> NullaryExpr(Index size,
                                                                                          const CustomNullaryOp& func);
  template <typename CustomNullaryOp>
  EIGEN_DEVICE_FUNC static const CwiseNullaryOp<CustomNullaryOp, PlainObject> NullaryExpr(const CustomNullaryOp& func);

  EIGEN_DEVICE_FUNC static const ZeroReturnType Zero(Index rows, Index cols);
  EIGEN_DEVICE_FUNC static const ZeroReturnType Zero(Index size);
  EIGEN_DEVICE_FUNC static const ZeroReturnType Zero();
  EIGEN_DEVICE_FUNC static const ConstantReturnType Ones(Index rows, Index cols);
  EIGEN_DEVICE_FUNC static const ConstantReturnType Ones(Index size);
  EIGEN_DEVICE_FUNC static const ConstantReturnType Ones();

  EIGEN_DEVICE_FUNC void fill(const Scalar& value);
  EIGEN_DEVICE_FUNC Derived& setConstant(const Scalar& value);
  EIGEN_DEVICE_FUNC Derived& setLinSpaced(Index size, const Scalar& low, const Scalar& high);
  EIGEN_DEVICE_FUNC Derived& setLinSpaced(const Scalar& low, const Scalar& high);
  EIGEN_DEVICE_FUNC Derived& setEqualSpaced(Index size, const Scalar& low, const Scalar& step);
  EIGEN_DEVICE_FUNC Derived& setEqualSpaced(const Scalar& low, const Scalar& step);
  EIGEN_DEVICE_FUNC Derived& setZero();
  EIGEN_DEVICE_FUNC Derived& setOnes();
  EIGEN_DEVICE_FUNC Derived& setRandom();

  template <typename OtherDerived>
  EIGEN_DEVICE_FUNC bool isApprox(const DenseBase<OtherDerived>& other,
                                  const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
  EIGEN_DEVICE_FUNC bool isMuchSmallerThan(const RealScalar& other,
                                           const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
  template <typename OtherDerived>
  EIGEN_DEVICE_FUNC bool isMuchSmallerThan(const DenseBase<OtherDerived>& other,
                                           const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;

  EIGEN_DEVICE_FUNC bool isApproxToConstant(const Scalar& value,
                                            const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
  EIGEN_DEVICE_FUNC bool isConstant(const Scalar& value,
                                    const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
  EIGEN_DEVICE_FUNC bool isZero(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
  EIGEN_DEVICE_FUNC bool isOnes(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;

  EIGEN_DEVICE_FUNC inline bool hasNaN() const;
  EIGEN_DEVICE_FUNC inline bool allFinite() const;

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator*=(const Scalar& other);
  template <bool Enable = !internal::is_same<Scalar, RealScalar>::value, typename = std::enable_if_t<Enable>>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator*=(const RealScalar& other);

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator/=(const Scalar& other);
  template <bool Enable = !internal::is_same<Scalar, RealScalar>::value, typename = std::enable_if_t<Enable>>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator/=(const RealScalar& other);

  typedef internal::add_const_on_value_type_t<typename internal::eval<Derived>::type> EvalReturnType;
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EvalReturnType eval() const {
    // Even though MSVC does not honor strong inlining when the return type
    // is a dynamic matrix, we desperately need strong inlining for fixed
    // size types on MSVC.
    return typename internal::eval<Derived>::type(derived());
  }

  template <typename OtherDerived>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void swap(const DenseBase<OtherDerived>& other) {
    EIGEN_STATIC_ASSERT(!OtherDerived::IsPlainObjectBase, THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
    eigen_assert(rows() == other.rows() && cols() == other.cols());
    call_assignment(derived(), other.const_cast_derived(), internal::swap_assign_op<Scalar>());
  }

  template <typename OtherDerived>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void swap(PlainObjectBase<OtherDerived>& other) {
    eigen_assert(rows() == other.rows() && cols() == other.cols());
    call_assignment(derived(), other.derived(), internal::swap_assign_op<Scalar>());
  }

  EIGEN_DEVICE_FUNC inline const NestByValue<Derived> nestByValue() const;
  EIGEN_DEVICE_FUNC inline const ForceAlignedAccess<Derived> forceAlignedAccess() const;
  EIGEN_DEVICE_FUNC inline ForceAlignedAccess<Derived> forceAlignedAccess();
  template <bool Enable>
  EIGEN_DEVICE_FUNC inline const std::conditional_t<Enable, ForceAlignedAccess<Derived>, Derived&>
  forceAlignedAccessIf() const;
  template <bool Enable>
  EIGEN_DEVICE_FUNC inline std::conditional_t<Enable, ForceAlignedAccess<Derived>, Derived&> forceAlignedAccessIf();

  EIGEN_DEVICE_FUNC Scalar sum() const;
  EIGEN_DEVICE_FUNC Scalar mean() const;
  EIGEN_DEVICE_FUNC Scalar trace() const;

  EIGEN_DEVICE_FUNC Scalar prod() const;

  template <int NaNPropagation>
  EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar minCoeff() const;
  template <int NaNPropagation>
  EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar maxCoeff() const;

  // By default, the fastest version with undefined NaN propagation semantics is
  // used.
  // TODO(rmlarsen): Replace with default template argument when we move to
  // c++11 or beyond.
  EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar minCoeff() const {
    return minCoeff<PropagateFast>();
  }
  EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar maxCoeff() const {
    return maxCoeff<PropagateFast>();
  }

  template <int NaNPropagation, typename IndexType>
  EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar minCoeff(IndexType* row, IndexType* col) const;
  template <int NaNPropagation, typename IndexType>
  EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar maxCoeff(IndexType* row, IndexType* col) const;
  template <int NaNPropagation, typename IndexType>
  EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar minCoeff(IndexType* index) const;
  template <int NaNPropagation, typename IndexType>
  EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar maxCoeff(IndexType* index) const;

  // TODO(rmlarsen): Replace these methods with a default template argument.
  template <typename IndexType>
  EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar minCoeff(IndexType* row, IndexType* col) const {
    return minCoeff<PropagateFast>(row, col);
  }
  template <typename IndexType>
  EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar maxCoeff(IndexType* row, IndexType* col) const {
    return maxCoeff<PropagateFast>(row, col);
  }
  template <typename IndexType>
  EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar minCoeff(IndexType* index) const {
    return minCoeff<PropagateFast>(index);
  }
  template <typename IndexType>
  EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar maxCoeff(IndexType* index) const {
    return maxCoeff<PropagateFast>(index);
  }

  template <typename BinaryOp>
  EIGEN_DEVICE_FUNC Scalar redux(const BinaryOp& func) const;

  template <typename Visitor>
  EIGEN_DEVICE_FUNC void visit(Visitor& func) const;

  inline const WithFormat<Derived> format(const IOFormat& fmt) const { return WithFormat<Derived>(derived(), fmt); }

  EIGEN_DEVICE_FUNC CoeffReturnType value() const {
    EIGEN_STATIC_ASSERT_SIZE_1x1(Derived) eigen_assert(this->rows() == 1 && this->cols() == 1);
    return derived().coeff(0, 0);
  }

  EIGEN_DEVICE_FUNC bool all() const;
  EIGEN_DEVICE_FUNC bool any() const;
  EIGEN_DEVICE_FUNC Index count() const;

  typedef VectorwiseOp<Derived, Horizontal> RowwiseReturnType;
  typedef const VectorwiseOp<const Derived, Horizontal> ConstRowwiseReturnType;
  typedef VectorwiseOp<Derived, Vertical> ColwiseReturnType;
  typedef const VectorwiseOp<const Derived, Vertical> ConstColwiseReturnType;

  // Code moved here due to a CUDA compiler bug
  EIGEN_DEVICE_FUNC inline ConstRowwiseReturnType rowwise() const { return ConstRowwiseReturnType(derived()); }
  EIGEN_DEVICE_FUNC RowwiseReturnType rowwise();

  EIGEN_DEVICE_FUNC inline ConstColwiseReturnType colwise() const { return ConstColwiseReturnType(derived()); }
  EIGEN_DEVICE_FUNC ColwiseReturnType colwise();

  typedef CwiseNullaryOp<internal::scalar_random_op<Scalar>, PlainObject> RandomReturnType;
  static const RandomReturnType Random(Index rows, Index cols);
  static const RandomReturnType Random(Index size);
  static const RandomReturnType Random();

  template <typename ThenDerived, typename ElseDerived>
  inline EIGEN_DEVICE_FUNC
      CwiseTernaryOp<internal::scalar_boolean_select_op<typename DenseBase<ThenDerived>::Scalar,
                                                        typename DenseBase<ElseDerived>::Scalar, Scalar>,
                     ThenDerived, ElseDerived, Derived>
      select(const DenseBase<ThenDerived>& thenMatrix, const DenseBase<ElseDerived>& elseMatrix) const;

  template <typename ThenDerived>
  inline EIGEN_DEVICE_FUNC
      CwiseTernaryOp<internal::scalar_boolean_select_op<typename DenseBase<ThenDerived>::Scalar,
                                                        typename DenseBase<ThenDerived>::Scalar, Scalar>,
                     ThenDerived, typename DenseBase<ThenDerived>::ConstantReturnType, Derived>
      select(const DenseBase<ThenDerived>& thenMatrix, const typename DenseBase<ThenDerived>::Scalar& elseScalar) const;

  template <typename ElseDerived>
  inline EIGEN_DEVICE_FUNC
      CwiseTernaryOp<internal::scalar_boolean_select_op<typename DenseBase<ElseDerived>::Scalar,
                                                        typename DenseBase<ElseDerived>::Scalar, Scalar>,
                     typename DenseBase<ElseDerived>::ConstantReturnType, ElseDerived, Derived>
      select(const typename DenseBase<ElseDerived>::Scalar& thenScalar, const DenseBase<ElseDerived>& elseMatrix) const;

  template <int p>
  RealScalar lpNorm() const;

  template <int RowFactor, int ColFactor>
  EIGEN_DEVICE_FUNC const Replicate<Derived, RowFactor, ColFactor> replicate() const;
  // Code moved here due to a CUDA compiler bug
  EIGEN_DEVICE_FUNC const Replicate<Derived, Dynamic, Dynamic> replicate(Index rowFactor, Index colFactor) const {
    return Replicate<Derived, Dynamic, Dynamic>(derived(), rowFactor, colFactor);
  }

  typedef Reverse<Derived, BothDirections> ReverseReturnType;
  typedef const Reverse<const Derived, BothDirections> ConstReverseReturnType;
  EIGEN_DEVICE_FUNC ReverseReturnType reverse();
  // Code moved here due to a CUDA compiler bug
  EIGEN_DEVICE_FUNC ConstReverseReturnType reverse() const { return ConstReverseReturnType(derived()); }
  EIGEN_DEVICE_FUNC void reverseInPlace();

#ifdef EIGEN_PARSED_BY_DOXYGEN

  typedef random_access_iterator_type iterator;
  typedef random_access_iterator_type const_iterator;
#else
  typedef std::conditional_t<(Flags & DirectAccessBit) == DirectAccessBit,
                             internal::pointer_based_stl_iterator<Derived>,
                             internal::generic_randaccess_stl_iterator<Derived> >
      iterator_type;

  typedef std::conditional_t<(Flags & DirectAccessBit) == DirectAccessBit,
                             internal::pointer_based_stl_iterator<const Derived>,
                             internal::generic_randaccess_stl_iterator<const Derived> >
      const_iterator_type;

  // Stl-style iterators are supported only for vectors.

  typedef std::conditional_t<IsVectorAtCompileTime, iterator_type, void> iterator;

  typedef std::conditional_t<IsVectorAtCompileTime, const_iterator_type, void> const_iterator;
#endif

  inline iterator begin();
  inline const_iterator begin() const;
  inline const_iterator cbegin() const;
  inline iterator end();
  inline const_iterator end() const;
  inline const_iterator cend() const;

  using RealViewReturnType = std::conditional_t<NumTraits<Scalar>::IsComplex, RealView<Derived>, Derived&>;
  using ConstRealViewReturnType =
      std::conditional_t<NumTraits<Scalar>::IsComplex, RealView<const Derived>, const Derived&>;

  EIGEN_DEVICE_FUNC RealViewReturnType realView();
  EIGEN_DEVICE_FUNC ConstRealViewReturnType realView() const;

#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::DenseBase
#define EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
#define EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(COND)
#define EIGEN_DOC_UNARY_ADDONS(X, Y)
#include "../plugins/CommonCwiseUnaryOps.inc"
#include "../plugins/BlockMethods.inc"
#include "../plugins/IndexedViewMethods.inc"
#include "../plugins/ReshapedMethods.inc"
#ifdef EIGEN_DENSEBASE_PLUGIN
#include EIGEN_DENSEBASE_PLUGIN
#endif
#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
#undef EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
#undef EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF
#undef EIGEN_DOC_UNARY_ADDONS

  // disable the use of evalTo for dense objects with a nice compilation error
  template <typename Dest>
  EIGEN_DEVICE_FUNC inline void evalTo(Dest&) const {
    EIGEN_STATIC_ASSERT((internal::is_same<Dest, void>::value),
                        THE_EVAL_EVALTO_FUNCTION_SHOULD_NEVER_BE_CALLED_FOR_DENSE_OBJECTS);
  }

 protected:
  EIGEN_DEFAULT_COPY_CONSTRUCTOR(DenseBase)
#ifdef EIGEN_INTERNAL_DEBUGGING
  EIGEN_DEVICE_FUNC constexpr DenseBase() {
    /* Just checks for self-consistency of the flags.
     * Only do it when debugging Eigen, as this borders on paranoia and could slow compilation down
     */
    EIGEN_STATIC_ASSERT(
        (internal::check_implication(MaxRowsAtCompileTime == 1 && MaxColsAtCompileTime != 1, int(IsRowMajor)) &&
         internal::check_implication(MaxColsAtCompileTime == 1 && MaxRowsAtCompileTime != 1, int(!IsRowMajor))),
        INVALID_STORAGE_ORDER_FOR_THIS_VECTOR_EXPRESSION)
  }
#else
  EIGEN_DEVICE_FUNC constexpr DenseBase() = default;
#endif

 private:
  EIGEN_DEVICE_FUNC explicit DenseBase(int);
  EIGEN_DEVICE_FUNC DenseBase(int, int);
  template <typename OtherDerived>
  EIGEN_DEVICE_FUNC explicit DenseBase(const DenseBase<OtherDerived>&);
};

template <typename DerivedA, typename DerivedB>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
    // Use forwarding references to capture all combinations of cv-qualified l+r-value cases.
    std::enable_if_t<std::is_base_of<DenseBase<std::decay_t<DerivedA>>, std::decay_t<DerivedA>>::value &&
                         std::is_base_of<DenseBase<std::decay_t<DerivedB>>, std::decay_t<DerivedB>>::value,
                     void>
    swap(DerivedA&& a, DerivedB&& b) {
  a.swap(b);
}

}  // end namespace Eigen

#endif  // EIGEN_DENSEBASE_H