eigen库使用

程序员文章站 2022-06-03 17:59:04

...

第一部分转自：http://blog.csdn.net/r1254/article/details/47418871

矩阵、向量初始化

#include <iostream>
#include "Eigen/Dense"
using namespace Eigen;
int main()
{
    MatrixXf m1(3,4);   //动态矩阵，建立3行4列。
    MatrixXf m2(4,3);   //4行3列，依此类推。
    MatrixXf m3(3,3);

    Vector3f v1;        //若是静态数组，则不用指定行或者列
    /* 初始化 */
    Matrix3d m = Matrix3d::Random();
    m1 = MatrixXf::Zero(3,4);       //用0矩阵初始化,要指定行列数
    m2 = MatrixXf::Zero(4,3);
    m3 = MatrixXf::Identity(3,3);   //用单位矩阵初始化
    v1 = Vector3f::Zero();          //同理，若是静态的，不用指定行列数

    m1 << 1,0,0,1,      //也可以以这种方式初始化
        1,5,0,1,
        0,0,9,1;
    m2 << 1,0,0,
        0,4,0,
        0,0,7,
        1,1,1;
    //向量初始化，与矩阵类似
    Vector3d v3(1,2,3);
    VectorXf vx(30);
}

C++数组和矩阵转换

使用Map函数，可以实现Eigen的矩阵和c++中的数组直接转换,语法如下：

//@param MatrixType 矩阵类型
//@param MapOptions 可选参数，指的是指针是否对齐，Aligned, or Unaligned. The default is Unaligned.
//@param StrideType 可选参数，步长
/*
    Map<typename MatrixType,
        int MapOptions,
        typename StrideType>
*/
    int i;
    //数组转矩阵
    double *aMat = new double[20];
    for(i =0;i<20;i++)
    {
        aMat[i] = rand()%11;
    }
    //静态矩阵，编译时确定维数 Matrix<double,4,5> 
    Eigen:Map<Matrix<double,4,5> > staMat(aMat);


    //输出
    for (int i = 0; i < staMat.size(); i++)
        std::cout << *(staMat.data() + i) << " ";
    std::cout << std::endl << std::endl;


    //动态矩阵，运行时确定 MatrixXd
    Map<MatrixXd> dymMat(aMat,4,5);


    //输出，应该和上面一致
    for (int i = 0; i < dymMat.size(); i++)
        std::cout << *(dymMat.data() + i) << " ";
    std::cout << std::endl << std::endl;

    //Matrix中的数据存在一维数组中，默认是行优先的格式，即一行行的存
    //data()返回Matrix中的指针
    dymMat.data();

矩阵基础操作

eigen重载了基础的+ - * / += -= = /= 可以表示标量和矩阵或者矩阵和矩阵

#include <iostream>
#include <Eigen/Dense>
using namespace Eigen;
int main()
{
    //单个取值，单个赋值
    double value00 = staMat(0,0);
    double value10 = staMat(1,0);
    staMat(0,0) = 100;
    std::cout << value00 <<value10<<std::endl;
    std::cout <<staMat<<std::endl<<std::endl;
    //加减乘除示例 Matrix2d 等同于 Matrix<double,2,2>
    Matrix2d a;
     a << 1, 2,
     3, 4;
    MatrixXd b(2,2);
     b << 2, 3,
     1, 4;

    Matrix2d c = a + b;
    std::cout<< c<<std::endl<<std::endl;

    c = a - b;
    std::cout<<c<<std::endl<<std::endl;

    c = a * 2;
    std::cout<<c<<std::endl<<std::endl;

    c = 2.5 * a;
    std::cout<<c<<std::endl<<std::endl;

    c = a / 2;
    std::cout<<c<<std::endl<<std::endl;

    c = a * b;
    std::cout<<c<<std::endl<<std::endl;

点积和叉积

#include <iostream>
#include <Eigen/Dense>
using namespace Eigen;
using namespace std;
int main()
{
    //点积、叉积(针对向量的)
    Vector3d v(1,2,3);
    Vector3d w(0,1,2);
    std::cout<<v.dot(w)<<std::endl<<std::endl;
    std::cout<<w.cross(v)<<std::endl<<std::endl;
}
*/

转置、伴随、行列式、逆矩阵

小矩阵（4 * 4及以下）eigen会自动优化，默认采用LU分解，效率不高

#include <iostream>
#include <Eigen/Dense>
using namespace std;
using namespace Eigen;
int main()
{
    Matrix2d c;
     c << 1, 2,
     3, 4;
    //转置、伴随
    std::cout<<c<<std::endl<<std::endl;
    std::cout<<"转置\n"<<c.transpose()<<std::endl<<std::endl;
    std::cout<<"伴随\n"<<c.adjoint()<<std::endl<<std::endl;
    //逆矩阵、行列式
    std::cout << "行列式： " << c.determinant() << std::endl;
    std::cout << "逆矩阵\n" << c.inverse() << std::endl;
}

计算特征值和特征向量

#include <iostream>
#include <Eigen/Dense>
using namespace std;
using namespace Eigen;
int main()
{
    //特征向量、特征值
    std::cout << "Here is the matrix A:\n" << a << std::endl;
    SelfAdjointEigenSolver<Matrix2d> eigensolver(a);
    if (eigensolver.info() != Success) abort();
     std::cout << "特征值:\n" << eigensolver.eigenvalues() << std::endl;
     std::cout << "Here's a matrix whose columns are eigenvectors of A \n"
     << "corresponding to these eigenvalues:\n"
     << eigensolver.eigenvectors() << std::endl;
}

解线性方程

#include <iostream>
#include <Eigen/Dense>
using namespace std;
using namespace Eigen;
int main()
{
    //线性方程求解 Ax =B;
    Matrix4d A;
    A << 2,-1,-1,1,
        1,1,-2,1,
        4,-6,2,-2,
        3,6,-9,7;

    Vector4d B(2,4,4,9);

    Vector4d x = A.colPivHouseholderQr().solve(B);
    Vector4d x2 = A.llt().solve(B);
    Vector4d x3 = A.ldlt().solve(B);    


    std::cout << "The solution is:\n" << x <<"\n\n"<<x2<<"\n\n"<<x3 <<std::endl;
}

除了colPivHouseholderQr、LLT、LDLT，还有以下的函数可以求解线性方程组，请注意精度和速度：解小矩阵（4*4）基本没有速度差别

最小二乘求解

最小二乘求解有两种方式，jacobiSvd或者colPivHouseholderQr，4*4以下的小矩阵速度没有区别，jacobiSvd可能更快，大矩阵最好用colPivHouseholderQr

#include <iostream>
#include <Eigen/Dense>
using namespace std;
using namespace Eigen;
int main()
{
    MatrixXf A1 = MatrixXf::Random(3, 2);
    std::cout << "Here is the matrix A:\n" << A1 << std::endl;
    VectorXf b1 = VectorXf::Random(3);
    std::cout << "Here is the right hand side b:\n" << b1 << std::endl;
    //jacobiSvd 方式:Slow (but fast for small matrices)
    std::cout << "The least-squares solution is:\n"
    << A1.jacobiSvd(ComputeThinU | ComputeThinV).solve(b1) << std::endl;
    //colPivHouseholderQr方法:fast
    std::cout << "The least-squares solution is:\n"
    << A1.colPivHouseholderQr().solve(b1) << std::endl;
}

稀疏矩阵

稀疏矩阵的头文件包括：

#include

typedef Eigen::Triplet<double> T;
std::vector<T> tripletList;
triplets.reserve(estimation_of_entries); //estimation_of_entries是预估的条目
for(...)
{
    tripletList.push_back(T(i,j,v_ij));//第 i,j个有值的位置的值
}
SparseMatrixType mat(rows,cols);
mat.setFromTriplets(tripletList.begin(), tripletList.end());
// mat is ready to go!

2.直接将已知的非0值插入

SparseMatrix<double> mat(rows,cols);
mat.reserve(VectorXi::Constant(cols,6));
for(...)
{
    // i,j 个非零值 v_ij != 0
    mat.insert(i,j) = v_ij;
}
mat.makeCompressed(); // optional

稀疏矩阵支持大部分一元和二元运算:

sm1.real() sm1.imag() -sm1 0.5*sm1
sm1+sm2 sm1-sm2 sm1.cwiseProduct(sm2)
二元运算中，稀疏矩阵和普通矩阵可以混合使用

//dm表示普通矩阵
dm2 = sm1 + dm1;
也支持计算转置矩阵和伴随矩阵

第二部分转自（同matlab命令对比，比较清晰）：

http://blog.csdn.net/yuxiangyunei/article/details/50220287

（http://eigen.tuxfamily.org/dox/AsciiQuickReference.txt）

Eigen 矩阵定义

[cpp]

#include <Eigen/Dense>
Matrix<double, 3, 3> A; // Fixed rows and cols. Same as Matrix3d.
Matrix<double, 3, Dynamic> B; // Fixed rows, dynamic cols.
Matrix<double, Dynamic, Dynamic> C; // Full dynamic. Same as MatrixXd.
Matrix<double, 3, 3, RowMajor> E; // Row major; default is column-major.
Matrix3f P, Q, R; // 3x3 float matrix.
Vector3f x, y, z; // 3x1 float matrix.
RowVector3f a, b, c; // 1x3 float matrix.
VectorXd v; // Dynamic column vector of doubles
double s;

Eigen 基础使用

[cpp]

// Basic usage
// Eigen // Matlab // comments
x.size() // length(x) // vector size
C.rows() // size(C,1) // number of rows
C.cols() // size(C,2) // number of columns
x(i) // x(i+1) // Matlab is 1-based
C(i,j) // C(i+1,j+1) //
A.resize(4, 4); // Runtime error if assertions are on.
B.resize(4, 9); // Runtime error if assertions are on.
A.resize(3, 3); // Ok; size didn't change.
B.resize(3, 9); // Ok; only dynamic cols changed.
A << 1, 2, 3, // Initialize A. The elements can also be
4, 5, 6, // matrices, which are stacked along cols
7, 8, 9; // and then the rows are stacked.
B << A, A, A; // B is three horizontally stacked A's.
A.fill(10); // Fill A with all 10's.

Eigen 特殊矩阵生成

[cpp]

// Eigen // Matlab
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)
C.setOnes(rows,cols) // C = ones(rows,cols)
MatrixXd::Random(rows,cols) // rand(rows,cols)*2-1 // MatrixXd::Random returns uniform random numbers in (-1, 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 矩阵分块

[cpp]

// Matrix slicing and blocks. All expressions listed here are read/write.
// Templated 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<cols>() // P(:, 1:cols)
P.leftCols(cols) // P(:, 1:cols)
P.middleCols<cols>(j) // P(:, j+1:j+cols)
P.middleCols(j, cols) // P(:, j+1:j+cols)
P.rightCols<cols>() // 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 矩阵元素交换

[cpp]

// 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 矩阵转置

[cpp]

// 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)
R.conjugate() // conj(R)

Eigen 矩阵乘积

[cpp]

// All the same as Matlab, but matlab doesn't have *= style operators.
// Matrix-vector. Matrix-matrix. Matrix-scalar.
y = M*x; R = P*Q; R = P*s;
a = b*M; R = P - Q; R = s*P;
a *= M; R = P + Q; R = P/s;
R *= Q; R = s*P;
R += Q; R *= s;
R -= Q; R /= s;

Eigen 矩阵单个元素操作

[cpp]

// 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(P) // 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 矩阵化简

[cpp]

// 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)
R.rowwise().prod() // prod(R, 2) or prod(R')'
R.trace() // trace(R)
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 矩阵点乘

[cpp]

// Dot products, norms, etc.
// Eigen // Matlab
x.norm() // norm(x). Note that norm(R) doesn't work in Eigen.
x.squaredNorm() // dot(x, x) Note the equivalence is not true for complex
x.dot(y) // dot(x, y)
x.cross(y) // cross(x, y) Requires #include <Eigen/Geometry>

Eigen 矩阵类型转换

[cpp]

//// Type conversion
// Eigen // Matlab
A.cast<double>(); // double(A)
A.cast<float>(); // single(A)
A.cast<int>(); // int32(A)
A.real(); // real(A)
A.imag(); // imag(A)
// if the original type equals destination type, no work is done

[cpp]

// Note that for most operations Eigen requires all operands to have the same type:
MatrixXf F = MatrixXf::Zero(3,3);
A += F; // illegal in Eigen. In Matlab A = A+F is allowed
A += F.cast<double>(); // F converted to double and then added (generally, conversion happens on-the-fly)
// Eigen can map existing memory into Eigen matrices.
float array[3];
Vector3f::Map(array).fill(10); // create a temporary Map over array and sets entries to 10
int data[4] = {1, 2, 3, 4};
Matrix2i mat2x2(data); // copies data into mat2x2
Matrix2i::Map(data) = 2*mat2x2; // overwrite elements of data with 2*mat2x2
MatrixXi::Map(data, 2, 2) += mat2x2; // adds mat2x2 to elements of data (alternative syntax if size is not know at compile time)

Eigen 求解线性方程组 Ax = b

[cpp]

// 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 矩阵特征值

[cpp]

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

eigen库使用

矩阵、向量初始化

C++数组和矩阵转换

矩阵基础操作

点积和叉积

转置、伴随、行列式、逆矩阵

计算特征值和特征向量

解线性方程

最小二乘求解

稀疏矩阵

Docker基本命令使用详解(推荐)

使用SIS 630死机的处理

移动硬盘在前置USB接口不能用在后置USB接口却可正常使用

主板使用过程中常见问题杂锦

如何将视频转换成音频?使用万兴优转将视频转音频的方法介绍

U盘使用时弹出错误提示0x80070570的解决办法

双十一大促，用户使用余额宝支付61.25亿元

液晶显示器使用经验谈

视频格式如何转换?使用万兴优转转换视频格式的方法

Sis 630主板使用时应注意的一个问题