Eigen教程1

最新推荐文章于 2022-05-01 22:46:08 发布
最新推荐文章于 2022-05-01 22:46:08 发布
阅读量571 收藏 5
点赞数 1
分类专栏： eigen
转载http://blog.csdn.net/xuezhisdc/article/details/54619853

固定大小的矩阵和向量

/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <Eigen/Core>

using namespace Eigen;  
using namespace std;  

// import most common Eigen types
int main(int, char *[])
{
    Matrix3f m3; //3x3单精度矩阵
    m3 << 1, 2, 3, 4, 5, 6, 7, 8, 9;
    Matrix4f m4 = Matrix4f::Identity(); //4x4单位矩阵（单精度）
    Vector4i v4(1, 2, 3, 4); // 长度为4的整型向量

    // 输出结果
    std::cout << "m3\n" << m3 << "\nm4:\n"
        << m4 << "\nv4:\n" << v4 << std::endl;
}
  • Matrix表示矩阵，Vector表示向量，数字表示维度，最后的f和i分别表示单精度和整型数据类型。
  • 固定大小表示编译时，行数和列数是固定的。这时，Eigen不会分配动态内存。这对于比较小的尺寸比较适合，比如16x16。

动态大小的矩阵和向量

/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <Eigen/Core>

using namespace Eigen;  
using namespace std;  

int main(int, char *[])
{
    // 动态矩阵
    for (int size=1; size<=4; ++size)
    {
        MatrixXi m(size,size+1); // 一个整型的大小为 (size)x(size+1) 的矩阵
        for (int j=0; j<m.cols(); ++j) // 遍历列
            for (int i=0; i<m.rows(); ++i) // 遍历行
                m(i,j) = i+j*m.rows(); // 使用圆括号m(i,j)访问矩阵的元素
        std::cout << m << "\n\n"; //打印矩阵
    }

    // 动态向量
    VectorXf v(4); // 定义一个4维单精度向量
    // 使用圆括号()或方括号[]访问向量元素
    v[0] = 1; v[1] = 2; v(2) = 3; v(3) = 4;
    std::cout << "\nv:\n" << v << std::endl;
}
  • 小结：X表示动态大小。
  • #include <Eigen/Eigen>将包含所有的Eigen函数。#include <Eigen/Dense>包含所有普通矩阵函数，不包括稀疏矩阵函数。它们会增加编译时间。

矩阵和向量类型

  • Eigen中的所有密集矩阵和向量都是通过Matrix类来表示的。Matrix通过一系列的模板参数来生成具体的类别。
  • Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime>中，Scalar表示数据类型，RowsAtCompileTime和ColsAtCompileTime分别表示编译时的行数和列数。
  • Vector3d 定义为 Matrix<double, 3, 1>
  • 对于动态大小的类型，在编译时不指定行数和列数，使用Eigen::Dynamic。比如，VectorXd定义为Matrix<double, Dynamic, 1>。

访问元素

  • Eigen支持以下的读/写元素语法：
matrix(i,j);
vector(i)
vector[i]
vector.x() // first coefficient
vector.y() // second coefficient
vector.z() // third coefficient
vector.w() // fourth coefficient
  • 矩阵只能通过圆括号()访问；
  • 向量可以通过圆括号()和方括号[]访问。
  • 上述的元素访问方法都通过断言检查范围，代价比较大。
    • 通过定义EIGEN_NO_DEBUG 或 NDEBUG，取消断言。
    • 通过使用coeff()和coeffRef()，来取消检查。比如，MatrixBase::coeff(int,int) const, MatrixBase::coeffRef(int,int)等。

创建和初始化矩阵和向量

通过预定义矩阵初始化
创建固定大小的矩阵和向量
/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <Eigen/Core>

using namespace Eigen;  
using namespace std;  

int main(int, char *[])
{
    float value = 3.0;
    Matrix3f x; // 创建一个3x3的单精度矩阵
    x = Matrix3f::Zero(); //全零矩阵
    cout << x << endl << endl;
    x = Matrix3f::Ones(); //全一矩阵
    cout << x << endl << endl;
    x = Matrix3f::Constant(value); //全value矩阵
    cout << x << endl << endl;
    x = Matrix3f::Identity(); //单位矩阵
    cout << x << endl << endl;
    x = Matrix3f::Random(); // 随机矩阵
    cout << x << endl << endl;
    x.setZero();
    cout << x << endl << endl;
    x.setOnes();
    cout << x << endl << endl;
    x.setIdentity();
    cout << x << endl << endl;
    x.setConstant(value);
    cout << x << endl << endl;
    x.setRandom();
    cout << x << endl << endl;
}
创建动态大小的矩阵
/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <Eigen/Core>

using namespace Eigen;  
using namespace std;  

int main(int, char *[])
{
    float value = 3.0f;
    int rows = 3;
    int cols = 4;
    MatrixXf x;
    x = MatrixXf::Zero(rows, cols);
    cout << x << endl << endl;
    x = MatrixXf::Ones(rows, cols);
    cout << x << endl << endl;
    x = MatrixXf::Constant(rows, cols, value);
    cout << x << endl << endl;
    x = MatrixXf::Identity(rows, cols);
    cout << x << endl << endl;
    x = MatrixXf::Random(rows, cols);
    cout << x << endl << endl;
    x.setZero(rows, cols);
    cout << x << endl << endl;
    x.setOnes(rows, cols);
    cout << x << endl << endl;
    x.setConstant(rows, cols, value);
    cout << x << endl << endl;
    x.setIdentity(rows, cols);
    cout << x << endl << endl;
    x.setRandom(rows, cols);
    cout << x << endl << endl;
    return 0;
}
创建动态大小的向量
/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <Eigen/Core>

using namespace Eigen;  
using namespace std;  

int main(int, char *[])
{
    int size = 3;
    float value = 3.0f;
    VectorXf x; // 定义动态向量
    x = VectorXf::Zero(size); //全0向量
    cout << x << endl << endl;
    x = VectorXf::Ones(size); //全1向量
    cout << x << endl << endl;
    x = VectorXf::Constant(size, value);//全value向量
    cout << x << endl << endl;
    //x = VectorXf::Identity(size);//报错
    x = VectorXf::Random(size);
    cout << x << endl << endl;
    x.setZero(size);
    cout << x << endl << endl;
    x.setOnes(size);
    cout << x << endl << endl;
    x.setConstant(size, value);
    cout << x << endl << endl;
    //x.setIdentity(size);
    x.setRandom(size);
    cout << x << endl << endl;
    return 0;
}
创建固定大小的基向量
/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <Eigen/Core>

using namespace Eigen;  
using namespace std;  

int main(int, char *[])
{
    Vector3f x;
    x = Vector3f::UnitX(); // 1 0 0
    cout << x << endl << endl;
    x = Vector3f::UnitY(); // 0 1 0
    cout << x << endl << endl;
    x = Vector3f::UnitZ(); // 0 0 1
    cout << x << endl << endl;

    return 0;
}
创建动态大小的基向量
/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <Eigen/Core>

using namespace Eigen;  
using namespace std;  

int main(int, char *[])
{
    VectorXf x;
    x = VectorXf::Unit(4,1);
    cout << x << endl << endl;
    x = Vector4f(0,1,0,0);
    cout << x << endl << endl;
    x = Vector4f::UnitY();
    cout << x << endl << endl;

    return 0;
}
例子
/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <Eigen/Core>

using namespace Eigen;  
using namespace std;  

int main(int, char *[])
{

    cout << MatrixXf::Constant(2, 3, sqrt(2)) << endl; // 2x3的单精度矩阵
    RowVector3i v; //3维行向量
    v.setConstant(6);
    cout << "v = " << v << endl;

    return 0;
}
通过Cast的方式初始化
相同尺寸的矩阵兼容
  • 元素类型通过MatrixBase::cast()自动转换。
/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <Eigen/Core>
#include <Eigen/Eigen>

using namespace Eigen;  
using namespace std;  

int main(int, char *[])
{
    Vector3d md(1,2,3);
    Vector3f mf = md.cast<float>();
    cout << "md = " << md << endl;
    cout << "mf = " << mf << endl;
    return 0;
}
相同类型的矩阵兼容
/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <Eigen/Core>

using namespace Eigen;  
using namespace std;  

int main(int, char *[])
{
    MatrixXf res(10,10);
    Matrix3f a, b;
    a = Matrix3f::Identity();
    b = Matrix3f::Constant(3);
    res = a+b; // OK: res is resized to size 3x3

    cout << a << endl << endl;
    cout << b << endl << endl;
    cout << res << endl << endl;
    return 0;
}
通过Map方式初始化
/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <vector>
#include <Eigen/Core>

using namespace Eigen;  
using namespace std;  

int main(int, char *[])
{
    std::vector<float> stlarray(10);
    VectorXf::Map(&stlarray[0], stlarray.size()).squaredNorm();

    return 0;
}
  • 下面的代码没有完全调通
/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <vector>
#include <Eigen/Core>

using namespace Eigen;  
using namespace std;  

int main(int, char *[])
{
    const int rows = 3;
    const int cols = 4;
    float array[rows*cols];
    Map<MatrixXf> m(array,rows,cols);
    Matrix3f othermatrix1 = Matrix3f::Identity();//单位矩阵
    MatrixXf othermatrix2(3,4);
    othermatrix2 = MatrixXf::Constant(3,4,5);//3x4的常量矩阵，值都为5
    m = othermatrix1 * othermatrix2;
    //m.eigenvalues();
    std::vector<float> stlarray(10);
    VectorXf::Map(&stlarray[0], stlarray.size()).squaredNorm();
    cout << m << endl;
    return 0;
}
通过逗号初始化
/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <vector>
#include <Eigen/Core>

using namespace Eigen;  
using namespace std;  

int main(int, char *[])
{
    Matrix3f m;
    m << 1, 2, 3,
        4, 5, 6,
        7, 8, 9;
    cout << m << endl;
    return 0;
}
  • 使用逗号和子矩阵，初始化矩阵。
/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <vector>
#include <Eigen/Core>

using namespace Eigen;  
using namespace std;  

int main(int, char *[])
{
    int rows=5, cols=5;
    MatrixXf m(rows,cols);
    m << (Matrix3f() << 1, 2, 3, 4, 5, 6, 7, 8, 9).finished(),//左上角3x3
        MatrixXf::Zero(3,cols-3), //右上角3x2
        MatrixXf::Zero(rows-3,3), //左下角2x3
        MatrixXf::Identity(rows-3,cols-3); //右下角2x2

    cout << m << endl;
    return 0;
}
  • .finished()用于当临时矩阵初始化完成时，获取实际的矩阵对象。尽管看起来很复杂，但实际上编译时已经优化。

算术操作

传统的数学运算
  • 矩阵/向量乘法：
col2 = mat1 * col1; //矩阵x列向量
row2 = row1 * mat1;  // 行向量x矩阵
row1 *= mat1;
mat3 = mat1 * mat2; 
mat3 *= mat1;
  • 矩阵/向量加法/减法：
mat3 = mat1 + mat2; 
mat3 += mat1;
mat3 = mat1 - mat2; 
mat3 -= mat1;
  • 标量加法/减法：
mat3 = mat1 * s1; 
mat3 = s1 * mat1; 
mat3 *= s1;
mat3 = mat1 / s1; 
mat3 /= s1;
逐元素的操作

  • 逐元素的操作，请查阅.cwise()。

  • 逐元素乘法

mat3 = mat1.cwise() * mat2;
  • 加/减标量
//需要Array模块 #include <Eigen/Array>
mat3 = mat1.cwise() + scalar;
mat3.cwise() += scalar;
mat3.cwise() -= scalar;
  • 逐元素除法
//需要Array模块 #include <Eigen/Array>
mat3 = mat1.cwise() / mat2;
  • 逐元素取倒数
//需要Array模块 #include <Eigen/Array>
mat3 = mat1.cwise().inverse();
  • 逐元素比较运算
//需要Array模块 #include <Eigen/Array>
mat3 = mat1.cwise() < mat2;
mat3 = mat1.cwise() <= mat2;
mat3 = mat1.cwise() > mat2;
//等
  • 三角余弦
    • sin(), cos()等。
//需要Array模块 #include <Eigen/Array>
mat3 = mat1.cwise().sin();
// 等
  • 指数
    • pow(), square(), cube(), sqrt(), exp(), log()等。
//需要Array模块 #include <Eigen/Array>
mat3 = mat1.cwise().square();
mat3 = mat1.cwise().pow(5);
mat3 = mat1.cwise().log();
//等
  • 最小值，最大值，绝对值
mat3 = mat1.cwise().min(mat2);
mat3 = mat1.cwise().max(mat2);
mat3 = mat1.cwise().abs();
mat3 = mat1.cwise().abs2();

  • 各种乘法运算

    • 矩阵乘法：m1*m2
    • 逐元素乘法：mat1.cwise()*mat2
    • 点积：scalar = vec1.dot(vec2);
    • 外积：mat = vec1 * vec2.transpose();
    • 交叉积：#include <Eigen/Geometry> vec3 = vec1.cross(vec2);

  • 逐元素操作示例：

/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <vector>
#include <Eigen/Eigen>

using namespace Eigen;  
using namespace std;  

int main(int, char *[])
{
    Matrix3f x, y;
    x << 5,3,1,2,-7,8,9,-4,6;
    y << 5,3,1,2,-7,8,9,4,7;
    cout << x << endl << endl;
    cout << x.cwiseAbs() << endl << endl;//绝对值
    cout << x.cwiseAbs2() << endl << endl; //平方
    cout << x.cwiseEqual(y) << endl << endl; //是否相等
    cout << x.cwiseMax(y) << endl << endl; //逐元素最大值
    cout << x.cwiseMin(y) << endl << endl;
    cout << x.cwiseInverse() << endl << endl; //倒数
    cout << x.cwiseNotEqual(y) << endl << endl; //不相等
    cout << x.cwiseProduct(y) << endl << endl; //逐元素乘法
    cout << x.cwiseQuotient(y) << endl << endl; //除法
    cout << x.cwiseSqrt() << endl << endl; //
    return 0;
}

Reductions

  • Eigen提供了一些reduction方法： minCoeff() , maxCoeff() , sum() , trace() , norm() , squaredNorm() , all() , 和 any()。
  • 上述这些方法都可以逐列或逐行的执行。如下所示：
/*
 * 参考链接：http://eigen.tuxfamily.org/dox-2.0/TutorialCore.html#TutorialCoreGettingStarted
*/

#include <iostream>
#include <vector>
#include <Eigen/Core>

using namespace Eigen;  
using namespace std;  

int main(int, char *[])
{
    Matrix3f x;
    x << 5,3,1,2,7,8,9,4,6;
    cout << x.minCoeff() << endl;
    cout << x.colwise().minCoeff() << endl;
    cout << x.rowwise().minCoeff() << endl;

    return 0;
}
  • maxCoeff()和minCoeff()函数可以通过设置可选参数，返回最大/小值的位置：maxCoeff(int* i, int* j) , minCoeff(int* i, int* j) 。
  • all() 和 any()在使用逐元素操作时，非常有用。
sda42342342423
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SLAM——之Eigen函数库
格物致知
05-03 1897
1. Eigen示例 相较于Ceres而言，Eigen函数库相对较为简单，我们上一篇文章详细描述了Ceres的使用以及注意事项，由于Ceres能够使用ceres::AutoDiffCostFunction这一类的自动求导函数，相对而言更加轻松，所以Eigen更多的是做矩阵运算。这里我们给出上一篇文章最后的Ceres求解的Eigen版本。我们可以看到本质上差别不大，只是Eigen需要自己求解雅克比矩阵J，并在用GN构建增量方程后，使用ldlt求解线性方程HX=g。 #include <iostream&
Eigen——线性代数运算的C++模板库
Aliang's dream house
01-11 3993
之前几天，帮着师兄改写程序，需要将Mathematica编写的程序用C语言翻译出来并运行出结果。这几天下来也算对Eigen有了初步的了解。写一下，希望对大家有所帮助。 在最初选择C++矩阵运算库是，主要参考了如下两篇文， http://blog.csdn.net/chenbang110/article/details/12304123 http://blog.csdn.net/h
Eigen笔记1
qq_42731705的博客
09-27 507
1.从旋转矩阵转欧拉角 rotation_matrix.eulerAngles() 这里是绕动轴的欧拉角，也就是按照旋转坐标系进行旋转的角度。关于每一次按照一个轴旋转都会得到本次的旋转矩阵，注意这里的旋转矩阵是旋转后的坐标系到原坐标系之间的变换，一个求旋转矩阵的记忆方法就是，假设世界坐标为W，把世界坐标系旋转后的坐标系是C，那么求C到W的旋转矩阵R_WC，就是把坐标系C的各个坐标轴向W坐标系中投影，xyz三个坐标轴的投影分别是旋转矩阵的三个列向量，也就是把C坐标系的xyz轴在W坐标系中表达，三个轴在W坐标系
稀疏矩阵操作
LYKymy的博客
10-13 5197
操纵和解决稀疏问题的模块 稀疏矩阵格式 在许多应用中（例如，有限元方法），通常处理非常大的矩阵，其中只有少数系数与零不同。 在这种情况下，通过使用仅存储非零系数的专用表示，可以减少存储器消耗并提高性能。 这种矩阵称为稀疏矩阵。 SparseMatrix类是Eigen稀疏模块的主要稀疏矩阵表示; 它提供高性能和低内存使用率。 它实现了广泛使用的压缩列（或行）存储方案的更通用的变体。 它由四...
【C++】Eigen优化及D8016错误
weixin_36576175的博客
08-17 721
Eigen优化过程 背景 最近在写一个保边滤波的算法。为了加快运算速率，采用C++语言，使用Eigen库进行大矩阵运算。 效率问题 作为基于全局图像的算法，需要创建一个全局的矩阵（n*m在数千万到数亿的级别），但是，有效数据大约只有数十万级别，也就是说这是一个不折不扣的稀疏矩阵。因此，我们所有的矩阵运算都是基于Eigen::SparseMatrix 对于矩阵的构建，常用的有以下几种方法。 直接给稀疏矩阵（SparseMatrix赋值） Eigen::SparseMatrix<double>
网页版eigen中文教程_eigen教程_eigen；矩阵函数库；中文教程_
10-01
在`网页版eigen教程`中，你将学习如何初始化和操作Eigen的矩阵和向量，理解表达式模板的工作原理，以及如何解决线性系统。教程可能还涵盖了如何使用稀疏矩阵、进行矩阵运算（如乘法和求逆）以及如何在实际项目中应用...
eigen-3.3.9(包含详细编译教程）
02-24
1. **获取源码**：首先，你需要从压缩包中解压"eigen-ver-3.3.9"，这将包含Eigen的所有源文件。 2. **配置环境**：确保你的系统上已经安装了C++编译器，例如GCC或Clang。此外，可能需要CMake来管理编译过程。 3. *...
eigen库使用教程，使用说明文档
最新发布
05-31
本教程将详细介绍Eigen库的核心概念、主要功能以及如何在项目中有效地使用它。 ### 1. Eigen库简介 Eigen库的核心特点在于其对矩阵和向量操作的优化。它不依赖任何外部库，仅依赖于标准C++库，因此易于集成到任何...
Eigen类库的中文简易教程
11-28
**Eigen类库中文简易教程** Eigen是一个开源的C++矩阵和向量库，它专注于高效、灵活和易于使用。这个库被广泛应用于数值计算、机器学习、计算机视觉等多个领域。本教程将帮助你理解并掌握如何利用Eigen进行矩阵运算...
eigen3.3.9
01-09
1. **高效性能**：Eigen使用模板元编程技术，直接在编译时生成高效的汇编代码，避免了运行时的类型检查和动态内存分配，从而实现了极高的计算速度。 2. **易用性**：Eigen的API设计简洁，直观，使得开发者可以方便...
Eigen库的使用指南
07-21
Eigen库的使用指南
Eigen最经典的操作
weixin_44142774的博客
02-13 839
1、声明与赋值 1.1、声明 1.1.1、在编译期不确定矩阵（向量）大小，如下 MatrixXd mat; Matrix<double, Dynamic, Dynamic> mat; //typedef Matrix<double, Dynamic, Dynamic> MatrixXd; VectorXd v; 1.1.2、在编译期确定矩阵（向量）大小 MatrixXd mat(2,4); Matrix<double, 2, 4> mat;
【Eigen】学习Eigen的一些总结——快速入门指南（一）
qq_29504955的博客
01-23 1787
对Eigen快速入门指南的一些学习
C++应用Eigen库对应实现matlab中部分函数
nannanstyle的博客
04-25 2336
一、将Eigen加入到项目中 1.如下图将Eigen库文件夹加入到项目目录中。 2.将Eigen文件加入到运行环境变量中 3.在项目头文件中包含Eigen。 二、使用Eigen中函数及功能 1)声明矩阵，向量，数组： 图中声明了一个2x3的矩阵，矩阵中数据类型为float。 第一个参数为矩阵中数据类型，第二参数为行数，第三为列数。 当参数为Dynamic时为动态，程序会自动检测需要设置XxX矩阵。 2)矩阵赋值 方法一： 方法二： 方法三： 复数矩阵赋值方式 输出矩阵 使用方法 4)
Eigen入门系列 —— Eigen::Matrix常用数据类型及初始化
工业机器视觉
05-01 4647
Eigen入门系列 —— Eigen::Matrix常用数据类型及初始化前言程序说明输出结果代码示例 前言 随着工业自动化、智能化的不断推进，机器视觉（2D/3D）在工业领域的应用和重要程度也同步激增（识别、定位、抓取、测量，缺陷检测等），而针对不同作业场景进行解决方案设计时，通常会借助PCL、OpenCV、Eigen等简单方便的开源算法库进行方案的快速验证和迭代以满足作业场景下的目标需求。 为了让对工业机器视觉方向感兴趣的同学能够少走一些弯路，故推出了此一系列简易入门教程示例，让初次使用者能够最简单..
Eigen关于稀疏矩阵
wh15542311366的博客
08-09 3929
处理和解决稀疏问题涉及各种模块，总结如下： 模块 头文件 内容 SparseCore #include <Eigen/SparseCore> SparseMatrix 和 SparseVector 类、矩阵组装、 基本稀疏线性代数（包括稀疏三角求解器） SparseCholesky #include <Eigen/Spars
C++ 矩阵操作，Eigen::MatrixXf一些见解
weixin_33566282的博客
02-11 1万+
1 Eigen::MatrixXf矩阵运算加速方法 舍弃不必要的计算：用不着的数据去掉； 尽量引用加const传递变量； 尽量不自己写for计算； 加入O3优化：在CMakeLists中添加 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3") message(${CMAKE_CXX_FLAGS}) 2 Error:cannot call member ...
Eigen学习（六）高级初始化
热门推荐
Fearless的博客
04-05 4万+
本节介绍几个初始化矩阵的高级方法，会更具体的介绍逗号初始化的方法。同样会介绍如何得到特殊矩阵比如单位矩阵和零矩阵等。逗号初始化Eigen提供了一个逗号初始化方法可以让使用者方便的设置矩阵、向量及数组的所有元素。简单的列出所有的元素，从左上角开始，从左至右，从上到下即可，当然前提是指定对象的尺寸，如果输入的数据少了或者多了，Eigen会报错的。Matrix3f m; m &lt;&lt; 1, 2,...
EIGEN函数
printeger的博客
11-04 563
旋转向量/旋转矩阵/四元数赋值 //对旋转向量（轴角）赋值的三大种方法 //1.使用旋转的角度和旋转轴向量（此向量为单位向量）来初始化角轴 AngleAxisd V1(M_PI / 4, Vector3d(0, 0, 1));//以（0,0,1）为旋转轴，旋转45度 cout << "Rotation_vector1" << endl << V1.matrix() << endl; //2.使用旋转矩阵转旋转向量的方式
线性化系统分析程序Eigen-values教程
05-26
Eigen-values（特征值）是线性系统分析中的一个重要概念，它可以用来描述系统的稳定性和响应特性。Eigen-values的计算可以通过求解系统的特征方程来完成，而特征方程的求解可以使用线性代数中的特征值和特征向量来实现。在这里，我们将介绍如何使用Eigen-values程序来进行线性系统分析。 首先，需要安装Eigen-values程序包。该程序包是一个免费的开源软件，在网上可以找到下载链接。安装完成后，可以使用以下命令在C++代码中包含Eigen-values库： ``` #include <eigenvalues/eigenvalues.h> ``` 接下来，需要定义一个矩阵表示线性系统的状态空间模型。例如，假设我们有以下状态空间模型： ``` x_dot = Ax + Bu y = Cx + Du ``` 其中，A、B、C和D是系统矩阵，x是状态向量，u是输入向量，y是输出向量。我们可以使用Eigen-values程序中的Matrix类来定义这些矩阵： ``` Eigen::MatrixXd A(n, n); Eigen::MatrixXd B(n, m); Eigen::MatrixXd C(p, n); Eigen::MatrixXd D(p, m); ``` 其中，n是状态向量的维数，m是输入向量的维数，p是输出向量的维数。接下来，我们需要将A、B、C和D矩阵填充为实际的数值。例如，假设我们有一个2维状态向量、1维输入向量和1维输出向量的系统，可以使用以下代码来填充矩阵： ``` A << 0, 1, -1, -2; B << 0, 1; C << 1, 0; D << 0; ``` 现在，我们可以使用Eigen-values程序中的eig()函数来计算该系统的特征值。该函数将返回一个包含系统特征值的向量： ``` Eigen::VectorXcd eigenvalues = eig(A); ``` 在这里，我们使用了复数向量（VectorXcd）来存储特征值，因为线性系统的特征值可能是复数。如果所有特征值的实部都小于零，则系统是稳定的。如果存在一个或多个特征值的实部大于或等于零，则系统是不稳定的。 除了特征值，我们还可以使用Eigen-values程序来计算系统的特征向量。特征向量是满足以下方程的向量： ``` Av = λv ``` 其中，λ是特征值，v是特征向量。特征向量描述了线性系统在特征值对应的方向上的响应特性。例如，如果系统的特征值是实数，则特征向量可以表示系统的振荡模式。如果系统的特征值是复数，则特征向量可以表示系统的旋转模式。可以使用以下代码来计算系统的特征向量： ``` Eigen::EigenSolver<Eigen::MatrixXd> solver(A); Eigen::MatrixXcd eigenvectors = solver.eigenvectors(); ``` 在这里，我们使用Eigenvalues程序中的EigenSolver类来计算系统的特征向量。该类将返回一个包含特征向量的矩阵。由于特征向量可能是复数，因此我们使用复数矩阵（MatrixXcd）来存储它们。 使用Eigen-values程序进行线性系统分析时，需要注意以下几点： 1. 系统的状态空间模型必须是已知的。 2. 系统必须是线性的。 3. 系统必须是时不变的。 4. 系统必须是有限维的。 如果满足上述条件，则可以使用Eigen-values程序来计算系统的特征值和特征向量，以进行稳定性和响应分析。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值