[G+smo]C++开源矩阵计算工具——Eigen的简单用法

Eigen教程:1 Eigen简介和矩阵常见操作 文章目录矩阵1. 矩阵类型2. 数据存储3. 动态矩阵和静态矩阵4. 矩阵元素的访问5. 设置矩阵的元素6. 重置矩阵大小7. 矩阵和向量的算术运算参考  Eigen是可以用来进行线性代数、矩阵、向量操作等运算的C++库,它里面包含了很多算法。它的License是MPL2。它支持多平台。  Eigen采用源码的方式提供给用户使用,在使用时只需要包含Eigen的头文件即可进行使用。之所以采用这种方式,是因为Eigen采用模板方式实现,由于模板函数不支持分离编译,所以只能提供源码而不是动态库的方式供用户使用。 阅读详情

http://blog.youkuaiyun.com/houjixin/article/details/8490941

Eigen非常方便矩阵操作,当然它的功能不止如此,由于本人只用到了它的矩阵相关操作,所以这里只给出了它的一些矩阵相关的简单用法,以方便快速入门。矩阵操作在算法研究过程中,非常重要,例如在图像处理中二维高斯拟合求取光斑中心时使用Eigen提供的矩阵算法,差不多十来行代码即可实现,具体可见:http://blog.youkuaiyun.com/hjx_1000/article/details/8490653

Eigen的下载与安装,可参考下面两个博客:

http://blog.youkuaiyun.com/hjx_1000/article/details/8477522

或者:http://blog.youkuaiyun.com/abcjennifer/article/details/7781936;

Eigen帮助文档的地址:http://eigen.tuxfamily.org/dox/pages.html,本文中很多例子也是直接摘自这些帮助文档,

另外关于Eigen的论坛可以访问http://forum.kde.org/viewforum.php?f=74

Eigen用源码的方式提供给用户使用,在使用时只需要包含Eigen的头文件即可进行使用。

之所以采用这种方式,是因为Eigen采用模板方式实现,由于模板函数不支持分离编译,所以只能提供源码而不是动态库的方式供用户使用,不过这也也更方面用户使用和研究。关于模板的不支持分离编译的更多内容,请参考:http://blog.youkuaiyun.com/hjx_1000/article/details/8093701


1、  矩阵的定义

Eigen中关于矩阵类的模板函数中,共有6个模板参数,但是目前常用的只有前三个,如下所示:

[cpp]  view plain copy
  1.  template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>  
  2.  struct traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >  
  3. .......  
其前三个参数分别表示矩阵元素的类型,行数和列数。
矩阵定义时可以使用Dynamic来表示矩阵的行列数为未知,例如:
typedef Matrix<double,Dynamic, Dynamic> MatrixXd;
在Eigen中也提供了很多常见的简化定义形式,例如:
typedef Matrix< double , 3 , 1> Vector3d

注意:

(1)Eigen中无论是矩阵还是数组、向量,无论是静态矩阵还是动态矩阵都提供默认构造函数,也就是你定义这些数据结构时都可以不用提供任何参数,其大小均由运行时来确定。

(2)矩阵的构造函数中只提供行列数、元素类型的构造参数,而不提供元素值的构造,对于比较小的、固定长度的向量提供初始化元素的定义,例如:

[cpp]  view plain copy
  1. Vector2d a(5.0, 6.0);  
  2. Vector3d b(5.0, 6.0, 7.0);  
  3. Vector4d c(5.0, 6.0, 7.0, 8.0);  

2、动态矩阵和静态矩阵

动态矩阵是指其大小在运行时确定,静态矩阵是指其大小在编译时确定,在Eigen中并未这样称呼矩阵。具体可见如下两段代码:

代码段1:

[cpp]  view plain copy
  1. #include <iostream>  
  2. #include <Eigen/Dense>  
  3. using namespace Eigen;  
  4. using namespace std;  
  5. int main()  
  6. {  
  7. MatrixXd m = MatrixXd::Random(3,3);  
  8. m = (m + MatrixXd::Constant(3,3,1.2)) * 50;  
  9. cout << "m =" << endl << m << endl;  
  10. VectorXd v(3);  
  11. v << 1, 2, 3;  
  12. cout << "m * v =" << endl << m * v << endl;  
  13. }  

代码段2:

[cpp]  view plain copy
  1. #include <iostream>  
  2. #include <Eigen/Dense>  
  3. using namespace Eigen;  
  4. using namespace std;  
  5. int main()  
  6. {  
  7. Matrix3d m = Matrix3d::Random();  
  8. m = (m + Matrix3d::Constant(1.2)) * 50;  
  9. cout << "m =" << endl << m << endl;  
  10. Vector3d v(1,2,3);  
  11. cout << "m * v =" << endl << m * v << endl;  
  12. }  
说明:

1)代码段1中MatrixXd表示任意大小的元素类型为double的矩阵变量,其大小只有在运行时被赋值之后才能知道; MatrixXd::Random(3,3)表示产生一个元素类型为double的3*3的临时矩阵对象。

 2) 代码段2中Matrix3d表示元素类型为double大小为3*3的矩阵变量,其大小在编译时就知道;

3)上例中向量的定义也是类似,不过这里的向量时列优先,在Eigen中行优先的矩阵会在其名字中包含有row,否则就是列优先。

4)向量只是一个特殊的矩阵,其一个维度为1而已,如:typedef Matrix< double , 3 , 1> Vector3d

3、矩阵元素的访问

在矩阵的访问中,行索引总是作为第一个参数,需注意Eigen中遵循大家的习惯让矩阵、数组、向量的下标都是从0开始。矩阵元素的访问可以通过()操作符完成,例如m(2,3)即是获取矩阵m的第2行第3列元素(注意行列数从0开始)。可参看如下代码:

[cpp]  view plain copy
  1. #include <iostream>  
  2. #include <Eigen/Dense>  
  3. using namespace Eigen;  
  4. int main()  
  5. {  
  6. MatrixXd m(2,2);  
  7. m(0,0) = 3;  
  8. m(1,0) = 2.5;  
  9. m(0,1) = -1;  
  10. m(1,1) = m(1,0) + m(0,1);  
  11. std::cout << "Here is the matrix m:\n" << m << std::endl;  
  12. VectorXd v(2);  
  13. v(0) = 4;  
  14. v(1) = v(0) - 1;  
  15. std::cout << "Here is the vector v:\n" << v << std::endl;  
  16. }  
其输出结果为:

Here is the matrix m:
  3  -1
2.5 1.5
Here is the vector v:
4
3

针对向量还提供[]操作符,注意矩阵则不可如此使用,原因为:在C++中m[i, j]中逗号表达式 “i, j”的值始终都是“j”的值,即m[i, j]对于C++来讲就是m[j];

4、设置矩阵的元素

在Eigen中重载了"<<"操作符,通过该操作符即可以一个一个元素的进行赋值,也可以一块一块的赋值。另外也可以使用下标进行复制,例如下面两段代码:

代码段1

[cpp]  view plain copy
  1. Matrix3f m;  
  2. m << 1, 2, 3,  
  3. 4, 5, 6,  
  4. 7, 8, 9;  
  5. std::cout << m;  
输出结果为:

1 2 3
4 5 6
7 8 9
代码段二(使用下标进行复制)
[cpp]  view plain copy
  1. VectorXf m_Vector_A;  
  2. MatrixXf m_matrix_B;  
  3. int m_iN =-1;  
  4.   
  5. bool InitData(int pSrc[100][100], int iWidth, int iHeight)  
  6. {  
  7.     if (NULL == pSrc || iWidth <=0 || iHeight <= 0)  
  8.         return false;  
  9.     m_iN = iWidth*iHeight;  
  10.     VectorXf tmp_A(m_iN);  
  11.     MatrixXf tmp_B(m_iN, 5);  
  12.     int i =0, j=0, iPos =0;  
  13.     while(i<iWidth)  
  14.     {  
  15.          j=0;  
  16.         while(j<iHeight)  
  17.         {  
  18.             tmp_A(iPos) = pSrc[i][j] * log((float)pSrc[i][j]);  
  19.   
  20.             tmp_B(iPos,0) = pSrc[i][j] ;  
  21.             tmp_B(iPos,1) = pSrc[i][j] * i;  
  22.             tmp_B(iPos,2) = pSrc[i][j] * j;  
  23.             tmp_B(iPos,3) = pSrc[i][j] * i * i;  
  24.             tmp_B(iPos,4) = pSrc[i][j] * j * j;  
  25.             ++iPos;  
  26.             ++j;  
  27.         }  
  28.         ++i;  
  29.     }  
  30.     m_Vector_A = tmp_A;  
  31.     m_matrix_B = tmp_B;  
  32. }  

5、重置矩阵大小
当前矩阵的行数、列数、大小可以通过rows(),cols()和size()来获取,对于动态矩阵可以通过resize()函数来动态修改矩阵的大小.
需注意:
(1) 固定大小的矩阵是不能使用resize()来修改矩阵的大小;
(2) resize()函数会析构掉原来的数据,因此调用resize()函数之后将不能保证元素的值不改变。
(3) 使用“=”操作符操作动态矩阵时,如果左右边的矩阵大小不等,则左边的动态矩阵的大小会被修改为右边的大小。例如下面的代码段:
[cpp]  view plain copy
  1. MatrixXf a(2,2);  
  2. std::cout << "a is of size " << a.rows() << "x" << a.cols() << std::endl;  
  3. MatrixXf b(3,3);  
  4. a = b;  
  5. std::cout << "a is now of size " << a.rows() << "x" << a.cols() << std::endl;  
输出结果为:
a is of size 2x2
a is now of size 3x3

6、如何选择动态矩阵和静态矩阵?
Eigen对于这问题的答案是:对于小矩阵(一般大小小于16)的使用固定大小的静态矩阵,它可以带来比较高的效率,对于大矩阵(一般大小大于32)建议使用动态矩阵。

还需特别注意的是:如果特别大的矩阵使用了固定大小的静态矩阵则可能造成栈溢出的问题


本文主要是Eigen中矩阵和向量的算术运算,在Eigen中的这些算术运算重载了C++的+,-,*,所以使用起来非常方便。

1、矩阵的运算

Eigen提供+、-、一元操作符“-”、+=、-=,例如:

二元操作符+/-表示两矩阵相加(矩阵中对应元素相加/减,返回一个临时矩阵): B+C 或 B-C;

一元操作符-表示对矩阵取负(矩阵中对应元素取负,返回一个临时矩阵): -C; 

组合操作法+=或者-=表示(对应每隔元素都做相应操作):A += B 或者 A-=B

代码段1为矩阵的加减操作,代码如下:

[cpp]  view plain copy
  1. #include <iostream>  
  2. #include <Eigen/Dense>  
  3. using namespace Eigen;  
  4. int main()  
  5. {  
  6. Matrix2d a;  
  7. a << 1, 2,  
  8. 3, 4;  
  9. MatrixXd b(2,2);  
  10. b << 2, 3,  
  11. 1, 4;  
  12. std::cout << "a + b =\n" << a + b << std::endl;  
  13. std::cout << "a - b =\n" << a - b << std::endl;  
  14. std::cout << "Doing a += b;" << std::endl;  
  15. a += b;  
  16. std::cout << "Now a =\n" << a << std::endl;  
  17. Vector3d v(1,2,3);  
  18. Vector3d w(1,0,0);  
  19. std::cout << "-v + w - v =\n" << -v + w - v << std::endl;  
  20. }  
输出结果为:

a + b =
3 5
4 8
a - b =
-1 -1
 2  0
Doing a += b;
Now a =
3 5
4 8
-v + w - v =
-1
-4
-6

另外,矩阵还提供与标量(单一个数字)的乘除操作,表示每个元素都与该标量进行乘除操作。例如:

二元操作符*在:A*a中表示矩阵A中的每隔元素都与数字a相乘,结果放在一个临时矩阵中,矩阵的值不会改变。

对于a*A、A/a、A*=a、A /=a也是一样,例如下面的代码:

[cpp]  view plain copy
  1. #include <iostream>  
  2. #include <Eigen/Dense>  
  3. using namespace Eigen;  
  4. int main()  
  5. {  
  6. Matrix2d a;  
  7. a << 1, 2,  
  8. 3, 4;  
  9. Vector3d v(1,2,3);  
  10. std::cout << "a * 2.5 =\n" << a * 2.5 << std::endl;  
  11. std::cout << "0.1 * v =\n" << 0.1 * v << std::endl;  
  12. std::cout << "Doing v *= 2;" << std::endl;  
  13. v *= 2;  
  14. std::cout << "Now v =\n" << v << std::endl;  
  15. }  
输出结果为:

a * 2.5 =
2.5  5
7.5 10
0.1 * v =
0.1
0.2
0.3
Doing v *= 2;
Now v =
2
4
6

需要注意:

在Eigen中,算术操作例如 “操作符+”并不会自己执行计算操作,他们只是返回一个“算术表达式对象”,而实际的计算则会延迟到后面的赋值时才进行。这些不影响你的使用,它只是为了方便Eigen的优化。

2、求矩阵的转秩、共轭矩阵、伴随矩阵。

可以通过 成员函数transpose(), conjugate(),和 adjoint()来完成,注意这些函数返回操作后的结果,而不会对原矩阵的元素进行直接操作,如果要让原矩阵的进行转换,则需要使用响应的InPlace函数,例如:transposeInPlace() 、 adjointInPlace() 之类。

例如下面的代码所示:

[cpp]  view plain copy
  1. MatrixXcf a = MatrixXcf::Random(2,2);  
  2. cout << "Here is the matrix a\n" << a << endl;  
  3. cout << "Here is the matrix a^T\n" << a.transpose() << endl;  
  4. cout << "Here is the conjugate of a\n" << a.conjugate() << endl;  
  5. cout << "Here is the matrix a^*\n" << a.adjoint() << endl;  
输出结果为:
Here is the matrix a
 (-0.211,0.68) (-0.605,0.823)
 (0.597,0.566)  (0.536,-0.33)
Here is the matrix a^T
(-0.211,0.68) (0.597,0.566)
(-0.605,0.823) (0.536,-0.33)
Here is the conjugate of a
 (-0.211,-0.68) (-0.605,-0.823)
 (0.597,-0.566)    (0.536,0.33)
Here is the matrix a^*
(-0.211,-0.68) (0.597,-0.566)
(-0.605,-0.823)   (0.536,0.33)


3、矩阵相乘、矩阵向量相乘

矩阵的相乘,矩阵与向量的相乘也是使用操作符*,共有*和*=两种操作符,其用法可以参考如下代码:

[cpp]  view plain copy
  1. #include <iostream>  
  2. #include <Eigen/Dense>  
  3. using namespace Eigen;  
  4. int main()  
  5. {  
  6. Matrix2d mat;  
  7. mat << 1, 2,  
  8. 3, 4;  
  9. Vector2d u(-1,1), v(2,0);  
  10. std::cout << "Here is mat*mat:\n" << mat*mat << std::endl;  
  11. std::cout << "Here is mat*u:\n" << mat*u << std::endl;  
  12. std::cout << "Here is u^T*mat:\n" << u.transpose()*mat << std::endl;  
  13. std::cout << "Here is u^T*v:\n" << u.transpose()*v << std::endl;  
  14. std::cout << "Here is u*v^T:\n" << u*v.transpose() << std::endl;  
  15. std::cout << "Let's multiply mat by itself" << std::endl;  
  16. mat = mat*mat;  
  17. std::cout << "Now mat is mat:\n" << mat << std::endl;  
  18. }  
输出结果为:
Here is mat*mat:
 7 10
15 22
Here is mat*u:
1
1
Here is u^T*mat:
2 2
Here is u^T*v:
-2
Here is u*v^T:
-2 -0
 2  0
Let's multiply mat by itself
Now mat is mat:
 7 10
15 22


本节主要涉及Eigen的块操作以及QR分解,Eigen的QR分解非常绕人,搞了很久才搞明白是怎么回事,最后是一个使用Eigen的矩阵操作完成二维高斯拟合求取光点的代码例子,关于二维高斯拟合求取光点的详细内容可参考:http://blog.youkuaiyun.com/hjx_1000/article/details/8490653

1、矩阵的块操作

        1)矩阵的块操作有两种使用方法,其定义形式为:

[cpp]  view plain copy
  1. matrix.block(i,j,p,q);      (1)  
  2.   
  3. matrix.block<p,q>(i,j);    (2)  
定义(1)表示返回从矩阵的(i, j)开始,每行取p个元素,每列取q个元素所组成的临时新矩阵对象,原矩阵的元素不变。

定义(2)中block(p, q)可理解为一个p行q列的子矩阵,该定义表示从原矩阵中第(i, j)开始,获取一个p行q列的子矩阵,返回该子矩阵组成的临时 矩阵对象,原矩阵的元素不变。

详细使用情况,可参考下面的代码段:

[cpp]  view plain copy
  1. #include <Eigen/Dense>  
  2. #include <iostream>  
  3. using namespace std;  
  4. int main()  
  5. {  
  6. Eigen::MatrixXf m(4,4);  
  7. m << 1, 2, 3, 4,  
  8. 5, 6, 7, 8,  
  9. 9,10,11,12,  
  10. 13,14,15,16;  
  11. cout << "Block in the middle" << endl;  
  12. cout << m.block<2,2>(1,1) << endl << endl;  
  13. for (int i = 1; i <= 3; ++i)  
  14. {  
  15. cout << "Block of size " << i << "x" << i << endl;  
  16. cout << m.block(0,0,i,i) << endl << endl;  
  17. }  
  18. }  

输出的结果为:

Block in the middle
 6  7
10 11

Block of size 1x1
1

Block of size 2x2
1 2
5 6

Block of size 3x3
 1  2  3
 5  6  7
 9 10 11
通过上述方式获取的子矩阵即可以作为左值也可以作为右值,也就是即可以用这个子矩阵给其他矩阵赋值,也可以给这个子矩阵对象赋值。

2)矩阵也提供了获取其指定行/列的函数,其实获取某行/列也是一种特殊的获取子块。可以通过 .col()和 .row()来完成获取指定列/行的操作,参数为列/行的索引。
注意:
(1)需与获取矩阵的行数/列数的函数( rows(), cols() )的进行区别,不要弄混淆。
(2)函数参数为响应行/列的索引,需注意矩阵的行列均以0开始。
下面的代码段用于演示获取矩阵的指定行列:

[cpp]  view plain copy
  1. #include <Eigen/Dense>  
  2. #include <iostream>  
  3. using namespace std;  
  4. int main()  
  5. {  
  6. Eigen::MatrixXf m(3,3);  
  7. m << 1,2,3,  
  8. 4,5,6,  
  9. 7,8,9;  
  10. cout << "Here is the matrix m:" << endl << m << endl;  
  11. cout << "2nd Row: " << m.row(1) << endl;  
  12. m.col(2) += 3 * m.col(0);  
  13. cout << "After adding 3 times the first column into the third column, the matrix m is:\n";  
  14. cout << m << endl;  
  15. }  
输出结果为:

Here is the matrix m:
1 2 3
4 5 6
7 8 9
2nd Row: 4 5 6
After adding 3 times the first column into the third column, the matrix m is:
 1  2  6
 4  5 18
 7  8 30
3)向量的块操作,其实向量只是一个特殊的矩阵,但是Eigen也为它单独提供了一些简化的块操作,如下三种形式:
      获取向量的前n个元素:vector.head(n); 
      获取向量尾部的n个元素:vector.tail(n);
      获取从向量的第i个元素开始的n个元素:vector.segment(i,n);
      其用法可参考如下代码段:

[cpp]  view plain copy
  1. #include <Eigen/Dense>  
  2. #include <iostream>  
  3. using namespace std;  
  4. int main()  
  5. {  
  6. Eigen::ArrayXf v(6);  
  7. v << 1, 2, 3, 4, 5, 6;  
  8. cout << "v.head(3) =" << endl << v.head(3) << endl << endl;  
  9. cout << "v.tail<3>() = " << endl << v.tail<3>() << endl << endl;  
  10. v.segment(1,4) *= 2;  
  11. cout << "after 'v.segment(1,4) *= 2', v =" << endl << v << endl;  
  12. }  
输出结果为:

v.head(3) =
1
2
3

v.tail<3>() = 
4
5
6

after 'v.segment(1,4) *= 2', v =
1
4
6
8
10
6

2、QR分解
        Eigen的QR分解非常绕人,它总共提供了下面这些矩阵的分解方式:

Decomposition Method Requirements on the matrix Speed Accuracy
PartialPivLU partialPivLu() Invertible ++ +
FullPivLU fullPivLu() None - +++
HouseholderQR householderQr() None ++ +
ColPivHouseholderQR colPivHouseholderQr() None + ++
FullPivHouseholderQR fullPivHouseholderQr() None - +++
LLT llt() Positive definite +++ +
LDLT ldlt() Positive or negative semidefinite +++ ++
由于我只用到了QR分解,而且Eigen的QR分解开始使用时确实不容易入手,因此这里只提供了householderQR的分解方式的演示代码:

[cpp]  view plain copy
  1. void QR2()  
  2. {  
  3.     Matrix3d A;  
  4.     A<<1,1,1,  
  5.         2,-1,-1,  
  6.         2,-4,5;  
  7.   
  8.     HouseholderQR<Matrix3d> qr;  
  9.     qr.compute(A);  
  10.     MatrixXd R = qr.matrixQR().triangularView<Upper>();  
  11.     MatrixXd Q =  qr.householderQ();  
  12.     std::cout << "QR2(): HouseholderQR---------------------------------------------"<< std::endl;  
  13.     std::cout << "A "<< std::endl <<A << std::endl << std::endl;  
  14.     std::cout <<"qr.matrixQR()"<< std::endl << qr.matrixQR() << std::endl << std::endl;  
  15.     std::cout << "R"<< std::endl <<R << std::endl << std::endl;  
  16.     std::cout << "Q "<< std::endl <<Q << std::endl << std::endl;  
  17.     std::cout <<"Q*R" << std::endl <<Q*R << std::endl << std::endl;  
  18. }  
输出结果为:



3、一个矩阵使用的例子:用矩阵操作完成二维高斯拟合,并求取光斑中心

下面的代码段是一个使用Eigen的矩阵操作完成二维高斯拟合求取光点的代码例子,关于二维高斯拟合求取光点的详细内容可参考:http://blog.youkuaiyun.com/hjx_1000/article/details/8490653

[cpp]  view plain copy
  1. bool GetCentrePoint(float& x0,float& y0)  
  2. {  
  3.     if (m_iN<=0)  
  4.         return false;  
  5.     //QR分解  
  6.     HouseholderQR<MatrixXf> qr;  
  7.     qr.compute(m_matrix_B);  
  8.     MatrixXf R = qr.matrixQR().triangularView<Upper>();  
  9.     MatrixXf Q =  qr.householderQ();  
  10.   
  11.     //块操作,获取向量或矩阵的局部  
  12.     VectorXf S;  
  13.     S = (Q.transpose()* m_Vector_A).head(5);  
  14.     MatrixXf R1;  
  15.     R1 = R.block(0,0,5,5);  
  16.   
  17.     VectorXf C;  
  18.     C = R1.inverse() * S;  
  19.   
  20.     x0 = -0.5 * C[1] / C[3];  
  21.     y0 = -0.5 * C[2] / C[4];  
  22.   
  23.     return true;  
  24. }  



[矩阵的QR分解系列二] 吉文斯(Givens)变换 吉文斯变换简介 之前介绍的矩阵的三角分解系列介绍了利用矩阵初等变换解决了矩阵三角化问题以及具体的三角分解。但是以初等变换工具的三角分解方法并不能消除病态线性方程组不稳定问题,而且有时候对于可逆矩阵有可能也不存在三角分解。所以后面为了解决这里问题,发展出来了以正交(酉)变换的矩阵的QR(正交三角)分解,矩阵的正交三角分解是一种对任何可逆矩阵均存在理想分解。进行QR分解需要用到施密特(Schmidt)正交规范化,吉文斯(Givens)变换和豪斯霍尔德(Householder)变换等。这里矩阵的QR分解系列教程主 阅读详情

相关推荐

[矩阵的QR分解系列三] 豪斯霍尔德(Householder)变换

豪斯霍尔德变换简介 之前介绍的矩阵的三角分解系列介绍了利用矩阵初等变换解决了矩阵三角化问题以及具体的三角分解。但是以初等变换工具的三角分解方法并不能消除病态线性方程组不稳定问题,而且有时候对于可逆矩阵有可能也不存在三角分解。所以后面为了解决这里问题,发展出来了以正交(酉)变换的矩阵的QR(正交三角)分解,矩阵的正交三角分解是一种对任何可逆矩阵均存在理想分解。进行QR分解需要用到施密特(Schmidt)正交规范化,吉文斯(Givens)变换和豪斯霍尔德(Householder)变换等。这里矩阵的QR分解系列教

honyniu的专栏 4万+

Eigen: C++开源矩阵计算工具——Eigen的简单用法

Eigen非常方便矩阵操作,当然它的功能不止如此,由于本人只用到了它的矩阵相关操作,所以这里只给出了它的一些矩阵相关的简单用法,以方便快速入门。矩阵操作在算法研究过程中,非常重要,例如在图像处理中二维高斯拟合求取光斑中心时使用Eigen提供的矩阵算法,差不多十来行代码即可实现,具体可见:http://blog.youkuaiyun.com/hjx_1000/article/details/8490653Eig

Augusdi的专栏 14万+

从零实现SVM:C++手写SMO算法与核函数实战解析

支持向量机(SVM)是一种经典的监督学习算法,其核心思想是通过寻找一个最优超平面来最大化不同类别数据之间的间隔,从而实现分类。其原理基于结构风险最小化,通过引入拉格朗日乘子法和对偶问题,将原始优化问题转化为更易求解的形式。SVM的技术价值在于其出色的泛化能力和对高维数据的处理能力,尤其通过核技巧,可以高效地解决非线性分类问题。在应用场景上,SVM广泛应用于文本分类、图像识别和生物信息学等领域。本文聚焦于使用C++从零实现SVM,详细剖析了序列最小优化(SMO)算法的迭代过程与核函数的设计,为深入理解机器学习

weixin_33695450的博客 629

Eigen库QR分解

在计算光斑中心位置的研究中,选择了高斯中心法,而该方法求解过程中需要用到QR分解。所以在这里记录分享Eigen库的QR分解使用方法。

HPC_ZY 5107

等几何分析编程记录 --- 未完待续

等几何分析编程记录

mw_1422102031的博客 1639

【信息科学与工程学】【研发体系】第十篇 半导体电路设计 126 光学光刻、计算光刻 第一部分

用于全芯片修正的快速三维掩模近似模型(边界层模型、薄掩模近似改进)。:用于模型校准的测试图形设计(包含各种宽度、间距、方向的图形);扫描电镜、光学散射仪等量测数据的处理与模型拟合;模型误差的分解与追踪;:反演光刻技术的数学框架与求解算法(梯度法、像素翻转、水平集法);基于模型的OPC中边缘放置误差片段的智能移动策略;热点检测与分类的深度学习模型;:交替型、衰减型、无铬型等不同类型PSM的原理、制造与应用;光刻胶模型与显影模型的建立与校准。扫描电镜、散射仪等量测数据的处理与模型拟合;:厚掩模的电磁场仿真;

weixin_49199313的博客 1050

应用Eigen 的项目

是一个开放的计算环境,用于工程和科学应用,使用现代C / C++库(Boost,Eigen,FFTW等)和其他最先进的数值库。是一个用于对统计算法进行编程的系统,例如来自R.NIMBLE的马尔可夫链蒙特卡洛,包括一个使用Eigen的R到C++子集的编译器。提供了简单的机制,使任意算法能够在流形上运行。是一个用C++编写的跨平台框架,它为复杂的机器人应用程序的开发提供了一个中间件,它由分布式软件模块组成。,一个 C 和 C++ 依赖项管理器,#includes 最流行和最有用的 C/C++ 库和框架。

weixin_40948750的博客 1114

Eigen HouseholderQR分解

#include <vector> #include <algorithm> #include <iostream> #include <Eigen/Dense> using namespace std; using namespace Eigen; int main() { Matrix3d A; A << 1, 1, 1, ...

qq_35752161的博客 4205

用C#完成最小二乘法拟合平面方程,再计算点到面的距离

【代码】用C#完成最小二乘法拟合平面方程,再计算点到面的距离。

MechMaster 649

企业数字化转型的 4A 架构指南:从概念解读到 TOGAF 阶段对应

4A企业架构是中国数字化转型实践中总结的简化框架,包含业务、应用、数据和技术四个架构层。它自上而下形成业务驱动应用的指导关系,自下而上构建技术支撑数据的实现路径,与国际标准TOGAF核心内容高度对应。该模型通过统一语言、战略对齐和系统梳理,有效连接业务需求与IT实施,已成为企业架构规划的实用工具。其分层结构清晰展示了从业务目标到技术落地的完整推导链,特别适合中国企业的数字化转型场景。

友莘居士的博客 2179

Householder变换进行QR分解及其代码实现(C++)

初等变换工具如三角分解(LU分解)可以用于求解线性方程组,但确实存在一些限制。例如,对于病态(ill-conditioned)的线性方程组,LU分解可能会导致数值不稳定的结果。此外,对于不可逆矩阵,LU分解也不适用。为了克服这些问题,引入了QR分解,其中矩阵分解为正交矩阵Q和上三角矩阵R。QR分解对于任何可逆矩阵都是适用的,并且可以提供数值稳定的解决方案。QR分解的实现可以借助施密特正交规范化、吉文斯变换和豪斯霍尔德变换等技术来完成。

qq_18935435的博客 2507

新手避坑指南:在MacBook上为PyTorch正确配置MPS环境,跑通第一个YOLOv8训练

本文详细指导新手如何在MacBook上为PyTorch正确配置MPS环境,并成功运行YOLOv8训练。从环境准备、PyTorch安装到YOLOv8配置和性能调优,提供全面的避坑指南和实用技巧,帮助开发者充分利用Mac的GPU加速能力。

weixin_29100399的博客 231

Eigen 教程 进阶篇(二)

eigen3 进阶教程,QR 分解,SVD 分解

jucat的博客 1471

Anasys Workbanch实战解析:齿轮接触强度有限元分析全流程

本文详细解析了在Anasys Workbanch中进行齿轮接触强度有限元分析的全流程。从模型简化、材料赋予、接触对设置,到网格划分艺术、非线性接触求解调试,再到结果后处理与工程解读,提供了避开常见陷阱的实战经验,旨在帮助工程师精准评估齿轮强度与疲劳寿命。

weixin_29209805的博客 347

基于RK3588与昇腾310B的异构K8s集群部署与NPU统一调度实战

本文介绍了基于RK3588与昇腾310B的异构K8s集群部署方案,通过HAMi+Volcano实现NPU统一调度。方案包含硬件配置、操作系统准备(银河麒麟/欧拉)、容器运行时部署及K8s集群搭建等关键步骤,支持多厂商NPU设备的统一抽象和精细化切分,为边缘AI计算提供高效资源管理能力。

huanghm88的专栏 281

[Eigen中文文档] 矩阵与向量运算

Eigen通过重载常见的 C++ 算术运算符(如)或通过特殊方法(如dot()cross()等)提供矩阵/向量算术运算。对于Matrix类(矩阵和向量),重载运算符仅支持线性代数运算。例如,代表矩阵乘法,向量与标量的加法是不合法的。如果想执行各种数组运算,而不是线性代数,请参阅数组类与元素操作。

淋曦的进击手记 2630

03、ZigBee 开发教程之进阶篇—CC2530无线传输质量检测

文章目录1、Packet Error Rate Tester(包错误率测试)理论分析1.1、工作流程1.2、流程图1.3、丢包、PER、RSSI计算方法2、实验详解2.1、实验目的2.2、实验设备2.3、实验现象2.4、源码分析2.5、实验步骤及现象 1、Packet Error Rate Tester(包错误率测试)理论分析 1.1、工作流程 Packet Error Rate Tester(包错误率测试) 1、启动 板载外设、射频IO、系统时钟、中断等初始化(halBoardInit();); Bas

嵌入式羊圈 1539

eigen householderQr().solve 返回值auto 和Eigen::VectorXf 不同导致结果不同

eigen householderQr().solve auto Eigen::VectorXf 返回值不同导致结果不同

lalafans的博客 767

(建议收藏)2024最新 URL Scheme大全APP跳转界面地址更新中 ios快捷指令快捷方式链接跳转微信小程序必备autojs可用免root (可定制开发和提取URL Scheme 参数提取)

(建议收藏)2024最新 URL Scheme大全APP跳转界面地址更新中 ios快捷指令快捷方式链接跳转微信小程序必备autojs可用免root (可定制开发和提取URL Scheme 参数提取)

代码简单说 Vue、JAVA、PHP、Node.js 熟练运用,接口、架构、性能全搞定。 1万+

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

Python自动化办公,深度优先搜索文件夹并移动全部doc文件(深度优先算法)以及(文件、文件夹的移动、复制、删除、重命名)

Python自动化办公,深度优先搜索文件夹并移动全部doc文件(深度优先算法)以及(文件、文件夹的移动、复制、删除、重命名)

qq_44745905的博客 594

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

Eigen深入剖析Matrix(进阶一)

Eigen是以线性代数和矩阵理论为基础的数值计算库。在Eigen中所有的矩阵和向量都是Matrix模板类的对象,向量只是一种特殊的矩阵,默认向量是列向量。Array类的很多操作与Matrix类似,所以本章中介绍的部分操作也适用于Array。

小怪物爱吹牛的博客 5871

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Window7下使用VS2017编译VTK-9.0.1的64位动态库教程(超详细)(附编译的库包含32位和64位)

前言:是一个开源的免费软件系统,主要用于三维计算机图形学、图像处理和可视化。 今天编译最新版VTK-9.0.1,并整理成编译教程,提供给新入门的朋友们参考; 我使用vs2017编译VTK的64位库,编译32位库的过程和这类似。 可以参照本文进行VTK的库的编译,也可以下载我编译好得(在末尾,包括64位和32位)。 一、源码下载 下载VTK-9.0.1源码 编译工具是cmake,官网进行下载:cmake3.9.12 二、编译过程 1、创建目录F:/Demo/VTK作为编译根目录,将下载的源码解压到根目录,另外

weixin_42962516的博客 1438

opencv矩阵转eigen_OpenCV中的Mat类型与Eigen中的Matrix类型转换

参考链接:https://blog.youkuaiyun.com/chengde6896383/article/details/83448882整体概括了Eigen库中的Matrix类与OpenCV中的Mat类转换过程中的注意事项,尤其是在使用两个不同的第三方依赖库时,头文件的引入顺序很重要,其次就是转换方法。https://blog.youkuaiyun.com/piaoxuezhong/article/details...

weixin_28192383的博客 1217

Kalman滤波器的C++实现

1、原理介绍 kalman滤波在状态估计和多传感器融合等方面应用广泛,典型的应用有无人机的飞行姿态估计,汽车的行驶状态估计,无人驾驶中的激光雷达和其他传感器之间的融合等。至于Kalman滤波的数学推导,比较复杂,需要数学功底比较好,我看了很多次书还是不会推导,放弃了,拿过来用就行了。有点儿拿来主义了。还是的介绍下kalman滤波所涉及的系统微分方程和几个核心公式。kalman滤波分为预测和更新两...

Alexon Xu的博客 2万+

Eigen 简单矩阵运算

矩阵的定义:Eigen::Matrix<数据类型,行数,列数> 矩阵名称 已经提供的矩阵类型: Vector3d 向量名称 实质上是:Eigen::Matrix<double, 3, 1> Matrix3d 矩阵名称 实质上是:Eigen::Matrix<double, 3, 3> 矩阵初始化为零:Eigen::Matrix3d 矩阵名称 = Eig...

gwh1010的博客 3139
上一篇: [G+smo]Eigen常用函数以及注意事项总结
下一篇: 常用RGB颜色表
solidsanke54
博客等级 码龄17年 30粉丝 71原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值