《GNU_Octave_Beginner_s_Guide》读书笔记2:变量与运算符

《GNU_Octave_Beginner_s_Guide》读书笔记2:变量与运算符


变量
一.简单数字变量：
不明示的情况下，octave解释为实数，双精度浮点。 a=2
变量名由字母，数字，下划线组成，不能以数字开头。
>> 1_a=99
parse error:
  syntax error
用下标访问元素，下标起始值为1.
例：
>> b=[1,9,3];b(2)
ans =  9
>> A=[10 20 30;40 50 60];A(2,3)
ans =  60
取整行或列，用“：”代替。如取A的第二列：A(:,2)，冒号是一个操作数。
元素斌值：
A(2,3) = -10.1
缺省使用format short。
A =
   10.000   20.000   30.000
   40.000   50.000  -10.100
使用format long后：
A =
   10.0000000000000   20.0000000000000   30.0000000000000
   40.0000000000000   50.0000000000000  -10.1000000000000
用一个行向量b代替A的第二行：
A(2,:) = b
标量代替总是没有问题的。
A(:,2)=88
A(:,2)=[]  //删除A的第二列
b=[b 4 5]  //扩展一个行向量
生成子集：
>> d = [2 4 6 8 10 12 14 16 18 20];d(1:2:9)  //下标从1开始，步长为2，直到下标为9，注意在小括号中。
ans =
    2    6   10   14   18
下标的冒号表达： A(开始位：步长：结束位)， 包含首尾，这种表达方式可以方便的完成很多矩阵切分操作。
>> d(3:3:12) = -1  //下标从3开始，步长为3，直到下标为12，但其实总数只有10，所以最后一轮补0，并让第12个元素为-1。
d =
    2    4   -1    8   10   -1   14   16   -1   20    0   -1
二.复杂变量
复数：z =  1 + 2i  //i,j,I,J都可以，但i是标准的。推荐用I.
real(z) //取实部
imag(z)  //取虚部
三.文本变量   
t="text";t(3)  //认为字符串是字母的向量
t(2:4)  //子串，从第二到第四，首尾都包含
t=[t " World"] //扩展
T= ["Hello" ; "George"]  //列向量，也可视为字母矩阵，没对齐尾部系统会加空格
T(2,2)  //访问一个字母
四.高维数组
B(2,2,2)=1;  //（行数，列数，第几个矩阵）
ones(2,3) //定义一个2行3列矩阵，值全为1
A=eye(5)  //定义一个5行5列的单位矩阵
五.结构体structure，概念上类似于C语言；Cell arrays
任务：定义一个structure.
projectile.mass=10.1
projectile.velocity=[1 0 0]
projectile.type="Cannonball" //分别赋值方式
projectile =struct("mass", 10.1, "velocity", [1 0 0],"type", "Cannonball") //直接赋值方式，全部逗号分隔，field名用双引号括起来。
struct是一个函数。
一个struct类形本身可以作为元素。
任务：定义一个array.
s(1) = projectile;
s(2) = projectile; 
s(2).type //drilling down
s(2) = setfield(s(2), "type", "Cartridge");  //setfield,返回一个结构体。
getfield(s(2), "type") //getfield
projectiles = struct("type1", s(1), "type2", s(2)); //结构体嵌套
projectiles.type1.type  //嵌套结构体的访问
Cell arrays：
一个Cell arrays类似于早期java的无泛型容器list，成员可以是数字变量和字符串变量，定义和访问都使用{}。
projectile = {10.1, [1 0 0], "Cannonball"} //定义一个cell array
projectile{2} //访问成员
一个二维的cell array适合用一张无表头的表。
projectiles = {10.1, [1 0 0], "Cannonball"; 1.0, [0 0 0], "Cartridge"}
projectiles{2,3} //访问成员




函数：
信息查询：
whos //列出当前scope的所有变量情况，一共五列
1. Attr：可以是g(globe),p(persistent),没有表示local，默认就是顶层空间，
2. 变量名
3. 长度size: 张量的shape，没有二维用二维表示
4. Bytes: 
5. class:
whos("A") //查一个变量
who //更简单的信息反馈, who与whos("A")连着用更方便 
size("A") //同tensorflow中的shape
rows(A)
columns(A)
>> c=[1.0 2 3];length(c) //当c为向量或string时，length指array长度
ans =  3
>> a=["ab"; "abcdefg"];length(a) //其它情况下(即高维情况下)，指元素最多的那一维的元素个数。
ans =  7
类型判断：(istype函数家族)
isscalar(a)
isvector(b)
ismatrix(b) //vector也是matrix
typeinfo(b)
从当前名字空间中删除变量：
clear A 
clear p*  //删除以p开头的所有变量
clear  //小心，删除所有变量，把系统内置的ans也会删了


生成序列:
两种方式，注意在中括号中：
[开始值：步长：结束值]
b = [-2.1:0.2:0.5]
[开始值：结束值] //步长默认为1
c=[1:9]
如果不知道步长，只知道一节瓜分为几截，用“线性等分向量”linspace(开始，结束，截数);
linspace(-2.1, 0.5, 7)
ones(2,3)  //2*3的全1矩阵
ones(2,3)*6  //2*3的全6矩阵
zeros(1, 4) //1*4的全0矩阵
eye(4) //4*4的单位矩阵


基本算术
向量的加、减、乘、除、右除
a = 2; b=[1 2 3]; c=[1; 2; 3]; A=[1 2 3; 4 5 6];  //b是行向量，c是列向量
规则1：标量 + 行/列向量/高维张量 ---》标量+行/列向量的分量/高维张量
规则2：向量+向量 ---》对应分量相加  //当同为行向量或列向量时，要求shape相同，把标量视为向量除外。
规则3：行向量+列向量 ---》设j属于（1,m）,m为列向量的长度, 拆成“m个行向量+列向量第j个元素”，生成的结果在第j行。
也就是说：n长的行向量+ m长的列向量将生成一个m*n的矩阵！(octave v4.2.1)
2
。）
这点需要注意，在书中的老版本，这是要报错的。
例：
>> b=[1 2 3];c=[1;2;3;4];d=b+c
d =
   2   3   4
   3   4   5
   4   5   6
   5   6   7
在同一行中输入多个命令，使用"；"将抑制响应，使用"，"不会抑制，使用空格直接报错。
规则4：行/列向量+矩阵 ---》向量+矩阵的每一行/列
这点需要注意，在书中的老版本，这是要报错的。
>> A=[1 2 3; 4 5 6];e=[1;2];e+A
ans =
   2   3   4
   6   7   8
规则5：张量*标量--->张量的每个元素*标量
>> A=[1 2 3;4 5 6];b=-1;A*b
ans =
  -1  -2  -3
  -4  -5  -6   
规则6：矩阵*矩阵需符合(n x k)(k x m) = n x m的点积要求，标量除外。没有交换律。
>> A=[1 2; 3 4]; B=[1 2 3; 4 5 6];A*B
ans =
    9   12   15
   19   26   33
元素级操作“.*”，小数点表示元素级操作，可以连接其它操作符。
>>  B=[1 2 3; 4 5 6];B.*B  //B.^2
ans =
    1    4    9
   16   25   36
>> B.+B  //B+B
ans =
    2    4    6
    8   10   12
>>  B=[1 2 3; 4 5 6];B.^B //第二个B的元素作指数
ans =
       1       4      27
     256    3125   46656
错误，非元素级操作：
>> B^2.1
error: for x^A, A must be a square matrix.  Use .^ for elementwise power.
矩阵转置符：单引号‘，在矩阵变量名后跟一个单引号，就转置了该矩阵。单引号是“复共轭转置算子”。
>> C=[1;2;3];c'
ans =
   1   2   3
系统内置了一个虚数单位I。
>> clear
>> who
>> I
ans =  0 + 1i
>> B = [1 2; 3 4] + I.*eye(2)
B =
   1 + 1i   2 + 0i
   3 + 0i   4 + 1i
>> B'                //单引号是“复共轭转置算子”，复数被转置，虚部（复共轭，说得高大上，唉）被反号。在实数的情况下，我们只看到了转置的效果。
ans =
   1 - 1i   3 - 0i
   2 - 0i   4 - 1i
为了看清楚点，
>> B
B =
   1 + 1i   2 + 2i
   3 + 0i   4 + 1i


>> B'
ans =
   1 - 1i   3 - 0i
   2 - 2i   4 - 1i
struct和cell array的运算，能正确引用其成员就没啥问题。
>> s = struct("A", [1 2; 3 4], "x", [1; 2]);s.A*s.x
ans =
    5
   11
>> c = {[1 2; 3 4], [1;2]};c{1}*c{2}
ans =
    5
   11
线性方程组： 矩阵的左除和右除
方程组：
2*x1+x2-3*x3=1
4*x1+2*x2-2*x3=3
-x1+(1/2)*x2-(1/2)=1.5
Ax=y  --》 x=A\y   //左除.指用A的逆矩阵去左乘。
//右除，指用A的逆矩阵去右乘，即 y乘A的逆矩阵，这里没有意义。
A是系数矩阵，
x=[x1;x2;x3]
y=[1; 3; 1.5]
>> A=[2 1 -3; 4 2 -2; -1 0.5 -0.5]; y = [1; 3; 1.5];A\y
ans =
  -0.37500
   2.50000
   0.25000
A/A 《===》A右乘A的逆矩阵，得到单位矩阵。
标量的右除就是普通除法，左除就是分子分母再倒一下。
>> a=2
a =  2
>> 1/a
ans =  0.50000
>> 1\a
ans =  2
-----------------------------------------------------------
>> A=[1 2;3 4];2./A  
ans =
   2.00000   1.00000
   0.66667   0.50000
>> A=[1 2;3 4];2.\A  //等价于 A*0.5或A./2
ans =
   0.50000   1.00000
   1.50000   2.00000
>> A.\2  
ans =
   2.00000   1.00000
   0.66667   0.50000
我们居然得到如下规律： 2./A  《===》 A.\2
                       2.\A  《===》 A./2   //这难道是传说中的对称美？hold on，我有点晕：）
-------------------------------------------------------------
  
复数的操作：
>> z = 1 + 2I; w = 2 -3I;z + w
ans =  3 - 1i
>> z = 1 + 2I; w = 2 -3I;z - w
ans = -1 + 5i
>> z = 1 + 2I; w = 2 -3I;z * w  //二项式展开，没有意外
ans =  8 + 1i
>> z = 1 + 2I; w = 2 -3I;z / w
ans = -0.30769 + 0.53846i
>> z = 1 + 2I; w = 2 -3I;w \ z  //看来在复数上或矩阵上这一招都有用
ans = -0.30769 + 0.53846i


比较操作符：
>> A(2,1)
ans =  4
>> A(2,1)==1  //判等运算符
ans = 0      //假
>> A(2,1)==4
ans = 1      //真
其它：>,<,>=,<=,!=(或~=，也是不等于)，
相似按元素级比较，形成bool矩阵。
>> A=[2 1 -3; 4 -2 -2; -1 0.5 -0.5];A(:,1)>=[2;2;0]
ans =
  1
  1
  0
>> A
A =
   2.00000   1.00000  -3.00000
   4.00000  -2.00000  -2.00000
  -1.00000   0.50000  -0.50000
>> A>ones(3)
ans =
  1  0  0
  1  0  0
  0  0  0
>> "hello"=="helloo" //长度不同的字符串不能用==比较，得用strcmp().
error: mx_el_eq: nonconformant arguments (op1 is 1x5, op2 is 1x6)
>> strcmp("hello", "helloo") //用strcmp比较不等长字符串
ans = 0
>> "hello"=="henno" //用==比较等长字符串，得到bool矩阵。
ans =
  1  1  0  0  1
小知识：bool来源于英国数学家George Boole的名字。
运算符优先级：
()  //括号
.^  //元素级指数运算
' .'  //转置类， .'和'是一个意思。
/\*   //乘除类
+-     //加减类
== > < >= <= != ~=  //比较类
>> A=[1 2;3 4];A.'==A'
ans =
  1  1
  1  1
优先级与数学常见的差不多，但验证就不那多直接了，矩阵运算不象标量那么直接。不确定时仍然用括号。
总的来讲，矩阵的运算在合不合法上就是一个大坑，稍微复杂一点，就不大容易一眼看出来，不如直接在系统中验证下。
求矩阵A的逆矩阵：inv(A)
>> A
A =
   1   2   3
   4   5   6
   7   8   9
>> inv(A)
warning: matrix singular to machine precision, rcond = 1.54198e-018
ans =
  -4.5036e+015  9.0072e+015  -4.5036e+015
  9.0072e+015  -1.8014e+016  9.0072e+015
  -4.5036e+015  9.0072e+015  -4.5036e+015


minimum norm solution：最小范数解
一个三元一次方程组，系数矩阵A，计算rank(A),如果rank=2,而不是rank=3，说明有两个方程是依赖的，有多解而不是唯一解。
此时系统给出的是最小范数解。