精华内容
下载资源
问答
  • Octave入门教程

    2018-03-15 17:28:13
    吴恩达《机器学习》课程制定工具Octave入门教程 吴恩达《机器学习》课程制定工具Octave入门教程
  • Octave 入门教程(莫及)

    2016-07-10 10:31:04
    莫及编写的Octave 入门教程 pdf
  • octave入门教程(一)

    2021-03-01 21:43:51
    序:最近在看吴恩达老师的机器学习入门教程,由于老师的力荐,因此决定学习octave作为练习语言,在此作为入门教程帮助同样在学习octave语言的初学者,同时也作为备忘录供自己复习。 安装完octave后,会有一个类似于...

    序:最近在看吴恩达老师的机器学习入门教程,由于老师的力荐,因此决定学习octave作为练习语言,在此作为入门教程帮助同样在学习octave语言的初学者,同时也作为备忘录供自己复习。

    安装完octave后,会有一个类似于cmd的命令行窗口,我们可以在此练习octave基础语法。
    在这里插入图片描述
    基础语法

    1. 加减乘除
      在这里插入图片描述
    2. 逻辑运算
      在这里插入图片描述
      % 为注释
    3. 变量赋值与显示
      在这里插入图片描述
    4. 矩阵、行向量、列向量、单位矩阵生成
      在这里插入图片描述
    5. 随机数、初始化矩阵
      在这里插入图片描述
    6. 简单绘图展示数据
      在这里插入图片描述
    展开全文
  • Octave 入门教程:向量

    千次阅读 2018-10-24 17:01:28
    本内容将介绍 Octave 中的向量的创建、引用及相关运算。

    Octave 入门教程目录,请点击: https://blog.csdn.net/benzhujie1245com/article/details/83146777



      本内容将介绍 Octave 中的向量的创建、引用及相关运算。

    一、向量

    1.1 创建向量

      向量分为行向量和列向量,其创建方法如下:

    输入方法描述
    行向量[ a 1 , a 2 , ⋯   , a n a_1, a_2, \cdots, a_n a1,a2,,an]将元素使用方括号括起来,使用空格或者逗号分隔元素。
    列向量[ a 1 ; a 2 ; ⋯   ; a n a_1;a_2;\cdots;a_n a1;a2;;an]将元素使用方括号括起来,使用分号分隔元素。

      例如:

    >>a1 = [1, 2, 3, 4, 5, 6, 7, 8]
    a1 =
    
       1   2   3   4   5   6   7   8
    
    >>a2 = [1; 2; 3; 4; 5; 6; 7; 8]
    a2 =
    
       1
       2
       3
       4
       5
       6
       7
       8
    
    >>
    

    1.2 创建等差元素向量

      当我们需要创建一个等差元素的向量时,我们可以采用上面的直接输入法进行创建。但是当元素数量很多时,会很麻烦。
      假如需要创建一个向量 v,其第一个元素为 s,最后一个元素为 e,元素之间的差异是 step,可以通过以下方法创建:

    v = [s: step: e]
    

      例如:

    >> a = [1: 2 : 9]
    a =
    
       1   3   5   7   9
    
    >>
    

    1.3 引用向量的元素

      可以通过多种方式来引用向量的一个或多个元素,具体方法如下:

    方法描述
    a(i)引用向量 a 的第 i 个元素(索引值从 1 开始)
    a(: )引用向量 a 中的所有元素
    a(m:n)引用向量 a 的第 m 到 n 个元素(索引值从 1 开始)

      例如:

    >>a1 = [1, 2, 3, 4, 5, 6, 7, 8];
    >>a2 = [1; 2; 3; 4; 5; 6; 7; 8];
    >>a1(2)   % 输出向量 a1 的第 2 个元素
    ans =  2
    >>a2(6)   % 输出向量 a2 的第 6 个元素
    ans =  6
    >>a1(:)   % 输出向量 a1 的所有元素
    ans =
    
       1
       2
       3
       4
       5
       6
       7
       8
    
    >>a2(3:6)  % 输出向量 a2 的第 3 到 6 个元素
    ans =
    
       3
       4
       5
       6
    
    >>
    

    1.4 向量运算

    1.4.1 向量的加减法

      当两个向量进行加减法时,这两个向量的元素必须有相同的类型和数量。向量加减法产生相同类型的新向量,原始向量的每个元素逐一进行加减法。
      例如:

    >>a = [6, 9, 7, 10];
    >>b = [2, 3, 6, 9];
    >>c = a + b;
    >>d = a - b;
    >>disp(c)
        8   12   13   19
    >>disp(d)
       4   6   1   1
    >>
    
    1.4.2 标量向量乘法

      将一个数字乘以一个标量,这称为标量乘法。标量乘法产生相同类型的新向量,原始向量的每个元素乘以数字。
      例如:

    >>a = [6, 9, 7, 10];
    >>b = 5 * a
    b =
    
       30   45   35   50
    
    >>
    
    1.4.3 转置向量

      转置操作时将列向量更改为行向量,反之亦然。转置操作由单引号(')表示。

    1.4.4 附加向量

      Octave 允许将多个向量附加在一起从而创建新的向量。
      假设存在两个行向量 r1(有 m 个元素) 和 r2(有 n 个元素),可以通过以下附加操作创建一个拥有 m+n 个元素的行向量 r:

    v = [v1, v2]
    

      如果上面的 m = n(即行向量 r1 和 r2 拥有相同数量的元素),可以通过以下附加操作,创建一个 2*m 的矩阵 rMatrix:

    v = [v1; v2]
    

      假设存在两个列向量 c1(有 m 个元素)和 c2(有 n 个元素),可以通过以下附加操作创建一个拥有 m+n 个元素的列向量 c:

    v = [v1; v2]
    

      如果上面的 m = n(即列向量 c1 和 c2 拥有相同数量的元素),可以通过以下附加操作创建一个拥有 m*2 的矩阵 cMatrix:

    v = [v1; v2]
    

      例如:

    >> v1 = [1, 2, 3, 4];
    >> v2 = [5, 6, 7, 8];
    >> v = [v1, v2]
    v =
    
       1   2   3   4   5   6   7   8
    
    >> v = [v1; v2]
    v =
    
       1   2   3   4
       5   6   7   8
    
    >> v3 = [1; 2; 3; 4];
    >> v4 = [5; 6; 7; 8];
    >> v = [v3; v4]
    v =
    
       1
       2
       3
       4
       5
       6
       7
       8
    
    >> v = [v3, v4]
    v =
    
       1   5
       2   6
       3   7
       4   8
    
    >>
    
    1.4.5 向量的模

      假设向量 V V V 拥有 v 1 , v 2 , ⋯   , v n v_1, v_2,\cdots,v_n v1,v2,,vn 元素,其模由以下公式求出:
    ∣ V ∣ = ( v 1 2 + v 2 2 + ⋯ + v n 2 ) |V|=\sqrt{(v_1^2+v_2^2+\cdots+v_n^2)} V=(v12+v22++vn2)
      在 Octave 中按照以下步骤求向量的模:

    • 使用数组乘法(.*)得到向量 sv(向量 sv 的元素是向量 v 的元素的平方),即 sv = v.*v
    • 使用 sum 函数得到向量 v 的元素的平方和,即向量 v 的点积。
    • 使用 sqrt 函数得到和的平方根,即向量的模。

      例如:

    >> v = [1, 2, 3, 4];
    >> sv = v.*v;
    >> dp = sum(sv);
    >> mag = sqrt(dp) % 实际上 dp 的值就是 v1 和 v1 的点积,可以通过下面的 dot 函数获取
    mag =  5.4772
    >>
    
    1.4.6 向量点积

      两个向量 a = [ a 1 , a 2 , ⋯   , a n ] a=[a_1,a_2,\cdots,a_n] a=[a1,a2,,an] b = [ b 1 , b 2 , ⋯   , b n ] b=[b_1,b_2,\cdots,b_n] b=[b1,b2,,bn] 的点积由以下公式求出:
    a . b = ∑ i = 1 n ( a i × b i ) a.b=\sum_{i=1}^{n}(a_i\times b_i) a.b=i=1n(ai×bi)
      在 Octave 中,通过 dot 求两个向量的点积,使用语法如下:

    dot(a, b)
    

      例如:

    >> v1 = [1, 2, 3];
    >> v2 = [2, 3, 4];
    >> dot(v1, v2)
    ans =  20
    

    参考:
    [1] https://www.w3cschool.cn/matlab/
    [2] http://m.yiibai.com/matlab/

    展开全文
  • Octave入门

    万次阅读 2014-03-21 00:35:06
    总而言之,octave在运算符方面彻底兼容MatLab,MatLab用户放心大胆地用octave吧,但octave用户用MatLab的时候就要小心了。 C-风格的自动增量、赋值、屏幕打印 Octave允许C-风格的 i++ ; ++i ; i+=1 ; ...

    作者:于江生(北京大学计算机系)

    声明:允许未经作者的同意进行非商业目的的转载,但必须保持原文的完整性。


    实话实说,MatLab是迄今为止矩阵计算最强大的工具(没有之一)。可惜MatLab是商用的,一般个体还真买不起。MatLab的Windows版本比Linux版本要好些,这让我不敢轻易断言Windows一无是处,毕竟其下有MatLab这样强悍的软件。以前在Windows下工作,MatLab一直是我的首选矩阵计算工具,在统计计算工具S-PLUS出现之前,人们快乐地用着MatLab简陋的统计工具箱。后来有了R,它彻底地坐稳了统计计算的头把交椅,MatLab似乎也无意去争夺全料冠军,但事实上它在很多方面都做得无可挑剔。这让我们这些买不起却很需要MatLab的穷人感慨不已,MatLab如果是免费的该多好……

    为何选择使用octave?

    SciLab和octave是开源的且免费的矩阵计算工具,二者都有希望成为矩阵计算的新宠。相比之下,

    • octave与MatLab的兼容性更高。
    • octave遵循GPL协议(GNU General Public License),用户可以单独发行octave或者包含在其产品中发行。而scilab则不允许,你只能免费地使用它。
    • octave没有图形界面,是命令交互的。在某些人眼里这是不可饶恕的缺点,而在另外一些人眼里则是大大的优点。

    它们都具备以下特点:以矩阵为基本数据类型,内置支持复数,有内置函数和外部函数库,用户自定义函数的可扩展性等特点。UNIX的很多用户选择使用octave,看中的就是它与MatLab兼容性好这一事实。随着开源运动的深入人心,octave不断地发展壮大,它会吸引一大批MatLab的使用者。

    GNU octave网站:http://www.octave.org/

    好习惯从头开始:

    • 首先学会使用help,搞不定再到网上查,最后才求人。
    • 学习octave的捷径:读octave的函数源码
    • 每个命令都以“;”结束,否则矩阵的具体内容会显示出来。
    • 学会适当地使用内置命令clear,从内存中清除一些无用数据或变元。
    • 如果没有必要,不要轻易改变矩阵大小。
    • 重要的中间结果要保存。

    导入文件

    octave和MatLab一样用load导入数据文件,譬如

    octave>  A = load data.txt ;
    
    将把data.txt里的数据导入octave并赋给矩阵 A。对于图像文件,octave用imread将图像导入并存为矩阵img,
    img = imread("jam.jpg") ;
    

    在octave里显示图像很简单,用命令:

    imshow(img) ;
    

    除了jpeg和png格式的图像可以直接导入,其他格式的图像必须经过ImageMagick的convert函数转换后才可读入。ImageMagick是命令行的强大的图像处理工具,convert几乎涵盖了所有格式图像的转换。

    如果你关心imread函数的源码,可以去读 /usr/local/share/octave/packages/image-1.0.8/imread.m,该函数把灰度图像导入为MxN矩阵,把彩色图像导入为MxNx3矩阵。具体的帮助文件,可以

    help imread ;
    
    或者来个更详细点儿的
    help -i imread ;
    

    Octave与MatLab的一些小区别

    MatLab用户转而使用octave几乎不需要什么培训,只是要一些小细节上注意一下。下面我们罗列一些octave和MatLab的区别。

    布尔值的乘积

    X = ones(2,2) ;
    prod(size(X)==1)
    
    MatLab和octave的输出是不同的:
    Matlab: ??? Function 'prod' is not defined for values of class 'logical'.
    Octave: ans = 0
    
    octave输出为0的原因是 size(X) 为
    ans =
    
       2   2
    

    逻辑运算符、算术运算符

    Octave与MatLab兼容,甚至更为宽松。如,

    运算Matlaboctave
    |“|” 或者“||”
    && 或者 &&
    ~=~= 或者 !=

    MatLab用 x^2,octave用 x^2 或者 x**2 表示 “x的平方”。Octave用 x**2 是为了照顾GnuPlot的用户。总而言之,octave在运算符方面彻底兼容MatLab,MatLab用户放心大胆地用octave吧,但octave用户用MatLab的时候就要小心了。

    C-风格的自动增量、赋值、屏幕打印

    Octave允许C-风格的

    i++ ; ++i ; i+=1 ;
    printf('My result is: %d\n', 4)
    
    而MatLab不认它们。MatLab打印至屏幕和文件都用 fprintf 函数。

    注意空格

    octave对空格是作为一个符号识别的,在列合并中短的列自然扩充,例如

    A = ['123 ';'123'] ;
    size(A)
    
    的结果是 2 4,而MatLab则返回列合并有问题:
    ?? Error using ==> vertcat
    

    另外,转置符号与矩阵之间如果有空格

    [0 1] '
    
    在MatLab里不允许,octave则允许,且与 [0 1]' 的结果是一样的。

    直方图内置函数hist

    octave的hist为

    hist (Y, X, NORM)
    
    其中NORM为所有柱高之和。

    导入空文件

    MatLab允许导入空文件,老版本的octave不允许,新版本的octave-3.0.3则允许。

    行续符

    MatLab中用 `...' 做行续符,如用

    A = rand (1, ...
             2) ;
    
    表达
    A = rand (1,2) ;
    
    Octave与MatLab兼容,除此之外,octave还允许如下两种表示方法。
    A = rand (1,
            2) ;
    
    A = rand (1, \
            2) ;
    

    if、for等环境的结束符

    Octave用

    end{if,for, ...}
    
    而MatLab则统一用 end。

    R和octave命令的对照表

    octave和R联合起来用的时候,我们需要下面的命令对照表帮助我们理清楚它们的区别。“无”仅仅是说没有一个命令行的简单表示,并不代表不能表示。这种对比不是比较谁更强大,而是为了记忆,无论是对R用户学习octave或者octave用户学习R,都是有所裨益的。

    octaveR
      
    帮助 
    help -ihelp.start()
    helphelp(help)
    help sorthelp(sort)
     demo()
    lookfor plotapropros('plot')
     help.search('plot')
    复数 
    3+4i3+4i
    i1i % R把"i"视为变量名
    abs(3+4i)Mod(3+4i)
    arg(3+4i)Arg(3+4i)
    conj(3+4i)Conj(3+4i)
    real(3+4i)Re(3+4i)
    imag(3+4i)Im(3+4i)
      
    向量、序列 
    1:101:10 或 seq(10)
    1:3:10seq(1,10,by=3)
    10:-1:110:1
    10:-3:1seq(from=10,to=1,by= -3)
    linspace(1,10,7)seq(1,10,length=7)
    (1:10)+i1:10+1i
    a=[2 3 4 5]; # 不显示结果a <- c(2,3,4,5) % 不用加分号
    a=[2 3 4 5] #显示结果(a <- c(2,3,4,5)) % 显示结果
    adash=[2 3 4 5]' ;adash <- t(c(2,3,4,5))
    [a a]c(a,a)
    [a a*3]c(a,a*3)
    a.*aa*a
    a.^3a^3
      
    向量的合并与重复 
    [1:4 a]c(1:4,a)
    [1:4 1:4]rep(1:4,2)
    rep(1:4,1:4) % 结果是:1 2 2 3 3 3 4 4 4 4
    rep(1:4,each=3) % 结果是:1 1 1 2 2 2 3 3 3 4 4 4
    a=1:100;a <- 1:100
    a(2:100)a[-1] % a 去掉第1个元素
    a([1:9 11:100])a[-10] % a 去掉第10个元素
    a[-seq(1,50,3)] % a 去掉第1,4,7,...个元素
      
    向量的赋值 
    a(a>90)= -44;a[a>90] <- -44
      
    向量的最大、最小 
    a=randn(1,4);a <- rnorm(4)
    b=randn(1,4);b <- rnorm(4)
    max(a,b)pmax(a,b)
    max([a' b'])cbind(max(a),max(b))
    max([a b])max(a,b)
    [m i] = max(a)m <- max(a) ; i <- which.max(a)
    "min" 类似 
      
    向量的秩 
    ranks(rnorm(8,1))rank(rnorm(8))
    ranks(rnorm(randn(5,6)))apply(matrix(rnorm(30),6),2,rank)
      
    矩阵的行合并与列合并 
    [1:4 ; 1:4]rbind(1:4,1:4)
    [1:4 ; 1:4]'cbind(1:4,1:4) 或 t(rbind(1:4,1:4))
    [2 3 4 5]c(2,3,4,5)
    [2 3;4 5]rbind(c(2,3),c(4,5)) % rbind() 合并行; cbind() 合并列
    [2 3;4 5]'cbind(c(2,3),c(4,5)) 或 matrix(2:5,2,2)
    a=[5 6];a <- c(5,6)
    b=[a a;a a];b <- rbind(c(a,a),c(a,a))
    [1:3 1:3 1:3 ; 1:9]rbind(1:3, 1:9)
    [1:3 1:3 1:3 ; 1:9]'cbind(1:3, 1:9)
    rbind(1:3, 1:8)
      
    产生矩阵 
    ones(4,7)matrix(1,4,7) 或 array(1,c(4,7))
    ones(4,7)*9matrix(9,4,7) 或 array(9,c(4,7))
    eye(3)diag(1,3) % 对角线都为1的对角阵
    diag([4 5 6])diag(c(4,5,6)) % 对角线为4,5,6的对角阵
    diag(1:10,3)
    reshape(1:6,2,3)matrix(1:6,nrow=2) 或 array(1:6,c(2,3))
    reshape(1:6,3,2)matrix(1:6,ncol=2) 或 array(1:6,c(3,2))
    reshape(1:6,3,2)'matrix(1:6,nrow=2,byrow=T)
    a=reshape(1:36,6,6);a <- matrix(1:36,c(6,6))
    rem(a,5)a %% 5
    a(rem(a,5)==1)= -999a[a%%5==1] <- -999
    a(:)as.vector(a)
      
    矩阵中抽取元素 
    a=reshape(1:12,3,4);a <- matrix(1:12,nrow=3)
    a(2,3)a[2,3]
    a(2,:)a[2, ]
    a(2:3,:)a[-1,]
    a(:,[1 3 4])a[,-2]
    a(:,1)a[ ,1]
    a(:,2:4)a[ ,-1]
    a([1 3],[1 2 4])a[-2,-3]
      
    矩阵赋值 
    a(:,1) = 99a[ ,1] <- 99
    a(:,1) = [99 98 97]'a[ ,1] <- c(99,98,97)
      
    矩阵:转置、共轭 
    a'Conj(t(a))
    a.'t(a)
      
    矩阵:求和 
    a=ones(6,7)a <- matrix(1,6,7)
    sum(a)apply(a,2,sum)
    sum(a')apply(a,1,sum)
    sum(sum(a))sum(a)
    cumsum(a)apply(a,2,cumsum)
    cumsum(a')apply(a,1,cumsum)
      
    矩阵排序 
    a=rand(3,4);a <- matrix(runif(12),c(3,4))
    sort(a(:))sort(a)
    sort(a)apply(a,2,sort)
    sort(a')apply(a,1,sort)
    cummax(a)apply(a,2,cummax)
      
    矩阵:最大、最小 
    a=randn(100,4)a <- matrix(rnorm(400),4)
    max(a)apply(a,1,max)
    [v i] = max(a)v <- apply(a,1,max) ; i <- apply(a,1,which.max)
    b=randn(4,4);b <-matrix(rnorm(16),4)
    c=randn(4,4);c <-matrix(rnorm(16),4)
    max(b,c)pmax(b,c)
      
    矩阵的乘法 
    a=reshape(1:6,2,3);a <- matrix(1:6,2,3)
    b=reshape(1:6,3,2);b <- matrix(1:6,3,2)
    c=reshape(1:4,2,2);c <- matrix(1:4,2,2)
    v=[10 11];v <- c(10,11)
    w=[100 101 102];w <- c(100,101,102)
    x=[4 5]' ;x <- t(c(4,5))
    a*ba %*% b
    v*av %*% a
    a*w'a %*% w
    b*v'b %*% v
    v*xx %*% v 或 v %*% t(x)
    x*vt(x) %*% v
    v*a*w'v %*% a %*% w
    v .* x'v*x 或_ x*v
    a .* [w ;w]w * a
    a .* [x x x]a * t(rbind(x,x,x)) 或 a*as.vector(x)
    v*cv %*% c
    c*v'c %*% v
      
    其他矩阵操作 
    a=rand(3,4);a <- matrix(runif(12),c(3,4))
    fliplr(a)a[,4:1]
    flipud(a)a[3:1,]
    a=reshape(1:9,3,3)a <- matrix(1:9,3)
    vec(a)as.vector(a)
    vech(a)a[row(a) <= col(a)]
    size(a)dim(a)
      
    网格 
    [x y]=meshgrid(1:5,10:12);
      
    查找 
    find(1:10 > 5.5)which(1:10 > 5.5)
    a=diag([4 5 6])a <- diag(c(4,5,6))
    find(a)which(a != 0) % which() 的变元是布尔变元
    [i j]= find(a)which(a != 0,arr.ind=T)
    [i j k]=find(a)ij <- which(a != 0,arr.ind=T); k <- a[ij]
      
    读文件 
    load foo.txtf <- read.table("~/foo.txt")
     f <- as.matrix(f)
    写文件 
    save -ascii bar.txt fwrite(f,file="bar.txt")
      
    图形输出 
    gset output "foo.eps"postscript(file="foo.eps")
    gset terminal postscript epsplot(1:10)
    plot(1:10)dev.off ()
      
    赋值 
    string="a=234";string <- "a <- 234"
    eval(string)eval(parse(text=string))
      
    产生随机数 
    均匀分布 
    rand(10,1)runif(10)
    2+5*rand(10,1)runif(10,min=2,max=7) 或 runif(10,2,7)
    rand(10)matrix(runif(100),10)
    正态分布 
    randn(10,1)rnorm(10)
    2+5*randn(10,1)rnorm(10,2,5)
    rand(10)matrix(rnorm(100),10)
    beta分布 
    hist(beta_rnd(4,2,1000,1)hist(rbeta(1000,shape1=4,shape2=10)) 或 hist(rbeta(1000,4,10))
      
    FOR循环 
    for i=1:5; disp(i); endforfor(i in 1:5) {print(i)}
      
    多项式的根 
    roots([1 2 1])polyroot(c(1,2,1))
    polyval([1 2 1 2],1:10)
      
    集合论 
    a = create_set([1 2 2 99 2 ])a <- sort(unique(c(1,2,2,99,2)))
    b = create_set([2 3 4 ])b <- sort(unique(c(2,3,4)))
    intersect(a,b)intersect(a,b)
    union(a,b)union(a,b)
    complement(a,b)setdiff(b,a)
    any(a == 2)is.element(2,a)
      
    绘图 
    a=rand(10);a <- array(runif(100),c(10,10))
    help plothelp (plot) and methods(plot)
    plot(a)matplot(a,type="l",lty=1)
    plot(a,'r')matplot(a,type="l",lty=1,col="red")
    plot(a,'x')matplot(a,pch=4)
    plot(a,'—')matplot(a,type="l",lty=2)
    plot(a,'x-')matplot(a,pch=4,type="b",lty=1)
    plot(a,'x—')matplot(a,pch=4,type="b",lty=2)
    semilogy(a)matplot(a,type="l",lty=1,log="y")
    semilogx(a)matplot(a,type="l",lty=1,log="x")
    loglog(a)matplot(a,type="l",lty=1,log="xy")
    plot(1:10,'r')plot(1:10,col="red",type="l")
    hold onmatplot(10:1,col="blue",type="l",add=T)
    plot(10:-1:1,'b') 
    gridgrid()
    a=randn(10);a <- matrix(rnorm(100),nr=10)
    contour(a)contour(a)
    contour(a,77)contour(a,nlevels=77) ; filled.contour(a)
    mesh(rand(10))persp(matrix(runif(100),10),theta=30,phi=30,d=1e9)
      
    文件与操作系统 
    system("ls")system("ls")
    pwdgetwd()
    cdsetwd()

    R读入octave导出的数据

    统计计算软件R的 foreign 包提供了函数 read.octave,可以读入 octave 用命令 save -ascii 创建的文本数据文件,且支持变量的大多数通用类型,包括标准的原子型(复矩阵, N维数组,字符串,布尔矩阵等)和 递归式(结构体,单元和列表)。

    在octave中用 save -ascii 保存的矩阵数据,也可以在 R 中用命令 read.table 导入,然后用 as.matrix() 强制为 R 中的矩阵使用。我比较倾向于这种方法。这样我们就能充分利用octave擅长矩阵计算和R擅长统计计算的优势,将二者联合起来使用。我们将详细介绍octave读入图像文件,输出能被R处理的矩阵数据

    下面举个例子:我们投掷一枚硬币,已知正面出现的概率为 p,恰好掷出 R 正面所用的次数 N 是我们要考察的,我们做 E 次随机试验,看看N的经验分布情况。

    ## File      : toss.m
    ## Purpose   : The numbers of tossing to get R heads
    ## Author    : Jiangsheng Yu (yujs@pku.edu.cn)
    ## Data      : 11-26-2008
    ## Available : http://icl.pku.edu.cn/member/yujs/Computing.htm
    ## Usage     : run toss.m
    
    more off ;   ## turn the pagination off
    E = 10000;   ## the number of experiments
    result = zeros(E,1);   ## the sequence of E results
    R = 6   ;    ## required number of heads
    p = 0.3 ;    ## the probability of head
    H = 0 ;      ## no heads at the beginning
    N = 0 ;      ## no tosses at the beginning
    for i = 1:E
        do
    	  ## if head, outcome=1; otherwise, outcome=0
    	  outcome = (rand(1,1) < p) ;
    	  H += outcome ; ## the total number of heads
    	  N += 1 ;       ## the total number of tosses
    	until ( H >= R ) ## until R heads
    	result(i,1) = N ;
    	N = 0 ;
    	H = 0 ;
    endfor
    hist (result,40,1) ;
    

    对于 p=0.3 ,R=2 做 E=10000 次随机试验得到 N 的直方图如下:

    掷出R个正面所用次数的直方图
    掷出R个正面所用次数的直方图

    对于 p=0.3 ,R=6 做 E=10000 次随机试验得到 N 的直方图如下:

    掷出R个正面所用次数的直方图
    掷出R个正面所用次数的直方图

    我们把结果保存为 result.data,再读到 R 中处理这些数据。

    > x = result' ;
    > save result.dat x ;
    

    在 R 中我们读入数据,然后画出直方图。

    > library(foreign)
    > a <- read.octave("result.dat")
    > hist(a$x, freq= FALSE, col="blue", border="pink")
    

    得到 p=0.3 ,R=6 的直方图:

    掷出R个正面所用次数的直方图
    掷出R个正面所用次数的直方图
    展开全文
  • Octave入门基础

    万次阅读 多人点赞 2014-10-26 16:14:26
    Octave入门基础 一,简介 1.1 Octave是什么? Octave是一款用于数值计算和绘图的开源软件。和Matlab一样,Octave 尤其精于矩阵运算:求解联立方程组、计算矩阵特征值和特征向量等等。 1.2 Octave的适用对象 Octave和...

    Octave入门基础

    一,简介

    1.1 Octave是什么?

    Octave是一款用于数值计算和绘图的开源软件。和Matlab一样,Octave 尤其精于矩阵运算:求解联立方程组、计算矩阵特征值和特征向量等等。

    1.2 Octave的适用对象

    Octave和Matlab被工程人员和科研人员广泛使用来进行各种工业和学术上的数值计算和仿真。例如,NASA 使用它来开发飞行器的对接系统;Jaguar Racing使用它来可视化和分析从 F1 赛车传来的数 据;Sheffield大学用它来开发用于识别癌细胞的软件。Octave这样的软件让编写数值处理程序变得简单,并提供数据可视化的多种方式。

    1.3 Octave的下载与安装

    参照网上相关教程; 


    二,简单计算

    2.1 Octave最简单的使用方式就是像使用一个计算器一样在命令提示符下输入相应的计算式。Octave能识别通常的计算表达式。例如,在终端输入

    octave:##>2+2

    并按回车键, 你将得到以下的结果ans=4

    各种计算符号的优先级与常规的一致,比如括号有最大优先级,其次为乘方,其次为乘除运算,最后为加减运算

    2.2 内建函数

    Octave中有很多内建函数,可以通过输入函数名和括号中的输入参数来调用函数,例如:

    octave:##> exp(1)

    ans=2.71813

    又如另一个更长的表达式:计算 1.2 sin(40◦ + ln(2.42)), 输入octave:##>1.2*sin(40*pi/180+log(2.4^2))

    ans=0.76618

    其中基本的数学函数有:sin, cos, tan, log, exp, abs, floor, ceil等;

    如果你要退出Octave,只需要在命令提示符下输入quit或者exit即可。


    三,Octave变量

    3.1 变量

    同C++,Java等变成语言一样我们可以定义变量,但Octave 为解释性语言。因此Octave中变量的类型是不用声明的,但Octave中变量名是区分大小的,即变量a和变量A是不同的变量。

    octave:##> deg=pi/180

    deg=0.017453

     

    如果你需要从当前的变量空间中删除某个变量,clear命令能移出所有的变量,或者移出某个特定变量, 如:

    clear name
将移出名为 name 的某个变量。

    3.2 载入和保存数据

    当你退出Octave的时候,你将丢失你所创建的变量。如果你需要在工作的中途退出Octave,那么你可以保存当前会话的数据并在之后重新载入它。如果你输入

    octave:##> save anyname


    这将整个工作空间上的变量存储到当前目录下一个名为anyname.mat 的文件中 (注意.mat是Octave自动添加的)。这样你可以退出Octave,之后重新启动Octave程序,通过输入

     octave:##> loadanyname

    将重新载入之前保存的命名空间,并从你中断的地方重新开始工作。同样的,你可以载入或者保存特定的变量。格式为

    octave:##>save filename var1 var2 ...

    例如,如果你想存储deg变量,那么你可以输入

    octave:##> save degconv deg


    这样将deg变量存储于名为degconv.mat的文件中,你可以通过以下命令重新载入变量

     octave:##> loaddegconv

    Octave 同样能从文件中导入数据,这样的功能在你使用其他的数据来源进行画图或者计算的时候变得非常有用。

    例如:

    X=load(‘featureX.txt’);

    3.3 获得帮助

    如果你不清楚某个命令或者函数的用法,可也用help命令来获得其详细的用法。

    help commandname

    例如:help plot

    3.4 分号和隐藏结果

    分号在通常的编程语言中被用来表示程序块或者单个语句的结束。在 Octave 中分号不是必需的,但它也有一个特殊的功能。我们目前的例子中,我们只要输入一个 Octave 命令并不以分号结尾的话,Octave 总 会将语句执行的结果随即显示出来。但是,如果我们在一行语句的末尾添上分号,Octave将不会显出相应的 结果。

    四 数组和向量及矩阵

    前面介绍过Octave的优势就是可以很方便的进行矩阵的相关计算。

    4.1 构造向量

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

    octave:##> a=[1 4 5]

    a=1 4 5

    octave:##> b=[2,1,0]

     b=2 1 0

    octave:##> c=[4;7;10]

    c=4

      7

     10

    在方括号中由空格或者逗号隔开的一组数据被定义为行向量; 而由分号或者回车隔开的一组数据被定义为列向量。你可以通过已经定义的向量来定义新的向量,例如

    octave:##> a=[1 4 5]

    a=1 4 5

    octave:##> d=[a 6]

     d=1 4 5 6

    4.2 冒号表达式

    利用冒号能够非常方便的创建一些特殊的向量

    octave:##> e=2:6

        e=2 3 4 5 6

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

    4.3 向量构造函数

    zeros(M,N) 创建一个MXN的全零矩阵

    ones(M,N)  创建一个MXN的全一矩阵

    linspace(x1,x2,N) 创建一个N个元素的向量,均匀分布于x1和下x2

    eye(M) 创建一个MXM的单位矩阵

    rand(M,N) 创建一个MXN的矩阵,元素为随机值

    4.4 向量中的元素操作

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

     octave:##>a=[1:2:6 -1 0]

        a=1 3 5 -1 0

    我们可以通过以下命令访问到该向量的第三个元素

     octave:##> a(3)

        ans=5

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

     octave:##>a(3:5)

        ans=5 -1 0

     octave:##>a(1:2:5)

     ans= 1 5 0

    4.5 向量的计算

    将一组数据存入一个向量之后能够使用很多的Octave函数来进行计算。在C++中如果你想进行相同的计算,例如每个元素乘以2, 你需要使用for循环来对每个元素操作。在Octave中虽然也可以使用for循环来实现,但是Octave本身由有简单的向量操作方式。

    向量中每个都乘以一个数可以通过对该向量乘以一个数来实现。以之前定义的 a 向量为例:

    octave:1> a=[1:2:6 -1 0]

    a=
1 3 5 -1 0

    octave:2> a*2

    ans=2 6 10 -2 0

    对向量中所有元素都除以一个数的操作与乘法类似。使用+−算符,你同样可以对该向量中的每个元素都加上或者减去一个数值。两个向量的相乘遵循矩阵的乘法法则,向量乘法并不是对应元素的相乘。如果要进行对应元素的乘除法,你可以使用.* 以及./ 算符注意每个算符前的‘.’表示为一个元素对元素的计算。例如:

    octave:3> b=1:5

    b= 1 2 3 4 5

    octave:4> a.*b

    ans=1 6 15 -4 0

    逐个元素的乘方计算同样也很有用。该计算的算符为,例如

    octave:5> b.^2

    ans =1 4 9 16 25

    octave:6> 2.^b

    ans =2 4 8 16 32

    octave:7> a.^b

    ans =
1 9 125 1 0

    只要两个向量又相同的大小和形状,它们就可以进行元素之间的(element-by-element) 加减乘除和乘方运算。

    4.6 函数操作向量

    前面讲到过的函数也是可以适用于向量。

    例如:exp, log,abs等

    octave:##>abs([-1 2 -3])

             ans=1 2 3

    此外max, length,size, sum, mean, std, floor, ceil等函数也许要掌握,可以通过help命令获得详细用法。

    4.7 矩阵的转置

    一个向量的转置将其由行向量转为列向量或者由列向量转换为行向量。矩阵的转置将其行和列交换。在数学上,矩阵A的转置表示为AT 在octave中转置操作用上引号实现:

    octave:6> A=[5 7 9;-1 3 -2]

    A= 5  7  9

    -1  3 - 2

    octave:7> A'

    ans =5   -1

    7   3

     9   -2

    此外inv求矩阵的逆,det求矩阵的特征值,trace求矩阵的迹。

    五 画图

    Octave通过调用另一个开源软件 GNUPLOT来实现非常丰富的画图功能。最基本的画图命令是 plot(x,y), 其中 x,y 分别为横轴和纵轴数据。可以进行相应地颜色和样式的选择如:’ro’代表们红色圆圈,’b.’代表蓝色点点等;可以通过title,xlabel,ylabel添加标题以及x,y轴名称;legend命令为该图片添加相应的图例。

    5.1 如果你想保存当前的图片内容并将新创建的图片层叠到原图片上,你可以通过使用 hold on命令来实现。使用该命令,我们可以实现在同一幅图上呈现由两个plot 命令绘制的线条。

    octave:##> x=linspace(-10,10);

    octave:##> plot(x,sin(x),’r-’);

    octave:##> hold on

    octave:##> plot(x,sin(x)./x,’b*’)

    octave:##>title(‘Figure’)

    octave:##>xlabel(‘X’)

    octave:##>ylabel(‘Y’)

    octave:##>legend(‘sin(x)’,’sin(x)/x’)


    5.2 subplot(2,3,2)表示在一个格子中画图。因此该条语句的意思是分成一个2X3的格子,并在第2个格子里画图;其中子格的顺序为从左到右从上到下递增,即 

                                                           1   2

                                                           3   4

                                                           5   6

    例如:

    octave:##> x=linspace(-10,10);

    octave:##> subplot(2,1,1)

    octave:##> plot(x,sin(x));

    octave:##> subplot(2,1,2)

    octave:##> plot(x,sin(x)./x)


    5.3 多幅图片可以用figure命令来实现.

    5.4 绘制曲面

    octave:##> x=2:0.2:4;

    octave:##>y=1:0.2:3;

    octave:##>[X,Y]=meshgrid(x,y);% make the grid

    octave:##> Z=(X-3).^2-(Y-2).^2;

    octave:##> subplot(2,2,1);surf(Z);title('surf')

    octave:##> subplot(2,2,2);mesh(Z);title('mesh')

    octave:##> subplot(2,2,3);meshz(Z);title('meshz')

    octave:##> subplot(2,2,4);contour(Z);title('contour')



    六 Octave脚本

    如果你有一些重复输入的命令的,你可以将这一系列的命令存入一个Octave 脚本之中。这种包含 Octave 命令的文本文件是 Octave 程序的基本形式。当你在 Octave 中执行这样的脚本的时候,其效果与将这些命令一行行输入 Octave 中的效果是一样的。而且当你对一系列要输入 Octave 的命令不是很拿的准的时候,在一个脚本中修改这些命令会比在 Octave 终端中重新调出及修改命令要简单方便许多。

    Octave的脚本是普通的文本文件,但是他们需要有一个.m 的后缀 (e.g.run.m)。因此,它们通常也被称为M文件。除去后缀的文件名部分是你在执行该命令时需要向 Octave 终端输入的部分。

    你可以在任何的文本编辑器 (如,emacs, vi,notepad) 中创建并编辑一个脚本文件。在Octave中可以通过以下命令

     octave:##> edit

    在新窗口中调出文本编辑器emacs。如果你想编辑一个已存在的脚本,你可以在edit命令后加上脚本的名字。例如,比如你有个名为 run.m的脚本,输入edit run 将调出编辑器并打开该文件供你编辑。

    然后在 Octave中输入 run执行脚本:

     octave:##> run

    Octave将运行该脚本中的命令并得到相应的结果。

    七 控制语句

    到目前为止我们所看到的程序或者表达式都是一些简单的顺序执行的操作。向量和矩阵的使用能够让Octave执行更加高级的计算,但是要实现更加复杂的功能,我们还需要一些标准的程序语言。Octave提供了通常的循环和选择语句。其语法类似于我们熟知的C,C++,Java等编程语言。

    在这里仅仅举一个例子:

    octave:##> x=1;

    octave:##> while 1+x>1

    x=x/2;

    end

    octave:##>x

        x=

    1.1102e-16

    八 Octave函数

    Octave中的脚本能实现一些简单的程序,但是比脚本更加强大的是用户自定义函数。自定义函数能够让你在命令行、其他函数中和脚本中调用。

    在Octave函数中参数是通过值传递的而不是通过reference传递并能返回多个返回值。Octave函数如同脚本一样,是写入一个纯文本文件中的,不同的是函数文件的第一行遵循如下的格式

     function[output1,output2,...]=name(input1,input2,...)

    每个函数都卸载了不同的M文件中,而且该M文件名不须与函数名一致。例如名为sind()的函数必需被定义在名为sind.m的M文件中。每个函数接受一定的参数输入并输出一定的数值。

    当你需要重复性的执行一定表达式,这表明你需要将这与的操作封装为一个函数。封装为函数之后 Octave 将更加易用,增加了代码的可读性并可以供他人使用。

    我们可以创建这么一个函数,创建一个名为 sind.m 的 文本文件并包含以下内容:

    function s=sind(x)

      % SIND(x)Calculates sine(x) in degrees

      s=sin(x*pi/180);

    end

    然后就可以使用该函数了,例如:

    octave:##> sind(0)

        ans=0

    octave:##> sind(45)

     ans= 0.7071

    octave:##> t=sind([30 60 90])

        t= 0.50000.8660 1.0000

     


    展开全文
  • octave是开源免费的软件, 功能与matlib类似,并且与matlib语法兼容. 本文是入门手册,分英文版和中文版. 原来的中文版有些疏漏的地方,可参照英文版.
  • octave入门教程[汇编].pdf
  • 本内容将介绍 Octave 的一些基本操作命令和使用方法。
  • OCTAVE入门教程

    2013-10-06 16:30:00
    OCTAVE入门教程 OCTAVE(Operationally Critical Treat,Asset,and Vulnerability Evaluation,可操作的关键威胁、资产和薄弱点评估)是由美国卡耐基·梅隆大学软件工程研究所下属的CERT协调中心开发的用以定义一种...
  • Octave 入门

    2019-01-23 17:07:03
    Matlab实在太贵,所以Andrew Ng推荐的完全开源免费的Octave却是个好的替代物。 关于为什么要用Octave,而不是用别的Matlab代替品如Freemat, Spider等,这篇AskUbuntu里有非常详尽的解答。 简而言之:Octave是Matlab...
  • Octave入门之一些常见的语法知识

    万次阅读 2016-11-20 14:51:41
    最近准备开始做数字图像处理的实验,我安装了Octave,于是准备继续用Octave做实验,(Matlab你懂的,入门买个觉得有点浪费,况且Octave能用懂,转到Matlab估计也不是很困难)。 下面记录下学习中觉得用的比较多的...
  • Octave 入门教程:矩阵

    千次阅读 2018-10-24 17:03:17
    本内容将介绍 Octave 中的矩阵的创建、引用及相关运算。
  • Octave 入门教程:数组

    千次阅读 2018-10-24 17:06:08
    本内容将介绍 Octave 中的数组的创建和操作。
  • Octave 入门教程:绘图

    万次阅读 多人点赞 2018-10-18 14:51:08
    本内容将介绍在 Octave 中绘制图形。
  • 吴恩达老师的课程介绍Octave处理矩阵,几何图形,过滤出独立音频只要用一句代码搞定,所以也过来入门。 下载 下载地址: https://github.com/octave-app/octave-app/releases 下载并安装 更多种安装方式请参考 ...
  • 【转】Octave入门基础

    千次阅读 2018-05-15 15:35:54
    Octave入门基础 一,简介 1.1 Octave是什么? Octave是一款用于数值计算和绘图的开源软件。和Matlab一样,Octave 尤其精于矩阵运算:求解联立方程组、计算矩阵特征值和特征向量等等。 1.2 Octave的适用对象 Octave...
  • 本内容将介绍 Octave 的控制语句(if/switch)和循环语句 (for/while/break/continue)的使用方法。
  • Octave 入门教程

    千次阅读 2018-10-18 15:03:08
    本内容主要介绍 Octave 的使用方法。对自己的学习进行总结,同时希望能够对大家有用,谢谢!
  • Octave入门(一)

    千次阅读 2018-07-21 18:39:02
    Octave安装直接搜就有,贴一个可在线运行的网址:Octave在线   Octave是一门针对数值运算的编程语言,和matlab很相近,对matlab有些了解的话会觉得octave也很熟悉 按照默认安装完Octave以后(尽量安装4.0以后的...
  • 显示输出 >> a = 2 a = 2 >> display(a) a = 2 >> disp(sprintf('2 decimals:%0.2f',a)) 2 decimals:2.00 矩阵相关 >> A=[1,2;3,4;5,6] A = 1 2 3 4 5 6 >>... 3
  • octave入门教程(二)

    2021-03-01 22:09:36
    size、length函数 size可用来返回矩阵行列数(也可指定参数单独显示行或...load:加载本地文件到octave环境中 whos:显示当前内存中保存的变量 save:将octave中的变量写入磁盘 clear:指定名称时在内存删除指定变量,.
  • octave入门教程(三)

    2021-03-02 16:09:19
    矩阵运算 矩阵 A * B .* 表示用数乘矩阵 矩阵+数为矩阵中对应每个元素都加上该数 A’ 表示矩阵转置 log为求对数函数 exp() 为求e的 参数次方 -A 表示求矩阵中各元素相反数 pinv() 函数为求逆矩阵 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,821
精华内容 728
关键字:

octave入门