Eigen/src/Core/Reshaped.h - mirror - Git at Google

 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
 // Copyright (C) 2008-2017 Gael Guennebaud <gael.guennebaud@inria.fr>
 // Copyright (C) 2014 yoco <peter.xiau@gmail.com>
 //
 // 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_RESHAPED_H
 #define EIGEN_RESHAPED_H

 namespace Eigen {

 /** \class Reshaped
   * \ingroup Core_Module
   *
   * \brief Expression of a fixed-size or dynamic-size reshape
   *
   * \tparam XprType the type of the expression in which we are taking a reshape
   * \tparam Rows the number of rows of the reshape we are taking at compile time (optional)
   * \tparam Cols the number of columns of the reshape we are taking at compile time (optional)
   * \tparam Order can be ColMajor or RowMajor, default is ColMajor.
   *
   * This class represents an expression of either a fixed-size or dynamic-size reshape.
   * It is the return type of DenseBase::reshaped(NRowsType,NColsType) and
   * most of the time this is the only way it is used.
   *
   * However, in C++98, if you want to directly maniputate reshaped expressions,
   * for instance if you want to write a function returning such an expression, you
   * will need to use this class. In C++11, it is advised to use the \em auto
   * keyword for such use cases.
   *
   * Here is an example illustrating the dynamic case:
   * \include class_Reshaped.cpp
   * Output: \verbinclude class_Reshaped.out
   *
   * Here is an example illustrating the fixed-size case:
   * \include class_FixedReshaped.cpp
   * Output: \verbinclude class_FixedReshaped.out
   *
   * \sa DenseBase::reshaped(NRowsType,NColsType)
   */

 namespace internal {

 template<typename XprType, int Rows, int Cols, int Order>
 struct traits<Reshaped<XprType, Rows, Cols, Order> > : traits<XprType>
 {
   typedef typename traits<XprType>::Scalar Scalar;
   typedef typename traits<XprType>::StorageKind StorageKind;
   typedef typename traits<XprType>::XprKind XprKind;
   enum{
     MatrixRows = traits<XprType>::RowsAtCompileTime,
     MatrixCols = traits<XprType>::ColsAtCompileTime,
     RowsAtCompileTime = Rows,
     ColsAtCompileTime = Cols,
     MaxRowsAtCompileTime = Rows,
     MaxColsAtCompileTime = Cols,
     XpxStorageOrder = ((int(traits<XprType>::Flags) & RowMajorBit) == RowMajorBit) ? RowMajor : ColMajor,
     ReshapedStorageOrder = (RowsAtCompileTime == 1 && ColsAtCompileTime != 1) ? RowMajor
                          : (ColsAtCompileTime == 1 && RowsAtCompileTime != 1) ? ColMajor
                          : XpxStorageOrder,
     HasSameStorageOrderAsXprType = (ReshapedStorageOrder == XpxStorageOrder),
     InnerSize = (ReshapedStorageOrder==int(RowMajor)) ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
     InnerStrideAtCompileTime = HasSameStorageOrderAsXprType
                              ? int(inner_stride_at_compile_time<XprType>::ret)
                              : Dynamic,
     OuterStrideAtCompileTime = Dynamic,

     HasDirectAccess = internal::has_direct_access<XprType>::ret
                     && (Order==int(XpxStorageOrder))
                     && ((evaluator<XprType>::Flags&LinearAccessBit)==LinearAccessBit),

     MaskPacketAccessBit = (InnerSize == Dynamic || (InnerSize % packet_traits<Scalar>::size) == 0)
                        && (InnerStrideAtCompileTime == 1)
                         ? PacketAccessBit : 0,
     //MaskAlignedBit = ((OuterStrideAtCompileTime!=Dynamic) && (((OuterStrideAtCompileTime * int(sizeof(Scalar))) % 16) == 0)) ? AlignedBit : 0,
     FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1) ? LinearAccessBit : 0,
     FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0,
     FlagsRowMajorBit = (ReshapedStorageOrder==int(RowMajor)) ? RowMajorBit : 0,
     FlagsDirectAccessBit = HasDirectAccess ? DirectAccessBit : 0,
     Flags0 = traits<XprType>::Flags & ( (HereditaryBits & ~RowMajorBit) | MaskPacketAccessBit),

     Flags = (Flags0 | FlagsLinearAccessBit | FlagsLvalueBit | FlagsRowMajorBit | FlagsDirectAccessBit)
   };
 };

 template<typename XprType, int Rows, int Cols, int Order, bool HasDirectAccess> class ReshapedImpl_dense;

 } // end namespace internal

 template<typename XprType, int Rows, int Cols, int Order, typename StorageKind> class ReshapedImpl;

 template<typename XprType, int Rows, int Cols, int Order> class Reshaped
   : public ReshapedImpl<XprType, Rows, Cols, Order, typename internal::traits<XprType>::StorageKind>
 {
     typedef ReshapedImpl<XprType, Rows, Cols, Order, typename internal::traits<XprType>::StorageKind> Impl;
   public:
     //typedef typename Impl::Base Base;
     typedef Impl Base;
     EIGEN_GENERIC_PUBLIC_INTERFACE(Reshaped)
     EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Reshaped)

     /** Fixed-size constructor
       */
     EIGEN_DEVICE_FUNC
     inline Reshaped(XprType& xpr)
       : Impl(xpr)
     {
       EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE)
       eigen_assert(Rows * Cols == xpr.rows() * xpr.cols());
     }

     /** Dynamic-size constructor
       */
     EIGEN_DEVICE_FUNC
     inline Reshaped(XprType& xpr,
           Index reshapeRows, Index reshapeCols)
       : Impl(xpr, reshapeRows, reshapeCols)
     {
       eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==reshapeRows)
           && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==reshapeCols));
       eigen_assert(reshapeRows * reshapeCols == xpr.rows() * xpr.cols());
     }
 };

 // The generic default implementation for dense reshape simply forward to the internal::ReshapedImpl_dense
 // that must be specialized for direct and non-direct access...
 template<typename XprType, int Rows, int Cols, int Order>
 class ReshapedImpl<XprType, Rows, Cols, Order, Dense>
   : public internal::ReshapedImpl_dense<XprType, Rows, Cols, Order,internal::traits<Reshaped<XprType,Rows,Cols,Order> >::HasDirectAccess>
 {
     typedef internal::ReshapedImpl_dense<XprType, Rows, Cols, Order,internal::traits<Reshaped<XprType,Rows,Cols,Order> >::HasDirectAccess> Impl;
   public:
     typedef Impl Base;
     EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl)
     EIGEN_DEVICE_FUNC inline ReshapedImpl(XprType& xpr) : Impl(xpr) {}
     EIGEN_DEVICE_FUNC inline ReshapedImpl(XprType& xpr, Index reshapeRows, Index reshapeCols)
       : Impl(xpr, reshapeRows, reshapeCols) {}
 };

 namespace internal {

 /** \internal Internal implementation of dense Reshaped in the general case. */
 template<typename XprType, int Rows, int Cols, int Order>
 class ReshapedImpl_dense<XprType,Rows,Cols,Order,false>
   : public internal::dense_xpr_base<Reshaped<XprType, Rows, Cols, Order> >::type
 {
     typedef Reshaped<XprType, Rows, Cols, Order> ReshapedType;
   public:

     typedef typename internal::dense_xpr_base<ReshapedType>::type Base;
     EIGEN_DENSE_PUBLIC_INTERFACE(ReshapedType)
     EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl_dense)

     typedef typename internal::ref_selector<XprType>::non_const_type MatrixTypeNested;
     typedef typename internal::remove_all<XprType>::type NestedExpression;

     class InnerIterator;

     /** Fixed-size constructor
       */
     EIGEN_DEVICE_FUNC
     inline ReshapedImpl_dense(XprType& xpr)
       : m_xpr(xpr), m_rows(Rows), m_cols(Cols)
     {}

     /** Dynamic-size constructor
       */
     EIGEN_DEVICE_FUNC
     inline ReshapedImpl_dense(XprType& xpr, Index nRows, Index nCols)
       : m_xpr(xpr), m_rows(nRows), m_cols(nCols)
     {}

     EIGEN_DEVICE_FUNC Index rows() const { return m_rows; }
     EIGEN_DEVICE_FUNC Index cols() const { return m_cols; }

     #ifdef EIGEN_PARSED_BY_DOXYGEN
     /** \sa MapBase::data() */
     EIGEN_DEVICE_FUNC inline const Scalar* data() const;
     EIGEN_DEVICE_FUNC inline Index innerStride() const;
     EIGEN_DEVICE_FUNC inline Index outerStride() const;
     #endif

     /** \returns the nested expression */
     EIGEN_DEVICE_FUNC
     const typename internal::remove_all<XprType>::type&
     nestedExpression() const { return m_xpr; }

     /** \returns the nested expression */
     EIGEN_DEVICE_FUNC
     typename internal::remove_reference<XprType>::type&
     nestedExpression() { return m_xpr; }

   protected:

     MatrixTypeNested m_xpr;
     const internal::variable_if_dynamic<Index, Rows> m_rows;
     const internal::variable_if_dynamic<Index, Cols> m_cols;
 };


 /** \internal Internal implementation of dense Reshaped in the direct access case. */
 template<typename XprType, int Rows, int Cols, int Order>
 class ReshapedImpl_dense<XprType, Rows, Cols, Order, true>
   : public MapBase<Reshaped<XprType, Rows, Cols, Order> >
 {
     typedef Reshaped<XprType, Rows, Cols, Order> ReshapedType;
     typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
   public:

     typedef MapBase<ReshapedType> Base;
     EIGEN_DENSE_PUBLIC_INTERFACE(ReshapedType)
     EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl_dense)

     /** Fixed-size constructor
       */
     EIGEN_DEVICE_FUNC
     inline ReshapedImpl_dense(XprType& xpr)
       : Base(xpr.data()), m_xpr(xpr)
     {}

     /** Dynamic-size constructor
       */
     EIGEN_DEVICE_FUNC
     inline ReshapedImpl_dense(XprType& xpr, Index nRows, Index nCols)
       : Base(xpr.data(), nRows, nCols),
         m_xpr(xpr)
     {}

     EIGEN_DEVICE_FUNC
     const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const
     {
       return m_xpr;
     }

     EIGEN_DEVICE_FUNC
     XprType& nestedExpression() { return m_xpr; }

     /** \sa MapBase::innerStride() */
     EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
     inline Index innerStride() const
     {
       return m_xpr.innerStride();
     }

     /** \sa MapBase::outerStride() */
     EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
     inline Index outerStride() const
     {
       return ((Flags&RowMajorBit)==RowMajorBit) ? this->cols() : this->rows();
     }

   protected:

     XprTypeNested m_xpr;
 };

 // Evaluators
 template<typename ArgType, int Rows, int Cols, int Order, bool HasDirectAccess> struct reshaped_evaluator;

 template<typename ArgType, int Rows, int Cols, int Order>
 struct evaluator<Reshaped<ArgType, Rows, Cols, Order> >
   : reshaped_evaluator<ArgType, Rows, Cols, Order, traits<Reshaped<ArgType,Rows,Cols,Order> >::HasDirectAccess>
 {
   typedef Reshaped<ArgType, Rows, Cols, Order> XprType;
   typedef typename XprType::Scalar Scalar;
   // TODO: should check for smaller packet types
   typedef typename packet_traits<Scalar>::type PacketScalar;

   enum {
     CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
     HasDirectAccess = traits<XprType>::HasDirectAccess,

 //     RowsAtCompileTime = traits<XprType>::RowsAtCompileTime,
 //     ColsAtCompileTime = traits<XprType>::ColsAtCompileTime,
 //     MaxRowsAtCompileTime = traits<XprType>::MaxRowsAtCompileTime,
 //     MaxColsAtCompileTime = traits<XprType>::MaxColsAtCompileTime,
 //
 //     InnerStrideAtCompileTime = traits<XprType>::HasSameStorageOrderAsXprType
 //                              ? int(inner_stride_at_compile_time<ArgType>::ret)
 //                              : Dynamic,
 //     OuterStrideAtCompileTime = Dynamic,

     FlagsLinearAccessBit = (traits<XprType>::RowsAtCompileTime == 1 || traits<XprType>::ColsAtCompileTime == 1 || HasDirectAccess) ? LinearAccessBit : 0,
     FlagsRowMajorBit = (traits<XprType>::ReshapedStorageOrder==int(RowMajor)) ? RowMajorBit : 0,
     FlagsDirectAccessBit =  HasDirectAccess ? DirectAccessBit : 0,
     Flags0 = evaluator<ArgType>::Flags & (HereditaryBits & ~RowMajorBit),
     Flags = Flags0 | FlagsLinearAccessBit | FlagsRowMajorBit | FlagsDirectAccessBit,

     PacketAlignment = unpacket_traits<PacketScalar>::alignment,
     Alignment = evaluator<ArgType>::Alignment
   };
   typedef reshaped_evaluator<ArgType, Rows, Cols, Order, HasDirectAccess> reshaped_evaluator_type;
   EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : reshaped_evaluator_type(xpr)
   {
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
   }
 };

 template<typename ArgType, int Rows, int Cols, int Order>
 struct reshaped_evaluator<ArgType, Rows, Cols, Order, /* HasDirectAccess */ false>
   : evaluator_base<Reshaped<ArgType, Rows, Cols, Order> >
 {
   typedef Reshaped<ArgType, Rows, Cols, Order> XprType;

   enum {
     CoeffReadCost = evaluator<ArgType>::CoeffReadCost /* TODO + cost of index computations */,

     Flags = (evaluator<ArgType>::Flags & (HereditaryBits /*| LinearAccessBit | DirectAccessBit*/)),

     Alignment = 0
   };

   EIGEN_DEVICE_FUNC explicit reshaped_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_xpr(xpr)
   {
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
   }

   typedef typename XprType::Scalar Scalar;
   typedef typename XprType::CoeffReturnType CoeffReturnType;

   typedef std::pair<Index, Index> RowCol;

   inline RowCol index_remap(Index rowId, Index colId) const
   {
     if(Order==ColMajor)
     {
       const Index nth_elem_idx = colId * m_xpr.rows() + rowId;
       return RowCol(nth_elem_idx % m_xpr.nestedExpression().rows(),
                     nth_elem_idx / m_xpr.nestedExpression().rows());
     }
     else
     {
       const Index nth_elem_idx = colId + rowId * m_xpr.cols();
       return RowCol(nth_elem_idx / m_xpr.nestedExpression().cols(),
                     nth_elem_idx % m_xpr.nestedExpression().cols());
     }
   }

   EIGEN_DEVICE_FUNC
   inline Scalar& coeffRef(Index rowId, Index colId)
   {
     EIGEN_STATIC_ASSERT_LVALUE(XprType)
     const RowCol row_col = index_remap(rowId, colId);
     return m_argImpl.coeffRef(row_col.first, row_col.second);
   }

   EIGEN_DEVICE_FUNC
   inline const Scalar& coeffRef(Index rowId, Index colId) const
   {
     const RowCol row_col = index_remap(rowId, colId);
     return m_argImpl.coeffRef(row_col.first, row_col.second);
   }

   EIGEN_DEVICE_FUNC
   EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const
   {
     const RowCol row_col = index_remap(rowId, colId);
     return m_argImpl.coeff(row_col.first, row_col.second);
   }

   EIGEN_DEVICE_FUNC
   inline Scalar& coeffRef(Index index)
   {
     EIGEN_STATIC_ASSERT_LVALUE(XprType)
     const RowCol row_col = index_remap(Rows == 1 ? 0 : index,
                                        Rows == 1 ? index : 0);
     return m_argImpl.coeffRef(row_col.first, row_col.second);

   }

   EIGEN_DEVICE_FUNC
   inline const Scalar& coeffRef(Index index) const
   {
     const RowCol row_col = index_remap(Rows == 1 ? 0 : index,
                                        Rows == 1 ? index : 0);
     return m_argImpl.coeffRef(row_col.first, row_col.second);
   }

   EIGEN_DEVICE_FUNC
   inline const CoeffReturnType coeff(Index index) const
   {
     const RowCol row_col = index_remap(Rows == 1 ? 0 : index,
                                        Rows == 1 ? index : 0);
     return m_argImpl.coeff(row_col.first, row_col.second);
   }
 #if 0
   EIGEN_DEVICE_FUNC
   template<int LoadMode>
   inline PacketScalar packet(Index rowId, Index colId) const
   {
     const RowCol row_col = index_remap(rowId, colId);
     return m_argImpl.template packet<Unaligned>(row_col.first, row_col.second);

   }

   template<int LoadMode>
   EIGEN_DEVICE_FUNC
   inline void writePacket(Index rowId, Index colId, const PacketScalar& val)
   {
     const RowCol row_col = index_remap(rowId, colId);
     m_argImpl.const_cast_derived().template writePacket<Unaligned>
             (row_col.first, row_col.second, val);
   }

   template<int LoadMode>
   EIGEN_DEVICE_FUNC
   inline PacketScalar packet(Index index) const
   {
     const RowCol row_col = index_remap(RowsAtCompileTime == 1 ? 0 : index,
                                         RowsAtCompileTime == 1 ? index : 0);
     return m_argImpl.template packet<Unaligned>(row_col.first, row_col.second);
   }

   template<int LoadMode>
   EIGEN_DEVICE_FUNC
   inline void writePacket(Index index, const PacketScalar& val)
   {
     const RowCol row_col = index_remap(RowsAtCompileTime == 1 ? 0 : index,
                                         RowsAtCompileTime == 1 ? index : 0);
     return m_argImpl.template packet<Unaligned>(row_col.first, row_col.second, val);
   }
 #endif
 protected:

   evaluator<ArgType> m_argImpl;
   const XprType& m_xpr;

 };

 template<typename ArgType, int Rows, int Cols, int Order>
 struct reshaped_evaluator<ArgType, Rows, Cols, Order, /* HasDirectAccess */ true>
 : mapbase_evaluator<Reshaped<ArgType, Rows, Cols, Order>,
                       typename Reshaped<ArgType, Rows, Cols, Order>::PlainObject>
 {
   typedef Reshaped<ArgType, Rows, Cols, Order> XprType;
   typedef typename XprType::Scalar Scalar;

   EIGEN_DEVICE_FUNC explicit reshaped_evaluator(const XprType& xpr)
     : mapbase_evaluator<XprType, typename XprType::PlainObject>(xpr)
   {
     // TODO: for the 3.4 release, this should be turned to an internal assertion, but let's keep it as is for the beta lifetime
     eigen_assert(((internal::UIntPtr(xpr.data()) % EIGEN_PLAIN_ENUM_MAX(1,evaluator<XprType>::Alignment)) == 0) && "data is not aligned");
   }
 };

 } // end namespace internal

 } // end namespace Eigen

 #endif // EIGEN_RESHAPED_H
	// This file is part of Eigen, a lightweight C++ template library
	// for linear algebra.
	//
	// Copyright (C) 2008-2017 Gael Guennebaud <gael.guennebaud@inria.fr>
	// Copyright (C) 2014 yoco <peter.xiau@gmail.com>
	//
	// 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_RESHAPED_H
	#define EIGEN_RESHAPED_H

	namespace Eigen {

	/** \class Reshaped
	* \ingroup Core_Module
	*
	* \brief Expression of a fixed-size or dynamic-size reshape
	*
	* \tparam XprType the type of the expression in which we are taking a reshape
	* \tparam Rows the number of rows of the reshape we are taking at compile time (optional)
	* \tparam Cols the number of columns of the reshape we are taking at compile time (optional)
	* \tparam Order can be ColMajor or RowMajor, default is ColMajor.
	*
	* This class represents an expression of either a fixed-size or dynamic-size reshape.
	* It is the return type of DenseBase::reshaped(NRowsType,NColsType) and
	* most of the time this is the only way it is used.
	*
	* However, in C++98, if you want to directly maniputate reshaped expressions,
	* for instance if you want to write a function returning such an expression, you
	* will need to use this class. In C++11, it is advised to use the \em auto
	* keyword for such use cases.
	*
	* Here is an example illustrating the dynamic case:
	* \include class_Reshaped.cpp
	* Output: \verbinclude class_Reshaped.out
	*
	* Here is an example illustrating the fixed-size case:
	* \include class_FixedReshaped.cpp
	* Output: \verbinclude class_FixedReshaped.out
	*
	* \sa DenseBase::reshaped(NRowsType,NColsType)
	*/

	namespace internal {

	template<typename XprType, int Rows, int Cols, int Order>
	struct traits<Reshaped<XprType, Rows, Cols, Order> > : traits<XprType>
	{
	typedef typename traits<XprType>::Scalar Scalar;
	typedef typename traits<XprType>::StorageKind StorageKind;
	typedef typename traits<XprType>::XprKind XprKind;
	enum{
	MatrixRows = traits<XprType>::RowsAtCompileTime,
	MatrixCols = traits<XprType>::ColsAtCompileTime,
	RowsAtCompileTime = Rows,
	ColsAtCompileTime = Cols,
	MaxRowsAtCompileTime = Rows,
	MaxColsAtCompileTime = Cols,
	XpxStorageOrder = ((int(traits<XprType>::Flags) & RowMajorBit) == RowMajorBit) ? RowMajor : ColMajor,
	ReshapedStorageOrder = (RowsAtCompileTime == 1 && ColsAtCompileTime != 1) ? RowMajor
	: (ColsAtCompileTime == 1 && RowsAtCompileTime != 1) ? ColMajor
	: XpxStorageOrder,
	HasSameStorageOrderAsXprType = (ReshapedStorageOrder == XpxStorageOrder),
	InnerSize = (ReshapedStorageOrder==int(RowMajor)) ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
	InnerStrideAtCompileTime = HasSameStorageOrderAsXprType
	? int(inner_stride_at_compile_time<XprType>::ret)
	: Dynamic,
	OuterStrideAtCompileTime = Dynamic,

	HasDirectAccess = internal::has_direct_access<XprType>::ret
	&& (Order==int(XpxStorageOrder))
	&& ((evaluator<XprType>::Flags&LinearAccessBit)==LinearAccessBit),

	MaskPacketAccessBit = (InnerSize == Dynamic \|\| (InnerSize % packet_traits<Scalar>::size) == 0)
	&& (InnerStrideAtCompileTime == 1)
	? PacketAccessBit : 0,
	//MaskAlignedBit = ((OuterStrideAtCompileTime!=Dynamic) && (((OuterStrideAtCompileTime * int(sizeof(Scalar))) % 16) == 0)) ? AlignedBit : 0,
	FlagsLinearAccessBit = (RowsAtCompileTime == 1 \|\| ColsAtCompileTime == 1) ? LinearAccessBit : 0,
	FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0,
	FlagsRowMajorBit = (ReshapedStorageOrder==int(RowMajor)) ? RowMajorBit : 0,
	FlagsDirectAccessBit = HasDirectAccess ? DirectAccessBit : 0,
	Flags0 = traits<XprType>::Flags & ( (HereditaryBits & ~RowMajorBit) \| MaskPacketAccessBit),

	Flags = (Flags0 \| FlagsLinearAccessBit \| FlagsLvalueBit \| FlagsRowMajorBit \| FlagsDirectAccessBit)
	};
	};

	template<typename XprType, int Rows, int Cols, int Order, bool HasDirectAccess> class ReshapedImpl_dense;

	} // end namespace internal

	template<typename XprType, int Rows, int Cols, int Order, typename StorageKind> class ReshapedImpl;

	template<typename XprType, int Rows, int Cols, int Order> class Reshaped
	: public ReshapedImpl<XprType, Rows, Cols, Order, typename internal::traits<XprType>::StorageKind>
	{
	typedef ReshapedImpl<XprType, Rows, Cols, Order, typename internal::traits<XprType>::StorageKind> Impl;
	public:
	//typedef typename Impl::Base Base;
	typedef Impl Base;
	EIGEN_GENERIC_PUBLIC_INTERFACE(Reshaped)
	EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Reshaped)

	/** Fixed-size constructor
	*/
	EIGEN_DEVICE_FUNC
	inline Reshaped(XprType& xpr)
	: Impl(xpr)
	{
	EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE)
	eigen_assert(Rows * Cols == xpr.rows() * xpr.cols());
	}

	/** Dynamic-size constructor
	*/
	EIGEN_DEVICE_FUNC
	inline Reshaped(XprType& xpr,
	Index reshapeRows, Index reshapeCols)
	: Impl(xpr, reshapeRows, reshapeCols)
	{
	eigen_assert((RowsAtCompileTime==Dynamic \|\| RowsAtCompileTime==reshapeRows)
	&& (ColsAtCompileTime==Dynamic \|\| ColsAtCompileTime==reshapeCols));
	eigen_assert(reshapeRows * reshapeCols == xpr.rows() * xpr.cols());
	}
	};

	// The generic default implementation for dense reshape simply forward to the internal::ReshapedImpl_dense
	// that must be specialized for direct and non-direct access...
	template<typename XprType, int Rows, int Cols, int Order>
	class ReshapedImpl<XprType, Rows, Cols, Order, Dense>
	: public internal::ReshapedImpl_dense<XprType, Rows, Cols, Order,internal::traits<Reshaped<XprType,Rows,Cols,Order> >::HasDirectAccess>
	{
	typedef internal::ReshapedImpl_dense<XprType, Rows, Cols, Order,internal::traits<Reshaped<XprType,Rows,Cols,Order> >::HasDirectAccess> Impl;
	public:
	typedef Impl Base;
	EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl)
	EIGEN_DEVICE_FUNC inline ReshapedImpl(XprType& xpr) : Impl(xpr) {}
	EIGEN_DEVICE_FUNC inline ReshapedImpl(XprType& xpr, Index reshapeRows, Index reshapeCols)
	: Impl(xpr, reshapeRows, reshapeCols) {}
	};

	namespace internal {

	/** \internal Internal implementation of dense Reshaped in the general case. */
	template<typename XprType, int Rows, int Cols, int Order>
	class ReshapedImpl_dense<XprType,Rows,Cols,Order,false>
	: public internal::dense_xpr_base<Reshaped<XprType, Rows, Cols, Order> >::type
	{
	typedef Reshaped<XprType, Rows, Cols, Order> ReshapedType;
	public:

	typedef typename internal::dense_xpr_base<ReshapedType>::type Base;
	EIGEN_DENSE_PUBLIC_INTERFACE(ReshapedType)
	EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl_dense)

	typedef typename internal::ref_selector<XprType>::non_const_type MatrixTypeNested;
	typedef typename internal::remove_all<XprType>::type NestedExpression;

	class InnerIterator;

	/** Fixed-size constructor
	*/
	EIGEN_DEVICE_FUNC
	inline ReshapedImpl_dense(XprType& xpr)
	: m_xpr(xpr), m_rows(Rows), m_cols(Cols)
	{}

	/** Dynamic-size constructor
	*/
	EIGEN_DEVICE_FUNC
	inline ReshapedImpl_dense(XprType& xpr, Index nRows, Index nCols)
	: m_xpr(xpr), m_rows(nRows), m_cols(nCols)
	{}

	EIGEN_DEVICE_FUNC Index rows() const { return m_rows; }
	EIGEN_DEVICE_FUNC Index cols() const { return m_cols; }

	#ifdef EIGEN_PARSED_BY_DOXYGEN
	/** \sa MapBase::data() */
	EIGEN_DEVICE_FUNC inline const Scalar* data() const;
	EIGEN_DEVICE_FUNC inline Index innerStride() const;
	EIGEN_DEVICE_FUNC inline Index outerStride() const;
	#endif

	/** \returns the nested expression */
	EIGEN_DEVICE_FUNC
	const typename internal::remove_all<XprType>::type&
	nestedExpression() const { return m_xpr; }

	/** \returns the nested expression */
	EIGEN_DEVICE_FUNC
	typename internal::remove_reference<XprType>::type&
	nestedExpression() { return m_xpr; }

	protected:

	MatrixTypeNested m_xpr;
	const internal::variable_if_dynamic<Index, Rows> m_rows;
	const internal::variable_if_dynamic<Index, Cols> m_cols;
	};


	/** \internal Internal implementation of dense Reshaped in the direct access case. */
	template<typename XprType, int Rows, int Cols, int Order>
	class ReshapedImpl_dense<XprType, Rows, Cols, Order, true>
	: public MapBase<Reshaped<XprType, Rows, Cols, Order> >
	{
	typedef Reshaped<XprType, Rows, Cols, Order> ReshapedType;
	typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
	public:

	typedef MapBase<ReshapedType> Base;
	EIGEN_DENSE_PUBLIC_INTERFACE(ReshapedType)
	EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl_dense)

	/** Fixed-size constructor
	*/
	EIGEN_DEVICE_FUNC
	inline ReshapedImpl_dense(XprType& xpr)
	: Base(xpr.data()), m_xpr(xpr)
	{}

	/** Dynamic-size constructor
	*/
	EIGEN_DEVICE_FUNC
	inline ReshapedImpl_dense(XprType& xpr, Index nRows, Index nCols)
	: Base(xpr.data(), nRows, nCols),
	m_xpr(xpr)
	{}

	EIGEN_DEVICE_FUNC
	const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const
	{
	return m_xpr;
	}

	EIGEN_DEVICE_FUNC
	XprType& nestedExpression() { return m_xpr; }

	/** \sa MapBase::innerStride() */
	EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
	inline Index innerStride() const
	{
	return m_xpr.innerStride();
	}

	/** \sa MapBase::outerStride() */
	EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
	inline Index outerStride() const
	{
	return ((Flags&RowMajorBit)==RowMajorBit) ? this->cols() : this->rows();
	}

	protected:

	XprTypeNested m_xpr;
	};

	// Evaluators
	template<typename ArgType, int Rows, int Cols, int Order, bool HasDirectAccess> struct reshaped_evaluator;

	template<typename ArgType, int Rows, int Cols, int Order>
	struct evaluator<Reshaped<ArgType, Rows, Cols, Order> >
	: reshaped_evaluator<ArgType, Rows, Cols, Order, traits<Reshaped<ArgType,Rows,Cols,Order> >::HasDirectAccess>
	{
	typedef Reshaped<ArgType, Rows, Cols, Order> XprType;
	typedef typename XprType::Scalar Scalar;
	// TODO: should check for smaller packet types
	typedef typename packet_traits<Scalar>::type PacketScalar;

	enum {
	CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
	HasDirectAccess = traits<XprType>::HasDirectAccess,

	// RowsAtCompileTime = traits<XprType>::RowsAtCompileTime,
	// ColsAtCompileTime = traits<XprType>::ColsAtCompileTime,
	// MaxRowsAtCompileTime = traits<XprType>::MaxRowsAtCompileTime,
	// MaxColsAtCompileTime = traits<XprType>::MaxColsAtCompileTime,
	//
	// InnerStrideAtCompileTime = traits<XprType>::HasSameStorageOrderAsXprType
	// ? int(inner_stride_at_compile_time<ArgType>::ret)
	// : Dynamic,
	// OuterStrideAtCompileTime = Dynamic,

	FlagsLinearAccessBit = (traits<XprType>::RowsAtCompileTime == 1 \|\| traits<XprType>::ColsAtCompileTime == 1 \|\| HasDirectAccess) ? LinearAccessBit : 0,
	FlagsRowMajorBit = (traits<XprType>::ReshapedStorageOrder==int(RowMajor)) ? RowMajorBit : 0,
	FlagsDirectAccessBit = HasDirectAccess ? DirectAccessBit : 0,
	Flags0 = evaluator<ArgType>::Flags & (HereditaryBits & ~RowMajorBit),
	Flags = Flags0 \| FlagsLinearAccessBit \| FlagsRowMajorBit \| FlagsDirectAccessBit,

	PacketAlignment = unpacket_traits<PacketScalar>::alignment,
	Alignment = evaluator<ArgType>::Alignment
	};
	typedef reshaped_evaluator<ArgType, Rows, Cols, Order, HasDirectAccess> reshaped_evaluator_type;
	EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : reshaped_evaluator_type(xpr)
	{
	EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
	}
	};

	template<typename ArgType, int Rows, int Cols, int Order>
	struct reshaped_evaluator<ArgType, Rows, Cols, Order, /* HasDirectAccess */ false>
	: evaluator_base<Reshaped<ArgType, Rows, Cols, Order> >
	{
	typedef Reshaped<ArgType, Rows, Cols, Order> XprType;

	enum {
	CoeffReadCost = evaluator<ArgType>::CoeffReadCost /* TODO + cost of index computations */,

	Flags = (evaluator<ArgType>::Flags & (HereditaryBits /\| LinearAccessBit \| DirectAccessBit/)),

	Alignment = 0
	};

	EIGEN_DEVICE_FUNC explicit reshaped_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_xpr(xpr)
	{
	EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
	}

	typedef typename XprType::Scalar Scalar;
	typedef typename XprType::CoeffReturnType CoeffReturnType;

	typedef std::pair<Index, Index> RowCol;

	inline RowCol index_remap(Index rowId, Index colId) const
	{
	if(Order==ColMajor)
	{
	const Index nth_elem_idx = colId * m_xpr.rows() + rowId;
	return RowCol(nth_elem_idx % m_xpr.nestedExpression().rows(),
	nth_elem_idx / m_xpr.nestedExpression().rows());
	}
	else
	{
	const Index nth_elem_idx = colId + rowId * m_xpr.cols();
	return RowCol(nth_elem_idx / m_xpr.nestedExpression().cols(),
	nth_elem_idx % m_xpr.nestedExpression().cols());
	}
	}

	EIGEN_DEVICE_FUNC
	inline Scalar& coeffRef(Index rowId, Index colId)
	{
	EIGEN_STATIC_ASSERT_LVALUE(XprType)
	const RowCol row_col = index_remap(rowId, colId);
	return m_argImpl.coeffRef(row_col.first, row_col.second);
	}

	EIGEN_DEVICE_FUNC
	inline const Scalar& coeffRef(Index rowId, Index colId) const
	{
	const RowCol row_col = index_remap(rowId, colId);
	return m_argImpl.coeffRef(row_col.first, row_col.second);
	}

	EIGEN_DEVICE_FUNC
	EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const
	{
	const RowCol row_col = index_remap(rowId, colId);
	return m_argImpl.coeff(row_col.first, row_col.second);
	}

	EIGEN_DEVICE_FUNC
	inline Scalar& coeffRef(Index index)
	{
	EIGEN_STATIC_ASSERT_LVALUE(XprType)
	const RowCol row_col = index_remap(Rows == 1 ? 0 : index,
	Rows == 1 ? index : 0);
	return m_argImpl.coeffRef(row_col.first, row_col.second);

	}

	EIGEN_DEVICE_FUNC
	inline const Scalar& coeffRef(Index index) const
	{
	const RowCol row_col = index_remap(Rows == 1 ? 0 : index,
	Rows == 1 ? index : 0);
	return m_argImpl.coeffRef(row_col.first, row_col.second);
	}

	EIGEN_DEVICE_FUNC
	inline const CoeffReturnType coeff(Index index) const
	{
	const RowCol row_col = index_remap(Rows == 1 ? 0 : index,
	Rows == 1 ? index : 0);
	return m_argImpl.coeff(row_col.first, row_col.second);
	}
	#if 0
	EIGEN_DEVICE_FUNC
	template<int LoadMode>
	inline PacketScalar packet(Index rowId, Index colId) const
	{
	const RowCol row_col = index_remap(rowId, colId);
	return m_argImpl.template packet<Unaligned>(row_col.first, row_col.second);

	}

	template<int LoadMode>
	EIGEN_DEVICE_FUNC
	inline void writePacket(Index rowId, Index colId, const PacketScalar& val)
	{
	const RowCol row_col = index_remap(rowId, colId);
	m_argImpl.const_cast_derived().template writePacket<Unaligned>
	(row_col.first, row_col.second, val);
	}

	template<int LoadMode>
	EIGEN_DEVICE_FUNC
	inline PacketScalar packet(Index index) const
	{
	const RowCol row_col = index_remap(RowsAtCompileTime == 1 ? 0 : index,
	RowsAtCompileTime == 1 ? index : 0);
	return m_argImpl.template packet<Unaligned>(row_col.first, row_col.second);
	}

	template<int LoadMode>
	EIGEN_DEVICE_FUNC
	inline void writePacket(Index index, const PacketScalar& val)
	{
	const RowCol row_col = index_remap(RowsAtCompileTime == 1 ? 0 : index,
	RowsAtCompileTime == 1 ? index : 0);
	return m_argImpl.template packet<Unaligned>(row_col.first, row_col.second, val);
	}
	#endif
	protected:

	evaluator<ArgType> m_argImpl;
	const XprType& m_xpr;

	};

	template<typename ArgType, int Rows, int Cols, int Order>
	struct reshaped_evaluator<ArgType, Rows, Cols, Order, /* HasDirectAccess */ true>
	: mapbase_evaluator<Reshaped<ArgType, Rows, Cols, Order>,
	typename Reshaped<ArgType, Rows, Cols, Order>::PlainObject>
	{
	typedef Reshaped<ArgType, Rows, Cols, Order> XprType;
	typedef typename XprType::Scalar Scalar;

	EIGEN_DEVICE_FUNC explicit reshaped_evaluator(const XprType& xpr)
	: mapbase_evaluator<XprType, typename XprType::PlainObject>(xpr)
	{
	// TODO: for the 3.4 release, this should be turned to an internal assertion, but let's keep it as is for the beta lifetime
	eigen_assert(((internal::UIntPtr(xpr.data()) % EIGEN_PLAIN_ENUM_MAX(1,evaluator<XprType>::Alignment)) == 0) && "data is not aligned");
	}
	};

	} // end namespace internal

	} // end namespace Eigen

	#endif // EIGEN_RESHAPED_H