第2章向量、矩阵与数组

2.1 向量

2.1.1 常用常量

名称	含义	名称	含义
ans	MATLAB 中默认的变量	nargin	所用函数的输入变量数目
pi	圆周率 \(\pi\) 的双精度表示	nargout	所用函数的输出变量数目
Inf(inf)	无穷大，由 0 作为除数引入此常量	realmin	最小可用正实数，\(2 ^ {-1022}\)
i(j)	复数中的虚数单位	realmax	最大可用正实数，\(2 ^ {1023}\)
NaN	不定值，表示非数值量，产生于 \(0/0\)、\(\infty/\infty\)、\(0*\infty\) 等运算	eps	容差变量，当绝对值小于 eps 时认为为 0 ，即浮点数的最小分辨率，在系统中该值为 \(2 ^ {-52}\)

2.1.2 创建向量

2.1.2.1 直接输入法

>> A=[2, 4, 6, 8] % 使用“,”创建行向量

A =

     2     4     6     8

>> B=[2 4 6 8] % 使用“ ”创建行向量

B =

     2     4     6     8

>> C=[2; 4; 6; 8]; % 使用“;”创建列向量
>> C % 使用“;”结尾时，不会立刻显示结果

C =

     2
     4
     6
     8

2.1.2.2 冒号表达式法

>> A=1:2:10 % 构造步长为 2 的递增向量

A =

     1     3     5     7     9

>> B=-2.5:2.5 % 省略时，默认构造步长为 1 的递增向量

B =

   -2.5000   -1.5000   -0.5000    0.5000    1.5000    2.5000

>> C=2:-0.5:-1 % 构造步长为 -1 的递减向量

C =

    2.0000    1.5000    1.0000    0.5000         0   -0.5000   -1.0000

2.1.2.3 函数法

A=linspace(a1, an, n) % 生成等分间距向量，省略 n 时，默认分为 100 份
B=logspace(a1, an, n) % 生成对数间距向量，省略 n 时，默认分为 50 份

>> A=linspace(1,10); % 创建 1~10 的 100 个线性等分元素
>> B=linspace(1,5,6) % 创建 1~6 的 5 个线性等分元素

B =

    1.0000    1.8000    2.6000    3.4000    4.2000    5.0000

>> C=logspace(0,4); % 创建 0~4 的 50 个对数等分元素
>> D=logspace(0,4,5) % 创建 0~4 的 5 个对数等分元素

D =

           1          10         100        1000       10000

2.1.3 向量运算

2.1.3.1 向量的算术运算

>> A=[2 4 6 8];
>> B=3:2:9;
>> AT=A'; % ' 表示转置
>> BT=B';
>> E1=A+B % 求 A 与 B 的元素和

E1 =

     5     9    13    17

>> E2=A-B % 求 A 与 B 的元素差

E2 =

    -1    -1    -1    -1

>> F=AT-BT

F =

    -1
    -1
    -1
    -1

>> G1=4*A  % 求 A 与 B 的元素积

G1 =

     8    16    24    32

>> G2=B/4  % 求 A 与 B 的元素商

G2 =

    0.7500    1.2500    1.7500    2.2500

2.1.3.2 向量的点积和差积运算

C=dot(A,B) % 计算 A 与 B 的标量点积
C=dot(A,B,dim) % 计算 A 与 B 沿维度 dim 的点积， dim 为正整数的标量
C=cross(A,B) % 计算 A 与 B 的标量叉积
C=cross(A,B,dim) % 计算 A 与 B 沿维度 dim 的叉积， dim 为正整数的标量

>> A=[2 4 6 8];
>> B=3:6;
>> AT=A';
>> BT=B';
>> e=dot(A,B)

e =

   100

>> f=dot(AT,BT)

f =

   100

>> A=3:5;
>> B=2:4;
>> C=[3 2 1];
>> E=cross(A,B)

E =

     1    -2     1

>> D=dot(C,cross(A,B))

D =

     0

>> E=cross(C,dot(A,B))
错误使用 cross ( 第 29 行 )
在获取交叉乘积的维度中， A 和 B 的长度必须为 3 。

2.2 矩阵

>> A=[1, 2, 3, 4; 5, 6, 7, 8; 9, 10, 11, 12; 13, 14, 15, 16]

A =

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

2.2.1 特殊矩阵函数

函数名	函数功能	基本调用函数
ones	生成矩阵元素全为 1 的矩阵	A=ones(n)	生成 n*n 个 1
ones	生成矩阵元素全为 1 的矩阵	A=ones(m,n)	生成 m*n 个 1
zeros	生成矩阵元素全为 0 的矩阵	A=zeros(n)	生成 n*n 个 0
zeros	生成矩阵元素全为 0 的矩阵	A=zeros(m,n)	生成 m*n 个 0
eye	生成单位矩阵，即主对角线上的元素为 1 ，其他全为 0	A=eye(n)	生成 n*n 的单位矩阵
eye	生成单位矩阵，即主对角线上的元素为 1 ，其他全为 0	A=eye(m,n)	生成 m*n 的单位矩阵
diag	把向量转化为对角矩阵或得到矩阵的对角元素	D=diag(v,k)	把向量√转换为一个对角矩阵
		D=diag(v)	把向量 v 转换为一个主对角矩阵
		x=diag(A,k)	得到矩阵 A 的第 k 条对角线上的元素， k=0 表示主对角线， k>0 表示主对角线上方， k<0 表示主对角线下方
		x=diag(A)	得到矩阵 A 的主对角元素
magic	生成魔方矩阵，即每行、每列之和相等的矩阵	magic(n)	生成 n*n 的魔方矩阵
rand	生成 0~1 均匀分布的随机数	Y=rand(n)	生成 n*n 的 0~1 均匀分布的随机数
rand	生成 0~1 均匀分布的随机数	Y=rand(m,n)	生成 m*n 的 0~1 均匀分布的随机数
randn	生成均值为 0 、方差为 1 高斯分布的随机数	Y=randn(n)	生成 n*n 的标准高斯分布的随机数
randn	生成均值为 0 、方差为 1 高斯分布的随机数	Y=randn(m,n)	生成 m*n 的标准高斯分布的随机数
randperm	生成整数 1~n 的随机排列	p=randperm(n)	生成整数 1~n 的随机排列
passcal	创建 PASCAL（帕斯卡）矩阵	P=pascal(n)	生成 n 阶帕斯卡矩阵
		P=pascal(n,1)	生成帕斯卡矩阵的下三角 Cholesky 因子， P 是对合矩阵，即矩阵 P 是它自身的逆矩阵
		P=pascal(n,2)	生成 pascal(n,1) 的转置和置换矩阵， P 是单位矩阵的立方根
compan	生成多项式的伴随矩阵	A=compan(u)	生成第一行为 -u(2:n)/u(1 ）的对应伴随矩阵， u 是多项式系数向量， compan(u) 的特征值是多项式的根

>> B=ones(2,3) % 创建 2*3 的全 1 矩阵

B =

     1     1     1
     1     1     1

>> C=eye(3) % 创建 3*3 的单位矩阵

C =

     1     0     0
     0     1     0
     0     0     1

>> A=magic(3) % 创建 3*3 的魔方矩阵

A =

     8     1     6
     3     5     7
     4     9     2

>> rand(4) % 创建 4*4 的随机数矩阵

ans =

    0.8147    0.6324    0.9575    0.9572
    0.9058    0.0975    0.9649    0.4854
    0.1270    0.2785    0.1576    0.8003
    0.9134    0.5469    0.9706    0.1419

\[计算与多项式 \ (x-1)(x-2)(x+3)=x ^ 3-7x+6\ 对应的伴随矩阵。 \]

>> u=[1 0 -7 6]; % 多项式的系数
>> A=compan(u) % 多项式对应的伴随矩阵

A =

     0     7    -6
     1     0     0
     0     1     0

>> X=eig(A) % A 的特征值是多项式的根

X =

   -3.0000
    2.0000
    1.0000

2.2.2 矩阵拓展与裁剪

C=[A B] % 水平方向上合并矩阵 A 和 B
C=[A;B] % 垂直方向上合并矩阵 A 和 B
>> A=eye(2,4);
>> B=ones(2,4);
>> c=[A;B]

c =

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

>> D=[A B]

D =

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

2.2.2.1 矩阵合并函数

函数名	函数功能	基本调用格式
cat	在指定方向上合并矩阵	cat(dim,A,B)	在 dim 维方向上合并矩阵 A 和 B
		cat(2,A,B)	与 [A B] 的用途一致
		cat(1,A,B)	与 [A; B] 的用途一致
horzcat	在水平方向上合并矩阵	horzcat(A,B)	与 [A B] 的用途一致
vertcat	在竖直方向上合并矩阵	vertcat(A,B)	与 [A; B] 的用途一致
repmat	通过复制矩阵来构造新的矩阵	B=repmat(A,M,N)	得到 M*N 个 A 的大矩阵
blkdiag	用已知矩阵来构造块对角化矩阵	Y=blkdiag(A,B,…)	得到以矩阵 A,B,… 等为对角块的矩阵 Y

>> A=ones(3);
>> B=eye(2);
>> C=blkdiag(A,B) % 构造对角化矩阵

C =

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

2.2.2.2 矩阵的拓展或裁剪

>> A=magic(3);
>> A(4,5)=12

A =

     8     1     6     0     0
     3     5     7     0     0
     4     9     2     0     0
     0     0     0     0    12

>> A(:,4)=16

A =

     8     1     6    16     0
     3     5     7    16     0
     4     9     2    16     0
     0     0     0    16    12

>> B=A(:,[1:5,1:5])

B =

     8     1     6    16     0     8     1     6    16     0
     3     5     7    16     0     3     5     7    16     0
     4     9     2    16     0     4     9     2    16     0
     0     0     0    16    12     0     0     0    16    12

>> A=magic(3)

A =

     8     1     6
     3     5     7
     4     9     2

>> A(3,:)=[]

A =

     8     1     6
     3     5     7

>> 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

>> B=A(2,:) % 提取第 2 行元素

B =

    23     5     7    14    16

>> C=A(1:2:5,2:2:5) % 提取第 1 、 3 、 5 行中的第 2 、 4 个元素

C =

    24     8
     6    20
    18     2

>> D=A(1:2:5,:) % 提取第 1 、 3 、 5 行中的所有元素

D =

    17    24     1     8    15
     4     6    13    20    22
    11    18    25     2     9

>> E=A([1,4],[2,2,5]) % 提取第 1 、 4 行中的第 2 、 2 、 5 行元素

E =

    24    24    15
    12    12     3

>> F=A([1,2,5],:) % 提取第 1 、 2 、 5 行中的所有元素

F =

    17    24     1     8    15
    23     5     7    14    16
    11    18    25     2     9

>> A([1,2,5],:)=[] % 删除第 1 、 2 、 5 行中的所有元素，创建新矩阵

A =

     4     6    13    20    22
    10    12    19    21     3

2.2.3 矩阵下标引用

2.2.3.1 全下标寻址

>> A=magic(4)

A =

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

>> a=A(2,4) % 查找第 2 行第 4 列的数字

a =

     8

>> A(2,4)=0

A =

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

2.2.3.2 单下标寻址

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

A =

     1     4     7
     2     5     8
     3     6     9

>> a=A(4)

a =

     4

>> b=A(5)

b =

     5

>> c=A(7)

c =

     7

2.2.3.3 引用方式转换

ind=sub2ind(sz,row,col) % 针对大小为 sz 的矩阵返回由 row 和 col 指定的行列下标的对应线性索引 ind， sz 是包含两个元素的向量
[row,col]=ind2sub(sz,ind) % 返回数组 row 和 col，其中包含与大小为 sz 的矩阵的线性索引 ind 对应的等效行和列下标

>> row=[1 2 3 1];
>> col=[2 2 2 3];
>> sz=[3 3];
>> ind=sub2ind(sz,row,col) % 将下标转换为线性索引

ind =

     4     5     6     7

>> ind=[3 4 5 6];
>> sz=[3 3];
>> [row,col]=ind2sub(sz,ind) % 将线性索引转换为下标

row =

     3     1     2     3


col =

     1     2     2     2

2.2.4 矩阵信息的获取

2.2.4.1 矩阵尺寸函数

函数名	函数功能	基本调用格式
length	矩阵最长方向的长度	n=length(X)	相当于 max(size(X))
ndims	矩阵的维数	n=ndims(A)	矩阵的维数
numel	矩阵的元素个数	n=numel(A)	矩阵的元素个数
size	矩阵各个方向的长度	d=size(X)	返回的大小信息以向量方式存储
		[m,n]=size(X)	返回的大小信息分开存储
		m=size(X,dim)	返回某一位的大小信息

>> A=rand(3,4) % 创建随机矩阵

A =

    0.6787    0.3922    0.7060    0.0462
    0.7577    0.6555    0.0318    0.0971
    0.7431    0.1712    0.2769    0.8235

>> n1=length(A) % 求矩阵 A 的最长方向的长度

n1 =

     4

>> n2=ndims(A) % 求矩阵 A 的维度

n2 =

     2

>> n3=numel(A) % 求矩阵的元素个数

n3 =

    12

2.2.4.2 矩阵元素的数据类型和结构信息

函数名	函数功能	基本调用格式
class	返回输入数据的数据类型	C=class(obj)
isa	判断输入数据是否为指定数据类型	tf=isa(obj,'class_name')
iscell	判断输入数据是否为元胞数组	tf=iscell(A)
iscellstr	判断输入数据是否为字符向量元胞数组	tf=iscellstr(A)
ischar	判断输入数据是否为字符数组	tf=ischar(A)
isfloat	判断输入数据是否为浮点数组	tf=isfloat(A)
isinteger	判断输入数据是否为整数数组	tf=isinteger(A)
islogical	判断输入数据是否为逻辑数组	tf=islogical(A)
isnumeric	判断输入数据是否为数值数组	tf=isnumeric(A)
isreal	判断输入数据是否为实数数组	tf=isreal(A)
isstruct	判断输入数据是否为结构体数组	tf=isstruct(A)
isempty	测试矩阵是否为空矩阵	tf=isempty(A)
isscalar	测试矩阵是否为标量	tf=isscalar(A)
issparse	测试矩阵是否为稀疏矩阵	tf=issparse(A)
isvector	测试矩阵是否为矢量	tf=isvector(A)

2.2.4.3 矩阵结构的改变

函数名	函数功能	基本调用格式
reshape	以指定的行数和列数重新排列矩阵元素	B=reshape(A,m,n)	把矩阵 A 变为 m*n 大小
repmat	以指定的行数和列数复制矩阵	B=repmat(A,m,n)	重复数组副本
rot90	旋转矩阵 90 °	B=rot90(A) B=rot90(A,k)	矩阵旋转 90 ° 矩阵旋转 k*90 ° ， k 为整数
fliplr	以竖直方向为轴做镜像	B=fliplr(A)	从左向右翻转 A
flipud	以水平方向为轴做镜像	B=flipud(A)	从上向下翻转 A
flipdim	以指定的轴做镜像	B=flipdim(A,dim)	dim=2 表示以水平方向为轴做镜像 dim=1 表示以竖直方向为轴做镜像
transpose	矩阵的转置	B=transpose(A)	相当于 B=A.'
ctranspose	矩阵的共轭转置	B=ctranspose(A)	相当于 B=A'

>> A=rand(3) % 创建随机矩阵

A =

    0.8147    0.9134    0.2785
    0.9058    0.6324    0.5469
    0.1270    0.0975    0.9575

>> B=flipud(A) % 把矩阵以水平方向为轴做镜像

B =

    0.1270    0.0975    0.9575
    0.9058    0.6324    0.5469
    0.8147    0.9134    0.2785

>> B=fliplr(A) % 从左向右翻转

B =

    0.2785    0.9134    0.8147
    0.5469    0.6324    0.9058
    0.9575    0.0975    0.1270

>> B=transpose(A) % 求矩阵的转置

B =

    0.8147    0.9058    0.1270
    0.9134    0.6324    0.0975
    0.2785    0.5469    0.9575

2.3 稀疏矩阵

nnz(M)/prod(size(M)); % 确定矩阵的密度
nnz(M)/numel(M); % 只有数据量极大且密度非常低的稀疏格式

2.3.1 满矩阵与稀疏矩阵的转换

S=sparse(A) % 将满矩阵 A 存为稀疏矩阵，以节省内存
S=sparse(m,n) % 生成 m*n 的全零稀疏矩阵
S=sparse(i,j,v) % 根据 i、 j 和 v 三元组生成生成稀疏矩阵 S， S(i(k),j(k))=v(k)
S=sparse(i,j,v,m,n) % 将 S 的大小指定为 m*n
A=full(S) % 将稀疏矩阵 S 转换为满储存结构

>> A=[0 0 5 0; 8 0 0 0; 0 1 0 0; 0 0 0 7]

A =

     0     0     5     0
     8     0     0     0
     0     1     0     0
     0     0     0     7

>> nnz(A)/prod(size(A)) % 查看矩阵密度

ans =

    0.2500

>> B=sparse(A) % 稀疏矩阵存储

B =

  4 × 4 稀疏 double 矩阵 (4 个非零值 )

   (2,1)        8
   (3,2)        1
   (1,3)        5
   (4,4)        7

>> C=full(B) % 满矩阵存储

C =

     0     0     5     0
     8     0     0     0
     0     1     0     0
     0     0     0     7

2.3.2 基于对角线元素创建稀疏矩阵

S=spdiags(B,d,m,n) % 创建大小为 m*n 且元素在 p 条对角线上的输出矩阵 S

>> B=[41 11 0; 52 22 0; 63 33 13; 74 44 24];
>> d=[-3; 0; 2];
>> A=spdiags(B, d, 7, 4)

A =

  7 × 4 稀疏 double 矩阵 (10 个非零值 )

   (1,1)       11
   (4,1)       41
   (2,2)       22
   (5,2)       52
   (1,3)       13
   (3,3)       33
   (6,3)       63
   (2,4)       24
   (4,4)       44
   (7,4)       74

>> full(A)

ans =

    11     0    13     0
     0    22     0    24
     0     0    33     0
    41     0     0    44
     0    52     0     0
     0     0    63     0
     0     0     0    74

2.3.2.1 特殊稀疏矩阵创建函数

函数名	函数功能	基本调用格式
speye	创建单位稀疏矩阵	S=speye(m,n)	创建 m*n 的单位稀疏矩阵
speye	创建单位稀疏矩阵	S=speye(n)	创建 n*n 的单位稀疏矩阵
spones	创建非零元素为 1 的稀疏矩阵	R=spones(S)	把矩阵 S 的非零元素的值改为 1
sprand	创建非零元素为均匀分布的随机数的稀疏矩阵	R=sprand(S)	把矩阵 S 的非零元素的值改为均匀分布的随机数 R=sprand(m,n,density)，创建非零元素密度为 density 的 m*n 的均匀分布的随机数
sprandn	创建非零元素为高斯分布的随机数的稀疏矩阵	R=sprandn(S)	把矩阵 S 的非零元素的值改为高斯分布的随机数 R=sprandn(m,n,density)，创建非零元素密度为 density 的 m*n 的高斯分布的随机数
sprandsym	创建非零元素为高斯分布的随机数的对称稀疏矩阵	R=sprandsym(S)	返回对称随机稀疏矩阵，其下三角和主对角结构与 S 相同
sprandsym	创建非零元素为高斯分布的随机数的对称稀疏矩阵	R=sprandsym(n,density)	返回 n*n 的对称随机稀疏矩阵，其非零元素密度为 density
spalloc	为稀疏矩阵分配空间	S=spalloc(m,n,nzmax)	相当于 sparse([],[],[],m,n,nzmax)

2.3.2.2 查看稀疏矩阵非零值信息的函数

函数名	函数功能	基本调用格式
nnz	返回非零值的个数	n=nnz(X)
nonzeros	返回非零值	s=nonzeros(A)
nzmax	返回用于存储非零值的空间长度	n=nzmax(S)

>> rng default % 设置种子数，方便复现
>> S=sprand(3,4,0.3) % 创建随机数的稀疏矩阵

S =

  3 × 4 稀疏 double 矩阵 (3 个非零值 )

   (3,1)       0.9649
   (1,2)       0.9575
   (3,3)       0.1576

>> A=full(S) % 满矩阵存储

A =

         0    0.9575         0         0
         0         0         0         0
    0.9649         0    0.1576         0

>> B=nonzeros(A) % 返回非零值

B =

    0.9649
    0.9575
    0.1576

2.3.3 从外部文件导入稀疏矩阵

S=spconvert(D) % 根据 D 的列，按 sparse 函数的类似方式构造稀疏矩阵 S

>> load uphill.dat
>> S=spconvert(uphill) % 转换为稀疏矩阵

S =

  4 × 4 稀疏 double 矩阵 (10 个非零值 )

   (1,1)       1.0000
   (1,2)       0.5000
   (2,2)       0.3333
   (1,3)       0.3333
   (2,3)       0.2500
   (3,3)       0.2000
   (1,4)       0.2500
   (2,4)       0.2000
   (3,4)       0.1667
   (4,4)       0.1429

>> full(S) % 满矩阵存储

ans =

    1.0000    0.5000    0.3333    0.2500
         0    0.3333    0.2500    0.2000
         0         0    0.2000    0.1667
         0         0         0    0.1429

2.4 多维数组

2.4.1 多维数组属性

C=cat(dim,A,B) % 沿维度 dim 将 B 串联到 A 的末尾
C=cat(dim,A1,A2,…,An) % 沿维度 dim 串联 A1 、 A2 、… An

>> A=ones(3)

A =

     1     1     1
     1     1     1
     1     1     1

>> B=zeros(3)

B =

     0     0     0
     0     0     0
     0     0     0

>> C1=cat(1,A,B)

C1 =

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

>> C2=cat(2,A,B)

C2 =

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

>> C3=cat(3,A,B)

C3(:,:,1) =

     1     1     1
     1     1     1
     1     1     1


C3(:,:,2) =

     0     0     0
     0     0     0
     0     0     0

>> C4=cat(4,A,B)

C4(:,:,1,1) =

     1     1     1
     1     1     1
     1     1     1


C4(:,:,1,2) =

     0     0     0
     0     0     0
     0     0     0

数组属性	函数用法	函数功能
尺寸	size(A)	按照行 - 列 - 页的顺序，返回数组 A 每一维上的大小
维度	ndims(A)	返回数组 A 具有的维度值
内存占用 / 数据类型等	whos	返回当前工作区中的各个变量的详细信息

>> A=cat(4,[6 2 0; 4 5 9], [0 3 2; 9 4 2], [7 1 2; 4 8 4]) % 通过合并方式构建多维数组

A(:,:,1,1) =

     6     2     0
     4     5     9


A(:,:,1,2) =

     0     3     2
     9     4     2


A(:,:,1,3) =

     7     1     2
     4     8     4

>> size(A) % 获取数组 A 的尺寸属性

ans =

     2     3     1     3

>> ndims(A) % 获取数组 A 的维度属性

ans =

     4

>> whos
  Name      Size               Bytes  Class     Attributes

  A         2x3x1x3              144  double              
  ans       1x1                    8  double

2.4.2 多维数组操作

2.4.2.1 多维数组的索引

>> rng default % 设置种子数，方便复现
>> A=randn(3,5,2)

A(:,:,1) =

    0.5377    0.8622   -0.4336    2.7694    0.7254
    1.8339    0.3188    0.3426   -1.3499   -0.0631
   -2.2588   -1.3077    3.5784    3.0349    0.7147


A(:,:,2) =

   -0.2050    1.4090   -1.2075    0.4889   -0.3034
   -0.1241    1.4172    0.7172    1.0347    0.2939
    1.4897    0.6715    1.6302    0.7269   -0.7873

>> A(3,2,2) % 访问 A 的第 3 行第 2 列第 2 页的元素

ans =

    0.6715

>> A(21) % 访问 A 第 21 个元素（即第 3 行第 2 列第 2 页的元素）

ans =

    0.6715

2.4.2.2 多维数组的维度操作

B=reshape(A,sz1,…,szN) % 将 A 重构为一个 sz1*…*szN 数组，其中 sz1 、…、 szN 指定每个维度的大小
B=squeeze(A) % 返回一个数组，其元素与输入数组 A 相同，但删除了长度为 1 的维度，例如：若 A 是 3*1*2 数组，则 squeeze(A) 返回 3*2 矩阵

>> A1=ones(3,2,3); % 创建 3*2*3 的数组
>> B1=reshape(A1,3,6) % 重构数组

B1 =

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

>> B2=reshape(A1,2,[]) % 使用 [] 可以自动计算该维度的大小

B2 =

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

>> A2=zeros(3,1,3); % 创建 3*1*3 的数组
>> A2(:,:,1)=[1 2 3]';
>> A2(:,:,2)=[-2 -4 -6]';
>> B3=squeeze(A2) % 删除长度为 1 的维度，得到 3*3 的矩阵

B3 =

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

B=permute(A,dimorder) % 按照向量 dimorder 指定的顺序重新排列数组的维度， ipermute 可以看作是 permute 的逆函数

>> rng default
>> A=rand(3,5,2) % 创建 3*5*2 的数组

A(:,:,1) =

    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


A(:,:,2) =

    0.1419    0.7922    0.0357    0.6787    0.3922
    0.4218    0.9595    0.8491    0.7577    0.6555
    0.9157    0.6557    0.9340    0.7431    0.1712

>> B=permute(A,[3 2 1]) % 交换第 1 个维度和第 3 个维度，得到 2*5*3 的数组

B(:,:,1) =

    0.8147    0.9134    0.2785    0.9649    0.9572
    0.1419    0.7922    0.0357    0.6787    0.3922


B(:,:,2) =

    0.9058    0.6324    0.5469    0.1576    0.4854
    0.4218    0.9595    0.8491    0.7577    0.6555


B(:,:,3) =

    0.1270    0.0975    0.9575    0.9706    0.8003
    0.9157    0.6557    0.9340    0.7431    0.1712

>> C=ipermute(B,[3 2 1])

C(:,:,1) =

    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


C(:,:,2) =

    0.1419    0.7922    0.0357    0.6787    0.3922
    0.4218    0.9595    0.8491    0.7577    0.6555
    0.9157    0.6557    0.9340    0.7431    0.1712

2.4.2.3 多维数组参与数学计算

>> A=randn(2,4,2)

A(:,:,1) =

   -0.1649    1.0933   -0.8637   -1.2141
    0.6277    1.1093    0.0774   -1.1135


A(:,:,2) =

   -0.0068   -0.7697   -0.2256   -1.0891
    1.5326    0.3714    1.1174    0.0326

>> B=sum(A)

B(:,:,1) =

    0.4628    2.2025   -0.7863   -2.3276


B(:,:,2) =

    1.5258   -0.3983    0.8918   -1.0565

>> C=sin(A)

C(:,:,1) =

   -0.1641    0.8881   -0.7602   -0.9371
    0.5873    0.8954    0.0773   -0.8972


C(:,:,2) =

   -0.0068   -0.6959   -0.2237   -0.8862
    0.9993    0.3629    0.8989    0.0326

>> D=eig(A(:,[1 2],1))

D =

   -0.5728
    1.5172
```    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

>> B=A(2,:) % 提取第2行元素

B =

    23     5     7    14    16

>> C=A(1:2:5,2:2:5) % 提取第1、3、5行中的第2、4个元素

C =

    24     8
     6    20
    18     2

>> D=A(1:2:5,:) % 提取第1、3、5行中的所有元素

D =

    17    24     1     8    15
     4     6    13    20    22
    11    18    25     2     9

>> E=A([1,4],[2,2,5]) % 提取第1、4行中的第2、2、5行元素

E =

    24    24    15
    12    12     3

>> F=A([1,2,5],:) % 提取第1、2、5行中的所有元素

F =

    17    24     1     8    15
    23     5     7    14    16
    11    18    25     2     9

>> A([1,2,5],:)=[] % 删除第1、2、5行中的所有元素，创建新矩阵

A =

     4     6    13    20    22
    10    12    19    21     3

2.2.3 矩阵下标引用

2.2.3.1 全下标寻址

>> A=magic(4)

A =

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

>> a=A(2,4) % 查找第2行第4列的数字

a =

     8

>> A(2,4)=0

A =

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

2.2.3.2 单下标寻址

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

A =

     1     4     7
     2     5     8
     3     6     9

>> a=A(4)

a =

     4

>> b=A(5)

b =

     5

>> c=A(7)

c =

     7

2.2.3.3 引用方式转换

ind=sub2ind(sz,row,col) % 针对大小为sz的矩阵返回由row和col指定的行列下标的对应线性索引ind，sz是包含两个元素的向量
[row,col]=ind2sub(sz,ind) % 返回数组row和col，其中包含与大小为sz的矩阵的线性索引ind对应的等效行和列下标

>> row=[1 2 3 1];
>> col=[2 2 2 3];
>> sz=[3 3];
>> ind=sub2ind(sz,row,col) % 将下标转换为线性索引

ind =

     4     5     6     7

>> ind=[3 4 5 6];
>> sz=[3 3];
>> [row,col]=ind2sub(sz,ind) % 将线性索引转换为下标

row =

     3     1     2     3


col =

     1     2     2     2

2.2.4 矩阵信息的获取

2.2.4.1 矩阵尺寸函数

函数名	函数功能	基本调用格式
length	矩阵最长方向的长度	n=length(X)	相当于max(size(X))
ndims	矩阵的维数	n=ndims(A)	矩阵的维数
numel	矩阵的元素个数	n=numel(A)	矩阵的元素个数
size	矩阵各个方向的长度	d=size(X)	返回的大小信息以向量方式存储
		[m,n]=size(X)	返回的大小信息分开存储
		m=size(X,dim)	返回某一位的大小信息

>> A=rand(3,4) % 创建随机矩阵

A =

    0.6787    0.3922    0.7060    0.0462
    0.7577    0.6555    0.0318    0.0971
    0.7431    0.1712    0.2769    0.8235

>> n1=length(A) % 求矩阵A的最长方向的长度

n1 =

     4

>> n2=ndims(A) % 求矩阵A的维度

n2 =

     2

>> n3=numel(A) % 求矩阵的元素个数

n3 =

    12

2.2.4.2 矩阵元素的数据类型和结构信息

函数名	函数功能	基本调用格式
class	返回输入数据的数据类型	C=class(obj)
isa	判断输入数据是否为指定数据类型	tf=isa(obj,'class_name')
iscell	判断输入数据是否为元胞数组	tf=iscell(A)
iscellstr	判断输入数据是否为字符向量元胞数组	tf=iscellstr(A)
ischar	判断输入数据是否为字符数组	tf=ischar(A)
isfloat	判断输入数据是否为浮点数组	tf=isfloat(A)
isinteger	判断输入数据是否为整数数组	tf=isinteger(A)
islogical	判断输入数据是否为逻辑数组	tf=islogical(A)
isnumeric	判断输入数据是否为数值数组	tf=isnumeric(A)
isreal	判断输入数据是否为实数数组	tf=isreal(A)
isstruct	判断输入数据是否为结构体数组	tf=isstruct(A)
isempty	测试矩阵是否为空矩阵	tf=isempty(A)
isscalar	测试矩阵是否为标量	tf=isscalar(A)
issparse	测试矩阵是否为稀疏矩阵	tf=issparse(A)
isvector	测试矩阵是否为矢量	tf=isvector(A)

2.2.4.3 矩阵结构的改变

函数名	函数功能	基本调用格式
reshape	以指定的行数和列数重新排列矩阵元素	B=reshape(A,m,n)	把矩阵A变为m*n大小
repmat	以指定的行数和列数复制矩阵	B=repmat(A,m,n)	重复数组副本
rot90	旋转矩阵90°	B=rot90(A) B=rot90(A,k)	矩阵旋转90° 矩阵旋转k*90°，k为整数
fliplr	以竖直方向为轴做镜像	B=fliplr(A)	从左向右翻转A
flipud	以水平方向为轴做镜像	B=flipud(A)	从上向下翻转A
flipdim	以指定的轴做镜像	B=flipdim(A,dim)	dim=2表示以水平方向为轴做镜像 dim=1表示以竖直方向为轴做镜像
transpose	矩阵的转置	B=transpose(A)	相当于B=A.'
ctranspose	矩阵的共轭转置	B=ctranspose(A)	相当于B=A'

>> A=rand(3) % 创建随机矩阵

A =

    0.8147    0.9134    0.2785
    0.9058    0.6324    0.5469
    0.1270    0.0975    0.9575

>> B=flipud(A) % 把矩阵以水平方向为轴做镜像

B =

    0.1270    0.0975    0.9575
    0.9058    0.6324    0.5469
    0.8147    0.9134    0.2785

>> B=fliplr(A) % 从左向右翻转

B =

    0.2785    0.9134    0.8147
    0.5469    0.6324    0.9058
    0.9575    0.0975    0.1270

>> B=transpose(A) % 求矩阵的转置

B =

    0.8147    0.9058    0.1270
    0.9134    0.6324    0.0975
    0.2785    0.5469    0.9575

2.3 稀疏矩阵

nnz(M)/prod(size(M)); % 确定矩阵的密度
nnz(M)/numel(M); % 只有数据量极大且密度非常低的稀疏格式

2.3.1 满矩阵与稀疏矩阵的转换

S=sparse(A) % 将满矩阵A存为稀疏矩阵，以节省内存
S=sparse(m,n) % 生成m*n的全零稀疏矩阵
S=sparse(i,j,v) % 根据i、j和v三元组生成生成稀疏矩阵S，S(i(k),j(k))=v(k)
S=sparse(i,j,v,m,n) % 将S的大小指定为m*n
A=full(S) % 将稀疏矩阵S转换为满储存结构

>> A=[0 0 5 0; 8 0 0 0; 0 1 0 0; 0 0 0 7]

A =

     0     0     5     0
     8     0     0     0
     0     1     0     0
     0     0     0     7

>> nnz(A)/prod(size(A)) % 查看矩阵密度

ans =

    0.2500

>> B=sparse(A) % 稀疏矩阵存储

B =

  4×4 稀疏 double 矩阵 (4 个非零值)

   (2,1)        8
   (3,2)        1
   (1,3)        5
   (4,4)        7

>> C=full(B) % 满矩阵存储

C =

     0     0     5     0
     8     0     0     0
     0     1     0     0
     0     0     0     7

2.3.2 基于对角线元素创建稀疏矩阵

S=spdiags(B,d,m,n) % 创建大小为m*n且元素在p条对角线上的输出矩阵S

>> B=[41 11 0; 52 22 0; 63 33 13; 74 44 24];
>> d=[-3; 0; 2];
>> A=spdiags(B, d, 7, 4)

A =

  7×4 稀疏 double 矩阵 (10 个非零值)

   (1,1)       11
   (4,1)       41
   (2,2)       22
   (5,2)       52
   (1,3)       13
   (3,3)       33
   (6,3)       63
   (2,4)       24
   (4,4)       44
   (7,4)       74

>> full(A)

ans =

    11     0    13     0
     0    22     0    24
     0     0    33     0
    41     0     0    44
     0    52     0     0
     0     0    63     0
     0     0     0    74

2.3.2.1 特殊稀疏矩阵创建函数

函数名	函数功能	基本调用格式
speye	创建单位稀疏矩阵	S=speye(m,n)	创建m*n的单位稀疏矩阵
speye	创建单位稀疏矩阵	S=speye(n)	创建n*n的单位稀疏矩阵
spones	创建非零元素为1的稀疏矩阵	R=spones(S)	把矩阵S的非零元素的值改为1
sprand	创建非零元素为均匀分布的随机数的稀疏矩阵	R=sprand(S)	把矩阵S的非零元素的值改为均匀分布的随机数R=sprand(m,n,density)，创建非零元素密度为density的m*n的均匀分布的随机数
sprandn	创建非零元素为高斯分布的随机数的稀疏矩阵	R=sprandn(S)	把矩阵S的非零元素的值改为高斯分布的随机数R=sprandn(m,n,density)，创建非零元素密度为density的m*n的高斯分布的随机数
sprandsym	创建非零元素为高斯分布的随机数的对称稀疏矩阵	R=sprandsym(S)	返回对称随机稀疏矩阵，其下三角和主对角结构与S相同
sprandsym	创建非零元素为高斯分布的随机数的对称稀疏矩阵	R=sprandsym(n,density)	返回n*n的对称随机稀疏矩阵，其非零元素密度为density
spalloc	为稀疏矩阵分配空间	S=spalloc(m,n,nzmax)	相当于 sparse([],[],[],m,n,nzmax)

2.3.2.2 查看稀疏矩阵非零值信息的函数

函数名	函数功能	基本调用格式
nnz	返回非零值的个数	n=nnz(X)
nonzeros	返回非零值	s=nonzeros(A)
nzmax	返回用于存储非零值的空间长度	n=nzmax(S)

>> rng default % 设置种子数，方便复现
>> S=sprand(3,4,0.3) % 创建随机数的稀疏矩阵

S =

  3×4 稀疏 double 矩阵 (3 个非零值)

   (3,1)       0.9649
   (1,2)       0.9575
   (3,3)       0.1576

>> A=full(S) % 满矩阵存储

A =

         0    0.9575         0         0
         0         0         0         0
    0.9649         0    0.1576         0

>> B=nonzeros(A) % 返回非零值

B =

    0.9649
    0.9575
    0.1576

2.3.3 从外部文件导入稀疏矩阵

S=spconvert(D) % 根据D的列，按sparse函数的类似方式构造稀疏矩阵S

>> load uphill.dat
>> S=spconvert(uphill) % 转换为稀疏矩阵

S =

  4×4 稀疏 double 矩阵 (10 个非零值)

   (1,1)       1.0000
   (1,2)       0.5000
   (2,2)       0.3333
   (1,3)       0.3333
   (2,3)       0.2500
   (3,3)       0.2000
   (1,4)       0.2500
   (2,4)       0.2000
   (3,4)       0.1667
   (4,4)       0.1429

>> full(S) % 满矩阵存储

ans =

    1.0000    0.5000    0.3333    0.2500
         0    0.3333    0.2500    0.2000
         0         0    0.2000    0.1667
         0         0         0    0.1429

2.4 多维数组

2.4.1 多维数组属性

C=cat(dim,A,B) % 沿维度dim将B串联到A的末尾
C=cat(dim,A1,A2,…,An) % 沿维度dim串联A1、A2、…An

>> A=ones(3)

A =

     1     1     1
     1     1     1
     1     1     1

>> B=zeros(3)

B =

     0     0     0
     0     0     0
     0     0     0

>> C1=cat(1,A,B)

C1 =

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

>> C2=cat(2,A,B)

C2 =

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

>> C3=cat(3,A,B)

C3(:,:,1) =

     1     1     1
     1     1     1
     1     1     1


C3(:,:,2) =

     0     0     0
     0     0     0
     0     0     0

>> C4=cat(4,A,B)

C4(:,:,1,1) =

     1     1     1
     1     1     1
     1     1     1


C4(:,:,1,2) =

     0     0     0
     0     0     0
     0     0     0

数组属性	函数用法	函数功能
尺寸	size(A)	按照行-列-页的顺序，返回数组A每一维上的大小
维度	ndims(A)	返回数组A具有的维度值
内存占用/数据类型等	whos	返回当前工作区中的各个变量的详细信息

>> A=cat(4,[6 2 0; 4 5 9], [0 3 2; 9 4 2], [7 1 2; 4 8 4]) % 通过合并方式构建多维数组

A(:,:,1,1) =

     6     2     0
     4     5     9


A(:,:,1,2) =

     0     3     2
     9     4     2


A(:,:,1,3) =

     7     1     2
     4     8     4

>> size(A) % 获取数组A的尺寸属性

ans =

     2     3     1     3

>> ndims(A) % 获取数组A的维度属性

ans =

     4

>> whos
  Name      Size               Bytes  Class     Attributes

  A         2x3x1x3              144  double              
  ans       1x1                    8  double

2.4.2 多维数组操作

2.4.2.1 多维数组的索引

>> rng default % 设置种子数，方便复现
>> A=randn(3,5,2)

A(:,:,1) =

    0.5377    0.8622   -0.4336    2.7694    0.7254
    1.8339    0.3188    0.3426   -1.3499   -0.0631
   -2.2588   -1.3077    3.5784    3.0349    0.7147


A(:,:,2) =

   -0.2050    1.4090   -1.2075    0.4889   -0.3034
   -0.1241    1.4172    0.7172    1.0347    0.2939
    1.4897    0.6715    1.6302    0.7269   -0.7873

>> A(3,2,2) % 访问A的第3行第2列第2页的元素

ans =

    0.6715

>> A(21) % 访问A第21个元素（即第3行第2列第2页的元素）

ans =

    0.6715

2.4.2.2 多维数组的维度操作

B=reshape(A,sz1,…,szN) % 将A重构为一个sz1*…*szN数组，其中sz1、…、szN指定每个维度的大小
B=squeeze(A) % 返回一个数组，其元素与输入数组A相同，但删除了长度为1的维度，例如：若A是3*1*2数组，则squeeze(A)返回3*2矩阵

>> A1=ones(3,2,3); % 创建3*2*3的数组
>> B1=reshape(A1,3,6) % 重构数组

B1 =

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

>> B2=reshape(A1,2,[]) % 使用[]可以自动计算该维度的大小

B2 =

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

>> A2=zeros(3,1,3); % 创建3*1*3的数组
>> A2(:,:,1)=[1 2 3]';
>> A2(:,:,2)=[-2 -4 -6]';
>> B3=squeeze(A2) % 删除长度为1的维度，得到3*3的矩阵

B3 =

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

B=permute(A,dimorder) % 按照向量dimorder指定的顺序重新排列数组的维度，ipermute可以看作是permute的逆函数

>> rng default
>> A=rand(3,5,2) % 创建3*5*2的数组

A(:,:,1) =

    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


A(:,:,2) =

    0.1419    0.7922    0.0357    0.6787    0.3922
    0.4218    0.9595    0.8491    0.7577    0.6555
    0.9157    0.6557    0.9340    0.7431    0.1712

>> B=permute(A,[3 2 1]) % 交换第1个维度和第3个维度，得到2*5*3的数组

B(:,:,1) =

    0.8147    0.9134    0.2785    0.9649    0.9572
    0.1419    0.7922    0.0357    0.6787    0.3922


B(:,:,2) =

    0.9058    0.6324    0.5469    0.1576    0.4854
    0.4218    0.9595    0.8491    0.7577    0.6555


B(:,:,3) =

    0.1270    0.0975    0.9575    0.9706    0.8003
    0.9157    0.6557    0.9340    0.7431    0.1712

>> C=ipermute(B,[3 2 1])

C(:,:,1) =

    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


C(:,:,2) =

    0.1419    0.7922    0.0357    0.6787    0.3922
    0.4218    0.9595    0.8491    0.7577    0.6555
    0.9157    0.6557    0.9340    0.7431    0.1712

2.4.2.3 多维数组参与数学计算

>> A=randn(2,4,2)

A(:,:,1) =

   -0.1649    1.0933   -0.8637   -1.2141
    0.6277    1.1093    0.0774   -1.1135


A(:,:,2) =

   -0.0068   -0.7697   -0.2256   -1.0891
    1.5326    0.3714    1.1174    0.0326

>> B=sum(A)

B(:,:,1) =

    0.4628    2.2025   -0.7863   -2.3276


B(:,:,2) =

    1.5258   -0.3983    0.8918   -1.0565

>> C=sin(A)

C(:,:,1) =

   -0.1641    0.8881   -0.7602   -0.9371
    0.5873    0.8954    0.0773   -0.8972


C(:,:,2) =

   -0.0068   -0.6959   -0.2237   -0.8862
    0.9993    0.3629    0.8989    0.0326

>> D=eig(A(:,[1 2],1))

D =

   -0.5728
    1.5172

posted @ 2026-01-12 08:43 Zhuye_inking 阅读(6) 评论(0) 收藏举报

刷新页面返回顶部

inking

第2章 向量、矩阵与数组

第2章 向量、矩阵与数组

2.1 向量

2.1.1 常用常量

2.1.2 创建向量

2.1.2.1 直接输入法

2.1.2.2 冒号表达式法

2.1.2.3 函数法

2.1.3 向量运算

2.1.3.1 向量的算术运算

2.1.3.2 向量的点积和差积运算

2.2 矩阵

2.2.1 特殊矩阵函数

2.2.2 矩阵拓展与裁剪

2.2.2.1 矩阵合并函数

2.2.2.2 矩阵的拓展或裁剪

2.2.3 矩阵下标引用

2.2.3.1 全下标寻址

2.2.3.2 单下标寻址

2.2.3.3 引用方式转换

2.2.4 矩阵信息的获取

2.2.4.1 矩阵尺寸函数

2.2.4.2 矩阵元素的数据类型和结构信息

2.2.4.3 矩阵结构的改变

2.3 稀疏矩阵

2.3.1 满矩阵与稀疏矩阵的转换

2.3.2 基于对角线元素创建稀疏矩阵

2.3.2.1 特殊稀疏矩阵创建函数

2.3.2.2 查看稀疏矩阵非零值信息的函数

2.3.3 从外部文件导入稀疏矩阵

2.4 多维数组

2.4.1 多维数组属性

2.4.2 多维数组操作

2.4.2.1 多维数组的索引

2.4.2.2 多维数组的维度操作

2.4.2.3 多维数组参与数学计算

2.2.3 矩阵下标引用

2.2.3.1 全下标寻址

2.2.3.2 单下标寻址

2.2.3.3 引用方式转换

2.2.4 矩阵信息的获取

2.2.4.1 矩阵尺寸函数

2.2.4.2 矩阵元素的数据类型和结构信息

2.2.4.3 矩阵结构的改变

2.3 稀疏矩阵

2.3.1 满矩阵与稀疏矩阵的转换

2.3.2 基于对角线元素创建稀疏矩阵

2.3.2.1 特殊稀疏矩阵创建函数

2.3.2.2 查看稀疏矩阵非零值信息的函数

2.3.3 从外部文件导入稀疏矩阵

2.4 多维数组

2.4.1 多维数组属性

2.4.2 多维数组操作

2.4.2.1 多维数组的索引

2.4.2.2 多维数组的维度操作

2.4.2.3 多维数组参与数学计算

公告

第2章向量、矩阵与数组

第2章向量、矩阵与数组