主要内容：

1. 变量基本语法介绍
2. 数值及其格式
3. 向量
4. 矩阵

一、 变量基本语法介绍

• 与很多高级语言不同，Octave中的变量的类型是不用声明的。

• Octave 所有的变量都是浮点型或者字符串

• ans 即为Octave中的一个变量，用于存储每次最近运算的结果，这个变量可以想普通变量一样使用

• Octave 中的变量名区分大小写

• Octave本身已经定义了一些变量，如 pi , sin，cos ,i,j 等，Octave允许逆重更新定义这些内置变量，但是不提倡

• 若需要查看某个变量的值，输入其变量名并回车即可；若想要查看当前命令名或者使用的函数名和变量名，输入 who命令

• 若想要从当前的变量空间中删除某个变量，clear命令能移除所有的变量，clear name 移除名为 name 的某个变量

  >> deg = pi/180
  deg = 0.017453
  >> 3
  ans = 3
  >> new = 2 *ans
  new = 6
  >>new
  new = 6
  >>who
  Variables visible from the current scope:
  
  ans  deg  new
  
  >>clear deg
  >>who
  Variables visible from the current scope:
  
  ans   new
  
  >>clear
  >>who
  >>
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22

二、 数值及其格式

• Octave中的数值，和计算机中存储的数值一样，事宜二进制的形式二不是以十进制的形式存储的

• Octave通常只显示一定的有效数字，format 命令能选择数值显示的不同方式，

  • format long 将让 octave 以 15 位的有效数字显示数值，这也是 octave 程序本身的计算精度。
  • format short将让 octave 以默认的方式显示数值

• Octave 使用科学记数法来表达数值很大或者很小的数字，例如 13142*.6 = 1.*31426 × 104, 而在 Octave 中 这个科学数值被显示为 1.3143e+04，这样的数值输入形式也同样能被 Octave 认可

• 能被 Octave 识别并计算的数据形式还有：

  • 复数 (e.g.3+4i), 能完全被 Octave 识别
  • 无穷大 (Inf) 一个数除以 0 得到的结果。
  • 非数值 (NaN) 0 除以 0 得到的结果。同样是其他数学表达式无法得到合法结果时的返回值。
    • 注意：Inf 和 NaN 可以向其他类型的数据一样参与运算，当然得到的结果通常还是 Inf 或者 NaN。

  >> deg = pi/180
  deg = 0.017453
  >> format long
  >> deg
  deg = 1.745329251994330e-02
  >>format short
  >>deg
  deg = 0.017453
  >> 3+4i
  ans = 3 + 4i
  >> 3/0
  ans = Inf
  >>0/0
  ans = NaN
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

三、向量

• 在编程语言中一组数据通常被称为数组 (array)。在 Octave 中

  这样的概念被称为向量 (vector)，而向量本身也是矩阵类数据的一个特例——只有一行或者一列的矩阵分别 为行向量 (· · ·) 或者列向量 (… .)

3.1 构造向量

• 构造矩阵或者向量的方法有很多。其中最直接简单的方法就是在一个方括号 [] 中给出其元素

• 在方括号中由空格或者逗号隔开的一组数据被定义为行向量; 而由分号或者回车隔开的一组数据被定义为列向量

• 可以通过已经定义的向量来定义新的向量

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

3.2 冒号表达式

• 冒号表达式的规则是告诉 octave 创建一个以第一个数字开始并以一递增至第二个数的向量。在第一和第 二个数之间可以插入第三个参数来声明向量中元素之间的递增量，形如 a : b : c。

• 如果向量中的增量不是恰好达到尾数，octave 将产生不超过尾数的一组向量。增量可以是 负数并相应产生有一个递减的向量。

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

3.3 向量构造函数

• 其中 zeros 和 ones 适用于向量和矩阵，而这两个函数的参数，M 和 N，分别指定矩阵的行数和列数

  zeros(2,3)
  ans =
  
     0   0   0
     0   0   0
  
  >> ones(2,3)
  ans =
  
     1   1   1
     1   1   1
  
  >> linspace(1,10,5)
  ans =
  
      1.0000    3.2500    5.5000    7.7500   10.0000
      
  >> logspace(1,2,5)
  ans =
  
      10.000    17.783    31.623    56.234   100.000
  
  >>
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23

3.4 向量中的元素操作

• 向量中的元素通过括号 ()，而第一个元素的编号为 1, 而不是像 C 或者 C++ 那样从 0 开始

• 通过以下命令 v(i) 访问到该向量的第i个元素

• 冒号的表示法同样可以用于声明向量中的元素的范围

  • v(m:n):得到向量中元素编号为[m,n]范围中的所有元素
  • v(m:s:n):得到向量中元素编号为[m,n]范围中每隔s个元素的所有元素

  >> v = [1:2:6 0 -1]
  v =
  
     1   3   5   0  -1
  
  >> v(2)
  ans = 3
  >> v(2:4)
  ans =
  
     3   5   0
  
  >> v(2:2:5)
  ans =
  
     3   0
  
  >>
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18

3.5 向量的计算

• 向量中每个都乘（除）以一个数可以通过对该向量乘（除）以一个数来实现，也可以使用 for 循 环来实现，但是 Octave 向量操作方式更简单

• 使用 +− 算符，你同样可以对该向量中的每个元素都加 上或者减去一个数值。

• 两个向量的相乘遵循矩阵的乘法法则，向量乘法并不并不是对应元素的相乘。如果要进行对应元素的乘除法， 你可以使用* /算符，注意每个算符前的.表示为一个元素对元素的计算

• 逐个元素的乘方计算同样也很有用。该计算的算符为 ^

• 只要两个向量有相同的大小和形状，它们就可以进行元素之间的 加减乘除和乘方运算。

  > a = [1:5]
  a =
  
     1   2   3   4   5
  
  >> a*2
  ans =
  
      2    4    6    8   10
  
  >> a/2
  ans =
  
     0.5000   1.0000   1.5000   2.0000   2.5000
  
  >> b = [2:6]
  b =
  
     2   3   4   5   6
  
  >> a.*b
  ans =
  
      2    6   12   20   30
  
  >> v.+a
  warning: the '.+' operator was deprecated in version 7 and will not be allowed in a future versi
  on of Octave; please use '+' instead
  ans =
  
      3    5    7    9   11
  
  >> a.^2
  ans =
  
      1    4    9   16   25
  
  >> a.^b
  ans =
  
         1       8      81    1024   15625
  
  >>
  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

四、矩阵

• 一个矩阵是由一些列的数字按照一定的行和列排列起来的，并通常用 m × n 来描述一个包含 m 行 n 列的矩阵
• 向量是矩阵的一个特殊例子。

4.1 矩阵的生成

1. 逐行输入，例如下面的A矩阵
2. 使用分号来标定一行的结束，例如下面的B矩阵
3. 可以使用冒号的表示法，例如下面的C矩阵
4. 另一种逐行生成矩阵的方法，例如下面的D矩阵

>> A =[5 7 9
-1 3 -2]
A =

   5   7   9
  -1   3  -2

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

   1   2
   3   4
   5   6

>> C = [1:3;8:-2:4]
C =

   1   2   3
   8   6   4

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

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

4.2 矩阵乘法

• 矩阵乘法必需满足一定的矩阵大小规则，一般地，在矩阵乘法中, 矩阵大小为 (l × m) ∗ (m × n) → (l × n)

• 矩阵的乘法用 * 表示

• 方阵还可以使用矩阵乘方计算

• 其中 A2 = A ∗ A。而对于矩阵中每个元素的相乘，则使用.* 算符。除法和乘方的元素之间的计算以此类推。

  >> A*B
  ans =
  
     71   92
     -2   -2
  
  >> A*C
  error: operator *: nonconformant arguments (op1 is 2x3, op2 is 2x3)
  
  >> A =[1 2;1 2]
  A =
  
     1   2
     1   2
  
  >> A^2
  ans =
  
     3   6
     3   6
  
  >> A =[1 2;1 2]
  A =
  
     1   2
     1   2
  
  >> B = [1 2; 3 4]
  B =
  
     1   2
     3   4
  >> A.*B
  ans =
  
     1   4
     3   8
  
  >>
  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

4.3 矩阵的转置

• 一个向量的转置将其由行向量转为列向量或者由列向量转换为行向量。矩阵的转置将其行和列交换。

• 在 数学上，矩阵 A 的转置表示为 AT。在 octave 中转置操作用上引号 ' 实现

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

4.4 矩阵创建函数

• ones 和 zeros 这两个创建全 1 和 全 0 的矩阵

• 单位矩阵：（除了主对角线上元素为1，其他元素都为0）任何矩阵与该矩阵相乘结果不变。在数学上通常用 I 来表示单位矩阵。Octave 中使用 eye 矩阵来创建单位矩阵，该函数要求一个输入参数

• 对角矩阵：（除了主对角线上元素不为0，其他元素都为0）diag 函数来创建这样的矩阵，输入参数为该对角矩阵的对角元向量:

• diag 的功能很强大，如果对一个矩阵使用该函数，该函数将返回该矩阵的对角元

• 要创建一个空矩阵来向其中添加矩阵元。定义这样的矩阵用方括号实现

  >> A = ones(2,3)
  A =
  
     1   1   1
     1   1   1
  
  >> A = zeros(2,3)
  A =
  
     0   0   0
     0   0   0
  
  >> I = eye(3)
  I =
  
  Diagonal Matrix
  
     1   0   0
     0   1   0
     0   0   1
  
  >> A = diag([1 3 5])
  A =
  
  Diagonal Matrix
  
     1   0   0
     0   3   0
     0   0   5
  
  >> A = [1 2 3;4 5 6;7 8 9]
  A =
  
     1   2   3
     4   5   6
     7   8   9
  
  >> diag(A)
  ans =
  
     1
     5
     9
  
  >> E = []
  E = [](0x0)
  >>
  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
  44
  45
  46
  47

4.5 创建复合矩阵

• 若需要用一些小矩阵来创建一个复合矩阵,你只需要注意各个子矩阵的行列数的匹配。

• >> A = [1 2 3 ;4 5 6]
  A =
  
     1   2   3
     4   5   6
  
  >> B = [2 0;0 -1;1 0]
  B =
  
     2   0
     0  -1
     1   0
  
  >> copm = [eye(3) B;A zeros(2,2)]
  copm =
  
     1   0   0   2   0
     0   1   0   0  -1
     0   0   1   1   0
     1   2   3   0   0
     4   5   6   0   0
  
  >>
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23

4.6 提取矩阵元

• 引用矩阵中的元素与向量中的操作一样，使用括号 ()。对于矩阵，你需要指定其行号和列号

• 其中冒号用来指定元素的的范围，单独使用该符号表示整行或者整列

• 这样的表达式同样可以用于矩阵元的赋值

  >> A = [1:3;4:6;7:9]
  A =
  
     1   2   3
     4   5   6
     7   8   9
  
  >> A(1,1)
  ans = 1
  >> A(2,3)
  ans = 6
  >> A(1:2,3)
  ans =
  
     3
     6
  
  >> A(2,:)
  ans =
  
     4   5   6
  
  >> A(3,2:3)=[-1 0]
  A =
  
     1   2   3
     4   5   6
     7  -1   0
  
  >>
  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

4.7 基本矩阵函数