eigen学习日志1

#include <iostream>
#include <Eigen/Eigen>
#include <Eigen/Dense>
#include <Eigen/Core>
using namespace Eigen;
void  MatrixClass(){

    //class Eigen::Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >
    //Matrix 类有6个模板参数，现在我们了解前三个足够。剩下的三个参数都有默认值，后面会探讨，现在不管他。

    //Matrix 的三个强制的模板参数：
    //Matrix<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime>
    //Scalar 就是矩阵元素标量类型。
    //RowsAtCompileTime 和ColsAtCompileTime 分别指代编译时候的行和列值。

    //声明一个2*3的float矩阵   matrix_23就是一个2*3的float类型的矩阵
    Matrix<float,2,3> matrix_23;
    //矩阵逗号初始化，注：使用逗号初始化之前必须先设置矩阵大小！！！
    matrix_23 << 1,2,3,4,5,6;
    //输出矩阵
    std::cout<<"输出matrix_23:"<<std::endl;
    std::cout<<matrix_23<<std::endl;

    //声明一个2*2的float类型矩阵
    Matrix2f m_2f;
    Matrix<float,2,2> m_2f_;
    std::cout<<"Matrix2f m_2f size:"<<m_2f.rows()<<"X"<<m_2f.cols()<<std::endl<<"Matrix<float,2,2> m_2f_ size:"<<m_2f_.rows()<<"X"<<m_2f_.cols()<<std::endl;

    /*
     ***********************************************************分隔符***************************************************
     */

    //在Eigen中，vectors 只是一种特殊形式的矩阵，有一行或者一列。在大多数情况下一列比较多，这样的向量也叫做列向量，也简称向量。其他情况叫做行向量。
    //声明一个3*1的double类型列向量v_c_3d
    Vector3d v_c_3d;
    //vector_3d等同于v_3d 都是一个3*1的double类型列向量
    Matrix<double,3,1> vector_c_3d;
    //向量初始化 和 矩阵初始化类似
    v_c_3d << 1,2,3;
    std::cout<<"v_c_3d"<<std::endl;
    std::cout<<v_c_3d<<std::endl;

    //声明一个1*3的float类型行向量
    RowVector3f v_r_3f;
    v_r_3f<<1,2,3;
    std::cout<<"v_r_3f"<<std::endl;
    std::cout<<v_r_3f<<std::endl;
    //声明一个1*3的float类型行向量vector_r_3f
    Matrix<float,1,3> vector_c_3f;
    vector_c_3f<<1,2,3;
    std::cout<<"vector_c_3f"<<std::endl;
    std::cout<<vector_c_3f<<std::endl;

    //固定大小的向量提供了另一种初始化操作
    //声明并初始化一个vector_c_2d：2*1的double类型列向量
    Vector2d vector_c_2d(2.0,3.1);
    std::cout<<"vector_c_2d"<<std::endl;
    std::cout<<vector_c_2d<<std::endl;

    /*
     ***********************************************************分隔符***************************************************
     */

    //动态矩阵
    //Eigen中除了定义上面固定大小的矩阵外，还有一种动态矩阵，也就是说编译的时候大小未知，在程序运行以后才确定大小。
    /*
     * typedef Matrix<double, Dynamic, Dynamic> MatrixXd;//n行，n列。double类型矩阵。
       typedef Matrix<int, Dynamic, 1> VectorXi;//动态列向量，n行1列
     */
    //声明一个n行m列（行列未知）的float类型动态矩阵，初始化时行列可不同也可相同
    MatrixXf matrixXf;
    //用一个3行2列的零矩阵初始化matrixXf,
    //注意：用矩阵初始化时行列要确定必须是常量
    const int rows=3;
    const int cols=2;
    matrixXf = Matrix<float,rows,cols>::Zero();
    std::cout<<"matrixXf"<<std::endl;
    std::cout<<matrixXf<<std::endl;

    //使用一个3*3的float类型随机矩阵初始化matrix_rand
    MatrixXd matrix_rand = MatrixXd::Random(3,3);// Random生成的随机矩阵，矩阵元素在（-1，1）之间
    std::cout<<"matrix_rand:"<<std::endl;
    std::cout<<matrix_rand<<std::endl;

    //另一种声明和初始化动态矩阵的方式
    //利用（索引号）来赋值给动态矩阵进行初始化，这种情况需要指定动态矩阵行列
    MatrixXd matrix_3_2f(3,2);//声明动态矩阵为3行2列的double类型矩阵，未初始化
    matrix_3_2f(0,0) = 1;
    matrix_3_2f(0,1) = 2;
    matrix_3_2f(1,0) = 1;
    matrix_3_2f(1,1) = 5;
    matrix_3_2f(2,0) = 3;
    matrix_3_2f(2,1) = 1;
    std::cout<<"matrix_3_2f"<<std::endl;
    std::cout<<matrix_3_2f<<std::endl;

    //动态向量的声明
    //声明一个3维的动态向量
    VectorXf v_c_3x(3);
    //初始化
    v_c_3x<<2,4,6;
    std::cout<<"v_c_3x"<<std::endl;
    std::cout<<v_c_3x<<std::endl;

    //动态矩阵和固定尺寸矩阵的选择
    //固定尺寸与动态尺寸
    // 什么时候应该使用固定尺寸（例如Matrix4f），什么时候应该使用动态尺寸（例如MatrixXf）？
    //简单的答案是：在可能的地方使用固定尺寸来显示非常小的尺寸，在需要的地方使用动态尺寸来显示较大的尺寸。
    //对于小尺寸，尤其是对于小于（大约）16的尺寸，使用固定尺寸对性能有极大的好处，因为它使Eigen避免了动态内存分配并展开了循环。
    //在内部，固定大小的本征矩阵只是一个简单的数组，即
    // Matrix4f mymatrix;
    // 真的等于只是在做
    // float[16];
    // 因此这确实具有零运行时间成本。相比之下，动态大小矩阵的数组始终分配在堆上，因此

    // MatrixXf mymatrix（行，列）;
    // 等于做
    // float * mymatrix = new [行*列];
    // 除此之外，MatrixXf对象还将其行数和列数存储为成员变量。
    // 当然，使用固定大小的限制是，只有当您在编译时知道大小时，才有可能这样做。
    //同样，对于足够大的尺寸（例如，对于大于（大约）32的尺寸），使用固定尺寸的性能优势变得可以忽略不计。
    //更糟糕的是，尝试使用函数内部的固定大小创建非常大的矩阵可能会导致堆栈溢出，因为Eigen会尝试自动将数组分配为局部变量，而这通常是在堆栈上完成的。
    //最后，视情况而定，当使用动态尺寸时，Eigen还可尝试进行矢量化（使用SIMD指令），请参见参考矢量化。


    /*
     ***********************************************************分隔符***************************************************
     */

    //访问矩阵元素
    //矩阵元素的访问用（i,j）的形式，下标从0开始

    //访问matrix_23的第一行第二列元素
    std::cout<<"matrix_23的第一行第二列元素"<<matrix_23(0,1)<<std::endl;
    //通过(i,j)访问matrix_3_2f的所有元素
    std::cout<<"matrix_3_2f:"<<std::endl;
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 2; ++j) {
            std::cout<<matrix_3_2f(i,j)<<" ";
        }
        std::cout<<std::endl;
    }

    //访问向量的元素
    //向量元素的访问通过（i）或者[i]的形式都可以访问

    //访问向量v_c_3x的第三个元素
    std::cout<<"v_c_3x(2)="<<v_c_3x(2)<<std::endl;
    std::cout<<"v_c_3x[2]="<<v_c_3x[2]<<std::endl;

    //单位矩阵identity()
    //通过identity()方法初始化矩阵为单位矩阵
    Matrix3d m_3D_identity = Matrix<double,3,3>::Identity() ;
    std::cout<<"m_3D_identity="<<std::endl<<m_3D_identity<<std::endl;


}
int main(){
    //Eigen中所有向量和矩阵都是Eigen::Matrix.他是一个模板类。它的前三个参数为数据类型，行，列
    //class Eigen::Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >

    MatrixClass();

    return 0;
}
/*
输出matrix_23:
1 2 3
4 5 6
v_c_3d
1
2
3
v_r_3f
1 2 3
vector_c_3f
1 2 3
vector_c_2d
  2
3.1
matrixXf
0 0
0 0
0 0
matrix_rand:
 0.680375   0.59688 -0.329554
-0.211234  0.823295  0.536459
 0.566198 -0.604897 -0.444451
matrix_3_2f
1 2
1 5
3 1
v_c_3x
2
4
6
matrix_23的第一行第二列元素2
matrix_3_2f:
1 2
1 5
3 1
v_c_3x(2)=6
v_c_3x[2]=6
m_3D_identity=
1 0 0
0 1 0
0 0 1
 */