TensorRef.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) 2014 Benoit Steiner <benoit.steiner.goog@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_CXX11_TENSOR_TENSOR_REF_H
11 #define EIGEN_CXX11_TENSOR_TENSOR_REF_H
12 
13 namespace Eigen {
14 
15 namespace internal {
16 
17 template <typename Dimensions, typename Scalar>
19  public:
22 
23  EIGEN_DEVICE_FUNC virtual const Dimensions& dimensions() const = 0;
24  EIGEN_DEVICE_FUNC virtual const Scalar* data() const = 0;
25 
26  EIGEN_DEVICE_FUNC virtual const Scalar coeff(DenseIndex index) const = 0;
27  EIGEN_DEVICE_FUNC virtual Scalar& coeffRef(DenseIndex index) = 0;
28 
29  void incrRefCount() { ++m_refcount; }
30  void decrRefCount() { --m_refcount; }
31  int refCount() const { return m_refcount; }
32 
33  private:
34  // No copy, no assigment;
37 
39 };
40 
41 
42 template <typename Dimensions, typename Expr, typename Device>
43 class TensorLazyEvaluatorReadOnly : public TensorLazyBaseEvaluator<Dimensions, typename TensorEvaluator<Expr, Device>::Scalar> {
44  public:
45  // typedef typename TensorEvaluator<Expr, Device>::Dimensions Dimensions;
47 
48  TensorLazyEvaluatorReadOnly(const Expr& expr, const Device& device) : m_impl(expr, device), m_dummy(Scalar(0)) {
49  m_dims = m_impl.dimensions();
50  m_impl.evalSubExprsIfNeeded(NULL);
51  }
53  m_impl.cleanup();
54  }
55 
56  EIGEN_DEVICE_FUNC virtual const Dimensions& dimensions() const {
57  return m_dims;
58  }
59  EIGEN_DEVICE_FUNC virtual const Scalar* data() const {
60  return m_impl.data();
61  }
62 
63  EIGEN_DEVICE_FUNC virtual const Scalar coeff(DenseIndex index) const {
64  return m_impl.coeff(index);
65  }
66  EIGEN_DEVICE_FUNC virtual Scalar& coeffRef(DenseIndex /*index*/) {
67  eigen_assert(false && "can't reference the coefficient of a rvalue");
68  return m_dummy;
69  };
70 
71  protected:
73  Dimensions m_dims;
74  Scalar m_dummy;
75 };
76 
77 template <typename Dimensions, typename Expr, typename Device>
78 class TensorLazyEvaluatorWritable : public TensorLazyEvaluatorReadOnly<Dimensions, Expr, Device> {
79  public:
81  typedef typename Base::Scalar Scalar;
82 
83  TensorLazyEvaluatorWritable(const Expr& expr, const Device& device) : Base(expr, device) {
84  }
86  }
87 
88  EIGEN_DEVICE_FUNC virtual Scalar& coeffRef(DenseIndex index) {
89  return this->m_impl.coeffRef(index);
90  }
91 };
92 
93 template <typename Dimensions, typename Expr, typename Device>
94 class TensorLazyEvaluator : public internal::conditional<bool(internal::is_lvalue<Expr>::value),
95  TensorLazyEvaluatorWritable<Dimensions, Expr, Device>,
96  TensorLazyEvaluatorReadOnly<Dimensions, const Expr, Device> >::type {
97  public:
101  typedef typename Base::Scalar Scalar;
102 
103  TensorLazyEvaluator(const Expr& expr, const Device& device) : Base(expr, device) {
104  }
106  }
107 };
108 
109 } // namespace internal
110 
111 
119 template<typename PlainObjectType> class TensorRef : public TensorBase<TensorRef<PlainObjectType> >
120 {
121  public:
123  typedef typename PlainObjectType::Base Base;
129  typedef typename Base::CoeffReturnType CoeffReturnType;
130  typedef Scalar* PointerType;
131  typedef PointerType PointerArgType;
132 
133  static const Index NumIndices = PlainObjectType::NumIndices;
134  typedef typename PlainObjectType::Dimensions Dimensions;
135 
136  enum {
137  IsAligned = false,
138  PacketAccess = false,
139  Layout = PlainObjectType::Layout,
140  CoordAccess = false, // to be implemented
141  RawAccess = false
142  };
143 
144  EIGEN_STRONG_INLINE TensorRef() : m_evaluator(NULL) {
145  }
146 
147  template <typename Expression>
148  EIGEN_STRONG_INLINE TensorRef(const Expression& expr) : m_evaluator(new internal::TensorLazyEvaluator<Dimensions, Expression, DefaultDevice>(expr, DefaultDevice())) {
149  m_evaluator->incrRefCount();
150  }
151 
152  template <typename Expression>
153  EIGEN_STRONG_INLINE TensorRef& operator = (const Expression& expr) {
154  unrefEvaluator();
156  m_evaluator->incrRefCount();
157  return *this;
158  }
159 
161  unrefEvaluator();
162  }
163 
164  TensorRef(const TensorRef& other) : m_evaluator(other.m_evaluator) {
165  eigen_assert(m_evaluator->refCount() > 0);
166  m_evaluator->incrRefCount();
167  }
168 
169  TensorRef& operator = (const TensorRef& other) {
170  if (this != &other) {
171  unrefEvaluator();
172  m_evaluator = other.m_evaluator;
173  eigen_assert(m_evaluator->refCount() > 0);
174  m_evaluator->incrRefCount();
175  }
176  return *this;
177  }
178 
179  EIGEN_DEVICE_FUNC
180  EIGEN_STRONG_INLINE Index rank() const { return m_evaluator->dimensions().size(); }
181  EIGEN_DEVICE_FUNC
182  EIGEN_STRONG_INLINE Index dimension(Index n) const { return m_evaluator->dimensions()[n]; }
183  EIGEN_DEVICE_FUNC
184  EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_evaluator->dimensions(); }
185  EIGEN_DEVICE_FUNC
186  EIGEN_STRONG_INLINE Index size() const { return m_evaluator->dimensions().TotalSize(); }
187  EIGEN_DEVICE_FUNC
188  EIGEN_STRONG_INLINE const Scalar* data() const { return m_evaluator->data(); }
189 
190  EIGEN_DEVICE_FUNC
191  EIGEN_STRONG_INLINE const Scalar operator()(Index index) const
192  {
193  return m_evaluator->coeff(index);
194  }
195 
196 #if EIGEN_HAS_VARIADIC_TEMPLATES
197  template<typename... IndexTypes> EIGEN_DEVICE_FUNC
198  EIGEN_STRONG_INLINE const Scalar operator()(Index firstIndex, IndexTypes... otherIndices) const
199  {
200  const std::size_t num_indices = (sizeof...(otherIndices) + 1);
201  const array<Index, num_indices> indices{{firstIndex, otherIndices...}};
202  return coeff(indices);
203  }
204  template<typename... IndexTypes> EIGEN_DEVICE_FUNC
205  EIGEN_STRONG_INLINE Scalar& coeffRef(Index firstIndex, IndexTypes... otherIndices)
206  {
207  const std::size_t num_indices = (sizeof...(otherIndices) + 1);
208  const array<Index, num_indices> indices{{firstIndex, otherIndices...}};
209  return coeffRef(indices);
210  }
211 #else
212 
213  EIGEN_DEVICE_FUNC
214  EIGEN_STRONG_INLINE const Scalar operator()(Index i0, Index i1) const
215  {
216  array<Index, 2> indices;
217  indices[0] = i0;
218  indices[1] = i1;
219  return coeff(indices);
220  }
221  EIGEN_DEVICE_FUNC
222  EIGEN_STRONG_INLINE const Scalar operator()(Index i0, Index i1, Index i2) const
223  {
224  array<Index, 3> indices;
225  indices[0] = i0;
226  indices[1] = i1;
227  indices[2] = i2;
228  return coeff(indices);
229  }
230  EIGEN_DEVICE_FUNC
231  EIGEN_STRONG_INLINE const Scalar operator()(Index i0, Index i1, Index i2, Index i3) const
232  {
233  array<Index, 4> indices;
234  indices[0] = i0;
235  indices[1] = i1;
236  indices[2] = i2;
237  indices[3] = i3;
238  return coeff(indices);
239  }
240  EIGEN_DEVICE_FUNC
241  EIGEN_STRONG_INLINE const Scalar operator()(Index i0, Index i1, Index i2, Index i3, Index i4) const
242  {
243  array<Index, 5> indices;
244  indices[0] = i0;
245  indices[1] = i1;
246  indices[2] = i2;
247  indices[3] = i3;
248  indices[4] = i4;
249  return coeff(indices);
250  }
251  EIGEN_DEVICE_FUNC
252  EIGEN_STRONG_INLINE Scalar& coeffRef(Index i0, Index i1)
253  {
254  array<Index, 2> indices;
255  indices[0] = i0;
256  indices[1] = i1;
257  return coeffRef(indices);
258  }
259  EIGEN_DEVICE_FUNC
260  EIGEN_STRONG_INLINE Scalar& coeffRef(Index i0, Index i1, Index i2)
261  {
262  array<Index, 3> indices;
263  indices[0] = i0;
264  indices[1] = i1;
265  indices[2] = i2;
266  return coeffRef(indices);
267  }
268  EIGEN_DEVICE_FUNC
269  EIGEN_STRONG_INLINE Scalar& operator()(Index i0, Index i1, Index i2, Index i3)
270  {
271  array<Index, 4> indices;
272  indices[0] = i0;
273  indices[1] = i1;
274  indices[2] = i2;
275  indices[3] = i3;
276  return coeffRef(indices);
277  }
278  EIGEN_DEVICE_FUNC
279  EIGEN_STRONG_INLINE Scalar& coeffRef(Index i0, Index i1, Index i2, Index i3, Index i4)
280  {
281  array<Index, 5> indices;
282  indices[0] = i0;
283  indices[1] = i1;
284  indices[2] = i2;
285  indices[3] = i3;
286  indices[4] = i4;
287  return coeffRef(indices);
288  }
289 #endif
290 
291  template <std::size_t NumIndices> EIGEN_DEVICE_FUNC
292  EIGEN_STRONG_INLINE const Scalar coeff(const array<Index, NumIndices>& indices) const
293  {
294  const Dimensions& dims = this->dimensions();
295  Index index = 0;
296  if (PlainObjectType::Options & RowMajor) {
297  index += indices[0];
298  for (size_t i = 1; i < NumIndices; ++i) {
299  index = index * dims[i] + indices[i];
300  }
301  } else {
302  index += indices[NumIndices-1];
303  for (int i = NumIndices-2; i >= 0; --i) {
304  index = index * dims[i] + indices[i];
305  }
306  }
307  return m_evaluator->coeff(index);
308  }
309  template <std::size_t NumIndices> EIGEN_DEVICE_FUNC
311  {
312  const Dimensions& dims = this->dimensions();
313  Index index = 0;
314  if (PlainObjectType::Options & RowMajor) {
315  index += indices[0];
316  for (size_t i = 1; i < NumIndices; ++i) {
317  index = index * dims[i] + indices[i];
318  }
319  } else {
320  index += indices[NumIndices-1];
321  for (int i = NumIndices-2; i >= 0; --i) {
322  index = index * dims[i] + indices[i];
323  }
324  }
325  return m_evaluator->coeffRef(index);
326  }
327 
328  EIGEN_DEVICE_FUNC
329  EIGEN_STRONG_INLINE const Scalar coeff(Index index) const
330  {
331  return m_evaluator->coeff(index);
332  }
333 
334  EIGEN_DEVICE_FUNC
335  EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
336  {
337  return m_evaluator->coeffRef(index);
338  }
339 
340  private:
342  if (m_evaluator) {
343  m_evaluator->decrRefCount();
344  if (m_evaluator->refCount() == 0) {
345  delete m_evaluator;
346  }
347  }
348  }
349 
351 };
352 
353 
354 // evaluator for rvalues
355 template<typename Derived, typename Device>
356 struct TensorEvaluator<const TensorRef<Derived>, Device>
357 {
358  typedef typename Derived::Index Index;
359  typedef typename Derived::Scalar Scalar;
362  typedef typename Derived::Dimensions Dimensions;
363 
364  enum {
365  IsAligned = false,
366  PacketAccess = false,
368  CoordAccess = false, // to be implemented
369  RawAccess = false
370  };
371 
372  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvaluator(const TensorRef<Derived>& m, const Device&)
373  : m_ref(m)
374  { }
375 
376  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_ref.dimensions(); }
377 
378  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(Scalar*) {
379  return true;
380  }
381 
382  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void cleanup() { }
383 
384  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
385  return m_ref.coeff(index);
386  }
387 
388  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) {
389  return m_ref.coeffRef(index);
390  }
391 
392  EIGEN_DEVICE_FUNC Scalar* data() const { return m_ref.data(); }
393 
394  protected:
396 };
397 
398 
399 // evaluator for lvalues
400 template<typename Derived, typename Device>
401 struct TensorEvaluator<TensorRef<Derived>, Device> : public TensorEvaluator<const TensorRef<Derived>, Device>
402 {
403  typedef typename Derived::Index Index;
404  typedef typename Derived::Scalar Scalar;
407  typedef typename Derived::Dimensions Dimensions;
408 
410 
411  enum {
412  IsAligned = false,
413  PacketAccess = false,
414  RawAccess = false
415  };
416 
417  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvaluator(TensorRef<Derived>& m, const Device& d) : Base(m, d)
418  { }
419 
420  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) {
421  return this->m_ref.coeffRef(index);
422  }
423 };
424 
425 
426 
427 } // end namespace Eigen
428 
429 #endif // EIGEN_CXX11_TENSOR_TENSOR_REF_H
Matrix3f m
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions & dimensions() const
Definition: TensorRef.h:376
TensorLazyBaseEvaluator & operator=(const TensorLazyBaseEvaluator &other)
PacketType< CoeffReturnType, Device >::type PacketReturnType
Definition: TensorRef.h:406
SCALAR Scalar
Definition: bench_gemm.cpp:33
TensorRef< PlainObjectType > Self
Definition: TensorRef.h:122
#define EIGEN_STRONG_INLINE
Definition: Macros.h:494
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar & coeffRef(Index index)
Definition: TensorRef.h:335
virtual EIGEN_DEVICE_FUNC Scalar & coeffRef(DenseIndex index)
Definition: TensorRef.h:88
virtual EIGEN_DEVICE_FUNC const Dimensions & dimensions() const
Definition: TensorRef.h:56
virtual EIGEN_DEVICE_FUNC const Dimensions & dimensions() const =0
TensorRef(const TensorRef &other)
Definition: TensorRef.h:164
virtual EIGEN_DEVICE_FUNC Scalar & coeffRef(DenseIndex)
Definition: TensorRef.h:66
int n
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar * data() const
Definition: TensorRef.h:188
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar & coeffRef(Index i0, Index i1, Index i2, Index i3, Index i4)
Definition: TensorRef.h:279
A cost model used to limit the number of threads used for evaluating tensor expression.
internal::traits< PlainObjectType >::Index Index
Definition: TensorRef.h:126
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:150
internal::traits< PlainObjectType >::StorageKind StorageKind
Definition: TensorRef.h:125
TensorLazyEvaluator(const Expr &expr, const Device &device)
Definition: TensorRef.h:103
Scalar * PointerType
Definition: TensorRef.h:130
internal::traits< PlainObjectType >::Scalar Scalar
Definition: TensorRef.h:127
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
Definition: TensorRef.h:384
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(Index i0, Index i1, Index i2, Index i3, Index i4) const
Definition: TensorRef.h:241
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar & coeffRef(Index index)
Definition: TensorRef.h:388
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(Scalar *)
Definition: TensorRef.h:378
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvaluator(TensorRef< Derived > &m, const Device &d)
Definition: TensorRef.h:417
virtual EIGEN_DEVICE_FUNC const Scalar coeff(DenseIndex index) const
Definition: TensorRef.h:63
PlainObjectType::Base Base
Definition: TensorRef.h:123
PacketType< CoeffReturnType, Device >::type PacketReturnType
Definition: TensorRef.h:361
TensorEvaluator< Expr, Device > m_impl
Definition: TensorRef.h:69
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index dimension(Index n) const
Definition: TensorRef.h:182
TensorLazyEvaluatorReadOnly< Dimensions, Expr, Device > Base
Definition: TensorRef.h:80
Eigen::internal::nested< Self >::type Nested
Definition: TensorRef.h:124
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index index) const
Definition: TensorRef.h:329
PointerType PointerArgType
Definition: TensorRef.h:131
PlainObjectType::Dimensions Dimensions
Definition: TensorRef.h:134
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvaluator(const TensorRef< Derived > &m, const Device &)
Definition: TensorRef.h:372
internal::TensorLazyBaseEvaluator< Dimensions, Scalar > * m_evaluator
Definition: TensorRef.h:350
EIGEN_STRONG_INLINE TensorRef(const Expression &expr)
Definition: TensorRef.h:148
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_STRONG_INLINE void unrefEvaluator()
Definition: TensorRef.h:341
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar & coeffRef(const array< Index, NumIndices > &indices)
Definition: TensorRef.h:310
TensorLazyEvaluatorWritable(const Expr &expr, const Device &device)
Definition: TensorRef.h:83
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const
Definition: TensorRef.h:186
virtual EIGEN_DEVICE_FUNC const Scalar * data() const =0
#define NULL
Definition: ccolamd.c:609
virtual EIGEN_DEVICE_FUNC const Scalar coeff(DenseIndex index) const =0
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions & dimensions() const
Definition: TensorRef.h:184
The tensor base class.
Definition: TensorBase.h:829
EIGEN_DEFAULT_DENSE_INDEX_TYPE DenseIndex
Definition: Meta.h:25
TensorEvaluator< const TensorRef< Derived >, Device > Base
Definition: TensorRef.h:409
NumTraits< Scalar >::Real RealScalar
Definition: TensorRef.h:128
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar & coeffRef(Index i0, Index i1)
Definition: TensorRef.h:252
virtual EIGEN_DEVICE_FUNC Scalar & coeffRef(DenseIndex index)=0
TensorLazyEvaluatorReadOnly(const Expr &expr, const Device &device)
Definition: TensorRef.h:48
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(const array< Index, NumIndices > &indices) const
Definition: TensorRef.h:292
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(Index index) const
Definition: TensorRef.h:191
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(Index i0, Index i1, Index i2, Index i3) const
Definition: TensorRef.h:231
EIGEN_STRONG_INLINE TensorRef()
Definition: TensorRef.h:144
A reference to a tensor expression The expression will be evaluated lazily (as much as possible)...
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar & coeffRef(Index index)
Definition: TensorRef.h:420
Base::CoeffReturnType CoeffReturnType
Definition: TensorRef.h:129
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(Index i0, Index i1, Index i2) const
Definition: TensorRef.h:222
TensorEvaluator< Expr, Device >::Scalar Scalar
Definition: TensorRef.h:46
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar & operator()(Index i0, Index i1, Index i2, Index i3)
Definition: TensorRef.h:269
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar & coeffRef(Index i0, Index i1, Index i2)
Definition: TensorRef.h:260
virtual EIGEN_DEVICE_FUNC const Scalar * data() const
Definition: TensorRef.h:59
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void cleanup()
Definition: TensorRef.h:382
Definition: pytypes.h:897
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(Index i0, Index i1) const
Definition: TensorRef.h:214
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rank() const
Definition: TensorRef.h:180


gtsam
Author(s):
autogenerated on Sat May 8 2021 02:45:56