212 lines
6.9 KiB
C++
212 lines
6.9 KiB
C++
// 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 inline Index rows() const { return m_matrix.rows(); }
|
|
EIGEN_DEVICE_FUNC inline Index cols() const { 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>
|
|
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>
|
|
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)
|
|
{
|
|
Index half = xpr.rows()/2;
|
|
xpr.topRows(half).swap(xpr.bottomRows(half).colwise().reverse());
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct vectorwise_reverse_inplace_impl<Horizontal>
|
|
{
|
|
template<typename ExpressionType>
|
|
static void run(ExpressionType &xpr)
|
|
{
|
|
Index half = xpr.cols()/2;
|
|
xpr.leftCols(half).swap(xpr.rightCols(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>
|
|
void VectorwiseOp<ExpressionType,Direction>::reverseInPlace()
|
|
{
|
|
internal::vectorwise_reverse_inplace_impl<Direction>::run(_expression().const_cast_derived());
|
|
}
|
|
|
|
} // end namespace Eigen
|
|
|
|
#endif // EIGEN_REVERSE_H
|