压缩矩阵的运算
数据结构实验五矩阵的压缩存储与运算学习资料
数据结构实验五矩阵的压缩存储与运算第五章矩阵的压缩存储与运算【实验目的】1. 熟练掌握稀疏矩阵的两种存储结构(三元组表和十字链表)的实现;2. 掌握稀疏矩阵的加法、转置、乘法等基本运算;3. 加深对线性表的顺序存储和链式结构的理解。
第一节知识准备矩阵是由两个关系(行关系和列关系)组成的二维数组,因此对每一个关系上都可以用线性表进行处理;考虑到两个关系的先后,在存储上就有按行优先和按列优先两种存储方式,所谓按行优先,是指将矩阵的每一行看成一个元素进行存储;所谓按列优先,是指将矩阵的每一列看成一个元素进行存储;这是矩阵在计算机中用一个连续存储区域存放的一般情形,对特殊矩阵还有特殊的存储方式。
一、特殊矩阵的压缩存储1. 对称矩阵和上、下三角阵若n阶矩阵A中的元素满足= (0≤i,j≤n-1 )则称为n阶对称矩阵。
对n阶对称矩阵,我们只需要存储下三角元素就可以了。
事实上对上三角矩阵(下三角部分为零)和下三角矩阵(上三角部分为零),都可以用一维数组ma[0.. ]来存储A的下三角元素(对上三角矩阵做转置存储),称ma为矩阵A的压缩存储结构,现在我们来分析以下,A和ma之间的元素对应放置关系。
问题已经转化为:已知二维矩阵A[i,j],如图5-1,我们将A用一个一维数组ma[k]来存储,它们之间存在着如图5-2所示的一一对应关系。
任意一组下标(i,j)都可在ma中的位置k中找到元素m[k]= ;这里:k=i(i+1)/2+j (i≥j)图5-1 下三角矩阵a00 a10 a11 a20 … an-1,0 … an-1,n-1k= 0 1 2 3 …n(n-1)/2 …n(n+1)/2-1图5-2下三角矩阵的压缩存储反之,对所有的k=0,1,2,…,n(n+1)/2-1,都能确定ma[k]中的元素在矩阵A中的位置(i,j)。
这里,i=d-1,(d是使sum= > k的最小整数),j= 。
2. 三对角矩阵在三对角矩阵中,所有的非零元素集中在以主对角线为中心的带内状区域中,除了主对角线上和直接在对角线上、下方对角线上的元素之外,所有其它的元素皆为零,见图5-3。
gpu布尔矩阵压缩算法 -回复
gpu布尔矩阵压缩算法-回复什么是GPU布尔矩阵压缩算法?在计算机科学中,布尔矩阵是一种由0和1组成的二维数组,其中1表示真值,0表示假值。
GPU布尔矩阵压缩算法是一种针对布尔矩阵的压缩方法,旨在将存储布尔矩阵所需的内存空间减少到最小化。
该算法利用GPU (Graphics Processing Unit,图形处理器)的并行计算能力,相较于传统的CPU(Central Processing Unit,中央处理器)计算,它可以更高效地进行运算。
在这篇文章中,我们将一步一步回答关于GPU布尔矩阵压缩算法的问题。
第一步:布尔矩阵是如何表示的?布尔矩阵通常使用二维数组来表示,其中每个元素要么为0,要么为1。
例如,以下是一个3x3的布尔矩阵的示例:[1, 0, 1][0, 1, 0][1, 1, 0]在传统储存方式下,需要占据9个内存位置,而对于大型布尔矩阵来说,这样的内存占用是十分巨大的。
第二步:GPU具有哪些优势?与CPU相比,GPU在并行计算方面具有极大的优势。
它拥有大量的处理单元和存储器并行处理能力,能够同时执行多个任务。
这使得GPU在处理大规模数据集和复杂计算方面具有更高的效率和速度。
第三步:如何进行GPU布尔矩阵压缩?GPU布尔矩阵压缩算法通常包括两个主要步骤:稀疏矩阵转换和压缩存储。
首先,我们将讨论稀疏矩阵转换。
稀疏矩阵转换是指将布尔矩阵转换为稀疏矩阵的过程,其中只有非零元素被保留。
在GPU中,我们可以使用稀疏矩阵的坐标列表(Coordinate List,COO)表示方法来实现这个转换。
在COO表示中,每个非零元素都由其行和列索引以及值表示。
例如,对于之前的3x3布尔矩阵示例:(0, 0, 1), (0, 2, 1), (1, 1, 1), (2, 0, 1), (2, 1, 1)这些元组表明了原始矩阵中每个非零元素在COO表示中的位置和值。
在完成稀疏矩阵转换后,接下来就是压缩存储。
GPU布尔矩阵压缩算法通常采用基于位运算的压缩方法,如位图压缩、哈夫曼编码等。
稀疏矩阵的压缩存储方法及主要运算的实现
1.实验目的:掌握稀疏矩阵的压缩存储方法及主要运算的实现。
2.实验内容与要求:设计一个稀疏矩阵计算器,要求能够:⑴输入并建立稀疏矩阵;⑵输出稀疏矩阵;⑶执行两个矩阵相加;⑷执行两个矩阵相乘;⑸求一个矩阵的转置矩阵。
3.数据结构设计逻辑结构:线性结构存储结构:顺序存储结构4.算法设计#include<stdio.h>#define MAXSIZE 100typedef int datatype;typedef struct{ int i,j;datatype v;}Triple;typedef struct{ Triple data[MAXSIZE+1];int rpos[MAXSIZE+1];int mu,nu,tu;}RLSMatrix;int main(){ void AddSMatrix(RLSMatrix M);void MultSMatrix(RLSMatrix M);void FastTransposeSMatrix(RLSMatrix M);RLSMatrix M;int k;printf("请输入稀疏矩阵M的行数、列数和非零元素个数:");scanf("%d%d%d",&M.mu,&M.nu,&M.tu);printf("请输入稀疏矩阵M中非零元素的行号、列号和元素的值:\n");for(k=1;k<=M.tu;k++)scanf("%d%d%d",&M.data[k].i,&M.data[k].j,&M.data[k].v);printf("请输出稀疏矩阵M中非零元素的行号、列号和元素的值:\n");for(k=1;k<=M.tu;k++){ printf("%d%3d%3d",M.data[k].i,M.data[k].j,M.data[k].v);printf("\n");}AddSMatrix(M);MultSMatrix(M);FastTransposeSMatrix(M);return 0;}void AddSMatrix(RLSMatrix M){ RLSMatrix N,R;int k,l=1,s=1;printf("请输入稀疏矩阵N的行数、列数和非零元素个数:");scanf("%d%d%d",&N.mu,&N.nu,&N.tu);printf("请输入稀疏矩阵N中非零元素的行号、列号和元素的值:\n"); for(k=1;k<=N.tu;k++)scanf("%d%d%d",&N.data[k].i,&N.data[k].j,&N.data[k].v);if(M.mu!=N.mu||M.nu!=N.nu) printf("错误\n");else{ R.mu=M.mu;R.nu=M.nu;k=1;if(M.tu*N.tu!=0){ while(k<=M.tu&&l<=N.tu){ if(M.data[k].i==N.data[l].i){ if(M.data[k].j<N.data[k].j){ R.data[s].i=M.data[k].i;R.data[s].j=M.data[k].j;R.data[s].v=M.data[k].v;k++;s++;}else if(M.data[k].j==N.data[l].j){ R.data[s].i=M.data[k].i;R.data[s].j=M.data[k].j;R.data[s].v=M.data[k].v+N.data[l].v;if(R.data[s].v!=0) s++;k++;l++;}else{ R.data[s].i=N.data[l].i;R.data[s].j=N.data[l].j;R.data[s].v=N.data[l].v;l++;s++;}}else if(M.data[k].i<N.data[l].i){ R.data[s].i=M.data[k].i;R.data[s].j=M.data[k].j;R.data[s].v=M.data[k].v;k++;s++;}else{ R.data[s].i=N.data[l].i;R.data[s].j=N.data[l].j;R.data[s].v=N.data[l].v;l++;s++;}}while(k<=M.tu){ R.data[s].i=M.data[k].i;R.data[s].j=M.data[k].j;R.data[s].v=M.data[k].v;k++;s++;}while(l<=N.tu){ R.data[s].i=N.data[l].i;R.data[s].j=N.data[l].j;R.data[s].v=N.data[l].v;l++;s++;}}printf("请输出稀疏矩阵M和稀疏矩阵N的和矩阵R中非零元素的行号、列号和元素的值:\n");for(k=1;k<s;k++)printf("%d%3d%3d\n",R.data[k].i,R.data[k].j,R.data[k].v);}}void MultSMatrix(RLSMatrix M){ RLSMatrix D,Q;int num1[MAXSIZE],num2[MAXSIZE],ctemp[MAXSIZE],arow,brow,ccol,p,q,tp,t; printf("请输入稀疏矩阵D的行数、列数和非零元素个数:");scanf("%d%d%d",&D.mu,&D.nu,&D.tu);printf("请输入稀疏矩阵D中非零元素的行号、列号和元素的值:\n");for(t=1;t<=D.tu;t++)scanf("%d%d%d",&D.data[t].i,&D.data[t].j,&D.data[t].v);for(ccol=1;ccol<=M.mu;ccol++)num1[ccol]=0;for(t=1;t<=M.tu;t++)num1[M.data[t].i]++;M.rpos[1]=1;for(ccol=2;ccol<=M.mu;ccol++)M.rpos[ccol]=M.rpos[ccol-1]+num1[ccol-1];for(ccol=1;ccol<=D.mu;ccol++)num2[ccol]=0;for(t=1;t<=D.tu;t++)num2[D.data[t].i]++;D.rpos[1]=1;for(ccol=2;ccol<=D.mu;ccol++)D.rpos[ccol]=D.rpos[ccol-1]+num2[ccol-1];if(M.nu!=D.mu) printf("错误\n");else{ Q.mu=M.mu;Q.nu=D.nu;Q.tu=0;if(M.tu*D.tu!=0){ for(arow=1;arow<=M.mu;arow++){ for(ccol=1;ccol<=Q.nu;ccol++)ctemp[ccol]=0;Q.rpos[arow]=Q.tu+1;if(arow<M.mu) tp=M.rpos[arow+1];else tp=M.tu+1;for(p=M.rpos[arow];p<tp;p++){ brow=M.data[p].j;if(brow<D.mu) t=D.rpos[brow+1];else t=D.tu+1;for(q=D.rpos[brow];q<t;q++){ ccol=D.data[q].j;ctemp[ccol]+=M.data[p].v*D.data[q].v;}}for(ccol=1;ccol<=Q.nu;ccol++)if(ctemp[ccol]!=0){ if(++Q.tu>MAXSIZE) printf("错误\n");else{ Q.data[Q.tu].i=arow;Q.data[Q.tu].j=ccol;Q.data[Q.tu].v=ctemp[ccol];}}}}}printf("请输出稀疏矩阵M和稀疏矩阵D的乘积矩阵Q中非零元素的行号、列号和元素的值:\n");for(ccol=1;ccol<=Q.tu;ccol++)printf("%d%3d%3d\n",Q.data[ccol].i,Q.data[ccol].j,Q.data[ccol].v);}void FastTransposeSMatrix(RLSMatrix M){ RLSMatrix T;int num[MAXSIZE],cpot[MAXSIZE],col,p,q,t;T.mu=M.mu;T.nu=M.nu;T.tu=M.tu;if(T.tu!=0){ for(col=1;col<=M.mu;col++)num[col]=0;for(t=1;t<=M.tu;t++)num[M.data[t].j]++;cpot[1]=1;for(col=2;col<=M.nu;col++)cpot[col]=cpot[col-1]+num[col-1];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].v=M.data[p].v;cpot[col]++;}}printf("请输出将稀疏矩阵M转置后的稀疏矩阵T中非零元素的行号、列号和元素的值:\n");for(col=1;col<=T.tu;col++)printf("%d%3d%3d\n",T.data[col].i,T.data[col].j,T.data[col].v);}。
第4章专题3矩阵的压缩存储
三元组表=( (0,0,15), (1,1,11), (2,3,6), (4,0,9) ) 如何存储三元组表?
清华大学出版社
数据结构(C++版)第2版
4.3 矩阵的压缩存储
稀疏矩阵的压缩存储——三元组顺序表 采用顺序存储结构存储三元组表
15 0 0 22 0 -15
0 11 3 0 0 0
A=
0 0
0 0 a43 a44 a45 0 0 0 a54 a55
(a) 三对角矩阵
按行 存储
元素aij在一维数组中的序号
=2 + 3(i-2)+( j-i + 2) =2i+ j -2 ∵一维数组下标从0开始
∴元素aij在一维数组中的下标
= 2i+ j -3
(b) 寻址的计算方法
0 1 2 3 4 5 6 7 8 9 10 11 12
0 0
0 0
6 0
0 0
0 0
91 0 0 0 0 0
三元组顺序表是否 需要预留存储空间?
稀疏矩阵的修改操作
三元组顺序表的插入/删除操作
清华大学出版社
数据结构(C++版)第2版
4.3 矩阵的压缩存储
稀疏矩阵的压缩存储——三元组顺序表
采用顺序存储结构存储三元组表
15 0 0 22 0 -15
0 11 3 0 0 0
上三角中的元素aij(i<j),因为aij=aji,则访问和 它对应的元素aji即可,即:k=j×(j+1)/2+i -1 。
清华大学出版社
数据结构(C++版)第2版
4.3 矩阵的压缩存储
特殊矩阵的压缩存储——三角矩阵
使用奇异值分解进行矩阵压缩的方法探讨(五)
奇异值分解(Singular Value Decomposition,SVD)是一种常用的矩阵分解方法,它在数据压缩和噪音过滤等领域有着广泛的应用。
在本文中,我将探讨使用奇异值分解进行矩阵压缩的方法,包括其原理、实现步骤以及应用场景。
奇异值分解是一种将一个矩阵分解为三个矩阵的方法,即将一个矩阵A分解为U、Σ和V的乘积,其中U和V是正交矩阵,Σ是对角矩阵。
在奇异值分解中,U和V代表了A的左奇异向量和右奇异向量,Σ则包含了A的奇异值。
奇异值分解的原理是将原始矩阵A映射到一个更低维的空间中,从而实现数据的压缩和降维。
实现奇异值分解的步骤主要包括以下几个步骤:首先,对原始矩阵A进行对称正交化处理,得到对称矩阵B。
然后,对矩阵B进行特征值分解,得到特征值和特征向量。
接下来,根据特征值和特征向量构建对角矩阵Σ和正交矩阵U和V。
最后,将U、Σ和V相乘,即可得到原始矩阵A的奇异值分解。
奇异值分解可以被广泛用于数据压缩和噪音过滤等领域。
在数据压缩方面,奇异值分解可以将原始矩阵A映射到一个更低维的空间中,从而实现对数据的压缩。
这种压缩方法在图像处理和语音识别等领域有着重要的应用,能够减小数据的存储空间和传输带宽。
另外,在噪音过滤方面,奇异值分解可以通过保留较大的奇异值,实现对数据中噪音的过滤,提高数据的质量和准确性。
除了数据压缩和噪音过滤,奇异值分解还可以应用于推荐系统和模式识别等领域。
在推荐系统中,奇异值分解可以通过对用户-物品评分矩阵进行分解,实现对用户的个性化推荐。
在模式识别中,奇异值分解可以通过对特征矩阵进行分解,实现对模式的识别和分类。
总之,奇异值分解是一种重要的矩阵分解方法,它在数据压缩、噪音过滤、推荐系统和模式识别等领域有着广泛的应用。
通过对奇异值分解的原理、实现步骤和应用场景进行探讨,可以更好地理解和应用这一方法,从而实现对数据的有效处理和利用。
矩阵压缩存储
矩阵压缩存储矩阵压缩存储是一种将矩阵中的数据进行压缩存储的方法,可以大大减小矩阵所占用的存储空间,提高数据存储和传输的效率。
矩阵压缩存储的实现方式有很多种,其中比较常见的有行压缩存储和列压缩存储。
行压缩存储是将矩阵中的每一行数据进行压缩存储,对于每一行数据,只存储其中非零元素的值和它们在该行中的位置。
这种方式适用于矩阵中非零元素比较稀疏的情况,可以大大减小存储空间。
例如,对于一个5*5的矩阵:1 0 0 0 00 2 0 0 00 0 3 0 00 0 0 4 00 0 0 0 5使用行压缩存储方式,可以将其压缩为:1 12 23 34 4 51 2 2 3 4 5其中第一行表示非零元素的值,第二行表示它们在该行中的位置。
列压缩存储是将矩阵中的每一列数据进行压缩存储,对于每一列数据,只存储其中非零元素的值和它们在该列中的位置。
这种方式适用于矩阵中非零元素比较密集的情况,可以大大减小存储空间。
例如,对于同样的5*5的矩阵:1 0 0 0 00 2 0 0 00 0 3 0 00 0 0 4 00 0 0 0 5使用列压缩存储方式,可以将其压缩为:1 2 3 4 51 2 3 4 51 2 3 4 51 2 4 51 5其中第一行表示非零元素的值,第二行表示它们在该列中的位置。
矩阵压缩存储的优点在于可以大大减小存储空间,提高数据存储和传输的效率。
但是,它也存在一些缺点。
首先,对于非零元素比较密集的矩阵,行压缩存储的效果不如列压缩存储,反之亦然。
其次,矩阵压缩存储需要进行解压缩操作才能得到原始数据,这会增加一定的计算量和时间成本。
最后,矩阵压缩存储的实现需要考虑到数据的稀疏性和分布情况,否则可能会导致存储空间的浪费或者解压缩效率的降低。
总之,矩阵压缩存储是一种非常实用的数据存储和传输方式,可以大大提高数据处理的效率和速度。
在实际应用中,需要根据具体情况选择合适的压缩方式,并进行适当的优化和调整,以达到最佳的效果。
对角矩阵压缩算法
对⾓矩阵压缩算法
对⾓矩阵压缩算法
以44对⾓矩阵为例⼦
⾸先我们得知道对⾓矩阵的概念对⾓矩阵(diagonal matrix)是⼀个主对⾓线之外的元素皆为0的矩阵,常写为diag(a1,a2,...,an) 。
对⾓矩阵可以认为是矩阵中最简单的⼀种,值得⼀提的是:对⾓线上的元素可以为 0 或其他值,对⾓线上元素相等的对⾓矩阵称为数量矩阵;对⾓线上元素全为1的对⾓矩阵称为单位矩阵—来⾃百度百科。
⽐如 1 2 0 0
5 4 3 0
0 1 2 3
0 0 2 3
我们可以发现三对⾓矩阵⾸⾏和尾⾏分别有2个⾮0元素,其余⾏都是3个⾮0元素
推⼴⾄在有n ⾏的情况⾮0 元素 3(n-2)+4=3n-2
推算下标k值
对数组a【i】【j】分配⾄对⾓矩阵前i⾏中有(i-1)3+2根据对⾓线推元素位⼦得不是i-j+1就是j-i+1所以k=(i-1)3+2+j-i+1=i2+j
所以我们可以⽤k的值来推算i,j i=(k+1)/3
J=k-2*i;
得出k于i,j的关系后便可以将矩阵进⾏压缩从⽽避免了0元素的空间占⽤,直接将矩阵压缩。
使用奇异值分解进行矩阵压缩的方法探讨(九)
奇异值分解(Singular Value Decomposition,SVD)是一种常用的数学方法,广泛应用于信号处理、图像压缩、数据降维等领域。
本文将探讨使用奇异值分解进行矩阵压缩的方法,以及其在实际应用中的一些特点和局限性。
奇异值分解是一种将矩阵分解为三个矩阵乘积的方法,即A=UΣV^T,其中A是一个m×n的矩阵,U是一个m×m的正交矩阵,Σ是一个m×n的对角矩阵,V^T 是一个n×n的正交矩阵。
在奇异值分解中,U和V被称为左奇异向量和右奇异向量,Σ的对角元素被称为奇异值。
在矩阵压缩中,我们可以利用奇异值分解将原始矩阵A分解为三个矩阵的乘积。
然后,我们可以通过保留奇异值较大的部分,来近似表示原始矩阵。
这样做的好处在于可以用较小的存储空间来表示原始矩阵,从而实现矩阵的压缩。
值得注意的是,奇异值分解的压缩效果取决于保留的奇异值个数。
通常情况下,我们可以根据奇异值的大小来决定保留的奇异值个数,从而实现不同程度的矩阵压缩。
在实际应用中,我们可以通过调整保留的奇异值个数来平衡压缩后的矩阵表示和压缩比之间的关系。
另外,奇异值分解在图像压缩中也有着重要的应用。
通过对图像矩阵进行奇异值分解,我们可以将图像表示为奇异值较少的近似矩阵,从而实现对图像的压缩。
这种方法在图像传输和存储中具有重要的意义,可以有效减小图像文件的大小,节省存储空间和传输带宽。
然而,奇异值分解也存在一些局限性。
首先,对于大规模矩阵的奇异值分解计算量较大,需要耗费大量的时间和计算资源。
其次,在实际应用中,由于保留奇异值个数的选择较为主观,可能会影响压缩后矩阵的表示效果。
因此,如何在实际应用中选择合适的奇异值个数,以及如何在保证表示效果的同时实现较高的压缩比,仍然是一个具有挑战性的问题。
综上所述,奇异值分解是一种重要的矩阵压缩方法,具有广泛的应用前景。
通过奇异值分解,我们可以实现对矩阵的压缩和近似表示,从而在存储和传输方面带来一系列的好处。
稀疏矩阵的压缩计算
稀疏矩阵的压缩计算稀疏矩阵是指矩阵中绝大多数元素都是0的矩阵,即非零元素远小于矩阵元素总数的矩阵。
在实际应用中,稀疏矩阵非常常见,比如图像处理、自然语言处理、推荐系统等领域的数据处理。
但是由于稀疏矩阵的特殊性,其存储和计算都会带来额外的开销。
因此,稀疏矩阵的压缩计算变得至关重要。
为了有效地存储和计算稀疏矩阵,研究者提出了多种压缩算法,其中最常用的有三种:压缩行(CSR)、压缩列(CSC)和亚正规(ELL)压缩算法。
压缩行(CSR)算法将稀疏矩阵的每行非零元素及其列索引存储在两个数组中。
一个数组用于存储每行第一个非零元素在第二个数组中的索引位置,第二个数组按非零元素出现的顺序存储矩阵的非零元素值和对应的列索引。
这种方式的好处是能够高效地进行矩阵向量乘法运算,但是在进行矩阵转置和矩阵矩阵相乘时效率较低。
压缩列(CSC)算法与压缩行算法类似,不同之处在于将矩阵的每列非零元素及其行索引存储在两个数组中。
这种方式适用于矩阵转置和矩阵矩阵相乘等操作,但是在矩阵向量乘法中效率较低。
亚正规(ELL)压缩算法综合了压缩行和压缩列算法的优点,将稀疏矩阵的每行的非零元素及其列索引存储在两个二维数组中。
第一个二维数组用于存储每行非零元素的值,第二个二维数组用于存储每行非零元素的列索引。
由于每行的非零元素个数可能不同,因此需要对二维数组进行补齐。
这种方式能够高效地进行矩阵向量乘法和矩阵转置,但是对于矩阵矩阵相乘效率较低。
除了上述的三种压缩算法,还有其他一些针对特定稀疏矩阵特点的压缩算法,如对角线压缩(DIA)算法,将矩阵的对角线及其对应的值存储在数组中,适用于具有对角线分布特点的矩阵;块压缩(BSC)算法,将矩阵按照行或列分块存储在多个数组中,适用于矩阵具有块状结构的情况。
总结来说,稀疏矩阵压缩计算是应对稀疏矩阵存储和计算的重要方法。
通过选择合适的压缩算法,可以充分利用稀疏矩阵的特点,减少存储开销和计算复杂度,提高计算效率。
三元组压缩存储结构的稀疏矩阵的运算快速转置
三元组压缩存储结构的稀疏矩阵的运算快速转置在计算机科学和数学领域中,稀疏矩阵是一种在大部分元素为零的矩阵。
由于其大部分元素为零,因此在存储和运算时存在着一些挑战。
为了解决这一问题,人们提出了三元组压缩存储结构,这种存储结构能够有效地压缩稀疏矩阵,并且能够实现快速的运算转置。
1.稀疏矩阵稀疏矩阵是一种大部分元素为零的矩阵,与之相对应的是稠密矩阵,其大部分元素为非零值。
稀疏矩阵通常在图像处理、文本处理、网络分析等领域中得到广泛应用。
然而,由于大部分元素为零,传统的存储方式会导致存储空间的浪费。
人们提出了三元组压缩存储结构,以解决稀疏矩阵存储的问题。
2.三元组压缩存储结构三元组压缩存储结构是一种用于表示稀疏矩阵的存储格式。
它采用三个数组来分别存储矩阵的非零元素的行坐标、列坐标和数值。
由于只需存储非零元素的信息,因此能够有效地压缩存储空间。
三元组压缩存储结构还能够实现快速的随机访问,这是由于它将矩阵的元素位置和数值分开存储,使得在进行运算时能够更为高效。
3.稀疏矩阵的运算稀疏矩阵的运算是对稀疏矩阵进行加法、减法、乘法等操作的过程。
在进行稀疏矩阵的运算时,三元组压缩存储结构能够显著提高计算效率。
这是由于在进行运算时,只需考虑非零元素,而无需考虑大量的零元素,从而减少了计算的复杂度。
4.稀疏矩阵的快速转置稀疏矩阵的转置是将矩阵的行和列交换,同时保持非零元素的位置和数值不变。
在传统的存储方式下,稀疏矩阵的转置操作相对复杂且耗时。
然而,采用三元组压缩存储结构后,稀疏矩阵的快速转置变得十分简便。
通过交换三元组中的行坐标和列坐标,即可完成稀疏矩阵的快速转置操作。
5.个人观点和理解我认为三元组压缩存储结构的出现,极大地解决了稀疏矩阵在存储和运算中的效率问题。
通过将矩阵的非零元素信息进行压缩存储,不仅节省了存储空间,同时也提高了计算效率。
在实际应用中,三元组压缩存储结构能够更好地满足对存储空间和计算效率有较高要求的场景,为稀疏矩阵的处理提供了更为便利和高效的途径。
压缩稀疏矩阵的两种常用方法
压缩稀疏矩阵的两种常用方法压缩稀疏矩阵是指通过一定的方法将稀疏矩阵中的零元素进行压缩,从而减少存储空间的方法。
在很多实际问题中,矩阵中的零元素数量很多,占据了大量的存储空间,但是这些零元素并没有提供有用的信息。
因此,压缩稀疏矩阵可以大大减少存储空间,提高计算效率。
下面将介绍两种常用的压缩稀疏矩阵的方法:压缩行(CSR)和压缩列(CSC)。
压缩行(CSR)是一种经典的压缩稀疏矩阵的方法。
在压缩行方法中,我们只存储矩阵中非零元素的值和对应的列下标,以及每行的非零元素的起始位置。
具体的步骤如下:1.遍历矩阵的每一行,将每一行的非零元素的值及对应的列下标存储在一个一维数组中,同时记录下每一行的非零元素的个数。
2.计算每一行的非零元素的起始位置。
起始位置可以通过前面每一行的非零元素的个数求和得到。
3.存储非零元素的值和对应的列下标的一维数组,则该数组的长度等于矩阵中非零元素的个数。
4.将每一行的非零元素的个数和起始位置存储在两个一维数组中,分别为行偏移数组和列索引数组。
压缩列(CSC)与压缩行类似。
不同之处在于,压缩列存储的是矩阵中每一列的非零元素的值和对应的行下标,以及每列的非零元素的起始位置。
具体步骤如下:1.遍历矩阵的每一列,将每一列的非零元素的值及对应的行下标存储在一个一维数组中,同时记录下每一列的非零元素的个数。
2.计算每一列的非零元素的起始位置。
起始位置可以通过前面每一列的非零元素的个数求和得到。
3.存储非零元素的值和对应的行下标的一维数组,则该数组的长度等于矩阵中非零元素的个数。
4.将每一列的非零元素的个数和起始位置存储在两个一维数组中,分别为列偏移数组和行索引数组。
综上所述,压缩行和压缩列是两种常用的压缩稀疏矩阵的方法。
它们都可以有效地减少矩阵中零元素的存储空间,提高存储效率和计算效率。
在实际应用中,我们可以根据具体的问题选择适合的方法来进行压缩稀疏矩阵的操作。
如何利用奇异值分解进行矩阵压缩(四)
奇异值分解(Singular Value Decomposition,SVD)是一种常用的矩阵分解方法,通过将一个矩阵分解为三个矩阵的乘积,可以帮助我们理解和压缩数据。
本文将介绍如何利用奇异值分解进行矩阵压缩,以及在实际应用中的一些技巧和注意事项。
首先,让我们简单回顾一下奇异值分解的定义和原理。
对于一个m×n 的矩阵A,其奇异值分解可以表示为A=UΣV^T,其中U是一个m×m 的正交矩阵,V是一个n×n 的正交矩阵,Σ是一个m×n 的对角矩阵。
Σ的对角线元素被称为矩阵A的奇异值,通常按照从大到小的顺序排列。
奇异值分解的一个重要性质是,矩阵A的秩等于其非零奇异值的个数。
因此,我们可以通过保留较大的奇异值,将一个矩阵压缩为一个低秩矩阵的近似。
这种近似可以在很大程度上减小数据的存储空间,并且在某些情况下可以保留原始数据的主要特征。
在实际应用中,奇异值分解常常用于图像压缩和降维处理。
以图像压缩为例,假设我们有一张色彩图像,可以将其表示为一个三维矩阵,其中每个元素代表像素的颜色值。
通过对图像矩阵进行奇异值分解,并保留部分较大的奇异值,我们可以将原始图像压缩为一个低秩矩阵的近似,从而实现图像压缩的效果。
接下来,我们将介绍一些利用奇异值分解进行矩阵压缩的常用技巧和注意事项。
首先,选择保留的奇异值个数是一个关键的问题。
一般来说,我们可以根据奇异值的能量分布情况,选择一个合适的截断参数,使得保留的奇异值个数能够满足我们对数据压缩程度和保留主要特征的需求。
其次,对于大规模矩阵的奇异值分解,常常需要使用一些优化算法和技巧,以提高计算效率和减小存储开销。
例如,在实际计算中,我们可以利用矩阵的特性和结构,采用分块计算、迭代算法等方法,加速奇异值分解的计算过程。
此外,需要注意的是,在进行矩阵压缩时,我们可能会丢失一部分信息。
因此,在应用奇异值分解进行矩阵压缩时,需要根据具体应用场景和需求,评估压缩后数据的质量和可用性,从而选择合适的压缩参数和方法。
coo压缩矩阵
COO(Coordinate Format)是矩阵的一种压缩存储格式,特别适用于稀疏矩阵的存储。
在COO格式中,非零元素以三元组的形式存储:(i, j, value),其中i和j分别表示元素所在的行号和列号,value则是该位置的值。
与常规矩阵不同的是,COO矩阵并不为每个元素分配空间,而是只记录那些非零元素的位置和值。
这样做的好处是可以显著减少存储需求,尤其是当矩阵大部分元素都是零时。
对于一个n×m的矩阵A,我们可以用一个大小为nnz的数组来存储其非零元素,其中nnz代表矩阵中的非零元素个数。
这个数组可以是一个结构体数组,每个结构体包含三个字段:row、column和value。
在进行矩阵运算时,如加法、乘法等,通常需要先将COO矩阵转换为其他更适合计算的格式,比如CSR(Compressed Sparse Row)或CSC (Compressed Sparse Column)格式。
这是因为COO格式虽然易于生成和理解,但在实际计算中效率较低。
需要注意的是,COO矩阵的一个限制是它不支持快速的随机访问,因为要查找某个特定位置的元素,可能需要遍历整个数组。
此外,如果矩阵中的元素分布非常不均匀,那么COO格式的性能可能会下降。
如何利用奇异值分解进行矩阵压缩(八)
奇异值分解是一种常用的矩阵分解方法,可以将一个矩阵分解为三个矩阵的乘积,从而达到矩阵压缩的效果。
在实际应用中,奇异值分解有着广泛的用途,比如在图像压缩、数据降维、推荐系统等领域都有着重要的作用。
本文将从奇异值分解的原理入手,探讨如何利用奇异值分解进行矩阵压缩。
首先,我们需要了解奇异值分解的原理。
对于一个矩阵A,其奇异值分解可以表示为A = UΣV^T,其中U和V是正交矩阵,Σ是一个对角矩阵,对角线上的元素称为奇异值。
奇异值分解的重要性在于它将原始矩阵分解为了三个部分,分别代表了矩阵的几何特性、奇异值以及旋转特性。
通过保留部分奇异值,我们可以实现对矩阵的压缩,从而达到减少存储空间和计算复杂度的目的。
在实际应用中,奇异值分解可以通过保留部分奇异值来实现矩阵的压缩。
在图像压缩中,我们可以将图像矩阵进行奇异值分解,然后只保留部分重要的奇异值和对应的U、V矩阵,舍弃其他奇异值和对应的矩阵。
这样就可以实现对图像信息的压缩,从而减少存储空间。
同样地,在数据降维和推荐系统中,奇异值分解也可以用来压缩数据,减少计算复杂度,提高推荐的准确性和效率。
除了矩阵压缩外,奇异值分解还有着其他重要的应用。
比如在信号处理领域,奇异值分解可以用来降噪和提取信号特征;在机器学习领域,奇异值分解可以用来降低数据维度,提高模型训练的速度和效果。
因此,奇异值分解作为一种重要的矩阵分解方法,在各个领域都有着重要的应用前景。
总之,奇异值分解是一种强大的矩阵分解方法,可以实现对矩阵的压缩和降维,从而减少存储空间和提高计算效率。
在实际应用中,我们可以根据具体的需求和场景,选择合适的奇异值分解方法,从而实现对矩阵的高效处理和利用。
希望本文对读者有所帮助,谢谢阅读!。
稀疏矩阵的压缩存储方法及主要运算的实现
稀疏矩阵的压缩存储方法及主要运算的实现稀疏矩阵是指矩阵中大部分元素都是0的矩阵。
由于在实际应用中,很多矩阵的元素大部分都是0,而且矩阵的规模很大,因此可以对稀疏矩阵采用压缩存储方法,减少存储空间的占用。
1.顺序表压缩法:顺序表压缩法是将矩阵中的每个非零元素按顺序存储在一维数组中。
对于每个非零元素,在数组中存储其数值及其在矩阵中的行和列的下标信息。
2.链表压缩法:链表压缩法是使用两个一维数组,一个用于存储非零元素的值,另一个用于存储非零元素所在的行和列的下标。
通过链表将这两个数组连接起来,实现对非零元素的存储和检索。
3.三元组顺序表压缩法:三元组顺序表压缩法是将矩阵中的非零元素及其位置信息以三元组的形式存储在一维数组中,每个三元组包含三个信息:行号、列号和元素的值。
在稀疏矩阵的运算中,主要涉及到矩阵的加法、减法和乘法运算。
在压缩存储的基础上,可以通过对稀疏矩阵进行特定的运算方式来实现这些运算。
1.矩阵加法:对于两个稀疏矩阵A和B,可以先将它们转换成对应的压缩存储方式。
然后对于两个矩阵中的每个非零元素,将它们的值相加得到结果矩阵的对应元素的值。
2.矩阵减法:与矩阵加法类似,对于两个稀疏矩阵A和B,也可以先将它们转换成对应的压缩存储方式。
然后对于两个矩阵中的每个非零元素,将它们的值相减得到结果矩阵的对应元素的值。
3.矩阵乘法:矩阵乘法是比较复杂的稀疏矩阵运算。
对于两个稀疏矩阵A和B,可以先将它们转换成对应的压缩存储方式。
然后通过循环遍历A的行和B的列,并在每次迭代中计算结果矩阵中的对应元素的值。
具体的计算方式是,将A的当前行和B的当前列对应的非零元素进行乘积,并将得到的结果累加到结果矩阵中的对应元素的值。
需要注意的是,由于稀疏矩阵的特殊性,压缩存储方式在空间上会减少存储空间的占用,但在一些具体的运算中,可能会导致运算的效率降低。
因此,在选择稀疏矩阵的压缩存储方式时,需要综合考虑存储空间和运算效率两个方面的因素。
矩阵压缩算法
矩阵压缩算法矩阵压缩算法是计算机科学和数学领域中的一项重要技术。
该算法的目的是将矩阵中的数据压缩成更小的形式,并且在对数据进行操作时仍然能够准确地还原原数据。
在大多数情况下,矩阵压缩算法非常适合在计算机科学领域使用,尤其是在处理大型数据集时。
该算法在各种数据处理任务中都非常有用,例如将图像、视频、音频和其他形式的数据压缩成更小的形式。
矩阵压缩算法的基本原理是利用矩阵的稀疏性质来压缩数据。
但是,矩阵的稀疏性是相对的,某些矩阵可能不太稀疏,而某些矩阵可能非常稀疏。
因此,不同的矩阵可能需要不同的压缩算法。
常用的矩阵压缩算法包括以下几种:1.对称压缩算法对称压缩算法(Symmetric Compressions)是一种利用矩阵的对称性质来压缩数据的算法。
对称矩阵是它本身的转置,因此可以将其上三角和下三角存储在一起,从而可以使用对称压缩算法将其压缩。
使用对称压缩算法可以将原始矩阵的存储需求减半。
3.小波变换压缩算法小波变换压缩算法(Wavelet Compressions)是一种利用小波变换来压缩数据的算法。
小波变换是一种将信号分解成各个不同频率的基本成分的数学方法。
可以使用小波变换压缩算法将信号分为不同的频带进行处理,并将每个频带中的系数进行压缩。
4.奇异值分解压缩算法奇异值分解压缩算法(Singular Value Decomposition,SVD)是一种利用奇异值分解来压缩数据的算法。
该算法将矩阵分解为三个不同的矩阵乘积的形式,其中每个矩阵的维数都较小。
使用奇异值分解压缩算法可以将原始矩阵的存储需求降低到很小的程度,并且可以在压缩后轻松地还原数据。
总的来说,矩阵压缩算法是一项非常有用的技术,可以帮助计算机科学家在处理大型数据集时节省存储空间和计算时间。
但是,每种压缩算法都有其优点和缺点,选择哪种算法取决于数据本身的特性和所需的精度。
带状矩阵压缩存储公式
带状矩阵压缩存储公式
首先,要明白的是带状对角矩阵的含义。
即所有的非零元素集中在以主对角线为中心的带状区域中,即除了主对角线和主对角线相邻两侧的若干条对角线上的元素之外,其余元素皆为零的矩阵为对角矩阵。
带状矩阵所有非0元素都集中在以主对角线为中心的带状区域,半带宽为d时,对左上角和右下角进行补“0”,如下图,则非0元素有(2d+1)*n-(1+d)*d个
当|i-j|>1时,元素a[i][j]=0.
为了节省空间(压缩),用一维数组A[]来存储
k=i*(2d+1)+d+(j-i)(k从0开始)
(i*(2d+1)表示前i行一共有几个元素,而d+(j-i)这一项是用来确定第i行中,第j列前有几个元素,如以i=j为例时,这时j-i=0)
反推公式为
i=k/5
j=k%5。
如何利用奇异值分解进行矩阵压缩(七)
矩阵压缩是一种重要的数据处理技术,在数据挖掘、图像处理、信号处理等领域都有着广泛的应用。
而奇异值分解(Singular Value Decomposition,SVD)是一种常用的矩阵分解方法,可以被用来进行矩阵压缩。
本文将介绍奇异值分解的基本原理和在矩阵压缩中的应用。
奇异值分解是一种将一个矩阵分解为三个矩阵的方法,即将一个矩阵A分解为U、Σ和V三个矩阵的乘积:A = UΣV^T。
其中,U和V是正交矩阵,Σ是一个对角矩阵,对角线上的元素称为奇异值。
奇异值分解的应用非常广泛,包括矩阵逆、最小二乘、主成分分析等,同时也可以被用来进行矩阵的压缩。
在矩阵压缩中,奇异值分解可以被用来保留矩阵中最重要的信息,同时去除一些噪音和冗余的信息,从而达到降低存储空间和计算复杂度的目的。
具体来说,通过保留奇异值较大的部分,可以近似地表示原始矩阵,从而实现矩阵的压缩。
这对于大规模数据的存储和处理非常有利。
以图像压缩为例,假设有一个m×n的图像矩阵A,可以对其进行奇异值分解:A = UΣV^T。
然后,可以只保留前k个奇异值及其对应的列向量,即将U、Σ和V分别截取为Uk、Σk和Vk。
最后,用这三个截取后的矩阵重新构造一个近似的矩阵A' = UkΣkVk^T,这个新的矩阵A'就是对原始矩阵A的压缩表示。
通过选择合适的k值,可以在保留较高图像质量的前提下,大大减少图像数据的存储空间。
除了图像压缩,奇异值分解还可以被用来进行文本压缩。
在自然语言处理中,常常会遇到大规模的文本数据,为了节省存储空间和提高计算效率,可以利用奇异值分解对文本矩阵进行压缩。
同样地,通过保留奇异值较大的部分,可以近似地表示原始文本矩阵,从而实现文本的压缩。
此外,奇异值分解还可以被用来进行音频文件的压缩。
在音频处理中,常常会遇到大规模的音频数据,为了节省存储空间和提高传输效率,可以利用奇异值分解对音频矩阵进行压缩。
同样地,通过保留奇异值较大的部分,可以近似地表示原始音频矩阵,从而实现音频的压缩。
累加矩阵压缩
累加矩阵压缩
矩阵压缩是一种将稀疏矩阵表示为更紧凑形式的方法。
稀疏矩阵是指其中大部分元素为0的矩阵。
累加矩阵压缩是一种特殊的矩阵压缩方法,可以将稀疏矩阵表示为累加矩阵的形式。
累加矩阵压缩的主要思想是将每一行的非零元素均表示为从该行的开头到该位置的累积和。
这样可以大大减少非零元素的数量,从而压缩矩阵的空间占用量。
同时,累加矩阵压缩不会引入额外的信息损失,可以通过累加运算恢复原始矩阵。
具体的累加矩阵压缩方法如下所示:
1. 初始化累加矩阵为原始矩阵的第一行;
2. 从第二行开始,将每一行的非零元素替换为从该行的开头到该位置的累积和;
3. 重复步骤2,直到处理完所有行。
下面是一个示例来说明累加矩阵压缩的过程:
原始矩阵:
1 0 0 2
0 3 0 0
0 0 0 4
累加矩阵(压缩后):
1 0 0 2
1 4 4 4
1 4 4 8
通过累加操作,原始矩阵的每一行的非零元素被替换为从开头到该位置的累积和。
可以看到,累加矩阵的非零元素数量比原始矩阵大大减少,从而实现了矩阵的压缩。
需要注意的是,累加矩阵压缩通常应用于行稀疏矩阵,即矩阵的每一行都有很少的非零元素。
对于列稀疏矩阵,可以先对矩阵进行转置,然后再进行累加矩阵压缩。
对称矩阵压缩存储
对称矩阵压缩存储对称矩阵压缩存储是一种将对称矩阵以压缩的方式存储的方法。
对称矩阵是指一个矩阵在翻转后与自己相同,即矩阵中第i行、第j列的元素等于第j行、第i列的元素。
这种矩阵在很多应用中经常出现,例如物理学中的密度矩阵、图论中的邻接矩阵等等。
存储方式举例原始矩阵M =1 0.5 00.5 2 0.50 0.5 3N = [1, 0.5, 0, 2, 0.5, 3]在对称矩阵压缩存储中,首先存储矩阵中的第一行元素,然后依次存储第1列至第n 列的下半部分,即M(i,j)(i<j)元素。
例如,在上述示例中,第一行元素为[1, 0.5, 0],第1列至第3列的下半部分元素为[0.5, 2, 0.5]。
为了更直观地理解对称矩阵压缩存储方法,我们可以将其与普通的矩阵存储方式进行比较。
假设我们用普通的矩阵存储方式将上述矩阵M存储为一个二维数组A,则该数组的形式为:可以看到,对称矩阵压缩存储省略了下三角部分的元素,而只保留了对称矩阵的上半部分元素。
这样一来,在存储大型对称矩阵时,可大大减少存储空间的需求,且能够提高数据读取和计算效率。
在压缩存储后,我们可以根据元素在一维数组N中的位置,将其还原为原始的矩阵形式。
还原的方法为:首先复制N中的第一行元素到矩阵M的第一行,然后将N中的第2至n 个元素填充至M的下三角部分,即M(j,i)(i<j)元素。
这样一来,就能够还原出原始的对称矩阵M。
总之,对称矩阵压缩存储是一种高效的存储方法,可用于存储大规模对称矩阵,其通过对称性质将矩阵压缩为一维数组,从而减少了存储空间的需求。
同时,该方法还能提高数据读取和计算效率,具有很高的实用性。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
for (m=T->elem_num-1;m>i-1;m--) { if (T->arry[m].h_num<T->arry[m-1].h_num)
void transpose_TS(TSMatrix *T);
void equal_Triple(Triple *t1,Triple *t2);
Rect.cpp
#include <stdio.h> #include <stdlib.h> #include "rect.h"
void Init_TS(TSMatrix *T) {
T->arry[n].h_num=T2->arry[j].h_num; T->arry[n].v_num=T2->arry[j].v_num; j++; n++; } } if (i>=T1->elem_num) { for (int m=j;m<T2->elem_num;m++) {
T->arry[n].elem=T2->arry[m].elem; T->arry[n].h_num=T2->arry[m].h_num; T->arry[n].v_num=T2->arry[m].v_num; n++; } } if (j>=T2->elem_num) { for (int m=i;m<T1->elem_num;m++) { T->arry[n].elem=T1->arry[m].elem; T->arry[n].h_num=T1->arry[m].h_num; T->arry[n].v_num=T1->arry[m].v_num; n++; } } T->elem_num=n;
{ equal_Triple(&W,&T->arry[m]); equal_Triple( &T->arry[m],&T->arry[m-1]); equal_Triple(&T->arry[m-1],&W);
} if (T->arry[m].h_num==T->arry[m-1].h_num) { if (T->arry[m].v_num<T->arry[m-1].v_num) { equal_Triple(&W,&T->arry[m]); equal_Triple(&T->arry[m],&T->arry[m-1]); equal_Triple(&T->arry[m-1],&W); }
T->arry=(Triple *)malloc(MAXSIZE*sizeof(Triple)); if(!T->arry) printf("error\n") ; T->elem_num=0; T->h_i=0; T->v_j=0; }
void Init_Tr(Triple *t) {
t->elem=0; t->h_num=0; t->v_num=0; }
void creat(TSMatrix *T);
void Print_TS(TSMatrix *);
void sum_TS(TSMatrix *T1,TSMatrix *T2,TSMatrix *T);
void mul_TS(TSMatrix *T1,TSMatrix *T2,TSMatrix *T);
if (T2->arry[k].h_num==T1->arry[i].v_num) {
T->arry[n].elem=T1->arry[i].elem*T2->arry[k].elem; T->arry[n].h_num=T1->arry[i].h_num; T->arry[n].v_num=T2->arry[k].v_num;
scanf("%d %d %d",&T->arry[i].h_num,&T->arry[i].v_num,&T->arry[i].elem); } };
void Print_TS(TSMatrix *T) {
printf("输出稀疏数组的信息\n"); printf("行下标列下标元素值\n"); for(int i=0;i<T->elem_num;i++) {
实验四 数组的运算
实验目的: 掌握稀疏矩阵的压缩存储方法及主要运算的实现。
实验内容与要求: 设计一个稀疏矩阵计算器,要求能够:⑴输入并建立稀疏矩阵;⑵输出稀疏矩阵;⑶执行
两个矩阵相加;⑷执行两个矩阵相乘;⑸求一个矩阵的转置矩阵;⑹求一个矩阵的逆矩阵(选 做)。 实验代码:
Rect.h
#define MAXSIZE 100
typedef struct {
int h_num; int v_num; int elem; }Triple;
typedef struct {
Triple *arry; int h_i; int v_j; int elem_num; }TSMatrix; void Init_TS(TSMatrix *T );
};
void mul_TS(TSMatrix *T1,TSMatrix *T2,TSMatrix *T) {
int i=0,j=T1->arry[0].h_num,k,n=0; while (i<T1->elem_num) {
while(j==T1->arry[i].h_num) {
for (k=0;k<T2->elem_num;k++) {
void creat(TSMatrix *T) {
printf("要输入的数组的行数和列数\n"); scanf("%d,%d",&T->h_i,&T->v_j); printf("要输入稀疏数组的元素个数\n"); scanf("%d",&T->elem_num); printf("输入要输入的稀疏数组的信息\n"); printf("行值列值元素值\n"); for(int i=0;i<T->elem_num;i++) {
} }
}
};
void equal_Triple(Triple *t1,Triple *t2) {
t1-&;h_num=t2->h_num; t1->v_num=t2->v_num; };
main.cpp
#include <stdio.h> #include <stdlib.h> #include "rect.h"
n++; } } i++; } j=T1->arry[i].h_num; } T->elem_num=n; T->h_i=T2->v_j; T->v_j=T1->h_i;
};
void transpose_TS(TSMatrix *T) {
int i; int m,n; Triple W; Init_Tr(&W); for (i=0;i<T->elem_num;i++) {
printf("%d %d %d\n",T->arry[i].h_num,T->arry[i].v_num,T->arry[i].elem); } };
void sum_TS(TSMatrix *T1,TSMatrix *T2,TSMatrix *T) {
T->h_i=T1->h_i;T->v_j=T1->v_j;
int j=0,i=0; int n=0; while(i<T1->elem_num&&j<T2->elem_num) {
if (T1->arry[i].h_num==T2->arry[j].h_num) {
if (T1->arry[i].v_num==T2->arry[j].v_num) {
T->arry[n].elem=T1->arry[i].elem+T2->arry[j].elem; T->arry[n].h_num=T1->arry[i].h_num; T->arry[n].v_num=T1->arry[i].v_num; n++; i++; j++; } else if (T1->arry[i].v_num>T2->arry[j].v_num) { T->arry[n].elem=T2->arry[j].elem; T->arry[n].h_num=T2->arry[j].h_num; T->arry[n].v_num=T2->arry[j].v_num; j++; n++; } else if (T1->arry[i].v_num<T2->arry[j].v_num) { T->arry[n].elem=T1->arry[i].elem; T->arry[n].h_num=T1->arry[i].h_num; T->arry[n].v_num=T1->arry[i].v_num; i++; n++; } } else if (T1->arry[i].h_num<T2->arry[j].h_num) { T->arry[n].elem=T1->arry[i].elem; T->arry[n].h_num=T1->arry[i].h_num; T->arry[n].v_num=T1->arry[i].v_num; i++; n++; } else if (T1->arry[i].h_num>T2->arry[j].h_num) { T->arry[n].elem=T2->arry[j].elem;