精华内容
下载资源
问答
  • Fortran 稀疏矩阵

    2021-04-26 14:12:35
    Fortran 处理稀疏矩阵 稀疏矩阵Ax=b 在Fortran里面使用稀疏矩阵最基础的是用BLAS(Basic Linear Algebra Subprograms),但是在后来的MKL库中有集成BLAS。如果是Ax=b的线性方程组,建议使用Pardiso,同样在MKL库中...

    Fortran 处理稀疏矩阵

    稀疏矩阵Ax=b

    在Fortran里面使用稀疏矩阵最基础的是用BLAS(Basic Linear Algebra Subprograms),但是在后来的MKL库中有集成BLAS。如果是解Ax=b的线性方程组,建议使用Pardiso,同样在MKL库中有集成,可以去官网查找资料。
    这里给出两篇博文,介绍了如何在Fortran里面解线性方程组以及BLAS库函数的示例
    https://blog.csdn.net/chd_lkl/article/details/83011186
    https://blog.csdn.net/chd_lkl/article/details/107433757

    目前查到的除上述表格中的MKL库函数之外,还有SPARSEKIT库函数,但是该库函数是在GNU下运行的,运行之前还需要安装该函数包,可以参考SPARSEKIT网站。

    以及SOL(Systems Optimization Laboratory)求解器,参考网站http://stanford.edu/group/SOL/download.html给出一个解线性方程组的包,里面还有LU分解函数。

    这里再附一个老师提供的稀疏矩阵求解器GMERS
    参考网站,主要功能就是两个:

    • 一个是对COO格式稀疏矩阵直接迭代求解Ax=b 使用函数 mgmres_st
    • 另一个是对CSR格式稀疏矩阵通过ILU方法求解Ax=b,使用函数pmgmres_ilu_cr
      测试结果来看,明显后者速度要快不少,如果只有COO格式的稀疏矩阵,可以通过MKL的库函数 mkl_dcsrcoo转换,具体的使用规则参考MKL库函数,还是之前给的链接。这个求解器里面还有一个求稀疏矩阵乘向量的小函数比较好用 ax_st ax_cr注意这里的向量是稠密的向量,st cr分别表示稀疏矩阵的存储格式是COO还是CSR格式。

    稀疏矩阵存储方式及运算

    稀疏矩阵的存储方式一般有两种:

    • COO 存三元组(行标、列标、值) 这种方法就很直观
    • CSR 存三元组(值,列标,行指标)
      其中CSR的rowindex表示每行第一个非0元素是第几个非0元素,rowindex最后一个表示最后一个非0元素是第几个。
      于是rowindex的长度为行数+1,rowindex最后一个元素为非0元素的个数。

    需要用到的mkl处理稀疏矩阵的函数主要参考文档
    里面给出了各种函数的用法,主要包括:

    功能 函数
    稀疏矩阵乘一般向量 mkl_?csrgemv
    解线性方程组Ax=b mkl_?csrsv
    稀疏矩阵乘一般矩阵 mkl_?csrmm

    需要注意的是,稀疏矩阵之间的加法、乘法这里没有给出具体的函数处理,需要自己去补充写。。。

    这里补充一个讲稀疏矩阵乘法的算法博客
    该算法就是两个嵌套的for循环分别遍历两个矩阵的非0元素

    关于稀疏矩阵的乘法目前在网上能查到的基本都是做两次遍历,外循环遍历矩阵A的所有非0元,内循环遍历B的非0元,这样时间复杂度就是O(num2)O(num^2)但是对于我们的问题(二维非局域热传导方程DG方法),num=CNxNyk3num=CN_xN_yk^3,当网格加密一倍,即Nx,NyN_x, N_y变为原来的两倍,则时间复杂度变为原来的16倍,这对于大规模矩阵运算是难以接受的。但实际上我们的稀疏矩阵是接近于三对角阵甚至对角阵,实际计算起来应该不太难,但是由于存储稀疏矩阵用COO格式或者CSR格式,并不能及时找到对应行列的元素,所以一般的稀疏矩阵乘法对于我们这的特殊矩阵并没有明显的优势。

    补充

    再补充几个编程中遇到的问题:

    • Fortran开辟动态数组的时候,需要给一个指定的长度,然后传参都是传地址,所以对于长度不固定的情况,目前的处理方法就是最简单无脑的给一个足够长的空间,由于传参传的是地址,如果有函数计算A-B并赋给C
      Minus(A, B, C)
      但此时如果需要计算A-B并赋给A,写成Minus(A, B, A)就会出问题,最好还是别这么写
    • Fortran里面声明完一个变量之后如果用的话尽量给它初始化!!!因为Fortran默认会给一些很奇怪的数,不管是integer变量还是real变量!!!
    展开全文
  • 在图像处理中,常常会需要求解超大稀疏矩阵,比如泊松融合,比如加权最小二乘法的保边缘平滑滤波器(WLS).对于一个300*300的图像输入,其对应的稀疏矩阵大小为90000*90000,这样的矩阵别说是求解,存储在内存...

    在图像处理中,常常会需要求解超大稀疏矩阵的解,比如泊松融合,比如加权最小二乘法的保边缘平滑滤波器(WLS).对于一个300*300的图像输入,其对应的稀疏矩阵大小为90000*90000,这样的矩阵别说是求解,存储在内存中都是一笔巨大的开销.好在我们有专门用于稀疏矩阵运算的工具,比如eigen矩阵运算库和cuda中的cusolver模块.

    在使用cusolver的过程中,我发现网上关于此的教程是少之又少,因而用了不少时间来阅读官方文档,和理解api,为了方便中文社区的使用者们,这里写下关键步骤的教程,以供参考.

    首先,不管是cuda还是eigen还是matlab,对于稀疏矩阵的存储都不是把每一个元素存储下来,最基本的稀疏矩阵存储方式是coo,也就是只存储非零元素的值以及坐标.cusolver模块中往往需要CSR格式的稀疏矩阵,CSR是基于COO的更进一步的压缩格式,它对于值的row坐标进行了压缩.这里我推荐大家去看CUSPARSE(cuda的稀疏矩阵模块)的文档的3.3节中介绍coo以及csr的部分,比较清晰.CSR难理解一点,推荐大家去搜索"csr 稀疏矩阵"这些关键词再看看csr的row到底是怎么压缩的.

    第二步,大家去看安装cuda时产生的samples的例子,一般在安装cuda时会默认安装开发工具nsight,一个基于eclipse的IDE,用起来很方便,直接新建项目--导入cuda项目--导入cuda Sample就可以了.


    其中NVIDIA_CUDA-8.0_Samples/7_CUDALibraries 这个目录下有一些cusolver模块的例子,下面这几个可以运行一下看一下,帮助大家理解.

    cuSolverDn_LinearSolver - cuSolverDn Linear Solver 
    实现cuSolverDN的LU, QR和Cholesky因式分解
    cuSolverRf - cuSolverRf Refactorization 
    重新因子化。
    cuSolverSp_LinearSolver - cuSolverSp Linear Solver 
    实现cuSolverSP的LU, QR和Cholesky因式分解
    cuSolverSp_LowlevelCholesky - cuSolverSp LowlevelCholesky Solver 
    使用cuSolverSP底层API实现Cholesky因式分解
    cuSolverSp_LowlevelQR - cuSolverSp Lowlevel QR Solver 
    使用cuSolverSP底层API实现QR因式分解

    接下来,我们创建一个coo格式的稀疏矩阵,很简单,一个coo格式的矩阵只需要3个变量:非零元素的值,非零元素的横坐标,非零元素的纵坐标,我们是预先知道这些元素的个数的,所以创建然后分配大小.

    int *h_cooRowIndA = NULL; //存储非零元素的纵坐标
    int *h_coo_csrColIndA = NULL;  //存储非零元素的横坐标
    float *h_coo_csrValA = NULL;  //存储非零元素的值
    h_coo_csrValA = (float *)malloc(sizeof(float)*n*5);  //分配n*5个元素,这也是我们的稀疏矩阵的非零元素的个数
    h_cooRowIndA = (int *)malloc(sizeof(int)*n*5); 
    h_coo_csrColIndA = (int *)malloc(sizeof(int)*n*5); 

    解释下我的数据,是带状稀疏矩阵,总共有5个带,所以我的非零元素有 n*5 个


    然后,我们需要对分配的内存空间进行赋值了,当然了这个值根据你需要解决的问题来决定.但是赋值方法可以共享给大家,我这里是这样赋值的


    下面就是coo转换为csr格式了,我提供一个函数给大家(当然cusparse模块有coo2csr的函数,不过那是一个global函数,也就是在显卡上操作数据的函数,需要对cudaMalloc的device数据进行操作,如果是在host分配的数据,只能自己写函数)

    void DeepAnalogy::compress_index(
        const int *Ind, //coo格式的row坐标
        int nnz,  //矩阵总共有多少非零元素?
        int m, //矩阵每一行有几个元素?
        int *Ptr, //返回的csr格式的row坐标
        int base) //下标从0开始还是从1开始?
    {
        int i;
    
        /* initialize everything to zero */
        for(i=0; i<m+1; i++){
            Ptr[i]=0;
        }
        /* count elements in every row */
        Ptr[0]=base;
        for(i=0; i<nnz; i++){
            Ptr[Ind[i]+(1-base)]++;
        }
        /* add all the values */
        for(i=0; i<m; i++){
            Ptr[i+1]+=Ptr[i];
        }
    }

    一个使用的范例如下,这里h_csrRowPtrA需要预先分配好空间,大小就是矩阵的行数+1

    h_csrRowPtrA = (int *)malloc(sizeof(int)*(n+1));
    compress_index(h_cooRowIndA, NonZero_count, n, h_csrRowPtrA, CUSPARSE_INDEX_BASE_ZERO);
    下面,我们将会通过chol分解方式求解稀疏矩阵A*x=B,也可以使用LU或者QR分解,请看samples里的例子,差别不大.

    目前位置,A*x=B方程我们分配好了A,接下来我们为x分配空间,并且输入B的值.

    float *h_bs1 = NULL, *h_xs2 = NULL;
    h_bs1 = (float*)malloc(sizeof(float)*n);
    .....按照自己的需要构建B的值,此部分因人而异,省略.....
    h_xs1 = (float*)malloc(sizeof(float)*n);

    用cpu求解很简单(没错,就是cpu,cuda提供了cpu求解的函数;在矩阵不大的情况下cpu求解反而比gpu求解更快一点),一些必要的初始化,然后一行语句求解:

    cusolverSpHandle_t handle = NULL;
    cusparseHandle_t cusparseHandle = NULL;
    cudaStream_t stream = NULL;
    checkCudaErrors(cusolverSpCreate(&handle));
    checkCudaErrors(cusparseCreate(&cusparseHandle));
    checkCudaErrors(cudaStreamCreate(&stream));
    checkCudaErrors(cusolverSpSetStream(handle, stream));
    checkCudaErrors(cusparseSetStream(cusparseHandle, stream));
    checkCudaErrors(cusolverSpScsrlsvcholHost(
    	handle, n, NonZero_count,
    	descrA, h_coo_csrValA, h_csrRowPtrA, h_coo_csrColIndA,
    	h_bs1, tol, reorder, h_xs1, &singularity));

    用gpu的话,就麻烦一点,需要拷贝数据,然后求解,最后拷贝回来.

    以上所说的求解是只求解一次,有时候我们有多个b值,需要求解多次A*x=b,这时候每次都要分解A就不应该了.此时我们可以先分解A

    //compute A = L*L^T
    checkCudaErrors(cusolverSpScsrcholFactor(handle, n, NonZero_count,
    	descrA, d_csrValA, d_csrRowPtrA, d_csrColIndA, d_info, buffer_gpu));

    然后对多个b进行求解

    //solve A*x = b
    checkCudaErrors(cusolverSpScsrcholSolve(handle, n, d_b1, d_x1, d_info, buffer_gpu));
    checkCudaErrors(cusolverSpScsrcholSolve(handle, n, d_b2, d_x2, d_info, buffer_gpu));
    checkCudaErrors(cusolverSpScsrcholSolve(handle, n, d_b3, d_x3, d_info, buffer_gpu));

    这样可以减少不必要的计算,samples里面的cuSolverSp_LowlevelCholesky介绍了这部分代码.

    展示下各个部分运行时间,单位是秒


    最后附上eigen求解A*x = b的方法


    展开全文
  • 高质量学习资源免费获取,专注但不限于【Linux】【C/...函数功能:生成稀疏矩阵使用方法 :S = sparse(A)将矩阵A转化为稀疏矩阵形式,即矩阵A中任何0元素被去除,非零元素及其下标组成矩阵S。如果A本身是稀疏的,sp...

     高质量学习资源免费获取,专注但不限于【Linux】【C/C++/Qt】【FPGA】【数据结构与算法】, 根据多年技术经验纯【原创】,纯【干货】,分享【技术心得】,力求【授人以鱼,更授人以渔】。

    函数功能:生成稀疏矩阵 

    使用方法
    S = sparse(A) 
    将矩阵A转化为稀疏矩阵形式,即矩阵A中任何0元素被去除,非零元素及其下标组成矩阵S。
    如果A本身是稀疏的,sparse(S)返回S。 
    S = sparse(i,j,s,m,n,nzmax) 
    由向量i,j,s生成一个m*n的含有nzmax个非零元素的稀疏矩阵S,并且有 S(i(k),j(k)) = s(k)。
    向量 i,j 和 s 有相同的长度。对应对向量i和j的值,s 中任何零元素将被忽略。
    s 中在 i 和 j 处的重复值将被叠加。 
    注意:如果i或j任意一个大于最大整数值范围,2^31-1, 稀疏矩阵不能被创建。 

    S = sparse(i,j,s,m,n) 
    用 nzmax = length(s) 
    S = sparse(i,j,s) 
    使m = max(i) 和 n = max(j),在s中零元素被移除前计算最大值,[i j s]中其中一行可能为[m n 0]。
    S = sparse(m,n) 
    sparse([],[],[],m,n,0)的缩写,生成一个m*n的所有元素都是0的稀疏矩阵。 


    备注:
    MATLAB中所有内置的算术,逻辑和索引操作都可以应用到稀疏矩阵或混合于稀疏和全矩阵上。
    稀疏矩阵的操作返回稀疏矩阵,全矩阵的操作返回权矩阵。 
    在大多数情况下,稀疏和全矩阵的混合操作返回全矩阵,例外的一种情况是混合操作的结果在结构上稀疏,例如,A.*S至少和矩阵S一样稀疏。 

    应用举例:
    S = sparse(1:n,1:n,1) 生成一个n*n的单位稀疏矩阵,和S = sparse(eye(n,n))有相同的结果,但是如果它的元素大部分是零元素的情况下也会暂时性的生成n*n的全矩阵。

    B = sparse(10000,10000,pi) 可能不是非常有用的,但是它是能运行和允许的,它生成一个10000*10000的仅仅包含一个非零原色的矩阵,不要用full(B),因为这需要800兆储存单元。 

    分析和重组一个稀疏矩阵: 
    [i,j,s] = find(S); 
    [m,n] = size(S); 
    S = sparse(i,j,s,m,n); 

    如果最后一行和最后一列是非零项,有下面: 
    [i,j,s] = find(S); 
    S = sparse(i,j,s);

     

    MATLAB中的full matrix和sparse matrix

    对full matrix和sparse matrix的理解:其实这只是matlab中存储稀疏矩阵的两种方法。

     

    MATLAB函数sparse简介
    函数功能:
    这个函数与稀疏矩阵有关。
    先说MATLAB中两个概念:full storage organization(对应于full matrix)和sparse storage organization(对应于sparse matrix)。
    而要说明这两个概念,需要介绍稀疏矩阵的概念。
    一般意义上的稀疏矩阵,就是看起来很松散的,也就是说,在这个矩阵中,绝大多数元素是零。例如:
    0, 0, 0, 0;
    0, 0, 1, 0;
    0, 0, 0, 0;
    0, 1, 0, 2;


    计算机存储稀疏矩阵可以有两种思路:
    1.按照存储一个普通矩阵一样存储一个稀疏矩阵,比如上面这个稀疏矩阵中总共十六个元素(三个非零元素),把这些元素全部放入存储空间中。这种存储方式,在matlab就叫做full storage organization。
    2.只存储非零元素,那么怎么存储呢?
    (4,2)        1
    (2,3)        1
    (4,4)        2
    看出来了吧, 只存储非零元素在稀疏矩阵中的位置和值。比如,上面所举的这个例子,值为2的项在第4行第4列,那么我们就只需要存储这一非零项在稀疏矩阵中的“坐标”(4,4)和这一非零项的值2。在MATLAB中,这种存储方式就叫做sparse storage organization。虽然,这样要多存储一组坐标,但如果稀疏矩阵中非零元素非常少,以这种存储方式存储稀疏矩阵反而节省了内存空间。


    为什么matlab中会同时存在这两种存储方式呢?
    第一种方式, 更加直观,进行矩阵运算时(比如稀疏矩阵的乘法),算法简单易实现。
    而第二种方式,虽然有时可以节省存储数据时占用的存储空间,但进行运算时需要专门的算法实现(使用C语言编写过稀疏矩阵乘法的同学应该能体会到)。


    sparse
    函数的功能就是把以第一种存储形式存储的稀疏矩阵转换成第二种形式存储(其实这个函数更重要的功能是构建稀疏矩阵,这里不再讨论)。对应的函数为full,即把以第二种方式存储的稀疏矩阵转换成第一种方式存储。
    在MATLAB中,存储一个稀疏矩阵有两种方法。
    语法格式:
    S = sparse(A)
    S = sparse(i,j,s,m,n,nzmax)
    S = sparse(i,j,s,m,n)
    S = sparse(i,j,s)
    S = sparse(m,n)
    各种语法格式详见MATLAB帮助文档。
    相关函数:full、issparse


    程序示例
    >> A = [0, 0, 0, 0;
    0, 0, 1, 0;
    0, 0, 0, 0;
    0, 1, 0, 2];
    >> sparse(A)
    ans =
       (4,2)        1
       (2,3)        1
       (4,4)        2

    当然sparse函数还可以通过一定规则构造稀疏矩阵,这里就不多说了。

    展开全文
  • Java实现稀疏矩阵

    2019-09-05 19:58:00
    笔者最近在学习数据结构与算法,现在我想总结一下稀疏矩阵的Java实现。 一、什么是稀疏矩阵 自我理解:我们有一些数据中,有效数据占据所有数据的比例小,这个时候,用一个较大的存储空间存储这部分数据会浪费空间...

    笔者最近在学习数据结构与算法,现在我想总结一下稀疏矩阵的Java实现。

    一、什么是稀疏矩阵

    自我理解:我们有一些数据中,有效数据占据所有数据的比例小,这个时候,用一个较大的存储空间存储这部分数据会浪费空间,这部分有效数据可以进行“压缩”,压缩成一个稀疏矩阵。

    假设我们定义了一个11×11的二维数组(棋盘),棋盘里面的没有子的地方为 “0”,而黑子为1,篮子为2。能看到,里面的有子的地方特别少,通过线性代数的学习,我们知道,在线代中,有一个叫做稀疏矩阵的数学模型,在这里,我们可以用到这个模型进行“数据压缩”。

    二、压缩算法

    具体算法请看代码:

    package com.yc.sparseArray;
    
    import java.io.*;
    
    /**
     * @author shkstart
     * @create 2019-08-29 19:42
     */
    public class SparseArray {
        public static void main(String[] args) throws IOException {
            //创建原始二位数组
            //0表示 没有棋子 , 1表示黑子,2表示篮子
            int chessArr1[][] = new int[11][11];
            chessArr1[1][2] = 1;
            chessArr1[2][3] = 2;
            chessArr1[4][5] = 2;
            //输出原始二位数组
            System.out.println("原始的二维数组:");
            for (int[] row:chessArr1){
                for(int data:row){
                    System.out.printf("%d\t",data);
                }
                System.out.println();
            }
    
            //将二维数组转为稀疏数组
            //遍历二维数组,得到非零数据的个数
            int sum = 0;
            for (int i = 0; i < chessArr1.length; i++) {
                for (int j = 0; j < chessArr1.length; j++) {
                    if(chessArr1[i][j] != 0){
                        sum++;
                    }
                }
            }
    
            //2.创建对应的稀疏数组
            int sparseArr[][] = new int[sum+1][3];
            //给稀疏数组赋值
            sparseArr[0][0] = chessArr1.length;
            sparseArr[0][1] = chessArr1.length;
            sparseArr[0][2] = sum;
    
            //遍历二维数组,将非零的值存放到稀疏数组
            int count = 0;  //count用于记录第几个非0数据
            for (int i = 0; i < chessArr1.length; i++) {
                for (int j = 0; j < chessArr1.length; j++) {
                    if(chessArr1[i][j] != 0){
                        count ++;
                        sparseArr[count][0] = i;
                        sparseArr[count][1] = j;
                        sparseArr[count][2] = chessArr1[i][j];
                    }
                }
            }
    
            //这里的  输出流 append属性一定不能设置为true,不然就是追加到文件中了
            OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d:\\map.data",false));
            BufferedWriter bw = new BufferedWriter(osw);
            for (int[] ints : sparseArr) {
                bw.write(ints[0]+ " " +ints[1]+ " " +ints[2]);
                bw.newLine();
            }
            //重要的一个部分,关闭流,养成好的习惯
            bw.flush();
            bw.close();
    
            //输出稀疏数组的形式
            System.out.println();
            System.out.println("得到的稀疏数组为:");
            InputStreamReader isr = new InputStreamReader(new FileInputStream("d:\\map.data"));
            BufferedReader br = new BufferedReader(isr);
    
            for (int i = 0; i < sparseArr.length; i++) {
                System.out.println(sparseArr[i][0] + "\t" +
                        sparseArr[i][1] + "\t" + sparseArr[i][2]);
            }
    
            //将稀疏数组恢复成原始二维数组
            /*
                先读取稀疏数组第一行,建立数组
             */
            String first = br.readLine();
            String[] firstLine = first.split(" ");
            int chessArr2[][] = new int[Integer.parseInt(firstLine[0])][Integer.parseInt(firstLine[1])];
    
            //在读取
            String next = null;
            while((next=br.readLine()) != null){
                String[] nextLine = next.split(" ");
                chessArr2[Integer.parseInt(nextLine[0])][Integer.parseInt(nextLine[1])] = Integer.parseInt(nextLine[2]);
            }
            //重要的一个部分,关闭流,养成好的习惯
            isr.close();
            br.close();
    
            System.out.println();
            System.out.println("还原的二维数组:");
            //恢复后的二维数组;
            for (int[] row:chessArr2){
                for(int data:row){
                    System.out.printf("%d\t",data);
                }
                System.out.println();
            }
        }
    }
    

    1).我先创建了一个二维数组,在里面存入了几个棋子。

    2).遍历二维数组,得到了棋子的个数

    3).根据数组的行列,创建相应的稀疏数组。将相应的棋子存入稀疏数组。(压缩)

    4).输入流写入文件,这里写入的时候只能写入到除C盘外的其他磁盘,算是一个小坑。不能通过追加的方式写入!!!第一次运行会出现空指针异常,之后运行会出现数组下标越界的异常!!!!巨坑。

    5).输入流读取文件,通过字符串拆分第一行,创建数组。通过读取其他行,给相应的棋子赋值。(解压缩)

    三、总结

    1).输入输出流不是很熟悉,导致写文件写入读取时花费时间比较多。

    2).debug能力要加强,顺带说一句,intellij的debug真好用,之前用eclipse的debug没那么顺手。

     

    展开全文
  • SciPy教程 - 稀疏矩阵库scipy.sparse

    万次阅读 多人点赞 2014-12-06 00:15:33
    http://blog.csdn.net/pipisorry/article/details/41762945 sparse模块的官方document:... 一、sparse matrix稀疏矩阵不同的存储形式在sparse模块中对应如下 bsr_matrix(arg1[, sh
  • C++实现稀疏矩阵的压缩存储

    千次阅读 2017-04-23 15:12:03
    什么是稀疏矩阵呢,就是在M*N的矩阵中,有效值的个数远小于无效值的个数,并且这些数据的分布没有规律。在压缩存储稀疏矩阵的时候我们只存储极少数的有效数据。我们在这里使用三元组存储每一个有效数据,三元组按原...
  • Eigen教程3 - 稀疏矩阵操作

    万次阅读 多人点赞 2017-01-20 15:11:12
    稀疏矩阵操作操作和求解稀疏问题需要的模块: * SparseCore * SparseMatrix 和 SparseVector 类,基本线性代数(包括三角求解器) * SparseCholesky * 稀疏LLT和LDLTCholesky分解,解决稀疏正定问题。 * ...
  • 压缩感知进阶——有关稀疏矩阵
  • 前段时间遇到一些稀疏矩阵的问题,主要是求解大型的非齐次线性方程组:Ax = b, 其中 A是一个大型的稀疏矩阵,可能有上万或十万阶,根据A的特点可能有下面一些求解方法: 1. A 是一个对称正定矩阵,可以用Cholesky...
  • 学过线性代数的同学一定对矩阵不陌生,因为线性代数就是一门关于矩阵的学科。 程序设计中有一种储存数据的方式是二维数组,而二维数组本质上就是矩阵。但是,假如我们想要用二维数组去储存一个大规模的矩阵并进行...
  • 一、稀疏矩阵的定义  对于那些零元素数目远远多于非零元素数目,并且非零元素的分布没有规律的矩阵称为稀疏矩阵(sparse)。  人们无法给出稀疏矩阵的确切定义,一般都只是凭个人的直觉来理解这个概念,即矩阵...
  • 大规模稀疏矩阵求逆

    万次阅读 2014-09-09 16:27:52
    1.全阶矩阵A的求逆运算inv(A) 和稀疏矩阵B(阶数和a一样) 的求逆运算inv(B)是不是采取一样的方法啊?也就是说他们的 计算量是不是一样的啊?不会因为是稀疏矩阵就采取特殊的 方法来处理求逆吧? 我电脑内存...
  • 摘要:本文为大家带来线性规划的稀疏矩阵存储和数据预处理。
  • 蓝桥杯之算法很美课程第四章习题 稀疏矩阵乘积 题目描述: 给定两个N × N的稀疏矩阵A和B,其中矩阵A有P个元素非0,矩阵B有Q个元素非0。请计算两个矩阵的乘积C = A × B并且输出C中所有非0的元素。 输入 第一行包含...
  • 问题:求解Ax=b的,其中,A为大型稀疏矩阵,长和宽分别为1500^2。 一般思路: (1)A为对称正定矩阵,对A使用cholesky分解。 (2)A为对称不定矩阵,使用LDL‘分解,即: PAP'=LDL' 其中,L为单位下三角矩阵...
  • 稀疏矩阵线性解析库SPOOLES的简单应用烤鱼片(@eii.dlmu)cleverysm@163.com SPOOLES的...顾名思义,就是可以用来解稀疏矩阵为参数的线性方程组的数学函数库。所谓面向对象是指的应用了面向对象的封装思想,但实际上S
  • 高阶稀疏矩阵的迭代求解方法

    千次阅读 2019-11-24 21:11:09
    对于特定的矩阵,若该矩阵恰好为方阵,且该nnn阶矩阵含有nnn个不同的特征值或者该矩阵的nnn个特征向量线性无关。则对该矩阵可以采取EVD分解。 但是对于更一般的情况,我们需要将特征分解推广到奇异值分解(SVD)。 ...
  • 稀疏矩阵与非稀疏矩阵的转换 矩阵中非零元素的个数远远小于矩阵元素的总数),并且非零元素的分布没有规律,则称该矩阵为稀疏矩阵(sparse matrix)。 二维数组Amn中有N个非零元素,若N<<m*n(N/m*n<=0.2...
  • 好久没更新了,肚子里也没什么货,就算python稀疏矩阵的最后一篇吧。之前的路飞的哥哥:多体物理python入门——Ising模型和稀疏矩阵​zhuanlan.zhihu.com计算了本征值,也就是平衡态问题。这次是动力学演化的演示...
  • Ubuntu下使用cholmod求解稀疏矩阵

    千次阅读 2010-06-30 14:55:00
    网格的数据结构可以使用openmesh,现在最难的就是数值计算的部分,在windows下我使用了cholmod(不了解的可以google下什么是cholmod)作为稀疏矩阵运算的库,所以理所应当在linux首选肯定也是它。下面就简单说一下...
  • 稀疏矩阵存储格式总结+存储效率对比:COO,CSR,DIA,ELL,HYB 时间 2015-02-04 23:05:00 博客园-原创精华区 原文 http://www.cnblogs.com/xbinworld/p/4273506.html 主题 矩阵 Dia 稀疏矩阵是指矩阵...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,478
精华内容 4,191
关键字:

解稀疏矩阵时间