精华内容
下载资源
问答
  • C++矩阵运算

    2017-11-20 15:37:29
    C++矩阵运算库,类似MATLAB里面的计算,使用起来非常方便简单
  • C++矩阵运算代码实现

    2017-05-03 22:12:32
    C++矩阵运算代码实现
  • C++矩阵运算

    2017-11-06 21:00:36
    运用C++ 实现矩阵的相关计算和操作,包括矩阵的加,减,乘,除等基本运算
  • C++矩阵类 C++矩阵运算

    2019-03-17 15:30:29
    封装好的矩阵类,提供运算化间求秩等功能,全部在Main函数上方
  • 文章目录一、C++矩阵运算库 - eigen1.下载及安装1.1Linux安装及配置1.2Windows配置2.测试使用2.1DevC++2.2Clion3.深入学习二、C++矩阵运算库 - Armadillo1.下载及安装1.1Linux安装1.2Windows配置2.测试使用3.深入...

    这篇博客总结一下C/C++中的矩阵运算库。

    一、C++矩阵运算库 - eigen

    Eigen是使用C++封装好的的一个矩阵运算库,可以很方便地实现各类矩阵运算,而且不用安装,只需要简单配置即可。

    1.下载及安装

    1.1Linux安装及配置

    sudo apt-get install libeigen3-dev
    

    Eigen只包含头文件,因此它不需要实现编译(只需要使用#include),指定好Eigen的头文件路径,编译项目即可。

    Eigen头文件的默认安装位置是:“/usr/include/eigen3”.

    1.2Windows配置

    下载地址:http://eigen.tuxfamily.org/index.php?title=Main_Page#Download

    下载文件解压后,文件目录如下:

    image-20210819215257932

    • 只需要将eigen-3.4.0的路径加入到头文件查找路径。

    • 使用时包含头文件即可,比如 #include <Eigen\Dense>

    2.测试使用

    本博客在Windows下使用DevC++和Clion两款C/C++来测试一下。

    为了应对不同的需求,Eigen库被分为多个功能模块,每个模块都有自己相对应的头文件,以供调用。 其中,Dense模块整合了绝大部分的模块,而Eigen模块更是整合了所有模块(也就是整个Eigen库)。

    在这里插入图片描述

    2.1DevC++

    添加头文件路径

    https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210819220638799.png

    测试代码

    #include <iostream>
    #include <Eigen\Dense>
    using namespace std;
    using namespace Eigen;
    int main()
    {
        Matrix2d a;
        a << 1, 2,
            3, 4;
        MatrixXd b(2, 2);
        b << 2, 3,
            1, 4;
        cout << "a + b =\n" << a + b << endl;
        cout << "a - b =\n" << a - b << endl;
        cout << "Doing a += b;" << endl;
        a += b;
        cout << "Now a =\n" << a << endl;
        cout << "a^T=  " << a.transpose() << endl;
        cout << "a*b= " << a*b << endl;
        Vector3d v(1, 2, 3);
        Vector3d w(1, 0, 0);
        cout << "-v + w - v =\n" << -v + w - v << endl;
        cout << v << endl;
        cout << v.transpose() << endl;
        system("pause");
    }
    

    运行结果如下

    image-20210819220836562

    2.2Clion

    clion中添加头文件可以在CMakeLists.txt中添加,也可以在项目目录中添加。

    1. (推荐)编辑项目目录下的 CMakeLists.txt,添加一行
    include_directories("/path/to/headers") #换成头文件所在目录
    
    1. 将对应的头文件或文件夹复制到项目根目录,然后在源文件中使用 #include “文件名” 包含

    这里我们使用第一种方法,更改之后,CMakeLists.txt文件内容如下:

    cmake_minimum_required(VERSION 3.19)
    project(untitled1)
    
    set(CMAKE_CXX_STANDARD 14)
    
    include_directories("D:\\eigen-3.4.0")
    
    add_executable(untitled1 main.cpp)
    

    测试代码依旧是上面的代码

    #include <iostream>
    #include <Eigen\Dense>
    using namespace std;
    using namespace Eigen;
    int main()
    {
        Matrix2d a;
        a << 1, 2,
            3, 4;
        MatrixXd b(2, 2);
        b << 2, 3,
            1, 4;
        cout << "a + b =\n" << a + b << endl;
        cout << "a - b =\n" << a - b << endl;
        cout << "Doing a += b;" << endl;
        a += b;
        cout << "Now a =\n" << a << endl;
        cout << "a^T=  " << a.transpose() << endl;
        cout << "a*b= " << a*b << endl;
        Vector3d v(1, 2, 3);
        Vector3d w(1, 0, 0);
        cout << "-v + w - v =\n" << -v + w - v << endl;
        cout << v << endl;
        cout << v.transpose() << endl;
        system("pause");
    }
    

    运行结果如下

    https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210819222406819.png

    3.深入学习

    本博客只是对矩阵运算库的简介、汇总、环境配置,因此不会讲太详细的使用。主要是本人太菜了,讲不来。不过为了内容的完整型,我会给几个好的比较完整的eigen学习教程。



    二、C++矩阵运算库 - Armadillo

    Armadillo是一个开源高性能C++线性代数库,提供了和Matlab中常用命令接近的函数接口,可以方便地将Matlab/Octave开发的算法移植到C++中。特别地,我们可以先在Matlab环境中编程进行算法原型验证,待算法充分验证通过之后再利用Armadillo移植到C++中编译为独立的可执行程序。虽然Matlab也支持利用mcc直接将m文件编译生成动态链接库文件或者可执行程序,但是这些代码的运行需要Matlab运行环境(MCR)的支持;而通过Armadillo进行移植则可以完全脱离Matlab环境。

    1.下载及安装

    1.1Linux安装

    执行命令:

    sudo apt-get install libopenblas-dev
    sudo apt-get install liblapack-dev
    sudo apt-get install libarpack2-dev
    sudo apt-get install libsuperlu-dev
    

    下载Armadillo包,链接:https://sourceforge.net/projects/arma/files/armadillo-9.600.6.tar.xz/download

    在Armadillo的安装目录打开终端执行:

    cmake .
    make
    

    1.2Windows配置

    因为Armadillo需要C++11的支持,而DEVC++好久没更新编译器了,支持不好,因此我们换用visual studio2019来测试。

    下载Armadillo包,链接:https://sourceforge.net/projects/arma/files/armadillo-9.600.6.tar.xz/download

    下载解压后需要配置头文件和库文件的路径。

    可以参考这篇文章:基于vs2017的armadillo配置教程(超详细!)

    2.测试使用

    测试代码如下:

    #include <iostream>
    #include <armadillo>
    using namespace arma;
    int main()
    {
        //生成一个随机矩阵A,大小为5x5,矩阵每个元素的范围为:(0,10)
        mat A = randu<mat>(5, 5) * 10;
        A.print("原矩阵A = \n");
    }
    

    在这里插入图片描述

    3.深入学习

    看了下,好像中文没啥好的教程,不如直接看帮助手册。

    三、C++矩阵运算库 - boost

    Boost在C++中地位非常高,被称为C++的准标准库,其中的ublas模块包含矩阵类,用法如下:

    #include <boost/numeric/ublas/matrix.hpp>
    #include <boost/numeric/ublas/io.hpp>
    #include <iostream>
    namespace ublas = boost::numeric::ublas;
    int main()
    {
        ublas::matrix<double> A(3, 3);
        for (unsigned i = 0; i < A.size1(); ++i)
            for (unsigned j = 0; j < A.size2(); ++j)
                A(i, j) = 3*i + j;
    	std::cout << A << std::endl;
        return 0;
    }
    

    关于boost的配置问题,可以参考博客boost库在visual studio、DevC++和vscode上的环境配置



    四、C语言矩阵运算库 -

    其实C++矩阵运算库已经很好用了,但是可能在某些场景下,因为项目历史或者编译器的原因,我们必须要使用C语言来实现矩阵运算。

    好像几乎没有特别知名C语言矩阵运算库,因此在此总结各位网友写的C语言矩阵运算库。

    1.C语言矩阵库1

    地址:如何用纯c语言优雅地实现一个矩阵运算库

    这个详细讲解了怎么自己实现一个矩阵运算库,想学习写一个自己的C语言矩阵运算库可以参考一下。

    2.C语言矩阵库2

    地址:我的C语言矩阵库

    github地址:https://github.com/colourfate/math_matrix

    3.C语言矩阵库3

    地址:C语言矩阵实现库运算, 简单的数组直接运算两种方式

    4.C语言矩阵库4

    地址:基于C语言的矩阵运算库

    5.C语言矩阵库5

    地址:超好用的纯C语言矩阵运算库

    github地址:https://github.com/fellylanma/easyMatrix

    6.C语言矩阵库6

    地址:C语言矩阵运算库(Light Matrix)

    github地址:https://github.com/zjc666/LightMatrix

    7.C语言矩阵库7

    github地址:https://github.com/kimwolf-fs/c_data_structure/tree/master/matrix

    8.C语言矩阵库8

    地址:异想家纯C语言矩阵运算库

    9.C语言矩阵库9

    github地址:https://github.com/Amoiensis/Matrix_hub

    10.C++矩阵运算库

    这个库是我同学写的,帮他传播一下!!!

    地址:C++矩阵库

    github地址:https://github.com/TING2938/Analysis


    总结

    在条件允许的情况下,可以优先使用eigen矩阵运算库。

    如果条件不允许或者希望自己能用一个更加小巧顺手的矩阵运算库,那可以参考上面,自己实现一个。

    展开全文
  • C++矩阵运算库是基于面向对象完成开发。包含一维向量,二维矩阵和三维矩阵的常用操作。类似MATLAB的矩阵运算,操作简单,可用于教学或者C++计算开发。
  • armadillo C++矩阵运算函数库,具体教程压缩包内有,不知道为什么国内去官网下下来的少很多东西
  • Windows下强大的C++矩阵运算库 Engin3 速度超过opencv 导入项目方便。
  • C++矩阵运算(较全面)

    千次阅读 2020-07-12 11:42:57
    C++矩阵运算,面向对象编程,构建C++矩阵运算库实现包括一维向量、二维矩阵以及三维矩阵的常见操作。

    `在这里插/C++矩阵运算库是基于面向对象完成开发
    Write By ZhangFa 2019年3月9日
    /

    #include
    #include
    using namespace std;

    class matrix
    {
    protected:
    int row;
    int col;
    int size;
    double data;
    public:
    matrix();
    matrix(int r,int c); //构造函数,矩阵定义入口
    matrix (const matrix& M); //拷贝构造函数
    ~matrix(void); //析构函数,自动释放内存
    friend void free_place(matrix& M); //释放内存
    matrix& operator=(matrix& M); //重载=运算符
    matrix operator+(matrix& M); //重载+运算符矩阵相加
    matrix operator+(double pos); //重载+运算符矩阵与一个数相加,矩阵每个元素加这个数
    matrix operator+=(matrix& M); //重载累加运算符
    matrix operator-(matrix& M); //重载-运算符矩阵相加
    matrix operator-=(matrix& M); //重载累减运算符
    double operator()(int r=0,int c=0); //索引内部元素
    friend matrix operator
    (matrix& M1,matrix& M2); //重载运算符矩阵乘法
    friend matrix operator
    (matrix& M1, double pos);//重载*运算符,矩阵元素同时乘以一个数
    friend matrix operator/(matrix& M1, double pos);//重载/运算符,矩阵元素同时除以一个数
    friend ostream& operator<<(ostream& out, matrix& M);//重载输出运算符
    friend istream& operator>>(istream &input, matrix &M);//重载输入运算符,一个一个的输入

    public:
    int size1(); //矩阵行数
    int size2(); //矩阵列数
    int numel(); //矩阵元素总数
    void array_to_matrix(double *array); //数组转化为矩阵

    public: //向量的基本操作
    double mean(); //求向量元素的平均数
    double sum(); //向量内部元素之和
    double length(); //向量长度
    double norm(); //向量的模
    double index(int n); //向量索引元素,注意下标从零开始
    int number_find(double pos); //向量中查找某个数的位置
    friend double dot(matrix& M1,matrix& M2); //向量的点乘,MATLAB中的dot语句
    friend matrix cross(matrix& M1,matrix& M2); //向量叉乘,仅限于3阶向量
    matrix blocks(int a,int b); //向量截取,从a到b,注意下标从零开始
    friend matrix sequence(double beg,double en,double step);//向量下标递增数列,给定开始和结尾数据
    void deassign(int n, double pos); //对向量某个元素重新赋值,从零开始
    matrix point_power(double n); //向量点方,相当于.^n
    void push_back(double pos); //向量后面增加一个数

    public: //二维矩阵的基本操作
    double index(int x,int y); //索引矩阵某一个元素
    void deassign(int r,int c,double pos); //对矩阵中的某个元素赋值或重新赋值,从零开始
    double det(); //矩阵行列式
    friend matrix numpy(matrix& M1,matrix& M2); //两个矩阵对应元素相乘,相当于.*
    friend matrix merge(matrix& M1, matrix& M2); //合并两个矩阵,[M1,M2]横排
    friend matrix vertical(matrix& M1,matrix& M2); //合并两个矩阵,[M1;M2]竖排
    void grow_col(matrix& M); //矩阵动态增长,M=[M,M1];
    void grow_row(matrix& M); //矩阵动态增长,M=[M;M1];
    friend matrix zeros(int r = 0, int c = 0); //生成零矩阵
    friend matrix eye(int num); //生成单位矩阵
    friend matrix ones(int r, int c); //产生元素全为1的矩阵
    //matrix ones(double n); //由某个向量扩充,元素有每一行第一个个数复制得到
    matrix diag(); //生成对角阵,通过向量生成
    matrix trans(); //矩阵转置
    matrix inverse(); //矩阵求逆
    matrix GuassInversion(); //高斯消元发求矩阵的逆
    matrix adjoint(); //伴随矩阵
    matrix getrow(size_t index); //得到矩阵的行向量
    matrix getcol(size_t index); //得到矩阵的列向量
    matrix blocks(int a,int b,int m,int n); //矩阵块提取,参数分别为从矩阵(a,b)开始,提取(m,n)块
    void replace(int a, int b, matrix& M); //已知矩阵用M矩阵重新赋值,从矩阵(a,b)开始,替换长度由M决定。矩阵长度从零开始
    void doolittle(matrix& L,matrix& U); //矩阵三角分解
    matrix Cholesky(); //chol分解
    void QR(matrix& Q,matrix& R); //矩阵QR分解
    matrix eig_val(In_opt unsigned _iters); //用QR分解计算特征值
    matrix eig_vect(In_opt unsigned _iters); //特征向量
    };

    //三维矩阵
    class Mat3D :public matrix //类的继承与派生
    {
    private:
    int lay;

    public: //三维矩阵的基本操作
    Mat3D(); //空矩阵
    Mat3D(int r, int c, int l); //构造函数
    ~Mat3D(void); //析构函数 Mat3D(const Mat3D& M); //拷贝赋值
    Mat3D& operator=(Mat3D& M); //重载=运算符
    friend ostream& operator<<(ostream& out, Mat3D& M);//重载输出运算符
    void zeros_3D(); //生成零矩阵 void save_in_ij(matrix& M); //把矩阵保存到ij面内
    void save_in_jk(matrix& M); //把矩阵保存到jk面
    void save_in_ik(matrix& M); //把矩阵保存到ik面内
    matrix pick_from_ij(int k); //从三维矩阵提取ij面的元素
    matrix pick_from_jk(int i);
    matrix pick_from_ik(int j);
    double index_3D(int a,int b,int c); //索引某一点出元素
    matrix pick_col_i(int j,int k); //取平行于i的一列元素
    matrix pick_col_j(int i,int k);
    matrix pick_col_k(int i,int j);
    void replace_ij(int k,matrix& M); //已知三维矩阵自身的变换,k层元素的替换,返回是替换后的矩阵
    void replace_jk(int i,matrix& M); //已知三维矩阵自身的变换,i层元素的替换,返回是替换后的矩阵
    void replace_ik(int j,matrix& M); //已知三维矩阵自身的变换,j层元素的替换,返回是替换后的矩阵 };入代码片

    `@C++矩阵运算(较全面)

    链接: https://mp.csdn.net/console/upDetailed.

    展开全文
  • 比较不错的 C++矩阵运算

    万次阅读 2019-03-10 20:25:41
    目前使用比较广的C++矩阵运算库之一,是在C++下使用Matlab方式操作矩阵很好的选择,许多Matlab的矩阵操作函数都可以找到对应,这对习惯了Matlab的人来说实在是非常方便,另外如果要将Matlab下做研究的代码改写成C++...

    Armadillo:C++下的Matlab替代品

    地址:http://arma.sourceforge.net/

    许可证:MPL 2.0

    目前使用比较广的C++矩阵运算库之一,是在C++下使用Matlab方式操作矩阵很好的选择,许多Matlab的矩阵操作函数都可以找到对应,这对习惯了Matlab的人来说实在是非常方便,另外如果要将Matlab下做研究的代码改写成C++,使用Armadillo也会很方便,这里有一个简易的Matlab到Armadillo的语法转换。下面列了一些Armadillo的特性:

    • 支持整数,浮点数,和复数矩阵。
    • 支持矩阵逐元素操作,包括abs · conj · conv_to · eps · imag/real · misc functions (exp, log, pow, sqrt, round, sign, …) · trigonometric functions (cos, sin, …)等等。
    • 支持矩阵分块操作。
    • 支持对整体矩阵的操作diagvec · min/max · prod · sum · statistics (mean, stddev, …) · accu · as_scalar · det · dot/cdot/norm_dot · log_det · norm · rank · trace等等。
    • Matlab用户,你甚至可以找到你熟悉的hist · histc · unique · cumsum · sort_index · find · repmat · linspace等函数。
    • 除了自带的矩阵基本运算之外,可自动检测是否安装有BLAS,或更快的 OpenBLAS, Intel MKL, AMD ACML,并使用他们替代自带基本运算实现。
    • 提供接口使用LAPACK进行矩阵分解运算,svd · qr · lu · fft等等。
    • 提供了稀疏矩阵类,支持常用操作,但暂时没有矩阵分解的实现。
    • 更新比较活跃,有一些计算机视觉、机器学习、物理方面的开源项目在使用,比如MLPACK (Machine Learning Library)。

    总体来讲很好用的矩阵库,速度上因为可以使用OpenBLAS等库进行加速,因此还是不错的。网上可以找到一个叫 Nghia Ho的人写的关于和eigen及opencv的速度比较做参考,速度略优。不过也由于依赖LAPACK等库完成矩阵分解计算,在windows上运行可能会比较痛苦。

    Eigen3:强大且只需头文件

    地址:http://eigen.tuxfamily.org/

    许可证:主要为MPL 2.0,部分有来自第三方的代码为LGPL

    非常强大的矩阵运算库,我一直在用,大家用了都说好。使用类似Matlab的方式操作矩阵,可以在这里查看官方的与Maltab的对应关系,个人感觉单纯讲和Matlab的对应的话,可能不如Armadillo对应的好,但功能绝对强大。Eigen包含了绝大部分你能用到的矩阵算法,同时提供许多第三方的接口。Eigen一个重要特点是没有什么依赖的库,本身仅有许多头文件组成,因此非常轻量而易于跨平台。你要做的就是把用到的头文件和你的代码放在一起就可以了。Eigen的一些特性:

    • 支持整数、浮点数、复数,使用模板编程,可以为特殊的数据结构提供矩阵操作。比如在用ceres-solver进行做优化问题(比如bundle adjustment)的时候,有时候需要用模板编程写一个目标函数,ceres可以将模板自动替换为内部的一个可以自动求微分的特殊的double类型。而如果要在这个模板函数中进行矩阵计算,使用Eigen就会非常方便。
    • 支持逐元素、分块、和整体的矩阵操作。
    • 内含大量矩阵分解算法包括LU,LDLt,QR、SVD等等。
    • 支持使用Intel MKL加速
    • 部分功能支持多线程
    • 稀疏矩阵支持良好,到今年新出的Eigen3.2,已经自带了SparseLU、SparseQR、共轭梯度(ConjugateGradient solver)、bi conjugate gradient stabilized solver等解稀疏矩阵的功能。同时提供SPQRUmfPack等外部稀疏矩阵库的接口。
    • 支持常用几何运算,包括旋转矩阵、四元数、矩阵变换、AngleAxis(欧拉角与Rodrigues变换)等等。
    • 更新活跃,用户众多(Google、WilliowGarage也在用),使用Eigen的比较著名的开源项目有ROS(机器人操作系统)、PCL(点云处理库)、Google Ceres(优化算法)。OpenCV自带到Eigen的接口。

    总体来讲,如果经常做一些比较复杂的矩阵计算的话,或者想要跨平台的话,非常值得一用。

    OpenCV:方便的计算机视觉计算库

    地址:http://opencv.org/

    许可证:目前是BSD

    OpenCV在计算机视觉领域名气实在是太大了,而且最近几年库里的算法开始爆炸式的增长,最近貌似计划推出OpenCV 3了(参见这里)。有人开始抱怨OpenCV现在内容太杂了,不过这样的好处就是从是研究开发的话,一个库就可以得到大部分计算机视觉的流行算法,省去了很多麻烦。

    OpenCV自带的矩阵计算功能算不上是专业的矩阵计算库,但是如果你用C++写机器学习、计算机视觉的程序,一定会经常用到。OpenCV的矩阵计算功能还算比较完善,虽然速度略差劲,但用在大多数的开发和研究领域也是足够了。特别是OpenCV 2.2之后提供了类Matlab的矩阵C++接口,使得直接使用OpenCV进行矩阵计算变得简单易用。列两个比较值得一提的特点:

    • 大量计算机视觉、机器学习相关的矩阵操作,非常方便。比如PCA、LDA、三维空间投影等等。
    • 自带并行加速的矩阵计算功能。其中cv::gpu模块提供了CUDA支持的GPU矩阵计算功能,cv::ocl模块提供了OpenCL支持的并行矩阵计算功能。可以非常方便的进行并行矩阵计算,不过不足的是这两个模块还暂时缺少矩阵分解的实现。我曾见过朋友在做深度学习的时候用cv::ocl模块进行大矩阵乘法,貌似效果还不错。

    ViennaCL:并行矩阵计算

    网址:http://viennacl.sourceforge.net/

    许可证:MIT

    作者Karl Rupp来自维也纳大学,开发了一套Vienna*系列的开源软件,其中还包括ViennaMath(symbolic math符号计算)、ViennaFEM(有限元)等等。ViennaCL在后台支持OpenCL、OpenMP和CUDA,可以方便地使用各种型号的CPU或GPU进行并行计算。

    • 目前矩阵类型支持float和double,1.4.2版尚不支持复数矩阵。
    • 支持常用的矩阵运算和分解。
    • 接口很有好,并提供接口到uBLAS、Eigen、MTL 4等矩阵库。

    安装使用有非常详细的官方文档

    PETSc:大规模并行科学计算

    网站:http://www.mcs.anl.gov/petsc/

    许可证:Copyright University of Chicago (GPL compatible)

    PETSc(Portable, Extensible Toolkit for Scientific Computation)  是美国能源部ODE2000支持开发的20多个ACTS工具箱之一,由Argonne国家实验室开发的可移植可扩展科学计算工具箱,主要用于在分布式存储环境高效求解偏微分方程组及相关问题。PETSc所有消息传递通信均采用MPI标准实现。线性方程组求解器是PETSc的核心组件之一,PETSc几乎提供了所有求解线性方程组的高效求解器,既有串行求解也有并行求解,既有直接法求解也有迭代法求解。对于大规模线性方程组, PETSc提供了大量基于Krylov子空间方法和各种预条件子的成熟而有效的迭代方法,以及其他通用程序和用户程序的接口。PETSc具有一般库软件所具备的高性能、可移植等优点,而且面向对象技术使得PETSc内部功能部件的使用非常方便,接口简单而又适用面广,可以缩短开发周期,减少工作量。[直接粘百度百科了]。

    PETSc在网上可一找到很多英文资料,使用也比较广泛。不过在学校实验室的一般的科学计算可能接触的还比较少。推荐一个YouTube(可能要翻墙)的五集PETSc简单入门《PRACE Video Tutorial – PETSc Tutorial》。

    其他的矩阵计算库和资料

    在Stackexchange上有一个帖子《Recommendations for a usable, fast C++ matrix library?》里面搜罗了许多矩阵运算库。另外INRIA有人写了一个文档《Linear Algebra Libraries》,对常见的矩阵运算库进行了总结。除了上面提到的几个库之外,下面还有一些比较常用或坚持更新的矩阵库:

    • uBLAS:Boost包中的BLAS库接口,据说速度一般。
    • GSL:GNU Scientific Library自带的矩阵运算,据说速度一般。
    • MTL 4Matrix Template Library version 4,类似Eigen和Armadillo,有开源版本。
    • Trilinos:和PETSc同是美国能源部ODE2000支持开发的20多个ACTS工具箱之一,用于大规模计算。
    展开全文
  • c++矩阵运算

    千次阅读 2018-08-04 08:49:53
    //这里不能对指针直接赋值,复制对求逆、转置等操作会影响原矩阵 item = new double[colNum*rowNum]; for (int i = 0; i *rowNum; i++) { item[i] = M.item[i]; } } Matrix& Matrix::operator=(const Matrix & ...

    原文地址:https://www.cnblogs.com/wzxwhd/p/6031444.html

    优化了一些算法

     

    #pragma once
    #include <iostream>
    #include <iomanip>
    #include <string>
    
    #define OVERFLOWED 1E-12
    class Matrix
    {
    public:
        Matrix(int m, int n);             //构建一个m*n的全零矩阵
        Matrix(int n);                 //构建一个n*n的单位矩阵
        Matrix(const Matrix &);         //拷贝构造函数,深拷贝
        Matrix(double* items, int m, int n);//根据数组拷贝一个矩阵
        ~Matrix();
        static Matrix FromFile(std::string file);
        int getRowNum() const;                //返回矩阵的行数
        int getColNum() const;                //返回矩阵的列数
    
        Matrix Trans() const;                //将矩阵转置
    
        double get(int i, int j) const;            //返回矩阵第i行j列元素
        void set(int i, int j, double val);        //设置矩阵第i行j列元素
    
        Matrix operator +(const Matrix &m);         //两个矩阵相加
        Matrix operator -(const Matrix &m);         //两个矩阵相减
        Matrix operator *(const Matrix &m);         //两个矩阵相乘
        Matrix operator *(const double f);         //矩阵乘以常数
        Matrix& operator=(const Matrix& m);
        Matrix Inverse();
        
        friend std::ostream& operator <<(std::ostream &os, const Matrix &m);
    
    private:
        double *item;        //指向矩阵首元素
        int rowNum;        //矩阵行数
        int colNum;        //矩阵列数
    
    private:
        //矩阵初等行变换
        //如果j=-1,则对i扩大multiply倍
        //如果j在取值范围内,则将第i行扩大multiply倍加到j行
        void RowSwap(int i, int j, double multiply);
        //交换两行
        void RowSwap(int i, int j);
        void FlowOver();
    };

     

     

    #include "Matrix.h"
    #include <vector>
    #include <cmath>
    #include <fstream>
    #include <sstream>
    
    using namespace std;
    Matrix::Matrix(int m, int n)
    {
        if (m < 0 || n < 0)
        {
            cout << "矩阵大小不能为负\n";
            return;
        }
        rowNum = m;
        colNum = n;
        item = new double[m*n];
        for (int i = 0; i < m*n; i++)
        {
            item[i] = 0;
        }
    }
    
    //也可用二维数组初始化
    Matrix::Matrix(double* items, int m, int n)
    {
        rowNum = m;
        colNum = n;
        item = new double[m*n];
        for (int i = 0; i < colNum*rowNum; i++)
        {
            item[i] = items[i];
        }
    }
    Matrix::Matrix(int n)
    {
        rowNum = colNum = n;
        item = new double[n*n];
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (i == j)
                    set(i, j, 1.0);
                else
                    set(i, j, 0);
            }
        }
    }
    Matrix::Matrix(const Matrix &M)
    {
        colNum = M.colNum;
        rowNum = M.rowNum;
        //这里不能对指针直接赋值,复制对求逆、转置等操作会影响原矩阵
        item = new double[colNum*rowNum];
        for (int i = 0; i < colNum*rowNum; i++)
        {
            item[i] = M.item[i];
        }
    }
    Matrix& Matrix::operator=(const Matrix & M)
    {
        colNum = M.colNum;
        rowNum = M.rowNum;
        if (item != nullptr) delete[] item;
        item = new double[colNum*rowNum];
        for (int i = 0; i < colNum*rowNum; i++)
        {
            item[i] = M.item[i];
        }
        return *this;
    }
    
    Matrix Matrix::FromFile(std::string file)
    {
        ifstream read(file);
        if (!read.is_open())
        {
            cout << "Matrix::未能打开文件\n";
        }
        int rows = 0;
        string line;
        vector<double> nums;
        while (getline(read, line))
        {
            istringstream record(line);
            double num = 0.0;
            while (record >> num)  nums.push_back(num);
            rows++;
        }
        return Matrix(&(*nums.begin()), rows, nums.size() / rows);
    }
    
    Matrix::~Matrix()
    {
        delete[] item;
    }
    double Matrix::get(int i, int j) const
    {
        return item[i*colNum + j];
    }
    void Matrix::set(int i, int j, double value)
    {
        item[i*colNum + j] = value;
    }
    void Matrix::RowSwap(int i, int j, double multiply)
    {
        if (j == -1)
        {
            for (int k = 0; k < colNum; k++)
            {
                set(i, k, multiply*get(i, k));
            }
        }
        else
        {
            for (int k = 0; k < colNum; k++)
            {
                set(j, k, multiply*get(i, k) + get(j, k));
            }
        }
    }
    void Matrix::RowSwap(int i, int j)
    {
        Matrix _copy = *this;
        for (int k = 0; k < colNum; k++)
        {
            double swap = _copy.get(j, k);
            set(j, k, _copy.get(i, k));
            set(i, k, swap);
        }
    }
    Matrix Matrix::Trans() const
    {
        Matrix _copy = *this;
        _copy.rowNum = this->colNum;
        _copy.colNum = this->rowNum;
        for (int i = 0; i < _copy.rowNum; i++)
        {
            for (int j = 0; j < _copy.colNum; j++)
            {
                _copy.set(i, j, get(j, i));
            }
        }
        return _copy;
    }
    int Matrix::getRowNum() const
    {
        return rowNum;
    }
    int Matrix::getColNum() const
    {
        return colNum;
    }
    ostream& operator <<(ostream &os, const Matrix &m)
    {
        for (int i = 0; i < m.rowNum; i++)
        {
            for (int j = 0; j < m.colNum; j++)
                os << std::setw(10) << std::fixed << std::setprecision(12) << m.get(i, j) << " ";
            os << "\n";
        }
        os.flush();
        return os;
    }
    Matrix Matrix::operator +(const Matrix &m)
    {
        if (m.colNum != colNum || m.rowNum != rowNum) return *this;
        Matrix _copy = *this;
        for (int i = 0; i < rowNum; i++)
        {
            for (int j = 0; j < colNum; j++)
            {
                _copy.set(i, j, get(i, j) + m.get(i, j));
            }
        }
        return _copy;
    }
    Matrix Matrix::operator -(const Matrix &m)
    {
        if (m.colNum != colNum || m.rowNum != rowNum) return *this;
        Matrix _copy = *this;
        for (int i = 0; i < rowNum; i++)
        {
            for (int j = 0; j < colNum; j++)
            {
                _copy.set(i, j, get(i, j) - m.get(i, j));
            }
        }
        return _copy;
    }
    Matrix Matrix::operator *(const double f)
    {
        Matrix _copy = *this;
        for (int i = 0; i < rowNum; i++)
        {
            for (int j = 0; j < colNum; j++)
            {
                _copy.set(i, j, get(i, j)*f);
            }
        }
        return _copy;
    }
    Matrix Matrix::operator *(const Matrix &m)
    {
        if (colNum != m.rowNum)
        {
            cout << "无法相乘!";
            return *this;
        }
        Matrix _copy(rowNum, m.getColNum());
        for (int i = 0; i < rowNum; i++)
        {
            for (int j = 0; j < m.colNum; j++)
            {
                double sum = 0;
                for (int k = 0; k < m.rowNum; k++)
                {
                    sum += get(i, k)*m.get(k, j);
                }
                _copy.set(i, j, sum);
            }
        }
        return _copy;
    }
    Matrix Matrix::Inverse()
    {
        Matrix _copy = *this;
        //变换结果
        Matrix result(colNum);
        if (colNum != rowNum)
        {
            cout << "矩阵不可逆!" << endl;
            return *this;
        }
        for (int i = 0; i < rowNum; i++)
        {
            int MaxRow = i;
            //首先找到第i列的绝对值最大的数,并将该行和第i行互换
            double max = abs(_copy.get(i, i));
            for (int j = i; j < colNum; j++)
            {
                if (abs(_copy.get(j, i))>max)
                {
                    max = abs(_copy.get(j, i));
                    MaxRow = j;
                }
            }
            //交换j,i两行
            if (MaxRow != i)
            {
                result.RowSwap(i, MaxRow);
                _copy.RowSwap(i, MaxRow);
            }
            //将第i行做初等行变换,将第一个非0元素化为1
            double r = 1.0 / _copy.get(i, i);
            _copy.RowSwap(i, -1, r);
            result.RowSwap(i, -1, r);
            //消元
            for (int j = 0; j < rowNum; j++)
            {
                if (j == i) continue;
                r = -_copy.get(j, i);
                _copy.RowSwap(i, j, r);
                result.RowSwap(i, j, r);
            }
        }
        //result.FlowOver();
        return result;
    }
    void Matrix::FlowOver()
    {
        for (int i = 0; i < rowNum;i++)
        {
            for (int j = 0; j < colNum;j++)
            {
                if (abs(get(i, j)) <= OVERFLOWED) set(i, j, 0);
            }
        }
    }
    展开全文
  • C++ 矩阵运算

    2012-04-25 12:42:16
    C++编写的矩阵运算的相关公式,并且附有运行实例,可以求解矩阵的逆,行列式,伴随阵
  • C++矩阵运算模块

    2018-04-09 17:36:07
    矩阵运算模块包括矩阵相加、相减、相乘、转置、求逆、数乘、求行列式等。资源共有三个文件:Demo.cpp、Matrix.cpp和Matrix.h,其中Demo里有使用例子,可直接运行。
  • Eigen——C++矩阵运算

    千次阅读 多人点赞 2019-11-28 23:16:27
    Eigen——C++矩阵运算库Eigen是什么?下载配置使用参考 Eigen是什么? Eigen是一个基于C++模板的开源库,支持线性代数,矩阵和矢量运算,数值分析及其相关的算法。 下载配置 官网:Eigen官网,下载解压缩可以重命名...
  • C++矩阵运算实现

    万次阅读 2017-01-07 13:28:07
    C++矩阵运算实现 C++库没有矩阵运算库,对于一些矩阵运算的话还是不方便。本文给了一些矩阵运算代码,加减乘的基本运算详见我给的链接,这里给出的是求行列式和求矩阵逆的代码。 目录 用 [TOC]来生成目录: ...
  • 包含Matrix和Array类,基础的线性代数运算和数组操作 #include <Eigen/SVD> SVD分解 #include <Eigen/Eigen>全部包含 使用时using namespace Eigen 2. Matix类: 前三个参数:Scalar,RowsAtCompileT
  • C++矩阵运算的实现

    2015-05-22 11:52:49
    C++控制台程序,利用指针进行矩阵的加、减、乘运算 头文件代码如下: #ifndef MATRIX_H #define MATRIX_H #include using namespace std; class Matrix { public: Matrix(int zRow = 0, int zLine = 0, double *...
  • 矩阵运算在计算机图形和视觉中用着十分广泛的应用,成熟的第三方库有很多比如:Eigen、opencv、ViennaCL等。 头文件 #pragma once #include <cmath> #include <assert.h>//如果方程无解或矩阵没有逆或...
  • C++矩阵运算库推荐

    2015-03-22 11:04:55
    目录[-] Armadillo:C++下的Matlab替代品 ...最近在几个地方都看到有人问C++下用什么矩阵运算库比较好,顺便做了个调查,做一些相关的推荐吧。主要针对稠密矩阵,有时间会再写一个稀疏矩阵的推荐。欢
  • C++矩阵运算库推荐.pdf

    2021-09-14 10:40:41
    C++矩阵运算库推荐.pdf
  • 摘要:VC/C++源码,数据库应用,矩阵运算,矩阵求逆,矩阵转置 C++实现几种基本的矩阵运算,包含头文件直接调用,包含矩阵转置、求逆、相乘几个通用操作,源代码由 武汉大学.遥感信息工程学院.卢昊提供。    内容概述...
  • C++矩阵运算类库(很实用).pdf
  • 本资源为EIGEN安装包 ,可在Visual Studio上添加配置,进行矩阵运算
  • 通过C++实现矩阵的常用运算,相加、减,数乘,矩阵相乘,矩阵转置,矩阵求逆等。
  • armadillo C++矩阵运算

    2015-02-06 16:36:19
    C++ 矩阵运算工具包,在科学计算中很常用,机器学习和模式识别领域很多大牛用到的,和matlab的风格相似,速度有保证
  • C++ QT 矩阵运算

    2019-04-24 13:31:17
    C++ QT 矩阵运算器。 使用QT、C++开发的矩阵运算器,支持加减乘和转置(对左边矩阵进行转置),底层数据结构使用的是稀疏矩阵,用数组实现。 C++、QT

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,292
精华内容 13,316
关键字:

c++矩阵运算

c++ 订阅
友情链接: java-caiquan.zip