Eigen学习（六）高级初始化

最新推荐文章于 2025-03-28 09:23:27 发布

Rap_God

最新推荐文章于 2025-03-28 09:23:27 发布

阅读量4.5w

点赞数 8

分类专栏： Eigen 文章标签：线性代数 Eigen

本文链接：https://blog.csdn.net/u012936940/article/details/79830267

版权

Eigen 专栏收录该内容

9 篇文章

订阅专栏

本节介绍几个初始化矩阵的高级方法，会更具体的介绍逗号初始化的方法。同样会介绍如何得到特殊矩阵比如单位矩阵和零矩阵等。

逗号初始化

Eigen提供了一个逗号初始化方法可以让使用者方便的设置矩阵、向量及数组的所有元素。简单的列出所有的元素，从左上角开始，从左至右，从上到下即可，当然前提是指定对象的尺寸，如果输入的数据少了或者多了，Eigen会报错的。

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

1 2 3
4 5 6
7 8 9

此外，初始化列表自身必须是向量或矩阵。常见的用法是将向量或矩阵组合起来。如下例子演示了如何将两个行向量组合起来。记得一定要提前设置好尺寸。

RowVectorXd vec1(3);
vec1 << 1, 2, 3;
std::cout << "vec1 = " << vec1 << std::endl;
RowVectorXd vec2(4);
vec2 << 1, 4, 9, 16;
std::cout << "vec2 = " << vec2 << std::endl;
RowVectorXd joined(7);
joined << vec1, vec2;
std::cout << "joined = " << joined << std::endl;

vec1 = 1 2 3
vec2 =  1  4  9 16
joined =  1  2  3  1  4  9 16

也可以用块结构初始化矩阵

MatrixXf matA(2, 2);
matA << 1, 2, 3, 4;
MatrixXf matB(4, 4);
matB << matA, matA/10, matA/10, matA;
std::cout << matB << std::endl;

1   2 0.1 0.2
  3   4 0.3 0.4
0.1 0.2   1   2
0.3 0.4   3   4

逗号初始化也可用来填充块表达式比如row(i)。如下是一个更复杂的例子

Matrix3f m;
m.row(0) << 1, 2, 3;
m.block(1,0,2,2) << 4, 5, 7, 8;
m.col(2).tail(2) << 6, 9;                   
std::cout << m;

输出

1 2 3
4 5 6
7 8 9

特殊矩阵和数组

矩阵和数组类有静态的方法比如Zero()，用来将所有元素清零。共有3个变体，第一个不带参数的只能用于固定尺寸的对象，如果你想初始化一个动态尺寸的对象为零，那么需要指定尺寸；第二个需要一个参数，可用于一维动态尺寸的对象；第三个需要两个参数，可用于二维的对象。

std::cout << "A fixed-size array:\n";
Array33f a1 = Array33f::Zero();
std::cout << a1 << "\n\n";
std::cout << "A one-dimensional dynamic-size array:\n";
ArrayXf a2 = ArrayXf::Zero(3);
std::cout << a2 << "\n\n";
std::cout << "A two-dimensional dynamic-size array:\n";
ArrayXXf a3 = ArrayXXf::Zero(3, 4);
std::cout << a3 << "\n";

输出

A fixed-size array:
0 0 0
0 0 0
0 0 0

A one-dimensional dynamic-size array:
0
0
0

A two-dimensional dynamic-size array:
0 0 0 0
0 0 0 0
0 0 0 0

类似的，Constant()方法设置所有的元素为常数value。如果对象的尺寸需要指定，那么额外的参数放在value之前，比如MatrixXd::Constant(rows,cols,value)。Random()方法用随机的数字填充矩阵或数组。Identity()方法获得单位矩阵，这个方法只能用于矩阵，不能用于数组。LinSpaced(size,low,high)只能用于向量和一维的数组，它可以得到一个指定尺寸的向量，其中的值介于low和high之间等间隔分布。

ArrayXXf table(10, 4);
table.col(0) = ArrayXf::LinSpaced(10, 0, 90);
table.col(1) = M_PI / 180 * table.col(0);
table.col(2) = table.col(1).sin();
table.col(3) = table.col(1).cos();
std::cout << "  Degrees   Radians      Sine    Cosine\n";
std::cout << table << std::endl;

输出

Degrees   Radians      Sine    Cosine
        0         0         0         1
       10     0.175     0.174     0.985
       20     0.349     0.342      0.94
       30     0.524       0.5     0.866
       40     0.698     0.643     0.766
       50     0.873     0.766     0.643
       60      1.05     0.866       0.5
       70      1.22      0.94     0.342
       80       1.4     0.985     0.174
       90      1.57         1 -4.37e-08

例子显示了由LinSpaced()返回的对象可以赋值给变量或表达式。Eigen提供了setZero(),MatrixBase::setIdentity和DenseBase::setLinSpaced()方法方便的实现他们。下面的例子展示了构造一个矩阵的三种方法：使用静态方法和赋值、使用静态方法和逗号初始化、使用setXxx()方法

const int size = 6;
MatrixXd mat1(size, size);
mat1.topLeftCorner(size/2, size/2)     = MatrixXd::Zero(size/2, size/2);
mat1.topRightCorner(size/2, size/2)    = MatrixXd::Identity(size/2, size/2);
mat1.bottomLeftCorner(size/2, size/2)  = MatrixXd::Identity(size/2, size/2);
mat1.bottomRightCorner(size/2, size/2) = MatrixXd::Zero(size/2, size/2);
std::cout << mat1 << std::endl << std::endl;
MatrixXd mat2(size, size);
mat2.topLeftCorner(size/2, size/2).setZero();
mat2.topRightCorner(size/2, size/2).setIdentity();
mat2.bottomLeftCorner(size/2, size/2).setIdentity();
mat2.bottomRightCorner(size/2, size/2).setZero();
std::cout << mat2 << std::endl << std::endl;
MatrixXd mat3(size, size);
mat3 << MatrixXd::Zero(size/2, size/2), MatrixXd::Identity(size/2, size/2),
        MatrixXd::Identity(size/2, size/2), MatrixXd::Zero(size/2, size/2);
std::cout << mat3 << std::endl;

输出是一样的三个矩阵:

0 0 0 1 0 0
0 0 0 0 1 0
0 0 0 0 0 1
1 0 0 0 0 0
0 1 0 0 0 0
0 0 1 0 0 0

临时对象的用法

如上所示，静态的方法可用于在声明时或在一个赋值运算符的右侧时初始化变量。可以认为这些方法返回了矩阵或数组，实际上，他们返回了表达式对象，当需要时被确定为矩阵或数组。

这些表达式同样可用于临时对象，之前展示过的一个例子如下

#include <iostream>
#include <Eigen/Dense>
using namespace Eigen;
using namespace std;
int main()
{
  MatrixXd m = MatrixXd::Random(3,3);
  m = (m + MatrixXd::Constant(3,3,1.2)) * 50;
  cout << "m =" << endl << m << endl;
  VectorXd v(3);
  v << 1, 2, 3;
  cout << "m * v =" << endl << m * v << endl;
}

m =
  94 89.8 43.5
49.4  101 86.8
88.3 29.8 37.8
m * v =
404
512
261

表达式m+MatrixXXf::Constant(3,3,1,2)构造了一个3x3的矩阵表达式，它的洗漱全部为1.2加上对应的m的元素。

逗号初始化也可以构造临时对象：

MatrixXf mat = MatrixXf::Random(2, 3);
std::cout << mat << std::endl << std::endl;
mat = (MatrixXf(2,2) << 0, 1, 1, 0).finished() * mat;
std::cout << mat << std::endl;

0.68  0.566  0.823
-0.211  0.597 -0.605

-0.211  0.597 -0.605
  0.68  0.566  0.823