DenseStorage.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) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
5 // Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
6 // Copyright (C) 2010-2013 Hauke Heibel <hauke.heibel@gmail.com>
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 #ifndef EIGEN_MATRIXSTORAGE_H
13 #define EIGEN_MATRIXSTORAGE_H
14 
15 #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
16  #define EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(X) X; EIGEN_DENSE_STORAGE_CTOR_PLUGIN;
17 #else
18  #define EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(X)
19 #endif
20 
21 namespace Eigen {
22 
23 namespace internal {
24 
26 
27 template<typename T, int Size>
28 EIGEN_DEVICE_FUNC
30 {
31  // if EIGEN_STACK_ALLOCATION_LIMIT is defined to 0, then no limit
32  #if EIGEN_STACK_ALLOCATION_LIMIT
33  EIGEN_STATIC_ASSERT(Size * sizeof(T) <= EIGEN_STACK_ALLOCATION_LIMIT, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG);
34  #endif
35 }
36 
41 template <typename T, int Size, int MatrixOrArrayOptions,
42  int Alignment = (MatrixOrArrayOptions&DontAlign) ? 0
45 {
46  T array[Size];
47 
48  EIGEN_DEVICE_FUNC
50  {
51  check_static_allocation_size<T,Size>();
52  }
53 
54  EIGEN_DEVICE_FUNC
56  {
57  check_static_allocation_size<T,Size>();
58  }
59 };
60 
61 #if defined(EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT)
62  #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask)
63 #elif EIGEN_GNUC_AT_LEAST(4,7)
64  // GCC 4.7 is too aggressive in its optimizations and remove the alignement test based on the fact the array is declared to be aligned.
65  // See this bug report: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53900
66  // Hiding the origin of the array pointer behind a function argument seems to do the trick even if the function is inlined:
67  template<typename PtrType>
68  EIGEN_ALWAYS_INLINE PtrType eigen_unaligned_array_assert_workaround_gcc47(PtrType array) { return array; }
69  #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) \
70  eigen_assert((internal::UIntPtr(eigen_unaligned_array_assert_workaround_gcc47(array)) & (sizemask)) == 0 \
71  && "this assertion is explained here: " \
72  "http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html" \
73  " **** READ THIS WEB PAGE !!! ****");
74 #else
75  #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) \
76  eigen_assert((internal::UIntPtr(array) & (sizemask)) == 0 \
77  && "this assertion is explained here: " \
78  "http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html" \
79  " **** READ THIS WEB PAGE !!! ****");
80 #endif
81 
82 template <typename T, int Size, int MatrixOrArrayOptions>
84 {
85  EIGEN_ALIGN_TO_BOUNDARY(8) T array[Size];
86 
87  EIGEN_DEVICE_FUNC
89  {
91  check_static_allocation_size<T,Size>();
92  }
93 
94  EIGEN_DEVICE_FUNC
96  {
97  check_static_allocation_size<T,Size>();
98  }
99 };
100 
101 template <typename T, int Size, int MatrixOrArrayOptions>
103 {
104  EIGEN_ALIGN_TO_BOUNDARY(16) T array[Size];
105 
106  EIGEN_DEVICE_FUNC
108  {
110  check_static_allocation_size<T,Size>();
111  }
112 
113  EIGEN_DEVICE_FUNC
115  {
116  check_static_allocation_size<T,Size>();
117  }
118 };
119 
120 template <typename T, int Size, int MatrixOrArrayOptions>
122 {
123  EIGEN_ALIGN_TO_BOUNDARY(32) T array[Size];
124 
125  EIGEN_DEVICE_FUNC
127  {
129  check_static_allocation_size<T,Size>();
130  }
131 
132  EIGEN_DEVICE_FUNC
134  {
135  check_static_allocation_size<T,Size>();
136  }
137 };
138 
139 template <typename T, int Size, int MatrixOrArrayOptions>
141 {
142  EIGEN_ALIGN_TO_BOUNDARY(64) T array[Size];
143 
144  EIGEN_DEVICE_FUNC
146  {
148  check_static_allocation_size<T,Size>();
149  }
150 
151  EIGEN_DEVICE_FUNC
153  {
154  check_static_allocation_size<T,Size>();
155  }
156 };
157 
158 template <typename T, int MatrixOrArrayOptions, int Alignment>
160 {
161  T array[1];
162  EIGEN_DEVICE_FUNC plain_array() {}
164 };
165 
166 } // end namespace internal
167 
180 template<typename T, int Size, int _Rows, int _Cols, int _Options> class DenseStorage;
181 
182 // purely fixed-size matrix
183 template<typename T, int Size, int _Rows, int _Cols, int _Options> class DenseStorage
184 {
186  public:
187  EIGEN_DEVICE_FUNC DenseStorage() {
189  }
190  EIGEN_DEVICE_FUNC
192  : m_data(internal::constructor_without_unaligned_array_assert()) {}
193  EIGEN_DEVICE_FUNC
194  DenseStorage(const DenseStorage& other) : m_data(other.m_data) {
196  }
197  EIGEN_DEVICE_FUNC
198  DenseStorage& operator=(const DenseStorage& other)
199  {
200  if (this != &other) m_data = other.m_data;
201  return *this;
202  }
203  EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) {
205  eigen_internal_assert(size==rows*cols && rows==_Rows && cols==_Cols);
206  EIGEN_UNUSED_VARIABLE(size);
207  EIGEN_UNUSED_VARIABLE(rows);
208  EIGEN_UNUSED_VARIABLE(cols);
209  }
210  EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { std::swap(m_data,other.m_data); }
211  EIGEN_DEVICE_FUNC static Index rows(void) {return _Rows;}
212  EIGEN_DEVICE_FUNC static Index cols(void) {return _Cols;}
213  EIGEN_DEVICE_FUNC void conservativeResize(Index,Index,Index) {}
214  EIGEN_DEVICE_FUNC void resize(Index,Index,Index) {}
215  EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
216  EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
217 };
218 
219 // null matrix
220 template<typename T, int _Rows, int _Cols, int _Options> class DenseStorage<T, 0, _Rows, _Cols, _Options>
221 {
222  public:
223  EIGEN_DEVICE_FUNC DenseStorage() {}
225  EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage&) {}
226  EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage&) { return *this; }
227  EIGEN_DEVICE_FUNC DenseStorage(Index,Index,Index) {}
228  EIGEN_DEVICE_FUNC void swap(DenseStorage& ) {}
229  EIGEN_DEVICE_FUNC static Index rows(void) {return _Rows;}
230  EIGEN_DEVICE_FUNC static Index cols(void) {return _Cols;}
231  EIGEN_DEVICE_FUNC void conservativeResize(Index,Index,Index) {}
232  EIGEN_DEVICE_FUNC void resize(Index,Index,Index) {}
233  EIGEN_DEVICE_FUNC const T *data() const { return 0; }
234  EIGEN_DEVICE_FUNC T *data() { return 0; }
235 };
236 
237 // more specializations for null matrices; these are necessary to resolve ambiguities
238 template<typename T, int _Options> class DenseStorage<T, 0, Dynamic, Dynamic, _Options>
240 
241 template<typename T, int _Rows, int _Options> class DenseStorage<T, 0, _Rows, Dynamic, _Options>
243 
244 template<typename T, int _Cols, int _Options> class DenseStorage<T, 0, Dynamic, _Cols, _Options>
246 
247 // dynamic-size matrix with fixed-size storage
248 template<typename T, int Size, int _Options> class DenseStorage<T, Size, Dynamic, Dynamic, _Options>
249 {
253  public:
254  EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0), m_cols(0) {}
256  : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0), m_cols(0) {}
257  EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other.m_data), m_rows(other.m_rows), m_cols(other.m_cols) {}
258  EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
259  {
260  if (this != &other)
261  {
262  m_data = other.m_data;
263  m_rows = other.m_rows;
264  m_cols = other.m_cols;
265  }
266  return *this;
267  }
268  EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index cols) : m_rows(rows), m_cols(cols) {}
269  EIGEN_DEVICE_FUNC void swap(DenseStorage& other)
270  { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); }
271  EIGEN_DEVICE_FUNC Index rows() const {return m_rows;}
272  EIGEN_DEVICE_FUNC Index cols() const {return m_cols;}
273  EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index cols) { m_rows = rows; m_cols = cols; }
274  EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index cols) { m_rows = rows; m_cols = cols; }
275  EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
276  EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
277 };
278 
279 // dynamic-size matrix with fixed-size storage and fixed width
280 template<typename T, int Size, int _Cols, int _Options> class DenseStorage<T, Size, Dynamic, _Cols, _Options>
281 {
284  public:
285  EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0) {}
287  : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0) {}
288  EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other.m_data), m_rows(other.m_rows) {}
289  EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
290  {
291  if (this != &other)
292  {
293  m_data = other.m_data;
294  m_rows = other.m_rows;
295  }
296  return *this;
297  }
298  EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index) : m_rows(rows) {}
299  EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); }
300  EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;}
301  EIGEN_DEVICE_FUNC Index cols(void) const {return _Cols;}
302  EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index) { m_rows = rows; }
303  EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index) { m_rows = rows; }
304  EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
305  EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
306 };
307 
308 // dynamic-size matrix with fixed-size storage and fixed height
309 template<typename T, int Size, int _Rows, int _Options> class DenseStorage<T, Size, _Rows, Dynamic, _Options>
310 {
313  public:
314  EIGEN_DEVICE_FUNC DenseStorage() : m_cols(0) {}
316  : m_data(internal::constructor_without_unaligned_array_assert()), m_cols(0) {}
317  EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other.m_data), m_cols(other.m_cols) {}
318  EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
319  {
320  if (this != &other)
321  {
322  m_data = other.m_data;
323  m_cols = other.m_cols;
324  }
325  return *this;
326  }
327  EIGEN_DEVICE_FUNC DenseStorage(Index, Index, Index cols) : m_cols(cols) {}
328  EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); }
329  EIGEN_DEVICE_FUNC Index rows(void) const {return _Rows;}
330  EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;}
331  void conservativeResize(Index, Index, Index cols) { m_cols = cols; }
332  void resize(Index, Index, Index cols) { m_cols = cols; }
333  EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
334  EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
335 };
336 
337 // purely dynamic matrix.
338 template<typename T, int _Options> class DenseStorage<T, Dynamic, Dynamic, Dynamic, _Options>
339 {
343  public:
344  EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_rows(0), m_cols(0) {}
346  : m_data(0), m_rows(0), m_cols(0) {}
347  EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols)
348  : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size)), m_rows(rows), m_cols(cols)
349  {
351  eigen_internal_assert(size==rows*cols && rows>=0 && cols >=0);
352  }
353  EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
354  : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(other.m_rows*other.m_cols))
355  , m_rows(other.m_rows)
356  , m_cols(other.m_cols)
357  {
359  internal::smart_copy(other.m_data, other.m_data+other.m_rows*other.m_cols, m_data);
360  }
361  EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
362  {
363  if (this != &other)
364  {
365  DenseStorage tmp(other);
366  this->swap(tmp);
367  }
368  return *this;
369  }
370 #if EIGEN_HAS_RVALUE_REFERENCES
371  EIGEN_DEVICE_FUNC
372  DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT
373  : m_data(std::move(other.m_data))
374  , m_rows(std::move(other.m_rows))
375  , m_cols(std::move(other.m_cols))
376  {
377  other.m_data = nullptr;
378  other.m_rows = 0;
379  other.m_cols = 0;
380  }
381  EIGEN_DEVICE_FUNC
382  DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT
383  {
384  using std::swap;
385  swap(m_data, other.m_data);
386  swap(m_rows, other.m_rows);
387  swap(m_cols, other.m_cols);
388  return *this;
389  }
390 #endif
391  EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols); }
392  EIGEN_DEVICE_FUNC void swap(DenseStorage& other)
393  { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); }
394  EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;}
395  EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;}
397  {
398  m_data = internal::conditional_aligned_realloc_new_auto<T,(_Options&DontAlign)==0>(m_data, size, m_rows*m_cols);
399  m_rows = rows;
400  m_cols = cols;
401  }
402  EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols)
403  {
404  if(size != m_rows*m_cols)
405  {
406  internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
407  if (size)
408  m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
409  else
410  m_data = 0;
412  }
413  m_rows = rows;
414  m_cols = cols;
415  }
416  EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
417  EIGEN_DEVICE_FUNC T *data() { return m_data; }
418 };
419 
420 // matrix with dynamic width and fixed height (so that matrix has dynamic size).
421 template<typename T, int _Rows, int _Options> class DenseStorage<T, Dynamic, _Rows, Dynamic, _Options>
422 {
425  public:
426  EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_cols(0) {}
428  EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size)), m_cols(cols)
429  {
431  eigen_internal_assert(size==rows*cols && rows==_Rows && cols >=0);
432  EIGEN_UNUSED_VARIABLE(rows);
433  }
434  EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
435  : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(_Rows*other.m_cols))
436  , m_cols(other.m_cols)
437  {
439  internal::smart_copy(other.m_data, other.m_data+_Rows*m_cols, m_data);
440  }
441  EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
442  {
443  if (this != &other)
444  {
445  DenseStorage tmp(other);
446  this->swap(tmp);
447  }
448  return *this;
449  }
450 #if EIGEN_HAS_RVALUE_REFERENCES
451  EIGEN_DEVICE_FUNC
452  DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT
453  : m_data(std::move(other.m_data))
454  , m_cols(std::move(other.m_cols))
455  {
456  other.m_data = nullptr;
457  other.m_cols = 0;
458  }
459  EIGEN_DEVICE_FUNC
460  DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT
461  {
462  using std::swap;
463  swap(m_data, other.m_data);
464  swap(m_cols, other.m_cols);
465  return *this;
466  }
467 #endif
468  EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols); }
469  EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); }
470  EIGEN_DEVICE_FUNC static Index rows(void) {return _Rows;}
471  EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;}
472  EIGEN_DEVICE_FUNC void conservativeResize(Index size, Index, Index cols)
473  {
474  m_data = internal::conditional_aligned_realloc_new_auto<T,(_Options&DontAlign)==0>(m_data, size, _Rows*m_cols);
475  m_cols = cols;
476  }
477  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index, Index cols)
478  {
479  if(size != _Rows*m_cols)
480  {
481  internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols);
482  if (size)
483  m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
484  else
485  m_data = 0;
487  }
488  m_cols = cols;
489  }
490  EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
491  EIGEN_DEVICE_FUNC T *data() { return m_data; }
492 };
493 
494 // matrix with dynamic height and fixed width (so that matrix has dynamic size).
495 template<typename T, int _Cols, int _Options> class DenseStorage<T, Dynamic, Dynamic, _Cols, _Options>
496 {
499  public:
500  EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_rows(0) {}
502  EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size)), m_rows(rows)
503  {
505  eigen_internal_assert(size==rows*cols && rows>=0 && cols == _Cols);
506  EIGEN_UNUSED_VARIABLE(cols);
507  }
508  EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
509  : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(other.m_rows*_Cols))
510  , m_rows(other.m_rows)
511  {
513  internal::smart_copy(other.m_data, other.m_data+other.m_rows*_Cols, m_data);
514  }
515  EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
516  {
517  if (this != &other)
518  {
519  DenseStorage tmp(other);
520  this->swap(tmp);
521  }
522  return *this;
523  }
524 #if EIGEN_HAS_RVALUE_REFERENCES
525  EIGEN_DEVICE_FUNC
526  DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT
527  : m_data(std::move(other.m_data))
528  , m_rows(std::move(other.m_rows))
529  {
530  other.m_data = nullptr;
531  other.m_rows = 0;
532  }
533  EIGEN_DEVICE_FUNC
534  DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT
535  {
536  using std::swap;
537  swap(m_data, other.m_data);
538  swap(m_rows, other.m_rows);
539  return *this;
540  }
541 #endif
542  EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows); }
543  EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); }
544  EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;}
545  EIGEN_DEVICE_FUNC static Index cols(void) {return _Cols;}
547  {
548  m_data = internal::conditional_aligned_realloc_new_auto<T,(_Options&DontAlign)==0>(m_data, size, m_rows*_Cols);
549  m_rows = rows;
550  }
551  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index rows, Index)
552  {
553  if(size != m_rows*_Cols)
554  {
555  internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows);
556  if (size)
557  m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
558  else
559  m_data = 0;
561  }
562  m_rows = rows;
563  }
564  EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
565  EIGEN_DEVICE_FUNC T *data() { return m_data; }
566 };
567 
568 } // end namespace Eigen
569 
570 #endif // EIGEN_MATRIX_H
EIGEN_DEVICE_FUNC DenseStorage(internal::constructor_without_unaligned_array_assert)
Definition: DenseStorage.h:315
EIGEN_DEVICE_FUNC T * conditional_aligned_new_auto(std::size_t size)
Definition: Memory.h:369
int array[24]
#define EIGEN_ALWAYS_INLINE
Definition: Macros.h:509
#define EIGEN_STRONG_INLINE
Definition: Macros.h:494
EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert)
Definition: DenseStorage.h:114
internal::plain_array< T, Size, _Options > m_data
Definition: DenseStorage.h:282
EIGEN_DEVICE_FUNC DenseStorage(internal::constructor_without_unaligned_array_assert)
Definition: DenseStorage.h:191
EIGEN_DEVICE_FUNC DenseStorage()
Definition: DenseStorage.h:187
EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert)
Definition: DenseStorage.h:163
EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols)
Definition: DenseStorage.h:203
EIGEN_DEVICE_FUNC void resize(Index, Index, Index)
Definition: DenseStorage.h:214
EIGEN_DEVICE_FUNC void swap(DenseStorage &other)
Definition: DenseStorage.h:543
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
EIGEN_DEVICE_FUNC T * data()
Definition: DenseStorage.h:216
DenseStorage(internal::constructor_without_unaligned_array_assert)
Definition: DenseStorage.h:427
#define EIGEN_STATIC_ASSERT(CONDITION, MSG)
Definition: StaticAssert.h:124
static EIGEN_DEVICE_FUNC Index rows(void)
Definition: DenseStorage.h:211
EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols)
Definition: DenseStorage.h:347
EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index cols)
Definition: DenseStorage.h:274
EIGEN_DEVICE_FUNC void swap(DenseStorage &other)
Definition: DenseStorage.h:299
EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols)
Definition: DenseStorage.h:502
internal::plain_array< T, Size, _Options > m_data
Definition: DenseStorage.h:311
Scalar Scalar int size
Definition: benchVecAdd.cpp:17
EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage &other)
Definition: DenseStorage.h:508
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index, Index cols)
Definition: DenseStorage.h:477
EIGEN_DEVICE_FUNC void smart_copy(const T *start, const T *end, T *target)
Definition: Memory.h:485
EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert)
Definition: DenseStorage.h:55
EIGEN_DEVICE_FUNC void resize(Index, Index, Index)
Definition: DenseStorage.h:232
EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols)
Definition: DenseStorage.h:402
#define EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(X)
Definition: DenseStorage.h:18
EIGEN_DEVICE_FUNC DenseStorage & operator=(const DenseStorage &other)
Definition: DenseStorage.h:361
EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage &other)
Definition: DenseStorage.h:353
static EIGEN_DEVICE_FUNC Index cols(void)
Definition: DenseStorage.h:230
EIGEN_DEVICE_FUNC void swap(DenseStorage &other)
Definition: DenseStorage.h:269
EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index)
Definition: DenseStorage.h:303
#define EIGEN_NOEXCEPT
Definition: Macros.h:989
EIGEN_DEVICE_FUNC void swap(DenseStorage &)
Definition: DenseStorage.h:228
EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage &other)
Definition: DenseStorage.h:434
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index cols)
Definition: DenseStorage.h:273
Eigen::Triplet< double > T
EIGEN_DEVICE_FUNC DenseStorage(internal::constructor_without_unaligned_array_assert)
Definition: DenseStorage.h:286
EIGEN_DEVICE_FUNC void swap(DenseStorage &other)
Definition: DenseStorage.h:392
EIGEN_DEVICE_FUNC DenseStorage & operator=(const DenseStorage &other)
Definition: DenseStorage.h:515
EIGEN_DEVICE_FUNC void swap(DenseStorage &other)
Definition: DenseStorage.h:328
#define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask)
Definition: DenseStorage.h:75
EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols)
Definition: DenseStorage.h:428
EIGEN_DEVICE_FUNC DenseStorage & operator=(const DenseStorage &other)
Definition: DenseStorage.h:258
void conservativeResize(Index size, Index rows, Index cols)
Definition: DenseStorage.h:396
EIGEN_DEVICE_FUNC DenseStorage(internal::constructor_without_unaligned_array_assert)
Definition: DenseStorage.h:224
A small structure to hold a non zero as a triplet (i,j,value).
Definition: SparseUtil.h:154
EIGEN_DEVICE_FUNC void swap(DenseStorage &other)
Definition: DenseStorage.h:210
EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage &other)
Definition: DenseStorage.h:317
DenseStorage(internal::constructor_without_unaligned_array_assert)
Definition: DenseStorage.h:501
EIGEN_DEVICE_FUNC void conservativeResize(Index, Index, Index)
Definition: DenseStorage.h:231
static EIGEN_DEVICE_FUNC Index rows(void)
Definition: DenseStorage.h:229
EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage &other)
Definition: DenseStorage.h:257
EIGEN_DEVICE_FUNC void conservativeResize(Index, Index, Index)
Definition: DenseStorage.h:213
EIGEN_DEVICE_FUNC DenseStorage(Index, Index, Index)
Definition: DenseStorage.h:227
EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index)
Definition: DenseStorage.h:302
EIGEN_DEVICE_FUNC DenseStorage & operator=(const DenseStorage &other)
Definition: DenseStorage.h:198
internal::plain_array< T, Size, _Options > m_data
Definition: DenseStorage.h:250
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index rows, Index)
Definition: DenseStorage.h:551
EIGEN_DEVICE_FUNC DenseStorage & operator=(const DenseStorage &other)
Definition: DenseStorage.h:289
#define EIGEN_STACK_ALLOCATION_LIMIT
Definition: Macros.h:801
EIGEN_DEVICE_FUNC DenseStorage(internal::constructor_without_unaligned_array_assert)
Definition: DenseStorage.h:345
EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index cols)
Definition: DenseStorage.h:268
EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage &)
Definition: DenseStorage.h:225
EIGEN_DEVICE_FUNC DenseStorage & operator=(const DenseStorage &other)
Definition: DenseStorage.h:441
EIGEN_DEVICE_FUNC void conservativeResize(Index size, Index, Index cols)
Definition: DenseStorage.h:472
#define eigen_internal_assert(x)
Definition: Macros.h:585
EIGEN_DEVICE_FUNC const T * data() const
Definition: DenseStorage.h:215
static EIGEN_DEVICE_FUNC Index cols(void)
Definition: DenseStorage.h:212
internal::plain_array< T, Size, _Options > m_data
Definition: DenseStorage.h:185
EIGEN_DEVICE_FUNC DenseStorage & operator=(const DenseStorage &other)
Definition: DenseStorage.h:318
EIGEN_DEVICE_FUNC DenseStorage & operator=(const DenseStorage &)
Definition: DenseStorage.h:226
EIGEN_DEVICE_FUNC void check_static_allocation_size()
Definition: DenseStorage.h:29
EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage &other)
Definition: DenseStorage.h:194
EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert)
Definition: DenseStorage.h:152
EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert)
Definition: DenseStorage.h:95
EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage &other)
Definition: DenseStorage.h:288
void conservativeResize(Index size, Index rows, Index)
Definition: DenseStorage.h:546
void swap(mpfr::mpreal &x, mpfr::mpreal &y)
Definition: mpreal.h:2986
EIGEN_DEVICE_FUNC DenseStorage(internal::constructor_without_unaligned_array_assert)
Definition: DenseStorage.h:255
#define EIGEN_UNUSED_VARIABLE(var)
Definition: Macros.h:618
EIGEN_DEVICE_FUNC plain_array()
Definition: DenseStorage.h:49
EIGEN_DEVICE_FUNC void swap(DenseStorage &other)
Definition: DenseStorage.h:469
EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index)
Definition: DenseStorage.h:298
EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert)
Definition: DenseStorage.h:133
void swap(scoped_array< T > &a, scoped_array< T > &b)
Definition: Memory.h:602
EIGEN_DEVICE_FUNC DenseStorage(Index, Index, Index cols)
Definition: DenseStorage.h:327
EIGEN_DEVICE_FUNC const T * data() const
Definition: DenseStorage.h:233


gtsam
Author(s):
autogenerated on Sat May 8 2021 02:41:58