Reverse.h
Go to the documentation of this file.
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
5 // Copyright (C) 2009 Ricard Marxer <email@ricardmarxer.com>
6 // Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
7 //
8 // This Source Code Form is subject to the terms of the Mozilla
9 // Public License v. 2.0. If a copy of the MPL was not distributed
10 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
11 
12 #ifndef EIGEN_REVERSE_H
13 #define EIGEN_REVERSE_H
14 
15 namespace Eigen {
16 
17 namespace internal {
18 
19 template<typename MatrixType, int Direction>
20 struct traits<Reverse<MatrixType, Direction> >
21  : traits<MatrixType>
22 {
23  typedef typename MatrixType::Scalar Scalar;
28  enum {
29  RowsAtCompileTime = MatrixType::RowsAtCompileTime,
30  ColsAtCompileTime = MatrixType::ColsAtCompileTime,
31  MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
32  MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
33  Flags = _MatrixTypeNested::Flags & (RowMajorBit | LvalueBit)
34  };
35 };
36 
37 template<typename PacketType, bool ReversePacket> struct reverse_packet_cond
38 {
39  static inline PacketType run(const PacketType& x) { return preverse(x); }
40 };
41 
42 template<typename PacketType> struct reverse_packet_cond<PacketType,false>
43 {
44  static inline PacketType run(const PacketType& x) { return x; }
45 };
46 
47 } // end namespace internal
48 
63 template<typename MatrixType, int Direction> class Reverse
64  : public internal::dense_xpr_base< Reverse<MatrixType, Direction> >::type
65 {
66  public:
67 
70  typedef typename internal::remove_all<MatrixType>::type NestedExpression;
71  using Base::IsRowMajor;
72 
73  protected:
74  enum {
76  IsColMajor = !IsRowMajor,
77  ReverseRow = (Direction == Vertical) || (Direction == BothDirections),
78  ReverseCol = (Direction == Horizontal) || (Direction == BothDirections),
79  OffsetRow = ReverseRow && IsColMajor ? PacketSize : 1,
80  OffsetCol = ReverseCol && IsRowMajor ? PacketSize : 1,
81  ReversePacket = (Direction == BothDirections)
82  || ((Direction == Vertical) && IsColMajor)
83  || ((Direction == Horizontal) && IsRowMajor)
84  };
86  public:
87 
88  EIGEN_DEVICE_FUNC explicit inline Reverse(const MatrixType& matrix) : m_matrix(matrix) { }
89 
91 
93  inline Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
95  inline Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
96 
98  {
99  return -m_matrix.innerStride();
100  }
101 
104  {
105  return m_matrix;
106  }
107 
108  protected:
109  typename MatrixType::Nested m_matrix;
110 };
111 
118 template<typename Derived>
121 {
122  return ReverseReturnType(derived());
123 }
124 
125 
126 //reverse const overload moved DenseBase.h due to a CUDA compiler bug
127 
140 template<typename Derived>
142 {
143  if(cols()>rows())
144  {
145  Index half = cols()/2;
146  leftCols(half).swap(rightCols(half).reverse());
147  if((cols()%2)==1)
148  {
149  Index half2 = rows()/2;
150  col(half).head(half2).swap(col(half).tail(half2).reverse());
151  }
152  }
153  else
154  {
155  Index half = rows()/2;
156  topRows(half).swap(bottomRows(half).reverse());
157  if((rows()%2)==1)
158  {
159  Index half2 = cols()/2;
160  row(half).head(half2).swap(row(half).tail(half2).reverse());
161  }
162  }
163 }
164 
165 namespace internal {
166 
167 template<int Direction>
169 
170 template<>
172 {
173  template<typename ExpressionType>
174  static void run(ExpressionType &xpr)
175  {
176  const int HalfAtCompileTime = ExpressionType::RowsAtCompileTime==Dynamic?Dynamic:ExpressionType::RowsAtCompileTime/2;
177  Index half = xpr.rows()/2;
178  xpr.topRows(fix<HalfAtCompileTime>(half))
179  .swap(xpr.bottomRows(fix<HalfAtCompileTime>(half)).colwise().reverse());
180  }
181 };
182 
183 template<>
185 {
186  template<typename ExpressionType>
187  static void run(ExpressionType &xpr)
188  {
189  const int HalfAtCompileTime = ExpressionType::ColsAtCompileTime==Dynamic?Dynamic:ExpressionType::ColsAtCompileTime/2;
190  Index half = xpr.cols()/2;
191  xpr.leftCols(fix<HalfAtCompileTime>(half))
192  .swap(xpr.rightCols(fix<HalfAtCompileTime>(half)).rowwise().reverse());
193  }
194 };
195 
196 } // end namespace internal
197 
209 template<typename ExpressionType, int Direction>
211 {
213 }
214 
215 } // end namespace Eigen
216 
217 #endif // EIGEN_REVERSE_H
SCALAR Scalar
Definition: bench_gemm.cpp:46
internal::reverse_packet_cond< PacketScalar, ReversePacket > reverse_packet
Definition: Reverse.h:85
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT
Definition: Reverse.h:95
const unsigned int LvalueBit
Definition: Constants.h:144
internal::dense_xpr_base< Reverse >::type Base
Definition: Reverse.h:68
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE FixedSegmentReturnType< internal::get_fixed_value< NType >::value >::Type tail(NType n)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE NRowsBlockXpr< internal::get_fixed_value< NRowsType >::value >::Type topRows(NRowsType n)
Definition: BlockMethods.h:570
MatrixXf MatrixType
const unsigned int RowMajorBit
Definition: Constants.h:66
EIGEN_DEVICE_FUNC Reverse(const MatrixType &matrix)
Definition: Reverse.h:88
static PacketType run(const PacketType &x)
Definition: Reverse.h:44
traits< MatrixType >::StorageKind StorageKind
Definition: Reverse.h:24
EIGEN_DEVICE_FUNC void reverseInPlace()
Definition: Reverse.h:141
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE NRowsBlockXpr< internal::get_fixed_value< NRowsType >::value >::Type bottomRows(NRowsType n)
Definition: BlockMethods.h:645
m row(1)
#define EIGEN_NOEXCEPT
Definition: Macros.h:1418
static PacketType run(const PacketType &x)
Definition: Reverse.h:39
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
#define EIGEN_CONSTEXPR
Definition: Macros.h:787
#define EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Derived)
Definition: Macros.h:1231
remove_reference< MatrixTypeNested >::type _MatrixTypeNested
Definition: Reverse.h:27
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT
Definition: Reverse.h:93
#define EIGEN_DEVICE_FUNC
Definition: Macros.h:976
EIGEN_DEVICE_FUNC Index innerStride() const
Definition: Reverse.h:97
void reverse(const MatrixType &m)
EIGEN_DEVICE_FUNC ReverseReturnType reverse()
Definition: Reverse.h:120
#define EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
Definition: Macros.h:1283
m col(1)
ref_selector< MatrixType >::type MatrixTypeNested
Definition: Reverse.h:26
const int Dynamic
Definition: Constants.h:22
EIGEN_DEVICE_FUNC void reverseInPlace()
Definition: Reverse.h:210
EIGEN_DEVICE_FUNC const internal::remove_all< typename MatrixType::Nested >::type & nestedExpression() const
Definition: Reverse.h:103
Map< Matrix< T, Dynamic, Dynamic, ColMajor >, 0, OuterStride<> > matrix(T *data, int rows, int cols, int stride)
Expression of the reverse of a vector or matrix.
Definition: Reverse.h:63
set noclip points set clip one set noclip two set bar set border lt lw set xdata set ydata set zdata set x2data set y2data set boxwidth set dummy x
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE NColsBlockXpr< internal::get_fixed_value< NColsType >::value >::Type rightCols(NColsType n)
Definition: BlockMethods.h:872
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE NColsBlockXpr< internal::get_fixed_value< NColsType >::value >::Type leftCols(NColsType n)
Definition: BlockMethods.h:797
Definition: pytypes.h:1370
MatrixType::Nested m_matrix
Definition: Reverse.h:109
EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf &a)


gtsam
Author(s):
autogenerated on Tue Jul 4 2023 02:35:34