Eigen

Eigen库介绍

Eigen库属于STL标准模板库，是很好用的c++模板库，下面是Eigen库的介绍。可能存在一些问题，后续会继续修改错误。

Eigen矩阵定义

#include <Eigen/Dense> --------------------%包含Eigen库文件
Matrix<double, 3, 3> A;----------------------%固定行和列，与Matrix3d类似
Matrix<double, 3, Dynamic> B; -----------%固定行，列动态.
Matrix<double, Dynamic, Dynamic> C;–%行、列全动态，类似 MatrixXd.
Matrix<double, 3, 3, RowMajor> E;-------%Row major; default is* column-major.
Matrix3f P, Q, R;-------------------------------%3x3浮点型矩阵
Vector3f x, y, z;---------------------------------%3x1浮点型列向量
RowVector3f a, b, c; -------------------------%1x3浮点型行向量
VectorXd v; ------------------------------------%双精度型动态列向量

Eigen库与Matlab的区别
Eigen -------- Matlab-------------comments
x.size() -------length(x)----------向量大小
C.rows() -----size(C,1)----------行的个数
C.cols()-------size(1,c) ----------列的个数
x(i) ------------ x(i+1) ------------ 向量的索引值起始不同
C(i,j) ---------- C(i+1,j+1)--------矩阵的索引值起始不同

Eigen基础使用

A.resize(4, 4);--------------------%重新定义矩阵尺寸大小
B.resize(4, 9); -------------------%重新定义矩阵尺寸大小
A.resize(3, 3);--------------------%重新定义矩阵尺寸大小
B.resize(3, 9);--------------------%重新定义矩阵尺寸大小

A << 1, 2, 3,
4, 5, 6,
7, 8, 9; ----------------------------%初始化矩阵A
B << A, A, A; --------------------%矩阵A水平排列组成矩阵B
A.fill(10);--------------------------%数值10填充矩阵A

Eigen矩阵生成

Eigen------------------------------------Matlab--------------------comments
MatrixXd::Identity(rows,cols)-----eye(rows,cols)----------初始化单位矩阵
C.setIdentity(rows,cols)-----------C = eye(rows,cols)-----初始化单位矩阵赋值
MatrixXd::Zero(rows,cols)--------zeros(rows,cols)--------初始化零矩阵
C.setZero(rows,cols)--------------C = ones(rows,cols)----零矩阵赋值
MatrixXd::Ones(rows,cols) ------ones(rows,cols)----------矩阵元素为1
C.setOnes(rows,cols)-------------C = ones(rows,cols)-----1矩阵赋值
MatrixXd::Random(rows,cols)—rand(rows,cols)*2-1-----随机设置矩阵
C.setRandom(rows,cols)---------C = rand(rows,cols)*2-1-随机矩阵赋值
VectorXd::LinSpaced(size,low,high)–linspace(low,high,size)’
v.setLinSpaced(size,low,high)----------v = linspace(low,high,size)’

Eigen矩阵分块

Matrix slicing and blocks. All expressions listed here are read/write. Template size versions are faster. Note that Matlab is 1-based (a size N
vector is x(1)…x(N)).
Eigen----------------------------Matlab
x.head(n)-----------------------x(1:n)
x.head<n>()-------------------x(1:n)
x.tail(n)--------------------------x(end - n + 1: end)
x.tail<n>()----------------------x(end - n + 1: end)
x.segment(i, n)---------------x(i+1 : i+n)
x.segment<n>(i)--------------x(i+1 : i+n)
P.block(i, j, rows, cols)------P(i+1 : i+rows, j+1 : j+cols)
P.block<rows, cols>(i, j)-----P(i+1 : i+rows, j+1 : j+cols)
P.row(i)--------------------------P(i+1, ：)
P.col(j)---------------------------P(:, j+1)
P.leftCols<clos>()-------------P(:, 1:cols)
P.leftCols(cols)---------------- P(:, 1:cols)
P.middleCols<clos>(j)--------P(:, j+1:j+cols)
P.middleCols(j, cols)----------P(:, j+1:j+cols)
P.rightCols<clos>()------------P(:, end-cols+1:end)
P.rightCols(cols)----------------P(:, end-cols+1:end)
P.topRows<rows>()------------P(1:rows, ：)
P.topRows(rows)---------------P(1:rows, ：)
P.middleRows<rows>(i)------P(i+1:i+rows, ：)
P.middleRows(i, rows)--------P(i+1:i+rows, ：)
P.bottomRows<rows>()-------P(end-rows+1:end, ：)
P.bottomRows(rows)-----------P(end-rows+1:end, ：)
P.topLeftCorner(rows, cols)—P(1:rows, 1:cols)
P.topRightCorner(rows, cols)-----------P(1:rows, end-cols+1:end)
P.bottomLeftCorner(rows, cols)--------P(end-rows+1:end, 1:cols)
P.bottomRightCorner(rows, cols)------P(end-rows+1:end, end-cols+1:end)
P.topLeftCorner<rows,cols>() ----------P(1:rows, 1:cols)
P.topRightCorner<rows,cols>()---------P(1:rows, end-cols+1:end)
P.bottomLeftCorner<rows,cols>()------P(end-rows+1:end, 1:cols)
P.bottomRightCorner<rows,cols>()----P(end-rows+1:end, end-cols+1:end)

Eigen矩阵元素交换

Of particular note is Eigen’s swap function which is highly optimized.
Eigen-----------------------------------Matlab
R.row(i) = P.col(j);-------------------R(i, ：) = P(:, i)
R.col(j1).swap(mat1.col(j2));-----R(:, [j1 j2]) = R(:, [j2, j1])

Eigen矩阵转置

Views, transpose, etc; all read-write except for .adjoint().
Eigen---------------------------Matlab
R.adjoint()---------------------R’----------------------------%伴随矩阵
R.transpose() ----------------R.’ or conj(R’)------------%矩阵转置
R.diagonal()-------------------diag( R )-------------------%对角矩阵
x.asDiagonal()----------------diag(x)---------------------%对角矩阵
R.transpose().colwise().reverse();----rot90( R )----%逆时针旋转90°
R.conjugate()------------------conj( R ) -----------------%共轭转置

Eigen矩阵乘积

All the same as Matlab, but matlab doesn’t have = style operators.
Matrix-vector-----Matrix-matrix-----Matrix-scalar.
y = Mx;-------------R = PQ;------------R = Ps;
a = bM;------------R = P - Q;----------R = sP;
a *= M;-------------R = P + Q;---------R = P/s;
-----------------------R * = Q;------------R = s * P;
-----------------------R += Q;-------------R *= s;
-----------------------R -= Q;--------------R /= s;

Eigen矩阵单个元素操作

Vectorized operations on each element independently
Eigen----------------------------------Matlab
R = P.cwiseProduct(Q);-----------R = P .* Q
R = P.array() * s.array();----------R = P .* s
R = P.cwiseQuotient(Q); ---------R = P ./ Q
R = P.array() / Q.array();----------R = P ./ Q
R = P.array() + s.array();----------R = P + s
R = P.array() - s.array();-----------R = P - s
R.array() += s;-----------------------R = R + s
R.array() -= s;------------------------R = R - s
R.array() < Q.array();---------------R < Q
R.array() <= Q.array();-------------R <= Q
R.cwiseInverse();--------------------1 ./ P
R.array().inverse();------------------1 ./ P
R.array().sin()-------------------------sin( P )
R.array().cos()------------------------cos( P )
R.array().pow(s)----------------------P .^ s
R.array().square()--------------------P .^ 2
R.array().cube()-----------------------P .^ 3
R.cwiseSqrt()--------------------------sqrt( P )
R.array().sqrt()------------------------sqrt( P )
R.array().exp()------------------------exp( P )
R.array().log()-------------------------log( P )
R.cwiseMax( P )----------------------max(R, P)
R.array().max(P.array())------------max(R, P)
R.cwiseMin§------------------------min(R, P)
R.array().min(P.array())-------------min(R, P)
R.cwiseAbs()--------------------------abs( P )
R.array().abs()------------------------abs( P )
R.cwiseAbs2()------------------------abs(P.^2)
R.array().abs2()----------------------abs(P.^2)
(R.array() < s).select(P,Q);---------(R < s ? P : Q)

Eigen矩阵化简

Reductions.
int r, c;
Eigen-----------------------------Matlab
R.minCoeff()--------------------min(R( : ))-------------%最小
R.maxCoeff()-------------------max(R( : ))------------%最大
s = R.minCoeff(&r, &c)-------[s, i] = min(R( : )); [r, c] = ind2sub(size( R ), i);
s = R.maxCoeff(&r, &c)------[s, i] = max(R( : )); [r, c] = ind2sub(size( R ), i);
R.sum()--------------------------sum(R(：)-------------%求和
R.colwise().sum()-------------sum( R )
R.rowwise().sum()------------sum(R, 2) or sum(R’)’
R.prod()--------------------------prod(R( : ))------------%元素积
R.colwise().prod()-------------prod®
R.rowwise().prod()------------prod(R, 2) or prod(R’)’
R.trace()-------------------------trace®
R.all()-----------------------------all(R( : ))
R.colwise().all()-----------------all( R )
R.rowwise().all()----------------all(R, 2)
R.any()----------------------------any(R( : ))
R.colwise().any()----------------any( R )
R.rowwise().any()---------------any(R, 2)

Eigen矩阵类型转换

Type conversion
Eigen----------------------------- Matlab
A.cast<double>();--------------double(A)--------%矩阵元素类型转为双精度
A.cast<float>();------------------single(A)---------%矩阵元素类型转为浮点型
A.cast();----------------------------int32(A)---------%矩阵元素类型转为整数
A.real();----------------------------real(A)-----------%矩阵元素取实数
A.imag();--------------------------imag(A)----------%矩阵元素取虚数

Eigen求解线性方程组Ax=b

Solve Ax = b. Result stored in x.---------Matlab: x = A \ b.
x = A.ldlt().solve(b)); ------------------------%A sym. p.s.d. #include <Eigen/Cholesky>
x = A.llt() .solve(b));-------------------------%A sym. p.d. #include <Eigen/Cholesky>
x = A.lu() .solve(b));-------------------------%Stable and fast. #include <Eigen/LU>
x = A.qr() .solve(b)); ------------------------%No pivoting. #include <Eigen/QR>
x = A.svd() .solve(b));-----------------------%Stable, slowest. #include <Eigen/SVD>
%.ldlt() -> .matrixL() and .matrixD()
% .llt() -> .matrixL()
%.lu() -> .matrixL() and .matrixU()
% .qr() -> .matrixQ() and .matrixR()
% .svd() -> .matrixU(), .singularValues(), and .matrixV()

Eigen矩阵特征值

Eigenvalue problems
Eigen---------------------------------Matlab
A.eigenvalues();-------------------eig(A);
EigenSolver eig(A);---------------[vec val] = eig(A)
eig.eigenvalues();-----------------diag(val)
eig.eigenvectors(); ---------------vec
%For self-adjoint matrices use SelfAdjointEigenSolver<>

Eigen矩阵点乘

Dot products, norms, etc.
Eigen--------------------Matlab--------comments
x.norm()-----------------norm(x).------%取范数
x.squaredNorm()-----dot(x, x)-------%点乘
x.dot(y) -----------------dot(x, y)-------%点乘
x.cross(y)---------------cross(x, y)----%需要 #include <Eigen/Geometry>

参考文献

【1】http://eigen.tuxfamily.org/dox/AsciiQuickReference.txt
【2】http://blog.csdn.net/augusdi/article/details/12907341