Octave

Kohteesta Linux-aktivaattori
Loikkaa: valikkoon, hakuun



GNU Octave on vapaa ohjelmisto ja kieli, joka on tarkoitettu mahdollisimman yhteensopivaksi Matlab-ohjelman kanssa. Se on tarkoitettu pääasiassa numeeriseen laskentaan. Sitä on mahdollista myös laajentaa käyttäjien tekemillä omilla C++-tiedostoilla. Octave löytyy tärkeimmille käyttöjärjestelmille, erityisesti Linux-, Windows- ja Mac OS X -alustoille.


GNU Octave is a high-level language, primarily intended for numerical computations. It provides a convenient command line interface for solving linear and nonlinear problems numerically, and for performing other numerical experiments using a language that is mostly compatible with Matlab. It may also be used as a batch-oriented language.

Käynnistys, lopetus ja opastus

Octave käynnistyy (Linuxin) komentoriviltä komennolla octave.

$ octave
GNU Octave, version 3.0.1
Copyright (C) 2008 John W. Eaton and others.
This is free software; see the source code for copying conditions.
There is ABSOLUTELY NO WARRANTY; not even for MERCHANTIBILITY or
FITNESS FOR A PARTICULAR PURPOSE.  For details, type `warranty'.

Octave was configured for "i486-pc-linux-gnu".

Additional information about Octave is available at http://www.octave.org.

Please contribute if you find this software useful.
For more information, visit http://www.octave.org/help-wanted.html

Report bugs to <bug@octave.org> (but first, please read
http://www.octave.org/bugs.html to learn how to write a helpful report).

For information about changes from previous versions, type `news'.

octave:1>

Kuten niin monet muutkin komentorivipohjaiset ohjelmat, myös Octave tulostaa ensimmäiseksi tervehdyksen, joka sisältää mm. tiedon ohjelman versiosta sekä viitteitä verkosta löytyvään materiaaliin. Octaven voi käynnistää myös ilman näitä tulosteita komennolla octave -q. (Kirjain q viittaa sanaan quitet.) Lopuksi Octave antaa komentokehotteen ja jää odottamaan syötettä käyttäjältä.

Ohjelman lopettaminen onnistuu komennoilla exit ja quit sekä näppäinyhdistelmällä ctrl-d.

Opastusta Octavessa saa monien muiden ohjelmien tavoin komennolla help. Tämä komento tulostaa pitkähkön, sivutetun luettelon käytössä olevistä operaattoreista, funktioista, varatuista sanoista, komennoista yms. Luettelon näyttämisen saa katkaistua q-näppäimellä. Tarkemmat ohjeet halutusta aiheesta saa komennolla help aihe.

octave:1> help if

*** if:

 -- Keyword: if (COND) ... endif
 -- Keyword: if (COND) ... else ... endif
 -- Keyword: if (COND) ... elseif (COND) ... endif
 -- Keyword: if (COND) ... elseif (COND) ... else ... endif
     Begin an if block.
          x = 1;
          if (x == 1)
            disp ("one");
          elseif (x == 2)
            disp ("two");
          else
            disp ("not one or two");
          endif


     See also: switch.


Additional help for built-in functions and operators is
available in the on-line version of the manual.  Use the command
`doc <topic>' to search the manual index.

Help and information about Octave is also available on the WWW
at http://www.octave.org and via the help@octave.org
mailing list.
octave:2>

Komentorivin editointi

Octaven komentorivi on ohjelmoitu käyttämään samaa readline-kirjastoa kuin Pari/GP ja siksi siinä toimivat myös samat Pari/GP#Komentojen_editointi editointiominaisuudet, mukaan lukien komentohistoria ja tabulaattoritäydennys.

Komennot voi halutessa päättää puolipisteellä, jolloin ne eivät aiheuta vastauksen tulostamista ruudulle. Tällöin komentoja voidaan kirjoittaa myös useampia samalle riville puolipisteellä eroteltuina. Komentoja voi erotella samalle riville myös pilkulla, jolloin pilkulla päätetyt komennot antavat tulosteen ja puolipisteellä päätetyt eivät.

Matriiseja

Octave käsittelee lukuja kaksoistarkkuuden numeerisina liukulukuina. Kokonaislukuja ei siis tarvitse erikseen muuttaa liukuluvuiksi esimerkiksi jakolaskun yhteydessä, kuten Pari/GP:ssä. Toisaalta luvut ovat siis kokoajan numeerisia liukulukuja eivätkä välttämättä esimerkiksi tarkkoja rationaalilukuja

Matlab-kloonina Octave pyrkii esittämään kaikki numeeriset arvot n x m matriiseina. Yksittäiset luvut, skalaarit ovat tulkittavissa 1 x 1 -matriiseina sekä vaaka- ja pystymatriisit yhden rivin tai sarakkeen matriiseina.

Matriiseja luodaan joko luettelemalla alkiot suoraan:

octave:2> v = [1,2,3]
v =

   1   2   3

octave:3> u = [2; 3]
u =

   2
   3

octave:4> M = [1,2;3,4;5,6]
M =

   1   2
   4   4
   5   6

Vaakarivin alkiot voi erotella myös pelkällä välilyönnillä ilman pilkkua:

octave:5> a = [1 2 3 4]
a =

   1   2   3   4

Matriiseja voi myös muodostaa kertomalla välin, jolta luvut halutaan. Vektorin [1 2 3 4 5 6] voi siis esittää myös muodossa [1:6]:

octave:6> [1:6]
ans =

   1   2   3   4   5   6

Oletusaskeleena on 1 ja tämä pätee myös desimaalilukuihin:

octave:7> [1.2:6.2]
ans =

   1.2000   2.2000   3.2000   4.2000   5.2000   6.2000
octave:8> [1.2:6.7]
ans =

   1.2000   2.2000   3.2000   4.2000   5.2000   6.2000

Askeleen pituuden voi myös määritellä. Esimerkiksi ensimmäiset parilliset luvut saadaan seuraavasti:

octave:9> [0:2:12]
ans =

    0    2    4    6    8   10   12

Tämä merkintätapa soveltuu myös matriisien rakentamiseen.

octave:10> [1:4; 2:2:8; 2.3:0.3:3.3]
ans =

   1.0000   2.0000   3.0000   4.0000
   2.0000   4.0000   6.0000   8.0000
   2.3000   2.6000   2.9000   3.2000

Matriiseille voi tehdä tuttuja matriisioperaatioita: matriisikertolaskun, yhteenlaskun, transponoinnin, jne. Transponoinnin lyhennysmerkintänä toimii M'.

octave:11> M*u
ans =

    8
   18
   28

octave:12> v*M
ans =
  22   28
octave:13>  [3 3 4]+v
ans =

   4   5   7
octave:14> transpose (M)
ans =

   1   3   5
   2   4   6

octave:15> M'
ans =

   1   3   5
   2   4   6

Matriisien määrittely onnistuu myös lohkomuodossa.

octave:16> [M v']
ans =

   1   2   1
   3   4   2
   5   6   3

octave:17> [M; u']
ans =

   1   2
   3   4
   5   6
   2   3

Matriisien kokoa voi tarkastella funktioilla size() (koko muodossa n x m) tai length (sarakkeiden määrä).

octave:18> size(M)
ans =

   3   2

octave:19> length(M)
ans =  3

Vektorien ja matriisien alkioihin voi viitata suoraan kirjoittamalla vektorin tai matriisin perään kaarisulut, joiden sisällä ilmaistaan haluttu solu. Haetaan vektorista v2=[4,2,7,5,8] kolmas alkio. Huomaa, että vektorin paikkojen indeksointi alkaa paikasta numero 1.

octave:20> v2=[4,2,7,5,8]
v2 =

   4   2   7   5   8

octave:21> v2(3)
ans =  7

Vastaavasti voidaan vektorista valita alivektori määräämällä indeksijono edellä esitetyllä merkintätavalla:

octave:22> v2(2:4)
ans =

   2   7   5

octave:23> v2(2:2:4)
ans =

   2   5

Tässä siis rajattiin vektorista ensin yhtenäinen osa indeksistä 2 indeksiin 4 (siis 2,3 ja 4) ja sen jälkeen indeksistä 2 indeksiin 4 askelen pituudella 2 (siis indeksit 2 ja 4). Osavektori halutusta indeksistä vektorin loppuun saakka saadaan käyttämällä sanaa end lopetusindeksinä.

octave:24> v2(2:end)
ans =

   2   7   5   8

Matriiseista halutut rivit ja sarakkeet saa poimittua ilmoittamalla vastaavalla tavalla rivit ja sarakkeet pilkulla eroteltuina. Jos halutaan poimia kaikki rivit tai sarakkeet, ilmoitetaan tämä symbolilla :.

octave:25> M2 = [1 2 3; 4 5 6; 7 8 9; 10 11 12]
M2 =

    1    2    3
    4    5    6
    7    8    9
   10   11   12

octave:26> M2(2:2:4, 2)
ans =

    5
   11

octave:27> M2(2:2:4,:)
ans =

    4    5    6
   10   11   12

octave:28> M2(:,1)
ans =

    1
    4
    7
   10

Matriisin kaikki alkiot saa lueteltua yhdeksi pystyvektoriksi sarakkeittain komennolla:

octave:29> M2(:)
ans =

    1
    4
    7
   10
    2
    5
    8
   11
    3
    6
    9
   12

Operaatioita

Matriisien, vektorien ja skalaarien välillä voidaan suorittaa monenlaisia operaatioita.

Skalaarioperaatiot

Skalaarien ja matriisien tai vektorien väliset aritmeettiset operaatiot, tapahtuvat alkiokohtaisesti. Esimerkiksi

octave:30> A=[1 2;3 4]
A =

   1   2
   3   4
 
octave:31> A + 5
ans =

   6   7
   8   9

octave:32> A*2
ans =

   2   4
   6   8

octave:33> A/2
ans =

   0.50000   1.00000
   1.50000   2.00000

Matriisioperaatiot

Matriisien ja/tai vektoreiden välillä voidaan suorittaa normaaleja matriisioperaatioita (yhteen-, vähennys- ja kertolaskut). Näiden lisäksi on olemassa kertolaskuoperaatio .*, joka tarkoittaa alkiokohtaista kertolaskua, sekä sitä vastaava alkiokohtainen jakolasku ./. Näitä operaatioita käytettäessä vektorien tai matriisien tulee olla täsmälleen saman kokoisia.

octave:34> a=[1 2 3]; b=[3 4 5];
octave:35> a.*b
ans =

    3    8   15

octave:36> B = [2 4; 6 8];
octave:37> A .* B
ans =

    2    8
   18   32

Funktioiden määrittely

Funktiot esitellään Octavessa sanalla function, jonka jälkeen tulee itse funktion määrittely. Funktiosta kerrotaan paluumuuttuja, funktion, syötemuuttujat sekä itse funktion runko. Esimerkiksi:

function y = myplus(a,b)
y = a+b;
endfunction
octave:99> myplus(3,7)
ans =  10

Tässä funktion nimi on myplus() ja se saa syötteenään kaksi muuttujaa a ja b. Paluumuuttujana on yksi yksittäinen muuttuja. Funktio palauttaa sen arvon, joka funktion rungossa viimeisenä sijoitetaan paluumuuttujan arvoksi. Funktion runko päättyy sanalla endfunction.

Paluumuttujia voi olla myös useampia, jolloin ne esitellään vektorina ja kuhunkin vektorin alkioon sijoitetaan arvo erikseen. Syötemuuttujille voi antaa oletusarvoja, jolloin kyseistä syötettä ei tarvitse välttämättä antaa funktiota kutsuttaessa.

function [a, b] = plustimes(X, y=5)
a = X+y;
b = X*y;
endfunction
octave:102> [a,b]=plustimes([2 5 6])
a =

    7   10   11

b =

   10   25   30
octave:103> [a,b]=plustimes([2 5 6],2)
a =

   4   7   8

b =

    4   10   12

Ohjelmointi

Octavessa on käytännössä ohjelmointikieli ja siitä löytyy normaali ohjelmointikielten kontrollirakenne.

Syöte ja tuloste

Ohjelma voi pyytää käyttäjältä syötettä funktiolla input().

octave:298> a = input("Anna luku!")
Anna luku! 5
a =  5

Tulostaminen taas tapahtuu funktiolla disp().

octave:299> disp(a)
 5
octave:300> disp("Myös tekstiä!")
Myös tekstiä!

If-lause

Octaven if-rakenteen muoto on:

if ehto1
  ...
elseif ehto2
  ...
else
  ...
endif

Esimerkiksi:

octave:301> function y = vertaa(numero)
> if numero > 0
> disp("Positiivinen")
> elseif numero < 0
> disp("Negatiivinen")
> else
> disp("Nolla")
> endif
> endfunction
octave:302> vertaa(6)
Positiivinen
octave:303> vertaa(-3)
Negatiivinen
octave:304> vertaa(0)
Nolla

For-silmukka

Octaven for-silmukassa ideana on, että silmukkamuuttujan arvo käy läpi annetun vektorin kaikkien alkioiden arvot ja silmukan vartalo suoritetaan kullakin arvolla. Silmukan vartalo lopetetaan sanalla endfor Esimerkiksi:

octave:305> v = [1 2 3 4]
octave:306> for i = v
> disp(2*i)
> endfor
 2
 4
 6
 8

Läpikäytävät arvot voidaan antaa myös jo aiemmin tutuksi tulleella lukujonojen muodostamiseen tarkoitetulla syntaksilla.

octave:307> for i = 4:2:10
> disp(i)
> endfor
 4
 6
 8
 10

While-silmukka

While silmukkaa suoritetaan niin kauan kuin silmukan ehto on voimassa. While-silmukan vartalo lopetetaan sanalla endwhile.

octave:308> a=1;
octave:309> while a < 10
> disp(a)
> a=a+1;
> endwhile
 1
 2
 3
 4
 5
 6
 7
 8
 9

While-silmukkaa käytettäessä on tärkeää aina varmistaa, että silmukan ehto varmasti lakkaa olemasta jossain vaiheessa, ettei päädytää ikuiseen silmukkaan.

Do...until-silmukka

While-silmukassa silmukkaehto tarkistetaan ennen vartalon suorittamista ja siksi vartaloa ei välttämättä suoriteta kertaakaan. Joskus on oleellista, että vartalo tulisi suoritettua ainakin kerran ja vasta sen jälkeen tarkistettaisiin, pitääkö silmukkaa toistaa. Tällaisia tilanteita varten Octavessa on do...until-silmukkarakenne. Silmukka alkaa sanalla do, jonka jälkeen tulee silmukan vartalo. Silmukka päättyy sanalla until sekä ehdolla, joka kertoo, mihin asti silmukkaa toteutetaan. Silmukkaa suoritetaan kirjaimellisesti kunnes ehto toteutuu. Tämänkin silmukkatyypin kanssa tulee olla varovainen ja varmistaa, että sen suoritus lopulta päättyy.

octave:310> do
> a=input("Anna nolla! ");
> until a == 0
Anna nolla! 4
Anna nolla! 6
Anna nolla! 2
Anna nolla! 0
octave:311>

Ohjelmien suorittaminen tiedostosta

Octave-komentoja ja -ohjelmia voi kirjoittaa tekstitiedostoon ja käskeä Octaven suorittaa ne. Ensin pitää siirtyä chdir()-funktiolla hakemistoon, johon tiedosto on tallennettu ja tämän jälkeen tiedosto voidaan suorittaa ihan vain kirjoittamalla tiedoston nimi:

octave:400> chdir("octave/skriptit")
octave:401> myscript.m;

Linux- tai Unix-alustoilla Octave-ohjelmia voidaan suorittaa myös suoraan komentoriviltä kirjoittamalla tiedoston alkuun ensimmäiseksi riviksi:

#!/usr/bin/octave -qf

Tämän lisäksi tiedostolle pitää asettaa ajo-oikeudet Linuxin komentoriviltä komennolla

chmod u+x tiedostonimi

Nyt tiedoston suoritus onnistuu komentoriviltä komennolla:

./tiedostonimi

Kuvaajien piirtäminen

Octave käyttää kuvaajien piirtämiseen gnuplot:ia, joten siksi käytettävissä olevat muotoiluparametrit ovat pitkälti siitä riippuvaisia.

Ehkä helpoin tapa piirtää kuvaaja, on muodostaa erilliset vektorit x- ja y-arvoista ja plotata ne plot()-funktiolla.

octave:199> x=[1 2 3 4 5 6 7]; y=[2 7 4.3 6 9.2 5 5.3];
octave:200> plot(x, y)

Useamman kuvaajan saa samaan kuvaan luettelemalla vuorotellen x- ja y-vektoreita. Luodaan kaksi uutta vektoria. Ensimmäisessä (x2) ovat luvut nollasta kymmeneen 0.2:n välein ja toisessa näiden sinit.

octave:201> x2 = [0:0.2:10]; y2 = sin(x2);

Piirretään nämä samaan kuvaajaan edellisen tulostuksen kanssa.

octave:202> plot(x,y,x2,y2)

Octave-plot-2funktiota.png

Käytettävän x-vektorin voi tuottaa myös linspace(alku, raja, määrä)-funktiolla, joka tuottaa parametrin määrä osoittaman määrän tasavälin olevia pisteitä, arvosta alku arvoon raja saakka. (alku ja raja mukaan luettuina) Jos määrä-parametria ei anneta, käytetään oletuksena lukua 100.

octave:203> x=linspace(0, 2*pi, 100); y=sin(x);

3D-kuvaajat

3D-kuvaajia piirrettäessä täytyy muistaa, että laskettavan funktion arvo z pitää laskea kaikilla x- ja y-vektorien arvojen yhdistelmillä. Tähän on käytettävissä avuksi funktio meshgrid(x,y), joka tuottaa kaksi matriisia, joiden alkioiden pareina saadaan kaikki tarvittavat pisteparit aikaiseksi. Itse kuvaaja piirretään mesh(x,y,z)-funktiolla.

octave:204> x = -2:0.1:2;
octave:205> [xx,yy] = meshgrid(x,x);
octave:206> z = sin(xx.^2-yy.^2);
octave:207> mesh(x,x,z);

Octave-3d-kuva.png

Muita funktioita, joilla voi piirtää 3D-kuvaajia, ovat surf(), contour() ja näiden yhdistelmä surfc().

octave:208> xx=-2:.1:2; yy=xx;
octave:209> [x,y]=meshgrid(xx,yy);
octave:210> size(x)

ans =

    41    41

octave:211> z=exp(-x.^2-y.^2);
octave:212> surf(x,y,z)

Komennolla grid kuvaan voi lisätä vielä ruudukon.

octave:213> grid

Siinä, missä mesh()-funktio piirtää kuvion vain viivoilla, surf() värittää myös viivojen väliset pinnat.

Octave-3d-surf.png

Kuviin voidaan lisätä otsikoita itse kuvalle sekä akseleille funktioilla title(), xlabel(), ylabel() ja zlabel().

octave:214> title('Otsikko'); xlabel('x-akseli'); ylabel('y-akseli'); zlabel('z-akseli');

3D-kuvaajan katselukulmaa voidaan muuttaa view(kulma1, kulma2)-funktiolla, jossa kulma1 kuvaa katselukulmaa xy-tasossa (azimuth) ja kulma2 katselukulman korkeutta xy-tasoon nähden (elevation). Kulmat ovat asteina ja jälkimmäinen rajoittuu välille [-90, 90].

octave:215> view(30,50)

Kuvat tiedostoiksi

Viimeisimmän näytölle piirretyn kuvan tallentaminen tiedostoon tapahtuu funktiolla print(), jolle annetaan parametreina tiedoston nimi sekä muita optioita, joihin kuuluu ainakin tallennuksessa käytettävä tiedostomuoto.

octave:216> print("3d-kuva.eps", "-depsc2")

Optiot annetaan merkkijonona, jossa "-d":llä merkitty optio kertoo tulostuslaitteen, eli tässä tapauksessa tiedoston tyypin. Erilaisia vaihtoehtoja tiedostojen tyypeiksi ovat ainakin:

        'ps'
        'ps2'
        'psc'
        'psc2'
              Postscript (level 1 ja 2, mustavalko ja värillinen)

        'eps'
        'eps2'
        'epsc'
        'epsc2'
              Encapsulated postscript (level 1 ja 2, mustavalko ja värillinen)

        'ill'
        'aifm'
              Adobe Illustrator

        'cdr'
        'corel'
              CorelDraw

        'fig'
              XFig

        'dxf'
              AutoCAD

        'png'
              Portable network graphics

        'svg'
              Scalable Vector Graphics

Lisää tiedostomuotoja ja muita optioita löytyy komennolla

octave:217> help print

Lisäpaketit

Octaveen on saatavilla lukuisia lisäpaketteja, jotka eivät ole Octaven oletusasennuksen mukana. Monet yleisimmin käytetyistä paketeista tulevat Linux-järjestelmien paketinhallinnassa omina erillisinä paketteinaan, mutta osan taas joutuu lataamaan erikseen Octaven lisäpakettivarastosta.

Lisäpaketti asennetaan seuraavasti. Ensin pakettitiedosto (esimerkiksi combinatorics-1.0.9.tar.gz) ladataan käytettävälle koneelle johonkin tiedostoon. Sitten octavessa siirrytään kyseiseen hakemistoon chdir()-funktiolla ja suoritetaan asennuskomento.

octave:204> chdir ("~/lataus/hakemisto")
octave:205> pkg install combinatorics-1.0.9.tar.gz

Tämän jälkeen paketin tuomat funktiot, vakiot ym. ominaisuudet ovat käytettävissä. Combinatorics-paketti tuo esimerkiksi combs()-funktion, jolla voidaan tuottaa kaikki n-alkion kombinaatiot annetusta vektorista v komennolla combs(v,n).

octave:206> combs([1,2,3,4], 2)
ans =

   1   2
   1   3
   1   4
   2   3
   2   4
   3   4

Asennettu paketti on automaattisesti käytettävissä uudessa istunnossa. Tarpeettoman paketin voi halutessaan ottaa pois käytöstä komennolla pkg unload paketti. Esimerkiksi:

octave:207> pkg unload combinatorics

ja ladata taas takaisin käyttöön komennolla pkg load paketti

octave:208> pkg load combinatorics

Listan käytettävissä olevista paketeista näkee komennolla:

octave:209> pkg list
Package Name   | Version | Installation directory
---------------+---------+-----------------------
combinatorics *|   1.0.9 | /home/pesasa/octave/combinatorics-1.0.9

Listassa on käytössä olevat paketit merkitty *-merkillä.

Tarpeettoman paketin voi poistaa kokonaan käytöstä pkg uninstall -komennolla:

octave:210> pkg uninstall combinatorics

Kannattaa myös huomioida, että tavallisen käyttäjän asentamat lisäpaketit ovat näkyvissä vain hänellä itsellään, ei muilla saman koneen käyttäjillä.