矩阵与二维数组

矩阵与数组的关系早在之前就有论述，仅从表现形式上看，矩阵就是二维数组，所以矩阵的创建、表示以及一些操作和数组是一样的，而二者之间的区别在于所遵守的运算规则不同，矩阵的运算一般将矩阵看做是一个整体进行运算，而数组的运算则是对应元素的运算。

矩阵\二维数组是如何存储的

矩阵在MATLAB是按列的顺序存储的，即先存储第一列，然后是第二列，依次类推。

>> A
A =
     1     2     3
     4     5     6
     7     8     9
>> A(2)
ans =
     4

矩阵\二维数组元素的表示及相关操作

元素的下标表示法

全下标

>> A
A =
     1     2     3
     4     5     6
     7     8     9
>> A(1,2)      %第一行第二列的元素
ans =
     2

单下标

>> A(2)
ans =
     4

元素的赋值

全下标方式

>>clear                         
>> A(1:2,1:3)=[1 1 1;1 1 1]  %用一矩阵给A的1~2行，1~3列全部赋值为1
A =
     1     1     1
     1     1     1
>> A(3,3) = 2              %给原矩阵中不存在的元素下标赋值会扩充矩阵，注意补0原则
A =
     1     1     1
     1     1     1
     0     0     2

单下标方式

>> A(3:6)=[-1 1 1 -1]
A =
     1     1     1
     1     1     1
    -1    -1     2
>> A(3) = 0;A(6) = 0
A =
     1     1     1
     1     1     1
     0     0     2

全元素方式
将矩阵B的所有元素赋值给A，即A(:)=B，不要求A，B同阶，只要求个数相同

>> A(:)=[1 2 3 4 5 6 7 8 9]      %按列存储的原则赋值给A，这里的A在上面用过，所以是3*3的形式
A =
     1     4     7
     2     5     8
     3     6     9
>> A(3,4) = 16                  %扩充矩阵A
A =
     1     4     7     0
     2     5     8     0
     3     6     9    16
>> B = [11 12 13;14 15 16;17 18 19;0 0 0]
B =
    11    12    13
    14    15    16
    17    18    19
     0     0     0
>> A(:)=B                       %按列存储的原则将B全部赋值给A
A =
    11     0    18    16
    14    12     0    19
    17    15    13     0

元素的删除

用空矩阵([])将矩阵中的单个元素，某行，某列，某矩阵块删除

>> A
A =
    11     0    18    16
    14    12     0    19
    17    15    13     0

>> A(:,4)=[]             %将第4列全部删除
A =
    11     0    18
    14    12     0
    17    15    13
>> A(1,:)=[]            %将第一行全部删除
A =
    14    12     0
    17    15    13
>> A(:,2:3)=[]           %将2~3列全部删除
A =
    14
    17

矩阵\二维数组的创建

直接输入法

>> A = [2 3 4;5 6 9;5 6 2]
A =
     2     3     4
     5     6     9
     5     6     2

抽取法

即大矩阵中抽取出需要的小矩阵，线性代数中分块矩阵就是从大矩阵中取出小矩阵的实例

全下标方式

>> A = [1 2 3 4;5 6 7 8;9 10 11 12]
A =
     1     2     3     4
     5     6     7     8
     9    10    11    12
>> B = A(2:3,2:3)                %取出矩阵A 2~3行，2~3列的元素
B =
     6     7
    10    11
>> C = A([1 3],end)              %end代表某一维数中的最大值，这里表示最后一列
C =
     4
    12

单下标方式

>> A
A =
     1     2     3     4
     5     6     7     8
     9    10    11    12
>> B = A([1 3 5;7:9;2 4 6])
B =
     1     9     6
     3     7    11
     5     2    10

相当于
      A(1)  A(3)  A(5)
B =   A(7)  A(8)  A(9)
      A(2)  A(4)  A(6)

拼接法

行数或者列数相同的矩阵扩展成大矩阵

>> A = [1 2 3;4 5 6;7 8 9;10 11 12]
A =
     1     2     3
     4     5     6
     7     8     9
    10    11    12
>> B = [9 8 7;6 5 4]
B =
     9     8     7
     6     5     4
>> C = [A;B]         %A和B列数相同，所以可进行列拼接
C =
     1     2     3
     4     5     6
     7     8     9
    10    11    12
     9     8     7
     6     5     4

函数法

函数	功能
zeros(m,n)	m $\times$ n阶的全0矩阵
ones(m,n)	m $\times$ n阶的全1矩阵
rand(m,n)	m $\times$ n阶取值在0~1之间满足均匀分布的随机矩阵
randn(m,n)	m $\times$ n阶标准正态分布矩阵
eye(m,n)	m $\times$ n阶单位矩阵
toeplitz	Toeplitz矩阵
magic	魔方矩阵

还有很多，这些比较常用

>> A = ones(3,4),B = zeros(2,3),C = magic(3)
A =
     1     1     1     1
     1     1     1     1
     1     1     1     1
B =
     0     0     0
     0     0     0
C =
     8     1     6
     3     5     7
     4     9     2

使用拼接函数或变形函数

拼接函数cat(dim, A1, A2, ...)

dim = 1表示往行方向上拼接，所以A1, A2, …的列数要相同
dim = 2表示往列方向上拼接，所以A1, A2, …的行数要相同
dim可以是大于2的数，此时拼接出来的是高维数组

拼接函数repmat(A,m,n)

将A作为一个元素，生成一个m $\times$ n阶矩阵

变形函数:reshape(A,m,n)

把矩阵A变形成m $\times$ n的形式，按列存储的方式给A赋值

%cat的用法
>> A1 = [1 2 3;4 5 6],A2 = [1 2;7 8]
A1 =
     1     2     3
     4     5     6
A2 =
     1     2
     7     8
>> cat(2,A1,A2) %列方向上拼接，要求A1，A2行数相同
ans =
     1     2     3     1     2
     4     5     6     7     8
 
 %repmat的用法
 >> A = [1 2;3 4]
A =
     1     2
     3     4
>> repmat(A,2,2)  %以A为元素，生成两行两列的矩阵
ans =
     1     2     1     2
     3     4     3     4
     1     2     1     2
     3     4     3     4
 
 %reshape的用法
 >> A = 1 : 9
A =
     1     2     3     4     5     6     7     8     9
>> A = reshape(A,3,3) %将A变形成3*3阶矩阵，按列存储
A =
     1     4     7
     2     5     8
     3     6     9

块操作函数

blkdiag(A1, A2, …)，把A1,A2看做单个元素，放置在主对角位置，其余位置补零形成的矩阵
在这里插入图片描述

kron(X,Y)，首先把Y当做是一个元素，然后生成一个"size(X)"规模的数组，每一个元素是X的对应元素与Y的乘积
在这里插入图片描述

加载法

该方法是把在外存中的.mat文件加载到MATLAB工作区，前提是保存了该.mat文件且数据文件是所需的矩阵

.M文件法

当一个矩阵规模较大，并且使用比较频繁时，可以将该矩阵输入到.m文件中。

创建一个test.m文件，里面的内容为

tes=[1 2 3 4 5 6;
    7 8 9 10 11 12;
    9 8 7 6 5 4]

在命令行输入test

>> test

tes =

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

一些有用的函数

find

find(A)函数的作用返回所有A中不为0元素的下标。
在这里插入图片描述

find函数经常与逻辑运算联合使用，非常的方便。因为逻辑运算产生的结果是逻辑数组，只包含0和1,1就是满足条件的，如果联合find的话，就可以找到符合我们要求的下标，然后对数组直接操作。

比如现在我要对一个数组中任何小于0的数全部修改为0。
在这里插入图片描述

A =
    -1     2     3
    -2    -3     5
     6     9     8
A =
     0     2     3
     0     0     5
     6     9     8

sort

函数	说明
B = sort(A)	若A是二维数组，则对数组的列进行从小到大排序，并且返回排序后的数组若A是一维数组，则直接对A排序，不管是行向量还是列向量
B=sort(A,dim)	dim=1，即在行方向上排序，即对每一列进行排序 dim=2，对每一行进行排列返回排序后的数组

注意：

sort并不改变A，若要进行从大到小排序，可在sort中加入’descend’，如sort(A,‘descend’)

>> A = [1 2 3;5 1 9;3 5 7]
A =
     1     2     3
     5     1     9
     3     5     7
>> B = sort(A)                    %对A的每一列进行从大到小排序
B =
     1     1     3
     3     2     7
     5     5     9
>> B = sort(A,'descend')          %对A的每一列进行从小到大排序
B =
     5     5     9
     3     2     7
     1     1     3
>> B = sort(A,2)                  %对A的每一行进行排序
B =
     1     2     3
     1     5     9
     3     5     7
>> B = sort(A,1)                  %与sort(A)的效果是一样的
B =
     1     1     3
     3     2     7
     5     5     9

any

any(A)，若A是二维数组，则对A中每一列的元素进行检测，若A中一列中元素有任意一个不为0，则返回1，否则返回0
若A是一个向量，即一维数组，则无论是行向量还是列向量，若该向量中有任意一个不为0则返回1，否则返回0。

>> A = [1 0;0 1]      %两列都不全为0，所以都返回1
A =
     1     0
     0     1
>> any(A)
ans =
     1     1
>> A(:) = 0
A =
     0     0
     0     0
>> any(A)       %%两列都全为0，所以都返回0
ans =
     0     0
 
 >> any([1 2 3])   %对一维数组，只要其中元素不全为0则返回1
 ans =
     1

all

all的用法与any相似，但是all的意思是，若全不为0则返回1，否则返回0，对于二维数组和一维数组的规定与any相同，即对于二维数组是对列的检测，并对每个列列返回一个值；对一维数组是无论行向量还是列向量对所有元素做检测并返回一个值。

>> A = [0 1;2 3]
A =
     0     1
     2     3
>> all(A)         %第一列不是全部不为0，返回0，第二列全部不为0，返回1
ans =
     0     1
>> all([1 0])     %对行向量中所有元素检测，不是全部不为0，返回0
ans =
     0
>> all([1; 2])    %对列向量中所有元素检测，是全部不为0，返回1
ans =
     1