Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
Eigen  3.4.0
 
Loading...
Searching...
No Matches
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
13namespace Eigen {
14
15namespace internal {
16template<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
34template<typename Derived>
35class 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
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
301template<typename Derived>
302class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, ReadOnlyAccessors>
303{
304 public:
305
306 typedef DenseCoeffsBase<Derived, ReadOnlyAccessors> Base;
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&
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&
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&
462 {
463 EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=4, OUT_OF_RANGE_ACCESS);
464 return (*this)[3];
465 }
466};
467
480template<typename Derived>
481class DenseCoeffsBase<Derived, DirectAccessors> : public DenseCoeffsBase<Derived, ReadOnlyAccessors>
482{
483 public:
484
485 typedef DenseCoeffsBase<Derived, ReadOnlyAccessors> Base;
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 EIGEN_CONSTEXPR
499 inline Index innerStride() const
500 {
501 return derived().innerStride();
502 }
503
509 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
510 inline Index outerStride() const
511 {
512 return derived().outerStride();
513 }
514
515 // FIXME shall we remove it ?
516 EIGEN_CONSTEXPR inline Index stride() const
517 {
518 return Derived::IsVectorAtCompileTime ? innerStride() : outerStride();
519 }
520
525 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
526 inline Index rowStride() const
527 {
528 return Derived::IsRowMajor ? outerStride() : innerStride();
529 }
530
535 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
536 inline Index colStride() const
537 {
538 return Derived::IsRowMajor ? innerStride() : outerStride();
539 }
540};
541
554template<typename Derived>
555class DenseCoeffsBase<Derived, DirectWriteAccessors>
556 : public DenseCoeffsBase<Derived, WriteAccessors>
557{
558 public:
559
560 typedef DenseCoeffsBase<Derived, WriteAccessors> Base;
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 EIGEN_CONSTEXPR
574 inline Index innerStride() const EIGEN_NOEXCEPT
575 {
576 return derived().innerStride();
577 }
578
584 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
585 inline Index outerStride() const EIGEN_NOEXCEPT
586 {
587 return derived().outerStride();
588 }
589
590 // FIXME shall we remove it ?
591 EIGEN_CONSTEXPR inline Index stride() const EIGEN_NOEXCEPT
592 {
593 return Derived::IsVectorAtCompileTime ? innerStride() : outerStride();
594 }
595
600 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
601 inline Index rowStride() const EIGEN_NOEXCEPT
602 {
603 return Derived::IsRowMajor ? outerStride() : innerStride();
604 }
605
610 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
611 inline Index colStride() const EIGEN_NOEXCEPT
612 {
613 return Derived::IsRowMajor ? innerStride() : outerStride();
614 }
615};
616
617namespace internal {
618
619template<int Alignment, typename Derived, bool JustReturnZero>
620struct first_aligned_impl
621{
622 static EIGEN_CONSTEXPR inline Index run(const Derived&) EIGEN_NOEXCEPT
623 { return 0; }
624};
625
626template<int Alignment, typename Derived>
627struct 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
642template<int Alignment, typename Derived>
643static 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
649template<typename Derived>
650static 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
657template<typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret>
658struct inner_stride_at_compile_time
659{
660 enum { ret = traits<Derived>::InnerStrideAtCompileTime };
661};
662
663template<typename Derived>
664struct inner_stride_at_compile_time<Derived, false>
665{
666 enum { ret = 0 };
667};
668
669template<typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret>
670struct outer_stride_at_compile_time
671{
672 enum { ret = traits<Derived>::OuterStrideAtCompileTime };
673};
674
675template<typename Derived>
676struct 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
EIGEN_CONSTEXPR Index innerStride() const
Definition: DenseCoeffsBase.h:499
EIGEN_CONSTEXPR Index rowStride() const
Definition: DenseCoeffsBase.h:526
EIGEN_CONSTEXPR Index outerStride() const
Definition: DenseCoeffsBase.h:510
EIGEN_CONSTEXPR Index colStride() const
Definition: DenseCoeffsBase.h:536
EIGEN_CONSTEXPR Index innerStride() const EIGEN_NOEXCEPT
Definition: DenseCoeffsBase.h:574
EIGEN_CONSTEXPR Index rowStride() const EIGEN_NOEXCEPT
Definition: DenseCoeffsBase.h:601
EIGEN_CONSTEXPR Index outerStride() const EIGEN_NOEXCEPT
Definition: DenseCoeffsBase.h:585
EIGEN_CONSTEXPR Index colStride() const EIGEN_NOEXCEPT
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 & z()
Definition: DenseCoeffsBase.h:451
Scalar & operator[](Index index)
Definition: DenseCoeffsBase.h:406
Scalar & w()
Definition: DenseCoeffsBase.h:461
Scalar & operator()(Index row, Index col)
Definition: DenseCoeffsBase.h:364
Scalar & y()
Definition: DenseCoeffsBase.h:441
Scalar & x()
Definition: DenseCoeffsBase.h:435
Scalar & coeffRef(Index row, Index col)
Definition: DenseCoeffsBase.h:342
Scalar & operator()(Index index)
Definition: DenseCoeffsBase.h:425
Scalar & coeffRef(Index index)
Definition: DenseCoeffsBase.h:389
@ 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:141
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