12 #ifndef EIGEN_MATRIXSTORAGE_H
13 #define EIGEN_MATRIXSTORAGE_H
15 #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
16 #define EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN EIGEN_DENSE_STORAGE_CTOR_PLUGIN;
18 #define EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN
25 struct constructor_without_unaligned_array_assert {};
27 template<
typename T,
int Size>
29 void check_static_allocation_size()
32 #if EIGEN_STACK_ALLOCATION_LIMIT
33 EIGEN_STATIC_ASSERT(Size *
sizeof(T) <= EIGEN_STACK_ALLOCATION_LIMIT, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG);
41 template <
typename T,
int Size,
int MatrixOrArrayOptions,
42 int Alignment = (MatrixOrArrayOptions&
DontAlign) ? 0
43 : compute_default_alignment<T,Size>::value >
51 check_static_allocation_size<T,Size>();
55 plain_array(constructor_without_unaligned_array_assert)
57 check_static_allocation_size<T,Size>();
61 #if defined(EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT)
62 #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask)
63 #elif EIGEN_GNUC_AT_LEAST(4,7)
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((reinterpret_cast<size_t>(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 !!! ****");
75 #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) \
76 eigen_assert((reinterpret_cast<size_t>(array) & (sizemask)) == 0 \
77 && "this assertion is explained here: " \
78 "http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html" \
79 " **** READ THIS WEB PAGE !!! ****");
82 template <
typename T,
int Size,
int MatrixOrArrayOptions>
83 struct plain_array<T, Size, MatrixOrArrayOptions, 8>
85 EIGEN_ALIGN_TO_BOUNDARY(8) T array[Size];
90 EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(7);
91 check_static_allocation_size<T,Size>();
95 plain_array(constructor_without_unaligned_array_assert)
97 check_static_allocation_size<T,Size>();
101 template <
typename T,
int Size,
int MatrixOrArrayOptions>
102 struct plain_array<T, Size, MatrixOrArrayOptions, 16>
104 EIGEN_ALIGN_TO_BOUNDARY(16) T array[Size];
109 EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(15);
110 check_static_allocation_size<T,Size>();
114 plain_array(constructor_without_unaligned_array_assert)
116 check_static_allocation_size<T,Size>();
120 template <
typename T,
int Size,
int MatrixOrArrayOptions>
121 struct plain_array<T, Size, MatrixOrArrayOptions, 32>
123 EIGEN_ALIGN_TO_BOUNDARY(32) T array[Size];
128 EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(31);
129 check_static_allocation_size<T,Size>();
133 plain_array(constructor_without_unaligned_array_assert)
135 check_static_allocation_size<T,Size>();
139 template <
typename T,
int Size,
int MatrixOrArrayOptions>
140 struct plain_array<T, Size, MatrixOrArrayOptions, 64>
142 EIGEN_ALIGN_TO_BOUNDARY(64) T array[Size];
147 EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(63);
148 check_static_allocation_size<T,Size>();
152 plain_array(constructor_without_unaligned_array_assert)
154 check_static_allocation_size<T,Size>();
158 template <
typename T,
int MatrixOrArrayOptions,
int Alignment>
159 struct plain_array<T, 0, MatrixOrArrayOptions, Alignment>
162 EIGEN_DEVICE_FUNC plain_array() {}
163 EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert) {}
180 template<
typename T,
int Size,
int _Rows,
int _Cols,
int _Options>
class DenseStorage;
183 template<
typename T,
int Size,
int _Rows,
int _Cols,
int _Options>
class DenseStorage
185 internal::plain_array<T,Size,_Options> m_data;
187 EIGEN_DEVICE_FUNC DenseStorage() {}
189 explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
190 : m_data(
internal::constructor_without_unaligned_array_assert()) {}
192 DenseStorage(
const DenseStorage& other) : m_data(other.m_data) {}
194 DenseStorage& operator=(
const DenseStorage& other)
196 if (
this != &other) m_data = other.m_data;
199 EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) {
200 EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN
201 eigen_internal_assert(size==rows*cols && rows==_Rows && cols==_Cols);
202 EIGEN_UNUSED_VARIABLE(size);
203 EIGEN_UNUSED_VARIABLE(rows);
204 EIGEN_UNUSED_VARIABLE(cols);
206 EIGEN_DEVICE_FUNC
void swap(DenseStorage& other) { std::swap(m_data,other.m_data); }
207 EIGEN_DEVICE_FUNC
static Index rows(
void) {
return _Rows;}
208 EIGEN_DEVICE_FUNC
static Index cols(
void) {
return _Cols;}
209 EIGEN_DEVICE_FUNC
void conservativeResize(Index,Index,Index) {}
210 EIGEN_DEVICE_FUNC
void resize(Index,Index,Index) {}
211 EIGEN_DEVICE_FUNC
const T *data()
const {
return m_data.array; }
212 EIGEN_DEVICE_FUNC T *data() {
return m_data.array; }
216 template<
typename T,
int _Rows,
int _Cols,
int _Options>
class DenseStorage<T, 0, _Rows, _Cols, _Options>
219 EIGEN_DEVICE_FUNC DenseStorage() {}
220 EIGEN_DEVICE_FUNC
explicit DenseStorage(internal::constructor_without_unaligned_array_assert) {}
221 EIGEN_DEVICE_FUNC DenseStorage(
const DenseStorage&) {}
222 EIGEN_DEVICE_FUNC DenseStorage& operator=(
const DenseStorage&) {
return *
this; }
223 EIGEN_DEVICE_FUNC DenseStorage(Index,Index,Index) {}
224 EIGEN_DEVICE_FUNC
void swap(DenseStorage& ) {}
225 EIGEN_DEVICE_FUNC
static Index rows(
void) {
return _Rows;}
226 EIGEN_DEVICE_FUNC
static Index cols(
void) {
return _Cols;}
227 EIGEN_DEVICE_FUNC
void conservativeResize(Index,Index,Index) {}
228 EIGEN_DEVICE_FUNC
void resize(Index,Index,Index) {}
229 EIGEN_DEVICE_FUNC
const T *data()
const {
return 0; }
230 EIGEN_DEVICE_FUNC T *data() {
return 0; }
234 template<
typename T,
int _Options>
class DenseStorage<T, 0, Dynamic, Dynamic, _Options>
235 :
public DenseStorage<T, 0, 0, 0, _Options> { };
237 template<
typename T,
int _Rows,
int _Options>
class DenseStorage<T, 0, _Rows, Dynamic, _Options>
238 :
public DenseStorage<T, 0, 0, 0, _Options> { };
240 template<
typename T,
int _Cols,
int _Options>
class DenseStorage<T, 0, Dynamic, _Cols, _Options>
241 :
public DenseStorage<T, 0, 0, 0, _Options> { };
244 template<
typename T,
int Size,
int _Options>
class DenseStorage<T, Size, Dynamic, Dynamic, _Options>
246 internal::plain_array<T,Size,_Options> m_data;
250 EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0), m_cols(0) {}
251 EIGEN_DEVICE_FUNC
explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
252 : m_data(
internal::constructor_without_unaligned_array_assert()), m_rows(0), m_cols(0) {}
253 EIGEN_DEVICE_FUNC DenseStorage(
const DenseStorage& other) : m_data(other.m_data), m_rows(other.m_rows), m_cols(other.m_cols) {}
254 EIGEN_DEVICE_FUNC DenseStorage& operator=(
const DenseStorage& other)
258 m_data = other.m_data;
259 m_rows = other.m_rows;
260 m_cols = other.m_cols;
264 EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index cols) : m_rows(rows), m_cols(cols) {}
265 EIGEN_DEVICE_FUNC
void swap(DenseStorage& other)
266 { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); }
267 EIGEN_DEVICE_FUNC Index rows()
const {
return m_rows;}
268 EIGEN_DEVICE_FUNC Index cols()
const {
return m_cols;}
269 EIGEN_DEVICE_FUNC
void conservativeResize(Index, Index rows, Index cols) { m_rows = rows; m_cols = cols; }
270 EIGEN_DEVICE_FUNC
void resize(Index, Index rows, Index cols) { m_rows = rows; m_cols = cols; }
271 EIGEN_DEVICE_FUNC
const T *data()
const {
return m_data.array; }
272 EIGEN_DEVICE_FUNC T *data() {
return m_data.array; }
276 template<
typename T,
int Size,
int _Cols,
int _Options>
class DenseStorage<T, Size, Dynamic, _Cols, _Options>
278 internal::plain_array<T,Size,_Options> m_data;
281 EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0) {}
282 EIGEN_DEVICE_FUNC
explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
283 : m_data(
internal::constructor_without_unaligned_array_assert()), m_rows(0) {}
284 EIGEN_DEVICE_FUNC DenseStorage(
const DenseStorage& other) : m_data(other.m_data), m_rows(other.m_rows) {}
285 EIGEN_DEVICE_FUNC DenseStorage& operator=(
const DenseStorage& other)
289 m_data = other.m_data;
290 m_rows = other.m_rows;
294 EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index) : m_rows(rows) {}
295 EIGEN_DEVICE_FUNC
void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); }
296 EIGEN_DEVICE_FUNC Index rows(
void)
const {
return m_rows;}
297 EIGEN_DEVICE_FUNC Index cols(
void)
const {
return _Cols;}
298 EIGEN_DEVICE_FUNC
void conservativeResize(Index, Index rows, Index) { m_rows = rows; }
299 EIGEN_DEVICE_FUNC
void resize(Index, Index rows, Index) { m_rows = rows; }
300 EIGEN_DEVICE_FUNC
const T *data()
const {
return m_data.array; }
301 EIGEN_DEVICE_FUNC T *data() {
return m_data.array; }
305 template<
typename T,
int Size,
int _Rows,
int _Options>
class DenseStorage<T, Size, _Rows, Dynamic, _Options>
307 internal::plain_array<T,Size,_Options> m_data;
310 EIGEN_DEVICE_FUNC DenseStorage() : m_cols(0) {}
311 EIGEN_DEVICE_FUNC
explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
312 : m_data(
internal::constructor_without_unaligned_array_assert()), m_cols(0) {}
313 EIGEN_DEVICE_FUNC DenseStorage(
const DenseStorage& other) : m_data(other.m_data), m_cols(other.m_cols) {}
314 EIGEN_DEVICE_FUNC DenseStorage& operator=(
const DenseStorage& other)
318 m_data = other.m_data;
319 m_cols = other.m_cols;
323 EIGEN_DEVICE_FUNC DenseStorage(Index, Index, Index cols) : m_cols(cols) {}
324 EIGEN_DEVICE_FUNC
void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); }
325 EIGEN_DEVICE_FUNC Index rows(
void)
const {
return _Rows;}
326 EIGEN_DEVICE_FUNC Index cols(
void)
const {
return m_cols;}
327 void conservativeResize(Index, Index, Index cols) { m_cols = cols; }
328 void resize(Index, Index, Index cols) { m_cols = cols; }
329 EIGEN_DEVICE_FUNC
const T *data()
const {
return m_data.array; }
330 EIGEN_DEVICE_FUNC T *data() {
return m_data.array; }
334 template<
typename T,
int _Options>
class DenseStorage<T, Dynamic, Dynamic, Dynamic, _Options>
340 EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_rows(0), m_cols(0) {}
341 EIGEN_DEVICE_FUNC
explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
342 : m_data(0), m_rows(0), m_cols(0) {}
343 EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols)
344 : m_data(
internal::conditional_aligned_new_auto<T,(_Options&
DontAlign)==0>(size)), m_rows(rows), m_cols(cols)
346 EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN
347 eigen_internal_assert(size==rows*cols && rows>=0 && cols >=0);
349 EIGEN_DEVICE_FUNC DenseStorage(
const DenseStorage& other)
350 : m_data(
internal::conditional_aligned_new_auto<T,(_Options&
DontAlign)==0>(other.m_rows*other.m_cols))
351 , m_rows(other.m_rows)
352 , m_cols(other.m_cols)
354 internal::smart_copy(other.m_data, other.m_data+other.m_rows*other.m_cols, m_data);
356 EIGEN_DEVICE_FUNC DenseStorage& operator=(
const DenseStorage& other)
360 DenseStorage tmp(other);
365 #ifdef EIGEN_HAVE_RVALUE_REFERENCES
367 DenseStorage(DenseStorage&& other)
368 : m_data(
std::move(other.m_data))
369 , m_rows(
std::move(other.m_rows))
370 , m_cols(
std::move(other.m_cols))
372 other.m_data =
nullptr;
377 DenseStorage& operator=(DenseStorage&& other)
380 swap(m_data, other.m_data);
381 swap(m_rows, other.m_rows);
382 swap(m_cols, other.m_cols);
386 EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols); }
387 EIGEN_DEVICE_FUNC
void swap(DenseStorage& other)
388 { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); }
389 EIGEN_DEVICE_FUNC Index rows(
void)
const {
return m_rows;}
390 EIGEN_DEVICE_FUNC Index cols(
void)
const {
return m_cols;}
391 void conservativeResize(Index size, Index rows, Index cols)
393 m_data = internal::conditional_aligned_realloc_new_auto<T,(_Options&DontAlign)==0>(m_data, size, m_rows*m_cols);
397 EIGEN_DEVICE_FUNC
void resize(Index size, Index rows, Index cols)
399 if(size != m_rows*m_cols)
401 internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
403 m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
406 EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN
411 EIGEN_DEVICE_FUNC
const T *data()
const {
return m_data; }
412 EIGEN_DEVICE_FUNC T *data() {
return m_data; }
416 template<
typename T,
int _Rows,
int _Options>
class DenseStorage<T, Dynamic, _Rows, Dynamic, _Options>
421 EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_cols(0) {}
422 explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_cols(0) {}
423 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)
425 EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN
426 eigen_internal_assert(size==rows*cols && rows==_Rows && cols >=0);
427 EIGEN_UNUSED_VARIABLE(rows);
429 EIGEN_DEVICE_FUNC DenseStorage(
const DenseStorage& other)
430 : m_data(
internal::conditional_aligned_new_auto<T,(_Options&
DontAlign)==0>(_Rows*other.m_cols))
431 , m_cols(other.m_cols)
433 internal::smart_copy(other.m_data, other.m_data+_Rows*m_cols, m_data);
435 EIGEN_DEVICE_FUNC DenseStorage& operator=(
const DenseStorage& other)
439 DenseStorage tmp(other);
444 #ifdef EIGEN_HAVE_RVALUE_REFERENCES
446 DenseStorage(DenseStorage&& other)
447 : m_data(
std::move(other.m_data))
448 , m_cols(
std::move(other.m_cols))
450 other.m_data =
nullptr;
454 DenseStorage& operator=(DenseStorage&& other)
457 swap(m_data, other.m_data);
458 swap(m_cols, other.m_cols);
462 EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols); }
463 EIGEN_DEVICE_FUNC
void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); }
464 EIGEN_DEVICE_FUNC
static Index rows(
void) {
return _Rows;}
465 EIGEN_DEVICE_FUNC Index cols(
void)
const {
return m_cols;}
466 EIGEN_DEVICE_FUNC
void conservativeResize(Index size, Index, Index cols)
468 m_data = internal::conditional_aligned_realloc_new_auto<T,(_Options&DontAlign)==0>(m_data, size, _Rows*m_cols);
471 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void resize(Index size, Index, Index cols)
473 if(size != _Rows*m_cols)
475 internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols);
477 m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
480 EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN
484 EIGEN_DEVICE_FUNC
const T *data()
const {
return m_data; }
485 EIGEN_DEVICE_FUNC T *data() {
return m_data; }
489 template<
typename T,
int _Cols,
int _Options>
class DenseStorage<T, Dynamic, Dynamic, _Cols, _Options>
494 EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_rows(0) {}
495 explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_rows(0) {}
496 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)
498 EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN
499 eigen_internal_assert(size==rows*cols && rows>=0 && cols == _Cols);
500 EIGEN_UNUSED_VARIABLE(cols);
502 EIGEN_DEVICE_FUNC DenseStorage(
const DenseStorage& other)
503 : m_data(
internal::conditional_aligned_new_auto<T,(_Options&
DontAlign)==0>(other.m_rows*_Cols))
504 , m_rows(other.m_rows)
506 internal::smart_copy(other.m_data, other.m_data+other.m_rows*_Cols, m_data);
508 EIGEN_DEVICE_FUNC DenseStorage& operator=(
const DenseStorage& other)
512 DenseStorage tmp(other);
517 #ifdef EIGEN_HAVE_RVALUE_REFERENCES
519 DenseStorage(DenseStorage&& other)
520 : m_data(
std::move(other.m_data))
521 , m_rows(
std::move(other.m_rows))
523 other.m_data =
nullptr;
527 DenseStorage& operator=(DenseStorage&& other)
530 swap(m_data, other.m_data);
531 swap(m_rows, other.m_rows);
535 EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows); }
536 EIGEN_DEVICE_FUNC
void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); }
537 EIGEN_DEVICE_FUNC Index rows(
void)
const {
return m_rows;}
538 EIGEN_DEVICE_FUNC
static Index cols(
void) {
return _Cols;}
539 void conservativeResize(Index size, Index rows, Index)
541 m_data = internal::conditional_aligned_realloc_new_auto<T,(_Options&DontAlign)==0>(m_data, size, m_rows*_Cols);
544 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void resize(Index size, Index rows, Index)
546 if(size != m_rows*_Cols)
548 internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows);
550 m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
553 EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN
557 EIGEN_DEVICE_FUNC
const T *data()
const {
return m_data; }
558 EIGEN_DEVICE_FUNC T *data() {
return m_data; }
563 #endif // EIGEN_MATRIX_H
Definition: StdDeque.h:58
Definition: Eigen_Colamd.h:54
Definition: Constants.h:326