c++矩阵运算库Eigen

最新推荐文章于 2024-09-14 11:51:04 发布
最新推荐文章于 2024-09-14 11:51:04 发布
阅读量594 收藏 6
点赞数
文章标签： php c/c++ 游戏
原文链接：http://www.cnblogs.com/goingupeveryday/p/5699053.html
版权

　　Eigen 的简介和下载安装

最近因为要写机械臂的运动学控制程序，因此难免就要在C++中进行矩阵运算。然而C++本身不支持矩阵运算，Qt库中的矩阵运算能力也相当有限，因此考虑寻求矩阵运算库Eigen的帮助。　

Eigen是一个C++线性运算的模板库：他可以用来完成矩阵，向量，数值解等相关的运算。（Eigen is a C++ template library for linear algebra: matrices, vectors, numerical solvers, and related algorithms.）

Eigen库下载： http://eigen.tuxfamily.org/index.php?title=Main_Page

Eigen库的使用相当方便，将压缩包中的Eigen文件夹拷贝到项目目录下，直接包含其中的头文件即可使用，省去了使用Cmake进行编译的烦恼。

Eigen官网有快速入门的参考文档：http://eigen.tuxfamily.org/dox/group__QuickRefPage.html

 

　　Eigen简单上手使用

要实现相应的功能只需要包含头相应的头文件即可：

Core
#include <Eigen/Core>
Matrix and Array classes, basic linear algebra (including triangular and selfadjoint products), array manipulation
Geometry
#include <Eigen/Geometry>
Transform, Translation, Scaling, Rotation2D and 3D rotations (Quaternion, AngleAxis)
LU
#include <Eigen/LU>
Inverse, determinant, LU decompositions with solver (FullPivLU, PartialPivLU)
Cholesky
#include <Eigen/Cholesky>
LLT and LDLT Cholesky factorization with solver
Householder
#include <Eigen/Householder>
Householder transformations; this module is used by several linear algebra modules
SVD
#include <Eigen/SVD>
SVD decomposition with least-squares solver (JacobiSVD)
QR
#include <Eigen/QR>
QR decomposition with solver (HouseholderQR, ColPivHouseholderQR, FullPivHouseholderQR)
Eigenvalues
#include <Eigen/Eigenvalues>
Eigenvalue, eigenvector decompositions (EigenSolver, SelfAdjointEigenSolver,ComplexEigenSolver)
Sparse
#include <Eigen/Sparse>
Sparse matrix storage and related basic linear algebra (SparseMatrix, DynamicSparseMatrix,SparseVector)
 
#include <Eigen/Dense>
Includes Core, Geometry, LU, Cholesky, SVD, QR, and Eigenvalues header files
 
#include <Eigen/Eigen>
Includes Dense and Sparse header files (the whole Eigen library)

 基本的矩阵运算只需要包含Dense即可

基本的数据类型：Array, matrix and vector

声明：

#include<Eigen/Dense>

...
//1D objects
Vector4d  v4;
Vector2f  v1(x, y);
Array3i   v2(x, y, z);
Vector4d  v3(x, y, z, w);
VectorXf  v5; // empty object
ArrayXf   v6(size);

//2D objects
atrix4f  m1;
MatrixXf  m5; // empty object
MatrixXf  m6(nb_rows, nb_columns);

赋值：

//    
Vector3f  v1;     v1 << x, y, z;
ArrayXf   v2(4);  v2 << 1, 2, 3, 4;

//
Matrix3f  m1;   m1 << 1, 2, 3,
                      4, 5, 6,
                      7, 8, 9;
int rows=5, cols=5;
MatrixXf m(rows,cols);
m << (Matrix3f() << 1, 2, 3, 4, 5, 6, 7, 8, 9).finished(),
     MatrixXf::Zero(3,cols-3),
     MatrixXf::Zero(rows-3,3),
     MatrixXf::Identity(rows-3,cols-3);
cout << m;


//对应的输出：
1 2 3 0 0
4 5 6 0 0
7 8 9 0 0
0 0 0 1 0
0 0 0 0 1

Resize矩阵：

//
vector.resize(size);
vector.resizeLike(other_vector);
vector.conservativeResize(size);

//
matrix.resize(nb_rows, nb_cols);
matrix.resize(Eigen::NoChange, nb_cols);
matrix.resize(nb_rows, Eigen::NoChange);
matrix.resizeLike(other_matrix);
matrix.conservativeResize(nb_rows, nb_cols);

元素读取：

vector(i)；    
vector[i]；

matrix(i,j)；

矩阵的预定义：

//vector x
x.setZero();
x.setOnes();
x.setConstant(value);
x.setRandom();
x.setLinSpaced(size, low, high);

VectorXf::Unit(4,1) == Vector4f(0,1,0,0)
                    == Vector4f::UnitY()

//matrix x
x.setZero(rows, cols);
x.setOnes(rows, cols);
x.setConstant(rows, cols, value);
x.setRandom(rows, cols);

x.setIdentity();//单位矩阵
x.setIdentity(rows, cols);

映射操作，可以将c语言类型的数组映射为矩阵或向量：

（注意：

1.映射只适用于对一维数组进行操作，如果希望将二维数组映射为对应的矩阵，可以借助"mat.row(i)=Map<Vector> v(data[i],n)"进行循环来实现，其中data为二维数组名，n为数组第一维的维度。

2.应设置之后数组名和矩阵或向量名其实指向同一个地址，只是名字和用法不同，另外，对其中的任何一个进行修改都会修改另外一个）

//连续映射
float data[] = {1,2,3,4};
Map<Vector3f> v1(data);       // uses v1 as a Vector3f object
Map<ArrayXf>  v2(data,3);     // uses v2 as a ArrayXf object
Map<Array22f> m1(data);       // uses m1 as a Array22f object
Map<MatrixXf> m2(data,2,2);   // uses m2 as a MatrixXf object

//间隔映射
float data[] = {1,2,3,4,5,6,7,8,9};
Map<VectorXf,0,InnerStride<2> >  v1(data,3);                      // = [1,3,5]
Map<VectorXf,0,InnerStride<> >   v2(data,3,InnerStride<>(3));     // = [1,4,7]
Map<MatrixXf,0,OuterStride<3> >  m2(data,2,3);                    // both lines     |1,4,7|
Map<MatrixXf,0,OuterStride<> >   m1(data,2,3,OuterStride<>(3));   // are equal to:  |2,5,8|

算术运算：

 

add 
subtract
mat3 = mat1 + mat2;           mat3 += mat1;
mat3 = mat1 - mat2;           mat3 -= mat1;
scalar product
mat3 = mat1 * s1;             mat3 *= s1;           mat3 = s1 * mat1;
mat3 = mat1 / s1;             mat3 /= s1;
matrix/vector 
products *
col2 = mat1 * col1;
row2 = row1 * mat1;           row1 *= mat1;
mat3 = mat1 * mat2;           mat3 *= mat1;
transposition 
adjoint *
mat1 = mat2.transpose();      mat1.transposeInPlace();
mat1 = mat2.adjoint();        mat1.adjointInPlace();
dot product 
inner product *
scalar = vec1.dot(vec2);
scalar = col1.adjoint() * col2;
scalar = (col1.adjoint() * col2).value();
outer product *
mat = col1 * col2.transpose();

 

norm 
normalization *
scalar = vec1.norm();         scalar = vec1.squaredNorm()
vec2 = vec1.normalized();     vec1.normalize(); // inplace

 

cross product *
#include <Eigen/Geometry>
vec3 = vec1.cross(vec2);

Coefficient-wise & Array operators

Coefficient-wise operators for matrices and vectors:

Matrix API *Via Array conversions
mat1.cwiseMin(mat2)
mat1.cwiseMax(mat2)
mat1.cwiseAbs2()
mat1.cwiseAbs()
mat1.cwiseSqrt()
mat1.cwiseProduct(mat2)
mat1.cwiseQuotient(mat2)
mat1.array().min(mat2.array())
mat1.array().max(mat2.array())
mat1.array().abs2()
mat1.array().abs()
mat1.array().sqrt()
mat1.array() * mat2.array()
mat1.array() / mat2.array()

Array operators:*

 

Arithmetic operators
array1 * array2     array1 / array2     array1 *= array2    array1 /= array2
array1 + scalar     array1 - scalar     array1 += scalar    array1 -= scalar
Comparisons　　　　　　　　　　
array1 < array2     array1 > array2     array1 < scalar     array1 > scalar
array1 <= array2    array1 >= array2    array1 <= scalar    array1 >= scalar
array1 == array2    array1 != array2    array1 == scalar    array1 != scalar
Trigo, power, and 
misc functions 
and the STL variants
array1.min(array2)           
array1.max(array2)           
array1.abs2()
array1.abs()                  abs(array1)
array1.sqrt()                 sqrt(array1)
array1.log()                  log(array1)
array1.exp()                  exp(array1)
array1.pow(exponent)          pow(array1,exponent)
array1.square()
array1.cube()
array1.inverse()
array1.sin()                  sin(array1)
array1.cos()                  cos(array1)
array1.tan()                  tan(array1)
array1.asin()                 asin(array1)
array1.acos()                 acos(array1)

Reductions

Eigen provides several reduction methods such as: minCoeff() , maxCoeff() , sum() , prod() , trace() *, norm()*, squaredNorm() *, all() , and any() . All reduction operations can be done matrix-wise, column-wise or row-wise. Usage example:

      5 3 1
mat = 2 7 8
      9 4 6
mat.minCoeff();
1
mat.colwise().minCoeff();
2 3 1
mat.rowwise().minCoeff();
1
2
4

Typical use cases of all() and any():

//Typical use cases of all() and any():

if((array1 > 0).all()) ...      // if all coefficients of array1 are greater than 0 ...
if((array1 < array2).any()) ... // if there exist a pair i,j such that array1(i,j) < array2(i,j) ...

 

Sub-matrices

Read-write access to a column or a row of a matrix (or array):

mat1.row(i) = mat2.col(j);
mat1.col(j1).swap(mat1.col(j2));

Read-write access to sub-vectors:

Default versionsOptimized versions when the size 
is known at compile time		 
vec1.head(n)
vec1.head<n>()
the first n coeffs
vec1.tail(n)
vec1.tail<n>()
the last n coeffs
vec1.segment(pos,n)
vec1.segment<n>(pos)
the n coeffs in the 
range [pos : pos + n - 1]

 

Read-write access to sub-matrices:

mat1.block(i,j,rows,cols)
(more)
mat1.block<rows,cols>(i,j)
(more)		the rows x cols sub-matrix 
starting from position (i,j)
mat1.topLeftCorner(rows,cols)
mat1.topRightCorner(rows,cols)
mat1.bottomLeftCorner(rows,cols)
mat1.bottomRightCorner(rows,cols)
mat1.topLeftCorner<rows,cols>()
mat1.topRightCorner<rows,cols>()
mat1.bottomLeftCorner<rows,cols>()
mat1.bottomRightCorner<rows,cols>()
the rows x cols sub-matrix 
taken in one of the four corners
mat1.topRows(rows)
mat1.bottomRows(rows)
mat1.leftCols(cols)
mat1.rightCols(cols)
mat1.topRows<rows>()
mat1.bottomRows<rows>()
mat1.leftCols<cols>()
mat1.rightCols<cols>()
specialized versions of block() 
when the block fit two corners

top

Miscellaneous operations

Reverse

Vectors, rows, and/or columns of a matrix can be reversed (see DenseBase::reverse(), DenseBase::reverseInPlace(),VectorwiseOp::reverse()).

vec.reverse()           mat.colwise().reverse()   mat.rowwise().reverse()
vec.reverseInPlace()

Replicate

Vectors, matrices, rows, and/or columns can be replicated in any direction (see DenseBase::replicate(),VectorwiseOp::replicate())

vec.replicate(times)                                          vec.replicate<Times>
mat.replicate(vertical_times, horizontal_times)               mat.replicate<VerticalTimes, HorizontalTimes>()
mat.colwise().replicate(vertical_times, horizontal_times)     mat.colwise().replicate<VerticalTimes, HorizontalTimes>()
mat.rowwise().replicate(vertical_times, horizontal_times)     mat.rowwise().replicate<VerticalTimes, HorizontalTimes>()

top

Diagonal, Triangular, and Self-adjoint matrices

(matrix world *)

Diagonal matrices

OperationCode
view a vector as a diagonal matrix 
mat1 = vec1.asDiagonal();
Declare a diagonal matrix
DiagonalMatrix<Scalar,SizeAtCompileTime> diag1(size);
diag1.diagonal() = vector;
Access the diagonal and super/sub diagonals of a matrix as a vector (read/write)
vec1 = mat1.diagonal();        mat1.diagonal() = vec1;      // main diagonal
vec1 = mat1.diagonal(+n);      mat1.diagonal(+n) = vec1;    // n-th super diagonal
vec1 = mat1.diagonal(-n);      mat1.diagonal(-n) = vec1;    // n-th sub diagonal
vec1 = mat1.diagonal<1>();     mat1.diagonal<1>() = vec1;   // first super diagonal
vec1 = mat1.diagonal<-2>();    mat1.diagonal<-2>() = vec1;  // second sub diagonal

 

Optimized products and inverse
mat3  = scalar * diag1 * mat1;
mat3 += scalar * mat1 * vec1.asDiagonal();
mat3 = vec1.asDiagonal().inverse() * mat1
mat3 = mat1 * diag1.inverse()

 

Triangular views

TriangularView gives a view on a triangular part of a dense matrix and allows to perform optimized operations on it. The opposite triangular part is never referenced and can be used to store other information.

Note
The .triangularView() template member function requires the  template keyword if it is used on an object of a type that depends on a template parameter; see The template and typename keywords in C++ for details.
OperationCode
Reference to a triangular with optional 
unit or null diagonal (read/write):
m.triangularView<Xxx>()

Xxx = Upper, Lower, StrictlyUpper, StrictlyLower, UnitUpper,UnitLower
Writing to a specific triangular part:
(only the referenced triangular part is evaluated)
m1.triangularView< Eigen::Lower>() = m2 + m3
Conversion to a dense matrix setting the opposite triangular part to zero:
m2 = m1.triangularView< Eigen::UnitUpper>()
Products:
m3 += s1 * m1.adjoint().triangularView< Eigen::UnitUpper>() * m2
m3 -= s1 * m2.conjugate() * m1.adjoint().triangularView< Eigen::Lower>()
Solving linear equations:
$ M_2 := L_1^{-1} M_2 $ 
$ M_3 := {L_1^*}^{-1} M_3 $ 
$ M_4 := M_4 U_1^{-1} $
L1.triangularView< Eigen::UnitLower>().solveInPlace(M2)
L1.triangularView<Eigen:: Lower>().adjoint().solveInPlace(M3)
U1.triangularView<Eigen:: Upper>().solveInPlace< OnTheRight>(M4)

Symmetric/selfadjoint views

Just as for triangular matrix, you can reference any triangular part of a square matrix to see it as a selfadjoint matrix and perform special and optimized operations. Again the opposite triangular part is never referenced and can be used to store other information.

Note
The .selfadjointView() template member function requires the  template keyword if it is used on an object of a type that depends on a template parameter; see The template and typename keywords in C++ for details.
OperationCode
Conversion to a dense matrix:
m2 = m.selfadjointView< Eigen::Lower>();
Product with another general matrix or vector:
m3  = s1 * m1.conjugate().selfadjointView< Eigen::Upper>() * m3;
m3 -= s1 * m3.adjoint() * m1.selfadjointView< Eigen::Lower>();
Rank 1 and rank K update: 
$ upper(M_1) \mathrel{​{+}{=}} s_1 M_2 M_2^* $ 
$ lower(M_1) \mathbin{​{-}{=}} M_2^* M_2 $
M1.selfadjointView< Eigen::Upper>().rankUpdate(M2,s1);
M1.selfadjointView< Eigen::Lower>().rankUpdate(M2.adjoint(),-1);
Rank 2 update: ( $ M \mathrel{​{+}{=}} s u v^* + s v u^* $)
M.selfadjointView< Eigen::Upper>().rankUpdate(u,v,s);
Solving linear equations:
( $ M_2 := M_1^{-1} M_2 $)
// via a standard Cholesky factorization
m2 = m1.selfadjointView< Eigen::Upper>().llt().solve(m2);
// via a Cholesky factorization with pivoting
m2 = m1.selfadjointView< Eigen::Lower>().ldlt().solve(m2);

 

 

更多内容请关注我的博客：http://markma.tk/

转载于:https://www.cnblogs.com/goingupeveryday/p/5699053.html

weixin_34024034
关注
【C/C++开源库】C/C++矩阵运算开源库
qq_41854911的博客
08-20 1万+
文章目录一、C++矩阵运算库 - eigen1.下载及安装1.1Linux安装及配置1.2Windows配置2.测试使用2.1DevC++2.2Clion3.深入学习二、C++矩阵运算库 - Armadillo1.下载及安装1.1Linux安装1.2Windows配置2.测试使用3.深入学习三、C++矩阵运算库 - boost四、C语言矩阵运算库 -1.C语言矩阵库12.C语言矩阵库23.C语言矩阵库34.C语言矩阵库45.C语言矩阵库56.C语言矩阵库67.C语言矩阵库78.C语言矩阵库89.C语言矩阵库
eigen-3.4.0矩阵运算c++库
01-30
eigen-3.4.0矩阵运算c++库
C++矩阵计算-杂记（包含Eigen库的安装）
m0_58235748的博客
05-13 1971
它提供了广泛的功能，包括矩阵操作（例如逆矩阵、特征值分解、奇异值分解）、向量操作（例如内积、外积）、线性方程组求解和特殊矩阵操作（例如对称矩阵求解、三角矩阵求解）。打开Visual Studio项目，右键点击项目名称，选择“属性”，在属性管理器中点击“新建属性表”按钮，输入一个名称作为属性表的名称，并点击“添加”按钮。C++中的重载运算符 (operator overloading) 是指在类中重新定义运算符，使其可以处理用户自定义的类型，实现与内置类型相同的功能。来指定Eigen库的位置，并使用。
C++教程（一）：超详细的C++矩阵操作和运算（附实例代码，与python对比）
最新发布
a8598671的博客
09-14 3841
在之前的章节中，我们详细介绍了python中numpy的矩阵操作。但在自动驾驶开发中，我们一般采用C++进行功能开发，因此C++矩阵运算就是自动驾驶开发工程师不可或缺的能力。在C++中没有直接进行矩阵操作的功能函数，需要采用数组或者vector等容器实现，或者引用第三方库，例如Eigen（一个高效的C++模板库，用于矩阵和向量的线性代数运算）、Armadillo（提供简洁语法和高效的矩阵操作，支持线性代数和统计学运算）、Boost uBLAS（Boost库中的矩阵运算模块）。
Eigen——C++矩阵运算库
weixin_42040046的博客
11-28 1万+
Eigen——C++矩阵运算库Eigen是什么？下载配置使用参考 Eigen是什么？ Eigen是一个基于C++模板的开源库，支持线性代数，矩阵和矢量运算，数值分析及其相关的算法。 下载配置 官网：Eigen官网，下载解压缩可以重命名为eigen3，在项目——属性——C/C++——常规——附加包含目录添加该库位置就好了。 图文详细：vs2013配置Eigen库 使用 注：Eigen使用源代码方式...
C++矩阵运算QT应用之Eigen库
weixin_40356612的博客
04-24 5247
本文主要描述在c++中应用Eigen进行矩阵（向量）的表示、运算，以及Eigen库的下载和配置。
【C C++开源库】C C++矩阵运算开源库_c
2401_84263262的博客
04-12 1293
在条件允许的情况下，可以优先使用eigen矩阵运算库。自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Go语言工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！因此收集整理了一份《2024年Go语言全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
C++矩阵库 Eigen 快速入门
01-21
近需要用 C++ 做一些数值计算，之前一直采用Matlab 混合编程的方式处理矩阵运算，非常麻烦，直到发现了 Eigen 库，简直相见恨晚，好用哭了。 Eigen 是一个基于C++模板的线性代数库，直接将库下载后放在项目目录下，...
eigen 矩阵运算库文档手册
02-13
**Eigen 矩阵运算库文档手册** Eigen 是一个开源的 C++ 库，专门用于高效、简洁地处理线性代数问题，包括向量、矩阵以及更复杂的运算。它被广泛应用于计算机图形学、机器学习、物理模拟等多个领域。Eigen 的设计...
C++ Eigen库的下载配置和使用
03-07
一、Eigen 介绍 二、Eigen 的下载 三、Eigen 的配置 3.1 在 Qt 下配置 ...4.6 矩阵运算 4.6.1 矩阵相乘 4.6.2 矩阵转置 4.6.3 矩阵求逆 4.6.4 求矩阵的特征值和特征向量 4.6.5 矩阵的SVD分解 4.6.6 计算矩阵的伪逆
Windows下强大的C++矩阵运算库
01-27
在Windows操作系统中，进行高效的C++矩阵运算，Engin3是一个值得推荐的库。它以其卓越的性能和易用性超越了知名的OpenCV库在矩阵运算方面的表现。Engin3专注于矩阵和向量操作，为开发者提供了简洁而强大的API，使得...
矩阵计算库matrix（标准C++编写，不使用第三的库）
06-29
矩阵计算库matrix（标准C++编写，不使用第三的库）
C++矩阵运算库
03-12
集成好的C++矩阵运算库，与MATLAB中的矩阵操作具有极大的相似性，功能强大。
C++矩阵运算（较全面）
love_petrel的博客
07-12 9856
C++矩阵运算，面向对象编程，构建C++矩阵运算库实现包括一维向量、二维矩阵以及三维矩阵的常见操作。
常见的C/C++开源数值计算库
罗伯特祥的博客
10-11 2176
常见的C/C++开源数值计算库介绍
ROS下C++控制UR机械臂
weixin_42156097的博客
09-27 6038
描述 ROS系统下，使用moveit和gazebo搭建UR机械臂控制的仿真环境，并使用C++编写一个节点来控制UR机械臂的移动 ROS系统：kinetic UR5机械臂 电脑系统：Ubuntu16.04 截图和运行效果 gazebo的机械臂会先水平，然后依次移动到两个位置 rviz中的机械臂移动和gazebo机械臂一致，但是会有一个透明效果的机械臂，沿着同样路径非常滞后的移动 代码 1. 特殊位置移动（Moveit中默认的位置） #include <moveit/move_group_interfa
C++矩阵运算库Eigen快速上手指南
yantuguiguziPGJ的博客
03-11 883
C++矩阵运算库Eigen快速上手指南
C++矩阵运算库推荐
热门推荐
萧瑟一笑的专栏
10-05 4万+
最近在几个地方都看到有人问C++下用什么矩阵运算库比较好，顺便做了个调查，做一些相关的推荐吧。主要针对稠密矩阵，有时间会再写一个稀疏矩阵的推荐。 Armadillo：C++下的Matlab替代品 地址：http://arma.sourceforge.net/ 许可证：MPL 2.0 目前使用比较广的C++矩阵运算库之一，是在C++下使用Matlab方式操作矩阵很好的
C++中Eigen库的安装与矩阵运算实战指南
资源摘要信息:"C++ Eigen库的下载配置和使用" 一、Eigen 介绍 Eigen是一个高级的C++库，用于线性代数、矩阵和向量运算，数值解算以及相关的数学运算。它具有表达式模板和延迟计算的特性，可以在编译时优化性能，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值