1、The Matrix class

一、The Matrix class

Matrix<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime>

Matrix：

For example, Matrix4f is a 4x4 matrix of floats. Here is how it is defined by Eigen:typedef Matrix<float, 4, 4> Matrix4f;

Vectors：

For example, the convenience typedef Vector3f is a (column) vector of 3 floats. It is defined as follows by Eigen:

typedef Matrix<float, 3, 1> Vector3f;

The special value Dynamic：

For example, the convenience typedef MatrixXd, meaning a matrix of doubles with dynamic size, is defined as follows:

typedef Matrix<double, Dynamic, Dynamic> MatrixXd;

And similarly, we define a self-explanatory typedef VectorXi as follows:

typedef Matrix<int, Dynamic, 1> VectorXi;

You can perfectly have e.g. a fixed number of rows with a dynamic number of columns, as in:

Matrix<float, 3, Dynamic>

Constructors：

Matrix3f a;
MatrixXf b;

a is a 3-by-3 matrix, with a plain float[9] array of uninitialized coefficients,
b is a dynamic-size matrix whose size is currently 0-by-0, and whose array of coefficients hasn’t yet been allocated at all.

MatrixXf a(10,15);
VectorXf b(30);

a is a 10x15 dynamic-size matrix, with allocated but currently uninitialized coefficients.
b is a dynamic-size vector of size 30, with allocated but currently uninitialized coefficients.

In order to offer a uniform API across fixed-size and dynamic-size matrices, it is legal to use these constructors on fixed-size matrices, even if passing the sizes is useless in this case. So this is legal:

Matrix3f a(3,3);

Finally, we also offer some constructors to initialize the coefficients of small fixed-size vectors up to size 4:

Vector2d a(5.0, 6.0);
Vector3d b(5.0, 6.0, 7.0);
Vector4d c(5.0, 6.0, 7.0, 8.0);

using：

for(int k = 0; k < 2; k++)
{
    cout << a(k) << " ";
}
cout << endl;

Coefficient accessors：

#include <iostream>
#include <Eigen/Dense>
 
using namespace Eigen;
 
int main()
{
  MatrixXd m(2,2);
  m(0,0) = 3;
  m(1,0) = 2.5;
  m(0,1) = -1;
  m(1,1) = m(1,0) + m(0,1);
  std::cout << "Here is the matrix m:\n" << m << std::endl;
  VectorXd v(2);
  v(0) = 4;
  v(1) = v(0) - 1;
  std::cout << "Here is the vector v:\n" << v << std::endl;
}

Matrix3f m;
m << 1, 2, 3,
     4, 5, 6,
     7, 8, 9;
std::cout << m;

The current size of a matrix can be retrieved by rows(), cols() and size(). These methods return the number of rows, the number of columns and the number of coefficients, respectively. Resizing a dynamic-size matrix is done by the resize() method.

#include <iostream>
#include <Eigen/Dense>
 
using namespace Eigen;
 
int main()
{
  MatrixXd m(2,5);
  m.resize(4,3);
  std::cout << "The matrix m is of size "
            << m.rows() << "x" << m.cols() << std::endl;
  std::cout << "It has " << m.size() << " coefficients" << std::endl;
  VectorXd v(2);
  v.resize(5);
  std::cout << "The vector v is of size " << v.size() << std::endl;
  std::cout << "As a matrix, v is of size "
            << v.rows() << "x" << v.cols() << std::endl;
}

Output：
The matrix m is of size 4x3
It has 12 coefficients
The vector v is of size 5
As a matrix, v is of size 5x1

Assignment and resizing：

Assignment is the action of copying a matrix into another, using operator=. Eigen resizes the matrix on the left-hand side automatically so that it matches the size of the matrix on the right-hand size. For example:

MatrixXf a(2,2);
std::cout << "a is of size " << a.rows() << "x" << a.cols() << std::endl;
MatrixXf b(3,3);
a = b;
std::cout << "a is now of size " << a.rows() << "x" << a.cols() << std::endl;

Fixed vs. Dynamic size:

Matrix4f mymatrix; 

really amounts to just doing

float mymatrix[16];

so this really has zero runtime cost. By contrast, the array of a dynamic-size matrix is always allocated on the heap, so doing

MatrixXf mymatrix(rows,columns);

amounts to doing

float *mymatrix = new float[rows*columns];

Optional template parameters:

Matrix<typename Scalar,
       int RowsAtCompileTime,
       int ColsAtCompileTime,
       int Options = 0,
       int MaxRowsAtCompileTime = RowsAtCompileTime,
       int MaxColsAtCompileTime = ColsAtCompileTime>