matlab基础知识加矩阵运算初步

** matlab（matrix laboratory）**

功能符号

1.分号（;）

不让matlab显示运算结果，抑制输出

2.续行号(…)

某行命令太长,指令行必须多行书写时，使用“…"处理，表示下一行是上一行的连续

常用指令

1.cd

显示或改变工作目录

2.clc

清空命令行窗口

3.clear

清除所有变量

clear+变量名清除一个特定的变量

clear+ 变量名1 变量名2（用空格分隔名称）

4.其他命令

disp 显示变量或文字内容

radius=5;
area=pi*radius^2;
disp(["the area of the disc is " area]);
>>"the area of the disc is"    "78.5398"

radius = 5;
area=pi*radius^2;
disp(['the area of the disc is ' area]);
>>the area of the disc is N

radius = 5;
area=pi*radius^2;
disp(['the area of the disc is ' num2str(area)]);
>>the area of the disc is 78.5398

变量与常量

变量

1.以字母开头，之后可以包含字母，数字，下划线
2.namelengthmax 最大名称长度=63
3.区分大小写
4.保留词关键词不能用作变量名
5.内置函数的名称不能用作变量名
6.who显示了在命令行窗口定义的变量
7.whos显示了在命令行窗口定义的变量的更多信息

常量

i(j) 复数中的虚数单位，前面可以加任意实数
inf 向上取极限+∞
pi 圆周率
eps 浮点运算相对精度
NaN 代表“不是一个数字”

格式功能

format rat 使用分数来表示数值
format bank 控制小数点后2位
format short 控制小数点后4位
format long 控制小数点后15位

>>format short                       >>format long
>>pi                                 >>pians =                                ans =3.1416                                3.141592653589793

格式命令还可以用于控制matlab命令与表达式的间距，可以是松散的（默认）或紧凑的
‘>>format loose’

‘>>format compact’

内置函数功能

help elfun
将显示很长的列表，分为三角函数，指数函数，复函数，舍入和剩余函数
sin+弧度
sind+角度
fix：向0取整
floor:向-∞取整
ceil：向+∞取整
round：四舍五入
`round(pi,2)保留2位小数
abs：绝对值
rem：返回除法的余数

rem(13,5)
>>ans=3
fix(19.999)
>>ans=19

mod(5,0)=5
rem(5,0)=NaN
sign 符号函数
nthroot(x,n):返回x元素的n次方实根
deg2rad:角的单位从度转换为弧度
rad2deg:角的单位从弧度转换为角度
log( ) :以e为底数
log2( ):以2为底
exp(n):e的n次方
查看ceil功能
1>>help ceil
2.ce[光标]il+F1
3.搜索

随机数

rng重置
rng(seed)改变初始种子
seed为小于 2^32 的非负整数种子。
rng(seed)=rng([seed])
rng(‘default’) 恢复matlab启动时默认的全局随机流
rng(‘shuffle’)* 根据当前时间为随机数生成器提供种子
rand 0-1的均匀随机分布，包括0和1
rand(m,n)产生m行n列的矩阵

 R = rand(N)              % 生成N×N的矩阵随机数，其中每个元素位于0~1之间，故N必须为整数R = rand([M,N,P,...])    % 生成M×N×P×...的矩阵随机数R = rand(M,N,P,...)      % 同上，中括号不是必须R = rand(..., CLASSNAME) % 生成CLASSNAME类型的随机数，如 'double' or 'single'

rand的应用实例

>> rand
ans =0.7060
>> rand()
ans =0.0318
>> rand(1)
ans =0.2769
>> rand(2)
ans =0.0462    0.82350.0971    0.6948
>> rand([3,2,2])
ans(:,:,1) =0.3171    0.43870.9502    0.38160.0344    0.7655
ans(:,:,2) =0.7952    0.44560.1869    0.64630.4898    0.7094

randn 均值为0方差为1的正态分布
randn(m,n)产生m行n列的矩阵
randi
randi(N) 是生成(0,N]间均匀分布的伪随机数，并且数都是整数，所以括号中每个数是位于1到N之间
randi(n)不超过n的1个正整数
randi([1,12]) 在[1,12]直接产生一个正整数
randi(1,12)产生一个12行12列全为1的矩阵

R = randi(iMax)            % 生成1：iMax之间的均匀分布随机数
R = randi(iMax,m,n)        % 生成m×n的1：iMax之间的均匀分布随机数
R = randi([iMin,iMax],m,n) % 生成m×n的iMin:iMax之间的均匀分布随机数
R = randi([iMin,iMax],[m,n]) %  同上，中括号不是必须

用round生成m行n列随机整数矩阵
round(rand(m,n)* 10)
把0-10之间的小数四舍五入取整数得到0~10之间的整数，包括0和10
round(rand(m,n)* 10,n)
把0-10之间的小数四舍五入取n位小数得到0~10之间的整数

找以···开头的函数

randn(m,n)可以通过回溯command history
操作方式：
函数开头几个字母+↑(方向键上键)

Tab 自动补全

随机数生成器并不是真正随机，它的工作方式是从一个数字开始，这个数字通常被称为种子，通常初始种子是预定值，或者从计算机中内置时钟中获得，基于种子通过一个过程确定下一个随机数，下一次使用这个数字作为种子，生成另一个随机数，下一次使用这个数字作为种子，生成另一个随机数，以上过程称为伪随机

数值类型

single4字节，double8字节

数值范围

>>intmax('int16')               >> intmin('int16')ans=                              ans=                                  int16                             int1632767                             -32768%2^16/2-1                         %-2^16/2
>>intmax('uint8')                 >>intmin('uint8')ans=                               ans=                                uint8                             uint8255                               0
%2^8-1                         >>int8(200)                       >>int8(200)
ans=                              ans=                                int8                             int 8127                              -128
%saturation饱和
>>double('程序设计')ans=31243 24207 35574 35745
>>realmax('double')
ans =1.797693134862316e+308
>> double(3E308)                 >>double(-3E308)
ans =                             ans =Inf                            -Inf
%舍入误差的影响
%由于计算机中用有限位数的浮点数存储实数，导致存储值与真实值存在差异，这便是舍入误差。
>>abs((0.001+1E0-1E0)-0.001)
ans =1.101549407245273e-16
>>abs((0.001+1E0-1E0)-0.001)<1E-13
ans=logical1

逻辑运算符

&&或&或and 逻辑与
| 或||或or 逻辑或
~或not 逻辑非
xor 逻辑异或，有且只有1个正确返回1
any 有非零元素即为1
all 所有元素均非零则为1

>> vec=[5 9 3 4 6 11]
vec =5     9     3     4     6    11
>> v=[0 1 0 0 1 1]
v =0     1     0     0     1     1
>> v=logical([0 1 0 0 1 1])
v =1×6 logical 数组0   1   0   0   1   1
>> vec(v)
ans =9     6    11
>> any(v)
ans =logical1
>> all(v)
ans =logical0>> xor('c'=='d'-1,2<4)ans =logical0

运算优先级

创建行向量

1.直接输入法

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

2.冒号法

本实例创建一个从3开始，增量为1，到9结束的行向量v

>> v=[3:1:9]
v =3     4     5     6     7     8     9

当中间的增量省略时，默认增量为1

>> v=(1.5:8.7)                                      %也可以不加括号
v =1.5000    2.5000    3.5000    4.5000    5.5000    6.5000    7.5000    8.5000 >> v=(1.5:8.7)
v =1.5000    2.5000    3.5000    4.5000    5.5000    6.5000    7.5000    8.5000

3.利用函数linspace()创建向量

lincpace(first_value,last_value,number)
该调用格式表示创建一个从first_value开始，到last_value结束,包含number个元素的向量

>> linspace(3,9,7)
ans =3     4     5     6     7     8     9

4.利用函数logspace()创建一个对数分隔的向量

logspace(first_value,last_value,number)
![[Pasted image 20230110115606.png]]

>>x=logspace(1,3,3)
x=10    100     1000

5.拼接行向量

>> v=(3:9)
v =3     4     5     6     7     8     9
>> u=0.1:0.2:0.9
u =0.1000    0.3000    0.5000    0.7000    0.9000
>> [u,v]
ans =0.1000    0.3000    0.5000    0.7000    0.9000    3.0000    4.0000    5.0000    6.0000    7.0000    8.0000    9.0000

工作区u右键打开所选内容

6.添加一个元素

>> v=3:9
v =3     4     5     6     7     8     9
>> v(10)=12
v =3     4     5     6     7     8     9     0     0    12

7.替换一个元素

>> v=3:9
v =3     4     5     6     7     8     9
>> v(2)=15
v =3    15     5     6     7     8     9

8.查找一个元素

>> v=(3:9)
v =3     4     5     6     7     8     9
>> v(3)
ans =5
>> v([3,5])
ans =5     7
>> v([3:5])
ans =5     6     7
>> v(end)
ans =9

9.向量转置

>> v=(3:9)'
v =3456789

创建列向量

>> [3;7;4]
ans =374

矩阵转置

>> [3,7,4]'
ans =374            %是共轭转置

共轭转置(')

>> [1+3i,2-7i,5+4i]'
ans =1.0000 - 3.0000i2.0000 + 7.0000i5.0000 - 4.0000i

转置(.')

>> [1+3i,2-7i,5+4i].'
ans =1.0000 + 3.0000i2.0000 - 7.0000i5.0000 + 4.0000i

创建矩阵

>> mat=[4,3,1;2,5,6]
mat =4     3     12     5     6
>> lab=[2:4;3:5]
lab =2     3     43     4     5

创建特殊矩阵

zeros(n):创建n×n全0矩阵
zeros(m,n):创建m×n全0矩阵
ones(n):创建n×n全1矩阵
ones(m,n):创建m×n全1矩阵
eye(n):创建n×n单位矩阵
eye(m,n):创建m×n的单位矩阵
单位矩阵：主对角线元素为1，其余元素为0的矩阵
hilb(n):创建n×n的希尔伯特矩阵
magic(n)生成n阶魔方矩阵
魔方矩阵：是有相同的行数和列数，并在每行每列、对角线上的和都相等的矩阵
pascal矩阵：

>> format rat
>> hilb(5)
ans =1              1/2            1/3            1/4            1/5     1/2            1/3            1/4            1/5            1/6     1/3            1/4            1/5            1/6            1/7     1/4            1/5            1/6            1/7            1/8     1/5            1/6            1/7            1/8            1/9

矩阵的抽取

diag(v):创建以向量v中的元素为对角的对角阵
对角阵：只有对角线上有非0元素的矩阵称为对角矩阵

>> v=3:9
v =3     4     5     6     7     8     9
>> diag(v)
ans =3     0     0     0     0     0     00     4     0     0     0     0     00     0     5     0     0     0     00     0     0     6     0     0     00     0     0     0     7     0     00     0     0     0     0     8     00     0     0     0     0     0     9

diag(v,k)得到矩阵 v 对角线上移k行的元素组成的列向量，diag(v,-k)得到矩阵 v 对角线下移k行的元素组成的列向量。

v=[1 2 3];
diag(v, -1)
ans =0 0 0 01 0 0 00 2 0 00 0 3 0>> diag(-1:-1:-6,-1)+diag(v)
ans =3     0     0     0     0     0     0-1     4     0     0     0     0     00    -2     5     0     0     0     00     0    -3     6     0     0     00     0     0    -4     7     0     00     0     0     0    -5     8     00     0     0     0     0    -6     9

diag(X):抽取主对角线
diag(X,k):抽取矩阵X的第k条对角线上的元素向量。k为0时抽主对角线,k为正整数时抽取上方第k条对角线上的元素，k为负整数时抽取下方第k条对角线上的元素

>> X=randi([1,9],[5,5])
X =8     1     2     2     69     3     9     4     12     5     9     9     89     9     5     8     96     9     8     9     7
>> diag(X,-1)
ans =9559

tril(X):提取矩阵X的主下三角部分
tril(X,k):提取矩阵第k条对角线下面的部分(包括第k条对角线)
triu(X):提取矩阵X的主上三角部分
triu(X,k):提取矩阵第k条对角线上面的部分(包括第k条对角线)

>> tril(X,-1)
ans =0     0     0     0     09     0     0     0     02     5     0     0     09     9     5     0     06     9     8     9     0

访问矩阵

>> M=[9,6,3;5,7,2]
M =9     6     35     7     2
>> M(2,3)
ans =2
>> M(2,[1,3])
ans =5     2
>> M(1,1:3)
ans =9     6     3
>> M(1,:)                    %表示第一行
ans =9     6     3
>> M(:,2)                    %表示第二列
ans =67
>> M(:,end)                 %表示最后一列
ans =32

矩阵的变维

reshape是对矩阵的元素重新排列的方法

>> M=randi([1,9],[3,4])
M =9     6     3     88     6     5     25     2     3     3
>> reshape(M,2,6)
ans =9     5     6     3     3     28     6     2     5     8     3M=randi([1,9],[3,4])
M =9     6     3     88     6     5     25     2     3     3
>> reshape(M,2,6)
ans =9     5     6     3     3     28     6     2     5     8     3
>> M(2)                               %查找元素
ans =8
>> M([6 2 5 4])
ans =
2     8     6     6

>> A=1:12
A =1     2     3     4     5     6     7     8     9    10    11    12
>> C=zeros(3,4);
>> C(:)=A(:)
C =1     4     7    102     5     8    113     6     9    12

修改矩阵元素

扩充矩阵

>> M=[9,6,3;5,7,2]
M =9     6     35     7     2
>> N=[M;10 11 12]
N =9     6     35     7     210    11    12
>> M=[9,6,3;5,7,2]
M =9     6     35     7     2
>> M(1:2,1:2)=[7,8;9,10]    %1~2行和1~2列的交集子矩阵%1~2行%1~2列
M =7     8     39    10     2
>> M(1:2,1:2)=[7,8,9,10]
无法执行赋值，因为左侧的大小为 2-by-2，右侧的大小为 1-by-4。
**更改一个矩阵的二维子集左右两边形状要相同**
>> M=[9,6,3,1;5,7,2,8;3,2,1,9]
M =9     6     3     15     7     2     83     2     1     9
>> M(1:2,1:3)=[7,8,9;10,4,5]
M =7     8     9     110     4     5     83     2     1     9
>> M(1,:)=0.5
M =0.5000    0.5000    0.5000    0.500010.0000    4.0000    5.0000    8.00003.0000    2.0000    1.0000    9.0000
>> M(1:2,1:2)=Inf
M =Inf       Inf    0.5000    0.5000Inf       Inf    5.0000    8.00003.0000    2.0000    1.0000    9.0000>> M(end-1,:)
ans =Inf   Inf     5     8

矩阵的变向

fliplr(X):将X左右翻转
flipud(X):将X上下翻转
flip(X):同上，将X上下翻转，以及将一个行向量左右翻转，列向量上下翻转

>> X=randi([1,9],[3,4])
X =3     4     8     59     4     2     61     7     5     7
>> flipud(X)
ans =1     7     5     79     4     2     63     4     8     5
>> flip(X)
ans =1     7     5     79     4     2     63     4     8     5

rot90(X):将X逆时针方向旋转90°

>> X=randi([1,9],[3,4])
X =7     6     5     63     2     9     37     2     4     7
>> rot90(X)
ans =6     3     75     9     46     2     27     3     7

向量和矩阵的常用函数

1.length(M):返回M矩阵行数和列数的较大值
2.size(M):返回M矩阵的行数和列数
3.numel(M):返回M矩阵中元素的个数

>> length(M)
ans =3
>> size(M)
ans =2     3
>> [n_row,n_col]=size(M)
n_row =2
n_col =3
>> numel(M)
ans =6

3.repmat()

创建一个矩阵，并将原矩阵(或元素或字符串)复制到新矩阵块中

使用相同的元素值初始化矩阵

创建一个所有元素的值均为 10 的 3×2 矩阵。
A = repmat(10,3,2)

A =10    1010    1010    10

垂直行向量堆栈

垂直堆叠行向量四次。

>>A = 1:4;
>>B = repmat(A,4,1)
B = 4×41     2     3     41     2     3     41     2     3     41     2     3     4

包含列向量的水平堆栈

A = (1:3)';
B = repmat(A,1,4)
B =1     1     1     12     2     2     23     3     3     3

方块格式

>> A=[1 2;3 4]
A =1     23     4
>> B=repmat(A,2)
B =1     2     1     23     4     3     41     2     1     23     4     3     4

矩形块格式

>> repmat(A,2,3)
ans =1     2     1     2     1     23     4     3     4     3     41     2     1     2     1     23     4     3     4     3     4

三维块数组

B = repmat(A,[2 3 2])

B =
B(:,:,1) =1     2     1     2     1     23     4     3     4     3     41     2     1     2     1     23     4     3     4     3     4B(:,:,2) =1     2     1     2     1     23     4     3     4     3     41     2     1     2     1     23     4     3     4     3     4

4.repelem()函数

创建一个矩阵，将每个元素复制到一个新矩阵块中
repelem作为两输入函数使用，第二个参数如果是一个数值，第一个参数要么是单个数值，要么是向量，不能是矩阵，第二个参数也为向量时，两个向量必须等长

>>repelem(3,5)
ans=3 3 3 3 3
>> repelem([1,2,3],3)
ans =1     1     1     2     2     2     3     3     3
>> repelem([1;2;3],3)
ans =111222333
>> repelem([1,2,3],[3,2,1])
ans =1     1     1     2     2     3

当repelem接受两个以上参数时，第一个参数为高维数组，后面有维数个参量，分别控制每一维度的重复。

如图，repelem([1,2;3,4],3,2)是将矩阵[1,2;3,4]沿着第一维重复3次，沿着第二维重复2次。

>>  A=[1 2;3 4]
A =1     23     4
>> B=repelem(A,3,2)
B =1     1     2     21     1     2     21     1     2     23     3     4     43     3     4     43     3     4     4

当然，每一维度的对应参数可以是和那一维度长度相等的向量。如图，沿着第一维重复4个,2个,沿着第二维重复3个,1个

>> repelem([1,2;3,4],[4,2],[3,1])
ans =1     1     1     21     1     1     21     1     1     21     1     1     23     3     3     43     3     3     4A = [1 2; 3 4]
A = 2×21     23     4B = repelem(A,1,[2 3])
B = 2×51     1     2     2     23     3     4     4     4

三维数组

M=randi([1,9],[3,4])M =9     7     1     83     4     1     97     6     5     2>> T(:,:,1)=MT =9     7     1     83     4     1     97     6     5     2>> T(:,:,2)=randi([1,9],[3,4])T(:,:,1) =9     7     1     83     4     1     97     6     5     2T(:,:,2) =6     4     3     65     2     5     31     8     2     6>> T(:,:,3)=randi([1,9],[3,4])T(:,:,1) =9     7     1     83     4     1     97     6     5     2T(:,:,2) =6     4     3     65     2     5     31     8     2     6T(:,:,3) =7     1     2     97     3     8     15     9     5     4>> T(:,:,4)=randi([1,9],[3,4])T(:,:,1) =9     7     1     83     4     1     97     6     5     2T(:,:,2) =6     4     3     65     2     5     31     8     2     6T(:,:,3) =7     1     2     97     3     8     15     9     5     4T(:,:,4) =1     7     1     89     8     4     41     8     3     9>> T(:,:,5)=randi([1,9],[3,4])T(:,:,1) =9     7     1     83     4     1     97     6     5     2T(:,:,2) =6     4     3     65     2     5     31     8     2     6T(:,:,3) =7     1     2     97     3     8     15     9     5     4T(:,:,4) =1     7     1     89     8     4     41     8     3     9T(:,:,5) =2     2     5     63     8     2     42     6     8     5>> size(T)ans =3     4     5>> whosName      Size             Bytes  Class     AttributesA         2x2                 32  double              E         0x0                  0  double              M         3x4                 96  double              T         3x4x5              480  double              ans       1x3                 24  double   >> numel(T)ans =60

数组中的常用其他函数

函数在向量中的应用

>> a=[-3,-3,2,9,0]
a =-3    -3     2     9     0
>> max(a)
ans =9
>> min(a)
ans =-3
>> sum(a)
ans =5
>> prod(a)
ans =0
>> cumsum(a)
ans =-3    -6    -4     5     5
>> cummin(a)
ans =-3    -3    -3    -3    -3
>> cummax(a)
ans =-3    -3     2     9     9
>> cumprod(a)
ans =-3     9    18   162     0

函数在矩阵中的应用

>> M=randi([1,9],[3,4])
M =6     4     1     71     8     2     63     1     6     5
>> min(M)        %返回每一列的最小值
ans =1     1     1     5
>> max(M)        %返回每一列的最大值
ans =6     8     6     7
>> sum(M)        %返回每一列各个数的和
ans =10    13     9    18
>> prod(M)       %返回每一列各个数的乘积
ans =18    32    12   210
>> cummin(M)     %返回每一列第一个元素最小值，前两个元素最小值，前三个
ans =                %元素最小值6     4     1     71     4     1     61     1     1     5
>> cummax(M)      %返回每一列第一个元素最大值，前两个元素最大值，前三个
ans =                %元素最大值6     4     1     76     8     2     76     8     6     7
>> cumsum(M)       %返回每一列第一个元素，第一个和第二个元素的和，前三个元素的和
ans =6     4     1     77    12     3    1310    13     9    18
>> cumprod(M)     %返回每一列第一个元素，第一个第一个和第二个元素的乘积，前三个元素的乘积
ans =6     4     1     76    32     2    4218    32    12   210

matlab中cumsum函数的使用

A =1     2     34     5     67     8     9
>>B=cumsum(A)
B =                                                                      1     2     35     7     9                12    15    18

A =1     2     3  4     5     6  7     8     9
>> B=cumsum(A,1)
B =1     2     35     7     912    15    18
>> B=cumsum(A,2)
B =1     3     64     9    157    15    24

diff()函数：求差距

>> diff([1 4 7 8 3])
ans =3     3     1    -5

logical数组索引

>> w=[5 9 3 4 6 11]
w =5     9     3     4     6    11
>> v=[0 1 0 0 1 1]
v =0     1     0     0     1     1
>> w(v)
数组索引必须为正整数或逻辑值。
>> v=logical([0 1 0 0 1 1])
v =1×6 logical 数组0   1   0   0   1   1
>> w(v)
ans =9     6    11

find():返回逻辑真元素的位置

>> d=[0 1 0 0 1]
d =0              1              0              0              1
>> find(d)
ans =2              5
>> find(d,1,'first')
ans =2
>> find(d,2,'first')
ans =2              5
>>vec=[11 -5 33 2 8 -4 25]   %寻找大于0的元素的方法
vec =11          -5           33           2           8          -4          25
>> vec=vec(find(vec>0))
vec =11             33              2              8             25
>> vec(vec>0)
ans =11             33              2              8             25
%下面寻找0和1之间发生变化多少次
>> v=randi([0,1],[1,100]);
>> sum(diff(v)==1)     %0->1
ans =23
>> sum(diff(v)==-1)   %1->0
ans =23
%下面寻找发生1->2的变化多少次，提供两种方法
①
>> U=randi([0,2],[1,1000]);
>> U(1:10)
ans =1     2     0     2     0     1     1     0     2     1
>> U2=U;
>> U2(U2==0)=NaN;
>> U2(1:10)
ans =1     2   NaN     2   NaN     1     1   NaN     2     1
>> sum(diff(U2)==1)
ans =122
②
>> U3=U(1:10)
U3 =1     2     0     2     0     1     1     0     2     1
>> V1=U(1:end-1);
>> V2=U(2:end);
>> sum(V1==1&V2==2)
ans =122
>> M=randi([1,9],[4,4])
M =5     1     5     78     5     3     91     7     6     18     6     9     5
>> [I J] = find(M == 1)%或者[I,J]=ind2sub(size(M),find(M==1))
>> I =313
J =124

isequal(v1,v2···vn) 判断矩阵是否完全相同
不仅对应数字要相等，维度也要一致

矩阵运算

M1* M2 两矩阵相乘

M0= 4  8  8  39  3  6  31  9  8  66  7  3  8
M0*M0=M0^2
ans=114  149  153  10887  156  147   96129  149  144  126138  152  138  121
>>M0.^2
ans=16   64   64    981    9   36    91   81   64    3636   49    9    64

两向量相乘

>> v1=randi([1 9],[1 3])
v1 =2     3     1
>> v2=randi([1 9],[1 3])
v2 =7     1     6
>> v1.*v2
ans =14     3     6
>> sum(v1.*v2)
ans =23
v1*v2'
>>ans =23