namespace Eigen { /** \page TutorialCore Tutorial 1/3 - Core features \ingroup Tutorial
\b Table \b of \b contents - \ref TutorialCoreSimpleExampleFixedSize - \ref TutorialCoreSimpleExampleDynamicSize - \ref TutorialCoreMatrixTypes - \ref TutorialCoreMatrixInitialization - \ref TutorialCoreBasicLinearAlgebra - \ref TutorialCoreReductions - \ref TutorialCoreSubMatrix - \ref TutorialCoreMatrixTransformations - \ref TutorialCoreTriangularMatrix - \ref TutorialCorePerformance \n\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 |
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 |
\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 |
\code
std::vector |
\include Tutorial_commainit_01.cpp | output: \verbinclude Tutorial_commainit_01.out |
\include Tutorial_commainit_02.cpp | output: \verbinclude Tutorial_commainit_02.out |
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 |
|
|
\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 |
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 |