Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
Eigen  3.4.99 (git rev 199c5f2b47eb1f8e5a2d20e60f07e97cd95a6ba6)
DenseCoeffsBase.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
5 //
6 // This Source Code Form is subject to the terms of the Mozilla
7 // Public License v. 2.0. If a copy of the MPL was not distributed
8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9 
10 #ifndef EIGEN_DENSECOEFFSBASE_H
11 #define EIGEN_DENSECOEFFSBASE_H
12 
13 namespace Eigen {
14 
15 namespace internal {
16 template<typename T> struct add_const_on_value_type_if_arithmetic
17 {
18  typedef typename conditional<is_arithmetic<T>::value, T, typename add_const_on_value_type<T>::type>::type type;
19 };
20 }
21 
34 template<typename Derived>
35 class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
36 {
37  public:
38  typedef typename internal::traits<Derived>::StorageKind StorageKind;
39  typedef typename internal::traits<Derived>::Scalar Scalar;
40  typedef typename internal::packet_traits<Scalar>::type PacketScalar;
41 
42  // Explanation for this CoeffReturnType typedef.
43  // - This is the return type of the coeff() method.
44  // - The LvalueBit means exactly that we can offer a coeffRef() method, which means exactly that we can get references
45  // to coeffs, which means exactly that we can have coeff() return a const reference (as opposed to returning a value).
46  // - The is_artihmetic check is required since "const int", "const double", etc. will cause warnings on some systems
47  // while the declaration of "const T", where T is a non arithmetic type does not. Always returning "const Scalar&" is
48  // not possible, since the underlying expressions might not offer a valid address the reference could be referring to.
49  typedef typename internal::conditional<bool(internal::traits<Derived>::Flags&LvalueBit),
50  const Scalar&,
51  typename internal::conditional<internal::is_arithmetic<Scalar>::value, Scalar, const Scalar>::type
52  >::type CoeffReturnType;
53 
54  typedef typename internal::add_const_on_value_type_if_arithmetic<
55  typename internal::packet_traits<Scalar>::type
56  >::type PacketReturnType;
57 
58  typedef EigenBase<Derived> Base;
59  using Base::rows;
60  using Base::cols;
61  using Base::size;
62  using Base::derived;
63 
64  EIGEN_DEVICE_FUNC
65  EIGEN_STRONG_INLINE Index rowIndexByOuterInner(Index outer, Index inner) const
66  {
67  return int(Derived::RowsAtCompileTime) == 1 ? 0
68  : int(Derived::ColsAtCompileTime) == 1 ? inner
69  : int(Derived::Flags)&RowMajorBit ? outer
70  : inner;
71  }
72 
73  EIGEN_DEVICE_FUNC
74  EIGEN_STRONG_INLINE Index colIndexByOuterInner(Index outer, Index inner) const
75  {
76  return int(Derived::ColsAtCompileTime) == 1 ? 0
77  : int(Derived::RowsAtCompileTime) == 1 ? inner
78  : int(Derived::Flags)&RowMajorBit ? inner
79  : outer;
80  }
81 
96  EIGEN_DEVICE_FUNC
97  EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
98  {
99  eigen_internal_assert(row >= 0 && row < rows()
100  && col >= 0 && col < cols());
101  return internal::evaluator<Derived>(derived()).coeff(row,col);
102  }
103 
104  EIGEN_DEVICE_FUNC
105  EIGEN_STRONG_INLINE CoeffReturnType coeffByOuterInner(Index outer, Index inner) const
106  {
107  return coeff(rowIndexByOuterInner(outer, inner),
108  colIndexByOuterInner(outer, inner));
109  }
110 
115  EIGEN_DEVICE_FUNC
116  EIGEN_STRONG_INLINE CoeffReturnType operator()(Index row, Index col) const
117  {
118  eigen_assert(row >= 0 && row < rows()
119  && col >= 0 && col < cols());
120  return coeff(row, col);
121  }
122 
138  EIGEN_DEVICE_FUNC
139  EIGEN_STRONG_INLINE CoeffReturnType
140  coeff(Index index) const
141  {
142  EIGEN_STATIC_ASSERT(internal::evaluator<Derived>::Flags & LinearAccessBit,
143  THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS)
144  eigen_internal_assert(index >= 0 && index < size());
145  return internal::evaluator<Derived>(derived()).coeff(index);
146  }
147 
148 
157  EIGEN_DEVICE_FUNC
158  EIGEN_STRONG_INLINE CoeffReturnType
159  operator[](Index index) const
160  {
161  EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime,
162  THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD)
163  eigen_assert(index >= 0 && index < size());
164  return coeff(index);
165  }
166 
177  EIGEN_DEVICE_FUNC
178  EIGEN_STRONG_INLINE CoeffReturnType
179  operator()(Index index) const
180  {
181  eigen_assert(index >= 0 && index < size());
182  return coeff(index);
183  }
184 
187  EIGEN_DEVICE_FUNC
188  EIGEN_STRONG_INLINE CoeffReturnType
189  x() const { return (*this)[0]; }
190 
193  EIGEN_DEVICE_FUNC
194  EIGEN_STRONG_INLINE CoeffReturnType
195  y() const
196  {
197  EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=2, OUT_OF_RANGE_ACCESS);
198  return (*this)[1];
199  }
200 
203  EIGEN_DEVICE_FUNC
204  EIGEN_STRONG_INLINE CoeffReturnType
205  z() const
206  {
207  EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=3, OUT_OF_RANGE_ACCESS);
208  return (*this)[2];
209  }
210 
213  EIGEN_DEVICE_FUNC
214  EIGEN_STRONG_INLINE CoeffReturnType
215  w() const
216  {
217  EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=4, OUT_OF_RANGE_ACCESS);
218  return (*this)[3];
219  }
220 
231  template<int LoadMode>
232  EIGEN_STRONG_INLINE PacketReturnType packet(Index row, Index col) const
233  {
234  typedef typename internal::packet_traits<Scalar>::type DefaultPacketType;
235  eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols());
236  return internal::evaluator<Derived>(derived()).template packet<LoadMode,DefaultPacketType>(row,col);
237  }
238 
239 
241  template<int LoadMode>
242  EIGEN_STRONG_INLINE PacketReturnType packetByOuterInner(Index outer, Index inner) const
243  {
244  return packet<LoadMode>(rowIndexByOuterInner(outer, inner),
245  colIndexByOuterInner(outer, inner));
246  }
247 
258  template<int LoadMode>
259  EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const
260  {
261  EIGEN_STATIC_ASSERT(internal::evaluator<Derived>::Flags & LinearAccessBit,
262  THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS)
263  typedef typename internal::packet_traits<Scalar>::type DefaultPacketType;
264  eigen_internal_assert(index >= 0 && index < size());
265  return internal::evaluator<Derived>(derived()).template packet<LoadMode,DefaultPacketType>(index);
266  }
267 
268  protected:
269  // explanation: DenseBase is doing "using ..." on the methods from DenseCoeffsBase.
270  // But some methods are only available in the DirectAccess case.
271  // So we add dummy methods here with these names, so that "using... " doesn't fail.
272  // It's not private so that the child class DenseBase can access them, and it's not public
273  // either since it's an implementation detail, so has to be protected.
274  void coeffRef();
275  void coeffRefByOuterInner();
276  void writePacket();
277  void writePacketByOuterInner();
278  void copyCoeff();
279  void copyCoeffByOuterInner();
280  void copyPacket();
281  void copyPacketByOuterInner();
282  void stride();
283  void innerStride();
284  void outerStride();
285  void rowStride();
286  void colStride();
287 };
288 
301 template<typename Derived>
302 class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, ReadOnlyAccessors>
303 {
304  public:
305 
307 
308  typedef typename internal::traits<Derived>::StorageKind StorageKind;
309  typedef typename internal::traits<Derived>::Scalar Scalar;
310  typedef typename internal::packet_traits<Scalar>::type PacketScalar;
311  typedef typename NumTraits<Scalar>::Real RealScalar;
312 
313  using Base::coeff;
314  using Base::rows;
315  using Base::cols;
316  using Base::size;
317  using Base::derived;
318  using Base::rowIndexByOuterInner;
319  using Base::colIndexByOuterInner;
320  using Base::operator[];
321  using Base::operator();
322  using Base::x;
323  using Base::y;
324  using Base::z;
325  using Base::w;
326 
341  EIGEN_DEVICE_FUNC
342  EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col)
343  {
344  eigen_internal_assert(row >= 0 && row < rows()
345  && col >= 0 && col < cols());
346  return internal::evaluator<Derived>(derived()).coeffRef(row,col);
347  }
348 
349  EIGEN_DEVICE_FUNC
350  EIGEN_STRONG_INLINE Scalar&
351  coeffRefByOuterInner(Index outer, Index inner)
352  {
353  return coeffRef(rowIndexByOuterInner(outer, inner),
354  colIndexByOuterInner(outer, inner));
355  }
356 
362  EIGEN_DEVICE_FUNC
363  EIGEN_STRONG_INLINE Scalar&
365  {
366  eigen_assert(row >= 0 && row < rows()
367  && col >= 0 && col < cols());
368  return coeffRef(row, col);
369  }
370 
371 
387  EIGEN_DEVICE_FUNC
388  EIGEN_STRONG_INLINE Scalar&
390  {
391  EIGEN_STATIC_ASSERT(internal::evaluator<Derived>::Flags & LinearAccessBit,
392  THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS)
393  eigen_internal_assert(index >= 0 && index < size());
394  return internal::evaluator<Derived>(derived()).coeffRef(index);
395  }
396 
404  EIGEN_DEVICE_FUNC
405  EIGEN_STRONG_INLINE Scalar&
407  {
408  EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime,
409  THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD)
410  eigen_assert(index >= 0 && index < size());
411  return coeffRef(index);
412  }
413 
423  EIGEN_DEVICE_FUNC
424  EIGEN_STRONG_INLINE Scalar&
426  {
427  eigen_assert(index >= 0 && index < size());
428  return coeffRef(index);
429  }
430 
433  EIGEN_DEVICE_FUNC
434  EIGEN_STRONG_INLINE Scalar&
435  x() { return (*this)[0]; }
436 
439  EIGEN_DEVICE_FUNC
440  EIGEN_STRONG_INLINE Scalar&
441  y()
442  {
443  EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=2, OUT_OF_RANGE_ACCESS);
444  return (*this)[1];
445  }
446 
449  EIGEN_DEVICE_FUNC
450  EIGEN_STRONG_INLINE Scalar&
451  z()
452  {
453  EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=3, OUT_OF_RANGE_ACCESS);
454  return (*this)[2];
455  }
456 
459  EIGEN_DEVICE_FUNC
460  EIGEN_STRONG_INLINE Scalar&
461  w()
462  {
463  EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=4, OUT_OF_RANGE_ACCESS);
464  return (*this)[3];
465  }
466 };
467 
480 template<typename Derived>
481 class DenseCoeffsBase<Derived, DirectAccessors> : public DenseCoeffsBase<Derived, ReadOnlyAccessors>
482 {
483  public:
484 
486  typedef typename internal::traits<Derived>::Scalar Scalar;
487  typedef typename NumTraits<Scalar>::Real RealScalar;
488 
489  using Base::rows;
490  using Base::cols;
491  using Base::size;
492  using Base::derived;
493 
498  EIGEN_DEVICE_FUNC
499  inline Index innerStride() const
500  {
501  return derived().innerStride();
502  }
503 
509  EIGEN_DEVICE_FUNC
510  inline Index outerStride() const
511  {
512  return derived().outerStride();
513  }
514 
515  // FIXME shall we remove it ?
516  inline Index stride() const
517  {
518  return Derived::IsVectorAtCompileTime ? innerStride() : outerStride();
519  }
520 
525  EIGEN_DEVICE_FUNC
526  inline Index rowStride() const
527  {
528  return Derived::IsRowMajor ? outerStride() : innerStride();
529  }
530 
535  EIGEN_DEVICE_FUNC
536  inline Index colStride() const
537  {
538  return Derived::IsRowMajor ? innerStride() : outerStride();
539  }
540 };
541 
554 template<typename Derived>
555 class DenseCoeffsBase<Derived, DirectWriteAccessors>
556  : public DenseCoeffsBase<Derived, WriteAccessors>
557 {
558  public:
559 
561  typedef typename internal::traits<Derived>::Scalar Scalar;
562  typedef typename NumTraits<Scalar>::Real RealScalar;
563 
564  using Base::rows;
565  using Base::cols;
566  using Base::size;
567  using Base::derived;
568 
573  EIGEN_DEVICE_FUNC
574  inline Index innerStride() const
575  {
576  return derived().innerStride();
577  }
578 
584  EIGEN_DEVICE_FUNC
585  inline Index outerStride() const
586  {
587  return derived().outerStride();
588  }
589 
590  // FIXME shall we remove it ?
591  inline Index stride() const
592  {
593  return Derived::IsVectorAtCompileTime ? innerStride() : outerStride();
594  }
595 
600  EIGEN_DEVICE_FUNC
601  inline Index rowStride() const
602  {
603  return Derived::IsRowMajor ? outerStride() : innerStride();
604  }
605 
610  EIGEN_DEVICE_FUNC
611  inline Index colStride() const
612  {
613  return Derived::IsRowMajor ? innerStride() : outerStride();
614  }
615 };
616 
617 namespace internal {
618 
619 template<int Alignment, typename Derived, bool JustReturnZero>
620 struct first_aligned_impl
621 {
622  static inline Index run(const Derived&)
623  { return 0; }
624 };
625 
626 template<int Alignment, typename Derived>
627 struct first_aligned_impl<Alignment, Derived, false>
628 {
629  static inline Index run(const Derived& m)
630  {
631  return internal::first_aligned<Alignment>(m.data(), m.size());
632  }
633 };
634 
642 template<int Alignment, typename Derived>
643 static inline Index first_aligned(const DenseBase<Derived>& m)
644 {
645  enum { ReturnZero = (int(evaluator<Derived>::Alignment) >= Alignment) || !(Derived::Flags & DirectAccessBit) };
646  return first_aligned_impl<Alignment, Derived, ReturnZero>::run(m.derived());
647 }
648 
649 template<typename Derived>
650 static inline Index first_default_aligned(const DenseBase<Derived>& m)
651 {
652  typedef typename Derived::Scalar Scalar;
653  typedef typename packet_traits<Scalar>::type DefaultPacketType;
654  return internal::first_aligned<int(unpacket_traits<DefaultPacketType>::alignment),Derived>(m);
655 }
656 
657 template<typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret>
658 struct inner_stride_at_compile_time
659 {
660  enum { ret = traits<Derived>::InnerStrideAtCompileTime };
661 };
662 
663 template<typename Derived>
664 struct inner_stride_at_compile_time<Derived, false>
665 {
666  enum { ret = 0 };
667 };
668 
669 template<typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret>
670 struct outer_stride_at_compile_time
671 {
672  enum { ret = traits<Derived>::OuterStrideAtCompileTime };
673 };
674 
675 template<typename Derived>
676 struct outer_stride_at_compile_time<Derived, false>
677 {
678  enum { ret = 0 };
679 };
680 
681 } // end namespace internal
682 
683 } // end namespace Eigen
684 
685 #endif // EIGEN_DENSECOEFFSBASE_H
Index innerStride() const
Definition: DenseCoeffsBase.h:499
Index rowStride() const
Definition: DenseCoeffsBase.h:526
Index colStride() const
Definition: DenseCoeffsBase.h:536
Index outerStride() const
Definition: DenseCoeffsBase.h:510
Index rowStride() const
Definition: DenseCoeffsBase.h:601
Index outerStride() const
Definition: DenseCoeffsBase.h:585
Index innerStride() const
Definition: DenseCoeffsBase.h:574
Index colStride() const
Definition: DenseCoeffsBase.h:611
Base class providing read-only coefficient access to matrices and arrays.
Definition: DenseCoeffsBase.h:36
CoeffReturnType y() const
Definition: DenseCoeffsBase.h:195
CoeffReturnType x() const
Definition: DenseCoeffsBase.h:189
CoeffReturnType operator[](Index index) const
Definition: DenseCoeffsBase.h:159
CoeffReturnType z() const
Definition: DenseCoeffsBase.h:205
CoeffReturnType w() const
Definition: DenseCoeffsBase.h:215
CoeffReturnType coeff(Index index) const
Definition: DenseCoeffsBase.h:140
CoeffReturnType operator()(Index row, Index col) const
Definition: DenseCoeffsBase.h:116
CoeffReturnType coeff(Index row, Index col) const
Definition: DenseCoeffsBase.h:97
CoeffReturnType operator()(Index index) const
Definition: DenseCoeffsBase.h:179
Base class providing read/write coefficient access to matrices and arrays.
Definition: DenseCoeffsBase.h:303
Scalar & operator()(Index index)
Definition: DenseCoeffsBase.h:425
Scalar & z()
Definition: DenseCoeffsBase.h:451
Scalar & operator[](Index index)
Definition: DenseCoeffsBase.h:406
Scalar & coeffRef(Index row, Index col)
Definition: DenseCoeffsBase.h:342
Scalar & coeffRef(Index index)
Definition: DenseCoeffsBase.h:389
Scalar & operator()(Index row, Index col)
Definition: DenseCoeffsBase.h:364
Scalar & x()
Definition: DenseCoeffsBase.h:435
Scalar & w()
Definition: DenseCoeffsBase.h:461
Scalar & y()
Definition: DenseCoeffsBase.h:441
@ DirectAccessors
Definition: Constants.h:380
@ ReadOnlyAccessors
Definition: Constants.h:376
@ WriteAccessors
Definition: Constants.h:378
@ DirectWriteAccessors
Definition: Constants.h:382
const unsigned int LinearAccessBit
Definition: Constants.h:130
const unsigned int DirectAccessBit
Definition: Constants.h:155
const unsigned int LvalueBit
Definition: Constants.h:144
const unsigned int RowMajorBit
Definition: Constants.h:66
Namespace containing all symbols from the Eigen library.
Definition: Core:134
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
Definition: EigenBase.h:30
Eigen::Index Index
The interface type of indices.
Definition: EigenBase.h:39
Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
Definition: NumTraits.h:213