Informatika1-2015/Gyakorlat9

A MathWikiből
(Változatok közti eltérés)
(Mátrixok)
1. sor: 1. sor:
 
[[Informatika1-2015/Gyakorlat8|Előző gyakorlat]] - [[Informatika1-2015#Gyakorlatok|Fel]] - [[Informatika1-2015/Gyakorlat10|Következő gyakorlat]]
 
[[Informatika1-2015/Gyakorlat8|Előző gyakorlat]] - [[Informatika1-2015#Gyakorlatok|Fel]] - [[Informatika1-2015/Gyakorlat10|Következő gyakorlat]]
  
== Octave ==
+
= Octave =
  
 
Az [http://www.gnu.org/software/octave/ Octave] programmal lehet különböző matematikai számításokat numerikusan elvégezni, a nagytestvérének a [http://www.mathworks.com/products/matlab/ MatLab]-nak az ingyenes ([https://en.wikipedia.org/wiki/Open_source opensource]) változata.
 
Az [http://www.gnu.org/software/octave/ Octave] programmal lehet különböző matematikai számításokat numerikusan elvégezni, a nagytestvérének a [http://www.mathworks.com/products/matlab/ MatLab]-nak az ingyenes ([https://en.wikipedia.org/wiki/Open_source opensource]) változata.
  
=== Kezdeti lépések ===
+
== Kezdeti lépések ==
  
==== Hozzáférés a programhoz ====
+
=== Hozzáférés a programhoz ===
 
Ha otthonról dolgozunk, akkor a következő lehetőségek legalább egyikével éljünk:
 
Ha otthonról dolgozunk, akkor a következő lehetőségek legalább egyikével éljünk:
 
* [http://www.gnu.org/software/octave/download.html telepítsünk Octave-ot], ez minden platformra ingyenes
 
* [http://www.gnu.org/software/octave/download.html telepítsünk Octave-ot], ez minden platformra ingyenes
13. sor: 13. sor:
 
A géptermekből Linux-ról futtassuk az Octave-ot
 
A géptermekből Linux-ról futtassuk az Octave-ot
  
==== Számológép ====
+
=== Számológép ===
 
Írjuk be az <tt>octave</tt> parancssorába:
 
Írjuk be az <tt>octave</tt> parancssorába:
 
  2+3
 
  2+3
36. sor: 36. sor:
 
  (180/pi)*acos(0.5)
 
  (180/pi)*acos(0.5)
  
=== Adattípusok ===
+
== Adattípusok ==
 
Minden megadott szám lebegőpontos, akkor is, ha véletlenül egész:
 
Minden megadott szám lebegőpontos, akkor is, ha véletlenül egész:
 
  1000/9
 
  1000/9
47. sor: 47. sor:
 
  sqrt(-2)
 
  sqrt(-2)
  
==== A számábrázolások ====
+
=== A számábrázolások ===
 
* <tt>double</tt>: dupla lebegő pontos, 64 bit (8 byte)
 
* <tt>double</tt>: dupla lebegő pontos, 64 bit (8 byte)
 
** valós: 8 byte
 
** valós: 8 byte
64. sor: 64. sor:
 
  int8(100+100)
 
  int8(100+100)
  
==== Mátrixok ====
+
=== Mátrixok ===
 
Az <tt>octave</tt>-ban '''minden szám egy mátrix'''
 
Az <tt>octave</tt>-ban '''minden szám egy mátrix'''
 
* számok: <tt>1x1<tt>
 
* számok: <tt>1x1<tt>
96. sor: 96. sor:
 
  size([1;2;3])
 
  size([1;2;3])
  
=== Műveletek mátrixokkal ===
+
=== Tartományok ===
 +
A tartományok speciális sorvektorok, Próbáljuk ki:
 +
1:10
 +
Ha nem egyesével akarunk ugrani:
 +
1:0.1:2
 +
1:2:10
 +
Komplex számmal nem lehet, mert azok nem rendezhetőek!<br>
 +
Az eredmény mindig <tt>double</tt> lesz, de utána konvertálhatjuk:
 +
int32(1:0.5:10)
 +
 
 +
Leszálló tartományok:
 +
4:-1:1
 +
 
 +
== Műveletek mátrixokkal ==
 +
Mivel minden szám egyben egy <tt>1x1</tt>-es mátrix, így ezek mindig használhatóak.
 +
 
 
Transzponált egyszerűen '''vesszővel''' (<tt>'</tt>):
 
Transzponált egyszerűen '''vesszővel''' (<tt>'</tt>):
 
  > [1 2; 3 4]'
 
  > [1 2; 3 4]'
109. sor: 124. sor:
 
   1 - 0i  0 - 3i
 
   1 - 0i  0 - 3i
 
   0 - 2i  4 - 0i
 
   0 - 2i  4 - 0i
 +
Konjugálás: <tt>i'</tt>
 +
 +
=== ===
  
=== Változók ===
+
== Változók ==
 
Ahhoz hogy értelmes dolgokat tudjunk számolni, az adatokat ''változókban'' tároljuk.
 
Ahhoz hogy értelmes dolgokat tudjunk számolni, az adatokat ''változókban'' tároljuk.
 
  a=2
 
  a=2

A lap 2015. november 2., 19:04-kori változata

Előző gyakorlat - Fel - Következő gyakorlat

Tartalomjegyzék

Octave

Az Octave programmal lehet különböző matematikai számításokat numerikusan elvégezni, a nagytestvérének a MatLab-nak az ingyenes (opensource) változata.

Kezdeti lépések

Hozzáférés a programhoz

Ha otthonról dolgozunk, akkor a következő lehetőségek legalább egyikével éljünk:

A géptermekből Linux-ról futtassuk az Octave-ot

Számológép

Írjuk be az octave parancssorába:

2+3

majd üssünk Enter-t. Ennek hatására:

> 2+3
ans =  5
> _

Próbáljuk ki ezeket is:

2-3
2*3
2/3
floor(2/3)
mod(2,3)
2^3
sqrt(2)
log(2)
log(3)
log(8)/log(2)
exp(1)
pi
cos(pi/2)
(180/pi)*acos(0.5)

Adattípusok

Minden megadott szám lebegőpontos, akkor is, ha véletlenül egész:

1000/9
ans = 111.11

Viszont megadhatjuk, hogy egészekként értelmezze a számokat:

int32(1000)/int32(9)
ans = 111

Egy szám valós, amíg komplexnek nem bizonyul:

sqrt(2)
sqrt(-2)

A számábrázolások

  • double: dupla lebegő pontos, 64 bit (8 byte)
    • valós: 8 byte
    • komplex: 16 byte
  • single: szimpla lebegő pontos, 32 bit (4 byte)
    • valós 4 byte
    • komplex: 8 byte
  • int32: 32 bites kettes komplemens egész (4 byte)
  • int8: 8 bites kettes komplemens egész: -128..127 (1 byte)
  • uint32: 32 bites pozitív egész (4 byte)
  • uint8: 8 bites pozitív egész: 0..255 (1 byte)

A méret nagyon is számít:

log(single(1.0001))
log(double(1.0001))
int32(100+100)
int8(100+100)

Mátrixok

Az octave-ban minden szám egy mátrix

  • számok: 1x1<tt>
  • vektorok:
    • sorvektor: <tt>1xn
    • oszlopvektor: nx1
  • matrix: nxm

Ennek alapos oka van, amit majd később fogunk megérteni és ami a MatLab leglényegéhez vezet bennünket, ezt vette át az octave is. Bővebben itt.

Sorvektor:

[1, 2, 3, 4]
[1 2 3 4]

Oszlopvektor:

[1;2;3;4]

Ez nem oszlopvektor:

[[1], [2], [3], [4]]

Mátrix:

[1 2; 3 4]
[1, 2; 3, 4]

Speciális mátrixok:

  • zeros: csupa 0
  • ones: csupa 1
  • eye: diagonálisban 1, máshol 0
zeros(2,3)
eye(2,3)
ones(3,1)

Próbáljuk ki:

size(5)
size([1,2,3])
size([1;2;3])

Tartományok

A tartományok speciális sorvektorok, Próbáljuk ki:

1:10

Ha nem egyesével akarunk ugrani:

1:0.1:2
1:2:10

Komplex számmal nem lehet, mert azok nem rendezhetőek!
Az eredmény mindig double lesz, de utána konvertálhatjuk:

int32(1:0.5:10)

Leszálló tartományok:

4:-1:1

Műveletek mátrixokkal

Mivel minden szám egyben egy 1x1-es mátrix, így ezek mindig használhatóak.

Transzponált egyszerűen vesszővel ('):

> [1 2; 3 4]'
ans =
 1 3
 2 4
> _

Komplex mátrixokra a vessző adjungálást jelent:

> [1,2i;3i,4]'
ans =
  1 - 0i   0 - 3i
  0 - 2i   4 - 0i

Konjugálás: i'

Változók

Ahhoz hogy értelmes dolgokat tudjunk számolni, az adatokat változókban tároljuk.

a=2
b=3
a+b

Mindig van egy ans nevű változónak, amiben az utoljára kiszámolt érték található.
Ha nincsen érték adva egy változónak, akkor nem tudunk hivatkozni rá:

> a/q
error: `q' undefined

A kettősponttal (;) csendes számolást végezhetünk, ekkor a parancs eredménye nem lesz kiírva:

a=2;
b=3;
a+b

A whos paranccsal megnézhetjük az aktuálisan tárolt változóinkat.

> whos
Variables in the current scope:
  Attr Name        Size                     Bytes  Class
  ==== ====        ====                     =====  =====
       a           1x1                          8  double
       ans         1x1                          8  double
       b           1x1                          8  double
Total is 3 elements using 24 bytes
> _

Azt tapasztaljuk, hogy a változók mind 1x1-es double típusúak. Próbáljuk ki a következőket:

a=1000
b=single(1000)
c=int32(1000)
d=int8(1000)
whos

Komplex számok

próbáljuk ki:

z=2+3j
whos z

Azt látjuk, hogy z dupla lebegő pontos, de 16 byte-ot foglal, mivel egy komplex szám két valós számmal ábrázolható.

Előző gyakorlat - Fel - Következő gyakorlat

Személyes eszközök