Eigen  3.3.90 (mercurial changeset 94875feeeeb9)
Matrix.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 // Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
6 //
7 // This Source Code Form is subject to the terms of the Mozilla
8 // Public License v. 2.0. If a copy of the MPL was not distributed
9 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
10 
11 #ifndef EIGEN_MATRIX_H
12 #define EIGEN_MATRIX_H
13 
14 namespace Eigen {
15 
16 namespace internal {
17 template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
18 struct traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
19 {
20 private:
21  enum { size = internal::size_at_compile_time<_Rows,_Cols>::ret };
22  typedef typename find_best_packet<_Scalar,size>::type PacketScalar;
23  enum {
24  row_major_bit = _Options&RowMajor ? RowMajorBit : 0,
25  is_dynamic_size_storage = _MaxRows==Dynamic || _MaxCols==Dynamic,
26  max_size = is_dynamic_size_storage ? Dynamic : _MaxRows*_MaxCols,
27  default_alignment = compute_default_alignment<_Scalar,max_size>::value,
28  actual_alignment = ((_Options&DontAlign)==0) ? default_alignment : 0,
29  required_alignment = unpacket_traits<PacketScalar>::alignment,
30  packet_access_bit = (packet_traits<_Scalar>::Vectorizable && (EIGEN_UNALIGNED_VECTORIZE || (actual_alignment>=required_alignment))) ? PacketAccessBit : 0
31  };
32 
33 public:
34  typedef _Scalar Scalar;
35  typedef Dense StorageKind;
36  typedef Eigen::Index StorageIndex;
37  typedef MatrixXpr XprKind;
38  enum {
39  RowsAtCompileTime = _Rows,
40  ColsAtCompileTime = _Cols,
41  MaxRowsAtCompileTime = _MaxRows,
42  MaxColsAtCompileTime = _MaxCols,
43  Flags = compute_matrix_flags<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::ret,
44  Options = _Options,
45  InnerStrideAtCompileTime = 1,
46  OuterStrideAtCompileTime = (Options&RowMajor) ? ColsAtCompileTime : RowsAtCompileTime,
47 
48  // FIXME, the following flag in only used to define NeedsToAlign in PlainObjectBase
49  EvaluatorFlags = LinearAccessBit | DirectAccessBit | packet_access_bit | row_major_bit,
50  Alignment = actual_alignment
51  };
52 };
53 }
54 
177 template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
178 class Matrix
179  : public PlainObjectBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
180 {
181  public:
182 
187 
188  enum { Options = _Options };
189 
190  EIGEN_DENSE_PUBLIC_INTERFACE(Matrix)
191 
192  typedef typename Base::PlainObject PlainObject;
193 
194  using Base::base;
195  using Base::coeffRef;
196 
205  EIGEN_DEVICE_FUNC
206  EIGEN_STRONG_INLINE Matrix& operator=(const Matrix& other)
207  {
208  return Base::_set(other);
209  }
210 
221  template<typename OtherDerived>
222  EIGEN_DEVICE_FUNC
223  EIGEN_STRONG_INLINE Matrix& operator=(const DenseBase<OtherDerived>& other)
224  {
225  return Base::_set(other);
226  }
227 
228  /* Here, doxygen failed to copy the brief information when using \copydoc */
229 
234  template<typename OtherDerived>
235  EIGEN_DEVICE_FUNC
236  EIGEN_STRONG_INLINE Matrix& operator=(const EigenBase<OtherDerived> &other)
237  {
238  return Base::operator=(other);
239  }
240 
241  template<typename OtherDerived>
242  EIGEN_DEVICE_FUNC
243  EIGEN_STRONG_INLINE Matrix& operator=(const ReturnByValue<OtherDerived>& func)
244  {
245  return Base::operator=(func);
246  }
247 
258  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
259  Matrix() : Base()
260  {
261  Base::_check_template_params();
262  EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
263  }
264 
265  // FIXME is it still needed
266  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
267  explicit Matrix(internal::constructor_without_unaligned_array_assert)
268  : Base(internal::constructor_without_unaligned_array_assert())
269  { Base::_check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED }
270 
271 #if EIGEN_HAS_RVALUE_REFERENCES
272  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
273  Matrix(Matrix&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_constructible<Scalar>::value)
274  : Base(std::move(other))
275  {
276  Base::_check_template_params();
277  }
278  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
279  Matrix& operator=(Matrix&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable<Scalar>::value)
280  {
281  other.swap(*this);
282  return *this;
283  }
284 #endif
285 
286 #if EIGEN_HAS_CXX11
287 
294  template <typename... ArgTypes>
295  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
296  Matrix(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args)
297  : Base(a0, a1, a2, a3, args...) {}
298 
320  EIGEN_DEVICE_FUNC
321  explicit EIGEN_STRONG_INLINE Matrix(const std::initializer_list<std::initializer_list<Scalar>>& list) : Base(list) {}
322 #endif // end EIGEN_HAS_CXX11
323 
324 #ifndef EIGEN_PARSED_BY_DOXYGEN
325 
326  // This constructor is for both 1x1 matrices and dynamic vectors
327  template<typename T>
328  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
329  explicit Matrix(const T& x)
330  {
331  Base::_check_template_params();
332  Base::template _init1<T>(x);
333  }
334 
335  template<typename T0, typename T1>
336  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
337  Matrix(const T0& x, const T1& y)
338  {
339  Base::_check_template_params();
340  Base::template _init2<T0,T1>(x, y);
341  }
342 
343 
344 #else
345 
346  EIGEN_DEVICE_FUNC
347  explicit Matrix(const Scalar *data);
348 
361  EIGEN_STRONG_INLINE explicit Matrix(Index dim);
364  Matrix(const Scalar& x);
377  EIGEN_DEVICE_FUNC
378  Matrix(Index rows, Index cols);
379 
382  Matrix(const Scalar& x, const Scalar& y);
383  #endif // end EIGEN_PARSED_BY_DOXYGEN
384 
388  EIGEN_DEVICE_FUNC
389  EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z)
390  {
391  Base::_check_template_params();
392  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Matrix, 3)
393  m_storage.data()[0] = x;
394  m_storage.data()[1] = y;
395  m_storage.data()[2] = z;
396  }
400  EIGEN_DEVICE_FUNC
401  EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z, const Scalar& w)
402  {
403  Base::_check_template_params();
404  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Matrix, 4)
405  m_storage.data()[0] = x;
406  m_storage.data()[1] = y;
407  m_storage.data()[2] = z;
408  m_storage.data()[3] = w;
409  }
410 
411 
413  EIGEN_DEVICE_FUNC
414  EIGEN_STRONG_INLINE Matrix(const Matrix& other) : Base(other)
415  { }
416 
420  template<typename OtherDerived>
421  EIGEN_DEVICE_FUNC
422  EIGEN_STRONG_INLINE Matrix(const EigenBase<OtherDerived> &other)
423  : Base(other.derived())
424  { }
425 
426  EIGEN_DEVICE_FUNC inline Index innerStride() const { return 1; }
427  EIGEN_DEVICE_FUNC inline Index outerStride() const { return this->innerSize(); }
428 
430 
431  template<typename OtherDerived>
432  EIGEN_DEVICE_FUNC
433  explicit Matrix(const RotationBase<OtherDerived,ColsAtCompileTime>& r);
434  template<typename OtherDerived>
435  EIGEN_DEVICE_FUNC
436  Matrix& operator=(const RotationBase<OtherDerived,ColsAtCompileTime>& r);
437 
438  // allow to extend Matrix outside Eigen
439  #ifdef EIGEN_MATRIX_PLUGIN
440  #include EIGEN_MATRIX_PLUGIN
441  #endif
442 
443  protected:
444  template <typename Derived, typename OtherDerived, bool IsVector>
445  friend struct internal::conservative_resize_like_impl;
446 
447  using Base::m_storage;
448 };
449 
479 #define EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix) \
480  \
481 typedef Matrix<Type, Size, Size> Matrix##SizeSuffix##TypeSuffix; \
482  \
483 typedef Matrix<Type, Size, 1> Vector##SizeSuffix##TypeSuffix; \
484  \
485 typedef Matrix<Type, 1, Size> RowVector##SizeSuffix##TypeSuffix;
486 
487 #define EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, Size) \
488  \
489 typedef Matrix<Type, Size, Dynamic> Matrix##Size##X##TypeSuffix; \
490  \
491 typedef Matrix<Type, Dynamic, Size> Matrix##X##Size##TypeSuffix;
492 
493 #define EIGEN_MAKE_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
494 EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 2, 2) \
495 EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 3, 3) \
496 EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 4, 4) \
497 EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Dynamic, X) \
498 EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 2) \
499 EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 3) \
500 EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 4)
501 
502 EIGEN_MAKE_TYPEDEFS_ALL_SIZES(int, i)
503 EIGEN_MAKE_TYPEDEFS_ALL_SIZES(float, f)
504 EIGEN_MAKE_TYPEDEFS_ALL_SIZES(double, d)
505 EIGEN_MAKE_TYPEDEFS_ALL_SIZES(std::complex<float>, cf)
506 EIGEN_MAKE_TYPEDEFS_ALL_SIZES(std::complex<double>, cd)
507 
508 #undef EIGEN_MAKE_TYPEDEFS_ALL_SIZES
509 #undef EIGEN_MAKE_TYPEDEFS
510 #undef EIGEN_MAKE_FIXED_TYPEDEFS
511 
512 #if EIGEN_HAS_CXX11
513 
514 #define EIGEN_MAKE_TYPEDEFS(Size, SizeSuffix) \
515  \
516  \
517 template <typename Type> \
518 using Matrix##SizeSuffix = Matrix<Type, Size, Size>; \
519  \
520  \
521 template <typename Type> \
522 using Vector##SizeSuffix = Matrix<Type, Size, 1>; \
523  \
524  \
525 template <typename Type> \
526 using RowVector##SizeSuffix = Matrix<Type, 1, Size>;
527 
528 #define EIGEN_MAKE_FIXED_TYPEDEFS(Size) \
529  \
530  \
531 template <typename Type> \
532 using Matrix##Size##X = Matrix<Type, Size, Dynamic>; \
533  \
534  \
535 template <typename Type> \
536 using Matrix##X##Size = Matrix<Type, Dynamic, Size>;
537 
538 EIGEN_MAKE_TYPEDEFS(2, 2)
539 EIGEN_MAKE_TYPEDEFS(3, 3)
540 EIGEN_MAKE_TYPEDEFS(4, 4)
541 EIGEN_MAKE_TYPEDEFS(Dynamic, X)
542 EIGEN_MAKE_FIXED_TYPEDEFS(2)
543 EIGEN_MAKE_FIXED_TYPEDEFS(3)
544 EIGEN_MAKE_FIXED_TYPEDEFS(4)
545 
548 template <typename Type, int Size>
549 using Vector = Matrix<Type, Size, 1>;
550 
553 template <typename Type, int Size>
554 using RowVector = Matrix<Type, 1, Size>;
555 
556 #undef EIGEN_MAKE_TYPEDEFS
557 #undef EIGEN_MAKE_FIXED_TYPEDEFS
558 
559 #endif // EIGEN_HAS_CXX11
560 
561 } // end namespace Eigen
562 
563 #endif // EIGEN_MATRIX_H
Index innerSize() const
Definition: DenseBase.h:235
Definition: Constants.h:324
const unsigned int DirectAccessBit
Definition: Constants.h:154
Matrix(const Scalar &x, const Scalar &y, const Scalar &z)
Constructs an initialized 3D vector with given coefficients.
Definition: Matrix.h:389
Namespace containing all symbols from the Eigen library.
Definition: Core:129
Definition: Half.h:180
Scalar & y()
Definition: DenseCoeffsBase.h:441
Derived & derived()
Definition: EigenBase.h:46
Eigen::Index Index
The interface type of indices.
Definition: EigenBase.h:39
const unsigned int RowMajorBit
Definition: Constants.h:65
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:41
const unsigned int PacketAccessBit
Definition: Constants.h:93
Definition: EigenBase.h:29
Scalar & z()
Definition: DenseCoeffsBase.h:451
Scalar & coeffRef(Index rowId, Index colId)
Definition: PlainObjectBase.h:183
Matrix & operator=(const EigenBase< OtherDerived > &other)
Copies the generic expression other into *this.
Definition: Matrix.h:236
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:42
Dense storage base class for matrices and arrays.
Definition: PlainObjectBase.h:95
Matrix(const Scalar &a0, const Scalar &a1, const Scalar &a2, const Scalar &a3, const ArgTypes &... args)
Construct a row of column vector with fixed size from an arbitrary number of coefficients. [c++11]
Definition: Matrix.h:296
Matrix(const std::initializer_list< std::initializer_list< Scalar >> &list)
Constructs a Matrix and initializes it from the coefficients given as initializer-lists grouped by ro...
Definition: Matrix.h:321
Derived & operator=(const PlainObjectBase &other)
Definition: PlainObjectBase.h:457
Scalar & x()
Definition: DenseCoeffsBase.h:435
Matrix(const EigenBase< OtherDerived > &other)
Copy constructor for generic expressions.
Definition: Matrix.h:422
Definition: Eigen_Colamd.h:50
Scalar & w()
Definition: DenseCoeffsBase.h:461
Definition: Constants.h:320
Matrix & operator=(const Matrix &other)
Assigns matrices to each other.
Definition: Matrix.h:206
const int Dynamic
Definition: Constants.h:21
Matrix(const Scalar &x, const Scalar &y, const Scalar &z, const Scalar &w)
Constructs an initialized 4D vector with given coefficients.
Definition: Matrix.h:401
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:178
Matrix()
Default constructor.
Definition: Matrix.h:259
Derived & _set(const DenseBase< OtherDerived > &other)
Copies the value of the expression other into *this with automatic resizing.
Definition: PlainObjectBase.h:777
PlainObjectBase< Matrix > Base
Base class typedef.
Definition: Matrix.h:186
const unsigned int LinearAccessBit
Definition: Constants.h:129
Matrix(const Matrix &other)
Copy constructor.
Definition: Matrix.h:414