Fixed-size matrix or vector |
Dynamic-size matrix |
Dynamic-size vector |
\code
Matrix3f x;
x = Matrix3f::Zero();
x = Matrix3f::Ones();
x = Matrix3f::Constant(value);
x = Matrix3f::Identity();
x = Matrix3f::Random();
x.setZero();
x.setOnes();
x.setIdentity();
x.setConstant(value);
x.setRandom();
\endcode
|
\code
MatrixXf x;
x = MatrixXf::Zero(rows, cols);
x = MatrixXf::Ones(rows, cols);
x = MatrixXf::Constant(rows, cols, value);
x = MatrixXf::Identity(rows, cols);
x = MatrixXf::Random(rows, cols);
x.setZero(rows, cols);
x.setOnes(rows, cols);
x.setConstant(rows, cols, value);
x.setIdentity(rows, cols);
x.setRandom(rows, cols);
\endcode
|
\code
VectorXf x;
x = VectorXf::Zero(size);
x = VectorXf::Ones(size);
x = VectorXf::Constant(size, value);
x = VectorXf::Identity(size);
x = VectorXf::Random(size);
x.setZero(size);
x.setOnes(size);
x.setConstant(size, value);
x.setIdentity(size);
x.setRandom(size);
\endcode
|
Basis vectors \link MatrixBase::Unit [details]\endlink |
\code
Vector3f::UnixX() // 1 0 0
Vector3f::UnixY() // 0 1 0
Vector3f::UnixZ() // 0 0 1
\endcode | | \code
VectorXf::Unit(size,i)
VectorXf::Unit(4,1) == Vector4f(0,1,0,0)
== Vector4f::UnitY()
\endcode
|
Here is an usage example:
matrix/vector product | \code
col2 = mat1 * col1;
row2 = row1 * mat1; row1 *= mat1;
mat3 = mat1 * mat2; mat3 *= mat1; \endcode
|
add/subtract | \code
mat3 = mat1 + mat2; mat3 += mat1;
mat3 = mat1 - mat2; mat3 -= mat1;\endcode
|
scalar product | \code
mat3 = mat1 * s1; mat3 = s1 * mat1; mat3 *= s1;
mat3 = mat1 / s1; mat3 /= s1;\endcode
|
\link MatrixBase::dot() dot product \endlink (inner product) | \code
scalar = vec1.dot(vec2);\endcode
|
outer product | \code
mat = vec1 * vec2.transpose();\endcode
|
\link MatrixBase::cross() cross product \endlink | \code
#include
vec3 = vec1.cross(vec2);\endcode |
In Eigen only mathematically well defined operators can be used right away,
but don't worry, thanks to the \link Cwise .cwise() \endlink operator prefix,
Eigen's matrices are also very powerful as a numerical container supporting
most common coefficient wise operators:
Default versions |
Optimized versions when the size \n is known at compile time |
|
\code vec1.start(n)\endcode | \code vec1.start()\endcode | the first \c n coeffs |
\code vec1.end(n)\endcode | \code vec1.end()\endcode | the last \c n coeffs |
\code vec1.block(pos,n)\endcode | \code vec1.block(pos)\endcode |
the \c size coeffs in \n the range [\c pos : \c pos + \c n [ |
Read-write access to sub-matrices: | | |
\code mat1.block(i,j,rows,cols)\endcode
\link MatrixBase::block(int,int,int,int) (more) \endlink |
\code mat1.block(i,j)\endcode
\link MatrixBase::block(int,int) (more) \endlink |
the \c rows x \c cols sub-matrix \n starting from position (\c i,\c j) |
\code
mat1.corner(TopLeft,rows,cols)
mat1.corner(TopRight,rows,cols)
mat1.corner(BottomLeft,rows,cols)
mat1.corner(BottomRight,rows,cols)\endcode
\link MatrixBase::corner(CornerType,int,int) (more) \endlink |
\code
mat1.corner(TopLeft)
mat1.corner(TopRight)
mat1.corner(BottomLeft)
mat1.corner(BottomRight)\endcode
\link MatrixBase::corner(CornerType) (more) \endlink |
the \c rows x \c cols sub-matrix \n taken in one of the four corners |
\code
vec1 = mat1.diagonal();
mat1.diagonal() = vec1;
\endcode
\link MatrixBase::diagonal() (more) \endlink | | |
\link MatrixBase::transpose() transposition \endlink (read-write) | \code
mat3 = mat1.transpose() * mat2;
mat3.transpose() = mat1 * mat2.transpose();
\endcode
|
\link MatrixBase::adjoint() adjoint \endlink (read only)\n | \code
mat3 = mat1.adjoint() * mat2;
mat3 = mat1.conjugate().transpose() * mat2;
\endcode
|
returns a \link MatrixBase::normalized() normalized \endlink vector \n
\link MatrixBase::normalize() normalize \endlink a vector
| \code
vec3 = vec1.normalized();
vec1.normalize();\endcode
|
\link MatrixBase::asDiagonal() make a diagonal matrix \endlink from a vector \n
this product is automatically optimized ! | \code
mat3 = mat1 * vec2.asDiagonal();\endcode
|
\link MatrixBase::minor() minor \endlink (read-write) | \code
mat4x4.minor(i,j) = mat3x3;
mat3x3 = mat4x4.minor(i,j);\endcode
|
\code
m4 = m4 * m4;\endcode |
auto-evaluates so no aliasing problem (performance penalty is low) |
\code
Matrix4f other = (m4 * m4).lazy();\endcode |
forces lazy evaluation |
\code
m4 = m4 + m4;\endcode |
here Eigen goes for lazy evaluation, as with most expressions |
\code
m4 = -m4 + m4 + 5 * m4;\endcode |
same here, Eigen chooses lazy evaluation for all that. |
\code
m4 = m4 * (m4 + m4);\endcode |
here Eigen chooses to first evaluate m4 + m4 into a temporary.
indeed, here it is an optimization to cache this intermediate result. |
\code
m3 = m3 * m4.block<3,3>(1,1);\endcode |
here Eigen chooses \b not to evaluate block() into a temporary
because accessing coefficients of that block expression is not more costly than accessing
coefficients of a plain matrix. |
\code
m4 = m4 * m4.transpose();\endcode |
same here, lazy evaluation of the transpose. |
\code
m4 = m4 * m4.transpose().eval();\endcode |
forces immediate evaluation of the transpose |
*/
/** \page TutorialAdvancedLinearAlgebra Tutorial 3/3 - Advanced linear algebra
\ingroup Tutorial
\ref index "Overview"
| \ref TutorialCore "Core features"
| \ref TutorialGeometry "Geometry"
| \b Advanced \b linear \b algebra
\b Table \b of \b contents
- \ref TutorialAdvLinearSolvers
- \ref TutorialAdvLU
- \ref TutorialAdvCholesky
- \ref TutorialAdvQR
- \ref TutorialAdvEigenProblems
\section TutorialAdvLinearSolvers Solving linear problems
todo