Global matrix typedefs

Detailed Description

Eigen defines several typedef shortcuts for most common matrix and vector types.

The general patterns are the following:

MatrixSizeType where Size can be 2,3,4 for fixed size square matrices or X for dynamic size, and where Type can be i for integer, f for float, d for double, cf for complex float, cd for complex double.

For example, Matrix3d is a fixed-size 3x3 matrix type of doubles, and MatrixXf is a dynamic-size matrix of floats.

There are also VectorSizeType and RowVectorSizeType which are self-explanatory. For example, Vector4cf is a fixed-size vector of 4 complex floats.

With [c++11], template alias are also defined for common sizes. They follow the same pattern as above except that the scalar type suffix is replaced by a template parameter, i.e.:

• MatrixSize<Type> where Size can be 2,3,4 for fixed size square matrices or X for dynamic size.
• MatrixXSize<Type> and MatrixSizeX<Type> where Size can be 2,3,4 for hybrid dynamic/fixed matrices.
• VectorSize<Type> and RowVectorSize<Type> for column and row vectors.

With [c++11], you can also use fully generic column and row vector types: Vector<Type,Size> and RowVector<Type,Size>.

See also

class Matrix

Typedefs
template<typename Type>
using	Eigen::Matrix2
	[c++11]
typedef Matrix< std::complex< double >, 2, 2 >	Eigen::Matrix2cd
typedef Matrix< std::complex< float >, 2, 2 >	Eigen::Matrix2cf
typedef Matrix< double, 2, 2 >	Eigen::Matrix2d
typedef Matrix< float, 2, 2 >	Eigen::Matrix2f
typedef Matrix< int, 2, 2 >	Eigen::Matrix2i
template<typename Type>
using	Eigen::Matrix2X
	[c++11]
typedef Matrix< std::complex< double >, 2, Dynamic >	Eigen::Matrix2Xcd
typedef Matrix< std::complex< float >, 2, Dynamic >	Eigen::Matrix2Xcf
typedef Matrix< double, 2, Dynamic >	Eigen::Matrix2Xd
typedef Matrix< float, 2, Dynamic >	Eigen::Matrix2Xf
typedef Matrix< int, 2, Dynamic >	Eigen::Matrix2Xi
template<typename Type>
using	Eigen::Matrix3
	[c++11]
typedef Matrix< std::complex< double >, 3, 3 >	Eigen::Matrix3cd
typedef Matrix< std::complex< float >, 3, 3 >	Eigen::Matrix3cf
typedef Matrix< double, 3, 3 >	Eigen::Matrix3d
typedef Matrix< float, 3, 3 >	Eigen::Matrix3f
typedef Matrix< int, 3, 3 >	Eigen::Matrix3i
template<typename Type>
using	Eigen::Matrix3X
	[c++11]
typedef Matrix< std::complex< double >, 3, Dynamic >	Eigen::Matrix3Xcd
typedef Matrix< std::complex< float >, 3, Dynamic >	Eigen::Matrix3Xcf
typedef Matrix< double, 3, Dynamic >	Eigen::Matrix3Xd
typedef Matrix< float, 3, Dynamic >	Eigen::Matrix3Xf
typedef Matrix< int, 3, Dynamic >	Eigen::Matrix3Xi
template<typename Type>
using	Eigen::Matrix4
	[c++11]
typedef Matrix< std::complex< double >, 4, 4 >	Eigen::Matrix4cd
typedef Matrix< std::complex< float >, 4, 4 >	Eigen::Matrix4cf
typedef Matrix< double, 4, 4 >	Eigen::Matrix4d
typedef Matrix< float, 4, 4 >	Eigen::Matrix4f
typedef Matrix< int, 4, 4 >	Eigen::Matrix4i
template<typename Type>
using	Eigen::Matrix4X
	[c++11]
typedef Matrix< std::complex< double >, 4, Dynamic >	Eigen::Matrix4Xcd
typedef Matrix< std::complex< float >, 4, Dynamic >	Eigen::Matrix4Xcf
typedef Matrix< double, 4, Dynamic >	Eigen::Matrix4Xd
typedef Matrix< float, 4, Dynamic >	Eigen::Matrix4Xf
typedef Matrix< int, 4, Dynamic >	Eigen::Matrix4Xi
template<typename Type>
using	Eigen::MatrixX
	[c++11]
template<typename Type>
using	Eigen::MatrixX2
	[c++11]
typedef Matrix< std::complex< double >, Dynamic, 2 >	Eigen::MatrixX2cd
typedef Matrix< std::complex< float >, Dynamic, 2 >	Eigen::MatrixX2cf
typedef Matrix< double, Dynamic, 2 >	Eigen::MatrixX2d
typedef Matrix< float, Dynamic, 2 >	Eigen::MatrixX2f
typedef Matrix< int, Dynamic, 2 >	Eigen::MatrixX2i
template<typename Type>
using	Eigen::MatrixX3
	[c++11]
typedef Matrix< std::complex< double >, Dynamic, 3 >	Eigen::MatrixX3cd
typedef Matrix< std::complex< float >, Dynamic, 3 >	Eigen::MatrixX3cf
typedef Matrix< double, Dynamic, 3 >	Eigen::MatrixX3d
typedef Matrix< float, Dynamic, 3 >	Eigen::MatrixX3f
typedef Matrix< int, Dynamic, 3 >	Eigen::MatrixX3i
template<typename Type>
using	Eigen::MatrixX4
	[c++11]
typedef Matrix< std::complex< double >, Dynamic, 4 >	Eigen::MatrixX4cd
typedef Matrix< std::complex< float >, Dynamic, 4 >	Eigen::MatrixX4cf
typedef Matrix< double, Dynamic, 4 >	Eigen::MatrixX4d
typedef Matrix< float, Dynamic, 4 >	Eigen::MatrixX4f
typedef Matrix< int, Dynamic, 4 >	Eigen::MatrixX4i
typedef Matrix< std::complex< double >, Dynamic, Dynamic >	Eigen::MatrixXcd
typedef Matrix< std::complex< float >, Dynamic, Dynamic >	Eigen::MatrixXcf
typedef Matrix< double, Dynamic, Dynamic >	Eigen::MatrixXd
typedef Matrix< float, Dynamic, Dynamic >	Eigen::MatrixXf
typedef Matrix< int, Dynamic, Dynamic >	Eigen::MatrixXi
template<typename Type, int Size>
using	Eigen::RowVector
	[c++11]
template<typename Type>
using	Eigen::RowVector2
	[c++11]
typedef Matrix< std::complex< double >, 1, 2 >	Eigen::RowVector2cd
typedef Matrix< std::complex< float >, 1, 2 >	Eigen::RowVector2cf
typedef Matrix< double, 1, 2 >	Eigen::RowVector2d
typedef Matrix< float, 1, 2 >	Eigen::RowVector2f
typedef Matrix< int, 1, 2 >	Eigen::RowVector2i
template<typename Type>
using	Eigen::RowVector3
	[c++11]
typedef Matrix< std::complex< double >, 1, 3 >	Eigen::RowVector3cd
typedef Matrix< std::complex< float >, 1, 3 >	Eigen::RowVector3cf
typedef Matrix< double, 1, 3 >	Eigen::RowVector3d
typedef Matrix< float, 1, 3 >	Eigen::RowVector3f
typedef Matrix< int, 1, 3 >	Eigen::RowVector3i
template<typename Type>
using	Eigen::RowVector4
	[c++11]
typedef Matrix< std::complex< double >, 1, 4 >	Eigen::RowVector4cd
typedef Matrix< std::complex< float >, 1, 4 >	Eigen::RowVector4cf
typedef Matrix< double, 1, 4 >	Eigen::RowVector4d
typedef Matrix< float, 1, 4 >	Eigen::RowVector4f
typedef Matrix< int, 1, 4 >	Eigen::RowVector4i
template<typename Type>
using	Eigen::RowVectorX
	[c++11]
typedef Matrix< std::complex< double >, 1, Dynamic >	Eigen::RowVectorXcd
typedef Matrix< std::complex< float >, 1, Dynamic >	Eigen::RowVectorXcf
typedef Matrix< double, 1, Dynamic >	Eigen::RowVectorXd
typedef Matrix< float, 1, Dynamic >	Eigen::RowVectorXf
typedef Matrix< int, 1, Dynamic >	Eigen::RowVectorXi
template<typename Type, int Size>
using	Eigen::Vector
	[c++11]
template<typename Type>
using	Eigen::Vector2
	[c++11]
typedef Matrix< std::complex< double >, 2, 1 >	Eigen::Vector2cd
typedef Matrix< std::complex< float >, 2, 1 >	Eigen::Vector2cf
typedef Matrix< double, 2, 1 >	Eigen::Vector2d
typedef Matrix< float, 2, 1 >	Eigen::Vector2f
typedef Matrix< int, 2, 1 >	Eigen::Vector2i
template<typename Type>
using	Eigen::Vector3
	[c++11]
typedef Matrix< std::complex< double >, 3, 1 >	Eigen::Vector3cd
typedef Matrix< std::complex< float >, 3, 1 >	Eigen::Vector3cf
typedef Matrix< double, 3, 1 >	Eigen::Vector3d
typedef Matrix< float, 3, 1 >	Eigen::Vector3f
typedef Matrix< int, 3, 1 >	Eigen::Vector3i
template<typename Type>
using	Eigen::Vector4
	[c++11]
typedef Matrix< std::complex< double >, 4, 1 >	Eigen::Vector4cd
typedef Matrix< std::complex< float >, 4, 1 >	Eigen::Vector4cf
typedef Matrix< double, 4, 1 >	Eigen::Vector4d
typedef Matrix< float, 4, 1 >	Eigen::Vector4f
typedef Matrix< int, 4, 1 >	Eigen::Vector4i
template<typename Type>
using	Eigen::VectorX
	[c++11]
typedef Matrix< std::complex< double >, Dynamic, 1 >	Eigen::VectorXcd
typedef Matrix< std::complex< float >, Dynamic, 1 >	Eigen::VectorXcf
typedef Matrix< double, Dynamic, 1 >	Eigen::VectorXd
typedef Matrix< float, Dynamic, 1 >	Eigen::VectorXf
typedef Matrix< int, Dynamic, 1 >	Eigen::VectorXi