Ref.h
Go to the documentation of this file.
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
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_REF_H
11 #define EIGEN_REF_H
12 
13 namespace Eigen {
14 
15 namespace internal {
16 
17 template<typename _PlainObjectType, int _Options, typename _StrideType>
18 struct traits<Ref<_PlainObjectType, _Options, _StrideType> >
19  : public traits<Map<_PlainObjectType, _Options, _StrideType> >
20 {
21  typedef _PlainObjectType PlainObjectType;
22  typedef _StrideType StrideType;
23  enum {
24  Options = _Options,
27  };
28 
29  template<typename Derived> struct match {
30  enum {
32  StorageOrderMatch = PlainObjectType::IsVectorAtCompileTime || Derived::IsVectorAtCompileTime || ((PlainObjectType::Flags&RowMajorBit)==(Derived::Flags&RowMajorBit)),
33  InnerStrideMatch = int(StrideType::InnerStrideAtCompileTime)==int(Dynamic)
34  || int(StrideType::InnerStrideAtCompileTime)==int(Derived::InnerStrideAtCompileTime)
35  || (int(StrideType::InnerStrideAtCompileTime)==0 && int(Derived::InnerStrideAtCompileTime)==1),
36  OuterStrideMatch = Derived::IsVectorAtCompileTime
37  || int(StrideType::OuterStrideAtCompileTime)==int(Dynamic) || int(StrideType::OuterStrideAtCompileTime)==int(Derived::OuterStrideAtCompileTime),
38  // NOTE, this indirection of evaluator<Derived>::Alignment is needed
39  // to workaround a very strange bug in MSVC related to the instantiation
40  // of has_*ary_operator in evaluator<CwiseNullaryOp>.
41  // This line is surprisingly very sensitive. For instance, simply adding parenthesis
42  // as "DerivedAlignment = (int(evaluator<Derived>::Alignment))," will make MSVC fail...
43  DerivedAlignment = int(evaluator<Derived>::Alignment),
44  AlignmentMatch = (int(traits<PlainObjectType>::Alignment)==int(Unaligned)) || (DerivedAlignment >= int(Alignment)), // FIXME the first condition is not very clear, it should be replaced by the required alignment
46  MatchAtCompileTime = HasDirectAccess && StorageOrderMatch && InnerStrideMatch && OuterStrideMatch && AlignmentMatch && ScalarTypeMatch
47  };
49  };
50 
51 };
52 
53 template<typename Derived>
54 struct traits<RefBase<Derived> > : public traits<Derived> {};
55 
56 }
57 
58 template<typename Derived> class RefBase
59  : public MapBase<Derived>
60 {
63 
64 public:
65 
68 
69  EIGEN_DEVICE_FUNC inline Index innerStride() const
70  {
71  return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1;
72  }
73 
74  EIGEN_DEVICE_FUNC inline Index outerStride() const
75  {
76  return StrideType::OuterStrideAtCompileTime != 0 ? m_stride.outer()
77  : IsVectorAtCompileTime ? this->size()
78  : int(Flags)&RowMajorBit ? this->cols()
79  : this->rows();
80  }
81 
82  EIGEN_DEVICE_FUNC RefBase()
83  : Base(0,RowsAtCompileTime==Dynamic?0:RowsAtCompileTime,ColsAtCompileTime==Dynamic?0:ColsAtCompileTime),
84  // Stride<> does not allow default ctor for Dynamic strides, so let' initialize it with dummy values:
85  m_stride(StrideType::OuterStrideAtCompileTime==Dynamic?0:StrideType::OuterStrideAtCompileTime,
86  StrideType::InnerStrideAtCompileTime==Dynamic?0:StrideType::InnerStrideAtCompileTime)
87  {}
88 
90 
91 protected:
92 
94 
95  template<typename Expression>
96  EIGEN_DEVICE_FUNC void construct(Expression& expr)
97  {
98  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(PlainObjectType,Expression);
99 
100  if(PlainObjectType::RowsAtCompileTime==1)
101  {
102  eigen_assert(expr.rows()==1 || expr.cols()==1);
103  ::new (static_cast<Base*>(this)) Base(expr.data(), 1, expr.size());
104  }
105  else if(PlainObjectType::ColsAtCompileTime==1)
106  {
107  eigen_assert(expr.rows()==1 || expr.cols()==1);
108  ::new (static_cast<Base*>(this)) Base(expr.data(), expr.size(), 1);
109  }
110  else
111  ::new (static_cast<Base*>(this)) Base(expr.data(), expr.rows(), expr.cols());
112 
113  if(Expression::IsVectorAtCompileTime && (!PlainObjectType::IsVectorAtCompileTime) && ((Expression::Flags&RowMajorBit)!=(PlainObjectType::Flags&RowMajorBit)))
114  ::new (&m_stride) StrideBase(expr.innerStride(), StrideType::InnerStrideAtCompileTime==0?0:1);
115  else
116  ::new (&m_stride) StrideBase(StrideType::OuterStrideAtCompileTime==0?0:expr.outerStride(),
117  StrideType::InnerStrideAtCompileTime==0?0:expr.innerStride());
118  }
119 
120  StrideBase m_stride;
121 };
122 
192 template<typename PlainObjectType, int Options, typename StrideType> class Ref
193  : public RefBase<Ref<PlainObjectType, Options, StrideType> >
194 {
195  private:
197  template<typename Derived>
198  EIGEN_DEVICE_FUNC inline Ref(const PlainObjectBase<Derived>& expr,
199  typename internal::enable_if<bool(Traits::template match<Derived>::MatchAtCompileTime),Derived>::type* = 0);
200  public:
201 
204 
205 
206  #ifndef EIGEN_PARSED_BY_DOXYGEN
207  template<typename Derived>
208  EIGEN_DEVICE_FUNC inline Ref(PlainObjectBase<Derived>& expr,
209  typename internal::enable_if<bool(Traits::template match<Derived>::MatchAtCompileTime),Derived>::type* = 0)
210  {
211  EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
212  Base::construct(expr.derived());
213  }
214  template<typename Derived>
215  EIGEN_DEVICE_FUNC inline Ref(const DenseBase<Derived>& expr,
216  typename internal::enable_if<bool(Traits::template match<Derived>::MatchAtCompileTime),Derived>::type* = 0)
217  #else
218 
219  template<typename Derived>
220  inline Ref(DenseBase<Derived>& expr)
221  #endif
222  {
223  EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
224  EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
225  EIGEN_STATIC_ASSERT(!Derived::IsPlainObjectBase,THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
226  Base::construct(expr.const_cast_derived());
227  }
228 
230 
231 };
232 
233 // this is the const ref version
234 template<typename TPlainObjectType, int Options, typename StrideType> class Ref<const TPlainObjectType, Options, StrideType>
235  : public RefBase<Ref<const TPlainObjectType, Options, StrideType> >
236 {
238  public:
239 
242 
243  template<typename Derived>
244  EIGEN_DEVICE_FUNC inline Ref(const DenseBase<Derived>& expr,
245  typename internal::enable_if<bool(Traits::template match<Derived>::ScalarTypeMatch),Derived>::type* = 0)
246  {
247 // std::cout << match_helper<Derived>::HasDirectAccess << "," << match_helper<Derived>::OuterStrideMatch << "," << match_helper<Derived>::InnerStrideMatch << "\n";
248 // std::cout << int(StrideType::OuterStrideAtCompileTime) << " - " << int(Derived::OuterStrideAtCompileTime) << "\n";
249 // std::cout << int(StrideType::InnerStrideAtCompileTime) << " - " << int(Derived::InnerStrideAtCompileTime) << "\n";
250  construct(expr.derived(), typename Traits::template match<Derived>::type());
251  }
252 
253  EIGEN_DEVICE_FUNC inline Ref(const Ref& other) : Base(other) {
254  // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy
255  }
256 
257  template<typename OtherRef>
258  EIGEN_DEVICE_FUNC inline Ref(const RefBase<OtherRef>& other) {
259  construct(other.derived(), typename Traits::template match<OtherRef>::type());
260  }
261 
262  protected:
263 
264  template<typename Expression>
265  EIGEN_DEVICE_FUNC void construct(const Expression& expr,internal::true_type)
266  {
267  Base::construct(expr);
268  }
269 
270  template<typename Expression>
271  EIGEN_DEVICE_FUNC void construct(const Expression& expr, internal::false_type)
272  {
274  Base::construct(m_object);
275  }
276 
277  protected:
278  TPlainObjectType m_object;
279 };
280 
281 } // end namespace Eigen
282 
283 #endif // EIGEN_REF_H
EIGEN_DEVICE_FUNC Index outerStride() const
Definition: Ref.h:74
EIGEN_DEVICE_FUNC Ref(const DenseBase< Derived > &expr, typename internal::enable_if< bool(Traits::template match< Derived >::MatchAtCompileTime), Derived >::type *=0)
Definition: Ref.h:215
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_assignment_no_alias(Dst &dst, const Src &src, const Func &func)
Stride< StrideType::OuterStrideAtCompileTime, StrideType::InnerStrideAtCompileTime > StrideBase
Definition: Ref.h:93
return int(ret)+1
void construct(...)
Definition: init.h:85
MapBase< Derived > Base
Definition: Ref.h:66
EIGEN_DEVICE_FUNC RefBase()
Definition: Ref.h:82
internal::traits< Ref > Traits
Definition: Ref.h:196
internal::traits< Derived >::PlainObjectType PlainObjectType
Definition: Ref.h:61
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
#define EIGEN_STATIC_ASSERT(CONDITION, MSG)
Definition: StaticAssert.h:124
EIGEN_DEVICE_FUNC Ref(const RefBase< OtherRef > &other)
Definition: Ref.h:258
const unsigned int RowMajorBit
Definition: Constants.h:61
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:41
EIGEN_DEVICE_FUNC void construct(Expression &expr)
Definition: Ref.h:96
Scalar Scalar int size
Definition: benchVecAdd.cpp:17
internal::conditional< MatchAtCompileTime, internal::true_type, internal::false_type >::type type
Definition: Ref.h:48
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
#define eigen_assert(x)
Definition: Macros.h:579
EIGEN_DEVICE_FUNC Ref(const Ref &other)
Definition: Ref.h:253
#define EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Derived)
Definition: Macros.h:842
StrideBase m_stride
Definition: Ref.h:120
A matrix or vector expression mapping an existing expression.
Definition: Ref.h:192
const unsigned int NestByRefBit
Definition: Constants.h:164
EIGEN_DEVICE_FUNC Ref(PlainObjectBase< Derived > &expr, typename internal::enable_if< bool(Traits::template match< Derived >::MatchAtCompileTime), Derived >::type *=0)
Definition: Ref.h:208
RefBase< Ref > Base
Definition: Ref.h:202
#define EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
Definition: Macros.h:870
const int Dynamic
Definition: Constants.h:21
EIGEN_DEVICE_FUNC void construct(const Expression &expr, internal::true_type)
Definition: Ref.h:265
EIGEN_DEVICE_FUNC void construct(const Expression &expr, internal::false_type)
Definition: Ref.h:271
Definition: pytypes.h:897
internal::traits< Derived >::StrideType StrideType
Definition: Ref.h:62
#define EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(TYPE0, TYPE1)
Definition: StaticAssert.h:189


gtsam
Author(s):
autogenerated on Sat May 8 2021 02:43:51