Octave/Matlab基本操作

基本操作

数学运算

基本的加、减、乘、除、指数运算:

1
2
3
4
5
6
7
8
9
10
octave:1> 5+6
ans = 11
ocatave:1> 3-2
ans = 1
octave:3> 5*8
ans = 40
octave:4> 1/2
ans = 0.50000
octave:5> 2^6
ans = 64

逻辑运算

1
2
3
4
5
6
7
8
9
10
octave:6> 1 == 2  % false
ans = 0
octave:7> 1 ~= 2
ans = 1
octave:8> 1 && 0 % AND
ans = 0
octave:9> 1 || 0 % OR
ans = 1
octave:10> xor(1, 0)
ans = 1

其中%代表注释符号,~=代表不等于,xor()是异或符号。

修改等待命令的快捷提示

通过PS1()命令来设置等待命令的快捷提示:

1
2
3
octave:11> PS1(">> ")
>>
>>

赋值运算

1
2
3
>> a = 3
a = 3
>>

如果不希望在屏幕上显示结果,只需要结尾加;即可抑制打印输出:

1
2
>> a = 3;  % semicolon supressing output
>>

变量的打印输出

变量的赋值与打印:

1
2
3
4
5
6
7
>> b = "hi";
>> b
b = hi
>> c = (3>=1);
>> c
>> c = 1
>>

对于一些复杂的输出,可以使用disp命令:

1
2
3
4
5
6
7
8
>> a = pi;
>> a
a = 3.1416
>> disp(a)
3.1416
>> disp(sprintf('2 decimals: %0.2f', a))
2 decimals: 3.14
>>

控制输出长短

1
2
3
4
5
6
7
8
9
>> a
a = 3.1416
>> format long
>> a
a = 3.14159265358979
>> format short
>> a
a = 3.1416
>>

矩阵的表示

表示一个三行两列的矩阵:

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

另一种表示矩阵的方式:

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

分配一个三行一列的列向量:

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

表示一个行向量,其中第一个值是起始值,中间的值是步长,最后一个值是终止值:

1
2
3
4
5
6
>> v = 1:0.1:2
v =
Columns 1 through 8:
1.0000 1.1000 1.2000 1.3000 1.4000 1.5000 1.6000 1.7000
Columns 9 through 11:
1.8000 1.9000 2.000

也可以不写步长,这样默认步长是1:

1
2
3
>> v = 1:6
v =
1 2 3 4 5 6

生成元素为1的矩阵

生成一个2行3列,所有元素都为1的矩阵:

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

1 1 1
1 1 1

生成一个2行3列,所有元素都为2的矩阵:

1
2
3
4
5
>> 2*ones(2,3)
ans =

2 2 2
2 2 2

生成0矩阵

生成一个1行3列的0矩阵:

1
2
3
4
>> w = zeros(1,3)
w =

0 0 0

生成随机数矩阵

生成一个元素为介于0到1之间随机数的1行3列的矩阵:

1
2
3
4
>> w = rand(1,3)
w =

0.65555 0.77468 0.85729

均值为0的高斯分布:

1
2
3
4
>> w = randn(1,3)
w =

0.61607 0.53219 1.48783

-6加上根号10乘以一个一行10000列的正太分布的随机向量。

1
>> w = -6 + sqrt(10)*(randn(1,10000));

绘制函数

绘制这个直方图:

1
>> hist(w)

绘制有50条的直方图:

1
>> hist(w,50)

生成单位矩阵

生成矩阵的特殊命令:eye ,可用来生成单位矩阵:

1
2
3
4
5
6
7
8
9
10
>> A = eye(5)
A =

Diagonal Matrix

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

help

help命令,后面跟任何其他指令,都可以查看该指令的说明文档,包括help自身:

1
>> help eye

移动数据

关于加载外部数据到Octave中,以及存储Octave的数据到文件中的一些操作。

首先,创建一个3行2列的矩阵A:

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

1 2
3 4
5 6

查看矩阵尺寸

通过size命令,我们能看到这个矩阵的尺寸:

1
2
3
4
>> size(A)
ans =

3 2

实际上size的这个输出结果自身也是一个矩阵:

1
2
3
4
5
6
7
8
9
>> sz = size(A)
sz =

3 2

>> size(sz)
ans =

1 2

分别查看A向量的size的输出结果中的两个值:

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

查看矩阵最大维度

length指令,来获取矩阵的最大维度,这个命令其实通常只对向量使用:

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

1 2 3 4

>> length(v)
ans = 4
>> A
A =

1 2
3 4
5 6

>> length(A)
ans = 3

设置Octave当前路径

当我们打开Octave的时候,其实我们已经处在了一个默认路径下:

1
2
3
>> pwd
ans = C:\Users\jing1
>>

这个路径是Octave的安装位置。我们可以改变当前目录到桌面目录:

1
2
3
>> cd /Users/jing1/Desktop
>> pwd
ans = /Users/jing1/Desktop

加载外部文件

目前桌面目录下有两个存有数据的文件:

1
2
>> ls
FeaturesX.dat PriceY.dat

通过load命令,加载外部文件:

1
2
>> load featuresX.dat
>> load priceY.dat

也可以使用load()的方式来加载,效果相同:

1
2
>> load('featuresX.dat')
>> load('priceY.dat')

查看存储变量

使用who命令来查看当前Octave中存储的变量:

1
2
3
4
5
>> who
Variables in the current scope:

A ans c priceY v
a b featuresX sz w

whos命令可以查看更详细的信息,包括尺寸,内存占用,以及类型:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>> whos
Variables in the current scope:

Attr Name Size Bytes Class
==== ==== ==== ===== =====
A x2 48 double
a x1 8 double
ans x2 16 double
b x2 2 char
c x1 1 logical
featuresX 7x2 752 double
priceY 7x1 376 double
sz x2 16 double
v x4 32 double
w x10000 80000 double

Total is 10159 elements using 81251 bytes

可以看到featuresXpriceY已经被成功的被作为一个变量加载进来了,直接输入featuresX来查看这个变量的内容:

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

featuresX =

2104 3
1600 3
2400 3
1416 2
3000 4
1985 4
1534 3
1427 3
1380 3
1494 3
1940 4
2000 3
1890 3
...

通过size()函数,可以看到featuresX是一个47行2列的矩阵,priceY是一个47行1列的矩阵:

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

47 2

>> size(priceY)
ans =

47 1

删除变量

可以使用clear命令来删除某个变量:

1
2
3
4
5
>> clear featuresX
>> who
Variables in the current scope:

A a ans b c priceY sz v w

截取矩阵部分元素

priceY的前10个元素存入变量V

1
2
3
4
5
6
7
8
9
10
11
12
13
>> V = priceY(1:10)
V =

3999
3299
3690
2320
5399
2999
3149
1989
2120
2425

变量的存储

将变量V存入hello.mat文件中:

1
2
3
>> save hello.mat V
>> ls
FeaturesX.dat PriceY.dat hello.mat

这里其实是把V按照压缩的二进制的形式进行存储,如果说V的数据很大,那么压缩的幅度也很大。

如果想按照一个可以看得懂的格式进行存储的话,可以这样输入:save hello.txt V -ascii

清空所有变量

直接输入clear命令,会清空所有的变量:

1
2
>> clear
>> whos

索引

用索引来查询

首先创建矩阵A

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

1 2
3 4
5 6

可以通过A(3,2)来访问矩阵的第三行第二列的元素:

1
2
>> A(3,2)
ans = 6

也可以通过A(2,:)来访问第二行的所有元素,其中:代表该行/列的所有元素:

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

3 4

可以通过A([1 3], :)来取矩阵第1行以及第3行的所有元素:

1
2
3
4
5
>> A([1 3], :)
ans =

1 2
5 6

通过A(:)来将所有的元素以一个列向量的形式展示:

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

1
3
5
10
11
12

用索引来赋值

你也可以通过索引来进行复制操作:

1
2
3
4
5
6
7
8
9
10
11
12
13
>> A
A =

1 2
3 4
5 6

>> A(:,2) = [10; 11; 12]
A =

1 10
3 11
5 12

在矩阵的右侧新增一列:

1
2
3
4
5
6
7
8
9
10
11
12
13
>> A
A =

1 10
3 11
5 12

>> A = [A,[100; 101; 102]]
A =

1 10 100
3 11 101
5 12 102

将两个行相等的向量按照从左到右的顺序连在一起:

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

1 2
3 4
5 6

>> B = [11 12;13 14;15 16]
B =

11 12
13 14
15 16

>> C = [A B]
C =

1 2 11 12
3 4 13 14
5 6 15 16

将两个列数相等的向量按照从上到下的顺序连在一起:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
>> A
A =

1 2
3 4
5 6

>> B
B =

11 12
13 14
15 16

>> C = [A;B]
C =

1 2
3 4
5 6
11 12
13 14
15 16

对数据进行运算

矩阵乘法

矩阵的乘法:

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

1 2
3 4
5 6

>> C = [1 1; 2 2]
C =

1 1
2 2

>> A*C
ans =

5 5
11 11
17 17

点乘操作

让两个矩阵中的每个对应位置的元素相乘(点乘操作):

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

1 2
3 4
5 6

>> B = [11 12; 13 14; 15 16]
B =

11 12
13 14
15 16

>> A.*B
ans =

11 24
39 56
75 96

对每个元素求平方

对矩阵$A$中的每个元素求平方:

1
2
3
4
5
6
>> A .^ 2
ans =

1 4
9 16
25 36

对每个元素求倒数

对矩阵中每个元素求倒数:

1
2
3
4
5
6
7
8
9
10
11
12
13
>> v = [1; 2; 3]
v =

1
2
3

>> 1 ./ v
ans =

1.00000
0.50000
0.33333

这里的.符号,表示对每个元素分别进行运算

对每个元素求对数

对每个元素求对数:

1
2
3
4
5
6
>> log(v)
ans =

0.00000
0.69315
1.09861

自然数e的幂次运算

以$e$为底,以每个元素为幂的运算:

1
2
3
4
5
6
>> exp(v)
ans =

2.7183
7.3891
20.0855

对每个元素求绝对值

对所有元素求绝对值:

1
2
3
4
5
6
>> abs([-1; 2; -3])
ans =

1
2
3

求相反数运算

1
2
3
4
5
6
>> -v
ans =

-1
-2
-3

其实就相当于-1 * v

对向量每个元素自增1

1
2
3
4
5
>> v + 1
ans =
2
3
4

矩阵的转置

1
2
3
4
5
6
7
8
9
>> A
A =
1 2
3 4
5 6
>> A'
ans =
1 3 5
2 4 6

获取像向量中的最大元素

1
2
3
4
5
6
7
>> a = [1 15 2 0.5]
a =

1.00000 15.00000 2.00000 0.50000

>> val = max(a)
val = 15

也可以获取最大元素的索引:

1
2
3
>> [val, ind] = max(a)
val = 15
ind = 2

值得注意的是,如果这里不是向量,而是矩阵,那么将得到每一列的最大值

1
2
3
4
5
6
7
8
9
10
11
>> D = [1 5;2 4; 3 3]
D =

1 5
2 4
3 3

>> max(D)
ans =

3 5

判断矩阵中每个元素是否满足某条件

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

1.00000 15.00000 2.00000 0.50000

>> a < 3
ans =

1 0 1 1

这里1代表真,0代表假

获取魔幻方阵(magic squares)

魔幻方阵,指的是矩阵的所有的行、列、以及对角线元素的和,都相等的矩阵。

1
2
3
4
5
6
>> A = magic(3)
A =

8 1 6
3 5 7
4 9 2

找出矩阵中满足某条件元素的索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>> A
A =

8 1 6
3 5 7
4 9 2

>> [r,c] = find(A >= 7)
r =

1
3
2

c =

1
2
3

其中r是所在行的索引,c是所在列的索引。

比如:元素(1,1)(3,2)(2,3)

求和函数

将矩阵中所有元素求和:

1
2
3
4
5
6
7
>> a
a =

1.00000 15.00000 2.00000 0.50000

>> sum(a)
ans = 18.500

求积函数

将矩阵中所有元素求积:

1
2
3
4
5
6
7
>> a
a =

1.00000 15.00000 2.00000 0.50000

>> prod(a)
ans = 15

四舍五入

向下四舍五入:

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

1.00000 15.00000 2.00000 0.50000

>> floor(a)
ans =

1 15 2 0

向上四舍五入:

1
2
3
4
>> ceil(a)
ans =

1 15 2 1

max函数

分别取两个矩阵中对应位置较大的一个元素,组成新矩阵:

1
2
3
4
5
6
>> max(rand(3),rand(3))
ans =

0.53967 0.79306 0.62026
0.90069 0.70636 0.55156
0.98940 0.68021 0.85094

获取一个矩阵中每一列最大的元素组成的向量:

1
2
3
4
5
6
7
8
9
10
11
>> A
A =

8 1 6
3 5 7
4 9 2

>> max(A,[],1)
ans =

8 9 7

获取矩阵每一行的最大值:

1
2
3
4
5
6
>> max(A,[],2)
ans =

8
7
9

找出矩阵$A$中最大元素的两种方法:

1
2
3
4
>> max(max(A))
ans = 9
>> max(A(:))
ans = 9

对矩阵的每一行(列)求和

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

47 58 69 80 1 12 23 34 45
57 68 79 9 11 22 33 44 46
67 78 8 10 21 32 43 54 56
77 7 18 20 31 42 53 55 66
6 17 19 30 41 52 63 65 76
16 27 29 40 51 62 64 75 5
26 28 39 50 61 72 74 4 15
36 38 49 60 71 73 3 14 25
37 48 59 70 81 2 13 24 35

>> sum(A,1)
ans =

369 369 369 369 369 369 369 369 369

>> sum(A,2)
ans =

369
369
369
369
369
369
369
369
369

求$A$的对角线元素的和:

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

47 58 69 80 1 12 23 34 45
57 68 79 9 11 22 33 44 46
67 78 8 10 21 32 43 54 56
77 7 18 20 31 42 53 55 66
6 17 19 30 41 52 63 65 76
16 27 29 40 51 62 64 75 5
26 28 39 50 61 72 74 4 15
36 38 49 60 71 73 3 14 25
37 48 59 70 81 2 13 24 35

>> eye(9)
ans =

Diagonal Matrix

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

>> A.*eye(9)
ans =

47 0 0 0 0 0 0 0 0
0 68 0 0 0 0 0 0 0
0 0 8 0 0 0 0 0 0
0 0 0 20 0 0 0 0 0
0 0 0 0 41 0 0 0 0
0 0 0 0 0 62 0 0 0
0 0 0 0 0 0 74 0 0
0 0 0 0 0 0 0 14 0
0 0 0 0 0 0 0 0 35

>> sum(sum(A.*eye(9)))
ans = 369

将矩阵上下翻转

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

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

求逆矩阵

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
>> A = magic(3)
A =

8 1 6
3 5 7
4 9 2

>> temp = pinv(A)
temp =

0.147222 -0.144444 0.063889
-0.061111 0.022222 0.105556
-0.019444 0.188889 -0.102778

>> temp * A
ans =

1.00000 0.00000 -0.00000
-0.00000 1.00000 0.00000
0.00000 0.00000 1.00000

实际上,这里的pinv()函数求得的是伪逆矩阵。

数据可视化

绘制正弦余弦函数

绘制一个正弦函数:

1
2
3
>> t=[0:0.01:0.98];	% 生成一个0到0.98的等差数列,差值为0.01
>> y1 = sin(8*pi*t)
>> plot(t,y1);

同理,可以绘制余弦图:

1
2
>> y2 = cos(8*pi*t);
>> plot(t,y2)

这样会覆盖掉之前的图,得到新的图:

{& asset_img 04.png %}

如果我们想将两个图重叠在一起绘制,可以使用hold on命令:

1
2
3
>> plot(t,y1);
>> hold on
>> plot(t,y2,'r'); % 这里第三个参数'r'代表颜色为红色

图的标记

可以用以下命令来对图进行标记:

1
2
3
4
>> xlabel('time')	%	标记x坐标
>> ylabel('value') % 标记y坐标
>> legend('sin','cos') % 标记图例
>> title('my plot') % 标记标题

图片的保存于删除

将图片保存在Octave所在目录。可能会花费一些时间

1
2
3
>> print -dpng 'myPlot.png'
warning: print.m: fig2dev binary is not available.
Some output formats are not available.

这里其实可以保存多种格式,可以查看help来了解。

如果想删除这个文件,直接输入close即可。

1
>> close

这样就会关闭视图窗口,并且删除刚才生成的文件。

为图像标号

可以通过figure函数对图像进行标号:

1
>> figure(1);plot(t,y1);

使用subplot将图像分割显示

subplot函数接受三个参数,前两个参数代表获取一个a × b格子,第三个参数代表当前使用的格子的索引。

1
>> subplot(1,2,1); % 将图像划分成1×2的格子,并且使用第一个格子

如果这个时候输入:

1
>> plot(t,y1);

那么将会绘制在第一个格子里:

同理,我们可以通过以下命令,将y2绘制在第二个格子里:

1
2
>> subplot(1,2,2);
>> plot(t,y2);

另外,可以使用axis函数,来改变当前图像的刻度:

1
>> axis([0.5 1 -1 1])	% 将x轴的范围调整到0.5到1之间,y轴的范围调整到-1到1之间

可以看到y2对应的图刻度发生了改变:

如果想清空图像,可以使用clf

1
>> clf;

矩阵的可视化

通过imagesc函数,将矩阵绘制出来,其中一种颜色代表一种数值。

1
2
3
4
5
6
7
8
9
10
>> 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

>> imagesc(A)

设置用来显示的颜色:

1
>> imagesc(A), colorbar, colormap gray;

这里其实相当于连续输入了三条命令。

可以看到,颜色变为了灰色,并且颜色对应的数值范围也在右侧列出:

控制语句:for, while, if符号的使用

for语句的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
>> v = zeros(10,1)
v =

0
0
0
0
0
0
0
0
0
0

>> for i=1:10,
> v(i) = 2^i;
> end;
>> v
v =

2
4
8
16
32
64
128
256
512
1024

也可以通过for来访问一个索引序列:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>> indices=1:10;
>> indices
indices =

1 2 3 4 5 6 7 8 9 10

>> for i=indices,
> disp(i);
> end;
1
2
3
4
5
6
7
8
9
10

while的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
>> v
v =

2
4
8
16
32
64
128
256
512
1024

>> i = 1;
>> while i <= 5,
> v(i) = 100;
> i = i+1;
> end;
>> v
v =

100
100
100
100
100
64
128
256
512
1024

if以及break的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
>> v
v =

100
100
100
100
100
64
128
256
512
1024

>> i=1;
>> while true,
> v(i) = 999;
> i = i+1;
> if i == 6,
> break;
> end;
> end;
>> v
v =

999
999
999
999
999
64
128
256
512
1024

else的使用

1
2
3
4
5
6
7
8
9
10
11
>> v(1)
ans = 2
>> v(1)=2;
>> if v(1)==1,
> disp('The value is one');
> elseif v(1) == 2,
> disp('The value is two');
> else
> disp('The value is not one or two.');
> end;
The value is two

退出Octave

退出Octave只需输入:

1
>> exit

或者

1
>> quit

函数

函数的定义以及调用

在当前Octave的目录下创建一个文件squareThisNumber.m

内容如下:

1
2
function y = squareThisNumber(x)
y = x^2;

在当前目录下就可以直接使用这个函数了:

1
2
>> squareThisNumber(5)
ans = 25

这里y是函数squareThisNumber的返回值,函数体是y = x^2;,参数是x
如果想要正常使用这个函数,必须把这个函数所在的文件放到当前目录下。

添加搜索路径

如果你想在其他目录下也正常的使用这个函数,那么你需要将这个文件路径添加到Octave的搜索路径下(addpath):

1
2
3
4
5
6
>> addpath('/Users/jing1/Desktop')
>> cd ~
>> pwd
ans = /Users/jing1
>> squareThisNumber(5)
ans = 25

多个返回值

Octave的函数有一个其他大多数语言不具备的一个特性,就是允许返回多个参数。

例如:

1
2
3
4
function [y1,y2] = squareAndCubeThisNumber(x)

y1 = x^2;
y2 = x^3;

可以看到函数squareAndCubeThisNumber返回两个值,分别为y1y2

使用这个函数:

1
2
3
4
5
>> [a,b] = squareAndCubeThisNumber(5);
>> a
a = 25
>> b
b = 125