笔记 matlab 矩阵运算03

AEmmmm.

已于 2024-08-02 01:04:18 修改

阅读量926

点赞数 14

文章标签：笔记 matlab 算法

于 2024-08-01 21:43:13 首次发布

本文链接：https://blog.csdn.net/AXZHJC/article/details/140556419

版权

内容均来自《MATLAB教程新手入门篇（数学建模清风主讲，适合零基础同学观看）》MATLAB教程新手入门篇（上部分）（数学建模清风主讲，适合零基础同学观看）_哔哩哔哩_bilibili

矩阵运算

1.常见函数

sum 求和函数
- sum（A） A是一个向量时，可以计算A向量中所有元素的和。
- sum(A,dim) A是一个矩阵，可以计算A沿不同维度dim时所有元素的和。
  - sum(A,1) 可以简写为sum(A),沿着行方向，即计算每一列的和。
  - sum(A,2) 沿着列方向，即计算每一行的和。

%A是向量
A=1:100;
sum(A)  %1~100累加，5050

%A是矩阵
A = randi(10,3,4)
A = 3×4    
%     3     9     4     7
%     9     3     2     5
%     3    10     3     4

sum(A,1)  % 计算每一列的和，返回行向量；等价于sum(A)，dim=1时可以不写  
%    15    22     9    16

sum(A,2)  % 计算每一行的和，返回列向量
ans = 3×1    
%   23
%   19
%   20

计算一个矩阵中所有元素的总和：
- sum(sum(A)) 计算每一列的和，返回一个行向量，然后再计算这个行向量的和
- sum(A(:)) 把A按照线性索引拼接成一个向量，然后再求和
- sum(A,'all') matlab2018b后可以用
- 新用法：sum(a, [1, 2]) 对数组 a 进行多维求和，会沿着数组 a 的第1维和第2维进行求和，而保留第3维不变。
```
a = randi(10,3,4)
% a = 3×4    
%     5     6     7     5
%     9     7     4     2
%     3     1     1     2

sum(a,"all")  % 双引号表示字符串
sum(a,'all')  % 单引号表示字符向量
sum(a,[1,2])
sum(sum(a))
sum(a(:))
% 结果都是 52
```
默认情况下，求和时含有NaN，那么最终会返回NaN；
可以在最后加一个输入参数 'omitnan', 这样计算时就会忽略NaN。
- sum(A, 'omitnan') A可以为向量和矩阵。
- sum(A, 2, 'omitnan') A可以为向量和矩阵
prod 求乘积函数

用法与sum函数类似

% A是向量
v = [2,4,5,1,10];  
prod(v)  % 向量中所有元素的乘积 
% 400

v = 1:10; 
prod(v)  % 计算10的阶乘，可以直接写成 prod(1:10)
% 3628800

% A是矩阵
A = randi(10,3,4)  
%    8     6     4     4
%   10     5     2     6
%    2     1     8     2

prod(A) % 计算每列的乘积，也可以写成 prod(A,1)  
%  160    30    64    48
prod(A,2)  % 计算每行的乘积  
%  768
%  600
%   32


v = [2,4,NaN,1,10];  % 有NaN值
A = [5 3 -8   4
1 5 NaN 10; 
3 6 18  9];  % 矩阵中存在NaN值

prod(v)  
% NAN
prod(A)  % 计算每一列的乘积
% 15 90 -144 360

% 如果计算时忽略NaN值，可以在最后面加上'omitnan'参数
prod(v, 'omitnan')
% 80
prod(A, 'omitnan')
% 15 90 -144 360
prod(A, 2, 'omitnan')
 %      -480
 %        50
 %      2916

cumcum 计算累积和

用法与sum类似

A = [1 5 3 4 -5 0 8];
cumsum(A)    %计算向量A的累加值
% 1 6 9 13 8 8 16

A = randi(10,3,4)  
%    9     2     4     2
%    2     3    10    10
%    3     5     5    10

cumsum(A)  % 或者写成cumsum(A,1)，计算每一列的累积和    
%    9     2     4     2
%   11     5    14    12
%   14    10    19    22

cumsum(A,2)  % 计算每一行的累积和 
%    9    11    15    17
%    2     5    15    25
%    3     8    13    23


A = [5 3 -8   4
1 5 NaN 10; 
3 6 18  9];
cumsum(A)  % 计算每一列的累积和
%    5     3    -8     4
%    6     8   NaN    14
%    9    14   NaN    23

cumsum(A,'omitnan')    % 忽略NaN值计算每一列的累积和 
%    5     3    -8     4
%    6     8    -8    14
%    9    14    10    23

cumsum(A, 2)  % 计算每一行的累积和  
%     5     8     0     4
%    1     6   NaN   NaN
%    3     9    27    36

cumsum(A, 2, 'omitnan')    % 忽略NaN值计算每一行的累积和  
%    5     8     0     4
%    1     6     6    16
%    3     9    27    36

diff 计算差分
- diff(A,n) A是向量时，表示A的n阶差分，当n等于1时，可以直接写成diff(A)。

w = [60 65 66 70 68 72 64 70];
diff(w)  % 1阶差分, diff(w,1)
%5 1 4 -2 4 -8 6
diff(w,2)  % 2阶差分
%-4 3 -6 6 -12 14
diff(w,3)  % 3阶差分
%7 -9 12 -18 26

diff(A,n,dim) A是矩阵时，表示沿A的维度dim方向上计算差分
- 当dim=1时，沿着行方向计算，即得到每列的n阶差分；diff(A,n,1)也可以简写成diff(A,n)。
- 当dim=2时沿着列方向计算，即得到每行的n阶差分。

diff函数不支持使用'omitnan'参数来忽略向量或者矩阵中的NaN值。

diff(w, 'omitnan') 错误使用 diff 差分阶数 N 必须为正整数标量。
diff(w, 1, 'omitnan') 错误使用 diff 差分阶数 N 必须为正整数标量。

diff(w, 1, 2,'omitnan') 错误使用 diff 差分阶数 N 必须为正整数标量。

A = randi(10,3,4)
%     2     6     4     1
%   10     1     9     2
5   10     3     1     7

% 计算每列的1阶差分
diff(A)  % 也可写成diff(A,1)或diff(A,1,1)   
%    8    -5     5     1
%    0     2    -8     5

% 计算每列的2阶差分
diff(A,2) % 也可写成diff(A,2,1)    
%   -8     7   -13     4

% 计算每行的1阶差分
diff(A,1,2)    
%    4    -2    -3
%   -9     8    -7
%   -7    -2     6

% 计算每行的2阶差分
diff(A,2,2)
%    -6    -1
%   17   -15
%    5     8

w = [60 65 NaN 70 68 72 64 70];
diff(w)    
%    5   NaN   NaN    -2     4    -8     6
diff(w, 'omitnan')   %错误使用 diff  差分阶数 N 必须为正整数标量。
diff(w, 1, 'omitnan') %错误使用 diff  差分阶数 N 必须为正整数标量。
diff(w, 1, 2,'omitnan') %错误使用 diff  差分阶数 N 必须为正整数标量。

mean 计算平均值

用法与sum类似

y = [1 3 5 7 9];
mean(y)    % A是向量，则mean(A)可以计算向量A的平均值。
% 5
    
%A是矩阵，则mean(A,dim)可以计算A沿维度dim中所有元素的平均值。
A = randi(10,3,4)
%     8     6     2     4
%    7     3     7     7
%    5     8     2     8

mean(A)    %可以写成mean(A,1) ，当dim=1时沿着行方向计算，即得到每列的平均值；
%   6.6667    5.6667    3.6667    6.3333

mean(A,2)    %当dim=2时沿着列方向计算，即得到每行的平均值。   
%   5.0000
%   6.0000
%   5.7500


A = [5 3 -8   4
1 5 NaN 10; 
3 6 18  9];    %也可以在最后加一个输入参数: 'omitnan', 这样计算时会忽略NaN。
mean(A)
%   3.0000    4.6667       NaN    7.6667

mean(A,'omitnan')   % 也可以写成mean(A,1,'omitnan')，忽略NaN值计算每一列的平均值 %    3.0000    4.6667    5.0000    7.6667

mean(A,2)
%    1
%  NaN
%    9

mean(A, 2, 'omitnan')    % 忽略NaN值计算每一行的平均值
%   1.0000
%   5.3333
%   9.0000

median 计算中位数

用法与mean类似

y = [6 80 1 5 100 20 1000];
median(y)    %计算向量y的中位数
% 20

A = [5 3 -8   4
1 5 NaN 10; 
3 6 18  9];
median(A)  % 计算每一列的中位数
% 3  5  NaN  9

% 忽略NaN计算每一列的中位数
median(A,'omitnan')    % 也可以写成median(A,1,'omitnan')，忽略NaN计算每一列的中位数
%   3     5     5     9

median(A, 2, 'omitnan')    % 忽略NaN计算每一行的中位数    
%   3.5000
%   5.0000
%   7.5000

median(A(:), 'omitnan')  % 整个矩阵的中位数
% 5

mode 计算众数

众数是指一组数据中出现次数最多的数。一组数据可以有多个众数。
计算向量A的众数，直接调用mode(A)会返回A中出现次数最多的值。
- 如果有多个值以相同的次数出现，mode函数将返回其中最小的值。
A是一个矩阵
- mode(A,1)或者mode(A)可以沿着行方向进行计算，得到每一列的众数；
- mode(A,2)可以沿着列方向进行计算，得到每一行的众数，这里的1和2表示维度dim。
使用mode函数计算众数时会自动忽略NaN值，我们不能额外添加'omitnan'参数，否则会报错

A = [2 3 -1 2 1 3];
mode(A)  % 2

A = randi(5,6,8)；
% 2 1 3 4 5 4 4 1
% 3 5 5 4 5 1 4 1
% 3 4 3 2 4 4 5 4
% 1 3 3 2 1 1 5 3
% 2 3 2 5 2 4 2 3
% 5 2 3 1 2 3 4 5

mode(A)  
% 2 3 3 2 2 4 4 1

mode(A,2)
% 4 
% 5
% 4
% 1
% 2 
% 2

%使用mode函数计算众数时会自动忽略NaN值，我们不能额外添加'omitnan'参数，否则会报错。
A = [2 3 -1 NaN 1 NaN NaN 3];
mode(A) % 3
mode(A, 'omitnan') 
% 错误使用 mode
% 维度参数必须为正整数标量、由唯一正整数组成的向量或 'all'。

mode函数可以有多个返回值

[M,F] = mode(A)，A是向量时，M表示向量A的众数，F表示众数M在向量A中出现的次数。

[M,F,C] = mode(A),M表示向量A的众数，F表示众数M在向量A中出现的次数，C是一个元胞数组，元胞数组里面有一个列向量，列向量中的每个元素都是向量A的众数。

A = [-1 2 0 8 -1 0 2 1 8 0 8];
[M, F] =mode(A)
% M=0
% F=3

A = [-1 2 0 8 -1 0 2 1 8 0 8];
[M, F, C] =mode(A)
% M=0
% F=3
% C = 
%   {2×1 double}

C{1}
% 0
% 8

A =  [3 3 1 4; 
     0 0 1 1;
     0 1 6 4;
     1 5 6 8];
[M, F, C] = mode(A) % 计算每一列的众数
% M = 1×4    第k列的众数
%    0     0     1     4
% F = 1×4    M中的各个众数在其所在列中出现的次数
%    2     1     2     2
% C=1X4cell    第k列的所有众数
%     1    2               3        4
%     0    [0;1;3;5]       [1;6]    4

C{1}
% 0
C{2}
% 0
% 1
% 3
% 5
C{2}
% 1
% 6
C{4}
% 4

[M, F, C] = mode(A, 2)    % 计算每一行的众数   
%    M=3
%      0
%      0
%      1    
%    F=2
%      2
%      1
%      1
%    C=4x1cell
%     1    3
%     2    [0;1]
%     3    [0;1;4;6]
%     4    [1;5;6;8]

C{1}
% 3
C{2}
% 0
% 1
C{3}
% 0
% 1
% 4
% 6
C{4}
% 1
% 5
% 6
% 8

var 计算方差
- A是向量，var(A,w)，计算A的方差
  - w=0时，计算样本的方差（n-1）；var(A,0)可以直接简写为var(A)
  - w=1时，计算总体方差（n）
- A是矩阵，var(A,w,dim),计算矩阵A沿维度dim上的方差
  - dim = 1时表示沿着行方向进行计算，即得到每一列的方差；
  - dim = 2时表示沿着列方向进行计算，即得到每一行的方差。
    - var(A, w, 1)可以简写为var(A,w)；若w为0，则可以进一步简写为var(A)。

如果数据中存在NaN值，可以在var函数的最后加上'omitnan'参数来忽略NaN。

v = [6 8 10 12 14];  
var(v)  % 样本方差，等价于var(v,0)
% 10

var(v,1)  % 总体方差
% 8


A = randi(10,4,5)
%A = 4×5    
%    5    10     6     2     6
%    6     4     7    10     9
%   10     8     7     2     7
%    5     7     2     1     2

var(A)  % 每一列的样本方差  等价于var(A,0),var(A,0,1)
%    5.6667    6.2500    5.6667   17.5833    8.6667
var(A,0,2)  % 每一行的样本方差
%ans = 4×1    
%      8.2000
%      5.7000
%      8.7000
%      6.3000

A = [9  7    10  10  NaN;
10  NaN 10  5   10;
2   3    2   9   8;
10  6   10    2  10];  
% 矩阵中存在NaN值
var(A, 0, 2)  % 计算每一行的样本方差
%ans = 4×1    
%      NaN
%      NaN
%  11.7000
%  12.8000
% 忽略NaN值计算每一行的样本方差
var(A, 0, 2, 'omitnan')  
%ans = 4×1    
%   2.0000
%   6.2500
%  11.7000
%  12.8000

std 计算标准差

用法与var相同

v = [6 8 10 12 14];  
std(v)  % 样本标准差，等价于std(v,0)
% 3.1623
std(v,1)  % 总体标准差
% 2.8284


% 下面看矩阵的例子
A = randi(10,4,5)
%A = 4×5    
%    9     7    10    10     5
%   10     1    10     5    10
%    2     3     2     9     8
%   10     6    10     2    10

std(A)  % 每一列的样本标准差，等价于std(A,0),std(A,0,1)
%ans = 1×5    
%  3.8622   2.7538    4.0000    3.6968    2.3629
std(A,0,2)  % 每一行的样本标准差
%ans = 4×1    
%   2.1679
%   4.0866
%   3.4205
%   3.5777


A = [9  7    10  10  NaN;
10  NaN 10  5   10;
2   3    2   9   8;
10  6   10    2  10];  
% 矩阵中存在NaN值
std(A, 0, 2)  % 计算每一行的样本标准差
%ans = 4×1    
%      NaN
%      NaN
%   3.4205
%   3.5777

% 忽略NaN值计算每一行的样本标准差
std(A, 0, 2, 'omitnan') 
%ans = 4×1    
%   1.4142
%   2.5000
%   3.4205
%   3.5777

min/max 求最小值/最大值

以min函数为例，max函数用法相同

1.求两个矩阵对应位置元素的最小值: min(A,B)

矩阵A和矩阵B的大小可以不一样，只要保证矩阵A和矩阵B具有兼容的大小就能够计算

A = randi(10,4,3)
%A = 4×3    
%     7    10     3
%     2     3     1
%     8     8     6
%     3     2     7

B = randi(10,4,3)
%B = 4×3    
%     6     7     8
%     5     7     3
%     7    10     2
%     7     3     7

min(A,B)
%ans = 4×3    
%     6     7     3
%     2     3     1
%     7     8     2
%     3     2     7

A = randi(10,4,3)
%A = 4×3    
%     5     4     9
%     5     7     3
%     7     5     7
%     8     9     6

B = 5;  % 例如B可以是一个标量（常数）
min(A,B)
%ans = 4×3    
%     5     4     5
%     5     5     3
%     5     5     5
%     5     5     5

B = [4 5 6];
min(A,B)
%ans = 4×3    
%     4     4     6
%     4     5     3
%     4     5     6
%     4     5     6

2.求向量或者矩阵中的最小值，可以指定沿什么维度计算并返回索引

（1）如果A是向量，则min(A)返回A中的最小值。如果A中有复数，则比较的是复数的模长。

（2）如果A是矩阵，这里的1和2表示矩阵的维度（dim）。

min(A, [ ], 1)沿着A的行方向求每一列的最小值，也可以简写为min(A)；
min(A, [ ], 2)沿着A的列方向求每一行的最小值。

若不加空向量[ ] ，就是将A中每个元素和1或者2比较大小，并返回较小值。

A = [5 6 7 3 5 3 10];
min(A)
% 3
B = [4.5  3+4i  6];
min(B) 
% 4.5000

A = randi(10,3,4)
%A = 3×4    
%     6     4     7     6
%     9     2     5     7
%     3    10     7     6
min(A,[ ],1)  % 求每一列的最小值，可以简写成min(A)
%ans = 1×4    
%     3     2     5     6

min(A,[ ],2)  % 求每一行的最小值
%ans = 3×1    
%     4
%     2
%     3

min(A, 2)
%ans = 3×4    
%     2     2     2     2
%     2     2     2     2
%     2     2     2     2

3.两个返回值 [m, ind] = min(A).

第一个返回值m是我们要求的最小值
ind是最小值在所在维度上的索引

如果最小元素出现多次，则 ind是最小值第一次出现位置的索引。


%A是向量
A = [5 6 7 3 5 3 10];
[min_A , ind] = min(A)
% min_A=3
% ind=4

% 矩阵的例子
A = [ 7  9  2  8
1  5  1  3
6  5  8  2];
[min_A , ind] = min(A,[ ],2)   % 求每一行的最小值并返回索引
% min_A = 3×1    
%     2
%     1
%     2
%ind = 3×1    
%     3
%     1
%     4
[min_A , ind] = min(A)   % 求每一列的最小值并返回索引
%min_A = 1×4    
%     1     5     1     2
%ind = 1×4    
%     2     2     2     3
%求出整个矩阵的最小值
A = randi(100,3,4)
%A = 3×4    
%    73    22     7    37
%    53    11    41    77
%   100    11    45    63
min(A(:))
% 7

如果向量或者矩阵中存在NaN值，min函数会自动忽略，不需要单独对NaN值进行处理。

% 存在缺失值的例子
A = [5 6 7 NaN 5 3 10];
[min_A , ind] = min(A)
% min_A=3
% ind=6

% 求x和y对应元素的最小值
x = [1  NaN  3   5   2  NaN  1];
y = [2   5   4  NaN  2  NaN  9];
min(x, y)
%ans = 1×7    
%     1     5     3     5     2   NaN     1

% 求两个矩阵对应位置元素的最小值时，min函数只能有一个返回值！
[min_xy, ind] = min(x, y)
%错误使用 min
%不支持具有两个要比较的矩阵和两个输出参数的 MIN。

mink 求前k个最小值

（1）如果A是一个向量，则mink(A,k)可以计算向量A的前k个最小值。

（2）如果A是一个矩阵，则mink(A,k,dim)可以计算A沿维度dim的前k个最小值。

当dim=1时沿着行方向计算，即得到每列的前k个最小值；dim=1时，mink(A,k,1)也可以简写成mink(A,k).
当dim=2时沿着列方向计算，即得到每行的前k个最小值。

A = [1,5,0,4,9,9,3,5,8];
mink(A,3)
%ans = 1×3    
%     0     1     3

A = randi(10,5,4)
%A = 5×4    
%     7     6     5     7
%     8     3     7     8
%     6     1     4     5
%     4     8     8     1
%     2     3     4     4
mink(A,3)  % 沿着行方向，等价于mink(A,3,1)
%ans = 3×4    
%     2     1     4     1
%     4     3     4     4
%     6     3     5     5
mink(A,3,2)  %沿着列方向
%ans = 5×3    
%     5     6     7
%     3     7     8
%     1     4     5
%     1     4     8
%     2     3     4

%老版本的MATLAB
%向量的前k个最小值
%可以先排序，再取出前k个元素。
sortA = sort(A);
sortA(1:3)
%ans = 1×3    
%     0     1     3
%矩阵的前k个最小值
sortA = sort(A);
sortA(1:3,:) %沿着行方向
%ans = 3×4    
%     2     1     4     1
%     4     3     4     4
%     6     3     5     5

sortA = sort(A,2);
sortA(:,1:3) %沿着列方向

maxk 求前k个最大值

用法与mink相同

topkrows 返回矩阵按照排序顺序的前若干行
- B=topkrows(X,k) 返回按降序（对于数值数据）或字母顺序倒序（对于文本数据）排序的数组X的前k行。
  - topkrows 基于第一列中的元素进行排序。当第一列包含值相等的元素时topkrows 将根据下一列中的元素进行排序，并对后续的相等值重复此行为，最后返回排序的前k行。
- B=topkrows(X,k,col)按col指定的列对结果进行排序。使用此语法可连续执行多列排序。
  - 例如，topkrows(X,k,5)基于第五列中的元素按降序对X的行进行排序。
  - topkrows(X,k,[4 6])首先基于第四列中的元素按降序对行进行排序，然后基于第六列中的元素进一步排序。
- B=topkrows(,direction)使用上述任何语法指定排序方向。
  - direction 可以是ascend'、'descend'或包含这两个值的元胞数组。
- 例如，topkrows(A,2,[2 3]).{'ascend''descend'”)首先基于第 2列的元素按升序对行进行排序从而获得前 2 行。然后基于第 3列中的元素，对第2列中具有相等条目的行按降序排序。
```
x = randi(10,10,4)；
topkrows(x,3) 
%等价于
sx = sortrows(x,'descend');
sx(1:3,:)

topkrows(x,4,2)  
%等价于
sx = sortrows(x,2,'descend');
sx(1:4,:)

topkrows(x,3,[2,4],'ascend') % 升序
%等价于
sx = sortrows(x,[2,4]);
sx(1:3,:)

topkrows(x,4,[3,2],{'ascend','descend'})
%等价于
sx = sortrows(x,[3,2],{'ascend','descend'});
sx(1:4,:)
```

2.算术运算

矩阵加法、减法
MATLAB中，只要两个矩阵的大小兼容，就能够进行计算
以下是一些具有兼容大小的标量、向量和矩阵的组合：
- 两个大小完全相同的输入。
- 一个输入是标量。
- 一个输入是矩阵，另一个输入是具有相同行数的列向量。
- 一个输入是矩阵，另一个输入是具有相同列数的行向量。
- 一个输入是列向量，另一个输入是行向量。

执行运算时，MATLAB会将大小兼容的矩阵隐式扩展为相同的大小，然后再将对应位置的元素进行运算，这种计算方式在MATLAB中称为“按对应位置的元素运算”

A = randi(10,2,3)
B = randi(10,2,3)
A + B
A - B

A = randi(10,2,3)
B = randi(10,1)
A + B
A - B

A = randi(10,2,3)
B = randi(10,2,1)
A + B
A - B

A = randi(10,2,3)
B = randi(10,1,3)
A + B
A - B

A = randi(10,2,1)
B = randi(10,1,3)
A + B
A - B

矩阵乘法
- 线性代数中定义的矩阵的乘法，使用的运算符号是乘号“*”，必须要满足前面矩阵A的列数和后面矩阵B的行数相等；
- 按对应位置的元素运算”的乘法，使用的运算符号是点乘 “.*”，这时A和B的大小只需要满足上方表格介绍的五种兼容模式。
如果一个矩阵和常数相乘，那么使用乘号“*”和点乘“.*”得到的结果相同。

A = randi(10,2,3)
% 4 2 3
% 6 7 7
B = randi(10,3,1)    
%    7
%    8
%    5
A * B
% 59
% 133

A = randi(10,2,3)  
%    10     5    10
%    1     2     1
B = randi(10,2,3)    
%    8     9     4
%    9     1     3
A .* B
% 80 45 40
% 9 2 3

x = randi(10,5)
% 6	 6	2	10	4
% 2	 5	3	5	2
% 9	 1	5	5	8
% 7	 3	1	4	4
% 4	 2	10	10	3
y = 3;
x * y 
x.* y
%18	 18	6	30	12
%6	 15	9	15	6
%27	 3	15	15	24
%21	 9	3	12	12
%12	 6	30	30	9

矩阵除法
- 右除 x = B/A 表示对线性方程组x*A = B求解x
- 左除 x = B\A 表示对线性方程组A*x = B求解x
- 点除即将两个矩阵按对应位置的元素做除法
  - A ./ B”表示用A的每个元素除以B的对应元素，A和B的大小必须兼容；
  - 命令“A .\ B”则表示用B的每个元素除以A的对应元素
  - 特别地，如果B是标量，那么A./B的结果和A/B的结果相同。

A = [2,8,2;
     5,-4,8;
     6,4,0];
B = [18,60,-6];
x = B / A   % [5 -2 3]
% 验算下：x*A是否等于B
x * A
% 18 60 -6

A = [1 5 8;
     2,4,9;
     3,0,2];
B = [10;
     4;
     -1];
x = A\B  % [1;5;-2]
% 验算下：A*x是否等于B
A * x
%    10
%    4
5   -1

A = randi([0,10],3,2)
% 4	10
% 1	10
% 1	6
B = randi([0,10],3,2)
% 0	9
% 2	0
% 3	0
A ./ B  % 点右除
% Inf	1.1111
% 0.5000	Inf
% 0.3333	Inf
1 ./ A  % 对A中每个元素计算倒数
% 0.2500	0.1000
% 1.0000	0.1000
% 1.0000	0.1667

矩阵乘方

“^”表示矩阵的幂运算，例如A是一个方阵，那么A ^ 3等价于A*A*A；

“.^”表示对矩阵中的每一个元素分别进行乘方计算，例如A .^ 0.5表示对矩阵A中的每一个元素开根号

A = randi([0,10],2,2)
% 7  4
% 2  6
A ^ 3 % 等价于A * A * A
% 503  540
% 270  368


A = randi(10,3,4)
%    8     8     5     6
%    1     5     4     9
%   10     5     6     8
A .^ 2  % 每个元素求平方，等价于 A .* A
%    64    64    25    36
%    1    25    16    81
%  100    25    36    64
A .^ 0.5   % 每个元素开根号，等价于sqrt(A)
%   2.8284    2.8284    2.2361    2.4495
%   1.0000    2.2361    2.0000    3.0000
%   3.1623    2.2361    2.4495    2.8284
A .^ (-1)   % 每个元素求倒数，等价于 1./ A 
%    0.1250    0.1250    0.2000    0.1667
%    1.0000    0.2000    0.2500    0.1111
%    0.1000    0.2000    0.1667    0.1250

矩阵的逆

只有方阵才有逆矩阵的概念

A^(-1) 或 inv(A)

A = [1 2 3;
    2 2 1;
    3 4 3]
B1 = A ^ (-1)
B2 = inv(A)
% B1 = 
%    1.0000    3.0000   -2.0000
%   -1.5000   -3.0000    2.5000
%    1.0000    1.0000   -1.0000

% B2 = 
%    1.0000    3.0000   -2.0000
%   -1.5000   -3.0000    2.5000
%    1.0000    1.0000   -1.0000

根据线性代数中逆矩阵的定义，互为逆矩阵的两个矩阵的乘积为单位矩阵（主对角线为1，其余位置为0的方阵）

理想情况下，B1*A将生成单位矩阵。但由于 MATLAB使用浮点数计算矩阵的逆存在一定的误差，因此，实际上 B1*A接近但不完全等于单位矩阵。

format long g
B1*A
% ans = 
%                         1      1.77635683940025e-15                         0
%     -8.88178419700125e-16                         1     -8.88178419700125e-16
%      4.44089209850063e-16                         0                         1
format short     %理想情况下，B1*A将生成单位矩阵。

矩阵转置
- 矩阵的转置符号为英文的单引号：“ ’ ”，转置的同时将复数变为共轭复数。
- 也可以在前面加上点变成“ .’ ”，转置的同时复数将保留原来的复数。
通常情况若矩阵中全是实数，那么使用“’”和“.’”的效果相同

format short
A = [ 3     1+3i;
      2     5;
      4-2i  6];
A'
% ans = 
%   3.0000 + 0.0000i   2.0000 + 0.0000i   4.0000 + 2.0000i
%   1.0000 - 3.0000i   5.0000 + 0.0000i   6.0000 + 0.0000i
A.'
% ans = 
%   3.0000 + 0.0000i   2.0000 + 0.0000i   4.0000 - 2.0000i
%   1.0000 + 3.0000i   5.0000 + 0.0000i   6.0000 + 0.0000i

练习
- 用来评价预测效果好坏的一些指标（详细解释在code3_4_2中）
  - 假设真实值是向量y, 拟合值或预测值是向量y_hat
    - SSE 误差(或残差)平方和，范围[0,+∞)，当预测值与真实值完全吻合时等于0。误差越大，该值越大。量纲是原来数据量纲的平方。
    - MSE 均方误差（Mean Square Error），范围[0,+∞)，就是SSE除了一个n。当预测值与真实值完全吻合时等于0。误差越大，该值越大。量纲是原来数据量纲的平方。
    - RMSE: 均方根误差（Root Mean Square Error），范围[0,+∞)，就是MSE加了个根号。当预测值与真实值完全吻合时等于0。误差越大，该值越大。量纲是原来数据量纲的平方。
    - MAE: 平均绝对误差（Mean Absolute Error）范围[0,+∞)，当预测值与真实值完全吻合时等于0。误差越大，该值越大。它的量纲和原来数据的量纲相同。
    - MAPE: 平均绝对百分比误差（Mean Absolute Percentage Error）该公式通常将值乘以100，以百分比形式表示数字。范围[0,+∞)，当预测值与真实值完全吻合时等于0。
      - 当真实值有数据等于0时，存在分母为0的问题，该公式不可用！
      - 将这个数乘以100，那么它的单位为%
    - SMAPE：对称平均绝对百分比误差（Symmetric Mean Absolute Percentage Error）它的范围是0％到200％，当预测值与真实值完全吻合时等于0。
      - 有些地方定义的SMAPE的分母没有加绝对值，这时候SMAPE可能为负数。
      - 将这个数乘以100，那么它的单位为%
    - R平方：决定系数、可决系数、R方、拟合优度（Coefficient of determination）
      - 注意：如果使用的是线性回归模型，那么两种计算R方的公式都可以使用，且此时R方的范围是[0,1]
      - 如果使用的是非线性回归模型，那么R方使用的是第一种定义方法！且此时R方的范围是负无穷到1。

y = [100 102 108 117 135 178 198 241 290 349];
y_hat = [93 108 118 117 141 170 196 249 296 359];

SSE = sum( (y-y_hat).^2 )

n = length(y);
MSE = 1/n*(sum( (y-y_hat).^2 ))

RMSE = sqrt( 1/n*(sum((y-y_hat).^2)) )

MAE = mean(abs(y-y_hat) )
MAE = 1/n*( sum( abs(y-y_hat) ) )

fz = y-y_hat;  % 分子
MAPE = mean(abs(fz ./ y))
MAPE = 1/n*(sum(abs(fz ./ y)))
% 将这个数乘以100，那么它的单位为%
MAPE = 1/n*(sum(abs(fz ./ y))) * 100

fz = abs(y-y_hat)  % 分子
fm = (abs(y)+abs(y_hat))/2  % 分母
SMAPE = 1/n*(sum(fz./ fm ))

%R平方
y = [100 102 108 117 135 178 198 241 290 349];
y_hat = [93 108 118 117 141 170 196 249 296 359];
% 使用第1种方法计算
fz = sum((y - y_hat).^2); % 分子
mean(y)
fm = sum((y - mean(y)).^2); % 分母 
R2 = 1 - fz/fm  

% 使用第2种方法计算
fz = sum((y_hat - mean(y)).^2); % 分子
fm = sum((y - mean(y)).^2); % 分母 
R2 = fz/fm

优化算法中常见的测试函数

Sphere函数
Rastrigin函数
Griewank函数

Rosenbrock函数

% Sphere函数 
x = 1:10
y = sum(x.^2) 

% Rastrigin函数
y = sum(x.^2-10*cos(2*pi*x)+10) %乘号不能省略

% Griewank函数
n = length(x);
y = 1/4000*sum(x.*x)-prod(cos(x./sqrt(1:n))) + 1

% Rosenbrock函数
x = 1:10;
tem1 = x(1:end-1)
tem2 = x(2:end)
y = sum(100 * (tem2-tem1.^2).^2 + (tem1-1).^2)

3.关系运算

6个关系运算符
关系运算符可以用来比较两个数组中元素的关系，如果结果为真，则MATLAB会返回逻辑值1；如果结果为假，则会返回逻辑值0。
== 等于
- 一个等号是赋值，两个连续的等号才是判断是否相等
~=不等于
> 大于
< 小于
>= 大于等于
<= 小于等于

NaN(不定值或缺失值)相互之间不相等

A = 5;
B = 4;  % 一个等号是给变量赋值，两个等号才是判断是否相等的关系运算符
A == B  % ans = logical 0


A = randi(5) % 生成[1,5]上的一个随机整数 A=5
B = randi(5,2,3)
% B = 2×3    
%     5     5     1
%     1     4     2

A == B  
% ans = 2×3 logical 数组    
%   1   1   0
%   0   0   0

A = NaN;
B = NaN;
A == B  % ans = logical 0

易错点：连续使用关系运算符

0 == 0 == 0   % 返回 logical 0 (false)
1 == 1 == 1   % 返回 logical 1 (true)
-1 < 0 < 1   % 返回 logical 0 (false)
1 > 0 > -1   % 返回 logical 1 (true)

逻辑值1和逻辑值0在进行计算时也可以被视为数值1和数值0

x = randi(10, 3, 4)
%x = 3×4    
%     7     4     8     1
%     8     7     1     1
%     8     2     3     9

y = x > 5 % 也可以写成y = (x>5)，加括号会让运算的顺序更清晰
%y = 3×4 logical 数组    
%   1   0   1   0
%   1   1   0   0
%   1   0   0   1

sum(y)  % 计算每一列的和
%ans = 1×4    
%     3     1     1     1

sum(y(:))  % 计算所有元素的和
% ans = 6

练习

% 模拟投硬币10万次，计算出现正面的次数和频率
n = 1e5;                % 科学计数法表示100000
x = randi([0,1], n, 1); % 0表示正面，1表示反面，生成n行1列的矩阵
s = sum(x == 0)         % 出现正面的次数
pl = s / n              % 出现正面的频率

判断浮点数是否相等

解决方法：使用容差 tol（而不是使用 ==）比较浮点数。

C = 0.5-0.4-0.1   % C = -2.7756e-17
C == 0            % ans = 0
C                 % C = -2.7756e-17
% 解决方法：使用容差 tol（而不是使用 ==）比较浮点数。
abs(C-0) <= 1e-12 % ans = 1

4.逻辑运算

逻辑运算符
逻辑与 and & and(1,1)=1&1
逻辑或 or | or(1,1)=1 |1
逻辑非 not ~ not(1)=~1
逻辑异或 xor 没有相应的运算符 xor(1,0)

MATLAB会将非零数值视为逻辑1，将数值零视为逻辑0——MATLAB在进行逻辑运算之前，在计算机内部自动将数值转换成了逻辑值

A = [-5 1.2  0  0  3  5.9];
B = [0   4   1  0 1.5 -2 ];
A & B    %   0   1   0   0   1   1

A = randi([-5,5],4,3)
%A = 4×3    
%     3     1     5
%     4    -4     5
%    -4    -2    -4
%     5     1     5

logical(A)
%ans = 4×3 logical 数组    
%   1   1   1
%   1   1   1
%   1   1   1
%   1   1   1

A = randi([-3,3],2,4)
%A = 2×4    
%     3     2    -1     2
%     0    -3     3     3

B = randi([-3,3],1,4)
%B = 1×4    
%     1    -3     2     3

B | 0
%ans = 1×4 logical 数组    
%   1   1   1   1

A | B
%ans = 2×4 logical 数组    
%   1   1   1   1
%   1   1   1   1

~A
%ans = 2×4 logical 数组    
%   0   0   0   0
%   1   0   0   0

xor(3,4)  % 0
xor(A,B)
%ans = 2×4 logical 数组    
%   0   0   0   0
%   1   0   0   0

true函数和false函数可分别用来生成全为逻辑1和逻辑0的逻辑矩阵。

true(2)  % 等价于logical(ones(2))
%ans = 2×2 logical 数组    
%   1   1
%   1   1

false(2,3)  % 等价于logical(zeros(2,3))
%ans = 2×3 logical 数组    
%   0   0   0
%   0   0   0

如果数据中存在NaN值，执行逻辑运算会报错

如果数据中存在复数，执行逻辑运算也会报错

a = [0 1 nan 1];
b = [0 1 1 1];
a & b
a | b
~a
or(a,b)
%错误使用  & 
%NaN 值无法转换为逻辑值。

a = 1+3i;
b = 1;
a & b
a | b
~a
xor(a,b)
%错误使用  & 
%NaN 值无法转换为逻辑值。

另外，逻辑与& 和逻辑或| 可以进行连续运算：

使用小括号来指定计算的先后顺序! 这样会清晰很多。

1 & 2 & 3 % 1
0 | 2 | 0 % 1
A = randi([-3,3],2,4)
% A = 2×4    
%      1     2     1     1
%      2    -1    -2    -3

B = randi([-3,3],1,4)
% B = 1×4    
%     -2    -3    -3     2

C = randi([-3,3],1,4)
% C = 1×4    
%      1    -1     3    -3

A & B & C
% ans = 2×4 logical 数组    
%    1   1   1   1
%    1   1   1   1

A | B | C
% ans = 2×4 logical 数组    
%    1   1   1   1
%    1   1   1   1

A & B | C
% ans = 2×4 logical 数组    
%    1   1   1   1
%    1   1   1   1

A & (B | C) % 使用小括号修改先后顺序
% ans = 2×4 logical 数组    
%    1   1   1   1
%    1   1   1   1

% & 运算符的优先级高于 | 运算符
2|0 &0   % 等价于2|(0&0) ,返回1
(2|0)&0  % 返回0


%区间[60,80)的表示
D = (A >= 60) & (A < 80)  %不能写成 60 <= A < 80
D = ((A >= 60) & (A < 80))

%区间[0,60)U[80,100]的表示
(A < 60) | (A >= 80)  
~D

&&和||
- （1）&&和||只能对标量（只有一个值）进行逻辑运算，不能对有多个元素的向量或者矩阵进行运算，而&和|可以。
- （2）&&和||进行逻辑运算时具有短路功能，可以提高运行效率：
  - 计算A && B时，如果A为逻辑0，则B不会被判断，因为最后的结果一定是逻辑0；
  - 计算A || B时，如果A为逻辑1，则B不会被判断，因为最后的结果一定是逻辑1。
```
a = 10; 
b = 2;
(a+b < 10) & (a/b > 1) % 0
(a+b < 10) && (a/b > 1) % 0

(10 > 3) | logical(NaN)  %运行到logical(NaN)会报错
(10 > 3) || logical(NaN) % 1，||有短路功能
```

利用逻辑值对矩阵进行索引

利用逻辑索引提取矩阵指定位置的元素，可以生成一个和A同样大小的逻辑矩阵L，L中的元素要么是逻辑值1，要么是逻辑值0，其中，等于逻辑值1的元素所处的位置是我们所需要的。接着使用命令A(L)，就能够在A中提取出指定位置的元素。

矩阵的数据在计算机的内存中被存储为单列，由矩阵的各列顺次连接而成。因此这里返回的结果是根据L中等于1的位置按照各列顺次连接的。

A = randi(10,3,4)
%A = 3×4    
%     8     7     6     3
%     3     9     2     9
%     6    10     2     3
L = (A <= 5)
%L = 3×4 logical 数组    
%   0   0   0   1
%   1   0   1   0
%   0   0   1   1
A(L)  %也可以写做A(A<=5)
%ans = 5×1    
%     3
%     2
%     2
%     3
%     3

使用逻辑值修改或删除矩阵元素

v = randi(10,1,6)
%v = 1×6    
%     9     4     3     5     2     7

v(v > 6) = 100  % 将v中大于6的元素全部修改成100
%v = 1×6    
%   100     4     3     5     2   100

v(v <= 5) = [ ]  % 删除v中小于等于5的元素
%v = 1×2    
%   100   100

A = [1:4; 2:5; 3:6]
%A = 3×4    
%     1     2     3     4
%     2     3     4     5
%     3     4     5     6

A(mod(A,3) == 0) = 10   % 将能被3整除的元素修改成10
%A = 3×4    
%     1     2    10     4
%     2    10     4     5
%    10     4     5    10

A(A < 3) = 0  % 将小于3的元素修改成0
%A = 3×4    
%     0     0    10     4
%     0    10     4     5
%    10     4     5    10

A(A <= 4 ) = [ ]  % 删除小于等于4的元素
%A = 1×6    
%    10    10    10     5     5    10

判断矩阵里是否含有NaN，返回一个和输入的数组大小相同的逻辑值

在MATLAB中，NaN相互之间不相等，运行NaN == NaN会返回逻辑0

A = [10 NaN 5 2 NaN 8 5];
isnan(A)
%ans = 1×7 logical 数组    
%   0   1   0   0   1   0   0

~(isnan(A))
%ans = 1×7 logical 数组    
%   1   0   1   1   0   1   1

 NaN == NaN % 0
 A == NaN % 0 0 0 0 0 0 0

all,any,find函数
- all：判断数组元素是否全为非零值（可指定dim），全为非零值返回逻辑1，否则返回逻辑0
- any：判断数组元素中是否存在至少1个非零值（可指定dim），是的话返回逻辑1，否则返回逻辑0
- find：查找数组中的非零元素，并返回其索引
  - k=find(x)返回一个包含数组x中每个非零元素的线性索引的向量
  - k=find(x,n)返回与x中的非零元素对应的前n索引
  - k=find(x,n,direction)（其中direction为last）查找与x中的非零元素对应的最后n个索引。direction的默认值为first，则为查找与非零元素对应的前n个索引
  - [row,col]=find(x) 返回数组中非零元素的行和列下标
  - [row,col,v]=find(x) 返回数组中非零元素的行和列下标，还返回包含x的非零元素的向量v
    - ```
    A = randi([-3,3],3,4)
    %A = 3×4    
    %    -3     3    -2    -1
    %     0    -1     3     1
    %    -1     3     1     1
    
    all(A)  % all(A,1)
    %ans = 
    %   0   1   1   1
    
    all(A,2)
    %ans = 
    %   1
    %   0
    %   1
    
    A = [0  0  -1  2;
        -3  0  1  -2;
        0  0  0  0];
    any(A)  % all(A,1)
    %ans = 
    %   1   0   1   1
    
    any(A,2)
    %ans = 
    %   1
    %   1
    %   0
    
    %判断整个矩阵的元素是否全部为非零值
    all(A(:)) % 0
    all(all(A)) % 0
    
    A = [4 0 11 -3 0 2 -4];
    ind = find(A) % 1 3 4 6 7
    [r, c] = find(A)
    % r=1 1 1 1 1
    % c=1 3 4 6 7
    
    A = [0 -1 0 0;
         4 0 0 3;
         0 1 0 0];
    ind = find(A, 2) % 2 4
    ind = find(A, 2, 'last') % 6 11
    [row,col] = find(A) 
    [row,col,v] = find(A)
    %row=
    %    2
    %    1 
    %    3 
    %    2
    %col=
    %    1
    %    2
    %    2
    %    4
    %v=
    %    4
    %    -1
    %    1
    %    3
```