Eigen学习日志2

#include <iostream>
#include <Eigen/Eigen>
#include <Eigen/Dense>
#include <Eigen/Core>
using namespace Eigen;
//动态矩阵和动态向量的resize操作
void eigen_resize();
//矩阵和向量之间的加减乘运算
void eigen_vector_operator();
//矩阵的转置，逆，迹，行列式
void eigen_special_operator();

void eigen_resize(){

    //矩阵的resize只能对动态矩阵适用！！！！

    //矩阵的当前大小可以通过rows()，cols()和size()获取。
    //这些方法分别返回行数，列数和系数数。调整动态大小矩阵的大小是通过resize()方法完成的。
    // 如果实际矩阵大小不变，则resize()方法为空操作。

    MatrixXd m(3,4);
    std::cout<<"resize前 m.size:"<<m.rows()<<"X"<<m.cols()<<std::endl;
    m.resize(2,7);
    std::cout<<"resize后 m.size:"<<m.rows()<<"X"<<m.cols()<<std::endl;

    //同理动态向量也能resize
    VectorXd v(2);
    std::cout << "before resize The vector v is of size " << v.size() << std::endl;
    v.resize(5);
    std::cout << "after resize The vector v is of size " << v.size() << std::endl;

    //动态矩阵的另一种reszie方式，通过给动态矩阵赋值另一种尺寸的矩阵来改变动态矩阵的尺寸
    //operator= 将矩阵复制到另一个矩阵中的操作。
    //Eigen自动调整左侧矩阵的大小，使其与右侧大小的矩阵大小匹配。例如：
    MatrixXf a(2, 2);
    a<<1,2,3,4;
    std::cout << "a is of size " << a.rows() << "x" << a.cols() << std::endl;
    std::cout<<"a:"<<std::endl<<a<<std::endl;
    MatrixXf b(3, 3);
    b<<3,6,2,6,12,45,7,2,3;
    std::cout<<"b:"<<std::endl<<b<<std::endl;
    a = b;
    std::cout << "a is now of size " << a.rows() << "x" << a.cols() << std::endl;
    std::cout<<"b复制给a后 a:"<<std::endl<<a<<std::endl;

}

void eigen_vector_operator(){

    //矩阵无法与常数相加减
    /*
    Matrix2d m;
    m<<1,2,3,4;
    std::cout<<"m:"<<std::endl<<m<<std::endl;
    std::cout<<"m+2:"<<std::endl<<m+2<<std::endl;
    错误：error: no match for 'operator+' (operand types are 'Eigen::Matrix2d {aka Eigen::Matrix<double, 2, 2>}' and 'int')
     */

    //矩阵和常数相乘
    Matrix2d a;
    a<<1,2,3,4;
    std::cout<<"a:"<<std::endl<<a<<std::endl;
    std::cout<<"a*2:"<<std::endl<<a*2<<std::endl;
    /*
     ***********************************************************分隔符***************************************************
     */
    //矩阵与矩阵相加减，相同类型和尺寸的矩阵对应位置相加减
    Matrix2d c;
    c << 1, 2,
         3, 4;
    std::cout<<"c:"<<std::endl<<c<<std::endl;
    MatrixXd b(2, 2);
    b << 2, 3,
         1, 4;
    std::cout<<"b:"<<std::endl<<b<<std::endl;
    std::cout << "c + b =\n"
              << c + b << std::endl;
    std::cout << "c - b =\n"
              << c - b << std::endl;
    std::cout << "Doing c += b;" << std::endl;
    c += b;
    std::cout << "Now c =\n"
              << c << std::endl;
    //注：矩阵相加减的前提是矩阵的类型和尺寸相同
    /*
    MatrixXd m_(3,3);
    m_<<1,2,4,6,2,4,6,23,4;
    m_ = c +m_;
    std::cout << "c + m_ =\n"
              <<  m_ << std::endl;
    错误：Assertion `aLhs.rows() == aRhs.rows() && aLhs.cols() == aRhs.cols()' failed.

    //m_2f是float类型矩阵，c是double类型矩阵，不能相加减
    Matrix2f m_2f;
    m_2f<<3,9,4,1;
    std::cout << "c + m_2f =\n"
              << c + m_2f << std::endl;
    */

    //矩阵和向量相乘
    //注意：矩阵和向量的元素类型要相同，不同不能相乘
    //矩阵与向量的乘法要符合运算规则
    Vector3d v_3d;
    v_3d<<3,6,9;
    std::cout<<"v_3d:"<<std::endl<<v_3d<<std::endl;
    Matrix3d m_3d;
    m_3d<<1,4,6,
          9,2,5,
          10,2,1;
    std::cout<<"m_3d:"<<std::endl<<m_3d<<std::endl;
    std::cout<<"m_3d*v_3d="<<std::endl<<m_3d*v_3d<<std::endl;


    //矩阵的强制类型转换
    Matrix2f m_2f;
    m_2f<<3,9,4,1;
    //由于m_2f是float类型，不能直接与doublev_2d类型直接运算，要进行强制类型转换后才能进行运算
    Vector2d v_2d(1,9);

    //使用cast<double>()进行强制类型转换
    //m_2f(2,2) v_2d(2,1)相乘后维度为（2，1），因此提供一个（2，1）的矩阵来接收运算结果
    Matrix<double,2,1> m_v_2d = m_2f.cast<double>()*v_2d;
    std::cout<<"m_v_2d:"<<std::endl<<m_v_2d<<std::endl;
    std::cout<<"m_v_2d size:"<<m_v_2d.rows()<<"X"<<m_v_2d.cols()<<std::endl;

    //矩阵与矩阵的乘法
    Matrix<float,2,4> m_24f;
    m_24f<<1,3,5,1,
           3,9,3,2;
    std::cout<<"m_24f:"<<std::endl<<m_24f<<std::endl;
    Matrix<float,4,3> m_43f;
    m_43f<<3,5,1,6,
           2,5,2,5,
           1,3,5,7;
    std::cout<<"m_43f:"<<std::endl<<m_43f<<std::endl;
    Matrix<float,2,3> m_23f;
    m_23f = m_24f*m_43f;
    std::cout<<"m_24f*m_43f:"<<std::endl<<m_24f*m_43f<<std::endl;
    /*
     ***********************************************************分隔符***************************************************
     */
    //向量的叉乘X与点乘.!!!!!!!!
    //对于內积和外积的计算可以使用dot()和cross()函数。当然点乘会得到一个1×1的矩阵(u.adjoint()*v)。
    //叉乘只适用于大小为3的向量，点乘适用于任意向量!!!!!
    Vector3d v(1, 2, 3);
    Vector3d w(0, 1, 2);
    std::cout<<"v："<<std::endl<<v<<std::endl;
    std::cout<<"w："<<std::endl<<w<<std::endl;
    std::cout<<"v叉乘w：v X w="<<std::endl<<v.cross(w)<<std::endl;
    std::cout<<"w叉乘v：w X v="<<std::endl<<w.cross(v)<<std::endl;
    //向量点乘
    Vector2f v_2f(2,4);
    Vector2f w_2f(3,2);
    std::cout<<"v点乘w：v . w="<<std::endl<<v.dot(w)<<std::endl;
    std::cout<<"v点乘w：v . w="<<std::endl<<v.adjoint()*w<<std::endl;
    //行向量与列向量相乘
    Vector3f v_3f(1,3,5);
    std::cout<<"v_3f："<<std::endl<<v_3f<<std::endl;
    RowVector3f v_r_3f(2,1,3);
    std::cout<<"v_r_3f："<<std::endl<<v_r_3f<<std::endl;
    std::cout<<"行向量v_r_3f*列向量v_3f：v_r_3f*v_3f="<<std::endl<<v_r_3f*v_3f<<std::endl;
    std::cout<<"列向量v_3f*行向量v_r_3f：v_3f*v_r_3f="<<std::endl<<v_3f*v_r_3f<<std::endl;


}

void eigen_special_operator(){
    //随机数矩阵
    Matrix3d m_33 = Matrix3d::Random();
    std::cout<<"Matrix3d m_33:"<<std::endl<<m_33<<std::endl;
    //矩阵的转置
    std::cout<<"m_33的转置：m_33^T:"<<std::endl<<m_33.transpose()<<std::endl;
    //矩阵元素之和
    std::cout<<"m_33各元素和：m_33.sum():"<<std::endl<<m_33.sum()<<std::endl;
    //矩阵元素中的最大值
    std::cout<<"m_33元素最大值：m_33.maxCoeff():"<<std::endl<<m_33.maxCoeff()<<std::endl;
    //矩阵元素中的最小值
    std::cout<<"m_33元素最小值：m_33.minCoeff():"<<std::endl<<m_33.minCoeff()<<std::endl;
    //矩阵元素的均值
    std::cout<<"m_33元素均值：m_33.mean():"<<std::endl<<m_33.mean()<<std::endl;
    //矩阵的迹（对角线元素之和）
    std::cout<<"m_33的迹（对角线元素之和）：m_33.trace():"<<std::endl<<m_33.trace()<<std::endl;
    //矩阵的逆（只有方阵才能求逆）(矩阵A为n阶方阵，若存在n阶矩阵B，使得矩阵A、B的乘积为单位阵，则称A为可逆阵，B为A的逆矩阵) 可逆矩阵的行列式值不为0
    std::cout<<"m_33的逆矩阵：m_33.inverse():"<<std::endl<<m_33.inverse()<<std::endl;
    //矩阵的行列式值（方阵才有行列式值）
    std::cout<<"m_33的行列式值：m_33.determinant():"<<std::endl<<m_33.determinant()<<std::endl;


    Matrix<float,3,3> matrix_33f;
    matrix_33f<<1,2,4,
                3,5,1,
                7,2,4;
    std::cout<<"matrix_33f:"<<std::endl<<matrix_33f<<std::endl;
    std::cout<<"matrix_33f的转置：matrix_33f^T:"<<std::endl<<matrix_33f.transpose()<<std::endl;
    std::cout<<"matrix_33f各元素和：matrix_33f.sum():"<<std::endl<<matrix_33f.sum()<<std::endl;
    std::cout<<"matrix_33f元素最大值：matrix_33f.maxCoeff():"<<std::endl<<matrix_33f.maxCoeff()<<std::endl;
    std::cout<<"matrix_33f元素最小值：matrix_33f.minCoeff():"<<std::endl<<matrix_33f.minCoeff()<<std::endl;
    std::cout<<"matrix_33f元素均值：matrix_33f.mean():"<<std::endl<<matrix_33f.mean()<<std::endl;
    std::cout<<"matrix_33f的迹（对角线元素之和）：matrix_33f.trace():"<<std::endl<<matrix_33f.trace()<<std::endl;
    std::cout<<"matrix_33f的逆矩阵：matrix_33f.inverse():"<<std::endl<<matrix_33f.inverse()<<std::endl;
    std::cout<<"matrix_33f的行列式值：matrix_33f.determinant():"<<std::endl<<matrix_33f.determinant()<<std::endl;

    Matrix<float,4,3> matrix_43f;
    matrix_43f<<2,9,10,
                3,1,4,
                10,3,1,
                5,8,3;
    std::cout<<"matrix_43f:"<<std::endl<<matrix_43f<<std::endl;
    std::cout<<"matrix_43f的转置：matrix_43f^T:"<<std::endl<<matrix_43f.transpose()<<std::endl;
    std::cout<<"matrix_43f各元素和：matrix_43f.sum():"<<std::endl<<matrix_43f.sum()<<std::endl;
    std::cout<<"matrix_43f的迹（对角线元素之和）：matrix_43f.trace():"<<std::endl<<matrix_43f.trace()<<std::endl;
    //只有方阵才能求逆，matrix_43f不是方阵不能求逆
    //std::cout<<"matrix_43f的逆矩阵：matrix_43f.inverse():"<<std::endl<<matrix_43f.inverse()<<std::endl;
    //错误：const Eigen::Inverse<Derived> Eigen::MatrixBase<Derived>::inverse() const [with Derived = Eigen::Matrix<float, 4, 3>]: Assertion `rows() == cols()' failed.

}

int main(){
    eigen_resize();
    eigen_vector_operator();
    eigen_special_operator();
    return 0;
}