cart-elc

Reverse.h (7522B)

---

 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
 // Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
 // Copyright (C) 2009 Ricard Marxer <email@ricardmarxer.com>
 // Copyright (C) 2009-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_REVERSE_H
 #define EIGEN_REVERSE_H
 
 namespace Eigen {
 
 namespace internal {
 
 template<typename MatrixType, int Direction>
 struct traits<Reverse<MatrixType, Direction> >
  : traits<MatrixType>
 {
   typedef typename MatrixType::Scalar Scalar;
   typedef typename traits<MatrixType>::StorageKind StorageKind;
   typedef typename traits<MatrixType>::XprKind XprKind;
   typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
   typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
   enum {
     RowsAtCompileTime = MatrixType::RowsAtCompileTime,
     ColsAtCompileTime = MatrixType::ColsAtCompileTime,
     MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
     Flags = _MatrixTypeNested::Flags & (RowMajorBit | LvalueBit)
   };
 };
 
 template<typename PacketType, bool ReversePacket> struct reverse_packet_cond
 {
   static inline PacketType run(const PacketType& x) { return preverse(x); }
 };
 
 template<typename PacketType> struct reverse_packet_cond<PacketType,false>
 {
   static inline PacketType run(const PacketType& x) { return x; }
 };
 
 } // end namespace internal
 
 /** \class Reverse
   * \ingroup Core_Module
   *
   * \brief Expression of the reverse of a vector or matrix
   *
   * \tparam MatrixType the type of the object of which we are taking the reverse
   * \tparam Direction defines the direction of the reverse operation, can be Vertical, Horizontal, or BothDirections
   *
   * This class represents an expression of the reverse of a vector.
   * It is the return type of MatrixBase::reverse() and VectorwiseOp::reverse()
   * and most of the time this is the only way it is used.
   *
   * \sa MatrixBase::reverse(), VectorwiseOp::reverse()
   */
 template<typename MatrixType, int Direction> class Reverse
   : public internal::dense_xpr_base< Reverse<MatrixType, Direction> >::type
 {
   public:
 
     typedef typename internal::dense_xpr_base<Reverse>::type Base;
     EIGEN_DENSE_PUBLIC_INTERFACE(Reverse)
     typedef typename internal::remove_all<MatrixType>::type NestedExpression;
     using Base::IsRowMajor;
 
   protected:
     enum {
       PacketSize = internal::packet_traits<Scalar>::size,
       IsColMajor = !IsRowMajor,
       ReverseRow = (Direction == Vertical)   || (Direction == BothDirections),
       ReverseCol = (Direction == Horizontal) || (Direction == BothDirections),
       OffsetRow  = ReverseRow && IsColMajor ? PacketSize : 1,
       OffsetCol  = ReverseCol && IsRowMajor ? PacketSize : 1,
       ReversePacket = (Direction == BothDirections)
                     || ((Direction == Vertical)   && IsColMajor)
                     || ((Direction == Horizontal) && IsRowMajor)
     };
     typedef internal::reverse_packet_cond<PacketScalar,ReversePacket> reverse_packet;
   public:
 
     EIGEN_DEVICE_FUNC explicit inline Reverse(const MatrixType& matrix) : m_matrix(matrix) { }
 
     EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Reverse)
 
     EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
     inline Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
     EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
     inline Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
 
     EIGEN_DEVICE_FUNC inline Index innerStride() const
     {
       return -m_matrix.innerStride();
     }
 
     EIGEN_DEVICE_FUNC const typename internal::remove_all<typename MatrixType::Nested>::type&
     nestedExpression() const
     {
       return m_matrix;
     }
 
   protected:
     typename MatrixType::Nested m_matrix;
 };
 
 /** \returns an expression of the reverse of *this.
   *
   * Example: \include MatrixBase_reverse.cpp
   * Output: \verbinclude MatrixBase_reverse.out
   *
   */
 template<typename Derived>
 EIGEN_DEVICE_FUNC inline typename DenseBase<Derived>::ReverseReturnType
 DenseBase<Derived>::reverse()
 {
   return ReverseReturnType(derived());
 }
 
 
 //reverse const overload moved DenseBase.h due to a CUDA compiler bug
 
 /** This is the "in place" version of reverse: it reverses \c *this.
   *
   * In most cases it is probably better to simply use the reversed expression
   * of a matrix. However, when reversing the matrix data itself is really needed,
   * then this "in-place" version is probably the right choice because it provides
   * the following additional benefits:
   *  - less error prone: doing the same operation with .reverse() requires special care:
   *    \code m = m.reverse().eval(); \endcode
   *  - this API enables reverse operations without the need for a temporary
   *  - it allows future optimizations (cache friendliness, etc.)
   *
   * \sa VectorwiseOp::reverseInPlace(), reverse() */
 template<typename Derived>
 EIGEN_DEVICE_FUNC inline void DenseBase<Derived>::reverseInPlace()
 {
   if(cols()>rows())
   {
     Index half = cols()/2;
     leftCols(half).swap(rightCols(half).reverse());
     if((cols()%2)==1)
     {
       Index half2 = rows()/2;
       col(half).head(half2).swap(col(half).tail(half2).reverse());
     }
   }
   else
   {
     Index half = rows()/2;
     topRows(half).swap(bottomRows(half).reverse());
     if((rows()%2)==1)
     {
       Index half2 = cols()/2;
       row(half).head(half2).swap(row(half).tail(half2).reverse());
     }
   }
 }
 
 namespace internal {
 
 template<int Direction>
 struct vectorwise_reverse_inplace_impl;
 
 template<>
 struct vectorwise_reverse_inplace_impl<Vertical>
 {
   template<typename ExpressionType>
   static void run(ExpressionType &xpr)
   {
     const int HalfAtCompileTime = ExpressionType::RowsAtCompileTime==Dynamic?Dynamic:ExpressionType::RowsAtCompileTime/2;
     Index half = xpr.rows()/2;
     xpr.topRows(fix<HalfAtCompileTime>(half))
        .swap(xpr.bottomRows(fix<HalfAtCompileTime>(half)).colwise().reverse());
   }
 };
 
 template<>
 struct vectorwise_reverse_inplace_impl<Horizontal>
 {
   template<typename ExpressionType>
   static void run(ExpressionType &xpr)
   {
     const int HalfAtCompileTime = ExpressionType::ColsAtCompileTime==Dynamic?Dynamic:ExpressionType::ColsAtCompileTime/2;
     Index half = xpr.cols()/2;
     xpr.leftCols(fix<HalfAtCompileTime>(half))
        .swap(xpr.rightCols(fix<HalfAtCompileTime>(half)).rowwise().reverse());
   }
 };
 
 } // end namespace internal
 
 /** This is the "in place" version of VectorwiseOp::reverse: it reverses each column or row of \c *this.
   *
   * In most cases it is probably better to simply use the reversed expression
   * of a matrix. However, when reversing the matrix data itself is really needed,
   * then this "in-place" version is probably the right choice because it provides
   * the following additional benefits:
   *  - less error prone: doing the same operation with .reverse() requires special care:
   *    \code m = m.reverse().eval(); \endcode
   *  - this API enables reverse operations without the need for a temporary
   *
   * \sa DenseBase::reverseInPlace(), reverse() */
 template<typename ExpressionType, int Direction>
 EIGEN_DEVICE_FUNC void VectorwiseOp<ExpressionType,Direction>::reverseInPlace()
 {
   internal::vectorwise_reverse_inplace_impl<Direction>::run(m_matrix);
 }
 
 } // end namespace Eigen
 
 #endif // EIGEN_REVERSE_H