稀疏矩阵A和B均以三元组表作为储存结构时,试写出矩阵相加算法,其结果存放在三元组表C中_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
稀疏矩阵A和B均以三元组表作为储存结构时,试写出矩阵相加算法,其结果存放在三元组表C中
上传于||暂无简介
大小：2.38KB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢稀疏矩阵的加法和乘法c语言（十字链算法）_百度知道
稀疏矩阵的加法和乘法c语言（十字链算法）
for(int l=1：\k++) {
for(int l=1;k++) {
for(int l=1;.t;&#47.data[p].t;k&n&quot.v*B; if(A.m) {
printf(&maxsize)======================================&#92.i][B.n;=A;=B;
if(arow&)；能处理任意输入的典型数据和进行出错数据处理（例如乘法：A的列数不等于B的行数;n& scanf(&n&quot.n;输入错误.rpos[row++]=A,c[k][l]);%d %d %d&quot.data[k].j][B;k++) {
printf(&l++)
printf(&quot，列数和非零元个数}tripletable.data[k]; for(k=1.t).j.t*B; printf(&l++)
printf(&quot.m;n&;#define maxsize 100typedef struct{=A;矩阵的减法{输入第%d个非0元素的行数.data[p];=A.t;A输入为; } int b[100][100]={0};%d &quot.j;k&lt.data[k];=C;输入第%d个非0元素的行数：&quot.v;;=A.data[k].rpos[brow+1].n.data[k]；输出要求用矩阵的形式输出（即习题集136页的形式）;=A，列数和值;typedef struct{ triple data[maxsize]：&#92.data[C.v;
3 矩阵减法\n&%d %d %d&quot.t].n) {
printf(&n&k&).m=A,j;/=B.n; } int row=1;; for(k=1.i;
ctemp[ccol]+=A;%d &quot,k);,&B; }}void multi()
&#47.data[k]; scanf(& for(k=1;矩阵的加法{l&lt.n.t);;);k++) {
B.n.t,);B输入为;k++) {
a[A;%d &k++) {
for(int l=1;++q)
printf(&k++) {
printf(&quot,&A.v;%d %d %d&=A;
printf(&quot.i)
B; printf(&
scanf(& for(k=1.t);l++)
printf(&k&l++)
printf(&);k++) {
while(row&=B;
printf(&quot.t;=B;k&lt,&A;);l++)
printf(&=A.data[k]; scanf(&输入错误：\该非零元的值}).v.i][B; tripletable A.t.m){tp=A.data[k];&#92.rpos[arow]=C，列数和非零元个数.j; } printf(&quot.v;=B.data[k];); for(k=1;，列数和非零元个数,B;k&lt.m;=B.i][B; for(k=1.n;=B.m.j]=C;k++) {
for(int l=1,&y):&n&k&lt.data[k];
printf(&quot.n; printf(& tripletable A;;%d &quot!=B,t;
} } int shuru[100][100]={0}.v); } printf(& for(k=1,&A; } printf(&quot,&A.t];
printf(&quot.h&k++) {
for(int l=1;
C;);;矩阵的乘法{结果为;乘法结果C为;}
for(p=A.j;&#92.v).rpos[arow];n&quot,result[k][l]); } printf(&quot,&A;n&).n;.t.m，列数和非零元个数;ccol&)：&
printf(& int y.n;n&=A;A:&quot.m;k++) {
c[C.i; for(k=1;k++) {
for(int l=1.t),a[k][l]).data[p].m.i][A;l&lt：\
return.n,&A.t;k++) {
for(int l=1;C; } int b[100][100]={0}.data[q];B,&B;\);.t&%d &k&lt.m)B.n.v; tripletable A;;);l++)
b[B; for(k=1;%d %d %d&quot.data[k].n.m;;k++) {
printf(&quot: add(); }}void main(){ printf(&quot,&A,&B; scanf(&quot.t;%d &quot.data[p];
printf(&quot.data[k].data[k],&B;);l++)
printf(&n\);=B.data[k];k&lt.data[k];
scanf(&k&lt.j;);=A.data[k].m.v);=B:&quot: convert(); } C!=0) {
for(arow=1;
/&#92.data[k];=A;n&=A; } int c[100][100]={0};; printf(&quot,p; } printf(&);请选择相应操作的序号;;
printf(&quot.v;=C; for(k=1.n) {
printf(&quot.v)：\n& case 2;; } int b[100][100]={0}.rpos[row++]=k;n&//n&quot.t.rpos[arow+1];);k++) {
for(int l=1;=B;输入稀疏矩阵A的行数; for(k=1;; for(k=1.data[k]，是用采用三元组作存储结构还是数组; for(k=1,&A.data[k];&#92,&B;\ printf(&quot.t=0.i]=B.data[k];).j;n&quot；必须采用三元组作存储结构;k++) {
for(int l=1;输入第%d个非0元素的行数.t=A，列数和值.data[k];
scanf(&;k&lt.m;n&).v=ctemp[ccol];=A;k++) {
result[B;l& } printf(&quot,&A.n;
2 矩阵加法\ } printf(&quot.v.t;=A;p&lt.j;
if(brow&=B.j]=B;%d %d %d&
scanf(&quot.j=A;l&
scanf(&quot.data[k];++p)
int brow=A.t;B输入为.m;).n;;%d %d %d&quot.m;=============
单 ==============\ printf(&quot.j]=A.i; } printf(&quot.rpos[row++]=k;n&;矩阵的行数.t;=B!=B;=C;=A;
for(col=1;l& tripletable A;
printf(&quot,B;).v=A; for(k=1;&#47.i;\l++)
c[k][l]=a[k][l]-b[k][l].m;;%d %d %d&quot,&A,&A;输入第%d个非0元素的行数; } row=1;%d &
printf(&quot.t+1;).data[k],&B;C;
} } printf(&quot.j]=B.m||A; for(k=1; for(k=1.data[k];n&quot.i][A.t);=B;
} int a[100][100]={0}.m){t=B;k&lt.m.t，列数和值;k&lt.m，请重新输入\=A;k&
int m.t],&A,a[k][l]):&quot,k););.n;}
else{t=B;;非零元三元组表.data[k]; printf(&n&);\=A，当第一个矩阵的列数不等于第二个矩阵的行数时）;n&.data[k].n=A;%d %d %d&
for(q=B.t);%d %d %d&quot,c[k][l]);;=B;%d %d %d&quot.v),&A;
goto loop,c[k][l]);矩阵的转置{k&lt,&A.m; }}void add()
&#47.v;=A.data[k].data[p];l&&#47：&#92:&k&lt.data[q];k++) {
printf(&输入稀疏矩阵A的行数.n.i;k&;l++)
printf(&quot.t+1; if(B,&B;).data[k];k&lt,%d &
++q.n; }}void jian()
&#47.data[q];%d& for(k=1; for(k=1，当第一个矩阵的行数不等于第二个矩阵的行数时.data[k],&A.v;k& scanf(&,a[k][l]); } printf(&quot.n：\k&lt.j= for(k=1;该非零元的行和列 int v，不能采用数组等形式：A与B的行数或列数不相同.j]=A：&quot：\ for(k=1;k++) {
shuru[B;n&t.m)A;减法结果C为;.j;/输入稀疏矩阵A的行数.n; } if(A;k++) {
printf(& for(k=1.data[k],C,&B;l++)
printf(&quot.data[C; for(k=1.n;).data[k]; int arow:&quot.n; printf(&quot.t,k)：A与B的行数或列数不相同; } printf(&%d &
1 矩阵转置\&#92,b[k][l]);=A;.data[k].j]=B.data[k].i;%d %d %d& scanf(&=B;}
else{tp=A,&A;++col)
for(int p=1;n&=C; } printf(&quot，注意如第三个乘法的形式输出******************************************************************************************#include&加法结果C为; scanf(&k++) {
while(row&lt.m=A,B.m;
printf(&q& for(k=1,&A;).n=B;col&
printf(&quot.m!=B.data[C; case 3，请重新输入\\
printf(&输入稀疏矩阵B的行数;n&),&A;++arow)
int ctemp[maxsize]={0};
C; if(A;输入稀疏矩阵B的行数;k++) {
for(int l=1.data[k];&#92.t+1;); for(k=1，data[0]未用 int rpos[maxsize];n&++p)
if(A;%d %d %d&A输入为;;l++)
printf(&quot.i][C.i)
scanf(&B.t+1，列数和非零元个数;k&l++)
printf(&quot,&B;).j;=B; } int c[100][100]={0};k&lt,&A;tp.m;l++)
c[k][l]=a[k][l]+b[k][l].m; } int c[100][100]={0}: printf(&=A;);;
} } while(row&lt.j]=A,k);stdio.t;输入稀疏矩阵A的行数.data[k]: jian();l&lt.t.n; } B,q.m; for(k=1;);%d %d %d&=B;n&quot!=B：&#92：&k&lt，列数和非零元个数.t+1;n&=A;&#47!=B.i=A; printf(&%d &quot.t);=B;k&lt,&B,&B;&#92.v);;=B,n,&B，列数和值.i][B;k&l&lt,&A;void convert()
/=A.data[k].n;l&=B;),&A.t: multi(),t;n&quot,&B.data[q];=A,&B,&B，列数和值;n&); printf(&quot：&k++) {
for(int l=1.rpos[row++]=B.m.data[k];B输入为.m,&A.rpos[brow];k&lt,k),&A;k&lt.n;),k);
} } printf(&输入第%d个非0元素的行数;
} } while(row&l&lt.i;k&l&p&=B.i=arow.m，列数和非零元个数;输入第%d个非0元素的行数;
C.data[k]：&#92.j]=B.data[k];k++) {
for(ccol=1;);n&.n;A输入为; } int a[100][100]={0}.t.data[k];输入第%d个非0元素的行数.n.data[k].data[k].t;\l&lt.data[k],b[k][l]).j;k&lt.data[k],b[k][l]).data[k];=A.v;n&\k&=B:&quot,&A;
return.j==col)
B; } if(A.m||A;
/n&quot,shuru[k][l]).i][A;\%d &k++) {
a[A;k++) {
for(int l=1：& for(k=1:&quot.data[p];输入稀疏矩阵B的行数;l&).m; for(k=1;n&quot.v);n& } int a[100][100]={0};k&
/%d %d %d&quot,++ccol)
if(ctemp[ccol])
if(++C.data[k]; for(k=1; for(k=1、乘法和转置;n&quot,k);k++) {
printf(&quot你没有写具体要求.data[k];);输入错误.data[k],&B; for(k=1：&=A，下面是我们以前做过的数据结构习题你参考一下;arow&lt.m.t) {
int q=1.t;)：能区分加法.data[q]：\ for(k=1; } int result[100][100]={0}.data[k]，列数和值;输入为,&B; switch(y) { case 1;=A，请重新输入\);); case 4，列数和非零元个数、减法,&B.i;k++) {
printf(&n&quot,B.data[k];=A;k++) {
printf(& scanf(&
printf(&);
4 矩阵乘法&#92，列数和值
其他类似问题
为您推荐：
稀疏矩阵的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁如果在中，多数的为0，称此矩阵为稀疏矩阵（sparse
matrix）。
矩阵中非零元素的个数远远小于矩阵元素的总数，并且非零元素的分布没有规律，则称该矩阵为(sparse
matrix)；与之相区别的是，如果非零元素的分布存在规律（如上三角矩阵、下三角矩阵、对称矩阵），则称该矩阵为。
稀疏矩阵的计算速度更快,因为M AT L A B只对非零元素进行操作,这是稀疏矩阵的一个突出的优点.
假设矩阵A,B中的矩阵一样.计算2*A需要一百万次的浮点运算,而计算2*B只需要2 0 0 0次浮点运算.
因为M AT L A B不能自动创建稀疏矩阵,所以要用特殊的命令来得到稀疏矩阵.
前面章节中的算术和都适用于稀疏矩阵.
对于一个用二维数组存储的稀疏矩阵Amn,如果假设存储每个数组元素需要L个字节,那么存储整个矩阵需要m*n*L个字节.但是,这些存储空间的大部分存放的是0元素,从而造成大量的空间浪费.为了节省存储空间，可以只存储其中的非0元素.
对于矩阵Amn的每个元素aij,知道其行号i和列号j就可以确定其位置.因此对于稀疏矩阵可以用一个结点来存储一个非0元素.该结点可以定义如下:
该结点由3个域组成,i:行号,j:列号;aij元素值.这样的结点被称为结点.矩阵的每一个元素Qij,由一个三元组结点(i,j,aij)唯一确定.
例如稀疏矩阵A:
-30 0 -60 5
其对应的三元组表为：
高斯一个稀疏矩阵中有许多元素等于零,这便于矩阵的计算和保存.如果把一个矩阵当作稀疏矩阵,那么只需在m&3的矩阵中存储m个非零项.第1列是行下标,第2列是列下标,第3列是非零元素值,不必保存零元素.如果存储一个要8个字节,存储每个下标要4个字节,那么整个矩阵在内存中存储需要1
6&m个字节.
A = e y e ( 1 0 0 0 ) ;
得到一个1 0 0 0&1 0 0 0的,存储它需要8
Mb空间.如果使用命令:
B = s p e y e ( 1 0 0 0 ) ;
用一个1 0 0 0&3的矩阵来代表,每行包含有一个行下标,列下标和元素本身.只需1 6 K b的空间就可以存储1 0 0 0&1 0
0 0的单位矩阵,它只需要满单位矩阵的0 . 2 %存储空间.对于许多的广义矩阵也可这样来作.
在M AT L A B中,用命令s p a r s e来创建一个稀疏矩阵.
命令集8 7创建稀疏矩阵
s p a r s e ( A )由非零元素和下标建立稀疏矩阵A.如果A已是一个稀疏矩阵,则返回A本身.
s p a r s e ( m , n )生成一个m&n的所有元素都是0的稀疏矩阵.
s p a r s e ( u , v , a )生成一个由长度相同的u,v和a定义的稀疏矩阵.其中u和v是整数向量,a是一个实数或者复数向量.(ui,
vi)对应值ai,如果a中有零元素,则将这个元素排除在外.
稀疏矩阵的大小为m a x (u)&m a x (v).
s p a r s e ( u , v , a , m , n )生成一个m&n的稀疏矩阵,(ui,
vi)对应值ai.向量u,v和a必须长度相同.
s p a r s e ( u , v , a , m , n ,生成一个m&n的含有n z m a
x个非零元素的稀疏矩阵.(ui,n z m a x )vi)对应值ai.n z m a
x的值必须大于或者等于向量u和v的长度.
f i n d ( x )返回向量x中非零元素的下标.如果x=X是一稀疏矩阵个矩阵,那么X的向量就作为一个长向量来考虑.
[ u , v ] = f i n d ( A )返回矩阵A中非零元素的下标.
[ u , v , s ] = f i n d ( A
)返回矩阵A中非零元素的下标.用向量s中元素的值及u和v中相应的下标,实际上就是向量u,v和s作为命令s p a r s
s p c o n v e r t ( D
)将一个有三列的矩阵转换成一个稀疏矩阵.D中的第1列作为行的下标,第2列作为列的下标,最后一列作为元素值.而且可以使用命令f u l
l将稀疏矩阵转换成一个满矩阵.
命令集8 8转换成满矩阵
f u l l ( S )将稀疏矩阵S转换成一个满矩阵.
a) 创建一个5&5的单位矩阵:
A = e y e ( 5 )
将矩阵A转换成稀疏矩阵B:
(b) 假设M AT L A B中给出如下的向量:
这样就有了,但是也可使用.运行命令S m
a t r i x = s p a r s e ( i n d 1 , i n d 2 , n u m b e r ),
其中有去掉了两个零元素.将这个矩阵转换成满矩阵,输入:
F u l l m a t r i x = f u l l ( S m a t r i x )
得到的结果为:
注意,稀疏矩阵和得到的满矩阵的大小是分别是由i n d 1和i n d 2中最大元素值确定的,即
使相应的值是零,并且在列出的稀疏矩阵中去掉这个值.
输入命令w h o s可得到:
可以看出虽然两个矩阵的大小相同,但是其中稀疏矩阵需要的存储空间更小些.
(c) 在处理稀疏矩阵时f i n d命令很有用.命令对于稀疏矩阵或者满矩阵都返回相同的结果.
返回得到的三个向量直接用来重新创建一个稀疏矩阵.令S m a t r i x定义在( b )中,运行命令:
得到的结果为:
用下面命令得到的矩阵和( b )中得到的矩阵是不一样的:
M AT L A B中对满矩阵的运算和函数同样可用在稀疏矩阵中.结果是稀疏矩阵还是满矩阵,
这取决于运算符或者函数及下列的操作数:稀疏矩阵的压缩存储当函数用一个矩阵作为输入参数,输出参数为一个标量或者一个给定大小的向量时,输出参数的格式总是返回一个满阵形式,如命令s
当函数用一个标量或者一个向量作为输入参数,输出参数为一个矩阵时,输出参数的格式也总是返回一个满矩阵,如命令e y
e.还有一些特殊的命令可以得到稀疏矩阵,如命令s p e y e.
对于单参数的其他函数来说,通常返回的结果和参数的形式是一样的,如d i a g.
对于双参数的运算或者函数来说,如果两个参数的形式一样,那么也返回同样形式的结果.在两个参数形式不一样的情况下,除非运算的需要,均以满矩阵的形式给出结果.
两个矩阵的组和[A B],如果A或B中至少有一个是满矩阵,则得到的结果就是满矩阵.
表达式右边的冒号是要求一个参数的运算符,遵守这些运算规则.
表达式左边的冒号不改变矩阵的形式.
这是一个5&5的单位满矩阵和相应的稀疏矩阵.
(a) C = 5*B,结果为:
这是一个稀疏矩阵.
(b) D = A + B,给出的结果为:
这是一个满矩阵.
(c) x = B \ h,结果为:
这是一个满向量.
有许多命令可以对非零元素进行操作.
命令集8 9矩阵的非零元素
n n z ( A )求矩阵A中非零元素的个数.它既可求满矩阵也可求稀疏矩阵.
s p y ( A )画出稀疏矩阵A中非零元素的分布.也可用在满矩阵中,在
这种情况下,只给出非零元素的分布.
s p y ( A , c s t r , s i z e )用指定的颜色c s t r(见表1 3 - 1 )和在s i z
e规定的范围内画出稀疏
矩阵A中非零元素的分布.
n o n z e r o s ( A )按照列的顺序找出矩阵A中非零的元素.
s p o n e s ( A )把矩阵A中的非零元素全换为1.
s p a l l o c ( m , n ,产生一个m&n阶只有n z m a x个非零元素的稀疏矩阵.这样可以
n z m a x )有效地减少存储空间和提高运算速度.
n z m a x ( A )给出为矩阵A中非零的内存数.不一定和n
n z ( A )得
到的数相同;参见s p a r s e或者s p a l l o c.
i s s p a r s e ( A )如果矩阵A是稀疏矩阵,则返回1;否则返回0.
s p f u n ( f c n , A )用A中所有非零元素对f c
n求值,如果函数不是对稀疏矩
阵定义的,同样也可以求值.
s p r a n k( A )求稀疏矩阵A的结构秩.对于所有的矩阵来说,都有
s p r a n k ( A）≥r a n k ( A ).
用下面的命令定义稀疏矩阵:
创建一个大矩阵:
稀疏矩阵Big=(A,
这个矩阵B i g是什么样子呢?
K r o n e c k e r给出一个大矩阵,它的元素是矩阵A的元素之间可能的乘积.因为参量都是稀疏矩阵,所以得到的矩阵也是一个稀疏矩阵.可以用命令
w h o s和i s s p a r s e来确认一下.
查看矩阵B i g的结构图,可输入s p y ( B i g ),结构图如右图所示. 从图中可以看出B i
g是一个块双对角矩阵.
MATLAB中有四个基本稀疏矩阵,它们是单位矩阵,,对称随机矩阵和对角矩阵.
命令集9 0单位稀疏矩阵
s p e y e ( n )生成n&n的单位稀疏矩阵.
s p e y e ( m , n )生成m&n的单位稀疏矩阵.
命令speye(A) 得到的结果和s p a r s e ( e y e ( A ) )是一样的,但是没有涉及到满阵的存储.
命令集9 1随机稀疏矩阵
s p r a n d ( A )生成与A有相同结构的随机稀疏矩阵,且元素服从均匀分布.
s p r a n d ( m , n , d e n s )生成一个m&n的服从均匀分布的随机稀疏矩阵,有d e n
n个非零元素,0≤d e n s≤1.参数d e n s是非零元素的分布密度.
s p r a n d ( m , n , d e n s ,生成一个近似的为1
/rc,大小为m&n的随机稀疏矩
r c )阵.如果rc=rc是一个长度为l≤l ( m i n (m, n) )的向量,那么
矩阵将rci作为它l个奇异值的第一个,其他的奇异值为0.
s p r a n d n ( A )生成与A有相同结构的随机稀疏矩阵,且元素服从.
s p r a n d n ( m , n , d e n s ,生成一个m&n的服从正态分布的随机稀疏矩阵,和sprand
r c )一样.
s p r a n d s y m ( S
)生成一个随机对称稀疏矩阵.它的下三角及主对角线部分与S的结构相同,矩阵元素服从.
s p r a n d s y m ( n , d e n s )生成一个m&n的随机对称稀疏矩阵.矩阵元素服从正态分布,分布密度为d
s p r a n d s y m ( n , d e n s ,生成一个近似为1
/rc的随机对称稀疏矩阵.元素以0r c )对称分布,但不是.如果rc=rc是一个向量,则矩阵有rci.也就是说,如果rc是一个正向量,则矩阵是.
s p r a n d s y m ( n , d e n s ,生成一个矩阵.如果k=
1,则矩阵是由一正定对称矩r c , k )阵经随机J a c o b i旋转得到的,其正好等于1
/如果k= 2,则矩阵为的换位和,其近似等于1
s p r a n d s y m ( S , d e n s ,生成一个与矩阵S结构相同的稀疏矩阵,近似为1
r c , 3 )参数d e n s被忽略,但是这个参数在这个位置以便能确认最后两个参数的正确与否.
(a) 假设有矩阵A:
输入R a n d o m = s p r a n d n ( A ),可得到随机稀疏矩阵:
矩阵中随机数的位置和矩阵A中非零元素的位置相同.
(b) 对于( a )中的矩阵A,输入:
B = s p r a n d s y m ( A )
这是一个用矩阵A的下三角及主对角线部分创建的,在非零元素的位置用随机数作为元素值.
用命令s p d i a g s可以取出对角线元素,并创建带状.假设矩阵A的大小为m&n,
稀疏矩阵在p个上有非零元素.B的大小为m
i n (m&n)&p,它的列是矩阵A的对角线.向量d的长度为p,其整型分量给定了A的对角元:
di0 主对角线上的对角线
命令集9 2对角稀疏矩阵
[ B , d ] = s p d i a g s ( A
)求出A中所有的对角元,对角元保存在矩阵B中,它们的下标保存在向量d中.
s p d i a g s ( A , d )生成一个矩阵,这个矩阵包含有矩阵A中向量d规定的对角元.
s p d i a g s ( B , d , A )A,用矩阵B中的列替换d定义的对角元.
A = s p d i a g s ( B , d , m , n )用保存在由d定义的B中的对角元创建稀疏矩阵A.
例11 . 4给出了如何使用s p d i a g s命令来解普通微分方程组.
稀疏矩阵在许多实际应用中要保留稀疏矩阵的结构,但是在计算过程中的中间结果会减弱它的稀疏性,如L
U分解.这就会导致增加浮点运算次数和存储空间.为了避免这种情况发生,在第稀疏矩阵1 2 9
M AT L A B中用命令对矩阵进行重新安排.这些命令都列在下面的命令集9 3中.通过h e l p命令
可以得到每个命令更多的帮助信息,也可见h e l p d e s k.
c o l m m d ( A )返回一个变换向量,使得矩阵A列的秩为最小.
s y m m m d ( A )返回使对称矩阵秩为最小的变换.
s y m r c m ( A )矩阵A的C u t h i l l - M c K e e逆变换.矩阵A的非零元素在附近.
c o l p e r m ( A )返回一个矩阵A的列变换的向量.列按非零元素升序排列.有时这是L U前有用的变换:lu(A(:,
j)).如果A是一个对称矩阵,对行和列进行排序,这有利于C h o l e s k y分解:chol(A(j, j)).
r a n d p e r m ( n )给出正数1,2,. . .,n的随机排列,可以用来创建随机变换矩阵.
d m p e r m ( A )对矩阵A进行D u l m a g e - M e n d e l s o h n分解,输入help
dmperm可得更多信息.
创建一个秩为4的,可输入:
一旦运行p e r m = r a n d p e r m ( 4 ),就会得到:
给出的变换矩阵为:
如果矩阵A为:
运行结果为:
有两个不完全命令,它们是用来在解大前进行预处理的.用h
e l p d e s k命令可得更多信息.命令集9 4不完全因式分解c h o l i n c ( A , o p t
)进行不完全C h o l e s k y分解,变量o p t取下列值之一:
d r o p t o l指定不完全分解的舍入误差,0给出完全分解.
m i c h o l如果m i c h o l = 1,则从对角线上抽取出被去掉的元素.
r d i a g用s q r t ( d r o p t o l*n o r m ( X ( : , j ) )
)代替上三角分
解因子中的零元素,j为零元素所在的列.
[ L , U , P ]=返回矩阵X的不完全分解得到的三个矩阵L,U和P,变量o p t取
l u i n c ( X , o p t )下列值之一:
d r o p t o l指定分解的舍入误差.
m i l u改变分解以便从上三角角分解因子中抽取被去掉的列元素.
u d i a g用d r o p t o l值代替上三角角分解因子中的对角线上的零元素.
t h r e s h中心极限.
解稀疏线性方程组既可用左除运算符解,也可用一些特殊命令来解.
命令集9 5稀疏矩阵和线性方程组
s p p a r m s ( k e y s t r , o p )设置稀疏矩阵算法的参数,用help
spparms可得详细信息.
s p a u g m e n t ( A , c )根据[ c*l A; A' 0 ]创建稀疏矩阵,这是二次线性方程组的最
小二乘问题.参见7 . 7节.
s y m b f a c t ( A )给出稀疏矩阵的C h o l e s k y和L U的符号分解因子.
用help symbfact可得详细信息.
稀疏矩阵的计算和普通满矩阵的范数计算有一个重要的区别.稀疏矩阵的不能直接求得.如果稀疏矩阵是一个小矩阵,则用n
o r m ( f u l l ( A ) )来计算它的;但是对于大矩阵来说,这样计算是不可能的.然而M
AT L A B可以计算出欧几里德的近似值,在计算时也是一样.
命令集9 6稀疏矩阵的近似欧几里德范数和条件数
n o r m e s t ( A )计算A的近似欧几里德,为1
n o r m e s t ( A , t o l )计算A的近似欧几里德范数,设置t
o l,而不用缺省时的1 0-6.
[ n r m , n i t ] =计算近似n r m范数,还给出计算范数迭代的次数n i t.
n o r m e s t ( A )
c o n d e s t ( A )求矩阵A的1
-范数中的下界估计值.
[ c , v ]=求矩阵A的1 -范数中的下界估计值c和向量v,使得
c o n d e s t ( A , t r )| |Av| | = ( | |A| | | |v| | ) / c.如果给定t
r,则给出计算的过程.t r= 1,
给出每步过程;t r=-1,给出商c / r c o n d ( A ).
用n o r m A p p r o x = n o r m e s t ( S p r s )计算出:
用t h e N o r m = n o r m ( f u l l ( S p r s ) )得:
为了找到它们之间的差别,计算d i f f e r e n c e = t h e N o r m - n o r m A p p r
在许多应用中,n o r m e s t计算得到的近似值是一个很好的近似欧几里德范数,它的计算步数要比n o r m要少得多;可参见7
用e t r e e命令来找到稀疏对称矩阵的消元树,用向量f来描述消元树,还可用e t r e e p l o
t命令画出来.元素fi是矩阵的上三角C h o l e s k y分解因子中i行上第1非零元素的列下标.如果有非零元素,则fi=
0.消元树可以这样来建立:
节点i是fi的孩子,或者如果fi= 0,则节点i是树的根节点.
命令集9 7矩阵的消元树
e t r e e ( A )求A的消元树向量f,这个命令有可选参数;输入h e l p
e t r e e获取帮助.
e t r e e p l o t ( A )画出向量f定义的消元树图形.
t r e e p l o t ( p , c , d )画出指针向量p的树图形,参数c和d分别指定节点的颜色和分支数.e t r e
e p l o t可以调用这个命令.
t r e e l a y o u t显示树的结构,t r e e p l o t可以调用这个命令.
假设有对称稀疏矩阵B:
运行命令b t r e e = e t r e e ( B ),结果为:
开始的数字2不难理解,它是矩阵的第1列上第1个非零元素的行数,它决定了在C h o l e s k
y分解因子的第1行第2列处有一个非零元素.当缩减第1列的元素时就得到第2列的数字5.B在缩减后,在( 5 , 2
)位置的元素是非零的,这样消元树向量中第2个元素的值为5.
s p y ( c h o l ( B ) )给出了C h o l e s k y分解因子的结构图,如图9 - 2所示:
图9-2 Cholesky分解结构图
图9-3 矩阵B的消元树
这个向量消元树可以这样来建立:上三角中只有一行有非零元素,节点8,因此这就是树
稀疏矩阵唯一的根.节点1是节点2的孩子,节点2和3是节点5的孩子,而节点5是节点6的孩子.节点4和6是节点7的孩子,而节点7又是节点8的孩子,即根的孩子.
命令e t r e e p l o t ( B )给出了树的结构图,如图9 - 3所示.
消元树的形状取决于列和行序,它可以用来分析消元过程.
用g p l o t命令可以画出坐标和矩阵元素间的联系图形.必须在n&2的矩阵中给出n个坐标,
矩阵的每一行作为一个点.这样就创建出点点之间连接的n&n矩阵,如果点4连接到点8,则(4,
8)的值为1.由于是一个大矩阵,而且非零元素较少,所以它应该被建成稀疏矩阵.
这个图可以说明网络问题,如传递问题.它还包含有中未知量之间的相关信息.
命令集9 8网络图形
g p l o t ( A , K )如果矩阵A的a(i, j)不为0,则将点ki连接到点kj.K是一个n&
2的坐标矩阵,A是一个n&n的关联矩阵.
g p l o t ( A , K , s t r )用字符串s t r给定的颜色和线型画出的同上图形.字符串s t r的
取值参见表1 3 - 1.
[ X , A ] = u n m e s h ( E )求边界矩阵E的L a
p l a c e矩阵A和网格点的坐标矩阵X.
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。