• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2011 Benoit Jacob <jacob.benoit.1@gmail.com>
5 // Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
6 // Copyright (C) 2011-2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
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 
13 #ifndef EIGEN_COREEVALUATORS_H
14 #define EIGEN_COREEVALUATORS_H
15 
16 namespace Eigen {
17 
18 namespace internal {
19 
20 // This class returns the evaluator kind from the expression storage kind.
21 // Default assumes index based accessors
22 template<typename StorageKind>
23 struct storage_kind_to_evaluator_kind {
24   typedef IndexBased Kind;
25 };
26 
27 // This class returns the evaluator shape from the expression storage kind.
28 // It can be Dense, Sparse, Triangular, Diagonal, SelfAdjoint, Band, etc.
29 template<typename StorageKind> struct storage_kind_to_shape;
30 
31 template<> struct storage_kind_to_shape<Dense>                  { typedef DenseShape Shape;           };
32 template<> struct storage_kind_to_shape<SolverStorage>          { typedef SolverShape Shape;           };
33 template<> struct storage_kind_to_shape<PermutationStorage>     { typedef PermutationShape Shape;     };
34 template<> struct storage_kind_to_shape<TranspositionsStorage>  { typedef TranspositionsShape Shape;  };
35 
36 // Evaluators have to be specialized with respect to various criteria such as:
37 //  - storage/structure/shape
38 //  - scalar type
39 //  - etc.
40 // Therefore, we need specialization of evaluator providing additional template arguments for each kind of evaluators.
41 // We currently distinguish the following kind of evaluators:
42 // - unary_evaluator    for expressions taking only one arguments (CwiseUnaryOp, CwiseUnaryView, Transpose, MatrixWrapper, ArrayWrapper, Reverse, Replicate)
43 // - binary_evaluator   for expression taking two arguments (CwiseBinaryOp)
44 // - ternary_evaluator   for expression taking three arguments (CwiseTernaryOp)
45 // - product_evaluator  for linear algebra products (Product); special case of binary_evaluator because it requires additional tags for dispatching.
46 // - mapbase_evaluator  for Map, Block, Ref
47 // - block_evaluator    for Block (special dispatching to a mapbase_evaluator or unary_evaluator)
48 
49 template< typename T,
50           typename Arg1Kind   = typename evaluator_traits<typename T::Arg1>::Kind,
51           typename Arg2Kind   = typename evaluator_traits<typename T::Arg2>::Kind,
52           typename Arg3Kind   = typename evaluator_traits<typename T::Arg3>::Kind,
53           typename Arg1Scalar = typename traits<typename T::Arg1>::Scalar,
54           typename Arg2Scalar = typename traits<typename T::Arg2>::Scalar,
55           typename Arg3Scalar = typename traits<typename T::Arg3>::Scalar> struct ternary_evaluator;
56 
57 template< typename T,
58           typename LhsKind   = typename evaluator_traits<typename T::Lhs>::Kind,
59           typename RhsKind   = typename evaluator_traits<typename T::Rhs>::Kind,
60           typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
61           typename RhsScalar = typename traits<typename T::Rhs>::Scalar> struct binary_evaluator;
62 
63 template< typename T,
64           typename Kind   = typename evaluator_traits<typename T::NestedExpression>::Kind,
65           typename Scalar = typename T::Scalar> struct unary_evaluator;
66 
67 // evaluator_traits<T> contains traits for evaluator<T>
68 
69 template<typename T>
70 struct evaluator_traits_base
71 {
72   // by default, get evaluator kind and shape from storage
73   typedef typename storage_kind_to_evaluator_kind<typename traits<T>::StorageKind>::Kind Kind;
74   typedef typename storage_kind_to_shape<typename traits<T>::StorageKind>::Shape Shape;
75 };
76 
77 // Default evaluator traits
78 template<typename T>
79 struct evaluator_traits : public evaluator_traits_base<T>
80 {
81 };
82 
83 template<typename T, typename Shape = typename evaluator_traits<T>::Shape >
84 struct evaluator_assume_aliasing {
85   static const bool value = false;
86 };
87 
88 // By default, we assume a unary expression:
89 template<typename T>
90 struct evaluator : public unary_evaluator<T>
91 {
92   typedef unary_evaluator<T> Base;
93   EIGEN_DEVICE_FUNC explicit evaluator(const T& xpr) : Base(xpr) {}
94 };
95 
96 
97 // TODO: Think about const-correctness
98 template<typename T>
99 struct evaluator<const T>
100   : evaluator<T>
101 {
102   EIGEN_DEVICE_FUNC
103   explicit evaluator(const T& xpr) : evaluator<T>(xpr) {}
104 };
105 
106 // ---------- base class for all evaluators ----------
107 
108 template<typename ExpressionType>
109 struct evaluator_base : public noncopyable
110 {
111   // TODO that's not very nice to have to propagate all these traits. They are currently only needed to handle outer,inner indices.
112   typedef traits<ExpressionType> ExpressionTraits;
113 
114   enum {
115     Alignment = 0
116   };
117 };
118 
119 // -------------------- Matrix and Array --------------------
120 //
121 // evaluator<PlainObjectBase> is a common base class for the
122 // Matrix and Array evaluators.
123 // Here we directly specialize evaluator. This is not really a unary expression, and it is, by definition, dense,
124 // so no need for more sophisticated dispatching.
125 
126 template<typename Derived>
127 struct evaluator<PlainObjectBase<Derived> >
128   : evaluator_base<Derived>
129 {
130   typedef PlainObjectBase<Derived> PlainObjectType;
131   typedef typename PlainObjectType::Scalar Scalar;
132   typedef typename PlainObjectType::CoeffReturnType CoeffReturnType;
133 
134   enum {
135     IsRowMajor = PlainObjectType::IsRowMajor,
136     IsVectorAtCompileTime = PlainObjectType::IsVectorAtCompileTime,
137     RowsAtCompileTime = PlainObjectType::RowsAtCompileTime,
138     ColsAtCompileTime = PlainObjectType::ColsAtCompileTime,
139 
140     CoeffReadCost = NumTraits<Scalar>::ReadCost,
141     Flags = traits<Derived>::EvaluatorFlags,
142     Alignment = traits<Derived>::Alignment
143   };
144 
145   EIGEN_DEVICE_FUNC evaluator()
146     : m_data(0),
147       m_outerStride(IsVectorAtCompileTime  ? 0
148                                            : int(IsRowMajor) ? ColsAtCompileTime
149                                            : RowsAtCompileTime)
150   {
151     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
152   }
153 
154   EIGEN_DEVICE_FUNC explicit evaluator(const PlainObjectType& m)
155     : m_data(m.data()), m_outerStride(IsVectorAtCompileTime ? 0 : m.outerStride())
156   {
157     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
158   }
159 
160   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
161   CoeffReturnType coeff(Index row, Index col) const
162   {
163     if (IsRowMajor)
164       return m_data[row * m_outerStride.value() + col];
165     else
166       return m_data[row + col * m_outerStride.value()];
167   }
168 
169   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
170   CoeffReturnType coeff(Index index) const
171   {
172     return m_data[index];
173   }
174 
175   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
176   Scalar& coeffRef(Index row, Index col)
177   {
178     if (IsRowMajor)
179       return const_cast<Scalar*>(m_data)[row * m_outerStride.value() + col];
180     else
181       return const_cast<Scalar*>(m_data)[row + col * m_outerStride.value()];
182   }
183 
184   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
185   Scalar& coeffRef(Index index)
186   {
187     return const_cast<Scalar*>(m_data)[index];
188   }
189 
190   template<int LoadMode, typename PacketType>
191   EIGEN_STRONG_INLINE
192   PacketType packet(Index row, Index col) const
193   {
194     if (IsRowMajor)
195       return ploadt<PacketType, LoadMode>(m_data + row * m_outerStride.value() + col);
196     else
197       return ploadt<PacketType, LoadMode>(m_data + row + col * m_outerStride.value());
198   }
199 
200   template<int LoadMode, typename PacketType>
201   EIGEN_STRONG_INLINE
202   PacketType packet(Index index) const
203   {
204     return ploadt<PacketType, LoadMode>(m_data + index);
205   }
206 
207   template<int StoreMode,typename PacketType>
208   EIGEN_STRONG_INLINE
209   void writePacket(Index row, Index col, const PacketType& x)
210   {
211     if (IsRowMajor)
212       return pstoret<Scalar, PacketType, StoreMode>
213 	            (const_cast<Scalar*>(m_data) + row * m_outerStride.value() + col, x);
214     else
215       return pstoret<Scalar, PacketType, StoreMode>
216                     (const_cast<Scalar*>(m_data) + row + col * m_outerStride.value(), x);
217   }
218 
219   template<int StoreMode, typename PacketType>
220   EIGEN_STRONG_INLINE
221   void writePacket(Index index, const PacketType& x)
222   {
223     return pstoret<Scalar, PacketType, StoreMode>(const_cast<Scalar*>(m_data) + index, x);
224   }
225 
226 protected:
227   const Scalar *m_data;
228 
229   // We do not need to know the outer stride for vectors
230   variable_if_dynamic<Index, IsVectorAtCompileTime  ? 0
231                                                     : int(IsRowMajor) ? ColsAtCompileTime
232                                                     : RowsAtCompileTime> m_outerStride;
233 };
234 
235 template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
236 struct evaluator<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> >
237   : evaluator<PlainObjectBase<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> > >
238 {
239   typedef Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> XprType;
240 
241   EIGEN_DEVICE_FUNC evaluator() {}
242 
243   EIGEN_DEVICE_FUNC explicit evaluator(const XprType& m)
244     : evaluator<PlainObjectBase<XprType> >(m)
245   { }
246 };
247 
248 template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
249 struct evaluator<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> >
250   : evaluator<PlainObjectBase<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> > >
251 {
252   typedef Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> XprType;
253 
254   EIGEN_DEVICE_FUNC evaluator() {}
255 
256   EIGEN_DEVICE_FUNC explicit evaluator(const XprType& m)
257     : evaluator<PlainObjectBase<XprType> >(m)
258   { }
259 };
260 
261 // -------------------- Transpose --------------------
262 
263 template<typename ArgType>
264 struct unary_evaluator<Transpose<ArgType>, IndexBased>
265   : evaluator_base<Transpose<ArgType> >
266 {
267   typedef Transpose<ArgType> XprType;
268 
269   enum {
270     CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
271     Flags = evaluator<ArgType>::Flags ^ RowMajorBit,
272     Alignment = evaluator<ArgType>::Alignment
273   };
274 
275   EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& t) : m_argImpl(t.nestedExpression()) {}
276 
277   typedef typename XprType::Scalar Scalar;
278   typedef typename XprType::CoeffReturnType CoeffReturnType;
279 
280   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
281   CoeffReturnType coeff(Index row, Index col) const
282   {
283     return m_argImpl.coeff(col, row);
284   }
285 
286   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
287   CoeffReturnType coeff(Index index) const
288   {
289     return m_argImpl.coeff(index);
290   }
291 
292   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
293   Scalar& coeffRef(Index row, Index col)
294   {
295     return m_argImpl.coeffRef(col, row);
296   }
297 
298   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
299   typename XprType::Scalar& coeffRef(Index index)
300   {
301     return m_argImpl.coeffRef(index);
302   }
303 
304   template<int LoadMode, typename PacketType>
305   EIGEN_STRONG_INLINE
306   PacketType packet(Index row, Index col) const
307   {
308     return m_argImpl.template packet<LoadMode,PacketType>(col, row);
309   }
310 
311   template<int LoadMode, typename PacketType>
312   EIGEN_STRONG_INLINE
313   PacketType packet(Index index) const
314   {
315     return m_argImpl.template packet<LoadMode,PacketType>(index);
316   }
317 
318   template<int StoreMode, typename PacketType>
319   EIGEN_STRONG_INLINE
320   void writePacket(Index row, Index col, const PacketType& x)
321   {
322     m_argImpl.template writePacket<StoreMode,PacketType>(col, row, x);
323   }
324 
325   template<int StoreMode, typename PacketType>
326   EIGEN_STRONG_INLINE
327   void writePacket(Index index, const PacketType& x)
328   {
329     m_argImpl.template writePacket<StoreMode,PacketType>(index, x);
330   }
331 
332 protected:
333   evaluator<ArgType> m_argImpl;
334 };
335 
336 // -------------------- CwiseNullaryOp --------------------
337 // Like Matrix and Array, this is not really a unary expression, so we directly specialize evaluator.
338 // Likewise, there is not need to more sophisticated dispatching here.
339 
340 template<typename Scalar,typename NullaryOp,
341          bool has_nullary = has_nullary_operator<NullaryOp>::value,
342          bool has_unary   = has_unary_operator<NullaryOp>::value,
343          bool has_binary  = has_binary_operator<NullaryOp>::value>
344 struct nullary_wrapper
345 {
346   template <typename IndexType>
347   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const { return op(i,j); }
348   template <typename IndexType>
349   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const { return op(i); }
350 
351   template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const { return op.template packetOp<T>(i,j); }
352   template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const { return op.template packetOp<T>(i); }
353 };
354 
355 template<typename Scalar,typename NullaryOp>
356 struct nullary_wrapper<Scalar,NullaryOp,true,false,false>
357 {
358   template <typename IndexType>
359   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType=0, IndexType=0) const { return op(); }
360   template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType=0, IndexType=0) const { return op.template packetOp<T>(); }
361 };
362 
363 template<typename Scalar,typename NullaryOp>
364 struct nullary_wrapper<Scalar,NullaryOp,false,false,true>
365 {
366   template <typename IndexType>
367   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j=0) const { return op(i,j); }
368   template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j=0) const { return op.template packetOp<T>(i,j); }
369 };
370 
371 // We need the following specialization for vector-only functors assigned to a runtime vector,
372 // for instance, using linspace and assigning a RowVectorXd to a MatrixXd or even a row of a MatrixXd.
373 // In this case, i==0 and j is used for the actual iteration.
374 template<typename Scalar,typename NullaryOp>
375 struct nullary_wrapper<Scalar,NullaryOp,false,true,false>
376 {
377   template <typename IndexType>
378   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const {
379     eigen_assert(i==0 || j==0);
380     return op(i+j);
381   }
382   template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const {
383     eigen_assert(i==0 || j==0);
384     return op.template packetOp<T>(i+j);
385   }
386 
387   template <typename IndexType>
388   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const { return op(i); }
389   template <typename T, typename IndexType>
390   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const { return op.template packetOp<T>(i); }
391 };
392 
393 template<typename Scalar,typename NullaryOp>
394 struct nullary_wrapper<Scalar,NullaryOp,false,false,false> {};
395 
396 #if 0 && EIGEN_COMP_MSVC>0
397 // Disable this ugly workaround. This is now handled in traits<Ref>::match,
398 // but this piece of code might still become handly if some other weird compilation
399 // erros pop up again.
400 
401 // MSVC exhibits a weird compilation error when
402 // compiling:
403 //    Eigen::MatrixXf A = MatrixXf::Random(3,3);
404 //    Ref<const MatrixXf> R = 2.f*A;
405 // and that has_*ary_operator<scalar_constant_op<float>> have not been instantiated yet.
406 // The "problem" is that evaluator<2.f*A> is instantiated by traits<Ref>::match<2.f*A>
407 // and at that time has_*ary_operator<T> returns true regardless of T.
408 // Then nullary_wrapper is badly instantiated as nullary_wrapper<.,.,true,true,true>.
409 // The trick is thus to defer the proper instantiation of nullary_wrapper when coeff(),
410 // and packet() are really instantiated as implemented below:
411 
412 // This is a simple wrapper around Index to enforce the re-instantiation of
413 // has_*ary_operator when needed.
414 template<typename T> struct nullary_wrapper_workaround_msvc {
415   nullary_wrapper_workaround_msvc(const T&);
416   operator T()const;
417 };
418 
419 template<typename Scalar,typename NullaryOp>
420 struct nullary_wrapper<Scalar,NullaryOp,true,true,true>
421 {
422   template <typename IndexType>
423   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const {
424     return nullary_wrapper<Scalar,NullaryOp,
425     has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
426     has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
427     has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().operator()(op,i,j);
428   }
429   template <typename IndexType>
430   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const {
431     return nullary_wrapper<Scalar,NullaryOp,
432     has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
433     has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
434     has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().operator()(op,i);
435   }
436 
437   template <typename T, typename IndexType>
438   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const {
439     return nullary_wrapper<Scalar,NullaryOp,
440     has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
441     has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
442     has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().template packetOp<T>(op,i,j);
443   }
444   template <typename T, typename IndexType>
445   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {
446     return nullary_wrapper<Scalar,NullaryOp,
447     has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
448     has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
449     has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().template packetOp<T>(op,i);
450   }
451 };
452 #endif // MSVC workaround
453 
454 template<typename NullaryOp, typename PlainObjectType>
455 struct evaluator<CwiseNullaryOp<NullaryOp,PlainObjectType> >
456   : evaluator_base<CwiseNullaryOp<NullaryOp,PlainObjectType> >
457 {
458   typedef CwiseNullaryOp<NullaryOp,PlainObjectType> XprType;
459   typedef typename internal::remove_all<PlainObjectType>::type PlainObjectTypeCleaned;
460 
461   enum {
462     CoeffReadCost = internal::functor_traits<NullaryOp>::Cost,
463 
464     Flags = (evaluator<PlainObjectTypeCleaned>::Flags
465           &  (  HereditaryBits
466               | (functor_has_linear_access<NullaryOp>::ret  ? LinearAccessBit : 0)
467               | (functor_traits<NullaryOp>::PacketAccess    ? PacketAccessBit : 0)))
468           | (functor_traits<NullaryOp>::IsRepeatable ? 0 : EvalBeforeNestingBit),
469     Alignment = AlignedMax
470   };
471 
472   EIGEN_DEVICE_FUNC explicit evaluator(const XprType& n)
473     : m_functor(n.functor()), m_wrapper()
474   {
475     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
476   }
477 
478   typedef typename XprType::CoeffReturnType CoeffReturnType;
479 
480   template <typename IndexType>
481   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
482   CoeffReturnType coeff(IndexType row, IndexType col) const
483   {
484     return m_wrapper(m_functor, row, col);
485   }
486 
487   template <typename IndexType>
488   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
489   CoeffReturnType coeff(IndexType index) const
490   {
491     return m_wrapper(m_functor,index);
492   }
493 
494   template<int LoadMode, typename PacketType, typename IndexType>
495   EIGEN_STRONG_INLINE
496   PacketType packet(IndexType row, IndexType col) const
497   {
498     return m_wrapper.template packetOp<PacketType>(m_functor, row, col);
499   }
500 
501   template<int LoadMode, typename PacketType, typename IndexType>
502   EIGEN_STRONG_INLINE
503   PacketType packet(IndexType index) const
504   {
505     return m_wrapper.template packetOp<PacketType>(m_functor, index);
506   }
507 
508 protected:
509   const NullaryOp m_functor;
510   const internal::nullary_wrapper<CoeffReturnType,NullaryOp> m_wrapper;
511 };
512 
513 // -------------------- CwiseUnaryOp --------------------
514 
515 template<typename UnaryOp, typename ArgType>
516 struct unary_evaluator<CwiseUnaryOp<UnaryOp, ArgType>, IndexBased >
517   : evaluator_base<CwiseUnaryOp<UnaryOp, ArgType> >
518 {
519   typedef CwiseUnaryOp<UnaryOp, ArgType> XprType;
520 
521   enum {
522     CoeffReadCost = evaluator<ArgType>::CoeffReadCost + functor_traits<UnaryOp>::Cost,
523 
524     Flags = evaluator<ArgType>::Flags
525           & (HereditaryBits | LinearAccessBit | (functor_traits<UnaryOp>::PacketAccess ? PacketAccessBit : 0)),
526     Alignment = evaluator<ArgType>::Alignment
527   };
528 
529   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
530   explicit unary_evaluator(const XprType& op)
531     : m_functor(op.functor()),
532       m_argImpl(op.nestedExpression())
533   {
534     EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<UnaryOp>::Cost);
535     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
536   }
537 
538   typedef typename XprType::CoeffReturnType CoeffReturnType;
539 
540   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
541   CoeffReturnType coeff(Index row, Index col) const
542   {
543     return m_functor(m_argImpl.coeff(row, col));
544   }
545 
546   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
547   CoeffReturnType coeff(Index index) const
548   {
549     return m_functor(m_argImpl.coeff(index));
550   }
551 
552   template<int LoadMode, typename PacketType>
553   EIGEN_STRONG_INLINE
554   PacketType packet(Index row, Index col) const
555   {
556     return m_functor.packetOp(m_argImpl.template packet<LoadMode, PacketType>(row, col));
557   }
558 
559   template<int LoadMode, typename PacketType>
560   EIGEN_STRONG_INLINE
561   PacketType packet(Index index) const
562   {
563     return m_functor.packetOp(m_argImpl.template packet<LoadMode, PacketType>(index));
564   }
565 
566 protected:
567   const UnaryOp m_functor;
568   evaluator<ArgType> m_argImpl;
569 };
570 
571 // -------------------- CwiseTernaryOp --------------------
572 
573 // this is a ternary expression
574 template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
575 struct evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >
576   : public ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >
577 {
578   typedef CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> XprType;
579   typedef ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> > Base;
580 
581   EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {}
582 };
583 
584 template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
585 struct ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>, IndexBased, IndexBased>
586   : evaluator_base<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >
587 {
588   typedef CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> XprType;
589 
590   enum {
591     CoeffReadCost = evaluator<Arg1>::CoeffReadCost + evaluator<Arg2>::CoeffReadCost + evaluator<Arg3>::CoeffReadCost + functor_traits<TernaryOp>::Cost,
592 
593     Arg1Flags = evaluator<Arg1>::Flags,
594     Arg2Flags = evaluator<Arg2>::Flags,
595     Arg3Flags = evaluator<Arg3>::Flags,
596     SameType = is_same<typename Arg1::Scalar,typename Arg2::Scalar>::value && is_same<typename Arg1::Scalar,typename Arg3::Scalar>::value,
597     StorageOrdersAgree = (int(Arg1Flags)&RowMajorBit)==(int(Arg2Flags)&RowMajorBit) && (int(Arg1Flags)&RowMajorBit)==(int(Arg3Flags)&RowMajorBit),
598     Flags0 = (int(Arg1Flags) | int(Arg2Flags) | int(Arg3Flags)) & (
599         HereditaryBits
600         | (int(Arg1Flags) & int(Arg2Flags) & int(Arg3Flags) &
601            ( (StorageOrdersAgree ? LinearAccessBit : 0)
602            | (functor_traits<TernaryOp>::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0)
603            )
604         )
605      ),
606     Flags = (Flags0 & ~RowMajorBit) | (Arg1Flags & RowMajorBit),
607     Alignment = EIGEN_PLAIN_ENUM_MIN(
608         EIGEN_PLAIN_ENUM_MIN(evaluator<Arg1>::Alignment, evaluator<Arg2>::Alignment),
609         evaluator<Arg3>::Alignment)
610   };
611 
612   EIGEN_DEVICE_FUNC explicit ternary_evaluator(const XprType& xpr)
613     : m_functor(xpr.functor()),
614       m_arg1Impl(xpr.arg1()),
615       m_arg2Impl(xpr.arg2()),
616       m_arg3Impl(xpr.arg3())
617   {
618     EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<TernaryOp>::Cost);
619     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
620   }
621 
622   typedef typename XprType::CoeffReturnType CoeffReturnType;
623 
624   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
625   CoeffReturnType coeff(Index row, Index col) const
626   {
627     return m_functor(m_arg1Impl.coeff(row, col), m_arg2Impl.coeff(row, col), m_arg3Impl.coeff(row, col));
628   }
629 
630   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
631   CoeffReturnType coeff(Index index) const
632   {
633     return m_functor(m_arg1Impl.coeff(index), m_arg2Impl.coeff(index), m_arg3Impl.coeff(index));
634   }
635 
636   template<int LoadMode, typename PacketType>
637   EIGEN_STRONG_INLINE
638   PacketType packet(Index row, Index col) const
639   {
640     return m_functor.packetOp(m_arg1Impl.template packet<LoadMode,PacketType>(row, col),
641                               m_arg2Impl.template packet<LoadMode,PacketType>(row, col),
642                               m_arg3Impl.template packet<LoadMode,PacketType>(row, col));
643   }
644 
645   template<int LoadMode, typename PacketType>
646   EIGEN_STRONG_INLINE
647   PacketType packet(Index index) const
648   {
649     return m_functor.packetOp(m_arg1Impl.template packet<LoadMode,PacketType>(index),
650                               m_arg2Impl.template packet<LoadMode,PacketType>(index),
651                               m_arg3Impl.template packet<LoadMode,PacketType>(index));
652   }
653 
654 protected:
655   const TernaryOp m_functor;
656   evaluator<Arg1> m_arg1Impl;
657   evaluator<Arg2> m_arg2Impl;
658   evaluator<Arg3> m_arg3Impl;
659 };
660 
661 // -------------------- CwiseBinaryOp --------------------
662 
663 // this is a binary expression
664 template<typename BinaryOp, typename Lhs, typename Rhs>
665 struct evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
666   : public binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
667 {
668   typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
669   typedef binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > Base;
670 
671   EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {}
672 };
673 
674 template<typename BinaryOp, typename Lhs, typename Rhs>
675 struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IndexBased, IndexBased>
676   : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
677 {
678   typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
679 
680   enum {
681     CoeffReadCost = evaluator<Lhs>::CoeffReadCost + evaluator<Rhs>::CoeffReadCost + functor_traits<BinaryOp>::Cost,
682 
683     LhsFlags = evaluator<Lhs>::Flags,
684     RhsFlags = evaluator<Rhs>::Flags,
685     SameType = is_same<typename Lhs::Scalar,typename Rhs::Scalar>::value,
686     StorageOrdersAgree = (int(LhsFlags)&RowMajorBit)==(int(RhsFlags)&RowMajorBit),
687     Flags0 = (int(LhsFlags) | int(RhsFlags)) & (
688         HereditaryBits
689       | (int(LhsFlags) & int(RhsFlags) &
690            ( (StorageOrdersAgree ? LinearAccessBit : 0)
691            | (functor_traits<BinaryOp>::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0)
692            )
693         )
694      ),
695     Flags = (Flags0 & ~RowMajorBit) | (LhsFlags & RowMajorBit),
696     Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<Lhs>::Alignment,evaluator<Rhs>::Alignment)
697   };
698 
699   EIGEN_DEVICE_FUNC explicit binary_evaluator(const XprType& xpr)
700     : m_functor(xpr.functor()),
701       m_lhsImpl(xpr.lhs()),
702       m_rhsImpl(xpr.rhs())
703   {
704     EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
705     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
706   }
707 
708   typedef typename XprType::CoeffReturnType CoeffReturnType;
709 
710   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
711   CoeffReturnType coeff(Index row, Index col) const
712   {
713     return m_functor(m_lhsImpl.coeff(row, col), m_rhsImpl.coeff(row, col));
714   }
715 
716   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
717   CoeffReturnType coeff(Index index) const
718   {
719     return m_functor(m_lhsImpl.coeff(index), m_rhsImpl.coeff(index));
720   }
721 
722   template<int LoadMode, typename PacketType>
723   EIGEN_STRONG_INLINE
724   PacketType packet(Index row, Index col) const
725   {
726     return m_functor.packetOp(m_lhsImpl.template packet<LoadMode,PacketType>(row, col),
727                               m_rhsImpl.template packet<LoadMode,PacketType>(row, col));
728   }
729 
730   template<int LoadMode, typename PacketType>
731   EIGEN_STRONG_INLINE
732   PacketType packet(Index index) const
733   {
734     return m_functor.packetOp(m_lhsImpl.template packet<LoadMode,PacketType>(index),
735                               m_rhsImpl.template packet<LoadMode,PacketType>(index));
736   }
737 
738 protected:
739   const BinaryOp m_functor;
740   evaluator<Lhs> m_lhsImpl;
741   evaluator<Rhs> m_rhsImpl;
742 };
743 
744 // -------------------- CwiseUnaryView --------------------
745 
746 template<typename UnaryOp, typename ArgType>
747 struct unary_evaluator<CwiseUnaryView<UnaryOp, ArgType>, IndexBased>
748   : evaluator_base<CwiseUnaryView<UnaryOp, ArgType> >
749 {
750   typedef CwiseUnaryView<UnaryOp, ArgType> XprType;
751 
752   enum {
753     CoeffReadCost = evaluator<ArgType>::CoeffReadCost + functor_traits<UnaryOp>::Cost,
754 
755     Flags = (evaluator<ArgType>::Flags & (HereditaryBits | LinearAccessBit | DirectAccessBit)),
756 
757     Alignment = 0 // FIXME it is not very clear why alignment is necessarily lost...
758   };
759 
760   EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op)
761     : m_unaryOp(op.functor()),
762       m_argImpl(op.nestedExpression())
763   {
764     EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<UnaryOp>::Cost);
765     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
766   }
767 
768   typedef typename XprType::Scalar Scalar;
769   typedef typename XprType::CoeffReturnType CoeffReturnType;
770 
771   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
772   CoeffReturnType coeff(Index row, Index col) const
773   {
774     return m_unaryOp(m_argImpl.coeff(row, col));
775   }
776 
777   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
778   CoeffReturnType coeff(Index index) const
779   {
780     return m_unaryOp(m_argImpl.coeff(index));
781   }
782 
783   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
784   Scalar& coeffRef(Index row, Index col)
785   {
786     return m_unaryOp(m_argImpl.coeffRef(row, col));
787   }
788 
789   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
790   Scalar& coeffRef(Index index)
791   {
792     return m_unaryOp(m_argImpl.coeffRef(index));
793   }
794 
795 protected:
796   const UnaryOp m_unaryOp;
797   evaluator<ArgType> m_argImpl;
798 };
799 
800 // -------------------- Map --------------------
801 
802 // FIXME perhaps the PlainObjectType could be provided by Derived::PlainObject ?
803 // but that might complicate template specialization
804 template<typename Derived, typename PlainObjectType>
805 struct mapbase_evaluator;
806 
807 template<typename Derived, typename PlainObjectType>
808 struct mapbase_evaluator : evaluator_base<Derived>
809 {
810   typedef Derived  XprType;
811   typedef typename XprType::PointerType PointerType;
812   typedef typename XprType::Scalar Scalar;
813   typedef typename XprType::CoeffReturnType CoeffReturnType;
814 
815   enum {
816     IsRowMajor = XprType::RowsAtCompileTime,
817     ColsAtCompileTime = XprType::ColsAtCompileTime,
818     CoeffReadCost = NumTraits<Scalar>::ReadCost
819   };
820 
821   EIGEN_DEVICE_FUNC explicit mapbase_evaluator(const XprType& map)
822     : m_data(const_cast<PointerType>(map.data())),
823       m_innerStride(map.innerStride()),
824       m_outerStride(map.outerStride())
825   {
826     EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(evaluator<Derived>::Flags&PacketAccessBit, internal::inner_stride_at_compile_time<Derived>::ret==1),
827                         PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1);
828     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
829   }
830 
831   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
832   CoeffReturnType coeff(Index row, Index col) const
833   {
834     return m_data[col * colStride() + row * rowStride()];
835   }
836 
837   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
838   CoeffReturnType coeff(Index index) const
839   {
840     return m_data[index * m_innerStride.value()];
841   }
842 
843   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
844   Scalar& coeffRef(Index row, Index col)
845   {
846     return m_data[col * colStride() + row * rowStride()];
847   }
848 
849   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
850   Scalar& coeffRef(Index index)
851   {
852     return m_data[index * m_innerStride.value()];
853   }
854 
855   template<int LoadMode, typename PacketType>
856   EIGEN_STRONG_INLINE
857   PacketType packet(Index row, Index col) const
858   {
859     PointerType ptr = m_data + row * rowStride() + col * colStride();
860     return internal::ploadt<PacketType, LoadMode>(ptr);
861   }
862 
863   template<int LoadMode, typename PacketType>
864   EIGEN_STRONG_INLINE
865   PacketType packet(Index index) const
866   {
867     return internal::ploadt<PacketType, LoadMode>(m_data + index * m_innerStride.value());
868   }
869 
870   template<int StoreMode, typename PacketType>
871   EIGEN_STRONG_INLINE
872   void writePacket(Index row, Index col, const PacketType& x)
873   {
874     PointerType ptr = m_data + row * rowStride() + col * colStride();
875     return internal::pstoret<Scalar, PacketType, StoreMode>(ptr, x);
876   }
877 
878   template<int StoreMode, typename PacketType>
879   EIGEN_STRONG_INLINE
880   void writePacket(Index index, const PacketType& x)
881   {
882     internal::pstoret<Scalar, PacketType, StoreMode>(m_data + index * m_innerStride.value(), x);
883   }
884 protected:
885   EIGEN_DEVICE_FUNC
886   inline Index rowStride() const { return XprType::IsRowMajor ? m_outerStride.value() : m_innerStride.value(); }
887   EIGEN_DEVICE_FUNC
888   inline Index colStride() const { return XprType::IsRowMajor ? m_innerStride.value() : m_outerStride.value(); }
889 
890   PointerType m_data;
891   const internal::variable_if_dynamic<Index, XprType::InnerStrideAtCompileTime> m_innerStride;
892   const internal::variable_if_dynamic<Index, XprType::OuterStrideAtCompileTime> m_outerStride;
893 };
894 
895 template<typename PlainObjectType, int MapOptions, typename StrideType>
896 struct evaluator<Map<PlainObjectType, MapOptions, StrideType> >
897   : public mapbase_evaluator<Map<PlainObjectType, MapOptions, StrideType>, PlainObjectType>
898 {
899   typedef Map<PlainObjectType, MapOptions, StrideType> XprType;
900   typedef typename XprType::Scalar Scalar;
901   // TODO: should check for smaller packet types once we can handle multi-sized packet types
902   typedef typename packet_traits<Scalar>::type PacketScalar;
903 
904   enum {
905     InnerStrideAtCompileTime = StrideType::InnerStrideAtCompileTime == 0
906                              ? int(PlainObjectType::InnerStrideAtCompileTime)
907                              : int(StrideType::InnerStrideAtCompileTime),
908     OuterStrideAtCompileTime = StrideType::OuterStrideAtCompileTime == 0
909                              ? int(PlainObjectType::OuterStrideAtCompileTime)
910                              : int(StrideType::OuterStrideAtCompileTime),
911     HasNoInnerStride = InnerStrideAtCompileTime == 1,
912     HasNoOuterStride = StrideType::OuterStrideAtCompileTime == 0,
913     HasNoStride = HasNoInnerStride && HasNoOuterStride,
914     IsDynamicSize = PlainObjectType::SizeAtCompileTime==Dynamic,
915 
916     PacketAccessMask = bool(HasNoInnerStride) ? ~int(0) : ~int(PacketAccessBit),
917     LinearAccessMask = bool(HasNoStride) || bool(PlainObjectType::IsVectorAtCompileTime) ? ~int(0) : ~int(LinearAccessBit),
918     Flags = int( evaluator<PlainObjectType>::Flags) & (LinearAccessMask&PacketAccessMask),
919 
920     Alignment = int(MapOptions)&int(AlignedMask)
921   };
922 
923   EIGEN_DEVICE_FUNC explicit evaluator(const XprType& map)
924     : mapbase_evaluator<XprType, PlainObjectType>(map)
925   { }
926 };
927 
928 // -------------------- Ref --------------------
929 
930 template<typename PlainObjectType, int RefOptions, typename StrideType>
931 struct evaluator<Ref<PlainObjectType, RefOptions, StrideType> >
932   : public mapbase_evaluator<Ref<PlainObjectType, RefOptions, StrideType>, PlainObjectType>
933 {
934   typedef Ref<PlainObjectType, RefOptions, StrideType> XprType;
935 
936   enum {
937     Flags = evaluator<Map<PlainObjectType, RefOptions, StrideType> >::Flags,
938     Alignment = evaluator<Map<PlainObjectType, RefOptions, StrideType> >::Alignment
939   };
940 
941   EIGEN_DEVICE_FUNC explicit evaluator(const XprType& ref)
942     : mapbase_evaluator<XprType, PlainObjectType>(ref)
943   { }
944 };
945 
946 // -------------------- Block --------------------
947 
948 template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel,
949          bool HasDirectAccess = internal::has_direct_access<ArgType>::ret> struct block_evaluator;
950 
951 template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
952 struct evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel> >
953   : block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel>
954 {
955   typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
956   typedef typename XprType::Scalar Scalar;
957   // TODO: should check for smaller packet types once we can handle multi-sized packet types
958   typedef typename packet_traits<Scalar>::type PacketScalar;
959 
960   enum {
961     CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
962 
963     RowsAtCompileTime = traits<XprType>::RowsAtCompileTime,
964     ColsAtCompileTime = traits<XprType>::ColsAtCompileTime,
965     MaxRowsAtCompileTime = traits<XprType>::MaxRowsAtCompileTime,
966     MaxColsAtCompileTime = traits<XprType>::MaxColsAtCompileTime,
967 
968     ArgTypeIsRowMajor = (int(evaluator<ArgType>::Flags)&RowMajorBit) != 0,
969     IsRowMajor = (MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1) ? 1
970                : (MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1) ? 0
971                : ArgTypeIsRowMajor,
972     HasSameStorageOrderAsArgType = (IsRowMajor == ArgTypeIsRowMajor),
973     InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
974     InnerStrideAtCompileTime = HasSameStorageOrderAsArgType
975                              ? int(inner_stride_at_compile_time<ArgType>::ret)
976                              : int(outer_stride_at_compile_time<ArgType>::ret),
977     OuterStrideAtCompileTime = HasSameStorageOrderAsArgType
978                              ? int(outer_stride_at_compile_time<ArgType>::ret)
979                              : int(inner_stride_at_compile_time<ArgType>::ret),
980     MaskPacketAccessBit = (InnerStrideAtCompileTime == 1) ? PacketAccessBit : 0,
981 
982     FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1 || (InnerPanel && (evaluator<ArgType>::Flags&LinearAccessBit))) ? LinearAccessBit : 0,
983     FlagsRowMajorBit = XprType::Flags&RowMajorBit,
984     Flags0 = evaluator<ArgType>::Flags & ( (HereditaryBits & ~RowMajorBit) |
985                                            DirectAccessBit |
986                                            MaskPacketAccessBit),
987     Flags = Flags0 | FlagsLinearAccessBit | FlagsRowMajorBit,
988 
989     PacketAlignment = unpacket_traits<PacketScalar>::alignment,
990     Alignment0 = (InnerPanel && (OuterStrideAtCompileTime!=Dynamic) && (((OuterStrideAtCompileTime * int(sizeof(Scalar))) % int(PacketAlignment)) == 0)) ? int(PacketAlignment) : 0,
991     Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<ArgType>::Alignment, Alignment0)
992   };
993   typedef block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel> block_evaluator_type;
994   EIGEN_DEVICE_FUNC explicit evaluator(const XprType& block) : block_evaluator_type(block)
995   {
996     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
997   }
998 };
999 
1000 // no direct-access => dispatch to a unary evaluator
1001 template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
1002 struct block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel, /*HasDirectAccess*/ false>
1003   : unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel> >
1004 {
1005   typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
1006 
1007   EIGEN_DEVICE_FUNC explicit block_evaluator(const XprType& block)
1008     : unary_evaluator<XprType>(block)
1009   {}
1010 };
1011 
1012 template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
1013 struct unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>, IndexBased>
1014   : evaluator_base<Block<ArgType, BlockRows, BlockCols, InnerPanel> >
1015 {
1016   typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
1017 
1018   EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& block)
1019     : m_argImpl(block.nestedExpression()),
1020       m_startRow(block.startRow()),
1021       m_startCol(block.startCol())
1022   { }
1023 
1024   typedef typename XprType::Scalar Scalar;
1025   typedef typename XprType::CoeffReturnType CoeffReturnType;
1026 
1027   enum {
1028     RowsAtCompileTime = XprType::RowsAtCompileTime
1029   };
1030 
1031   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1032   CoeffReturnType coeff(Index row, Index col) const
1033   {
1034     return m_argImpl.coeff(m_startRow.value() + row, m_startCol.value() + col);
1035   }
1036 
1037   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1038   CoeffReturnType coeff(Index index) const
1039   {
1040     return coeff(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0);
1041   }
1042 
1043   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1044   Scalar& coeffRef(Index row, Index col)
1045   {
1046     return m_argImpl.coeffRef(m_startRow.value() + row, m_startCol.value() + col);
1047   }
1048 
1049   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1050   Scalar& coeffRef(Index index)
1051   {
1052     return coeffRef(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0);
1053   }
1054 
1055   template<int LoadMode, typename PacketType>
1056   EIGEN_STRONG_INLINE
1057   PacketType packet(Index row, Index col) const
1058   {
1059     return m_argImpl.template packet<LoadMode,PacketType>(m_startRow.value() + row, m_startCol.value() + col);
1060   }
1061 
1062   template<int LoadMode, typename PacketType>
1063   EIGEN_STRONG_INLINE
1064   PacketType packet(Index index) const
1065   {
1066     return packet<LoadMode,PacketType>(RowsAtCompileTime == 1 ? 0 : index,
1067                                        RowsAtCompileTime == 1 ? index : 0);
1068   }
1069 
1070   template<int StoreMode, typename PacketType>
1071   EIGEN_STRONG_INLINE
1072   void writePacket(Index row, Index col, const PacketType& x)
1073   {
1074     return m_argImpl.template writePacket<StoreMode,PacketType>(m_startRow.value() + row, m_startCol.value() + col, x);
1075   }
1076 
1077   template<int StoreMode, typename PacketType>
1078   EIGEN_STRONG_INLINE
1079   void writePacket(Index index, const PacketType& x)
1080   {
1081     return writePacket<StoreMode,PacketType>(RowsAtCompileTime == 1 ? 0 : index,
1082                                              RowsAtCompileTime == 1 ? index : 0,
1083                                              x);
1084   }
1085 
1086 protected:
1087   evaluator<ArgType> m_argImpl;
1088   const variable_if_dynamic<Index, (ArgType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
1089   const variable_if_dynamic<Index, (ArgType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
1090 };
1091 
1092 // TODO: This evaluator does not actually use the child evaluator;
1093 // all action is via the data() as returned by the Block expression.
1094 
1095 template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
1096 struct block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel, /* HasDirectAccess */ true>
1097   : mapbase_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>,
1098                       typename Block<ArgType, BlockRows, BlockCols, InnerPanel>::PlainObject>
1099 {
1100   typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
1101   typedef typename XprType::Scalar Scalar;
1102 
1103   EIGEN_DEVICE_FUNC explicit block_evaluator(const XprType& block)
1104     : mapbase_evaluator<XprType, typename XprType::PlainObject>(block)
1105   {
1106     // TODO: for the 3.3 release, this should be turned to an internal assertion, but let's keep it as is for the beta lifetime
1107     eigen_assert(((internal::UIntPtr(block.data()) % EIGEN_PLAIN_ENUM_MAX(1,evaluator<XprType>::Alignment)) == 0) && "data is not aligned");
1108   }
1109 };
1110 
1111 
1112 // -------------------- Select --------------------
1113 // NOTE shall we introduce a ternary_evaluator?
1114 
1115 // TODO enable vectorization for Select
1116 template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType>
1117 struct evaluator<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
1118   : evaluator_base<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
1119 {
1120   typedef Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> XprType;
1121   enum {
1122     CoeffReadCost = evaluator<ConditionMatrixType>::CoeffReadCost
1123                   + EIGEN_PLAIN_ENUM_MAX(evaluator<ThenMatrixType>::CoeffReadCost,
1124                                          evaluator<ElseMatrixType>::CoeffReadCost),
1125 
1126     Flags = (unsigned int)evaluator<ThenMatrixType>::Flags & evaluator<ElseMatrixType>::Flags & HereditaryBits,
1127 
1128     Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<ThenMatrixType>::Alignment, evaluator<ElseMatrixType>::Alignment)
1129   };
1130 
1131   EIGEN_DEVICE_FUNC explicit evaluator(const XprType& select)
1132     : m_conditionImpl(select.conditionMatrix()),
1133       m_thenImpl(select.thenMatrix()),
1134       m_elseImpl(select.elseMatrix())
1135   {
1136     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
1137   }
1138 
1139   typedef typename XprType::CoeffReturnType CoeffReturnType;
1140 
1141   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1142   CoeffReturnType coeff(Index row, Index col) const
1143   {
1144     if (m_conditionImpl.coeff(row, col))
1145       return m_thenImpl.coeff(row, col);
1146     else
1147       return m_elseImpl.coeff(row, col);
1148   }
1149 
1150   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1151   CoeffReturnType coeff(Index index) const
1152   {
1153     if (m_conditionImpl.coeff(index))
1154       return m_thenImpl.coeff(index);
1155     else
1156       return m_elseImpl.coeff(index);
1157   }
1158 
1159 protected:
1160   evaluator<ConditionMatrixType> m_conditionImpl;
1161   evaluator<ThenMatrixType> m_thenImpl;
1162   evaluator<ElseMatrixType> m_elseImpl;
1163 };
1164 
1165 
1166 // -------------------- Replicate --------------------
1167 
1168 template<typename ArgType, int RowFactor, int ColFactor>
1169 struct unary_evaluator<Replicate<ArgType, RowFactor, ColFactor> >
1170   : evaluator_base<Replicate<ArgType, RowFactor, ColFactor> >
1171 {
1172   typedef Replicate<ArgType, RowFactor, ColFactor> XprType;
1173   typedef typename XprType::CoeffReturnType CoeffReturnType;
1174   enum {
1175     Factor = (RowFactor==Dynamic || ColFactor==Dynamic) ? Dynamic : RowFactor*ColFactor
1176   };
1177   typedef typename internal::nested_eval<ArgType,Factor>::type ArgTypeNested;
1178   typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNestedCleaned;
1179 
1180   enum {
1181     CoeffReadCost = evaluator<ArgTypeNestedCleaned>::CoeffReadCost,
1182     LinearAccessMask = XprType::IsVectorAtCompileTime ? LinearAccessBit : 0,
1183     Flags = (evaluator<ArgTypeNestedCleaned>::Flags & (HereditaryBits|LinearAccessMask) & ~RowMajorBit) | (traits<XprType>::Flags & RowMajorBit),
1184 
1185     Alignment = evaluator<ArgTypeNestedCleaned>::Alignment
1186   };
1187 
1188   EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& replicate)
1189     : m_arg(replicate.nestedExpression()),
1190       m_argImpl(m_arg),
1191       m_rows(replicate.nestedExpression().rows()),
1192       m_cols(replicate.nestedExpression().cols())
1193   {}
1194 
1195   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1196   CoeffReturnType coeff(Index row, Index col) const
1197   {
1198     // try to avoid using modulo; this is a pure optimization strategy
1199     const Index actual_row = internal::traits<XprType>::RowsAtCompileTime==1 ? 0
1200                            : RowFactor==1 ? row
1201                            : row % m_rows.value();
1202     const Index actual_col = internal::traits<XprType>::ColsAtCompileTime==1 ? 0
1203                            : ColFactor==1 ? col
1204                            : col % m_cols.value();
1205 
1206     return m_argImpl.coeff(actual_row, actual_col);
1207   }
1208 
1209   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1210   CoeffReturnType coeff(Index index) const
1211   {
1212     // try to avoid using modulo; this is a pure optimization strategy
1213     const Index actual_index = internal::traits<XprType>::RowsAtCompileTime==1
1214                                   ? (ColFactor==1 ?  index : index%m_cols.value())
1215                                   : (RowFactor==1 ?  index : index%m_rows.value());
1216 
1217     return m_argImpl.coeff(actual_index);
1218   }
1219 
1220   template<int LoadMode, typename PacketType>
1221   EIGEN_STRONG_INLINE
1222   PacketType packet(Index row, Index col) const
1223   {
1224     const Index actual_row = internal::traits<XprType>::RowsAtCompileTime==1 ? 0
1225                            : RowFactor==1 ? row
1226                            : row % m_rows.value();
1227     const Index actual_col = internal::traits<XprType>::ColsAtCompileTime==1 ? 0
1228                            : ColFactor==1 ? col
1229                            : col % m_cols.value();
1230 
1231     return m_argImpl.template packet<LoadMode,PacketType>(actual_row, actual_col);
1232   }
1233 
1234   template<int LoadMode, typename PacketType>
1235   EIGEN_STRONG_INLINE
1236   PacketType packet(Index index) const
1237   {
1238     const Index actual_index = internal::traits<XprType>::RowsAtCompileTime==1
1239                                   ? (ColFactor==1 ?  index : index%m_cols.value())
1240                                   : (RowFactor==1 ?  index : index%m_rows.value());
1241 
1242     return m_argImpl.template packet<LoadMode,PacketType>(actual_index);
1243   }
1244 
1245 protected:
1246   const ArgTypeNested m_arg;
1247   evaluator<ArgTypeNestedCleaned> m_argImpl;
1248   const variable_if_dynamic<Index, ArgType::RowsAtCompileTime> m_rows;
1249   const variable_if_dynamic<Index, ArgType::ColsAtCompileTime> m_cols;
1250 };
1251 
1252 
1253 // -------------------- PartialReduxExpr --------------------
1254 
1255 template< typename ArgType, typename MemberOp, int Direction>
1256 struct evaluator<PartialReduxExpr<ArgType, MemberOp, Direction> >
1257   : evaluator_base<PartialReduxExpr<ArgType, MemberOp, Direction> >
1258 {
1259   typedef PartialReduxExpr<ArgType, MemberOp, Direction> XprType;
1260   typedef typename internal::nested_eval<ArgType,1>::type ArgTypeNested;
1261   typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNestedCleaned;
1262   typedef typename ArgType::Scalar InputScalar;
1263   typedef typename XprType::Scalar Scalar;
1264   enum {
1265     TraversalSize = Direction==int(Vertical) ? int(ArgType::RowsAtCompileTime) :  int(ArgType::ColsAtCompileTime)
1266   };
1267   typedef typename MemberOp::template Cost<InputScalar,int(TraversalSize)> CostOpType;
1268   enum {
1269     CoeffReadCost = TraversalSize==Dynamic ? HugeCost
1270                   : TraversalSize * evaluator<ArgType>::CoeffReadCost + int(CostOpType::value),
1271 
1272     Flags = (traits<XprType>::Flags&RowMajorBit) | (evaluator<ArgType>::Flags&(HereditaryBits&(~RowMajorBit))) | LinearAccessBit,
1273 
1274     Alignment = 0 // FIXME this will need to be improved once PartialReduxExpr is vectorized
1275   };
1276 
1277   EIGEN_DEVICE_FUNC explicit evaluator(const XprType xpr)
1278     : m_arg(xpr.nestedExpression()), m_functor(xpr.functor())
1279   {
1280     EIGEN_INTERNAL_CHECK_COST_VALUE(TraversalSize==Dynamic ? HugeCost : int(CostOpType::value));
1281     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
1282   }
1283 
1284   typedef typename XprType::CoeffReturnType CoeffReturnType;
1285 
1286   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1287   const Scalar coeff(Index i, Index j) const
1288   {
1289     if (Direction==Vertical)
1290       return m_functor(m_arg.col(j));
1291     else
1292       return m_functor(m_arg.row(i));
1293   }
1294 
1295   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1296   const Scalar coeff(Index index) const
1297   {
1298     if (Direction==Vertical)
1299       return m_functor(m_arg.col(index));
1300     else
1301       return m_functor(m_arg.row(index));
1302   }
1303 
1304 protected:
1305   typename internal::add_const_on_value_type<ArgTypeNested>::type m_arg;
1306   const MemberOp m_functor;
1307 };
1308 
1309 
1310 // -------------------- MatrixWrapper and ArrayWrapper --------------------
1311 //
1312 // evaluator_wrapper_base<T> is a common base class for the
1313 // MatrixWrapper and ArrayWrapper evaluators.
1314 
1315 template<typename XprType>
1316 struct evaluator_wrapper_base
1317   : evaluator_base<XprType>
1318 {
1319   typedef typename remove_all<typename XprType::NestedExpressionType>::type ArgType;
1320   enum {
1321     CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
1322     Flags = evaluator<ArgType>::Flags,
1323     Alignment = evaluator<ArgType>::Alignment
1324   };
1325 
1326   EIGEN_DEVICE_FUNC explicit evaluator_wrapper_base(const ArgType& arg) : m_argImpl(arg) {}
1327 
1328   typedef typename ArgType::Scalar Scalar;
1329   typedef typename ArgType::CoeffReturnType CoeffReturnType;
1330 
1331   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1332   CoeffReturnType coeff(Index row, Index col) const
1333   {
1334     return m_argImpl.coeff(row, col);
1335   }
1336 
1337   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1338   CoeffReturnType coeff(Index index) const
1339   {
1340     return m_argImpl.coeff(index);
1341   }
1342 
1343   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1344   Scalar& coeffRef(Index row, Index col)
1345   {
1346     return m_argImpl.coeffRef(row, col);
1347   }
1348 
1349   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1350   Scalar& coeffRef(Index index)
1351   {
1352     return m_argImpl.coeffRef(index);
1353   }
1354 
1355   template<int LoadMode, typename PacketType>
1356   EIGEN_STRONG_INLINE
1357   PacketType packet(Index row, Index col) const
1358   {
1359     return m_argImpl.template packet<LoadMode,PacketType>(row, col);
1360   }
1361 
1362   template<int LoadMode, typename PacketType>
1363   EIGEN_STRONG_INLINE
1364   PacketType packet(Index index) const
1365   {
1366     return m_argImpl.template packet<LoadMode,PacketType>(index);
1367   }
1368 
1369   template<int StoreMode, typename PacketType>
1370   EIGEN_STRONG_INLINE
1371   void writePacket(Index row, Index col, const PacketType& x)
1372   {
1373     m_argImpl.template writePacket<StoreMode>(row, col, x);
1374   }
1375 
1376   template<int StoreMode, typename PacketType>
1377   EIGEN_STRONG_INLINE
1378   void writePacket(Index index, const PacketType& x)
1379   {
1380     m_argImpl.template writePacket<StoreMode>(index, x);
1381   }
1382 
1383 protected:
1384   evaluator<ArgType> m_argImpl;
1385 };
1386 
1387 template<typename TArgType>
1388 struct unary_evaluator<MatrixWrapper<TArgType> >
1389   : evaluator_wrapper_base<MatrixWrapper<TArgType> >
1390 {
1391   typedef MatrixWrapper<TArgType> XprType;
1392 
1393   EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& wrapper)
1394     : evaluator_wrapper_base<MatrixWrapper<TArgType> >(wrapper.nestedExpression())
1395   { }
1396 };
1397 
1398 template<typename TArgType>
1399 struct unary_evaluator<ArrayWrapper<TArgType> >
1400   : evaluator_wrapper_base<ArrayWrapper<TArgType> >
1401 {
1402   typedef ArrayWrapper<TArgType> XprType;
1403 
1404   EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& wrapper)
1405     : evaluator_wrapper_base<ArrayWrapper<TArgType> >(wrapper.nestedExpression())
1406   { }
1407 };
1408 
1409 
1410 // -------------------- Reverse --------------------
1411 
1412 // defined in Reverse.h:
1413 template<typename PacketType, bool ReversePacket> struct reverse_packet_cond;
1414 
1415 template<typename ArgType, int Direction>
1416 struct unary_evaluator<Reverse<ArgType, Direction> >
1417   : evaluator_base<Reverse<ArgType, Direction> >
1418 {
1419   typedef Reverse<ArgType, Direction> XprType;
1420   typedef typename XprType::Scalar Scalar;
1421   typedef typename XprType::CoeffReturnType CoeffReturnType;
1422 
1423   enum {
1424     IsRowMajor = XprType::IsRowMajor,
1425     IsColMajor = !IsRowMajor,
1426     ReverseRow = (Direction == Vertical)   || (Direction == BothDirections),
1427     ReverseCol = (Direction == Horizontal) || (Direction == BothDirections),
1428     ReversePacket = (Direction == BothDirections)
1429                     || ((Direction == Vertical)   && IsColMajor)
1430                     || ((Direction == Horizontal) && IsRowMajor),
1431 
1432     CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
1433 
1434     // let's enable LinearAccess only with vectorization because of the product overhead
1435     // FIXME enable DirectAccess with negative strides?
1436     Flags0 = evaluator<ArgType>::Flags,
1437     LinearAccess = ( (Direction==BothDirections) && (int(Flags0)&PacketAccessBit) )
1438                   || ((ReverseRow && XprType::ColsAtCompileTime==1) || (ReverseCol && XprType::RowsAtCompileTime==1))
1439                  ? LinearAccessBit : 0,
1440 
1441     Flags = int(Flags0) & (HereditaryBits | PacketAccessBit | LinearAccess),
1442 
1443     Alignment = 0 // FIXME in some rare cases, Alignment could be preserved, like a Vector4f.
1444   };
1445 
1446   EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& reverse)
1447     : m_argImpl(reverse.nestedExpression()),
1448       m_rows(ReverseRow ? reverse.nestedExpression().rows() : 1),
1449       m_cols(ReverseCol ? reverse.nestedExpression().cols() : 1)
1450   { }
1451 
1452   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1453   CoeffReturnType coeff(Index row, Index col) const
1454   {
1455     return m_argImpl.coeff(ReverseRow ? m_rows.value() - row - 1 : row,
1456                            ReverseCol ? m_cols.value() - col - 1 : col);
1457   }
1458 
1459   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1460   CoeffReturnType coeff(Index index) const
1461   {
1462     return m_argImpl.coeff(m_rows.value() * m_cols.value() - index - 1);
1463   }
1464 
1465   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1466   Scalar& coeffRef(Index row, Index col)
1467   {
1468     return m_argImpl.coeffRef(ReverseRow ? m_rows.value() - row - 1 : row,
1469                               ReverseCol ? m_cols.value() - col - 1 : col);
1470   }
1471 
1472   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1473   Scalar& coeffRef(Index index)
1474   {
1475     return m_argImpl.coeffRef(m_rows.value() * m_cols.value() - index - 1);
1476   }
1477 
1478   template<int LoadMode, typename PacketType>
1479   EIGEN_STRONG_INLINE
1480   PacketType packet(Index row, Index col) const
1481   {
1482     enum {
1483       PacketSize = unpacket_traits<PacketType>::size,
1484       OffsetRow  = ReverseRow && IsColMajor ? PacketSize : 1,
1485       OffsetCol  = ReverseCol && IsRowMajor ? PacketSize : 1
1486     };
1487     typedef internal::reverse_packet_cond<PacketType,ReversePacket> reverse_packet;
1488     return reverse_packet::run(m_argImpl.template packet<LoadMode,PacketType>(
1489                                   ReverseRow ? m_rows.value() - row - OffsetRow : row,
1490                                   ReverseCol ? m_cols.value() - col - OffsetCol : col));
1491   }
1492 
1493   template<int LoadMode, typename PacketType>
1494   EIGEN_STRONG_INLINE
1495   PacketType packet(Index index) const
1496   {
1497     enum { PacketSize = unpacket_traits<PacketType>::size };
1498     return preverse(m_argImpl.template packet<LoadMode,PacketType>(m_rows.value() * m_cols.value() - index - PacketSize));
1499   }
1500 
1501   template<int LoadMode, typename PacketType>
1502   EIGEN_STRONG_INLINE
1503   void writePacket(Index row, Index col, const PacketType& x)
1504   {
1505     // FIXME we could factorize some code with packet(i,j)
1506     enum {
1507       PacketSize = unpacket_traits<PacketType>::size,
1508       OffsetRow  = ReverseRow && IsColMajor ? PacketSize : 1,
1509       OffsetCol  = ReverseCol && IsRowMajor ? PacketSize : 1
1510     };
1511     typedef internal::reverse_packet_cond<PacketType,ReversePacket> reverse_packet;
1512     m_argImpl.template writePacket<LoadMode>(
1513                                   ReverseRow ? m_rows.value() - row - OffsetRow : row,
1514                                   ReverseCol ? m_cols.value() - col - OffsetCol : col,
1515                                   reverse_packet::run(x));
1516   }
1517 
1518   template<int LoadMode, typename PacketType>
1519   EIGEN_STRONG_INLINE
1520   void writePacket(Index index, const PacketType& x)
1521   {
1522     enum { PacketSize = unpacket_traits<PacketType>::size };
1523     m_argImpl.template writePacket<LoadMode>
1524       (m_rows.value() * m_cols.value() - index - PacketSize, preverse(x));
1525   }
1526 
1527 protected:
1528   evaluator<ArgType> m_argImpl;
1529 
1530   // If we do not reverse rows, then we do not need to know the number of rows; same for columns
1531   // Nonetheless, in this case it is important to set to 1 such that the coeff(index) method works fine for vectors.
1532   const variable_if_dynamic<Index, ReverseRow ? ArgType::RowsAtCompileTime : 1> m_rows;
1533   const variable_if_dynamic<Index, ReverseCol ? ArgType::ColsAtCompileTime : 1> m_cols;
1534 };
1535 
1536 
1537 // -------------------- Diagonal --------------------
1538 
1539 template<typename ArgType, int DiagIndex>
1540 struct evaluator<Diagonal<ArgType, DiagIndex> >
1541   : evaluator_base<Diagonal<ArgType, DiagIndex> >
1542 {
1543   typedef Diagonal<ArgType, DiagIndex> XprType;
1544 
1545   enum {
1546     CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
1547 
1548     Flags = (unsigned int)(evaluator<ArgType>::Flags & (HereditaryBits | DirectAccessBit) & ~RowMajorBit) | LinearAccessBit,
1549 
1550     Alignment = 0
1551   };
1552 
1553   EIGEN_DEVICE_FUNC explicit evaluator(const XprType& diagonal)
1554     : m_argImpl(diagonal.nestedExpression()),
1555       m_index(diagonal.index())
1556   { }
1557 
1558   typedef typename XprType::Scalar Scalar;
1559   typedef typename XprType::CoeffReturnType CoeffReturnType;
1560 
1561   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1562   CoeffReturnType coeff(Index row, Index) const
1563   {
1564     return m_argImpl.coeff(row + rowOffset(), row + colOffset());
1565   }
1566 
1567   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1568   CoeffReturnType coeff(Index index) const
1569   {
1570     return m_argImpl.coeff(index + rowOffset(), index + colOffset());
1571   }
1572 
1573   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1574   Scalar& coeffRef(Index row, Index)
1575   {
1576     return m_argImpl.coeffRef(row + rowOffset(), row + colOffset());
1577   }
1578 
1579   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
1580   Scalar& coeffRef(Index index)
1581   {
1582     return m_argImpl.coeffRef(index + rowOffset(), index + colOffset());
1583   }
1584 
1585 protected:
1586   evaluator<ArgType> m_argImpl;
1587   const internal::variable_if_dynamicindex<Index, XprType::DiagIndex> m_index;
1588 
1589 private:
1590   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rowOffset() const { return m_index.value() > 0 ? 0 : -m_index.value(); }
1591   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index colOffset() const { return m_index.value() > 0 ? m_index.value() : 0; }
1592 };
1593 
1594 
1595 //----------------------------------------------------------------------
1596 // deprecated code
1597 //----------------------------------------------------------------------
1598 
1599 // -------------------- EvalToTemp --------------------
1600 
1601 // expression class for evaluating nested expression to a temporary
1602 
1603 template<typename ArgType> class EvalToTemp;
1604 
1605 template<typename ArgType>
1606 struct traits<EvalToTemp<ArgType> >
1607   : public traits<ArgType>
1608 { };
1609 
1610 template<typename ArgType>
1611 class EvalToTemp
1612   : public dense_xpr_base<EvalToTemp<ArgType> >::type
1613 {
1614  public:
1615 
1616   typedef typename dense_xpr_base<EvalToTemp>::type Base;
1617   EIGEN_GENERIC_PUBLIC_INTERFACE(EvalToTemp)
1618 
1619   explicit EvalToTemp(const ArgType& arg)
1620     : m_arg(arg)
1621   { }
1622 
1623   const ArgType& arg() const
1624   {
1625     return m_arg;
1626   }
1627 
1628   Index rows() const
1629   {
1630     return m_arg.rows();
1631   }
1632 
1633   Index cols() const
1634   {
1635     return m_arg.cols();
1636   }
1637 
1638  private:
1639   const ArgType& m_arg;
1640 };
1641 
1642 template<typename ArgType>
1643 struct evaluator<EvalToTemp<ArgType> >
1644   : public evaluator<typename ArgType::PlainObject>
1645 {
1646   typedef EvalToTemp<ArgType>                   XprType;
1647   typedef typename ArgType::PlainObject         PlainObject;
1648   typedef evaluator<PlainObject> Base;
1649 
1650   EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
1651     : m_result(xpr.arg())
1652   {
1653     ::new (static_cast<Base*>(this)) Base(m_result);
1654   }
1655 
1656   // This constructor is used when nesting an EvalTo evaluator in another evaluator
1657   EIGEN_DEVICE_FUNC evaluator(const ArgType& arg)
1658     : m_result(arg)
1659   {
1660     ::new (static_cast<Base*>(this)) Base(m_result);
1661   }
1662 
1663 protected:
1664   PlainObject m_result;
1665 };
1666 
1667 } // namespace internal
1668 
1669 } // end namespace Eigen
1670 
1671 #endif // EIGEN_COREEVALUATORS_H
1672