Matlab 进阶

一、小技巧

清除命令行窗口中的所有文本
clc

清除工作区的所有变量
clear

快速注释
Ctrl + R

快速取消注释
Ctrl + T

矩阵的四则运算 与 矩阵元素的四则运算
+ - * /  与  .+ .- .* ./

Matlab 2016 版本没有双引号的用法

二、循环语句

if 循环

% 判断 i 是不是 0

i = 0;
if i~=0  			% 不等于符号
    disp('i不是0')
elseif i==0
    disp('i是0')
end

输出：i是0

for 循环

% 求 1 至 2 每次增加 0.5 的和

s = 0;
for i = 1 :0.5 :2
    s = s + i;		% i 加上本身 
end
disp(s)

输出：4.5000

while 循环

% 求 1 到 100 的和

s = 0;  
i = 1;
while (i <= 100)
    s = s + i;
    i = i + 1;
end
disp(s);

输出：5050

三、函数用法

disp 函数 和 input 函数（输入、输出）

a = [1 2 3]
disp(a)

输出：1 2 3

A = input('请输入A：')

输出：请输入A：

strcat 函数（合并字符串）

三种方法
strcat('字符串1','字符串2') 
['字符串1'  '字符串2']
['字符串1','字符串2']

输出：字符串1字符串2

num2str 函数（将数字转换为字符串）

c = 100
num2str(c)

输出：100

str2num 函数（将字符串转为数字）

c = '100'
str2num(c)

输出：100

mod 函数（求模）

mod(8,3)	% 相当于算 8 % 3

输出：2

sum 函数（求和）

(1) 如果是向量（无论是行向量还是列向量），都是直接求和
E = [1,2,3]
E = [1;2;3]
sum(E)

(2) 如果是矩阵，则需要根据行和列的方向作区分
E = [1,2;
	 3,4;
	 5,6]
	 
按列求和(得到一个行向量）
a = sum(E)
a = sum(E,1)

按行求和(得到一个列向量）
a = sum(E,2)

对整个矩阵求和
a = sum(sum(E))
a = sum(E(:))

prod 函数（求积）

(1) 如果是向量（无论是行向量还是列向量），都是直接求积
E = [1,2,3]
E = [1;2;3]
prod(E)

(2) 如果是矩阵，则需要根据行和列的方向作区分
E = [1,2;
	 3,4;
	 5,6]
	 
按列求积(得到一个行向量）
a = prod(E)
a = prod(E,1)

按行求积(得到一个列向量）
a = prod(E,2)

对整个矩阵求积
a = prod(prod(E))
a = prod(E(:))

max 函数（求最大值）

%% min 函数同理，就不讲了

(1) 如果是向量（无论是行向量还是列向量），都是直接求最大值

E = [1,2,3]
E = [1;2;3]
max(E)     		      % 无论行还是列，最大值都是 3
输出：3

(2) 如果是矩阵，可以分别 求每行 和 求每列 的最大值

E = [1,2,3;
	 4,5,6]
	 
max(E,[],1)            % 求每列的最大值，也可以写成 max(E)
输出：4 5 6

max(E,[],2)            % 求每行的最大值
输出：3
	  6

median 函数（求中位数值）

(1) 如果是向量（无论是行向量还是列向量），都是直接求中位数值

E = [1,2,3]
E = [1;2;3]
median(E)         			    % 无论行还是列，中位数值都是 2
输出：2

(2) 如果是矩阵，可以分别 求每行 和 求每列 的中位数值

E = [1,2,3;
	 4,5,6]
	 
max(E,1)           				 % 求每列的中位数值
输出：2.5000   3.5000   4.5000

max(E,2)        			     % 求每行的中位数值
输出：2
	  5

std 函数（求标准差）

标准用法：std (x, flag, dim)

x 代表向量或矩阵
flag 代表计算公差时要除以 n 还是 n-1 （flag = 1 代表前者，flag = 0 代表后者）
dim 代表维数 （dim = 1 代表求列，dim = 0 代表求行）

x = [1 2 3 4;
	 4 5 6 1]

(1) 默认格式是 std(x,0,1)		% 公差除以 n-1 并且求列
	 
std(x)
输出：2.1213    2.1213    2.1213    2.1213

(1) 自定义格式

std(x,1,2)
输出：1.1180
      1.8708

skewness 函数（求偏度）

x = [...]     % 数据
pd = skewness[x]	% 结果 >0 称为右偏态，<0 称为左偏态

kurtosis 函数（求峰度）

x = [...]     % 数据
fd = kurtosis [x]	% 用作衡量偏离正态分布的尺度之一

size 函数（求长度）

A = [1,2,3;
	 4,5,6]

% 返回一个行向量，第一个元素是矩阵的行数，第二个元素是矩阵的列数

[r,c] = size(A)
输出:  r = 2
	   c = 3

% 将矩阵A的行数返回到第一个变量 r，将矩阵的列数返回到第二个变量 c

r = size(A,1)  % 返回行数
c = size(A,2)  % 返回列数

repmat 函数（复制）

A = [1,2,3;
	 4,5,6]

% 将矩阵A复制m×n块，即把A作为B的元素，B由m×n个A平铺而成

B = repmat(A,2,1)  % 复制两行一列
输出: 1 2 3
	  4 5 6
	  1 2 3
	  4 5 6

B = repmat(A,2,2)  % 复制两行两列
输出: 1 2 3 1 2 3
	  4 5 6 4 5 6
	  1 2 3 1 2 3
	  4 5 6 4 5 6

find 函数（查找元素）

(1) 如果是向量（无论是行向量还是列向量），都是直接返回非0元素的位置
X = [1 0 4 -3 0 0 0 8 6]

ind = find(X)
输出：1 3 4 8 9

ind = find(X,2)  % 返回前2个非0的元素的位置
输出：1 3

(2) 如果是一个矩阵（二维，有行和列），则返回非0元素的列向量或坐标
X = [1 -3  0;
	 0  0  8;
	 4  0  6]
	 
ind = find(X)  % 返回列向量
输出:  1
	   3
	   4
	   8
	   9
	   
[r,c] = find(X)
输出：
r =  1
     3
     1
     2
     3
     
c =  1
     1
     2
     3
     3


[r,c] = find(X,1)  % 只找第一个非0元素的坐标
输出：
r =  1

c =  1

(3) 如果 find 函数中有比较参数，则返回指定的参数的位置
X = [1 0 4 -3 0 0 0 8 6]

ind = find(X > 1)
输出：3 8 9

Y = [1 -3  0;
	 0  0  8;
	 4  0  6]

[r,c] = find(Y > 1)
输出：
r =  3
     2
     3
     
c =  1
     3
     3

sort 函数（排序）

A = [5 2 7;
     4 9 3;
     1 8 6]     % 矩阵
   
B = [5 2 7 4 9 3 1 8 6]
C = [5 8 3 6 1 7 9 2 4]     % 列表


(1) 按行排序

a = sort(A,2)
输出：2 5 7
	  3 4 9
	  1 6 8

(2) 按列排序

a = sort(A,1)     % 默认是按列排序
输出：1 2 3
	  4 8 6
	  5 9 7

(3) 正序与倒序

a = sort(A,1,'ascend')    % 默认是正序
输出：1 2 3
	  4 8 6
	  5 9 7

a = sort(A,1,'descend')   % 倒序
输出：5 9 7
	  4 8 6
	  1 2 3

(4) 索引

[b,index] = sort(B)    % b 是排序结果，index 是索引
输出：
b =
1 2 3 4 5 6 7 8 9

index =
7 2 6 4 1 9 3 8 5      % 索引

c = C(index)
输出：
c =
9 8 7 6 5 4 3 2 1      % c 的顺序与 b 的顺序一一对应

reshape 函数（矩阵换顺序）

A = [1 2 3;
     4 5 6]

reshape(A,3,2)		% 将矩阵 A 变成 3 行 2 列（按照原矩阵的列读取）
ans = [1 5;
       4 3;
       2 6]

isempty 函数（判断空矩阵）

%% 可以用来判断矩阵是否为空, 如果矩阵为空，返回逻辑值 1(true)，否则返回逻辑值 0(false)

isempty(find([0,0,0,0,0]))		% find 函数未找到非 0 值返回空矩阵
ans = 1

isempty(find([0,1,0,0,1]))		% find 函数找到非 0 值返回矩阵 [2,5]
ans = 0

isempty([0,0,0,0,0])		% 参数中的矩阵不是空矩阵，而是值全为 0 的行矩阵
ans = 0

zeros 函数（生成全是 0 的矩阵）

(1) 一个参数

zeros(2)
输出：
0 0
0 0

(2) 两个参数

zeros(3,4)
输出：
0 0 0 0
0 0 0 0
0 0 0 0

ones 函数（生成全是 1 的矩阵）

(1) 一个参数

ones(2)
输出：
1 1
1 1

(2) 两个参数

ones(3,4)
输出：
1 1 1 1
1 1 1 1
1 1 1 1

eye 函数（生成单位矩阵）

eye(3)
ans = [1 0 0;
       0 1 0;
       0 0 1]

det 函数（求矩阵的值）

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

det(A)
ans = 1

B = [1 -2  4;
    -5  2  0;
     1  0  3]

det(B)
ans = -32

mean 函数（求平均值）

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

(1) 求列项平均值

mean(A)             % 也可以用 mean(A,1) 代替
输出：ans = 3.0000 4.5000 6.0000

(2) 求行项平均值

mean(A,2)           % 求行项
输出：
ans = 
	2.0000
	4.0000
	6.0000
	6.0000

roundn 函数（四舍五入）

a = 3.1445
b = 31445

roundn(a,-2)		% a 在小数点后两位 四舍五入
输出：
ans = 3.1400

roundn(a,2)			 % a 在十位 四舍五入
输出：
ans = 0

roundn(b,1)		     % b 在个位 四舍五入
输出：
ans = 31450

roundn(b,2)			 % b 在十位 四舍五入
输出：
ans = 31400

rand 函数（生成均匀分布随机数）

s1 = rand(1,5)   				 % 产生一个 0 至 1 之间的随机矩阵，大小为 1 x 5

ans = [0.8147    0.9058    0.1270    0.9134    0.6324]

s2 = 2 + (5-2) * rand(1,5)  	 % 产生一个 2 至 5 之间的随机矩阵，大小为 1 x 5

ans = [2.2926    2.8355    3.6406    4.8725    4.8947]

randi 函数（生成均匀分布随机整数）

s1 = randi(10,2,5)				 % 产生一个 1 至 10 之间的随机矩阵，大小为 2 x 5

ans = [2     10    9     5     8
       10    5     2     10    10]

s2 = randi([-5,5],1,10) 		 % 产生一个 -5 至 5 之间的随机矩阵，大小为 1 x 10

ans = [2   -5   4   5   2   3   3   -1   2   -4]

randperm 函数（生成随机序列）

randperm(5)

ans = [1 4 5 3 2]		% 仅含不同的 1 - 5 的全部数字

randperm(5)

ans = [3 5 1 2 4]		% 仅含不同的 1 - 5 的全部数字

randsrc 函数（以一定的概率生成随机数）

% 比如：要产生 1 4 6 这三个数，它们分别出现的概率为  0.1  0.2  0.7

alphabet = [1 4 6]; 		% alphabet 表示需要产生的随机数的数字，用一个行向量表示
prob = [0.1 0.2 0.7];		% prob 表示这些数字出现的概率大小，用一个行向量表示 (概率和要为 1)
randsrc(10,1,[alphabet; prob])	% 10 和 1 表示生成的随机数矩阵的行数和列数

ans = [4 6 1 6 6 4 6 6 6 6 ]

normrnd 函数（生成正态分布随机整数）

s = normrnd(0,2,3,4)			 % 产生一个均值为 0，标准差为 2 的正态分布的随机矩阵，大小为 3 x 4

ans = [1.7768   -1.6190    0.6504   -3.4230
      -2.2941   -5.8886   -1.5099   -0.2045
      -2.1377    2.8768    2.7406   -0.4829]

unique 函数（剔除重复值并排序）

unique([1 2 5; 6 8 9;2 4 6])		% 只要行向量不为 1，即输出 1 列向量
ans = [1
	   2
	   4
	   5
	   6
	   8
	   9]

unique([5 6 8 8 4 1 6 2 2 4 8 4 5 6])	% 行向量为 1，输出 1 行向量
ans = [1 2 4 5 6 8 9]

四、画图函数

plot 函数 和 subplot 函数（画图）

(1) 常规用法
plot(x1,y1,x2,y2) 

(2) 特殊用法
plot(x1,y1,'b*',x2,y2,'-')    % 前面的曲线用 蓝色星号 显示   % 后面的曲线用 默认颜色实线 显示

%% 线方式： - 实线 :点线 -. 虚点线 - - 波折线 
%% 点方式： . 圆点  +加号  * 星号  x x形  o 小圆
%% 颜色： y黄； r红； g绿； b蓝； w白； k黑； m紫； c青

(3) 多图共面用法
subplot(4,3,i)     % 在每个 plot 前面加上此函数，代表图显示在 4 行 3 列的第一个位置
plot(...)

fplot 函数（自定义函数画图）

%% 先说明匿名函数的基本用法

z = @(x,y) x^2+y^2;   % z 为调用匿名函数时使用的名字  x、y 为输入参数，可以是一个，也可以是多个，用逗号分隔
z(1,2) 
输出：
ans = 5

k = @(x) x+2;		  % 原理同上
k(3)
输出：
ans = 5

%% fplot 函数用于画出匿名一元函数的图形

fplot(z,[1,2]);   		% z 为匿名函数，[1,2]表示定义域区间

fplot(k,[3,4]);		  	% 原理同上

xlabel 函数 和 ylabel 函数（加上 x、y 轴标题）

plot(...)
xlabel('x 轴标题')			% 在每个 plot 后面加上此函数，表示 x 轴标题
ylabel('y 轴标题')			% 在每个 plot 后面加上此函数，表示 y 轴标题

axis 函数（设置坐标轴的范围）

plot(...)
axis([0 15,-inf,inf])		%  设置横坐标轴 0-15，纵坐标不变化
% 在每个 plot 后面加上此函数，用于设置坐标轴的范围，参数必须使用列表

lengend 函数（生成图例标识框）

plot(...)
lengend('原始数据','模型数据','Location','SouthEast')    % 图例标识框出现在右下角（东南方向）
% 在每个 plot 后面加上此函数，表示生成图例标识框，最后两个参数用于指定图例标识框的位置

text 函数（坐标点上标字符串）

text(2,4,'电影院')   % 在坐标为(2,4)的点上标上字符串：电影院

hold on 和 grid on（函数图像合并、生成表格线）

tic 和 toc 和 pause 和 close（计时、延时、关闭）

(1) 计时
tic
a = 2^100
toc		% 记录中间代码的运行时间

(2) 延时
pause(3)  % 暂停 3 秒后再继续接下来的命令

(3) 关闭
close  % 关闭图形窗口

五、其他操作

自定义函数

自定义函数都是单独的一个文件，但是可以在别的文件中使用（前提是在同一个文件夹中）

(1) 无返回值的函数
function mysum(n)  % mysum 是函数名
    s=0;
    for i = 1 : n
        s=i+s;
    end
    disp(s)  % 直接输出 s
end

>> mysum(3)
6

(2) 有返回值的函数
function result = mysum(n)  % mysum 是函数名，result 是返回值
    s=0;
    for i = 1 : n
        s=i+s;
    end
    result = s;  % 输出返回值 result
end

>> a = mysum(3)
6

提取矩阵中指定位置的元素

A=[1 2 3;
   4 5 6;
   7 8 9];
   	
(1) 取指定行和列的一个元素（输出的是一个值）

A(2,1)
输出：4

(2) 取指定的某一行的全部元素（输出的是一个行向量）

A(2,:)
输出：4 5 6

(3) 取指定的某一列的全部元素（输出的是一个列向量）

A(:,3)
输出:  3
	   6
	   9

(4) 取指定的某些行的全部元素（输出的是一个矩阵）


A(2:3,:)         % 第二行 到 第三行
输出: 4 5 6
	  7 8 9

A(2:end,:)       % 第二行 到 最后一行
输出: 4 5 6
	  7 8 9

(5) 取全部元素(按列拼接的，最终输出的是一个列向量)

A(:)
输出:  1
	   2
	   3
	   4
	   5
	   6
	   7
	   8
	   9   

求逆矩阵

A = [1 2 3;
	 2 2 1;
	 2 0 3]
	 
inv(A)
输出: -0.4286    0.4286    0.2857
       0.2857    0.2143   -0.3571
       0.2857   -0.2857    0.1429

求特征值和特征向量

A = [1 2 3;
	 2 2 1;
	 2 0 3]

(1) 求矩阵A的全部特征值，构成向量E

E = eig(A)
输出: -1.3166
       5.3166
       2.0000

(2) 求矩阵A的全部特征值，构成对角阵D，并求A的特征向量构成V的列向量
（V的每一列都是D中与之相同列的特征值的特征向量）

[V,D] = eig(A)      
输出：
V =   0.8364   -0.6336   -0.2408
     -0.3875   -0.5470   -0.8427
     -0.3875   -0.5470    0.4815



D =  -1.3166         0         0
           0    5.3166         0
           0         0    2.0000

查看矩阵存储方式

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

A(4)  % 查找元素4的位置
输出：2

A(8)  % 查找元素8的位置
输出：6

A(9)  % 查找元素9的位置
输出：9

说明矩阵是按列存储的，如下方式存储
 A = 1
     2
     3
     4
     5
     6
     7
     8
     9 

矩阵与常数的大小判断运算

X = [1 -3  0;
	 0  0  8;
	 4  0  6]

X > 0
输出: 1    0    0
 	  0    0    1
      1    0    1

X == 4
输出: 0    0    0
      0    0    0
      1    0    0

[1 5 6 0 8 0 -5] == 0
输出：0 0 0 1 0 1 0

输出一段数字加文字

a = 1;
disp([num2str(a) '45'])

输出：145

矩阵相乘

%% 两个矩阵相乘得出的矩阵的长宽是前行后列
举例一

a = [1 2 3;
	 4 5 6]	 		   % 两行
	 
b = [1 2;
	 3 4;
	 5 6]    	 	   % 两列

a * b = [22  28;
		 49  64]   	   % 两行两列

举例二

c = [1;
	 2;
	 3]			   		% 三行

d = [4 5 6]		  		% 三列

c * d = [4   5   6 ;
	 	 8   10  12;
	 	 12  15  18]    % 三行三列

矩阵间的吞入

tmp = [11 12 13 14 15]

temp = [1 2 4]

tmp(temp)
ans = [11 12 14]    	% 相当于输出 tmp([1 2 4])