Eigen学习（二）

本文算是对官网手册的翻译吧，参考：http://eigen.tuxfamily.org/dox/group__TutorialMatrixClass.html

Matrix类

在Eigen中，所有的矩阵和向量都是Matrix模板类的对象，向量只是特殊的矩阵而已，无论是行向量还是列向量。

Matrix类共有6个模板参数，主要使用的是前三个参数，剩余的都有默认值，前三个参数分别是

Matrix<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime>

其中Scalar是变量类型，如float，int等

RowsAtCompileTIme和ColsAtCompileTIme是矩阵的尺寸，分别是行和列。Eigen提供了很多常用的情况下的定义，如Matrix4f是4x4的folat型矩阵，其定义为

typedef Matrix<float, 4, 4> Matrix4f;

向量

上面说了向量只是一种特殊的矩阵，多数情况下使用的是列向量，一个3维列向量的定义如下

typedef Matrix<float, 3, 1> Vector3f;

Eigen同样提供了行向量的方便定义的形式

typedef Matrix<int, 1, 2> RowVector2i;

参数Dynamic

Eigen并不局限于在编译阶段指定矩阵的尺寸，前面提到的RowsAtCompileTIme和ColsAtCompileTIme参数可以取特殊值Dynamic，这代表编译时不能确定矩阵的尺寸，必须在运行时确定。Eigen中称为动态尺寸，编译时确定尺寸的矩阵称为固定尺寸的矩阵

typedef Matrix<double, Dynamic, Dynamic> MatrixXd;

上述定义表示一个动态尺寸的double型矩阵，同样的

typedef Matrix<int, Dynamic, 1> VectorXi;

表示动态尺寸的int型列向量，另外，还可以定义单个参数动态变化的矩阵，如

Matrix<float, 3, Dynamic>

表示矩阵的行为3,列为动态尺寸的。

构造函数

默认的构造函数不执行动态内存分配，也不初始化矩阵的元素。

Matrix3f a;

MatrixXf b;

这里a是3x3的矩阵，分配了float[9]的空间但是没有进行初始化；b是个0x0的矩阵。

对于构造函数指定尺寸也是可以的，对于矩阵首先传递的是行参数，对于向量则只传递尺寸就好，构造函数会分配相应的空间但是不进行初始化工作。

MatrixXf a(10,15);

VectorXf b(30);

这里a是10x15的矩阵，分配了空间没有进行初始化；b是个尺寸为30的向量同样没有初始化。

为了对固定尺寸和动态尺寸的矩阵提供统一的API，对指定大小的矩阵传递尺寸参数也是合法的，只是被忽略了而已。

最后，尺寸小于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);

元素获取

可以使用中括号获取对象的元素，矩阵是(行，列)，向量只传递索引即可，从0开始

#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;
}

输出为

Here is the matrix m:
  3  -1
2.5 1.5
Here is the vector v:
4
3

[]操作符在向量索引中进行了重载，因此对于向量可以使用中括号或者方括号获取元素，而矩阵只能使用中括号获取元素！

逗号初始化

矩阵和向量可以很容易的使用逗号初始化赋值

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

输出为

1 2 3
4 5 6
7 8 9

调整尺寸

矩阵的大小可以通过rows(),cols(),size()方法获取。对动态尺寸的矩阵调整尺寸时使用resize()方法

#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;
}

输出为

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

如果矩阵的大小不做改变的话，resize函数不做任何操作。否则将会导致有害的结果：元素的值将会被改变。如果想进行保守的调整尺寸，使用conservativeResize()函数。为了统一API，所有的操作可以用于固定尺寸的矩阵，但是你并不能真的去改变固定尺寸的矩阵的大小，这样做会导致失败。

Assignment和resizing

Assignment是将一个矩阵赋值给另一个，如果尺寸不同时Eigen会将左边的矩阵的尺寸自动resize成和右边的矩阵相同的尺寸

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;

输出为

a is of size 2x2
a is now of size 3x3

但是如果左边的矩阵是固定尺寸的话，操作是不允许的。

固定尺寸VS动态尺寸

什么时候使用固定尺寸？什么时候使用动态尺寸？简单的回答就是当矩阵尺寸很小时使用固定尺寸，尺寸较大时使用动态尺寸。对于小的矩阵，尤其是小于16个元素的，使用固定尺寸有利于代码性能，因为会避免动态内存的分配，固定尺寸的矩阵实际上就是个数组，比如Matrix4f mymatrix等价于float mymatrix[16]，而动态尺寸的矩阵总是在堆上申请内存，因此MatrixXf mymatrix[rows,cols]相当于float *mymatrix = new float[rows*cols]，并且MatrixXf对象还会存储它的行和列作为成员变量。

使用固定尺寸的局限在于仅仅当你能提前确定矩阵的尺寸。对于较大的矩阵，如大于32,使用固定尺寸带来的性能效果就变得可以忽略了，更糟糕的是，当试图在函数内部创建一个很大的固定尺寸的矩阵时可能会导致栈溢出，因为此时申请的是局部变量，通常情况下位于栈中。Eigen会根据环境对动态尺寸的对象做优化。

可选的参数

前面提高了3个模板参数，完整的参数列表是

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

Option是一个标志位，表明矩阵的存储方式，RowMajor表示按行存储。默认是按列存储的。

MaxRowsAtCompileTime和MaxRowsAtCompileTime表示编译时矩阵尺寸的上限，主要是为了避免动态内存分配。比如，如下的定义使用的是长度为12的数组，没有使用动态内存分配

Matrix<float, Dynamic, Dynamic, 0, 3, 4>