C++——Eigen库的学习(2)_eigen::vectorxd

三、Matrix类

在Eigen库中，Matrix类是一个基类，所有的矩阵以及向量的都是该类的对象，Vector只是一种特殊的矩阵（一行或者一列）。

1.Matrix类的定义

Matrix<typename Scalar,
       int RowsAtCompileTime,
       int ColsAtCompileTime,
       int Options = 0,
       int MaxRowsAtCompileTime = RowsAtCompileTime,
       int MaxColsAtCompileTime = ColsAtCompileTime>
1
2
3
4
5
6

Matrix类中一共有6个参数，重点常用的是前三个，参数的含义具体如下：
typename Scalar：表示矩阵元素的数据类型；
RowsAtCompileTime：表示矩阵的行数；
ColsAtCompileTime：表示矩阵的列数；
Options：一个比特标志位，只介绍一种RowMajor，它表明matrix使用按行存储，默认是按列存储，如：Matrix<float, 3, 3, RowMajor>；
MaxRowsAtCompileTime和MaxColsAtCompileTime表示在编译阶段矩阵的上限。主要是避免动态内存分配，使用数组。Matrix<float, Dynamic, Dynamic, 0, 3, 4> 等价于 float [12]

如何利用Matrix定义变量的类型，下面有一些例子，可以作为参考：

(1)定义一个4*4的矩阵：

typedef Matrix<float, 4, 4> Matrix4f;
1

(2)定义一个3*1的列向量：

typedef Matrix<float, 3, 1> Vector3f;
1

(3) 定义一个1*2的行向量：

typedef Matrix<int, 1, 2> RowVector2i;
1

(4)利用Dynamic标识符定义矩阵某一动态维度：

Eigen不局限于定义已知大小的矩阵，对于某些矩阵的大小不确定，或者不确定矩阵的某一维度，便引入了Dynamic标识符来对其进行定义：

typedef Matrix<double, Dynamic, Dynamic> MatrixXd;	//定义一个未知大小的矩阵，行列都是动态的
typedef Matrix<int, Dynamic, 1> VectorXi;	//定义一个位置大小的行向量
Matrix<float, 3, Dynamic>	//定义一个列数未知的矩阵，矩阵大小为3*n
1
2
3

2.构造函数的内存分配与元素初始化

(1)构造函数的内存分配

看下面的集中函数构造的例子，分别说明内存分配问题：

Matrix3f a;	//a是一个3*3的矩阵，分配了float[9]的空间，但未初始化内部元素
MatrixXf b;	//b是一个动态大小的矩阵，定义是未分配空间，且未初始化内部元素
MatrixXf c(10,15);	//c是一个10*15的动态大小的矩阵，分配了空间但未初始化元素
VectorXf d(30);	//d是一个30大小的向量，同样分配空间未初始化元素
1
2
3
4

(2)元素初始化问题

对于构造的矩阵变量，初始化方式有两种，下面分别介绍：

a、通过元素索引对元素进行赋值

#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 << "矩阵 m:\n" << m << std::endl;
  VectorXd v(2);
  v(0) = 4;
  v(1) = v(0) - 1;
  std::cout << "向量 v:\n" << v << std::endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

m(index)也可以用于获取矩阵元素，但取决于matrix的存储顺序，默认是按列存储的，当然也可以改为按行。

Eigen的构造函数支持4以内尺寸的vector的元素初始化，如下：

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

b、通过逗号初始化

Matrix3f m;
m << 1, 2, 3,
     4, 5, 6,
     7, 8, 9;
     
Eigen::VectorXd v(3);	//新建一个3维的列向量
v << 1,2,3;		//列向量的赋值
1
2
3
4
5
6
7

3.matrix矩阵的size操作以及resize

(1)matrix矩阵的size操作

matrix矩阵各个维度的大小可以通过rows()、cols()以及size()获取，且矩阵的大小可以通过resize()函数进行动态修改，具体可以看如下的示例代码：

#include <iostream>
#include <Eigen/Dense>
using namespace Eigen;
int main()
{
  Eigen::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;
  
  Eigen::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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

该程序的输出为：

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
1
2
3
4

(2)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
1
2
3
4
5
6
7
8

当然，如果左边量是固定大小的，上面的resizing是不允许的。

(3)固定尺寸与动态尺寸的选择

实际中，应该使用固定尺寸还是动态尺寸，简单的答案是：小的尺寸用固定的，大的尺寸用动态的。使用固定尺寸可以避免动态内存的开辟，固定尺寸只是一个普通数组。

Matrix4f mymatrix; 等价于 float mymatrix[16];

MatrixXf mymatrix(rows,columns); 等价于 float mymatrix = new float[rowscolumns];

使用固定尺寸(<=4*4)需要编译前知道矩阵大小，而且对于足够大的尺寸，如大于32，固定尺寸的收益可以忽略不计，而且可能导致栈崩溃。而且基于环境，Eigen会对动态尺寸做优化（类似于std::vector）

更多技术欢迎加入交流：320297153