稀疏矩阵的行压缩存储(CRS)

合集下载

稀疏矩阵的压缩存储

稀疏矩阵的压缩存储

稀疏矩阵的压缩存储稀疏矩阵的压缩存储:实现稀疏矩阵压缩存储,并实现矩阵转置和求和。

输⼊矩阵时,⾸先需要输⼊⾮零元素的个数,然后分别输⼊矩阵的⾏号,列号和值。

输完2个矩阵后,⾃动进⾏计算第⼀个矩阵的转置以及两个矩阵的和。

例如:输⼊如下:100 90 5 //矩阵的⾏数为100,列数为90,共5个⾮零元素。

1 10 100 //a(1,10)=10050 60 200//a(50,60)=20050 80 100//a(50,80)=10060 60 200//a(60,60)=20099 89 10//a(99,89)=10100 90 2 //矩阵b的⾏数为100,列数为90,共2个⾮零元素。

1 1 10 //b(1,1)=1050 60 -200//b(50,60)=-200#include <iostream>using namespace std;struct Triple { //三元组int Row, Col; //⾮零元素⾏号/列号int value; //⾮零元素的值void operator = (Triple & R) //赋值{Row = R.Row; Col = R.Col; value = R.value;}};class SparseMatrix {private: //a = a*bint Rows, Cols, Terms; //⾏/列/⾮零元素数Triple *smArray; //三元组表public:SparseMatrix(int maxSize=100); //构造函数void Transpose(SparseMatrix& B); //转置SparseMatrix Add(SparseMatrix& b); //a = a+bfriend ostream& operator << (ostream& out, SparseMatrix &M);friend istream& operator >> (istream& in, SparseMatrix &M);};SparseMatrix::SparseMatrix(int maxSize){Terms = maxSize;smArray = new Triple[maxSize];Rows = Cols = 0;};void SparseMatrix::Transpose(SparseMatrix & B){int *rowSize = new int[Cols]; //列元素数数组int *rowStart = new int[Cols]; //转置位置数组B.Rows = Cols; B.Cols = Rows;B.Terms = Terms;if (Terms > 0) {int i, j;for (i = 0; i < Cols; i++) rowSize[i] = 0;for (i = 0; i < Terms; i++)rowSize[smArray[i].Col]++;rowStart[0] = 0;for (i = 1; i < Cols; i++)rowStart[i] = rowStart[i - 1] + rowSize[i - 1];for (i = 0; i < Terms; i++) {j = rowStart[smArray[i].Col];B.smArray[j].Row = smArray[i].Col;B.smArray[j].Col = smArray[i].Row;B.smArray[j].value = smArray[i].value;rowStart[smArray[i].Col]++;}}delete[] rowSize; delete[] rowStart;}SparseMatrix SparseMatrix::Add(SparseMatrix & b){SparseMatrix res;int i = 0, j = 0, index_a, index_b;res.Terms = 0;while (i < Terms&&j < b.Terms) {index_a = Cols * smArray[i].Row + smArray[i].Col;index_b = Cols * b.smArray[j].Row + b.smArray[j].Col;if (index_a < index_b) {res.smArray[res.Terms] = smArray[i];i++;}else if (index_a > index_b) {res.smArray[res.Terms] = b.smArray[j];j++;}else{int vv= smArray[i].value + b.smArray[j].value;if (vv != 0) {res.smArray[res.Terms] = smArray[i];res.smArray[res.Terms].value = vv;}if (vv == 0) {res.Terms--;}i++; j++;}res.Terms++;}for (; i < Terms; i++) {res.smArray[res.Terms] = smArray[i];res.Terms++;}for (; j < b.Terms; j++) {res.smArray[res.Terms] = b.smArray[j];res.Terms++;}return res;}ostream & operator<<(ostream & out, SparseMatrix & M){for (int i = 0; i < M.Terms; i++) {out << M.smArray[i].Row << " " << M.smArray[i].Col << " " << M.smArray[i].value << endl; }return out;// TODO: 在此处插⼊ return 语句}istream & operator>>(istream & in, SparseMatrix & M){in >> M.Rows >> M.Cols >> M.Terms;for (int i = 0; i < M.Terms; i++) {in >> M.smArray[i].Row >> M.smArray[i].Col >> M.smArray[i].value;}return in;// TODO: 在此处插⼊ return 语句}int main(){SparseMatrix s,s2,s3,s4;cin >> s;cin >> s3;s.Transpose(s2);cout << "The transformed matrix is:" << endl;cout << s2;s4=s.Add(s3);cout << "The added matrix is:" << endl;cout << s4;return 0;}。

稀疏矩阵的压缩存储方法与应用场景

稀疏矩阵的压缩存储方法与应用场景

稀疏矩阵的压缩存储方法与应用场景稀疏矩阵指的是矩阵中绝大部分元素为0的情况下,只保存非零元素及其对应的坐标的一种存储方式。

相比于一般的矩阵存储方式,稀疏矩阵的压缩存储方法可以有效节省存储空间,并提高运算效率。

本文将介绍一些常见的稀疏矩阵的压缩存储方法以及其应用场景。

一、行压缩存储法(CRS)行压缩存储法(CRS,Compressed Row Storage)是一种经典的稀疏矩阵压缩存储方法。

在CRS中,矩阵的非零元素按行优先的顺序存储,并记录每行非零元素的开始位置及其列号。

由于CRS只存储非零元素及其对应的行列坐标,因此可以大大减少存储空间。

CRS适用于行操作较多的场景,比如图像处理、有限元分析等。

在这些场景下,常常需要对稀疏矩阵进行行操作,例如行相加、行相减、行乘以常数等。

CRS可以通过迅速定位非零元素所在的行并对其进行操作,提高计算效率。

二、列压缩存储法(CCS)列压缩存储法(CCS,Compressed Column Storage)是另一种常见的稀疏矩阵压缩存储方法。

在CCS中,矩阵的非零元素按列优先的顺序存储,并记录每列非零元素的开始位置及其行号。

与CRS相比,CCS可以更加高效地进行列操作,如列相加、列相减、列乘以常数等。

CCS常用于图论、网络分析等领域。

例如,在图论中,常常需要对邻接矩阵进行列操作,如计算图的邻接节点、计算图的度数等。

CCS 可以快速对非零元素所在的列进行操作,提高计算效率。

三、对角线压缩存储法(Diagonal Storage)对角线压缩存储法是一种适用于具有特殊结构的稀疏矩阵的压缩存储方法。

在对角线压缩存储法中,只存储矩阵的非零主对角线元素以及非零副对角线元素,其余元素均为0。

通过存储非零对角线元素及其位置,可以进一步减少存储空间。

对角线压缩存储法适用于具有对称或反对称性质的矩阵。

在数值计算、网络传输等领域,经常需要处理对称或反对称矩阵。

对角线压缩存储法可以有效存储这类特殊结构的矩阵,并提高运算效率。

稀疏矩阵 存储方法

稀疏矩阵 存储方法

稀疏矩阵存储方法稀疏矩阵是指矩阵中绝大部分元素为0的矩阵。

在实际问题中,往往会遇到大规模的稀疏矩阵,对于这种矩阵的存储需要考虑如何高效地使用内存空间。

下面将介绍几种常见的稀疏矩阵存储方法。

1. 链接存储法:在这种方法中,我们可以使用一个链表来存储非零元素的位置和值。

具体做法是每个非零元素都使用一个结点来表示,结点中包括行、列和对应的元素值。

这样,对于每个非零元素,我们只需要包含它的位置信息和值即可,并且可以通过遍历链表来获取所有的非零元素。

2. 顺序表存储法:在顺序表存储法中,我们使用两个数组来保存非零元素的位置和值。

一个一维数组存储所有非零元素的位置,另一个一维数组存储对应的值。

在这种方法中,我们需要额外的辅助空间来保存非零元素的位置信息,但是对于获取元素值的操作会更加高效,因为我们可以直接通过索引来访问元素。

3. 排序顺序表存储法:与顺序表存储法类似,不同之处在于我们需要对非零元素的位置进行排序。

一种常见的排序方法是按照行优先顺序进行排序。

这样做的好处是在矩阵乘法运算等操作中,我们可以利用行优先的顺序,减少对非零元素的访问次数,从而提高运算效率。

4. 压缩存储法:在压缩存储法中,我们通过记录每行非零元素的数量以及每个非零元素的位置和值来表示稀疏矩阵。

具体做法是使用三个一维数组分别存储每行非零元素的数量、非零元素的列索引和对应的值。

这种方法可以极大地节省存储空间,并且对于访问非零元素的操作也很高效。

以上介绍的是几种常见的稀疏矩阵存储方法,它们各自的特点和适用场景也不同。

选择何种存储方法应该根据具体应用的需求来确定。

例如,在求解线性方程组或稀疏矩阵乘法运算时,可以选择压缩存储法;而在矩阵的插入、删除操作较为频繁时,可以考虑使用链表存储法。

总之,在实际应用中,我们需要根据问题的特点和存储空间的要求,综合考虑各种因素来选择最合适的存储方法。

稀疏矩阵csr存储规则

稀疏矩阵csr存储规则

稀疏矩阵csr存储规则
稀疏矩阵CSR存储规则。

稀疏矩阵是指大部分元素为零的矩阵,对于这种矩阵,传统的
存储方式会造成大量的存储空间浪费。

因此,稀疏矩阵CSR (Compressed Sparse Row)存储规则应运而生。

在CSR存储规则中,矩阵被分为三个数组来存储,值数组(values),列索引数组(col_index)和行偏移数组(row_ptr)。

这种存储方式可以大大减少存储空间的浪费,提高了矩阵的存储效率。

具体来说,值数组存储矩阵中非零元素的值,列索引数组存储
每个非零元素对应的列索引,而行偏移数组存储每一行的第一个非
零元素在值数组中的索引位置。

这样一来,我们可以通过行偏移数
组来确定每一行非零元素的位置,通过列索引数组找到对应的列索引,然后在值数组中找到具体的值。

通过CSR存储规则,我们可以高效地存储和检索稀疏矩阵的数据,减少存储空间的浪费,提高计算效率。

因此,在处理大规模稀
疏矩阵时,CSR存储规则是一种非常有效的存储方式。

总而言之,稀疏矩阵CSR存储规则通过将矩阵分解为值数组、列索引数组和行偏移数组,实现了对稀疏矩阵高效存储和检索的目的,为处理大规模稀疏矩阵提供了重要的技术支持。

稀疏数据处理方法

稀疏数据处理方法

稀疏数据处理方法
稀疏数据指的是在大型数据集中具有很少非零元素的数据。

这种数据在现实世界中很常见,比如社交媒体、物联网和生物信息学等领域。

由于数据的稀疏性,传统的数据处理方法难以处理,因此需要一些特殊的处理技术来处理这种数据。

1. 稀疏数据表示方法
在稀疏数据处理中,最常用的表示方法是稀疏矩阵。

稀疏矩阵是一个矩阵,其中大多数元素都是零。

为了节省空间和计算资源,只需要存储非零元素和它们的位置。

通常情况下,非零元素的数量远远少于矩阵中所有的元素。

2. 稀疏数据的压缩
稀疏数据的压缩是减少存储空间和计算资源的有效方法。

最常用的压缩方法是压缩稀疏行(CSR)和压缩稀疏列(CSC)。

在CSR中,矩阵的非零元素按行存储,每一行存储一个非零元素的位置和值。

在CSC中,矩阵的非零元素按列存储,每一列存储一个非零元素的位置和值。

这种压缩方法可以大幅减少存储空间的占用。

3. 稀疏数据的算法
由于稀疏数据的特殊性质,传统的数据处理算法难以直接适用于稀疏数据。

因此,需要一些特殊的算法来处理稀疏数据。

最常用的算法包括稀疏矩阵乘法、岭回归和最小角回归等。

稀疏矩阵乘法是在稀疏矩阵上进行的一种特殊乘法运算。

它的思想是利用稀疏矩阵的特殊性质,将运算速度提高到O(NlogN)或O(N)。

岭回归是一种用于处理线性回归的方法。

它通过加入一个惩罚因子来解决过拟合的问题,同时利用稀疏矩阵的特殊性质来加速计算。

最小角回归是一种用于处理多元线性回归的方法。

它可以处理大规模的稀疏数据,并具有很强的稳定性和精度。

稀疏矩阵及其压缩存储方法

稀疏矩阵及其压缩存储方法

稀疏矩阵及其压缩存储方法1.基本概念稀疏矩阵(SparseMatrix):是矩阵中的一种特殊情况,其非零元素的个数远小于零元素的个数。

设m行n列的矩阵含t个非零元素,则称以二维数组表示高阶的稀疏矩阵时,会产生零值元素占的空间很大且进行了很多和零值的运算的问题。

特殊矩阵:值相同的元素或0元素在矩阵中的分布有一定的规律。

如下三角阵、三对角阵、稀疏矩阵。

压缩存储:为多个值相同的元素只分配一个存储空间;对0元素不分配空间。

目的是节省大量存储空间。

n x n的矩阵一般需要n2个存储单元,当为对称矩阵时需要n(1+n)/2个单元。

2.三元组顺序表——压缩存储稀疏矩阵方法之一(顺序存储结构)三元组顺序表又称有序的双下标法,对矩阵中的每个非零元素用三个域分别表示其所在的行号、列号和元素值。

它的特点是,非零元在表中按行序有序存储,因此便于进行依行顺序处理的矩阵运算。

当矩阵中的非0元素少于1/3时即可节省存储空间。

(1)稀疏矩阵的三元组顺序表存储表示方法#define MAXSIZE 12500 // 假设非零元个数的最大值为12500typedef struct {int i, j; // 该非零元的行下标和列下标ElemType e; //非零元素的值} Triple; // 三元组类型typedef union { //共用体Triple data[MAXSIZE + 1]; // 非零元三元组表,data[0]未用int mu, nu, tu; // 矩阵的行数、列数和非零元个数} TSMatrix; // 稀疏矩阵类型(2)求转置矩阵的操作◆用常规的二维数组表示时的算法for (col=1; col<=nu; ++col)for (row=1; row<=mu; ++row)T[col][row] = M[row][col];其时间复杂度为: O(mu×nu)◆用三元组顺序表表示时的快速转置算法Status FastTransposeSMatrix(TSMatrix M, TSMatrix &T) {// 采用三元组顺序表存储表示,求稀疏矩阵M的转置矩阵TT.mu = M.nu; T.nu = M.mu; T.tu = M.tu;if (T.tu) {for (col=1; col<=M.nu; ++col) num[col] = 0;for (t=1; t<=M.tu; ++t) ++num[M.data[t].j];// 求M 中每一列所含非零元的个数cpot[1] = 1;for (col=2; col<=M.nu; ++col) cpot[col] = cpot[col-1] + num[col-1];// 求M 中每一列的第一个非零元在b.data 中的序号for (p=1; p<=M.tu; ++p) { // 转置矩阵元素col = M.data[p].j; q = cpot[col];T.data[q].i =M.data[p].j; T.data[q].j =M.data[p].i;T.data[q].e =M.data[p].e; ++cpot[col];} // for} // ifreturn OK;} // FastTransposeSMatrix其时间复杂度为: O(mu +nu)3.行逻辑联接的顺序表——压缩存储稀疏矩阵方法之二(链接存储结构)行逻辑联接的顺序表:稀疏矩阵中为了随机存取任意一行的非0元素,需要知道每一行的第一个非0元素在三元组表中的位置,因此将上述快速转置算法中指示行信息的辅助数组cpot 固定在稀疏矩阵的存储结构中,让每一行对应一个单链表,每个单链表都有一个表头指针,这种“带行链接信息”的三元组表即称为行逻辑联接的顺序表。

csr读取稀疏矩阵

csr读取稀疏矩阵

csr读取稀疏矩阵1.引言1.1 概述概述部分的内容可以包括CSR格式和稀疏矩阵的基本概念和定义。

概述:CSR (Compressed Sparse Row) 格式是一种常用的稀疏矩阵存储格式,它通过压缩稀疏矩阵的行索引、列索引和非零元素值的方式,实现了对大规模稀疏矩阵的高效存储和读取。

稀疏矩阵是指矩阵中大部分元素为零的矩阵,与之相对的是稠密矩阵,即大部分元素都不为零。

在很多应用领域,如图像处理、机器学习和科学计算等,稀疏矩阵的表示和处理是非常重要的。

CSR格式最早由Yale大学的George K. Francis教授在1972年提出,在数值计算和稀疏矩阵计算领域得到了广泛应用。

相比于其他常见的稀疏矩阵存储格式,如COO (Coordinate) 格式和CSC (Compressed Sparse Column) 格式,CSR格式具有更高的存储效率和读取速度。

它通过将矩阵的非零元素按行顺序存储,并将每行的非零元素的列索引和值分别保存在两个数组中,大大节省了存储空间。

此外,CSR格式还支持快速的稀疏矩阵向量乘法等操作,是许多线性代数计算中的重要基础。

本文将介绍CSR格式在读取稀疏矩阵中的应用。

首先,我们将详细介绍CSR格式的原理和数据结构,并对其进行比较分析,了解其优势和不足之处。

然后,我们将探讨稀疏矩阵的定义和特点,从理论上认识稀疏矩阵的结构和特性,为后续的稀疏矩阵读取提供基础。

最后,我们将在结论部分总结CSR格式在读取稀疏矩阵中的优势和应用场景。

通过本文的阅读,读者将能够全面了解CSR格式在读取稀疏矩阵中的原理和应用,为进一步的研究和应用提供参考。

希望本文能够对读者在稀疏矩阵的处理和应用中起到一定的帮助和指导作用。

1.2文章结构文章结构是指文章的组织方式和章节的排列顺序。

一个良好的文档结构可以使读者更好地理解文章的主要内容和观点。

本文按照以下结构来组织:1. 引言1.1 概述1.2 文章结构1.3 目的2. 正文2.1 CSR格式介绍2.2 稀疏矩阵的定义和特点3. 结论3.1 CSR格式在读取稀疏矩阵中的应用3.2 总结在引言部分,我们将对文章要介绍的内容进行概述,简要说明CSR格式和稀疏矩阵,以及本文的目的。

稀疏矩阵的压缩存储上

稀疏矩阵的压缩存储上

第3讲 稀疏矩阵压缩存储上——教学讲义稀疏矩阵是指矩阵中大多数元素为零的矩阵。

从直观上讲,当非零元素个数低于总元素的30 %时,这样的矩阵为稀疏矩阵。

如下图所示的矩阵M 、 N 中,非零元素个数均为8个,矩阵元素总数均为6 ×7 =42 ,显然8 /42 <30 %,所以M 、 N 都是稀疏矩阵。

1 稀疏矩阵的三元组表表示法 ( 1 ) 稀疏矩阵的三元组存储表示对于稀疏矩阵的压缩存储,采取只存储非零元素的方法。

由于稀疏矩阵中非零元素aij 的分布没有规律 ,因此,要求在存储非零元素值的同时还必须存储该非零元素在矩阵中所处的行号和列号的位置信息,这就是稀疏矩阵的三元组表表示法。

每个非零元素在一维数组中的表示形式如下图所示。

说明:为处理方便,将稀疏矩阵中非零元素对应的三元组按“行序为主序”用一维结构体数组进行存放,将矩阵的每一行(行由小到大)的全部非零元素的三元组按列号递增存放。

由此得到矩阵M 、 N 的三元组表A 和B 。

如下图所示。

0 12 9 0 0 0 0 0 0 0 0 0 0 0 -3 0 0 0 0 14 0 0 0 24 0 0 0 0 0 18 0 0 0 0 0 15 0 0 -7 0 0 0M=6×7 0 0 -3 0 0 15 12 0 0 0 18 0 9 0 0 24 0 0 00 0 0 0 -7 0 0 0 0 0 0 00 14 0 0 0 00 0 0 0 07×6N= 稀疏矩阵M 和N三元组的结构( 2 )稀疏矩阵三元组表的类型定义 稀疏矩阵三元组表类型定义如下:#define MAXSIZE 1000 /*设非零元素的个数最多为1000*/ typedef struct { int row, col; /*该非零元素的行下标和列下标*/ ElementType e ; /*该非零元素的值*/ }Triple; typedef struct{ Triple data[MAXSIZE+1]; /* 非零元素的三元组表。

稀疏矩阵csr格式

稀疏矩阵csr格式

稀疏矩阵csr格式CSR(Compressed Sparse Row)格式是一种用于表示稀疏矩阵的存储格式。

在 CSR 格式中,矩阵的非零元素以行为主的顺序存储,同时使用两个附加的数组来存储行偏移和列索引信息。

考虑一个稀疏矩阵:在CSR格式中,这个矩阵的非零元素按行主序存储为 [1, 2, 3, 4, 5]。

同时,使用两个附加数组存储行偏移和列索引信息:1. 数值数组(Values Array): values=[1,2,3,4,5]2. 行偏移数组(Row Offsets Array):row_offsets=[0,1,3,5]这表示第一行的非零元素存储在 values[0],第二行的非零元素从 values[1] 开始,第三行的非零元素从 values[3] 开始。

3. 列索引数组(Column Indices Array):col_indices=[0,2,0,1,3]这表示对应于 values 数组中的元素的列索引。

在CSR格式中,对于每个非零元素,只需存储其数值、所在行和所在列的信息,从而节省了存储空间。

在Python中,使用SciPy库可以方便地将矩阵转换为CSR格式:import scipy.sparsematrix = scipy.sparse.csr_matrix([[1, 0, 0, 0],[0, 0, 2, 0],[3, 4, 0, 5]])values = matrix.datarow_offsets = matrix.indptrcol_indices = matrix.indices这样,values、row_offsets和col_indices分别包含了CSR格式所需的数值、行偏移和列索引信息。

Matlab中的稀疏矩阵处理技术介绍

Matlab中的稀疏矩阵处理技术介绍

Matlab中的稀疏矩阵处理技术介绍在数据处理和算法设计中,矩阵是一种非常常见的数据结构。

然而,在实际应用中,很多矩阵是稀疏的,即大部分元素都是0。

对于稀疏矩阵的处理,传统的方法十分低效,会浪费大量的存储空间和计算资源。

为了提高效率,Matlab中提供了一系列的稀疏矩阵处理技术,可以更高效地处理这类特殊的数据结构。

一、稀疏矩阵的定义和表示在介绍具体的处理技术之前,首先需要了解稀疏矩阵的定义和表示方法。

稀疏矩阵是指矩阵中大部分元素都是0的情况。

为了高效地表示这类矩阵,不必存储所有的元素,只需要存储非零元素以及它们的位置信息即可。

在Matlab中,稀疏矩阵可以通过提供非零元素的行列坐标和值来表示。

具体来说,可以使用sparse函数来创建稀疏矩阵,其语法如下:s = sparse(i, j, v, m, n)其中i和j是非零元素的行列坐标,v是非零元素的值,m和n是矩阵的维度。

通过这种方式,可以高效地存储稀疏矩阵,并且能够提供一些便捷的功能和操作。

二、稀疏矩阵的存储结构在计算机内存中,矩阵通常以行优先或者列优先的方式存储。

然而,对于稀疏矩阵来说,这种方式会浪费大量的存储空间,因为大部分的元素都是0。

为了更加高效地存储稀疏矩阵,Matlab中使用了压缩列(CSC)和压缩行(CSR)两种存储结构。

压缩列存储方式将矩阵按列进行存储。

具体来说,将矩阵分成m个列,每个列存储非零元素的行索引和值。

另外,需要一个向量来记录每个列的起始位置和结束位置。

这种存储方式在列操作中效率高,但在行操作中效率较低。

压缩行存储方式将矩阵按行进行存储。

具体来说,将矩阵分成n个行,每个行存储非零元素的列索引和值。

另外,需要一个向量来记录每个行的起始位置和结束位置。

这种存储方式在行操作中效率高,但在列操作中效率较低。

在Matlab中,可以使用full函数将稀疏矩阵转换为普通的密集矩阵,以便于进行一些特殊操作。

但需要注意的是,将稀疏矩阵转换为普通矩阵会消耗大量的存储空间,因此要谨慎使用。

稀疏矩阵的行压缩存储(CRS)

稀疏矩阵的行压缩存储(CRS)
• E.g. col_ind[5] stores the column index of val[5].
– row_ptr array stores the locations in the val array and col_ind array that start a row.
0
1 2 3
4
5 0 1 2 3 4 5
– Using CRS format to store a sparse matrix will save a lot of memory.
Compressed Row Storage
– val array stores the values of the nonzero elements in a row-wise fashion. – col_ind array stores the corresponding column indices of the elements in the val array.
CRS( float[][] matrix){ int i, j, index; //the total number of nonzero in the matrix int totalNonZeros; //get the number of rows and columns mSize = matrix.length;
val //store the matrix in CRS format
x x
...
index index = 0;// point to the next position to store the value for( i=0; i<mSize; i++ ){//each row for( j=0; j<mSize; j++ ){//each column if( matrix[i][j] != 0 ){ //add the value to val val[ index ] = matrix[ i ][ j ]; //record the column index in col_idx col_idx[ index ] = j; index++; } } //update row_ptr row_ptr[ i+1 ] = index; } }//end of CRS( float[][] matrix)

矩阵压缩存储

矩阵压缩存储

矩阵压缩存储矩阵压缩存储是一种用于减少数据存储空间的技术,它通过将稀疏矩阵转换为紧凑的格式来实现。

稀疏矩阵是指其中大部分元素为零的矩阵。

在实际应用中,许多矩阵都具有稀疏性,即只有少数非零元素。

因此,使用矩阵压缩存储可以显著减少存储空间的占用。

一种常用的矩阵压缩存储方法是压缩行存储(Compressed Row Storage,CRS)。

在CRS中,只保存非零元素的值以及它们所在的列索引,而行索引则通过其他方式获得。

具体来说,CRS将矩阵分为三个数组,分别用来存储非零元素的值、非零元素所在的列索引以及行指针。

通过使用矩阵压缩存储,可以有效地减少存储空间的占用。

以一个1000x1000的稀疏矩阵为例,假设其中只有100个非零元素,如果使用普通的二维数组来存储该矩阵,需要占用1000x1000=1000000个存储单元。

而如果使用矩阵压缩存储,只需要存储100个非零元素的值和列索引,以及101个行指针。

显然,矩阵压缩存储可以大幅减少存储空间的使用。

矩阵压缩存储不仅可以减少存储空间的占用,还可以提高计算效率。

在处理稀疏矩阵的运算时,如果使用矩阵压缩存储,可以避免对大量零元素的计算,从而提高运算速度。

此外,由于稀疏矩阵的非零元素较少,矩阵压缩存储还可以减少内存访问的次数,进一步提高运算效率。

除了CRS,还有其他的矩阵压缩存储方法,如压缩列存储(Compressed Column Storage,CCS)和块压缩存储(Block Compressed Storage,BCS)。

这些方法在存储结构上有所不同,但都旨在减少存储空间的占用并提高计算效率。

矩阵压缩存储在许多领域都有广泛的应用。

在图像处理中,图像可以看作是一个二维矩阵,而图像处理算法通常只需要对少数非零元素进行操作。

因此,使用矩阵压缩存储可以大幅减少图像数据的存储空间,并提高图像处理的效率。

在科学计算中,矩阵压缩存储也被广泛应用于线性代数运算、有限元分析等领域。

稀疏矩阵压缩的存储方法

稀疏矩阵压缩的存储方法

稀疏矩阵压缩的存储方法稀疏矩阵是在大多数元素为零的矩阵中只存储非零元素的一种矩阵表示方法。

稀疏矩阵压缩的存储方法旨在减少内存和存储空间的占用,同时保持矩阵的有效性。

以下是一些常见的稀疏矩阵压缩存储方法:1.压缩行存储(Compressed Row Storage,CRS):该方法将矩阵分为三个数组:值数组、列索引数组和行偏移数组。

值数组存储非零元素的值。

列索引数组存储每个非零元素所在的列索引。

行偏移数组存储每一行的第一个非零元素在值数组中的位置。

这种方法适用于稀疏矩阵中非零元素的分布较为均匀的情况。

2.压缩列存储(Compressed Column Storage,CCS):与CRS相似,但它将列作为主要的单位进行压缩。

值数组、行索引数组和列偏移数组分别存储非零元素的值、行索引和每一列的第一个非零元素在值数组中的位置。

这种方法适用于需要按列进行操作的情况。

3.坐标列表(COO):COO方法以三个数组的形式存储稀疏矩阵的非零元素:行索引、列索引和值。

这种方法的优势在于可以方便地添加和删除元素,但对于大型稀疏矩阵可能会浪费大量内存。

4.对角线存储(Diagonal Storage):如果稀疏矩阵是对称的,并且只存储对角线上和它下面的元素,这种存储方法可能非常有效。

只需存储对角线元素和它们的下面的元素,而忽略上面的元素。

5.分层压缩(Hierarchical Storage):对于大型稀疏矩阵,可以将矩阵分成多个较小的块,并使用其他稀疏矩阵压缩方法对每个块进行单独压缩。

这种方法有助于减小每个块的大小,从而提高存储和检索效率。

选择适当的稀疏矩阵压缩方法取决于矩阵的特点、应用需求和存储资源。

不同的方法在内存占用和操作效率方面都有各自的优劣。

根据具体情况,可以选择最适合的方法以最大程度地减小存储空间。

稀疏矩阵csr计算方式

稀疏矩阵csr计算方式

稀疏矩阵csr计算方式
稀疏矩阵是指具有大量零元素的矩阵。

在计算机科学中,稀疏矩阵的存储和计算是非常重要的问题。

其中,CSR (Compressed Sparse Row) 是一种最常用的稀疏矩阵存储格式之一。

CSR 矩阵的计算方式是通过三个数组来表示稀疏矩阵。

这三个数组分别为:
1. 矩阵值数组 (values):用于存储矩阵中非零元素的值;
2. 列标识符数组 (columns):用于存储矩阵中非零元素所在的列的位置;
3. 行偏移数组 (row_ptr):用于存储每一行第一个非零元素在values 数组中的位置。

通过这三个数组,我们可以轻松地实现稀疏矩阵的矩阵乘法、向量乘法等计算操作。

具体地,CSR 矩阵的矩阵乘法计算方式如下:
1. 对于矩阵 A 和矩阵 B,首先将 B 转置为 B';
2. 遍历 A 的每一行,在 row_ptr 数组中找到该行的起始位置和终止位置;
3. 对于该行的每一个非零元素,找到其对应的列标识符和值;
4. 在 B' 中找到该列的起始位置和终止位置;
5. 对于该列的每一个非零元素,找到其对应的行标识符和值;
6. 将该行的值和该列的值相乘并累加到结果矩阵 C 中。

通过以上步骤,即可实现 CSR 矩阵的矩阵乘法计算。

相比于一
般的矩阵乘法计算方式,CSR 矩阵的计算方式能够更加高效地处理稀疏矩阵,从而提高计算速度和效率。

稀疏矩阵的特征

稀疏矩阵的特征

稀疏矩阵的特征稀疏矩阵是一种特殊的矩阵,其中绝大多数元素为零。

稀疏矩阵的特征使得它在很多应用领域中具有重要的作用。

本文将从不同角度探讨稀疏矩阵的特征及其应用。

一、定义稀疏矩阵是指其中大部分元素为零的矩阵。

在稀疏矩阵中,非零元素的个数远小于矩阵中元素的总数。

相对于稠密矩阵,稀疏矩阵可以节省存储空间和计算时间。

二、特征1. 稀疏度高:稀疏矩阵中非零元素的比例很低,通常远小于总元素个数的一半。

这一特征使得稀疏矩阵具有较小的存储需求,节省了存储空间。

2. 压缩性强:由于矩阵中大部分元素为零,可以采用压缩存储的方式来表示稀疏矩阵。

常见的压缩存储方法包括压缩行存储(CSR)、压缩列存储(CSC)等。

3. 计算效率高:稀疏矩阵的计算效率通常高于稠密矩阵。

由于稀疏矩阵中大部分元素为零,很多计算可以被忽略或简化,从而减少了计算量。

4. 结构特征:稀疏矩阵中非零元素的分布往往具有一定的结构特征,例如,矩阵中的非零元素可能分布在对角线附近或集中在某些区域。

这一特征可以被利用来进一步优化稀疏矩阵的存储和计算。

三、应用1. 线性方程组求解:稀疏矩阵在线性方程组求解中有广泛的应用。

由于稀疏矩阵的计算效率高,可以大大加快线性方程组的求解速度。

常用的求解方法包括直接法(如LU分解)和迭代法(如共轭梯度法)等。

2. 图像处理:图像通常可以表示为一个二维的稀疏矩阵,其中像素值作为矩阵的元素。

稀疏矩阵的特征使得其在图像处理中具有重要的应用,例如图像压缩、边缘检测等。

3. 网络分析:在网络分析中,稀疏矩阵常用于表示网络中的连接关系。

通过对稀疏矩阵的分析,可以揭示网络的结构和特性,例如社交网络中的社区发现、推荐系统中的用户相似度计算等。

4. 自然语言处理:在自然语言处理中,稀疏矩阵可以用于表示文本的词频矩阵或TF-IDF矩阵。

通过对稀疏矩阵的处理,可以实现词汇聚类、主题模型等应用。

稀疏矩阵具有稀疏度高、压缩性强、计算效率高和结构特征明显等特点。

稀疏矩阵压缩存储

稀疏矩阵压缩存储

稀疏矩阵压缩存储介绍稀疏矩阵是指矩阵中大部分元素为0的矩阵。

由于稀疏矩阵中存在着大量无用的0元素,传统的存储方法会带来较大的存储空间浪费。

稀疏矩阵压缩存储技术就是通过一些有效的方法来压缩存储稀疏矩阵,减少存储空间的占用。

传统存储方法传统的存储方法是将稀疏矩阵直接以二维数组的形式存储,其中包含了大量的0元素。

这种方法的缺点在于浪费了大量的存储空间,尤其对于规模较大且稀疏性较高的矩阵来说,存储效率非常低下。

因此,需要寻求更加高效的存储方法。

压缩存储方法为了解决存储空间浪费的问题,研究者们提出了多种压缩存储方法,常见的方法有行压缩存储和列压缩存储。

下面将详细介绍这两种方法。

行压缩存储(CSR)行压缩存储方法(Compressed Sparse Row,CSR)是最常见的稀疏矩阵压缩存储方法之一。

该方法将稀疏矩阵分为三个部分来存储:数据部分、列指针部分和行偏移部分。

1.数据部分:数据部分存储了矩阵中所有非零元素的值,依次排列。

2.列指针部分:列指针部分存储了每列中非零元素在数据部分中的位置,即指向数据部分的指针。

3.行偏移部分:行偏移部分记录了每行中的第一个非零元素在数据部分中的位置,依次排列。

使用CSR方法存储稀疏矩阵可以有效地压缩存储空间。

然而,该方法需要通过索引来访问矩阵元素,因此在随机访问的情况下性能较低。

列压缩存储(CSC)列压缩存储方法(Compressed Sparse Column,CSC)是另一种常见的稀疏矩阵压缩存储方法。

与CSR方法相比,CSC方法将稀疏矩阵按列进行压缩存储。

1.数据部分:数据部分存储了矩阵中所有非零元素的值,依次排列。

2.行指针部分:行指针部分存储了每行中非零元素在数据部分中的位置,即指向数据部分的指针。

3.列偏移部分:列偏移部分记录了每列中的第一个非零元素在数据部分中的位置,依次排列。

CSC方法相对于CSR方法,在随机访问的情况下性能更好,但在矩阵乘法等操作中性能较低。

稀疏矩阵的压缩存储及运算

稀疏矩阵的压缩存储及运算

稀疏矩阵的压缩存储及运算一、实验内容实现稀疏矩阵的压缩存储方法以及在特定存储方法下的基本运算二、实验母的掌握数组的应用,包括稀疏矩阵、特殊矩阵的压缩存储方法。

矩阵的基本运算的实现,包括矩阵相加、转置、乘法等。

三、问题描述1)用行逻辑链接顺序表和十字链表分别实现稀疏矩阵的压缩存储2)编程实现矩阵的转置运算和乘法运算(运用行逻辑链接顺序表或十字链表作为存储结构)四、问题的实现稀疏矩阵的抽象数据类型定义:ADT SpareseMatrix{数据对象:;,,2,1;,,2,1|{n j m i D a ij ===},,列数分别称为矩阵的行数和和n m ElemSet a j i ∈数据关系: :}1,11|,{}11,1|,{},{,1,1,,n j m i Col n j m i Row Col Row R a a a a j i j i j i j i ≤≤-≤≤><=-≤≤≤≤><==++基本操作:CreateSMatrix(&M);操作结果:创建稀疏矩阵M 。

PrintSMatrix(M);初始条件:稀疏矩阵M 存在。

操作结果:输出稀疏矩阵M 。

AddSMatrix(M ,N ,&Q);初始条件:稀疏矩阵M 和N 的行数和列数对应相等。

操作结果:求稀疏矩阵的和Q=M+N 。

MultSMatrix(M ,N ,&Q);初始条件:稀疏矩阵M 的列数等于N 的行数。

操作结果:求稀疏矩阵乘积Q=M*N 。

TransposeSMatrix(M,&T);初始条件:稀疏矩阵M 存在。

操作结果:求稀疏矩阵M 的转置矩阵T 。

}ADT SpareseMatrix五、主要源程序代码#include <iostream>using namespace std;#define MAXSIZE 100;typedef struct OLNode{int i,j;int e;struct OLNode *right,*down;}OLNode,*OLink;typedef struct{OLink *rhead,*chead;int mu,nu,tu;}CrossList; //十字链表结构体定义int CreatSMatrix_OL(CrossList &M){int i,j,e;OLink q;OLink p;cout<<"请输入稀疏矩阵的行数,列数,非零元素的个数:";cin>>M.mu;cin>>M.nu;cin>>M.tu;M.rhead=(OLink *)malloc((M.mu+1)*sizeof(OLNode));M.chead=(OLink *)malloc((M.nu+1)*sizeof(OLNode));for(i=1;i<=M.mu;i++) M.rhead[i]=NULL;for(i=1;i<=M.nu;i++) M.chead[i]=NULL;cout<<"请输入稀疏矩阵,若为空,则退出"<<endl;cin>>i;cin>>j;cin>>e;while (i!=0){p=(OLink)malloc(sizeof(OLNode));p->i=i;p->j=j;p->e=e;if (M.rhead[i]==NULL || M.rhead[i]->j>j) {p->right=M.rhead[i];M.rhead[i]=p;}else{q=M.rhead[i];while (q->right && q->right->j<j)q=q->right;p->right=q->right;q->right=p;}if (M.chead[j]==NULL || M.chead[j]->i>i) {p->down=M.chead[j];M.chead[j]=p;}else{q=M.chead[j];while (q->down && q->down->i<i)q=q->down;p->down=q->down;q->down=p;}cin>>i;cin>>j;cin>>e;}} //创建十字链表void TurnSMatrix_OL(CrossList &M){int a,b;OLink p,q;for(a<1;a<=M.mu;a++){q=p=M.rhead[a];while(q){b=p->i;p->i=p->j;p->j=b;q=p->right;p->right=p->down;p->down=q;}}} //十字链表实现稀疏矩阵转置int AddSMatrix_OL(CrossList *A,CrossList *B){OLNode *pa,*pb,*p,*pre,*cp[100];int i,j,t;t=A->tu+B->tu;for(j=1;j<=A->nu;j++) cp[j]=A->chead[j];for(i=1;i<=A->mu;i++){pa=A->rhead[i];pb=B->rhead[i];pre=NULL;while(pb){if(pa==NULL || pa->j>pb->j){p=(OLink)malloc(sizeof(OLNode));if(!pre)A->rhead[i]=p;else pre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;if(!A->chead[p->j]){A->chead[p->j]=cp[p->j]=p;p->down=NULL;}else{cp[p->j]->down=p;cp[p->j]=p;}pb=pb->right;}else if(pa->j<pb->j) {pre=pa;pa=pa->right;}else if(pa->e+pb->e){t--;pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}else{t=t-2;if(!pre)A->rhead[i]=pa->right;else pre->right=pa->right;p=pa;pa=pa->right;if(A->chead[p->j]==p) A->chead[p->j]=cp[p->j]=p->down;else cp[p->j]->down=p->down;free(p);pb=pb->right;}}}A->mu=A->mu>B->mu? A->mu:B->mu;A->nu=A->nu>B->nu? A->nu:B->nu;return 1;} //十字链表实现两稀疏矩阵相加int MultSMatrix_OL(CrossList M,CrossList N,CrossList &Q){int i,j,e;OLink p0,q0,p,p1,p1a;if(M.nu!=N.mu){cout<<"稀疏矩阵A的列数和B的行数不相等,不能相乘";return 0;}Q.mu=M.mu;Q.nu=N.nu;Q.tu=0;if(!(Q.rhead=(OLink *)malloc((Q.mu+1)*sizeof(OLink))))exit(-2);if(!(Q.chead=(OLink *)malloc((Q.nu+1)*sizeof(OLink))))exit(-2);for(i=1;i<=Q.mu;i++) Q.rhead[i]=NULL;for(i=1;i<=Q.nu;i++) Q.chead[i]=NULL;for(i=1;i<=Q.mu;i++)for(j=1;j<=Q.nu;j++){p0=M.rhead[i];q0=N.chead[j];e=0;while(p0 && q0){if(p0->j>q0->i) q0=q0->down;else if(p0->j<q0->i) p0=p0->right;else{e+=p0->e*q0->e;q0=q0->down;p0=p0->right;}}if(e){if(!(p=(OLink)malloc(sizeof(OLNode))))exit(-2);Q.tu++;p->i=i;p->j=j;p->e=e;p->right=NULL;p->down=NULL;if(Q.rhead[i]==NULL)Q.rhead[i]=p1=p;else p1->right=p;p1=p;if(Q.chead[j]==NULL)Q.chead[j]=p;else{p1a=Q.chead[j];while(p1a->down)p1a=p1a->down;p1a->down=p;}}}return 1;} //十字链表实现两稀疏矩阵相乘int ShowSMatrix(CrossList *A){int a;OLink p;for(a=1;a<=A->mu;a++)if(A->rhead[a]) {p=A->rhead[a];}while(p){printf("%3d%3d%3d\n",p->i,p->j,p->e);p=p->right;}return 1;} //十字链表显示void main(){int n;char c;CrossList MM,TT,SS;CreatSMatrix_OL(MM);cout<<"您输入的稀疏矩阵(只列出非零元素):"<<endl;cout<<"行列大小"<<endl;ShowSMatrix(&MM);cout<<"请选择操作:"<<endl;cout<<"1:实现稀疏矩阵的转置"<<endl;cout<<"2:实现两稀疏矩阵的相加"<<endl;cout<<"3:实现两稀疏矩阵的相乘"<<endl;cout<<"4:退出程序"<<endl;cin>>n;switch(n){case 1:TurnSMatrix_OL(MM);cout<<"转置后的稀疏矩阵:行列大小"<<endl;ShowSMatrix(&MM);break;case 2:cout<<"请输入另一个稀疏矩阵:"<<endl;CreatSMatrix_OL(TT);AddSMatrix_OL(&MM,&TT);cout<<"相加后的矩阵为:"<<endl;ShowSMatrix(&MM);break;case 3:cout<<"请输入另一个稀疏矩阵:"<<endl;CreatSMatrix_OL(TT);MultSMatrix_OL(MM,TT,SS);cout<<"相乘后的矩阵为:"<<endl;ShowSMatrix(&SS);break;case 4:exit(0);default:cout<<"error!"<<endl;}system("pause");}六、总结整个实验中学会了稀疏矩阵的压缩存储方法,用十字链表来存储,以及在特定存储方法下的基本运算。

a矩阵的稀疏矩阵矩阵描述方式 -回复

a矩阵的稀疏矩阵矩阵描述方式 -回复

a矩阵的稀疏矩阵矩阵描述方式-回复什么是稀疏矩阵?稀疏矩阵是一种矩阵,其中大部分元素为零。

与稠密矩阵相比,稀疏矩阵在内存和计算资源的利用方面具有很大的优势。

由于零元素较多,稀疏矩阵可以通过高效的数据结构存储,并且在进行各种矩阵操作时可以节省大量的计算时间。

如何描述稀疏矩阵?稀疏矩阵可以使用多种方式进行描述。

其中最常见的方法有三种:COO 格式(坐标存储格式)、CSR格式(压缩行存储格式)和CSC格式(压缩列存储格式)。

1. COO格式:COO格式是稀疏矩阵最基本也是最容易理解的一种描述方式。

在COO格式中,矩阵中的每个非零元素都被存储为一个三元组,包含元素的行索引、列索引和元素的值。

例如,对于一个3x3的稀疏矩阵:[1 0 2][0 0 3][4 5 0]可以用COO格式表示为:(0, 0, 1)(0, 2, 2)(1, 2, 3)(2, 0, 4)(2, 1, 5)2. CSR格式:CSR格式是一种基于行的存储格式,可以更有效地进行矩阵乘法和向量乘法等操作。

在CSR格式中,矩阵被分为三个数组:数据数组(存储非零元素的值)、行偏移数组(存储每一行非零元素在数据数组中的起始位置)和列索引数组(存储每个非零元素的列索引)。

使用上述示例矩阵,它可以用CSR格式表示为:数据数组:[1 2 3 4 5]行偏移数组:[0 2 3 5]列索引数组:[0 2 2 0 1]3. CSC格式:CSC格式是一种基于列的存储格式,与CSR格式类似,但是更适合进行稀疏矩阵向量乘法等列优先的操作。

在CSC格式中,矩阵被分为三个数组:数据数组、列偏移数组和行索引数组。

使用上述示例矩阵,它可以用CSC 格式表示为:数据数组:[1 4 5 2 3]列偏移数组:[0 2 3 5]行索引数组:[0 2 2 0 1]这三种描述方式各有优缺点,选择其中一种取决于应用程序的需求。

COO 格式适用于构建和插入操作,但对于矩阵乘法等操作较为低效。

稀疏矩阵存储技术

稀疏矩阵存储技术

稀疏矩阵存储技术哎呀,说到稀疏矩阵存储技术,这可真是个让人头疼的话题。

不过,别担心,我会尽量用大白话来给你讲讲这玩意儿到底是个啥,怎么用的。

首先,啥是稀疏矩阵呢?简单来说,就是那种大部分元素都是0的矩阵。

比如,一个10x10的矩阵,如果只有5个元素不是0,那它就是稀疏的。

你想想,如果直接存储这种矩阵,那得多浪费空间啊,因为大部分地方都是0,对吧?所以,人们就想出了一些聪明的办法来存储这种矩阵,这就是稀疏矩阵存储技术。

这技术的核心思想就是:只存储那些非0的元素,其他的0就不存了,这样就能大大节省空间。

现在,让我给你举个栗子。

假设我们有一个5x5的稀疏矩阵,只有三个非0元素,分别是(1,1)位置的3,(2,3)位置的5,和(4,4)位置的7。

按照普通的存储方法,我们需要一个5x5的数组,总共25个元素。

但是,用稀疏矩阵存储技术,我们只需要存储这三个非0元素,以及它们的位置信息。

具体来说,我们可以这样存储:1. 一个数组,用来存储非0元素的值,比如[3, 5, 7]。

2. 一个数组,用来存储非0元素的行索引,比如[1, 2, 4]。

3. 一个数组,用来存储非0元素的列索引,比如[1, 3, 4]。

这样,我们只需要三个数组,总共9个元素,就能完整地表示这个5x5的稀疏矩阵。

相比原来的25个元素,节省了一大半的空间。

当然,这只是稀疏矩阵存储技术的一种实现方式,还有其他的方法,比如压缩稀疏行(CSR)和压缩稀疏列(CSC)。

这些方法在不同的应用场景下有不同的优势,但核心思想都是一样的:只存储非0元素,节省空间。

总的来说,稀疏矩阵存储技术就是通过只存储非0元素,来节省空间的一种技术。

虽然听起来有点复杂,但其实原理挺简单的。

希望我这个大白话的解释,能让你对稀疏矩阵存储技术有个基本的了解。

下次再遇到这个话题,你就不会一头雾水啦!。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

– Using CRS format to store a sparse matrix will save a lot of memory.
Compressed Row Storage
– val array stores the values of the nonzero elements in a row-wise fashion. – col_ind array stores the corresponding column indices of the elements in the val array.
•The value of nonzero elements of row i: val[ row_ptr[ i ] ], ... , val[ row_ptr[ i+1 ] -1 ]
//Compressed Row Storage format //for a sparse square (mSize X mSize) matrix public class CRS{ //the values of the nonzero elements of the matrix float[] val; //the column indices of the elements in val array int[] col_idx; //locations in the val and col_idx array that start a row int[] row_ptr; //the size of the matrix: the number of rows int mSize=0; //constructor that takes a sparse matrix and convert it to a CRS object CRS( float[][] matrix){... } //print the matrix in CRS format. public void printCRS(){... } //test the program public static void main(String[] args){... } }
CRS( float[][] matrix){ int i, j, index; //the total number of nonzero in the matrix int totalNonZeros; //get the number of rows and columns mSize = matrix.length;
0
2
5
16
val col_ind
10 1
-2 5
3 1
9 2
3 6
7 2
8 3
7 4
… …
4 2
2 5
ห้องสมุดไป่ตู้
-1 6
the number of nonzero elements in a matrix
row_ptr
0
2
5
8
12
16
19
the number of rows +1
•The number of nonzero elements of row i = row_ptr[i+1] - row_ptr[ i ]
//get the total number of nonzero entries in the matrix totalNonZeros = 0; for( i=0; i<mSize; i++){ for( j=0; j<mSize; j++){ if(matrix[i][j] != 0) totalNonZeros++; } } //allocate memory for val and col_idx array val = new float[ totalNonZeros ]; col_idx = new int[ totalNonZeros ]; //allocate memory for row_ptr row_ptr = new int[ mSize+1]; row_ptr[ 0 ] = 0;
val //store the matrix in CRS format
x x
...
index index = 0;// point to the next position to store the value for( i=0; i<mSize; i++ ){//each row for( j=0; j<mSize; j++ ){//each column if( matrix[i][j] != 0 ){ //add the value to val val[ index ] = matrix[ i ][ j ]; //record the column index in col_idx col_idx[ index ] = j; index++; } } //update row_ptr row_ptr[ i+1 ] = index; } }//end of CRS( float[][] matrix)
• E.g. col_ind[5] stores the column index of val[5].
– row_ptr array stores the locations in the val array and col_ind array that start a row.
0
1 2 3
4
5 0 1 2 3 4 5
//test the program public static void main(String[] args){ float[][] matrix = {{10, 0, 0, 0, -2, 0}, {3, 9, 0, 0, 0, 3}, {0, 7, 8, 7, 0, 0}, {3, 0, 8, 7, 5, 0}, {0, 8, 0, 9, 9, 13}, {0, 4, 0, 0, 2, -1}}; System.out.println("the original sparse matrix"); for(int i=0; i<6; i++){ for(int j=0; j<6; j++){ System.out.print(matrix[i][j]+", "); } System.out.println(); } System.out.println(); CRS crs = new CRS(matrix); crs.printMatrix(); crs.printCRS(); }
Lab 3
Why Compressed Row Storage
– A sparse matrix has a lot of elements of value zero. – Using a two dimensional array to store a sparse matrix wastes a lot of memory. – Compressed Row Storage (CRS) format only stores the nonzero elements.
相关文档
最新文档