namespace Eigen { /** \page QuickStartGuide
\include Tutorial_simple_example_fixed_size.cpp | output: \include Tutorial_simple_example_fixed_size.out |
\include Tutorial_simple_example_dynamic_size.cpp | output: \include Tutorial_simple_example_dynamic_size.out |
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 |
\code cout << MatrixXf::Constant(2, 3, sqrt(2)) << endl; RowVector3i v; v.setConstant(6); cout << "v = " << v << endl; \endcode | output: \code 1.41 1.41 1.41 1.41 1.41 1.41 v = 6 6 6 \endcode |
\include Tutorial_commainit_01.cpp | output: \verbinclude Tutorial_commainit_01.out |
\include Tutorial_commainit_02.cpp | output: \verbinclude Tutorial_commainit_02.out |
\b Side \b note: here .finished() is used to get the actual matrix object once the comma initialization of our temporary submatrix is done. Note that despite the appearant complexity of such an expression Eigen's comma initializer usually yields to very optimized code without any overhead.
top\section BasicLinearAlgebra Basic Linear Algebra In short all mathematically well defined operators can be used right away as in the following example: \code mat4 -= mat1*1.5 + mat2 * mat3/4; \endcode which includes two matrix scalar products ("mat1*1.5" and "mat3/4"), a matrix-matrix product ("mat2 * mat3/4"), a matrix addition ("+") and substraction with assignment ("-=").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 \endcode | \code
#include |
|
|
\b Side \b note: If you feel the \c .cwise() syntax is too verbose for your taste and don't bother to have non mathematical operator directly available feel free to extend MatrixBase as described \ref ExtendingMatrixBase "here".
top\section Reductions Reductions Eigen provides several several reduction methods such as: \link Cwise::minCoeff() minCoeff() \endlink, \link Cwise::maxCoeff() maxCoeff() \endlink, \link Cwise::sum() sum() \endlink, \link Cwise::trace() trace() \endlink, \link Cwise::norm() norm() \endlink, \link Cwise::norm2() norm2() \endlink, \link Cwise::all() all() \endlink,and \link Cwise::any() any() \endlink. All reduction operations can be done matrix-wise, \link MatrixBase::colwise() column-wise \endlink or \link MatrixBase::rowwise() row-wise \endlink. Usage example:\code 5 3 1 mat = 2 7 8 9 4 6 \endcode | \code mat.minCoeff(); \endcode | \code 1 \endcode |
\code mat.colwise().minCoeff(); \endcode | \code 2 3 1 \endcode | |
\code mat.rowwise().minCoeff(); \endcode | \code 1 2 4 \endcode |
\b Side \b note: The all() and any() functions are especially useful in combinaison with coeff-wise comparison operators (\ref CwiseAll "example").
top\section SubMatrix Sub matrices Read-write access to a \link MatrixBase::col(int) column \endlink or a \link MatrixBase::row(int) row \endlink of a matrix: \code mat1.row(i) = mat2.col(j); mat1.col(j1).swap(mat1.col(j2)); \endcode Read-write access to sub-vectors:Default versions | Optimized versions when the size is known at compile time | |
\code vec1.start(n)\endcode | \code vec1.start | the first \c n coeffs |
\code vec1.end(n)\endcode | \code vec1.end | the last \c n coeffs |
\code vec1.block(pos,n)\endcode | \code vec1.block |
the \c size coeffs in the range [\c pos : \c pos + \c n [ |
Default versions | Optimized versions when the size is known at compile time | |
\code mat1.block(i,j,rows,cols)\endcode \link MatrixBase::block(int,int,int,int) (more) \endlink | \code mat1.block |
the \c rows x \c cols sub-matrix 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 |
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 |
\link MatrixBase::asDiagonal() make a diagonal matrix \endlink from a vector \n \b Note: 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 |