Inherited by ei_unaligned_type< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > >.
The Matrix class is the work-horse for all dense (note) matrices and vectors within Eigen. Vectors are matrices with one column, and row-vectors are matrices with one row.
The Matrix class encompasses both fixed-size and dynamic-size objects (note).
The first three template parameters are required:
_Scalar | Numeric type, i.e. float, double, int | |
_Rows | Number of rows, or Dynamic | |
_Cols | Number of columns, or Dynamic |
_Options | A combination of either RowMajor or ColMajor, and of either AutoAlign or DontAlign. The former controls storage order, and defaults to column-major. The latter controls alignment, which is required for vectorization. It defaults to aligning matrices except for fixed sizes that aren't a multiple of the packet size. | |
_MaxRows | Maximum number of rows. Defaults to _Rows (note). | |
_MaxCols | Maximum number of columns. Defaults to _Cols (note). |
Matrix2d
is a 2x2 square matrix of doubles (Matrix<double, 2, 2>
) Vector4f
is a vector of 4 floats (Matrix<float, 4, 1>
) RowVector3i
is a row-vector of 3 ints (Matrix<int, 1, 3>
)MatrixXf
is a dynamic-size matrix of floats (Matrix<float, Dynamic, Dynamic>
) VectorXf
is a dynamic-size vector of floats (Matrix<float, Dynamic, 1>
)You can access elements of vectors and matrices using normal subscripting:
Eigen::VectorXd v(10); v[0] = 0.1; v[1] = 0.2; v(0) = 0.3; v(1) = 0.4; Eigen::MatrixXi m(10, 10); m(0, 1) = 1; m(0, 2) = 2; m(0, 3) = 3;
Some notes:
Dense matrices and vectors are plain usual arrays of coefficients. All the coefficients are stored, in an ordinary contiguous array. This is unlike Sparse matrices and vectors where the coefficients are stored as a list of nonzero coefficients.
Dynamic-size means that the numbers of rows or columns are not necessarily known at compile-time. In this case they are runtime variables, and the array of coefficients is allocated dynamically on the heap.
Note that dense matrices, be they Fixed-size or Dynamic-size, do not expand dynamically in the sense of a std::map. If you want this behavior, see the Sparse module.
Public Types | |
enum | { Options } |
enum | { NeedsToAlign } |
typedef class Eigen::Map < Matrix, Aligned > | AlignedMapType |
typedef class Eigen::Map < Matrix, Unaligned > | UnalignedMapType |
Public Member Functions | |
const Scalar & | coeff (int index) const |
const Scalar & | coeff (int row, int col) const |
Scalar & | coeffRef (int index) |
Scalar & | coeffRef (int row, int col) |
int | cols () const |
Scalar * | data () |
const Scalar * | data () const |
template<typename OtherDerived> | |
Matrix (const RotationBase< OtherDerived, ColsAtCompileTime > &r) | |
Matrix (const Matrix &other) | |
template<typename OtherDerived> | |
Matrix (const MatrixBase< OtherDerived > &other) | |
Matrix (const Scalar *data) | |
Matrix (const Scalar &x, const Scalar &y, const Scalar &z, const Scalar &w) | |
Matrix (const Scalar &x, const Scalar &y, const Scalar &z) | |
Matrix (const double &x, const double &y) | |
Matrix (const float &x, const float &y) | |
Matrix (int x, int y) | |
Matrix (int dim) | |
Matrix () | |
template<typename OtherDerived> | |
Matrix & | operator= (const RotationBase< OtherDerived, ColsAtCompileTime > &r) |
Matrix & | operator= (const Matrix &other) |
template<typename OtherDerived> | |
Matrix & | operator= (const MatrixBase< OtherDerived > &other) |
template<int LoadMode> | |
PacketScalar | packet (int index) const |
template<int LoadMode> | |
PacketScalar | packet (int row, int col) const |
void | resize (int size) |
void | resize (int rows, int cols) |
int | rows () const |
int | stride (void) const |
void | swap (Matrix &other) |
template<int StoreMode> | |
void | writePacket (int index, const PacketScalar &x) |
template<int StoreMode> | |
void | writePacket (int row, int col, const PacketScalar &x) |
~Matrix () | |
Static Public Member Functions | |
Map | |
These are convenience functions returning Map objects. The Map() static functions return unaligned Map objects, while the AlignedMap() functions return aligned Map objects and thus should be called only with 16-byte-aligned data pointers.
| |
static UnalignedMapType | Map (Scalar *data, int rows, int cols) |
static const UnalignedMapType | Map (const Scalar *data, int rows, int cols) |
static UnalignedMapType | Map (Scalar *data, int size) |
static const UnalignedMapType | Map (const Scalar *data, int size) |
static UnalignedMapType | Map (Scalar *data) |
static const UnalignedMapType | Map (const Scalar *data) |
static AlignedMapType | MapAligned (Scalar *data, int rows, int cols) |
static const AlignedMapType | MapAligned (const Scalar *data, int rows, int cols) |
static AlignedMapType | MapAligned (Scalar *data, int size) |
static const AlignedMapType | MapAligned (const Scalar *data, int size) |
static AlignedMapType | MapAligned (Scalar *data) |
static const AlignedMapType | MapAligned (const Scalar *data) |
Protected Attributes | |
ei_matrix_storage< Scalar, MaxSizeAtCompileTime, RowsAtCompileTime, ColsAtCompileTime, Options > | m_storage |
Matrix | ( | ) | [inline, explicit] |
Default constructor.
For fixed-size matrices, does nothing.
For dynamic-size matrices, creates an empty matrix of size 0. Does not allocate any array. Such a matrix is called a null matrix. This constructor is the unique way to create null matrices: resizing a matrix to 0 is not supported.
Matrix | ( | int | dim | ) | [inline, explicit] |
Constructs a vector or row-vector with given dimension. This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.
Note that this is only useful for dynamic-size vectors. For fixed-size vectors, it is redundant to pass the dimension here, so it makes more sense to use the default constructor Matrix() instead.
Matrix | ( | int | x, | |
int | y | |||
) | [inline] |
This constructor has two very different behaviors, depending on the type of *this.
Matrix | ( | const float & | x, | |
const float & | y | |||
) | [inline] |
constructs an initialized 2D vector with given coefficients
Matrix | ( | const double & | x, | |
const double & | y | |||
) | [inline] |
constructs an initialized 2D vector with given coefficients
Matrix | ( | const Scalar & | x, | |
const Scalar & | y, | |||
const Scalar & | z | |||
) | [inline] |
constructs an initialized 3D vector with given coefficients
Matrix | ( | const Scalar & | x, | |
const Scalar & | y, | |||
const Scalar & | z, | |||
const Scalar & | w | |||
) | [inline] |
constructs an initialized 4D vector with given coefficients
Matrix | ( | const Scalar * | data | ) | [inline, explicit] |
Constructor copying an existing array of data. Only for fixed-size matrices and vectors.
data | The array of data to copy |
Matrix | ( | const MatrixBase< OtherDerived > & | other | ) | [inline] |
Constructor copying the value of the expression other
Copy constructor
~Matrix | ( | ) | [inline] |
Destructor
Matrix | ( | const RotationBase< OtherDerived, ColsAtCompileTime > & | r | ) | [inline, explicit] |
This is defined in the Geometry module.
#include <Eigen/Geometry>
Constructs a Dim x Dim rotation matrix from the rotation r
const Scalar& coeff | ( | int | index | ) | const [inline] |
Short version: don't use this function, use operator[](int) const instead.
Long version: this function is similar to operator[](int) const , but without the assertion. Use this for limiting the performance cost of debugging code when doing repeated coefficient access. Only use this when it is guaranteed that the parameter index is in range.
If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this function equivalent to operator[](int) const .
Reimplemented from MatrixBase.
const Scalar& coeff | ( | int | row, | |
int | col | |||
) | const [inline] |
Short version: don't use this function, use operator()(int,int) const instead.
Long version: this function is similar to operator()(int,int) const , but without the assertion. Use this for limiting the performance cost of debugging code when doing repeated coefficient access. Only use this when it is guaranteed that the parameters row and col are in range.
If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this function equivalent to operator()(int,int) const .
Reimplemented from MatrixBase.
Scalar& coeffRef | ( | int | index | ) | [inline] |
Short version: don't use this function, use operator[](int) instead.
Long version: this function is similar to operator[](int), but without the assertion. Use this for limiting the performance cost of debugging code when doing repeated coefficient access. Only use this when it is guaranteed that the parameters row and col are in range.
If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this function equivalent to operator[](int).
Reimplemented from MatrixBase.
Scalar& coeffRef | ( | int | row, | |
int | col | |||
) | [inline] |
Short version: don't use this function, use operator()(int,int) instead.
Long version: this function is similar to operator()(int,int), but without the assertion. Use this for limiting the performance cost of debugging code when doing repeated coefficient access. Only use this when it is guaranteed that the parameters row and col are in range.
If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this function equivalent to operator()(int,int).
Reimplemented from MatrixBase.
int cols | ( | void | ) | const [inline] |
Scalar* data | ( | ) | [inline] |
const Scalar* data | ( | ) | const [inline] |
Matrix< _Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols > & operator= | ( | const RotationBase< OtherDerived, ColsAtCompileTime > & | r | ) | [inline] |
This is defined in the Geometry module.
#include <Eigen/Geometry>
Set a Dim x Dim rotation matrix from the rotation r
Matrix& operator= | ( | const Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > & | other | ) | [inline] |
This is a special case of the templated operator=. Its purpose is to prevent a default operator= from hiding the templated operator=.
Matrix& operator= | ( | const MatrixBase< OtherDerived > & | other | ) | [inline] |
Copies the value of the expression other into *this
with automatic resizing.
*this might be resized to match the dimensions of other. If *this was a null matrix (not already initialized), it will be initialized.
Note that copying a row-vector into a vector (and conversely) is allowed. The resizing, if any, is then done in the appropriate way so that row-vectors remain row-vectors and vectors remain vectors.
Reimplemented from MatrixBase.
PacketScalar packet | ( | int | index | ) | const [inline] |
Reimplemented from MatrixBase.
PacketScalar packet | ( | int | row, | |
int | col | |||
) | const [inline] |
Reimplemented from MatrixBase.
void resize | ( | int | size | ) | [inline] |
void resize | ( | int | rows, | |
int | cols | |||
) | [inline] |
Resizes *this
to a rows x cols matrix.
Makes sense for dynamic-size matrices only.
If the current number of coefficients of *this
exactly matches the product rows * cols, then no memory allocation is performed and the current values are left unchanged. In all other cases, including shrinking, the data is reallocated and all previous values are lost.
int rows | ( | void | ) | const [inline] |
int stride | ( | void | ) | const [inline] |
Reimplemented from MatrixBase.
void swap | ( | Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > & | other | ) | [inline] |
Override MatrixBase::swap() since for dynamic-sized matrices of same type it is enough to swap the data pointers.