MATLAB基本矩阵运算.docx
《MATLAB基本矩阵运算.docx》由会员分享，可在线阅读，更多相关《MATLAB基本矩阵运算.docx（25页珍藏版）》请在冰点文库上搜索。
MATLAB基本矩阵运算
BasicMatrixOperations
一、实验目的
1、掌握向量和矩阵的创建方法；
2、掌握向量和矩阵元素的索引方法；
3、掌握向量和矩阵的基本操作；
4、利用MATLAB编写程序进行矩阵运算。
二、基础知识
1、常见数学函数
函数名
数学计算功能
函数名
数学计算功能
Abs（x）
实数的绝对值或复数的幅值
floor（x）
对x朝-∞方向取整
Acos（x）
反余弦arcsinx
gcd（m，n）
求正整数m和n的最大公约数
acosh（x）
反双曲余弦arccoshx
imag（x）
求复数x的虚部
angle（x）
在四象限内求复数x的相角
lcm（m，n）
求正整数m和n的最小公倍数
asin（x）
反正弦arcsinx
log（x）
自然对数（以e为底数）
asinh（x）
反双曲正弦arcsinhx
log10（x）
常用对数（以10为底数）
atan（x）
反正切arctanx
real（x）
求复数x的实部
atan2（x,y）
在四象限内求反正切
Rem（m，n）
求正整数m和n的m/n之余数
atanh（x）
反双曲正切arctanhx
round（x）
对x四舍五入到最接近的整数
ceil（x）
对x朝+∞方向取整
sign（x）
符号函数：
求出x的符号
conj（x）
求复数x的共轭复数
sin（x）
正弦sinx
cos（x）
余弦cosx
sinh（x）
反双曲正弦sinhx
cosh（x）
双曲余弦coshx
sqrt（x）
求实数x的平方根：
x
exp（x）
指数函数xe
tan（x）
正切tanx
fix（x）
对x朝原点方向取整
tanh（x）
双曲正切tanhx
2、常量与变量
系统的变量命名规则：
变量名区分字母大小写；变量名必须以字母打头，其后可以是任意字母，数字，或下划线的组合。
此外，系统内部预先定义了几个有特殊意义和用途的变量，见下表：
特殊的变量、常量
取值
ans
用于结果的缺省变量名
pi
圆周率π的近似值（3.1416）
eps
数学中无穷小（epsilon）的近似值（2.2204e-016）
inf
无穷大，如1/0=inf（infinity）
NaN
非数，如0/0=NaN（NotaNumber），inf/inf=NaN
i，j
虚数单位：
i=j=1−
数值型向量（矩阵）的输入
①任何矩阵（向量），可以直接按行方式……输入每个元素：
同一行中的元素用逗号（，）或者用空格符来分隔；行与行之间用分号（；）分隔。
所有元素处于一方括号（[]）内；
例1：
>>Time=[111212345678910]
>>X_Data=[2.323.43；4.375.98]
②系统中提供了多个命令用于输入特殊的矩阵：
函数
功能
函数
功能
compan
伴随阵
toeplitz
Toeplitz矩阵
diag
对角阵
vander
Vandermonde矩阵
hadamard
Hadamard矩阵
zeros
元素全为0的矩阵
hankel
Hankel矩阵
ones
元素全为1的矩阵
invhilb
Hilbert矩阵的逆阵
rand
元素服从均匀分布的随机矩阵
kron
Kronercker张量积
randn
元素服从正态分布的随机矩阵
magic
魔方矩阵
eye
对角线上元素为1的矩阵
pascal
Pascal矩阵
meshgrid
由两个向量生成的矩阵
上面函数的具体用法，可以用帮助命令help得到。
如：
meshgrid（x,y）
输入x=[1234];y=[105];[X,Y]=meshgrid（x,y），则
X=Y=
12341111
12340000
12345555
目的是将原始数据x，y转化为矩阵数据X，Y。
3、数组（矩阵）的点运算
运算符：
+（加）、-（减）、./（右除）、.\（左除）、.^（乘方），
例3：
>>g=[1234]；h=[4321]；
>>s1=g+h,s2=g.*h,s3=g.^h,s4=g.^2,s5=2.^h
4、矩阵的运算
运算符：
+（加）、-（减）、*（乘）、/（右除）、\（左除）、^（乘方）、’（转置）等；
常用函数：
det（行列式）、inv（逆矩阵）、rank（秩）、eig（特征值、特征向量）、rref（化矩阵为行最简形）
例4：
>>A=[20–1;132];B=[17–1;423;201];
>>M=A*B%矩阵A与B按矩阵运算相乘
M=
014-3
171310
>>det_B=det（B）%矩阵A的行列式
det_B=
20
>>rank_A=rank（A）%矩阵A的秩
rank_A=
2
>>inv_B=inv（B）%矩阵B的逆矩阵
inv_B=
0.1000-0.35001.1500
0.10000.1500-0.3500
-0.20000.7000-1.3000
>>[V,D]=eig（B）%矩阵B的特征值矩阵V与特征向量构成的矩阵D
=
7.268000
0-1.6340+0.2861i0
00-1.6340-0.2861i
>>X=A/B%A/B=A*B-1，即XB=A，求X
0.4000-1.40003.6000
0.00001.5000-2.5000
>>Y=B\A%B\A=B-1*A，即BY=A，求Y
三、实验内容
1、练习数据和符号的输入方式，将前面的命令在命令窗口中执行通过。
2、键入常数矩阵输入命令：
a=[123]与a=[1;2;3]
记录结果，比较显示结果有何不同；
b=[125]与b=[125];
记录结果，比较显示结果有何不同；
aa’bb’
记录结果，比较变量加“’”后的区别；
c=a*b125
2410
3615
c=a*b’
记录显示结果与出错原因；
a=[123;456;780]，求a^2
a^0.5
。
303615
668142
395469
0.5977+0.7678i0.7519+0.0979i0.5200-0.4680i
1.4102+0.1013i1.7741+0.6326i1.2271-0.7467i
1.2757-1.0289i1.6049-1.0272i1.1100+1.6175i
3、使用冒号选出指定元素：
已知A=[123;456;789]，求A中第3列前2个元素，A中所有列第2，3行的元素。
ns=
3
6
ns=
456
780
4、输入A=[715;256;315]，B=[111;222;333]，在命令窗口中执行下列表达式，掌握其含义：
A（2,3）
ans=
6
A（:
2）
A（3,:
）A（:
1:
2:
3）
ans=
75
26
35
A（:
3）.*B（:
2）
ns=
5
12
15
A（:
3）*B（2,:
）A*BA.*BA^2A.^2B/AB./A
5、建立M文件，求
的逆矩阵。
nv_M=
1.00003.0000-2.0000
-1.5000-3.00002.5000
1.00001.0000-1.0000
6、设
，建立M文件，求矩阵X，使满足：
AXB=C。
四，详细设计
（1）存储要点
position[col]=position[col-1]+num[col-1];
三元组表（row，col，v）
稀疏矩阵（（行数m，列数n，非零元素个数t），三元组，...，三元组）
row
col
v
A->data[0]
0
4
8
1
1
0
1
2
1
2
3
3
2
1
2
4
3
0
6
…
…
…
max-1
（2）乘法运算要点
已知稀疏矩阵A（m1×n1）和B（m2×n2），求乘积C（m1×n2）。
稀疏矩阵A、B、C及它们对应的三元组表A.data、B.data、C.data如图6所示。
由矩阵乘法规则知：
C（i，j）=A（i,1）×B（1,j）+A（i,2）×B（2,j）+…+A（i,n）×B（n,j）=
这就是说只有A（i,k）与B（k,p）（即A元素的列与B元素的行相等的两项）才有相乘的机会，且当两项都不为零时，乘积中的这一项才不为零。
矩阵用二维数组表示时，a11只有可能和B中第1行的非零元素相乘，a12只有可能和B中第2行的非零元素相乘，…，而同一行的非零元是相邻存放的，所以求c11和c12同时进行：
求a11*b11累加到c11，求a11*b12累加到c12，再求a12*b21累加到c11，再求a12*b22累加到c22.，…，当然只有aik和bkj（列号与行号相等）且均不为零（三元组存在）时才相乘，并且累加到cij当中去。
（3）稀疏矩阵的快速转置要点：
矩阵A中三元组的存放顺序是先行后列，对同一行来说，必定先遇到列号小的元素，这样只需扫描一遍A.data。
所以需引入两个向量来实现：
num[n+1]和position[n+1]，num[col]表示矩阵A中第col列的非零元素的个数（为了方便均从1单元用起），position[col]初始值表示矩阵A中的第col列的第一个非零元素在B.data中的位置。
于是position的初始值为：
position[1]=1;
position[col]=position[col-1]+num[col-1];2≤col≤n
依次扫描A.data，当扫描到一个col列元素时，直接将其存放在B.data的position[col]位置上，position[col]加1，position[col]中始终是下一个col列元素在B.data中的位置。
A->row[0]
0
1
1
2
3
3
4
（4）逆矩阵
⒈判断矩阵是否为方阵
⒉逆矩阵的算法：
①求行列式的值
②求矩阵的伴随矩阵
③用伴随矩阵除以行列式
⒊求逆矩阵的流程：
五、源程序（测试结果）
#include
#include
#include
#include
usingnamespacestd;
#definemax100
#definedatatypeint
typedefstruct{
introw,col;//行，列
datatypev;//非0数值
}Node;
typedefstruct{
Nodedata[max];//稀疏矩阵
intm,n,t;//m行，n列，t非0数个数
}Matrix;
/*求逆矩阵存储*/
typedefstruct{//存储结构
intm,n;//行、列数
double*p;//矩阵基址
}nMatrix;
voidIn（nMatrixa）{//求逆输入
cout<<"请将矩阵a的行、列数再次输入：
";
cin>>a.m>>a.n;
intm=a.m,n=a.n;
inti,j;
double*p=a.p=newdouble[m*n];//p是行指针
cout<<"请按行优先输入矩阵a的全部数值：
\n";
for（i=0;i{
for（j=0;jcin>>p[j];//即a.p[i*n+j]
}
}
voidOut（nMatrixa）{//求逆输出
intm=a.m,n=a.n;
inti,j;
double*p=a.p;
for（i=0;i{
for（j=0;jcout<cout<}
}
istream&operator>>（istream&input,Matrix&A）{
inti;
cout<<"请输入行数:
";
input>>A.m;
cout<<"请输入列数:
";
input>>A.n;
cout<<"请输入非0值个数:
";
input>>A.t;
for（i=1;i<=A.t;i++）{
cout<<"请输入行数，列数，非0值:
"<<"（"<input>>A.data[i].row>>A.data[i].col>>A.data[i].v;
}
returninput;
}
ostream&operator<<（ostream&output,Matrix&A）{
inti,j,t=1,k=0;
for（i=1;i<=A.m;i++）{
for（j=1;j<=A.n;j++）{
if（A.data[t].row==i&&A.data[t].col==j）{
output<t++;}
else
output<}
cout<<"\n";
}
returnoutput;
}
Matrixoperator+（MatrixA,MatrixB）{//加法
inti,j,k;
MatrixC;
if（A.m!
=B.m||A.n!
=B.n）{
cout<<"这两个矩阵不能相加"<exit（0）;}
C.m=A.m;C.n=A.n;
C.t=0;
if（A.t==0&&B.t==0）exit（0）;
i=j=k=1;
while（i<=A.t&&j<=B.t）{
if（A.data[i].rowC.data[k]=A.data[i];
i++;k++;
}
else{
if（A.data[i].row>B.data[j].row）{
C.data[k]=B.data[j];
j++;k++;
}
else{
if（A.data[i].colC.data[k]=A.data[i];
i++;k++;
}
else{
if（A.data[i].col>B.data[j].col）{
C.data[k]=B.data[j];
j++;k++;
}
else{
if（A.data[i].v+B.data[j].v!
=0）{
C.data[k].row=A.data[i].row;
C.data[k].col=A.data[i].col;
C.data[k].v=A.data[i].v+B.data[j].v;
k++;
}
i++;j++;
}
}
}
}
}
while（iC.data[k]=A.data[i];
i++;k++;
}
while（jC.data[k]=B.data[j];
j++;k++;
}
C.t=k;
returnC;
}
Matrixoperator-（MatrixA,MatrixB）{
MatrixC;
inti,j,k;
if（A.m!
=B.m||A.n!
=B.n）
{
cout<<"这两个矩阵不能相减";exit（0）;}
C.m=A.m;C.n=A.n;
C.t=0;
if（A.t==0&&B.t==0）exit（0）;
i=j=k=1;
while（i<=A.t&&j<=B.t）
{if（A.data[i].row{C.data[k]=A.data[i];
i++;k++;
}
else
{if（A.data[i].row>B.data[j].row）
{C.data[k]=B.data[j];
j++;k++;
}
else
{if（A.data[i].col{C.data[k]=A.data[i];
i++;k++;
}
else
{if（A.data[i].col>B.data[j].col）
{C.data[k]=B.data[j];
j++;k++;
}
else
{if（A.data[i].v-B.data[j].v!
=0）
{C.data[k].row=A.data[i].row;
C.data[k].col=A.data[i].col;
C.data[k].v=A.data[i].v-B.data[j].v;
k++;
}
i++;j++;
}
}
}
}
}
while（i{C.data[k]=A.data[i];
i++;k++;
}
while（j{C.data[k]=B.data[j];
j++;k++;
}
C.t=k;
returnC;
}
Matrixoperator*（MatrixA,MatrixB）{
MatrixC;
intk,p,crow,brow,q,ccol;
intnum[max],pos[max],ctemp[max];
if（A.n==B.m）{
for（k=1;k<=B.m;k++）
num[k]=0;
for（k=1;k<=B.t;k++）
num[B.data[k].row]++;
pos[1]=1;
for（k=2;k<=B.t;k++）
pos[k]=pos[k-1]+num[k-1];
pos[1+B.t]=pos[B.t]+1;
C.m=A.m;C.n=B.n;C.t=0;p=1;
while（p<=A.t）{
crow=A.data[p].row;
for（k=1;k<=C.n;k++）
ctemp[k]=0;
while（p<=A.t&&A.data[p].row==crow）{
brow=A.data[p].col;
for（q=pos[brow];q<=pos[brow+1]-1;q++）{
ccol=B.data[q].col;
ctemp[ccol]=ctemp[ccol]+A.data[p].v*B.data[q].v;
}
p=p+1;
}
for（ccol=1;ccol<=B.n;ccol++）
if（ctemp[ccol]!
=0）{
C.t=C.t+1;
C.data[C.t].row=crow;
C.data[C.t].col=ccol;
C.data[C.t].v=ctemp[ccol];
}
}
}
else
cout<<"这两个矩阵不能相乘";
returnC;
}
Matrixoperator~（MatrixA）{
MatrixB;
intcol,i,p,q;
intnum[max],position[max];
B.t=A.t;B.m=A.n;B.n=A.m;
if（B.t）{
for（col=1;col<=A.n;col++）
num[col]=0;
for（i=1;i<=A.t;i++）
num[A.data[i].col]++;
position[1]=1;
for（col=2;col<=A.n;col++）
position[col]=position[col-1]+num[col-1];
for（p=1;p<=A.t;p++）{
col=A.data[p].col;q=position[col];
B.data[q].row=A.data[p].col;
B.data[q].col=A.data[p].row;
B.data[q].v=A.data[p].v;
position[col]++;
}
}
returnB;
}
nMatrixTrs（nMatrixa）{//求逆矩阵的先转置
nMatrixtrs;
trs.m=a.n;
trs.n=a.m;
trs.p=newdouble[a.m*a.n];
for（inti=0;i{
for（intj=0;j{
trs.p[j*a.m+i]=a.p[i*a.n+j];
}
}
returntrs;
}
nMatrixAdjunct（nMatrixa,intindexm,intindexn）{//求第indexm行indexn列元素的代数余子式
nMatrixadj;
adj.m=a.m-1;
ad
升级会员 