【Matlab】矩阵

矩阵

zeros函数

产生全0矩阵，即零矩阵。

调用格式：

• zeros(m)：产生m×m的零矩阵。
• zeros(m, n)：产生m×n的零矩阵。
• zeros(size(A))：产生与矩阵A同样大小的零矩阵。

下面函数的调用方式均与之相同。

ones函数

产生全1矩阵，即幺矩阵。

eye函数

产生对角线为1的矩阵。当矩阵是方阵时，得到一个单位矩阵。

rand函数

产生(0, 1)区间均匀分布的随机矩阵。

randn函数

randn函数：产生均值为0，方差为1的标准正态分布随机矩阵。

randi函数

randi()函数生成均匀分布的伪随机整数，范围为imin–imax，如果没指定imin，则默认为1。

r = randi(imax,n)：生成n×n的矩阵，n省略则产生1×1的矩阵

r = randi(imax,m,n)：生成m×n的矩阵

r = randi(imax,[m,n])：同上，用法：r = randi(imax,size(A));

r = randi(imax,m,n,p,…)：生成m×n×p×…的矩阵

r = randi(imax,[m,n,p,…])：同上

r = randi([imin,imax],…)：规定了imin，其余参数与上面相同

应用1

首先产生5阶两位随机整数矩阵A，再产生均值为0.6、方差为0.1的5阶正态分布随机矩阵B，最后验证(A+B)I=IA+BI（I为单位矩阵）。

• fix(a+(b-a+1)*x)：产生[a, b]区间上均匀分布的随机整数。
• $\mu$+$\sigma$x：得到均值为$\mu$、方差为${\sigma }^2$的随机数。

A = fix(10+(99-10+1)*rand(5));
B = 0.6+sqrt(0.1)*randn(5);
C = eye(5);
(A+B)*C == C*A + B*C

结果如下：

ans =

  5×5 logical 数组

   1   1   1   1   1
   1   1   1   1   1
   1   1   1   1   1
   1   1   1   1   1
   1   1   1   1   1

magic函数

n阶魔方阵由1,2,3,…,n2共n2个整数组成，且每行、每列以及主、副对角线上各n个元素之和都相等。
n阶魔方阵每行每列元素的和为(1+2+3+…+n2)/n=(n+n3)/2。MATLAB函数magic(n)产生一个特定的魔方阵。

M = magic(8);
sum(M(1, :)) % 260
sum(M(:, 1)) % 260

补充一下sum的用法

sum函数

调用形式：

• sum(A)：对每一列求和，返回一个由每列的和构成的行向量。
• sum(A, 1)：与sum(A)等价。
• sum(A, 2)：对每一行求和，返回一个由每行的和构成的列向量。
• sum(subA)：subA为A的索引子矩阵，求子矩阵中全部元素之和。

用法举例：

A = [1 2 3; 4 5 6;7 8 9];
sum(A) % 12    15    18
sum(A, 1) % 12    15    18
sum(A, 2) 
%     6
%    15
%    24
sum(A(1:2, 2:3)) % 7     9
sum(A(:)) % 45

伴随矩阵

MATLAB生成伴随矩阵的函数是compan§，其中p是一个多项式的系数向量，高次幂系数排在前，低次幂系数排在后。

例如，生成多项式$x^3-2x^2-5x+6$的伴随矩阵。

p = [1 -2 -5 6];
A = compan(p)

结果如下：

A =

     2     5    -6
     1     0     0
     0     1     0

稀疏矩阵

• 完全存储方式

• 稀疏存储方式

  稀疏存储方式只存储矩阵的非零元素的值及其位置，即行号和列号。

  注意，采用稀疏存储方式时，矩阵元素的存储顺序并没有改变，也是按列的顺序进行存储。

完全存储方式与稀疏存储方式之间的转化

A=sparse(S)：将矩阵S转化为稀疏存储方式的矩阵A。
S=full(A)：将矩阵A转化为完全存储方式的矩阵S。

A = sparse(eye(3)) % 等价于 speye(3)
full(A)

结果如下：

A =

   (1,1)        1
   (2,2)        1
   (3,3)        1

ans =

     1     0     0
     0     1     0
     0     0     1

sparse函数的其他调用格式

sparse(m, n)：生成一个$m\times n$的所有元素都是零的稀疏矩阵。

A = sparse(4, 5);
A(8) = 3;
A(1, 2) = 4;
full(A(1:3, :))

结果如下：

ans =

     0     4     0     0     0
     0     0     0     0     0
     0     0     0     0     0

先通过上述调用格式生成全零稀疏矩阵，再可以通过完全存储方式的赋值和访问方式进行赋值和访问操作。

---

spase(row, col, val)：row、col和val为等长的向量，分别表示行号，列号和对应的值。

A = sparse([1 2 2], [2 1 4], [4 5 -7])
full(A)

结果如下：

A =

   (2,1)        5
   (1,2)        4
   (2,4)       -7

ans =

     0     4     0     0
     5     0     0    -7

spconvert函数

调用格式为：spconvert(A)，A为若干行三列或若干行四列的一个矩阵，第一列表示每个数所在的行号，第二列表示每个数所在的列号，第三列表示每个数的实部，第四列表示每个数的虚部，若矩阵的全部元素都是实数，则无需第四列；可见，A矩阵每一行都表示一个非零元素，其行数就是稀疏矩阵中非零的元素个数。

A = [2 2 1; 2 1 -1; 2 4 3]
spconvert(A)

结果如下：

A =

     2     2     1
     2     1    -1
     2     4     3

ans =

   (2,1)       -1
   (2,2)        1
   (2,4)        3

带状稀疏矩阵

[B,d]=spdiags(A)：从带状稀疏矩阵A中提取全部非零对角线元素赋给矩阵B及其这些非零对角线的位置向量d。
A=spdiags(B,d,m,n)：产生带状稀疏矩阵的稀疏存储矩阵A，其中m、n为原带状稀疏矩阵的行数与列数，矩阵B的第i列即为原带状稀疏矩阵的第i条非零对角线，向量d为原带状稀疏矩阵所有非零对角线的位置。

A=[11 0 0 12 0 0; 0 21 0 0 22 0; 0 0 31 0 0 32; 41 0 0 42 0 0; 0 51 0 0 52 0]
[B,d]=spdiags(A)

结果如下：

A =

    11     0     0    12     0     0
     0    21     0     0    22     0
     0     0    31     0     0    32
    41     0     0    42     0     0
     0    51     0     0    52     0

B =

     0    11    12
     0    21    22
     0    31    32
    41    42     0
    51    52     0

d =

    -3
     0
     3

spdiags(B, d, 5, 6)

结果如下：

ans =

   (1,1)       11
   (4,1)       41
   (2,2)       21
   (5,2)       51
   (3,3)       31
   (1,4)       12
   (4,4)       42
   (2,5)       22
   (5,5)       52
   (3,6)       32

我们还可以通过先产生完全存储的矩阵再转换为稀疏矩阵的方式产生带状稀疏矩阵：

B = diag([11 21 31 42 52 0]) + diag([12 22 32], 3) + diag([41 51 0], -3);
B = B(1:end-1, :)
sparse(B)

结果如下：

B =

    11     0     0    12     0     0
     0    21     0     0    22     0
     0     0    31     0     0    32
    41     0     0    42     0     0
     0    51     0     0    52     0
     
ans =

   (1,1)       11
   (4,1)       41
   (2,2)       21
   (5,2)       51
   (3,3)       31
   (1,4)       12
   (4,4)       42
   (2,5)       22
   (5,5)       52
   (3,6)       32

先用diag函数构建方阵，让方阵相加得到完全存储下的矩阵，调用sparse将其稀疏化。

注意：

spdiags(B,d,m,n)格式中的m、n的大小关系决定了如何利用矩阵B进行填充：

结论：

• 当m≤n时，主对角线下方的对角线（也就是对角线-1：-n+1）进行数据填充时，从B矩阵某一列从上至下去取值；而主对角线之上的对角线（1：n-1）进行元素填充时，从B的某一列从下至上去取值。
• 当m>n时，主对角线下方的对角线进行数据填充时，从B矩阵某一列从下至上去取值；而主对角线之上的对角线进行元素填充时，从B的某一列从上至下去取值。

可见下面的例子：

A = reshape(1:15, 5, 3);
B = spdiags(A,[-2 0 2], 5, 5);
C = spdiags(A,[-2 0 2], 5, 6);
D = spdiags(A,[-2 0 2], 5, 4);
A
BB = full(B)
CC = full(C)
DD = full(D)

A =

     1     6    11
     2     7    12
     3     8    13
     4     9    14
     5    10    15


BB =

     6     0    13     0     0
     0     7     0    14     0
     1     0     8     0    15
     0     2     0     9     0
     0     0     3     0    10


CC =

     6     0    11     0     0     0
     0     7     0    12     0     0
     3     0     8     0    13     0
     0     4     0     9     0    14
     0     0     5     0    10     0


DD =

     6     0    13     0
     0     7     0    14
     1     0     8     0
     0     2     0     9
     0     0     3     0

speye函数

speye(n)：返回n阶单位方阵。

speye(m, n)：返回$m\times n$的单位方阵。

应用

通过稀疏存储的方式对稀疏矩阵进行存储和运算可以提高运算的效率，这是我们使用稀疏矩阵最重要的原因。

k1 = [1; 1; 2; 1; 0];
k2 = [2; 4; 6; 6; 1];
k3 = [0; 3; 1; 4; 2];
B = [k1 k2 k3];
d = [-1 0 1];
A = spdiags(B, d, 5, 5);
full(A)
b = [0; 3; 2; 1; 5];
x = A\b

结果如下：

ans =

     2     3     0     0     0
     1     4     1     0     0
     0     1     6     4     0
     0     0     2     6     2
     0     0     0     1     1

x =

   -0.1667
    0.1111
    2.7222
   -3.6111
    8.6111