Eigen  3.3.0
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
259  EIGEN_STRONG_INLINE 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
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
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();
278  Base::_set_noalias(other);
279  }
280  EIGEN_DEVICE_FUNC
281  Matrix& operator=(Matrix&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable<Scalar>::value)
282  {
283  other.swap(*this);
284  return *this;
285  }
286 #endif
287 
288  #ifndef EIGEN_PARSED_BY_DOXYGEN
289 
290  // This constructor is for both 1x1 matrices and dynamic vectors
291  template<typename T>
292  EIGEN_DEVICE_FUNC
293  EIGEN_STRONG_INLINE explicit Matrix(const T& x)
294  {
295  Base::_check_template_params();
296  Base::template _init1<T>(x);
297  }
298 
299  template<typename T0, typename T1>
300  EIGEN_DEVICE_FUNC
301  EIGEN_STRONG_INLINE Matrix(const T0& x, const T1& y)
302  {
303  Base::_check_template_params();
304  Base::template _init2<T0,T1>(x, y);
305  }
306  #else
308  EIGEN_DEVICE_FUNC
309  explicit Matrix(const Scalar *data);
310 
323  EIGEN_STRONG_INLINE explicit Matrix(Index dim);
325  Matrix(const Scalar& x);
338  EIGEN_DEVICE_FUNC
339  Matrix(Index rows, Index cols);
340 
342  Matrix(const Scalar& x, const Scalar& y);
343  #endif
344 
346  EIGEN_DEVICE_FUNC
347  EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z)
348  {
349  Base::_check_template_params();
350  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Matrix, 3)
351  m_storage.data()[0] = x;
352  m_storage.data()[1] = y;
353  m_storage.data()[2] = z;
354  }
356  EIGEN_DEVICE_FUNC
357  EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z, const Scalar& w)
358  {
359  Base::_check_template_params();
360  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Matrix, 4)
361  m_storage.data()[0] = x;
362  m_storage.data()[1] = y;
363  m_storage.data()[2] = z;
364  m_storage.data()[3] = w;
365  }
366 
367 
369  EIGEN_DEVICE_FUNC
370  EIGEN_STRONG_INLINE Matrix(const Matrix& other) : Base(other)
371  { }
372 
376  template<typename OtherDerived>
377  EIGEN_DEVICE_FUNC
378  EIGEN_STRONG_INLINE Matrix(const EigenBase<OtherDerived> &other)
379  : Base(other.derived())
380  { }
381 
382  EIGEN_DEVICE_FUNC inline Index innerStride() const { return 1; }
383  EIGEN_DEVICE_FUNC inline Index outerStride() const { return this->innerSize(); }
384 
386 
387  template<typename OtherDerived>
388  EIGEN_DEVICE_FUNC
389  explicit Matrix(const RotationBase<OtherDerived,ColsAtCompileTime>& r);
390  template<typename OtherDerived>
391  EIGEN_DEVICE_FUNC
392  Matrix& operator=(const RotationBase<OtherDerived,ColsAtCompileTime>& r);
393 
394  // allow to extend Matrix outside Eigen
395  #ifdef EIGEN_MATRIX_PLUGIN
396  #include EIGEN_MATRIX_PLUGIN
397  #endif
398 
399  protected:
400  template <typename Derived, typename OtherDerived, bool IsVector>
401  friend struct internal::conservative_resize_like_impl;
402 
403  using Base::m_storage;
404 };
405 
426 #define EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix) \
427  \
428 typedef Matrix<Type, Size, Size> Matrix##SizeSuffix##TypeSuffix; \
429  \
430 typedef Matrix<Type, Size, 1> Vector##SizeSuffix##TypeSuffix; \
431  \
432 typedef Matrix<Type, 1, Size> RowVector##SizeSuffix##TypeSuffix;
433 
434 #define EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, Size) \
435  \
436 typedef Matrix<Type, Size, Dynamic> Matrix##Size##X##TypeSuffix; \
437  \
438 typedef Matrix<Type, Dynamic, Size> Matrix##X##Size##TypeSuffix;
439 
440 #define EIGEN_MAKE_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
441 EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 2, 2) \
442 EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 3, 3) \
443 EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 4, 4) \
444 EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Dynamic, X) \
445 EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 2) \
446 EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 3) \
447 EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 4)
448 
449 EIGEN_MAKE_TYPEDEFS_ALL_SIZES(int, i)
450 EIGEN_MAKE_TYPEDEFS_ALL_SIZES(float, f)
451 EIGEN_MAKE_TYPEDEFS_ALL_SIZES(double, d)
452 EIGEN_MAKE_TYPEDEFS_ALL_SIZES(std::complex<float>, cf)
453 EIGEN_MAKE_TYPEDEFS_ALL_SIZES(std::complex<double>, cd)
454 
455 #undef EIGEN_MAKE_TYPEDEFS_ALL_SIZES
456 #undef EIGEN_MAKE_TYPEDEFS
457 #undef EIGEN_MAKE_FIXED_TYPEDEFS
458 
459 } // end namespace Eigen
460 
461 #endif // EIGEN_MATRIX_H
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:47
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:180
Matrix & operator=(const Matrix &other)
Assigns matrices to each other.
Definition: Matrix.h:206
Matrix(const Scalar &x, const Scalar &y, const Scalar &z, const Scalar &w)
Constructs an initialized 4D vector with given coefficients.
Definition: Matrix.h:357
Matrix(Index dim)
Constructs a vector or row-vector with given dimension. This is only for vectors (either row-vectors ...
Matrix & operator=(const EigenBase< OtherDerived > &other)
Copies the generic expression other into *this.
Definition: Matrix.h:236
Matrix(const Scalar &x, const Scalar &y)
Constructs an initialized 2D vector with given coefficients.
Matrix(const Scalar &x, const Scalar &y, const Scalar &z)
Constructs an initialized 3D vector with given coefficients.
Definition: Matrix.h:347
Matrix(const Matrix &other)
Copy constructor.
Definition: Matrix.h:370
Matrix()
Default constructor.
Definition: Matrix.h:259
Matrix(const Scalar &x)
Constructs an initialized 1x1 matrix with the given coefficient.
PlainObjectBase< Matrix > Base
Base class typedef.
Definition: Matrix.h:186
Matrix(const EigenBase< OtherDerived > &other)
Copy constructor for generic expressions.
Definition: Matrix.h:378
Matrix(const Scalar *data)
Constructs a fixed-sized matrix initialized with coefficients starting at data.
Matrix(Index rows, Index cols)
Constructs an uninitialized matrix with rows rows and cols columns.
Dense storage base class for matrices and arrays.
Definition: PlainObjectBase.h:94
Derived & _set(const DenseBase< OtherDerived > &other)
Copies the value of the expression other into *this with automatic resizing.
Definition: PlainObjectBase.h:701
Scalar & coeffRef(Index rowId, Index colId)
Definition: PlainObjectBase.h:177
Derived & _set_noalias(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:714
Derived & operator=(const PlainObjectBase &other)
Definition: PlainObjectBase.h:451
@ DontAlign
Definition: Constants.h:326
@ RowMajor
Definition: Constants.h:322
const unsigned int PacketAccessBit
Definition: Constants.h:89
const unsigned int LinearAccessBit
Definition: Constants.h:125
const unsigned int DirectAccessBit
Definition: Constants.h:150
const unsigned int RowMajorBit
Definition: Constants.h:61
Namespace containing all symbols from the Eigen library.
Definition: Core:287
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
const int Dynamic
Definition: Constants.h:21
Definition: EigenBase.h:29