矩阵

矩阵的建立

用中括号括起来，按矩阵行的顺序输入各元素，同一行的用逗号,或者空格 分割，不同行的用分号分割

例如：

1
2
3
4
5
6
7
8
a = [1 2 3; 4 5 6; 7 8 9]

[output]
a =

     1     2     3
     4     5     6
     7     8     9

矩阵可以利用已建好的矩阵来建立更大的矩阵，例如

1
2
3
4
5
6
7
8
9
10
11
12
13
A = [1 2 3; 4 5 6; 7 8 9];
B = [-1 -2 -3; -4 -5 -6; -7 -8 -9];
C = [A, B; B, A]

[output]
C =

     1     2     3    -1    -2    -3
     4     5     6    -4    -5    -6
     7     8     9    -7    -8    -9
    -1    -2    -3     1     2     3
    -4    -5    -6     4     5     6
    -7    -8    -9     7     8     9

可以用实部矩阵和虚部矩阵构成虚部矩阵，例如

1
2
3
4
5
6
7
8
9
B = [1 2 3; 4 5 6];
C = [6 7 8; 9 10 11];
A = B + i * C

[output]
A =

   1.0000 + 6.0000i   2.0000 + 7.0000i   3.0000 + 8.0000i
   4.0000 + 9.0000i   5.0000 +10.0000i   6.0000 +11.0000i

冒号表达式

可以使用冒号表达式来建立行向量（矩阵的特殊类型）

格式为e1:e2:e3，e1为初始值，e2为步长，e3为终止值，跟Python的range(Start, End, Step)有点相似，只不过终止值和步长换了位置，在冒号表达式中，e2可以不写，那步长就默认为1，即t = 0:1:5 = t = 0:5

例如：

1
2
3
4
5
6
t = 0:1:5

[output]
t =

     0     1     2     3     4     5

linspace函数

可以用于产生行向量，用法为linspace(a,b,n)，a是第一个元素，b是第二个元素,n是元素总数，当n省略时，其缺省值为100（跟numpy的numpy.linspace(Start, End, Count)用法一样，只不过numpy的缺省值是50）

结构矩阵(struct)

感觉有点类似制表，使用格式为结构矩阵元素.成员名 = 表达式，这里还是给出个例子

1
2
3
4
5
6
7
8
9
10
11
12
a(1).x1 = 10;a(1).x2 = 'liu'; a(1).x3 = [1 2 3];
a(2).x1 = 20;a(2).x2 = 'wang'; a(2).x3 = [4 5 6];
a

[output]
a = 

  包含以下字段的 1×2 struct 数组:

    x1
    x2
    x3

在变量浏览器里面可以看到这个a变量长这样

x1 x2 x3
1 10 ‘liu’ [1,2,3]
2 20 ‘wang’ [4,5,6]

单元矩阵

建立方法：使用大括号{}将元素括起来，所有元素可以是不同类型的数据，例如：

1
2
3
4
5
6
7
8
9
10
b = {10 'liu' [1 2 ; 4 5]; 20, 'wang' [6 7 ; 9 10]}

[output]
b =

  2×3 cell 数组

    {[10]}    {'liu' }    {2×2 double}
    {[20]}    {'wang'}    {2×2 double}

在变量浏览器里面可以看到b变量长这样（就是真正的表格了，没有x1,x2,x3这种头头索引）

1 2 3
1 10 ‘liu’ [1,2;4,5]
2 20 ‘wang’ [6,7;9,10]

矩阵元素的使用

引用方式

下标法

使用变量名(位置)来索引，例如：

A(3,2)表示A矩阵第3行第2列的位置，同样可以通过该方式修改矩阵中的元素，例如：

A(3,2) = 100就是将A矩阵第3行第2列的元素修改为100

实例
1
2
3
4
5
6
7
8
9
10
A = [1 2 3; 4 5 6];
A(5,5) = 10

A =

     1     2     3     0     0
     4     5     6     0     0
     0     0     0     0     0
     0     0     0     0     0
     0     0     0     0    10

当给出的行和列的下表超出了矩阵的行数和列数，那将会自动扩展原来的矩阵并将为赋值元素自动赋值为0

序号法

序号就是元素在矩阵的排列顺序，存储顺序是第一列->最后一列（不是我们习惯性的行），例如：

1
2
3
4
5
6
7
A = [1 2 3; 4 5 6];
A(3)

[output]
ans =

     2

序号与下标是一一对应的，以m*n矩阵A为例，矩阵A(i,j)的序号是(j-1)*m+i

矩阵元素的序号和下标可以通过sub2ind（行列换序号）和ind2sub（序号换行列）函数进行相互转换

调用格式：

D=sub2ind(S,I,J)，S表示由矩阵的行数和列数组成的向量，一般用size(变量名)来获取；I表示转换矩阵元素的行下标，J表示转换矩阵元素的列下标。若I和J为矩阵的话，会将多个元素的下表转换为序号，此时I和J的行列数必须相同

[I,J]=ind2sub(S,D)，S表示行数和列数组成的向量，D表示序号，返回序号所对应的行下标和列下表，I为行下标，J为列下标

冒号表达式

这一节以下面的几个例子展开：

1
2
3
4
A(i,:)			% 第i行的全部元素
A(:,j)			% 第j列的全部元素
A(i:i+m,k:k+m)	% 第i~i+m行内且在第k~k+m列中的所有元素
A(iLi+m,:)		% 第i~i+m行的全部元素

从上面看，个人认为有点像Python的列表切片那种东西，只不过这里是二维的而且是全闭区间，Python的是半开半闭区间

可以使用end来表示某一位的末尾元素下标，例如：

1
2
3
4
5
6
7
A = [1 2 3; 4 5 6; 7 8 9];
A(end,:)

[output]
ans =

     7     8     9

此处的end就是第三行，也就是说end会取到行/列的最大值

删除矩阵元素

利用空矩阵删除矩阵的元素

若x为非空矩阵，此时想删除x中的内容，则直接使用x = []就可以删除元素了

可以跟冒号表达式一起使用删除大矩阵中的部分元素

改变矩阵的形状

利用函数reshape(A,m,n)，表示在矩阵A保持不变的情况下，将A排列为m*n的二维矩阵，但是不改变元素个数和存储顺序，举例：

1
2
3
4
5
6
7
8
9
x = [1 2 3 4 5 6 7 8 9 10 11 12];
y = reshape(x,3,4)

[output]
y =

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

特殊的表达方式A(:)将A的每一列元素堆叠起来，成为一个列向量，例如：（此处的x与上面的一样）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
z = x(:)

[output]
z =

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

这样z就是用x中的元素堆叠成的列