Matlab数组知识点总结

 Matlab中的数组无处不在，所有变量在Matlab中都是以数组形式存储和运算的。

 按照数组元素的个数和排列方式，可以分为：

• 没有元素的空数组；

• 只有一个元素的标量（scalar），它实际上是一行一列的数组；

• 只有一行或者一列的向量（vector），分别叫做行向量和列向量，也统称为一维数组；

• 普通的具有多行多列元素的二维数组；

• 超过二维的多维数组。

1.数组的创建

1.1创建空数组

a = []
# []

12创建一维数组

>>a = [1 2 3 4]
a =
     1     2     3     4

>>a = [1;2;3;4]
a =
     1
     2
     3
     4

>>a = 1:1:10 # 创建等差数列
a =
     1     2     3     4     5     6     7     8     9    10

>>a = linspace(1,10,10) # linspace(start_val,stop_val,n),不指定n时默认n=100
a =
     1     2     3     4     5     6     7     8     9    10

>>a = logspace(0,log10(32),6)# 不指定n时默认n=50
a =
    1.0000    2.0000    4.0000    8.0000   16.0000   32.0000

1.2创建二维数组

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

>> b = [1:5;linspace(6,10,5);2 3 4 5 6]
b =
     1     2     3     4     5
     6     7     8     9    10
     2     3     4     5     6

2.数组属性

2.1数组结构

函数	作用
isempty(a)	判断a是否为空数组
isscalar(a)	检测a数组是否为单元素的标量数组
isvector(a)	判断a数组是否为向量数组
issparse(a)	判断a数组是否为稀疏数组

返回1表示符合条件，返回0表示不符合条件。

2.2数组大小

• d=size(a)：将数组a的行列尺寸以一个行向量的形式返回给变量d，即d=[m,n]
• [a,b] = size(a)：a = m,b = n
• length(a)： 当a是一维数组，返回一维数组元素的个数。当a是二维数组时，返回size(a)得到的两个数中较大的那个
• numel(a)：返回数组元素总个数，对于m行n列数组，返回m*n

2.3 数组维度

ndims(a)：返回结果实际等于length(size(a))

>> a = 2
a = 2
>> ndims(a)
ans = 2
>> b = 1:5
b =
     1     2     3     4     5
>>ndims(b)
ans = 2

2.4 数组数据类型

函数	说明（判断）
isnumeric(a)	数值型变量为元素的数组
isreal(a)	实数数值型变量为元素的数组
isfloat(a)	浮点数值型变量为元素的数组
isinteger(a)	整数型变量为元素的数组
islogical(a)	逻辑型变量为元素的数组
ischar(a)	字符型变量为元素的数组
isstruct(a)	结构体型变量为元素的数组
iscell(a)	元胞型变量为元素的数组

2.4 数组的内存占用

>> a = [3 2 5]
a =
     3     2     5
>> whos
Name      Size            Bytes  Class      Attributes

  a         1x3                24  double

3.创建特殊数组

3.1 0-1数组

>> zeros(2)
ans =
     0     0
     0     0

>> ones(3,4)
ans =
     1     1     1     1
     1     1     1     1
     1     1     1     1

>> eye(2,2)
ans =
     1     0
     0     1

3.2 对角数组

>> a = diag([1,2,3])
a =
     1     0     0
     0     2     0
     0     0     3

>> b = diag([1,2,3],2)
b =
     0     0     1     0     0
     0     0     0     2     0
     0     0     0     0     3
     0     0     0     0     0
     0     0     0     0     0

>> b = diag([1,2,3],-2)
b =
     0     0     0     0     0
     0     0     0     0     0
     1     0     0     0     0
     0     2     0     0     0
     0     0     3     0     0

>> c = [3 5 1 2;2 5 7 6]
c =
     3     5     1     2
     2     5     7     6

>> diag(c)
ans =
     3
     5

>> diag(diag(c),-1)
ans =
     0     0     0
     3     0     0
     0     5     0

3.3 随机数组

• rand(m,n)：产生m行n列的随机数组，其元素服从0到1的均匀分布。
• rand(size(a))：产生和a数组具有同样大小的随机数组，其元素服从0到1的均匀分布。
• rand(m)：产生m行m列的随机数组，元素分布同上。
• randn函数用法与rand类似，不同的是其元素分布服从标准正态分布。

3.4 魔方数组

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

每一行每一列的元素之和都相等。

4.数组操作

4.1 数组的保存和装载

• save命令一般语法：save <filename> <var1> <var2> … <varN>

其作用是把var1，var2…指定的工作区变量存储在filename指定的.mat文件中。

• load命令的一般语法：load <filename> <var1> <var2>…<varN>

其作用是把当前目录下存储在filename.mat文件的var1，var2等等变量加载到Matlab工作区中。

4.2 数组索引和寻址

4.2.1 数字索引方式

>> a = [1,2,3,4;2,3,4,5;3,4,5,6]
a =
     1     2     3     4
     2     3     4     5
     3     4     5     6

>> a(2,3)
ans =
     4

a(10) #访问第10个元素
ans =
     4

>> a(10:12)
ans =
     4     5     6

>> a(2,1:4)
ans =
     2     3     4     5

>> a([3,1],2)
ans =
     4
     2

>> a([3,1],[2,1])
ans =
     4     3
     2     1

>> a(10) = 0
a =
     1     2     3     0
     2     3     4     5
     3     4     5     6

4.2.2 单下标索引和双下标索引的转换

>> a = rand(3,5)
a =
    0.8147    0.9134    0.2785    0.9649    0.9572
    0.9058    0.6324    0.5469    0.1576    0.4854
    0.1270    0.0975    0.9575    0.9706    0.8003

>> sub2ind(size(a),2,2)
ans =
     5

>> [i,j] = ind2sub(size(a),13)
i =
     1
j =
     5

4.2.3 逻辑索引方式

>> b = a>0.7
b =
  5×5 logical 数组
   0   0   1   1   1
   0   0   1   0   0
   1   1   0   0   0
   1   1   0   0   1
   1   0   0   0   0

>> b = a<0.5
b =
  5×5 logical 数组
   1   0   0   0   0
   1   1   0   1   0
   0   0   1   1   1
   0   0   0   1   0
   0   0   1   1   1

>> a(b) = 0
a =
         0    0.6557    0.7577    0.7060    0.8235
         0         0    0.7431         0    0.6948
    0.9157    0.8491         0         0         0
    0.7922    0.9340    0.6555         0    0.9502
    0.9595    0.6787         0         0         0

先通过比较关系运算产生一个满足比较关系的数组元素的索引数组（实际上是由0和1组成的逻辑数组）。然后利用这个索引数组来访问原数组，并重新进行赋值等操作。

4.3 数组的扩展和裁剪

1.数组编辑器

可以在数组编辑器进行扩展，裁剪，对数组元素进行编辑。

2.数组扩展的cat函数

>> a = rand(3,5)
a =
    0.8147    0.9134    0.2785    0.9649    0.9572
    0.9058    0.6324    0.5469    0.1576    0.4854
    0.1270    0.0975    0.9575    0.9706    0.8003

>> b = eye(5)
b =
     1     0     0     0     0
     0     1     0     0     0
     0     0     1     0     0
     0     0     0     1     0
     0     0     0     0     1

>> c = magic(3)
c =
     8     1     6
     3     5     7
     4     9     2

>> cat(1,a,b) % 1表示把数组当做两个行元素连接，2表示把数组当做两个列元素连接
ans =
    0.8147    0.9134    0.2785    0.9649    0.9572
    0.9058    0.6324    0.5469    0.1576    0.4854
    0.1270    0.0975    0.9575    0.9706    0.8003
    1.0000         0         0         0         0
         0    1.0000         0         0         0
         0         0    1.0000         0         0
         0         0         0    1.0000         0
         0         0         0         0    1.0000

>> cat(2,a,b)
错误使用 cat
要串联的数组的维度不一致。

>> cat(1,a,c)
错误使用 cat
要串联的数组的维度不一致。

>> cat(2,a,c)
ans =
    0.8147    0.9134    0.2785    0.9649    0.9572    8.0000    1.0000    6.0000
    0.9058    0.6324    0.5469    0.1576    0.4854    3.0000    5.0000    7.0000
    0.1270    0.0975    0.9575    0.9706    0.8003    4.0000    9.0000    2.0000

>> horzcat(a,c) %水平方向连接
ans =
    0.8147    0.9134    0.2785    0.9649    0.9572    8.0000    1.0000    6.0000
    0.9058    0.6324    0.5469    0.1576    0.4854    3.0000    5.0000    7.0000
    0.1270    0.0975    0.9575    0.9706    0.8003    4.0000    9.0000    2.0000

>> vertcat(a,b) % 垂直方向连接
ans =
    0.8147    0.9134    0.2785    0.9649    0.9572
    0.9058    0.6324    0.5469    0.1576    0.4854
    0.1270    0.0975    0.9575    0.9706    0.8003
    1.0000         0         0         0         0
         0    1.0000         0         0         0
         0         0    1.0000         0         0
         0         0         0    1.0000         0
         0         0         0         0    1.0000

3. 块操作函数

（1）数组块状复制函数repmat

a =
     1     0
     0     1

>> repmat(a,2,2)
ans =
     1     0     1     0
     0     1     0     1
     1     0     1     0
     0     1     0     1

>> repmat(a,2,3)
ans =
     1     0     1     0     1     0
     0     1     0     1     0     1
     1     0     1     0     1     0
     0     1     0     1     0     1

（2）对角块生成函数bikdiag

>> a = eye(2)
a =
     1     0
     0     1

>> b = ones(2,3)
b =
     1     1     1
     1     1     1

>> blkdiag(a,b) % 安排在新数组的主对角线位置，其他位置用零数组块进行填充
ans =
     1     0     0     0     0
     0     1     0     0     0
     0     0     1     1     1
     0     0     1     1     1

（3）块操作函数kron

>> a = [0,1;1,2]
a =
     0     1
     1     2

>> b = magic(2)
b =
     1     3
     4     2

>> kron(a,b) % 把b当做一个“元素块”，先复制扩展出size（a）规模的元素块，然后每一个块元素与a的相应位置的元素值相乘
ans =
     0     0     1     3
     0     0     4     2
     1     3     2     6
     4     2     8     4

4. 索引扩展

>> a = eye(3)
a =
     1     0     0
     0     1     0
     0     0     1

>> a(4,6) = 2
a =
     1     0     0     0     0     0
     0     1     0     0     0     0
     0     0     1     0     0     0
     0     0     0     0     0     2

>> a(5,2) = 3
a =
     1     0     0     0     0     0
     0     1     0     0     0     0
     0     0     1     0     0     0
     0     0     0     0     0     2
     0     3     0     0     0     0

5. 通过冒号操作符裁剪数组

>> a = magic(5)
a =
    17    24     1     8    15
    23     5     7    14    16
     4     6    13    20    22
    10    12    19    21     3
    11    18    25     2     9

>> a(1:2:5,3:5)
ans =
     1     8    15
    13    20    22
    25     2     9

>> a(:,[3,4,5])
ans =
     1     8    15
     7    14    16
    13    20    22
    19    21     3
    25     2     9

>> a(10:20)
ans =
    18     1     7    13    19    25     8    14    20    21     2

6. 数组元素删除

>> a = magic(7)
a =
    30    39    48     1    10    19    28
    38    47     7     9    18    27    29
    46     6     8    17    26    35    37
     5    14    16    25    34    36    45
    13    15    24    33    42    44     4
    21    23    32    41    43     3    12
    22    31    40    49     2    11    20

>> a(1:3:8,:) = []
a =

    38    47     7     9    18    27    29
    46     6     8    17    26    35    37
    13    15    24    33    42    44     4
    21    23    32    41    43     3    12

>> a(:,[3,5,6]) = []
a =
    38    47     9    29
    46     6    17    37
    13    15    33     4
    21    23    41    12

4.4 数组形状的改变

1. 数组转置

>> a = rand(2,4)
a =
    0.1419    0.9157    0.9595    0.0357
    0.4218    0.7922    0.6557    0.8491

>> a'
ans =
    0.1419    0.4218
    0.9157    0.7922
    0.9595    0.6557
    0.0357    0.8491

>> b = [2-i,3+4i,2.5i;6+i,4-i,2i]
b =
   2.0000 - 1.0000i   3.0000 + 4.0000i   0.0000 + 2.5000i
   6.0000 + 1.0000i   4.0000 - 1.0000i   0.0000 + 2.0000i

>> b' % 共轭转置
ans =
   2.0000 + 1.0000i   6.0000 - 1.0000i
   3.0000 - 4.0000i   4.0000 + 1.0000i
   0.0000 - 2.5000i   0.0000 - 2.0000i

>> ctranspose(b) % 共轭转置
ans =
   2.0000 + 1.0000i   6.0000 - 1.0000i
   3.0000 - 4.0000i   4.0000 + 1.0000i
   0.0000 - 2.5000i   0.0000 - 2.0000i

>> b.' % 非共轭转置
ans =
   2.0000 - 1.0000i   6.0000 + 1.0000i
   3.0000 + 4.0000i   4.0000 - 1.0000i
   0.0000 + 2.5000i   0.0000 + 2.0000i

>> transpose(b) % 非共轭转置
ans =
   2.0000 - 1.0000i   6.0000 + 1.0000i
   3.0000 + 4.0000i   4.0000 - 1.0000i
   0.0000 + 2.5000i   0.0000 + 2.0000i

2. 数组翻转

>> a = rand(4,6)
a =
    0.9340    0.3922    0.0318    0.8235    0.0344    0.7952
    0.6787    0.6555    0.2769    0.6948    0.4387    0.1869
    0.7577    0.1712    0.0462    0.3171    0.3816    0.4898
    0.7431    0.7060    0.0971    0.9502    0.7655    0.4456

>> flipud(a) % 上下翻转数组
ans =
    0.7431    0.7060    0.0971    0.9502    0.7655    0.4456
    0.7577    0.1712    0.0462    0.3171    0.3816    0.4898
    0.6787    0.6555    0.2769    0.6948    0.4387    0.1869
    0.9340    0.3922    0.0318    0.8235    0.0344    0.7952

>> fliplr(a) % 左右翻转数组
ans =
    0.7952    0.0344    0.8235    0.0318    0.3922    0.9340
    0.1869    0.4387    0.6948    0.2769    0.6555    0.6787
    0.4898    0.3816    0.3171    0.0462    0.1712    0.7577
    0.4456    0.7655    0.9502    0.0971    0.7060    0.7431

>> flipdim(a,1) %指定k方向翻转数组，k=1上下翻转，k=2左右翻转
ans =
    0.7431    0.7060    0.0971    0.9502    0.7655    0.4456
    0.7577    0.1712    0.0462    0.3171    0.3816    0.4898
    0.6787    0.6555    0.2769    0.6948    0.4387    0.1869
    0.9340    0.3922    0.0318    0.8235    0.0344    0.7952

>> flipdim(a,2)
ans =
    0.7952    0.0344    0.8235    0.0318    0.3922    0.9340
    0.1869    0.4387    0.6948    0.2769    0.6555    0.6787
    0.4898    0.3816    0.3171    0.0462    0.1712    0.7577
    0.4456    0.7655    0.9502    0.0971    0.7060    0.7431

>> rot90(a) % 逆时针旋转k*90度k不指定时默认取1
ans =

    0.7952    0.1869    0.4898    0.4456
    0.0344    0.4387    0.3816    0.7655
    0.8235    0.6948    0.3171    0.9502
    0.0318    0.2769    0.0462    0.0971
    0.3922    0.6555    0.1712    0.7060
    0.9340    0.6787    0.7577    0.7431

>> rot90(a,2)
ans =
    0.4456    0.7655    0.9502    0.0971    0.7060    0.7431
    0.4898    0.3816    0.3171    0.0462    0.1712    0.7577
    0.1869    0.4387    0.6948    0.2769    0.6555    0.6787
    0.7952    0.0344    0.8235    0.0318    0.3922    0.9340

3. 数组尺寸调整

>> a =rand(3,4)
a =
    0.6463    0.2760    0.1626    0.9597
    0.7094    0.6797    0.1190    0.3404
    0.7547    0.6551    0.4984    0.5853

>> reshape(a,2,6)
ans =
    0.6463    0.7547    0.6797    0.1626    0.4984    0.3404
    0.7094    0.2760    0.6551    0.1190    0.9597    0.5853

>> reshape(a,2,8)
错误使用 reshape
要执行 RESHAPE，请勿更改元素数目。

4.5 数组运算

1.数组运算

>> a = magic(4)
a =
    16     2     3    13
     5    11    10     8
     9     7     6    12
     4    14    15     1

>> b = eye(4)
b =
     1     0     0     0
     0     1     0     0
     0     0     1     0
     0     0     0     1

>> c = ones(4,2)
c =
     1     1
     1     1
     1     1
     1     1

>> a+b
ans =
    17     2     3    13
     5    12    10     8
     9     7     7    12
     4    14    15     2

>> b-a
ans =
   -15    -2    -3   -13
    -5   -10   -10    -8
    -9    -7    -5   -12
    -4   -14   -15     0

>> a*c
ans =
    34    34
    34    34
    34    34
    34    34

>> c*c'
ans =
     2     2     2     2
     2     2     2     2
     2     2     2     2
     2     2     2     2

>> (c*c')^3
ans =
   128   128   128   128
   128   128   128   128
   128   128   128   128
   128   128   128   128

数组除法：

（1）a/b相当于a*inv(b)或者a*pinv(b)。

（2）a\b相当于inv(a)*b或者pinv(a)*b。

inv是数组求逆函数，仅适用于行列数相同的方形数组，pinv是求数组广义逆的函数。

2. 点运算

>> a = magic(4)
a =
    16     2     3    13
     5    11    10     8
     9     7     6    12
     4    14    15     1

>> b = ones(4) + 4*eye(4)
b =
     5     1     1     1
     1     5     1     1
     1     1     5     1
     1     1     1     5

>> a.*b
ans =
    80     2     3    13
     5    55    10     8
     9     7    30    12
     4    14    15     5

>> b.*a
ans =
    80     2     3    13
     5    55    10     8
     9     7    30    12
     4    14    15     5

>> b.^3
ans =
   125     1     1     1
     1   125     1     1
     1     1   125     1
     1     1     1   125

>> a.\b
ans =
    0.3125    0.5000    0.3333    0.0769
    0.2000    0.4545    0.1000    0.1250
    0.1111    0.1429    0.8333    0.0833
    0.2500    0.0714    0.0667    5.0000

>> a./b
ans =
    3.2000    2.0000    3.0000   13.0000
    5.0000    2.2000   10.0000    8.0000
    9.0000    7.0000    1.2000   12.0000
    4.0000   14.0000   15.0000    0.2000

>> a = [1 2 3 4 5]
a =
     1     2     3     4     5

>> b = [2 3 4 5 6]
b =
     2     3     4     5     6

>> dot(a,b)
ans =
    70

>> sum(a.*b) % 两种方法效果一样，点积运算的数组长度须一致
ans =
    70

3. 专门针对数组的运算函数

>> a = magic(4)
a =
    16     2     3    13
     5    11    10     8
     9     7     6    12
     4    14    15     1

>> sqrt(a)
ans =
    4.0000    1.4142    1.7321    3.6056
    2.2361    3.3166    3.1623    2.8284
    3.0000    2.6458    2.4495    3.4641
    2.0000    3.7417    3.8730    1.0000

>> sqrtm(a)
ans =
   3.7584 - 0.2071i  -0.2271 + 0.4886i   0.3887 + 0.7700i   1.9110 - 1.0514i
   0.2745 - 0.0130i   2.3243 + 0.0306i   2.0076 + 0.0483i   1.2246 - 0.0659i
   1.3918 - 0.2331i   1.5060 + 0.5498i   1.4884 + 0.8666i   1.4447 - 1.1833i
   0.4063 + 0.4533i   2.2277 - 1.0691i   1.9463 - 1.6848i   1.2506 + 2.3006i

>> exp(a)
ans =
   1.0e+06 *

    8.8861    0.0000    0.0000    0.4424
    0.0001    0.0599    0.0220    0.0030
    0.0081    0.0011    0.0004    0.1628
    0.0001    1.2026    3.2690    0.0000

>> expm(a)
ans =
   1.0e+14 *

    1.4587    1.4587    1.4587    1.4587
    1.4587    1.4587    1.4587    1.4587
    1.4587    1.4587    1.4587    1.4587
    1.4587    1.4587    1.4587    1.4587

4. 逻辑运算

>> a = [1 2 0 4 0]
a =
     1     2     0     4     0

>> b = [0 4 3 0 1]
b =
     0     4     3     0     1

>> a&b
ans =
  1×5 logical 数组

   0   1   0   0   0

>> a|b
ans =
  1×5 logical 数组

   1   1   1   1   1

>> ~a
ans =
  1×5 logical 数组

   0   0   1   0   1

>> a&1
ans =
  1×5 logical 数组

   1   1   0   1   0

4.5 数组查找

>> a = rand(3,5)
a =
    0.1493    0.2543    0.9293    0.2511    0.3517
    0.2575    0.8143    0.3500    0.6160    0.8308
    0.8407    0.2435    0.1966    0.4733    0.5853

>> a>0.3
ans =
  3×5 logical 数组

   0   0   1   0   1
   0   1   1   1   1
   1   0   0   1   1

>> a<0.5
ans =
  3×5 logical 数组

   1   1   0   1   1
   1   0   1   0   0
   0   1   1   1   0

>> (a>0.3)&(a<0.5)
ans =
  3×5 logical 数组

   0   0   0   0   1
   0   0   1   0   0
   0   0   0   1   0

>> find((a>0.3)&(a<0.5))
ans =
     8
    12
    13

>> a(find((a>0.3)&(a<0.5)))
ans =
    0.3500
    0.4733
    0.3517

4.6 数组排序

>> a = rand(1,8)
a =
    0.5497    0.9172    0.2858    0.7572    0.7537    0.3804    0.5678    0.0759

>> sort(a)
ans =
    0.0759    0.2858    0.3804    0.5497    0.5678    0.7537    0.7572    0.9172

>> [b,c] = sort(a,'descend')
b =
    0.9172    0.7572    0.7537    0.5678    0.5497    0.3804    0.2858    0.0759

c =
     2     4     5     7     1     6     3     8

>> a = rand(3,6)
a =
    0.0540    0.9340    0.4694    0.1622    0.5285    0.2630
    0.5308    0.1299    0.0119    0.7943    0.1656    0.6541
    0.7792    0.5688    0.3371    0.3112    0.6020    0.6892

>> sort(a) % 对每一列进行升序排序
ans =
    0.0540    0.1299    0.0119    0.1622    0.1656    0.2630
    0.5308    0.5688    0.3371    0.3112    0.5285    0.6541
    0.7792    0.9340    0.4694    0.7943    0.6020    0.6892

>> [b,c] = sort(a,2)
b =
    0.0540    0.1622    0.2630    0.4694    0.5285    0.9340
    0.0119    0.1299    0.1656    0.5308    0.6541    0.7943
    0.3112    0.3371    0.5688    0.6020    0.6892    0.7792

c =
     1     4     6     3     5     2
     3     2     5     1     6     4
     4     3     2     5     6     1

sort(a,dim) dim=1表示对每一列排序，dim=2表示对每一行排序。

sort(a,dim,mode) mode为”ascend”时，进行升序排序；mode为”descend”时，进行降序排序。

[b,c] = sort(a,…) c为排序后各元素在原数组中的行位置或列位置的索引。

5. 多维数组

 MATLAB把超过两维的数组称为多维数组，多维数组实际上是二维数组的扩展。

5.1 多维数组的创建

 三维数组实际上可以看做行-列-页确定的一个长方体。MATLAB中创建多维数组有三种方法：

1. 通过指定索引把二维数组扩展为多维数组

 方法就是先创建三维数组中每一页上的二维数组，然后将它们赋值到三维数组第三维的指定位置上。同样，也可以通过对二维数组的扩展创建更高维的数组。对于没有指定赋值的维度上的元素，MATLAB默认赋值为0。

>> a = [5 7 8;3 4 5;4 5 7]
a =
     5     7     8
     3     4     5
     4     5     7

>> a(:,:,2) = [1 3 5;3 4 6;4 5 7]
a(:,:,1) =
     5     7     8
     3     4     5
     4     5     7

a(:,:,2) =
     1     3     5
     3     4     6
     4     5     7

2. 采用MATLAB的内联函数创建

>> ones(2,2,3)
ans(:,:,1) =
     1     1
     1     1

ans(:,:,2) =
     1     1
     1     1

ans(:,:,3) =
     1     1
     1     1

>> zeros(2,2,3)
ans(:,:,1) =
     0     0
     0     0

ans(:,:,2) =
     0     0
     0     0

ans(:,:,3) =
     0     0
     0     0

>> rand(2,2,3)
ans(:,:,1) =
    0.6324    0.2785
    0.0975    0.5469

ans(:,:,2) =
    0.9575    0.1576
    0.9649    0.9706

ans(:,:,3) =
    0.9572    0.8003
    0.4854    0.1419

>> randn(2,2,3)
ans(:,:,1) =
   -2.2794    0.2797
   -1.8988    0.2655

ans(:,:,2) =
    0.0637    0.7898
    0.7260    0.4789

ans(:,:,3) =
   -0.2847   -0.6239
    0.9077   -0.0129


>> repmat(2.5,[2,2,3])
ans(:,:,1) =
    2.5000    2.5000
    2.5000    2.5000

ans(:,:,2) =
    2.5000    2.5000
    2.5000    2.5000

ans(:,:,3) =
    2.5000    2.5000
    2.5000    2.5000

>> repmat([1 2 1],[2 2 3])
ans(:,:,1) =
     1     2     1     1     2     1
     1     2     1     1     2     1

ans(:,:,2) =
     1     2     1     1     2     1
     1     2     1     1     2     1

ans(:,:,3) =
     1     2     1     1     2     1
     1     2     1     1     2     1

3. 利用cat函数进行连接创建

>> a = cat(3,[2,3;4,5],[2,4;5,6])
a(:,:,1) =
     2     3
     4     5

a(:,:,2) =
     2     4
     5     6

4.多维数组属性

>> size(a) % 上例的a矩阵
ans =
     2     2     2

>> ndims(a)
ans =
     3

>> whos
  Name      Size             Bytes  Class     Attributes

  a         2x2x2               64  double              
  ans       1x1                  8  double          

5.2 多维数组的操作

5.2.1 多维数组的索引

 与二维数组类似，比如可以直接访问a(1,2,3)，即a的第一行第二列第三页的元素；a(3,2,:)，即a的第三行第二列所有页的元素；a(:,:,[1 2])，即a的第一页第二页上所有行和所有列的元素。

5.2.2 多维数组的维度操作

>> a = randn(3,4,1,2)
a(:,:,1,1) =
   -0.1205    0.6732   -1.1834    1.6195
   -1.8522   -0.3350   -0.2075    0.0370
   -1.0730    0.4033   -1.9385    0.8841

a(:,:,1,2) =
    0.9089    1.7016    1.8210    0.2632
    0.5233    0.5250    0.1016   -0.1659
   -0.5582    1.0860   -1.1987    0.2316

>> a = reshape(a,[2 4 1 3])
a(:,:,1,1) =
   -0.1205   -1.0730   -0.3350   -1.1834
   -1.8522    0.6732    0.4033   -0.2075

a(:,:,1,2) =
   -1.9385    0.0370    0.9089   -0.5582
    1.6195    0.8841    0.5233    1.7016

a(:,:,1,3) =
    0.5250    1.8210   -1.1987   -0.1659
    1.0860    0.1016    0.2632    0.2316

>> squeeze(a) % 清除单值维度
ans(:,:,1) =
   -0.1205   -1.0730   -0.3350   -1.1834
   -1.8522    0.6732    0.4033   -0.2075

ans(:,:,2) =
   -1.9385    0.0370    0.9089   -0.5582
    1.6195    0.8841    0.5233    1.7016

ans(:,:,3) =
    0.5250    1.8210   -1.1987   -0.1659
    1.0860    0.1016    0.2632    0.2316

>> a = randn(4,3,2)
a(:,:,1) =
   -1.0736   -0.8384    0.5640
   -1.5019   -0.2955   -0.5026
    0.5686    0.4819   -0.4630
   -1.3645   -0.3159   -1.0611

a(:,:,2) =
   -0.5777   -2.1047   -0.6276
   -0.7961   -0.2042    0.6392
   -1.0471   -0.0478    1.1178
    0.5181    1.2487   -1.6204

>> permute(a,[3 1 2]) % 按照指定的顺序重新定义多维数组的维度顺序，ipermute可以看做是permute的逆函数。
ans(:,:,1) =
   -1.0736   -1.5019    0.5686   -1.3645
   -0.5777   -0.7961   -1.0471    0.5181

ans(:,:,2) =
   -0.8384   -0.2955    0.4819   -0.3159
   -2.1047   -0.2042   -0.0478    1.2487

ans(:,:,3) =
    0.5640   -0.5026   -0.4630   -1.0611
   -0.6276    0.6392    1.1178   -1.6204

补充

1.数组合并

>> a = eye(2)
a =
     1     0
     0     1

>> b = randn(2)
b =
    1.7119   -2.1384
   -0.1941   -0.8396

>> [a b]
ans =
    1.0000         0    1.7119   -2.1384
         0    1.0000   -0.1941   -0.8396

>> [a;b]
ans =
    1.0000         0
         0    1.0000
    1.7119   -2.1384
   -0.1941   -0.8396

2. 求积

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

>> prod(a,1) % 默认为1
ans =
    28    80   162

>> prod(a,2)
ans =
     6
   120
   504

>> cumprod(a,1)
ans =
     1     2     3
     4    10    18
    28    80   162

>> cumprod(a,2)
ans =
     1     2     6
     4    20   120
     7    56   504

3. 求差分

>> a = magic(4)
a =
    16     2     3    13
     5    11    10     8
     9     7     6    12
     4    14    15     1

>> diff(a)
ans =
   -11     9     7    -5
     4    -4    -4     4
    -5     7     9   -11

>> diff(a,2)
ans =
    15   -13   -11     9
    -9    11    13   -15

>> diff(a,1,2)
ans =
   -14     1    10
     6    -1    -2
    -2    -1     6
    10     1   -14

diff(a,n,dim)：n为求差分的阶次，dim=1时，计算各列元素的差分，dim=2时计算各行元素的差分。

4. 矩阵分析常见函数

函数名	功能
norm	求矩阵或者向量的范数
normest	估计矩阵的2阶范数
rank	求矩阵的秩
det	求矩阵的行列式
trace	求矩阵的迹
null	求化零矩阵
orth	求正交化空间
subspace	求两个矩阵空间的角度

norm(a,p)：p=1,一阶范式；p=2，二阶范式；p=inf，正无限阶范式；p=‘fro’，F范式。

5. 矩阵分解

函数	功能
chol	Cholesky分解
lu	矩阵LU分解
qr	正交三角分解
cholinc	稀疏矩阵的不完全Cholesky分解
luinc	稀疏矩阵的不完全LU分解

6. 特征值和特征向量

（1） eig(a)：矩阵a的特征值向量

（2）[V,D] = eig(a)：矩阵a的特征值在对角线上的对角矩阵D和矩阵V,满足AV=VD

（3）eigs(a)：a的部分特征值组成的向量，最多计算6个特征值

（4）[V,D]=eig(a,b)：矩阵a的特征值向量V和特征向量D（满足AV=BV*D）

7. 稀疏矩阵

>> a = sparse([1 2 3 4 5],[1 2 3 4 5],[1,2,3,4,5],10,12)
a =
   (1,1)        1
   (2,2)        2
   (3,3)        3
   (4,4)        4
   (5,5)        5

>> A = [1 0 0 1;0 0 0 1;0 1 0 0]
A =
     1     0     0     1
     0     0     0     1
     0     1     0     0

>> sparse(A)
ans =
   (1,1)        1
   (3,2)        1
   (1,4)        1
   (2,4)        1

>> whos
  Name       Size            Bytes  Class     Attributes

  A          3x4                96  double              
  a         10x12              184  double    sparse    
  ans        3x4               104  double    sparse    
  b          2x2                32  double              
  c          3x6               144  double

>> full(ans) % 稀疏矩阵转换为满矩阵
ans =
     1     0     0     1
     0     0     0     1
     0     1     0     0

sparse(a)

sparse(i,j,s,m,n)

sparse(i,j,s)

sparse(m,n)

该函数生成稀疏矩阵，a是待处理的完全矩阵，i j为稀疏矩阵的下标向量，s为对应的值向量，生成的矩阵为m*n维。