Eigen/src/Core/Ref.h - eigen - Git at Google

 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
 // Copyright (C) 2012 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_REF_H
 #define EIGEN_REF_H

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

 namespace Eigen {

 namespace internal {

 template <typename PlainObjectType_, int Options_, typename StrideType_>
 struct traits<Ref<PlainObjectType_, Options_, StrideType_> >
     : public traits<Map<PlainObjectType_, Options_, StrideType_> > {
   typedef PlainObjectType_ PlainObjectType;
   typedef StrideType_ StrideType;
   enum {
     Options = Options_,
     Flags = traits<Map<PlainObjectType_, Options_, StrideType_> >::Flags | NestByRefBit,
     Alignment = traits<Map<PlainObjectType_, Options_, StrideType_> >::Alignment,
     InnerStrideAtCompileTime = traits<Map<PlainObjectType_, Options_, StrideType_> >::InnerStrideAtCompileTime,
     OuterStrideAtCompileTime = traits<Map<PlainObjectType_, Options_, StrideType_> >::OuterStrideAtCompileTime
   };

   template <typename Derived>
   struct match {
     enum {
       IsVectorAtCompileTime = PlainObjectType::IsVectorAtCompileTime || Derived::IsVectorAtCompileTime,
       HasDirectAccess = internal::has_direct_access<Derived>::ret,
       StorageOrderMatch =
           IsVectorAtCompileTime || ((PlainObjectType::Flags & RowMajorBit) == (Derived::Flags & RowMajorBit)),
       InnerStrideMatch = int(InnerStrideAtCompileTime) == int(Dynamic) ||
                          int(InnerStrideAtCompileTime) == int(Derived::InnerStrideAtCompileTime) ||
                          (int(InnerStrideAtCompileTime) == 0 && int(Derived::InnerStrideAtCompileTime) == 1),
       OuterStrideMatch = IsVectorAtCompileTime || int(OuterStrideAtCompileTime) == int(Dynamic) ||
                          int(OuterStrideAtCompileTime) == int(Derived::OuterStrideAtCompileTime),
       // NOTE, this indirection of evaluator<Derived>::Alignment is needed
       // to workaround a very strange bug in MSVC related to the instantiation
       // of has_*ary_operator in evaluator<CwiseNullaryOp>.
       // This line is surprisingly very sensitive. For instance, simply adding parenthesis
       // as "DerivedAlignment = (int(evaluator<Derived>::Alignment))," will make MSVC fail...
       DerivedAlignment = int(evaluator<Derived>::Alignment),
       AlignmentMatch = (int(traits<PlainObjectType>::Alignment) == int(Unaligned)) ||
                        (DerivedAlignment >= int(Alignment)),  // FIXME the first condition is not very clear, it should
                                                               // be replaced by the required alignment
       ScalarTypeMatch = internal::is_same<typename PlainObjectType::Scalar, typename Derived::Scalar>::value,
       MatchAtCompileTime = HasDirectAccess && StorageOrderMatch && InnerStrideMatch && OuterStrideMatch &&
                            AlignmentMatch && ScalarTypeMatch
     };
     typedef std::conditional_t<MatchAtCompileTime, internal::true_type, internal::false_type> type;
   };
 };

 template <typename Derived>
 struct traits<RefBase<Derived> > : public traits<Derived> {};

 }  // namespace internal

 template <typename Derived>
 class RefBase : public MapBase<Derived> {
   typedef typename internal::traits<Derived>::PlainObjectType PlainObjectType;
   typedef typename internal::traits<Derived>::StrideType StrideType;

  public:
   typedef MapBase<Derived> Base;
   EIGEN_DENSE_PUBLIC_INTERFACE(RefBase)

   EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index innerStride() const {
     return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1;
   }

   EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index outerStride() const {
     return StrideType::OuterStrideAtCompileTime != 0 ? m_stride.outer()
            : IsVectorAtCompileTime                   ? this->size()
            : int(Flags) & RowMajorBit                ? this->cols()
                                                      : this->rows();
   }

   EIGEN_DEVICE_FUNC RefBase()
       : Base(0, RowsAtCompileTime == Dynamic ? 0 : RowsAtCompileTime,
              ColsAtCompileTime == Dynamic ? 0 : ColsAtCompileTime),
         // Stride<> does not allow default ctor for Dynamic strides, so let' initialize it with dummy values:
         m_stride(StrideType::OuterStrideAtCompileTime == Dynamic ? 0 : StrideType::OuterStrideAtCompileTime,
                  StrideType::InnerStrideAtCompileTime == Dynamic ? 0 : StrideType::InnerStrideAtCompileTime) {}

   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(RefBase)

  protected:
   typedef Stride<StrideType::OuterStrideAtCompileTime, StrideType::InnerStrideAtCompileTime> StrideBase;

   // Resolves inner stride if default 0.
   static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index resolveInnerStride(Index inner) { return inner == 0 ? 1 : inner; }

   // Resolves outer stride if default 0.
   static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index resolveOuterStride(Index inner, Index outer, Index rows, Index cols,
                                                                     bool isVectorAtCompileTime, bool isRowMajor) {
     return outer == 0 ? isVectorAtCompileTime ? inner * rows * cols : isRowMajor ? inner * cols : inner * rows : outer;
   }

   // Returns true if construction is valid, false if there is a stride mismatch,
   // and fails if there is a size mismatch.
   template <typename Expression>
   EIGEN_DEVICE_FUNC bool construct(Expression& expr) {
     // Check matrix sizes.  If this is a compile-time vector, we do allow
     // implicitly transposing.
     EIGEN_STATIC_ASSERT(EIGEN_PREDICATE_SAME_MATRIX_SIZE(PlainObjectType, Expression)
                             // If it is a vector, the transpose sizes might match.
                             || (PlainObjectType::IsVectorAtCompileTime &&
                                 ((int(PlainObjectType::RowsAtCompileTime) == Eigen::Dynamic ||
                                   int(Expression::ColsAtCompileTime) == Eigen::Dynamic ||
                                   int(PlainObjectType::RowsAtCompileTime) == int(Expression::ColsAtCompileTime)) &&
                                  (int(PlainObjectType::ColsAtCompileTime) == Eigen::Dynamic ||
                                   int(Expression::RowsAtCompileTime) == Eigen::Dynamic ||
                                   int(PlainObjectType::ColsAtCompileTime) == int(Expression::RowsAtCompileTime)))),
                         YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)

     // Determine runtime rows and columns.
     Index rows = expr.rows();
     Index cols = expr.cols();
     if (PlainObjectType::RowsAtCompileTime == 1) {
       eigen_assert(expr.rows() == 1 || expr.cols() == 1);
       rows = 1;
       cols = expr.size();
     } else if (PlainObjectType::ColsAtCompileTime == 1) {
       eigen_assert(expr.rows() == 1 || expr.cols() == 1);
       rows = expr.size();
       cols = 1;
     }
     // Verify that the sizes are valid.
     eigen_assert((PlainObjectType::RowsAtCompileTime == Dynamic) || (PlainObjectType::RowsAtCompileTime == rows));
     eigen_assert((PlainObjectType::ColsAtCompileTime == Dynamic) || (PlainObjectType::ColsAtCompileTime == cols));

     // If this is a vector, we might be transposing, which means that stride should swap.
     const bool transpose = PlainObjectType::IsVectorAtCompileTime && (rows != expr.rows());
     // If the storage format differs, we also need to swap the stride.
     const bool row_major = ((PlainObjectType::Flags)&RowMajorBit) != 0;
     const bool expr_row_major = (Expression::Flags & RowMajorBit) != 0;
     const bool storage_differs = (row_major != expr_row_major);

     const bool swap_stride = (transpose != storage_differs);

     // Determine expr's actual strides, resolving any defaults if zero.
     const Index expr_inner_actual = resolveInnerStride(expr.innerStride());
     const Index expr_outer_actual = resolveOuterStride(expr_inner_actual, expr.outerStride(), expr.rows(), expr.cols(),
                                                        Expression::IsVectorAtCompileTime != 0, expr_row_major);

     // If this is a column-major row vector or row-major column vector, the inner-stride
     // is arbitrary, so set it to either the compile-time inner stride or 1.
     const bool row_vector = (rows == 1);
     const bool col_vector = (cols == 1);
     const Index inner_stride =
         ((!row_major && row_vector) || (row_major && col_vector))
             ? (StrideType::InnerStrideAtCompileTime > 0 ? Index(StrideType::InnerStrideAtCompileTime) : 1)
         : swap_stride ? expr_outer_actual
                       : expr_inner_actual;

     // If this is a column-major column vector or row-major row vector, the outer-stride
     // is arbitrary, so set it to either the compile-time outer stride or vector size.
     const Index outer_stride =
         ((!row_major && col_vector) || (row_major && row_vector))
             ? (StrideType::OuterStrideAtCompileTime > 0 ? Index(StrideType::OuterStrideAtCompileTime)
                                                         : rows * cols * inner_stride)
         : swap_stride ? expr_inner_actual
                       : expr_outer_actual;

     // Check if given inner/outer strides are compatible with compile-time strides.
     const bool inner_valid = (StrideType::InnerStrideAtCompileTime == Dynamic) ||
                              (resolveInnerStride(Index(StrideType::InnerStrideAtCompileTime)) == inner_stride);
     if (!inner_valid) {
       return false;
     }

     const bool outer_valid =
         (StrideType::OuterStrideAtCompileTime == Dynamic) ||
         (resolveOuterStride(inner_stride, Index(StrideType::OuterStrideAtCompileTime), rows, cols,
                             PlainObjectType::IsVectorAtCompileTime != 0, row_major) == outer_stride);
     if (!outer_valid) {
       return false;
     }

     internal::construct_at<Base>(this, expr.data(), rows, cols);
     internal::construct_at(&m_stride, (StrideType::OuterStrideAtCompileTime == 0) ? 0 : outer_stride,
                            (StrideType::InnerStrideAtCompileTime == 0) ? 0 : inner_stride);
     return true;
   }

   StrideBase m_stride;
 };

 /** \class Ref
  * \ingroup Core_Module
  *
  * \brief A matrix or vector expression mapping an existing expression
  *
  * \tparam PlainObjectType the equivalent matrix type of the mapped data
  * \tparam Options specifies the pointer alignment in bytes. It can be: \c #Aligned128, , \c #Aligned64, \c #Aligned32,
  * \c #Aligned16, \c #Aligned8 or \c #Unaligned. The default is \c #Unaligned. \tparam StrideType optionally specifies
  * strides. By default, Ref implies a contiguous storage along the inner dimension (inner stride==1), but accepts a
  * variable outer stride (leading dimension). This can be overridden by specifying strides. The type passed here must be
  * a specialization of the Stride template, see examples below.
  *
  * This class provides a way to write non-template functions taking Eigen objects as parameters while limiting the
  * number of copies. A Ref<> object can represent either a const expression or a l-value: \code
  * // in-out argument:
  * void foo1(Ref<VectorXf> x);
  *
  * // read-only const argument:
  * void foo2(const Ref<const VectorXf>& x);
  * \endcode
  *
  * In the in-out case, the input argument must satisfy the constraints of the actual Ref<> type, otherwise a compilation
  * issue will be triggered. By default, a Ref<VectorXf> can reference any dense vector expression of float having a
  * contiguous memory layout. Likewise, a Ref<MatrixXf> can reference any column-major dense matrix expression of float
  * whose column's elements are contiguously stored with the possibility to have a constant space in-between each column,
  * i.e. the inner stride must be equal to 1, but the outer stride (or leading dimension) can be greater than the number
  * of rows.
  *
  * In the const case, if the input expression does not match the above requirement, then it is evaluated into a
  * temporary before being passed to the function. Here are some examples: \code MatrixXf A; VectorXf a; foo1(a.head());
  * // OK foo1(A.col());              // OK foo1(A.row());              // Compilation error because here innerstride!=1
  * foo2(A.row());              // Compilation error because A.row() is a 1xN object while foo2 is expecting a Nx1 object
  * foo2(A.row().transpose());  // The row is copied into a contiguous temporary
  * foo2(2*a);                  // The expression is evaluated into a temporary
  * foo2(A.col().segment(2,4)); // No temporary
  * \endcode
  *
  * The range of inputs that can be referenced without temporary can be enlarged using the last two template parameters.
  * Here is an example accepting an innerstride!=1:
  * \code
  * // in-out argument:
  * void foo3(Ref<VectorXf,0,InnerStride<> > x);
  * foo3(A.row());              // OK
  * \endcode
  * The downside here is that the function foo3 might be significantly slower than foo1 because it won't be able to
  * exploit vectorization, and will involve more expensive address computations even if the input is contiguously stored
  * in memory. To overcome this issue, one might propose to overload internally calling a template function, e.g.: \code
  * // in the .h:
  * void foo(const Ref<MatrixXf>& A);
  * void foo(const Ref<MatrixXf,0,Stride<> >& A);
  *
  * // in the .cpp:
  * template<typename TypeOfA> void foo_impl(const TypeOfA& A) {
  *     ... // crazy code goes here
  * }
  * void foo(const Ref<MatrixXf>& A) { foo_impl(A); }
  * void foo(const Ref<MatrixXf,0,Stride<> >& A) { foo_impl(A); }
  * \endcode
  *
  * See also the following stackoverflow questions for further references:
  *  - <a href="http://stackoverflow.com/questions/21132538/correct-usage-of-the-eigenref-class">Correct usage of the
  * Eigen::Ref<> class</a>
  *
  * \sa PlainObjectBase::Map(), \ref TopicStorageOrders
  */
 template <typename PlainObjectType, int Options, typename StrideType>
 class Ref : public RefBase<Ref<PlainObjectType, Options, StrideType> > {
  private:
   typedef internal::traits<Ref> Traits;
   template <typename Derived>
   EIGEN_DEVICE_FUNC inline Ref(
       const PlainObjectBase<Derived>& expr,
       std::enable_if_t<bool(Traits::template match<Derived>::MatchAtCompileTime), Derived>* = 0);

  public:
   typedef RefBase<Ref> Base;
   EIGEN_DENSE_PUBLIC_INTERFACE(Ref)

 #ifndef EIGEN_PARSED_BY_DOXYGEN
   template <typename Derived>
   EIGEN_DEVICE_FUNC inline Ref(
       PlainObjectBase<Derived>& expr,
       std::enable_if_t<bool(Traits::template match<Derived>::MatchAtCompileTime), Derived>* = 0) {
     EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
     // Construction must pass since we will not create temporary storage in the non-const case.
     const bool success = Base::construct(expr.derived());
     EIGEN_UNUSED_VARIABLE(success)
     eigen_assert(success);
   }
   template <typename Derived>
   EIGEN_DEVICE_FUNC inline Ref(
       const DenseBase<Derived>& expr,
       std::enable_if_t<bool(Traits::template match<Derived>::MatchAtCompileTime), Derived>* = 0)
 #else
   /** Implicit constructor from any dense expression */
   template <typename Derived>
   inline Ref(DenseBase<Derived>& expr)
 #endif
   {
     EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
     EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
     EIGEN_STATIC_ASSERT(!Derived::IsPlainObjectBase, THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
     // Construction must pass since we will not create temporary storage in the non-const case.
     const bool success = Base::construct(expr.const_cast_derived());
     EIGEN_UNUSED_VARIABLE(success)
     eigen_assert(success);
   }

   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Ref)
 };

 // this is the const ref version
 template <typename TPlainObjectType, int Options, typename StrideType>
 class Ref<const TPlainObjectType, Options, StrideType>
     : public RefBase<Ref<const TPlainObjectType, Options, StrideType> > {
   typedef internal::traits<Ref> Traits;

   static constexpr bool may_map_m_object_successfully =
       (static_cast<int>(StrideType::InnerStrideAtCompileTime) == 0 ||
        static_cast<int>(StrideType::InnerStrideAtCompileTime) == 1 ||
        static_cast<int>(StrideType::InnerStrideAtCompileTime) == Dynamic) &&
       (TPlainObjectType::IsVectorAtCompileTime || static_cast<int>(StrideType::OuterStrideAtCompileTime) == 0 ||
        static_cast<int>(StrideType::OuterStrideAtCompileTime) == Dynamic ||
        static_cast<int>(StrideType::OuterStrideAtCompileTime) ==
            static_cast<int>(TPlainObjectType::InnerSizeAtCompileTime) ||
        static_cast<int>(TPlainObjectType::InnerSizeAtCompileTime) == Dynamic);

  public:
   typedef RefBase<Ref> Base;
   EIGEN_DENSE_PUBLIC_INTERFACE(Ref)

   template <typename Derived>
   EIGEN_DEVICE_FUNC inline Ref(const DenseBase<Derived>& expr,
                                std::enable_if_t<bool(Traits::template match<Derived>::ScalarTypeMatch), Derived>* = 0) {
     //      std::cout << match_helper<Derived>::HasDirectAccess << "," << match_helper<Derived>::OuterStrideMatch << ","
     //      << match_helper<Derived>::InnerStrideMatch << "\n"; std::cout << int(StrideType::OuterStrideAtCompileTime)
     //      << " - " << int(Derived::OuterStrideAtCompileTime) << "\n"; std::cout <<
     //      int(StrideType::InnerStrideAtCompileTime) << " - " << int(Derived::InnerStrideAtCompileTime) << "\n";
     EIGEN_STATIC_ASSERT(Traits::template match<Derived>::type::value || may_map_m_object_successfully,
                         STORAGE_LAYOUT_DOES_NOT_MATCH);
     construct(expr.derived(), typename Traits::template match<Derived>::type());
   }

   EIGEN_DEVICE_FUNC inline Ref(const Ref& other) : Base(other) {
     // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy
   }

   EIGEN_DEVICE_FUNC inline Ref(Ref&& other) {
     if (other.data() == other.m_object.data()) {
       m_object = std::move(other.m_object);
       Base::construct(m_object);
     } else
       Base::construct(other);
   }

   template <typename OtherRef>
   EIGEN_DEVICE_FUNC inline Ref(const RefBase<OtherRef>& other) {
     EIGEN_STATIC_ASSERT(Traits::template match<OtherRef>::type::value || may_map_m_object_successfully,
                         STORAGE_LAYOUT_DOES_NOT_MATCH);
     construct(other.derived(), typename Traits::template match<OtherRef>::type());
   }

  protected:
   template <typename Expression>
   EIGEN_DEVICE_FUNC void construct(const Expression& expr, internal::true_type) {
     // Check if we can use the underlying expr's storage directly, otherwise call the copy version.
     if (!Base::construct(expr)) {
       construct(expr, internal::false_type());
     }
   }

   template <typename Expression>
   EIGEN_DEVICE_FUNC void construct(const Expression& expr, internal::false_type) {
     internal::call_assignment_no_alias(m_object, expr, internal::assign_op<Scalar, Scalar>());
     const bool success = Base::construct(m_object);
     EIGEN_ONLY_USED_FOR_DEBUG(success)
     eigen_assert(success);
   }

  protected:
   TPlainObjectType m_object;
 };

 }  // end namespace Eigen

 #endif  // EIGEN_REF_H
	// This file is part of Eigen, a lightweight C++ template library
	// for linear algebra.
	//
	// Copyright (C) 2012 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_REF_H
	#define EIGEN_REF_H

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

	namespace Eigen {

	namespace internal {

	template <typename PlainObjectType_, int Options_, typename StrideType_>
	struct traits<Ref<PlainObjectType_, Options_, StrideType_> >
	: public traits<Map<PlainObjectType_, Options_, StrideType_> > {
	typedef PlainObjectType_ PlainObjectType;
	typedef StrideType_ StrideType;
	enum {
	Options = Options_,
	Flags = traits<Map<PlainObjectType_, Options_, StrideType_> >::Flags \| NestByRefBit,
	Alignment = traits<Map<PlainObjectType_, Options_, StrideType_> >::Alignment,
	InnerStrideAtCompileTime = traits<Map<PlainObjectType_, Options_, StrideType_> >::InnerStrideAtCompileTime,
	OuterStrideAtCompileTime = traits<Map<PlainObjectType_, Options_, StrideType_> >::OuterStrideAtCompileTime
	};

	template <typename Derived>
	struct match {
	enum {
	IsVectorAtCompileTime = PlainObjectType::IsVectorAtCompileTime \|\| Derived::IsVectorAtCompileTime,
	HasDirectAccess = internal::has_direct_access<Derived>::ret,
	StorageOrderMatch =
	IsVectorAtCompileTime \|\| ((PlainObjectType::Flags & RowMajorBit) == (Derived::Flags & RowMajorBit)),
	InnerStrideMatch = int(InnerStrideAtCompileTime) == int(Dynamic) \|\|
	int(InnerStrideAtCompileTime) == int(Derived::InnerStrideAtCompileTime) \|\|
	(int(InnerStrideAtCompileTime) == 0 && int(Derived::InnerStrideAtCompileTime) == 1),
	OuterStrideMatch = IsVectorAtCompileTime \|\| int(OuterStrideAtCompileTime) == int(Dynamic) \|\|
	int(OuterStrideAtCompileTime) == int(Derived::OuterStrideAtCompileTime),
	// NOTE, this indirection of evaluator<Derived>::Alignment is needed
	// to workaround a very strange bug in MSVC related to the instantiation
	// of has_*ary_operator in evaluator<CwiseNullaryOp>.
	// This line is surprisingly very sensitive. For instance, simply adding parenthesis
	// as "DerivedAlignment = (int(evaluator<Derived>::Alignment))," will make MSVC fail...
	DerivedAlignment = int(evaluator<Derived>::Alignment),
	AlignmentMatch = (int(traits<PlainObjectType>::Alignment) == int(Unaligned)) \|\|
	(DerivedAlignment >= int(Alignment)), // FIXME the first condition is not very clear, it should
	// be replaced by the required alignment
	ScalarTypeMatch = internal::is_same<typename PlainObjectType::Scalar, typename Derived::Scalar>::value,
	MatchAtCompileTime = HasDirectAccess && StorageOrderMatch && InnerStrideMatch && OuterStrideMatch &&
	AlignmentMatch && ScalarTypeMatch
	};
	typedef std::conditional_t<MatchAtCompileTime, internal::true_type, internal::false_type> type;
	};
	};

	template <typename Derived>
	struct traits<RefBase<Derived> > : public traits<Derived> {};

	} // namespace internal

	template <typename Derived>
	class RefBase : public MapBase<Derived> {
	typedef typename internal::traits<Derived>::PlainObjectType PlainObjectType;
	typedef typename internal::traits<Derived>::StrideType StrideType;

	public:
	typedef MapBase<Derived> Base;
	EIGEN_DENSE_PUBLIC_INTERFACE(RefBase)

	EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index innerStride() const {
	return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1;
	}

	EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index outerStride() const {
	return StrideType::OuterStrideAtCompileTime != 0 ? m_stride.outer()
	: IsVectorAtCompileTime ? this->size()
	: int(Flags) & RowMajorBit ? this->cols()
	: this->rows();
	}

	EIGEN_DEVICE_FUNC RefBase()
	: Base(0, RowsAtCompileTime == Dynamic ? 0 : RowsAtCompileTime,
	ColsAtCompileTime == Dynamic ? 0 : ColsAtCompileTime),
	// Stride<> does not allow default ctor for Dynamic strides, so let' initialize it with dummy values:
	m_stride(StrideType::OuterStrideAtCompileTime == Dynamic ? 0 : StrideType::OuterStrideAtCompileTime,
	StrideType::InnerStrideAtCompileTime == Dynamic ? 0 : StrideType::InnerStrideAtCompileTime) {}

	EIGEN_INHERIT_ASSIGNMENT_OPERATORS(RefBase)

	protected:
	typedef Stride<StrideType::OuterStrideAtCompileTime, StrideType::InnerStrideAtCompileTime> StrideBase;

	// Resolves inner stride if default 0.
	static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index resolveInnerStride(Index inner) { return inner == 0 ? 1 : inner; }

	// Resolves outer stride if default 0.
	static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index resolveOuterStride(Index inner, Index outer, Index rows, Index cols,
	bool isVectorAtCompileTime, bool isRowMajor) {
	return outer == 0 ? isVectorAtCompileTime ? inner * rows * cols : isRowMajor ? inner * cols : inner * rows : outer;
	}

	// Returns true if construction is valid, false if there is a stride mismatch,
	// and fails if there is a size mismatch.
	template <typename Expression>
	EIGEN_DEVICE_FUNC bool construct(Expression& expr) {
	// Check matrix sizes. If this is a compile-time vector, we do allow
	// implicitly transposing.
	EIGEN_STATIC_ASSERT(EIGEN_PREDICATE_SAME_MATRIX_SIZE(PlainObjectType, Expression)
	// If it is a vector, the transpose sizes might match.
	\|\| (PlainObjectType::IsVectorAtCompileTime &&
	((int(PlainObjectType::RowsAtCompileTime) == Eigen::Dynamic \|\|
	int(Expression::ColsAtCompileTime) == Eigen::Dynamic \|\|
	int(PlainObjectType::RowsAtCompileTime) == int(Expression::ColsAtCompileTime)) &&
	(int(PlainObjectType::ColsAtCompileTime) == Eigen::Dynamic \|\|
	int(Expression::RowsAtCompileTime) == Eigen::Dynamic \|\|
	int(PlainObjectType::ColsAtCompileTime) == int(Expression::RowsAtCompileTime)))),
	YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)

	// Determine runtime rows and columns.
	Index rows = expr.rows();
	Index cols = expr.cols();
	if (PlainObjectType::RowsAtCompileTime == 1) {
	eigen_assert(expr.rows() == 1 \|\| expr.cols() == 1);
	rows = 1;
	cols = expr.size();
	} else if (PlainObjectType::ColsAtCompileTime == 1) {
	eigen_assert(expr.rows() == 1 \|\| expr.cols() == 1);
	rows = expr.size();
	cols = 1;
	}
	// Verify that the sizes are valid.
	eigen_assert((PlainObjectType::RowsAtCompileTime == Dynamic) \|\| (PlainObjectType::RowsAtCompileTime == rows));
	eigen_assert((PlainObjectType::ColsAtCompileTime == Dynamic) \|\| (PlainObjectType::ColsAtCompileTime == cols));

	// If this is a vector, we might be transposing, which means that stride should swap.
	const bool transpose = PlainObjectType::IsVectorAtCompileTime && (rows != expr.rows());
	// If the storage format differs, we also need to swap the stride.
	const bool row_major = ((PlainObjectType::Flags)&RowMajorBit) != 0;
	const bool expr_row_major = (Expression::Flags & RowMajorBit) != 0;
	const bool storage_differs = (row_major != expr_row_major);

	const bool swap_stride = (transpose != storage_differs);

	// Determine expr's actual strides, resolving any defaults if zero.
	const Index expr_inner_actual = resolveInnerStride(expr.innerStride());
	const Index expr_outer_actual = resolveOuterStride(expr_inner_actual, expr.outerStride(), expr.rows(), expr.cols(),
	Expression::IsVectorAtCompileTime != 0, expr_row_major);

	// If this is a column-major row vector or row-major column vector, the inner-stride
	// is arbitrary, so set it to either the compile-time inner stride or 1.
	const bool row_vector = (rows == 1);
	const bool col_vector = (cols == 1);
	const Index inner_stride =
	((!row_major && row_vector) \|\| (row_major && col_vector))
	? (StrideType::InnerStrideAtCompileTime > 0 ? Index(StrideType::InnerStrideAtCompileTime) : 1)
	: swap_stride ? expr_outer_actual
	: expr_inner_actual;

	// If this is a column-major column vector or row-major row vector, the outer-stride
	// is arbitrary, so set it to either the compile-time outer stride or vector size.
	const Index outer_stride =
	((!row_major && col_vector) \|\| (row_major && row_vector))
	? (StrideType::OuterStrideAtCompileTime > 0 ? Index(StrideType::OuterStrideAtCompileTime)
	: rows * cols * inner_stride)
	: swap_stride ? expr_inner_actual
	: expr_outer_actual;

	// Check if given inner/outer strides are compatible with compile-time strides.
	const bool inner_valid = (StrideType::InnerStrideAtCompileTime == Dynamic) \|\|
	(resolveInnerStride(Index(StrideType::InnerStrideAtCompileTime)) == inner_stride);
	if (!inner_valid) {
	return false;
	}

	const bool outer_valid =
	(StrideType::OuterStrideAtCompileTime == Dynamic) \|\|
	(resolveOuterStride(inner_stride, Index(StrideType::OuterStrideAtCompileTime), rows, cols,
	PlainObjectType::IsVectorAtCompileTime != 0, row_major) == outer_stride);
	if (!outer_valid) {
	return false;
	}

	internal::construct_at<Base>(this, expr.data(), rows, cols);
	internal::construct_at(&m_stride, (StrideType::OuterStrideAtCompileTime == 0) ? 0 : outer_stride,
	(StrideType::InnerStrideAtCompileTime == 0) ? 0 : inner_stride);
	return true;
	}

	StrideBase m_stride;
	};

	/** \class Ref
	* \ingroup Core_Module
	*
	* \brief A matrix or vector expression mapping an existing expression
	*
	* \tparam PlainObjectType the equivalent matrix type of the mapped data
	* \tparam Options specifies the pointer alignment in bytes. It can be: \c #Aligned128, , \c #Aligned64, \c #Aligned32,
	* \c #Aligned16, \c #Aligned8 or \c #Unaligned. The default is \c #Unaligned. \tparam StrideType optionally specifies
	* strides. By default, Ref implies a contiguous storage along the inner dimension (inner stride==1), but accepts a
	* variable outer stride (leading dimension). This can be overridden by specifying strides. The type passed here must be
	* a specialization of the Stride template, see examples below.
	*
	* This class provides a way to write non-template functions taking Eigen objects as parameters while limiting the
	* number of copies. A Ref<> object can represent either a const expression or a l-value: \code
	* // in-out argument:
	* void foo1(Ref<VectorXf> x);
	*
	* // read-only const argument:
	* void foo2(const Ref<const VectorXf>& x);
	* \endcode
	*
	* In the in-out case, the input argument must satisfy the constraints of the actual Ref<> type, otherwise a compilation
	* issue will be triggered. By default, a Ref<VectorXf> can reference any dense vector expression of float having a
	* contiguous memory layout. Likewise, a Ref<MatrixXf> can reference any column-major dense matrix expression of float
	* whose column's elements are contiguously stored with the possibility to have a constant space in-between each column,
	* i.e. the inner stride must be equal to 1, but the outer stride (or leading dimension) can be greater than the number
	* of rows.
	*
	* In the const case, if the input expression does not match the above requirement, then it is evaluated into a
	* temporary before being passed to the function. Here are some examples: \code MatrixXf A; VectorXf a; foo1(a.head());
	* // OK foo1(A.col()); // OK foo1(A.row()); // Compilation error because here innerstride!=1
	* foo2(A.row()); // Compilation error because A.row() is a 1xN object while foo2 is expecting a Nx1 object
	* foo2(A.row().transpose()); // The row is copied into a contiguous temporary
	* foo2(2*a); // The expression is evaluated into a temporary
	* foo2(A.col().segment(2,4)); // No temporary
	* \endcode
	*
	* The range of inputs that can be referenced without temporary can be enlarged using the last two template parameters.
	* Here is an example accepting an innerstride!=1:
	* \code
	* // in-out argument:
	* void foo3(Ref<VectorXf,0,InnerStride<> > x);
	* foo3(A.row()); // OK
	* \endcode
	* The downside here is that the function foo3 might be significantly slower than foo1 because it won't be able to
	* exploit vectorization, and will involve more expensive address computations even if the input is contiguously stored
	* in memory. To overcome this issue, one might propose to overload internally calling a template function, e.g.: \code
	* // in the .h:
	* void foo(const Ref<MatrixXf>& A);
	* void foo(const Ref<MatrixXf,0,Stride<> >& A);
	*
	* // in the .cpp:
	* template<typename TypeOfA> void foo_impl(const TypeOfA& A) {
	* ... // crazy code goes here
	* }
	* void foo(const Ref<MatrixXf>& A) { foo_impl(A); }
	* void foo(const Ref<MatrixXf,0,Stride<> >& A) { foo_impl(A); }
	* \endcode
	*
	* See also the following stackoverflow questions for further references:
	* - <a href="http://stackoverflow.com/questions/21132538/correct-usage-of-the-eigenref-class">Correct usage of the
	* Eigen::Ref<> class</a>
	*
	* \sa PlainObjectBase::Map(), \ref TopicStorageOrders
	*/
	template <typename PlainObjectType, int Options, typename StrideType>
	class Ref : public RefBase<Ref<PlainObjectType, Options, StrideType> > {
	private:
	typedef internal::traits<Ref> Traits;
	template <typename Derived>
	EIGEN_DEVICE_FUNC inline Ref(
	const PlainObjectBase<Derived>& expr,
	std::enable_if_t<bool(Traits::template match<Derived>::MatchAtCompileTime), Derived>* = 0);

	public:
	typedef RefBase<Ref> Base;
	EIGEN_DENSE_PUBLIC_INTERFACE(Ref)

	#ifndef EIGEN_PARSED_BY_DOXYGEN
	template <typename Derived>
	EIGEN_DEVICE_FUNC inline Ref(
	PlainObjectBase<Derived>& expr,
	std::enable_if_t<bool(Traits::template match<Derived>::MatchAtCompileTime), Derived>* = 0) {
	EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
	// Construction must pass since we will not create temporary storage in the non-const case.
	const bool success = Base::construct(expr.derived());
	EIGEN_UNUSED_VARIABLE(success)
	eigen_assert(success);
	}
	template <typename Derived>
	EIGEN_DEVICE_FUNC inline Ref(
	const DenseBase<Derived>& expr,
	std::enable_if_t<bool(Traits::template match<Derived>::MatchAtCompileTime), Derived>* = 0)
	#else
	/** Implicit constructor from any dense expression */
	template <typename Derived>
	inline Ref(DenseBase<Derived>& expr)
	#endif
	{
	EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
	EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
	EIGEN_STATIC_ASSERT(!Derived::IsPlainObjectBase, THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
	// Construction must pass since we will not create temporary storage in the non-const case.
	const bool success = Base::construct(expr.const_cast_derived());
	EIGEN_UNUSED_VARIABLE(success)
	eigen_assert(success);
	}

	EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Ref)
	};

	// this is the const ref version
	template <typename TPlainObjectType, int Options, typename StrideType>
	class Ref<const TPlainObjectType, Options, StrideType>
	: public RefBase<Ref<const TPlainObjectType, Options, StrideType> > {
	typedef internal::traits<Ref> Traits;

	static constexpr bool may_map_m_object_successfully =
	(static_cast<int>(StrideType::InnerStrideAtCompileTime) == 0 \|\|
	static_cast<int>(StrideType::InnerStrideAtCompileTime) == 1 \|\|
	static_cast<int>(StrideType::InnerStrideAtCompileTime) == Dynamic) &&
	(TPlainObjectType::IsVectorAtCompileTime \|\| static_cast<int>(StrideType::OuterStrideAtCompileTime) == 0 \|\|
	static_cast<int>(StrideType::OuterStrideAtCompileTime) == Dynamic \|\|
	static_cast<int>(StrideType::OuterStrideAtCompileTime) ==
	static_cast<int>(TPlainObjectType::InnerSizeAtCompileTime) \|\|
	static_cast<int>(TPlainObjectType::InnerSizeAtCompileTime) == Dynamic);

	public:
	typedef RefBase<Ref> Base;
	EIGEN_DENSE_PUBLIC_INTERFACE(Ref)

	template <typename Derived>
	EIGEN_DEVICE_FUNC inline Ref(const DenseBase<Derived>& expr,
	std::enable_if_t<bool(Traits::template match<Derived>::ScalarTypeMatch), Derived>* = 0) {
	// std::cout << match_helper<Derived>::HasDirectAccess << "," << match_helper<Derived>::OuterStrideMatch << ","
	// << match_helper<Derived>::InnerStrideMatch << "\n"; std::cout << int(StrideType::OuterStrideAtCompileTime)
	// << " - " << int(Derived::OuterStrideAtCompileTime) << "\n"; std::cout <<
	// int(StrideType::InnerStrideAtCompileTime) << " - " << int(Derived::InnerStrideAtCompileTime) << "\n";
	EIGEN_STATIC_ASSERT(Traits::template match<Derived>::type::value \|\| may_map_m_object_successfully,
	STORAGE_LAYOUT_DOES_NOT_MATCH);
	construct(expr.derived(), typename Traits::template match<Derived>::type());
	}

	EIGEN_DEVICE_FUNC inline Ref(const Ref& other) : Base(other) {
	// copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy
	}

	EIGEN_DEVICE_FUNC inline Ref(Ref&& other) {
	if (other.data() == other.m_object.data()) {
	m_object = std::move(other.m_object);
	Base::construct(m_object);
	} else
	Base::construct(other);
	}

	template <typename OtherRef>
	EIGEN_DEVICE_FUNC inline Ref(const RefBase<OtherRef>& other) {
	EIGEN_STATIC_ASSERT(Traits::template match<OtherRef>::type::value \|\| may_map_m_object_successfully,
	STORAGE_LAYOUT_DOES_NOT_MATCH);
	construct(other.derived(), typename Traits::template match<OtherRef>::type());
	}

	protected:
	template <typename Expression>
	EIGEN_DEVICE_FUNC void construct(const Expression& expr, internal::true_type) {
	// Check if we can use the underlying expr's storage directly, otherwise call the copy version.
	if (!Base::construct(expr)) {
	construct(expr, internal::false_type());
	}
	}

	template <typename Expression>
	EIGEN_DEVICE_FUNC void construct(const Expression& expr, internal::false_type) {
	internal::call_assignment_no_alias(m_object, expr, internal::assign_op<Scalar, Scalar>());
	const bool success = Base::construct(m_object);
	EIGEN_ONLY_USED_FOR_DEBUG(success)
	eigen_assert(success);
	}

	protected:
	TPlainObjectType m_object;
	};

	} // end namespace Eigen

	#endif // EIGEN_REF_H