Matlab Hogyan - Hidrodinamikai Rendszerek Tanszék

Matlab Hogyan 

c○GPL 

csaklogo.eps 

BME Hidrodinamikai Rendszerek Tanszék 

belső használatra 

2005. február 17.

Tartalomjegyzék 

1. Alapok 5 

1.1. Az alapbeállítás menürendszere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 

1.2. Parancssor, scriptek, függvények . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 

1.3. Script fájlok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 

1.4. Függvények . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 

1.5. Lokális és globális változók . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 

1.6. Függvény mutatók . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 

2. Műveletek mátrixokkal, vektorokkal 10 

2.1. Alapműveletek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 

2.2. Lineáris Algebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 

3. Ciklusutasítások, elágazások 13 

3.1. for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 

3.2. while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 

3.3. if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 

3.4. switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 

4. Nemlineáris feladatok 16 

4.1. Polinomok zérushelyei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 

4.2. Optimalizációs feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 

4.3. Nemlineáris függvények zérushelyei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 

5. I/0 22 

5.1. Formázott kivitel (output) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 

5.1.1. Mátrix kiírása fájlba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 

5.2. Formázott beolvasás (intput) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 

5.2.1. Adatfájlból beolvasás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 

6. Grafika 26 

1

TARTALOMJEGYZÉK 2 

7. Interpoláció 28 

7.1. Egydimenziós interpoláció . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 

7.2. Többdimenziós interpoláció . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 

8. Görbeillesztés 29 

9. Közönséges differenciálegyenletek (ODE) megoldása 30 

9.1. Kezdeti érték feladatok (IVP) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 

9.1.1. Szabadsugár sebességeloszlása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 

9.1.2. Egy merev feladat: a Van der Pol egyenlet . . . . . . . . . . . . . . . . . . . . . . . . . 33 

9.1.3. Eseménykezelés: vízcsepp alakja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 

9.2. Perem érték feladatok (BVP) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 

9.2.1. Couette áramlás sebességgradienssel . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 

10.Fourier analízis 38 

11.Példaprogramok 40 

11.1. Karakterisztikák módszere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 

11.2. Nyíltfelszínű csatornaáramlás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 

11.3. Függőlegesből vízszintesbe vezető ívben mozgó anyagdugó . . . . . . . . . . . . . . . . . . . . 45

Tárgymutató 

Fourier analízis 

fft demo.m , 36 

függvény kilincsek 

handle pelda.m , 7 

függvények 

masodfok fv.m , 6 

for 

demo for.m , 12 

formázott i/o 

demo io 1.m , 21 

demo io 2.m , 22 

görbeillesztés 

polyfit pelda.m , 27 

grafika 

demo 2d grafika.m , 24 

demo 3d grafika.m , 25 

kezdeti érték feladatok 

csepp.m , 32 

szabadsugar.m , 30 

van der Pol.m , 31 

lokális és globális változók 

masodfok fv2.m , 6 

masodfok fv3.m , 6 

nemlineáris egyenleternedszerek 

ventillator.m , 18 

optimalizálás 

fminbnd demo.m , 16 

fminsearch demo.m , 17 

peremérték feladatok 

couette.m , 34 

nyiltfelszin.m , 38 

scriptek 

masodfok script.m , 5 

while 

stirling.m, 13 

3

TÁRGYMUTATÓ 4 

Előszó 

Ez a rövid összefoglaló a Budapesti Műszaki és Gazdaságtudományi Egyetem Hidrodinamikai Rendszerek 

Tanszékén (volt Vízgépek Tanszék) készült a Matlab programcsomag oktatásának és használatának 

megkönnyítésére. Igyekeztem nagyon egyszerű példákkal kezdeni és onnan fokozatosan bemutatni a program 

által kínált lehetőségeket, ugyanakkor sokkal inkább ugródeszkát és ötleteket szeretnék adni, mintsem egy 

magyar nyelvű dokumentációt. Mivel nem vagyok profi felhasználó, esetleg egyes programozástechnikai megoldásaim 

nem elegánsak/szépek/gazdaságosak, ezért nagyon fontosnak tartom a beépített Help használatát, 

ami szerintem annyira alapos és érthető, hogy akár azon keresztül is gyorsan el lehet sajátítani a programnyelvet. 

A példaprogramokkal kapcsolatban szívesen fogadok minden észrevételt, javaslatot. 

Ezen írásos anyag és a hozzá tartozó kiegészítő és magyarázó példaprogramok letölthetők a 

www.vizgep.bme.hu 

oldalról nyíló link segítségével. Meg szeretném jegyezni, hogy a Matlab scriptek nagy része kompatibilis 

a Unix/Linux rendszerek alatt hozzáférhető és ingyenes Octave programcsomaggal, mely letölthető pl. a 

www.octave.org honlapról. A dokumentáció magyarosított L A TEX-ben készült, ehhez további információk 

találhatók pl. a következő weblapon: 

http://ebizlab.hit.bme.hu/ tisanyi/latex/ 

Az anyaggal kapcsolatos minden észrevételt, hibát, stb. szívesen fogadok. 

Hős Csaba 

hoscsaba@vizgep.bme.hu 

2004. június 27. 

Szeretném megköszönni Kiss Atillának és Pandula Zolinak a hasznos észrevételeket! Igyekeztem tanácsaik 

alapján javítani a magyarázatokon ill. kijavítottam jópár hibát (de azért még hagytam benne....). Újdonságak 

számít a Pneumatikus anyagszállítás példaprogram, Dr. Váradi Sándor tárgyához segítség. 

2005. február 15.

1. fejezet 

Alapok 

A program neve a Matrix Laboratory rövidítése, ami nagyon találó, ugyanis az egész program mátrixstruktúrákban 

gonolkodik. Ez alatt nem csupán a numerikus mátrixokra gonolunk hanem pl. egy grafikus 

ábra beállításai is ilyen struktúrában kerülnek tárolásra. Ez első hallásra furcsának tűnhet, de (a) ha 

kellő gyakorlatra teszünk szert, nagyban megkönnyíti a munkát és (b) úgysem tudunk mást csinálni, ilyenre 

írták a programot és kész. A csomag maga egy matematikai eljárásgyűjteményként is felfogható, ahol a 

felhasználónak kell a konkrét kódot megírnia, de mikor pl. egy sajárértékfeladathoz ér, egyszerűen meghív 

egy eljárást. Ebből fakad az a tulajdonság is, hogy a Matlab fő erőssége a numerika, analitikus számítások 

elvégzésére nem kényelmes (arra pl. ott a Mathematica vagy a Maple rendszer). A program másik hatalmas 

előnye a fejlett grafikai rendszer, mellyel könnyen és gyorsan elkészíthetők a grafikonok, ábrák és ezek 

gyakorlatilag minden fontosabb formátumban (.ps, .eps, .jpg, .gif, stb.) menthetők. 

Elöljáróban még annyit érdemes tudni a Matlab-ról, hogy a technikai numerikus számításoknak pillanatnyilag 

ez a nemzetközileg legjobban elfogadott és elterjedt programnyelve. 

1.1. Az alapbeállítás menürendszere 

A Matlab indításakor megjelenő menürendszer a következő elemekből áll (alapbeállításban): 

• Command Window: itt adjuk ki a parancsokat, pl. egyszerűbb számítások, függvényhívások vagy 

programok futtatása. 

• Launch Pad: hozzáférhetünk az installált Toolbox-okhoz (amik általában külön megvásárolható ’extra’ 

eljárásgyűjtemények.) 

• Workspace: nyomon követhetjük az aktuális változókat, azok nagyságát, esetleg törölhetjük őket. 

Ez komolyabb programok futtatása esetén lehet fontos, ha tudni akarjuk a Matlab által lefogalt 

memóriaterületet. 

• Command History: az eddig kiadott parancsok. 

• Current Directory: aktuális könyvtár. Ha esetleg más könyvtárban elhelyezett eljárást, adatfile-t 

szeretnénk használni, a File ⇒ Set Path... menüben hozzáadhatjuk a saját könyvtárainkat. 

Az ablakkiosztást megváltoztathatjuk a View ⇒ Desktop Layout paranccsal (vagy kézzel). A paranccsorba 

máris begépelhetjük: 

>> 2*2, 

mire a program boldogan válaszol: 

5

1. FEJEZET. ALAPOK 6 

ans = 

4 

1.2. Parancssor, scriptek, függvények 

A Matlab-bal végzett számítások során - a nagyon egyszerű, zsebszámológép szintű számításoktól eltekintve 

- programozói szemlélet szükséges, azaz az ember gyakorlatilag egy kódot ír. A bonyolultságtól függően 

(elméletileg) háromféle megközelítése lehet egy számítási feladatnak: 

• Parancssor (ld. előző példa) 

• Script: egymás után, lépésről lépésre végrehajtandó parancsok, külön fájlban tárolva. 

• Egymásba ágyazott függvények, eljárások, stb., hasonlóan más programnyelvekhez (pl. Pascal, C, C++, 

stb.). 

1.3. Script fájlok 

Ez egy lineárisan, lépésről lépésre végrehajtandó utasítássorozatot tartalmazó fájl. Példaként lépjünk be 

a Matlab saját szerkesztőjébe (File ⇒ New ⇒ M-file) és készítsünk programot a másodfokú egyenlet 

megoldására. 

masodfok script.m 

a=1; b=2; c=1; 

D= b^2 - 4*a*c; 

if D>0 

uzenet=’valos gyokok:’; 

elseif D> masodfok_script 

komplex gyokok 

-1.0000e+000 +1.4142e+000i 

-1.0000e+000 -1.4142e+000i


1.4. Függvények 

A függvényeket paraméterlistával hívjuk meg és visszatérési értékeik vannak. Az előző másodfokú példa 

függvényként: 

masodfok fv.m 

function gyokok = masodfok_fv(a,b,c) 

D=b^2-4*a*c; 

gyok1=(-b+sqrt(D))/2/a; 

gyok2=(-b-sqrt(D))/2/a; 

gyokok = [gyok1 gyok2]; 

Magyarázat 

Ezt a fájlt már nem lehet akármilyen néven elmenteni, a fájlnévnek masodfok fv.m-nek kell lennie (azaz 

az eljárárs nevének). A függvény bemenete a, b és c, kimenete pedig a gyokok vektor. A függvény hívása 

parancssorból: 

>> mo=masodfok_fv(1,2,5); 

>> mo 

mo = 

-1.0000 + 2.0000i -1.0000 - 2.0000i 

A D diszkrimináns belső változó, a parancssorból nem érhető el: 

>> D 

??? Undefined function or variable ’D’. 

1.5. Lokális és globális változók 

Induljunk ki az előző esetből, ahol adott egy függvény és ezen belül definiáltunk változókat. Ha most azt 

szeretnénk, hogy valamilyen belső változóhoz másik függvény is hozzáférjen, két lehetőségünk van: 

• a függvények argumentumlistájában definiáljuk az értéket (ld. masodfok fv2.m) 

• globális változóként definiáljuk a változókat (ld. masodfok fv3.m) 

A következő program az argumentumlistában megkapott a, b és c változókat átadja a diszkr(a,b,c) 

eljárásnak, amely szintén az argumentumlistában veszi át az értékeket. A b2 és negyac véltozók csak a 

diszkr eljáráson belül hozzáférhetők. 

masodfok fv2.m 

function gyokok=masodfok_fv2(a,b,c) 

D=diszkr(a,b,c); 


gyok2=(-b-sqrt(D))/2/a;



function ertek=diszkr(a,b,c) 

b2=b^2; 

negyac=4*a*c 

ertek=b2-negyac; 

A masodfok fv3 eljárásnál az a, b és c változók globálisnak vannak deklarálva, így az összes olyan függvény 

hozzáfér ill. módosíthat rajtuk, amelyben szintén globálisként definiáltuk őket. (Tehát nem elég a ’főprogramban’ 

globálisként definiálni, az összes olyan eljárásban meg kell tenni ugyanezt, ahol hozzá szeretnénk 

férni.) 

masodfok fv3.m 

function gyokok=masodfok_fv3 

global a b c 

a=1; b=2; c=3; 

D=diszkr; 


gyok2=(-b-sqrt(D))/2/a; 


function ertek=diszkr 

global a b c 

b2=b^2; 

negyac=4*a*c; 

ertek=b2-negyac; 

1.6. Függvény mutatók 

A függvény mutatók segítségével függvényekre hivatkozhatunk. Tipikusan egy eljárás argumentumlistájában 

szerepelnek a változók mellett, pl. a beépített fzero(fun,x0) gyökkereső eljárás a fun változóban 

várja annak a függvénynek a nevét, melynek az x0-hoz közeli gyökét visszaadja. A mutatók használatának 

rejtelmeiről és előnyeiről a Help bő felvilágosítást ad. Tipikusan akkor érdemes használni, ha sokszor kell 

ugyanazt az eljárást lefuttatni különböző függvényeken és nem akarjuk mindig átírni a programot. 

Az alábbi egyszerű példa (handle pelda.m) szemlélteti a fentieket. 

handle pelda.m 

function handle_pelda 

a=2; b=3; 

fhandle=@osszead; 

c=feval(fhandle,a,b) 

fhandle=@szoroz;


c=feval(fhandle,a,b) 

%------------------------ 

function y=osszead(a,b) 

y=a+b; 

function y=szoroz(a,b) 

y=a*b; 

A program kimenete a parancssorban: 

>> handle_pelda 

c = 

5 

c = 

6

2. fejezet 

Műveletek mátrixokkal, vektorokkal 

2.1. Alapműveletek 

A Matlab használata során talán a mátrixműveletek megismerése és elsajátítása alapvető, hiszen az egész 

programnyelv erre épül (a név is innen ered: Matrix Laboratory). A mátrixok elemeit szögletes zárójel fogja 

közre, a sorok elemeit üres karakter választja el, az új sort pedig pontosvessző jelöli: 

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

A = 

16 3 2 13 

5 10 11 8 

9 6 7 12 

4 15 14 1 

A transzponálás felső vesszővel történik: 

>> A’ 

ans = 

16 5 9 4 

3 10 6 15 

2 11 7 14 

13 8 12 1 

Egy mátrix elemeire pedig az alábbi módon hivatkozhatunk: 

>> A(2,3) 

ans = 

11 

Gyakran szükséges a mátrix egy sorát vagy oszlopát ’kivonni’, ez a kettőspont operátorral történik, a soroszlop 

konvenció figyelembevételével. Tehát a A(:,2) parancs a mátrix második oszlopát, a A(1,:) az első 

sorát adja eredményül. A kettőspont operátor jelentése lehet is, azaz: 

10

2. FEJEZET. MŰVELETEK MÁTRIXOKKAL, VEKTOROKKAL 11 

>> 0:pi/4:pi 

ans = 

0 0.7854 1.5708 2.3562 3.1416 

Fontos szerepet játszik még a pont operátor is, amely az elemenkénti műveleteket jelenti. Tehát ha A és B 

két mátrix, akkor A*B a hagyományos mátrixszorzatot adja, míg a A.*B az elemenkénti szorzatot. 

Mátrixokat beolvashatunk adatfájlból is a load parancs segítségével. Bármilyen szövegszerkesztőben (pl. 

Notepad) készítsük el az alábbi sorokat: 

1 4. -5.56 

344 -.454 33 

-0 1 1 

majd mentsük el ize.txt néven. A load parancs beolvassa az adatfile-t és a kiterjesztés levágásával kapott 

változóba teszi az adatokat: 

>> load ize.txt 

>> ize 

ize = 

1.0000 4.0000 -5.5600 

344.0000 -0.4540 33.0000 

0 1.0000 1.0000 

2.2. Lineáris Algebra 

A fontosabb parancsok rövid áttekintése: 

Például: 

Parancs Leírás 

zeros(n,m) n × m-es nullmátrixot hoz létre 

A+B 

Összeadás (elemenként) 

A*B 

Mátrixszorzás 

A’ Transzponált 

det(A) 

Determináns 

trace(A) Nyom (főátlóbeli elemek összege, spur) 

inv(A) 

Inverz 

eig(A) 

Sajátértékek, sajátvektorok 

poly(A) A karakterisztikus polinom együtthatói csökkenű kitevű szerint 

A.*B 

Elemenkénti mátrixszorzat 

A./B 

Elemenkénti osztás 

[L,U] = lu(A) A mátrix LU felbontása 

A\b Az Ax=b lineáris egyenletrendszer megoldása. Ugyanezt az 

eredményt adja az inv(A)*b parancs is. b-nek oszlopvektornak 

kell lennie!

2. FEJEZET. MŰVELETEK MÁTRIXOKKAL, VEKTOROKKAL 12 

>> [V,lambda]=eig(ize); 

>> ize*V(:,1) 

ans = 

-4.0124 

37.6942 

-0.9685 

>> lambda(1)*V(:,1) 

ans = 

-4.0124 

37.6942 

-0.9685 

Példaként számítsuk ki egy adott általános, térbeli feszültségi állapothoz tartozó főfeszültségeket és a főfeszültségi 

irányokat! A szilárdságtan tanítása szerint a T feszültségi tenzorhoz tartozó σ i főfeszültségek a 

feszültségi tenzor sajátértékei: 

T v i = σ i v i , 

ahol v i jelöli a σ i -hez tartozó sajátvektort. A feszültségi mátrix diagonalizálható egy V transzformációs 

mátrixszal, melynek oszlopait a sajátvektorokból képezzük: V = [v 1 , v 2 , v 3 ] (az eig() parancs éppen ezt 

adja vissza): 

Valóban, 

⎛ 

⎞ 

σ 1 0 0 

V −1 T V = ⎝ 0 σ 2 0 ⎠ . 

0 0 σ 3 

>> inv(V)*ize*V 

ans = 

-37.9196 -0.0000 0.0000 

0.0000 37.1044 -0.0000 

-0.0000 -0.0000 2.3611

3. fejezet 

Ciklusutasítások, elágazások 

3.1. for 

Egy utasítás ismétlése megadott alkalommal. 

demo for.m 

n=4; 

a = zeros(n,n); 

for i = 1:n 

for j = 1:n 

a(i,j) = 1/(i+j -1); 

end; 

end; 

disp(a); 

A script futásának eredménye : 

>> demo_for 

1.0000 0.5000 0.3333 0.2500 

0.5000 0.3333 0.2500 0.2000 

0.3333 0.2500 0.2000 0.1667 

0.2500 0.2000 0.1667 0.1429 

3.2. while 

Egy utasítás ismétlése bizonytalan számú alkalommal, valamilyen feltétel teljesüléséig. Példaként számítsuk 

ki π értékét eps relatív pontossággal a Stirling-formula segítségével: 

π = 

lim 

n→∞ 

( ) 

1 n! e 

n 2 

2n n n . 

Fontos azonban, hogy n!, n n és e n értékét ne közvetlenül számítsuk ki a túlcsordulás veszélye miatt, hanem 

az alábbi alakban: 

n! e n 

n n 

= e n × 2e 

n × 3e (n − 1)e 

× · · · × × e. 

n n 

13

3. FEJEZET. CIKLUSUTASÍTÁSOK, ELÁGAZÁSOK 14 

Az eljárást függvényként definiáljuk kimenet nélkül, max rel hiba bemenettel stirling.m : 

stirling.m 

function stirling(max_rel_hiba) 

fprintf(’\n pi szamitasa Stirling-fromulaval \n’); 

eps=1.e5; 

n=1; 

while eps>max_rel_hiba 

a=1; 

for i=1:n 

a=a*i/n*exp(1); 

end; 

pii=a^2/2/n; 

eps=abs(pi-pii)/pi; 

n=n+1; 

end; 

fprintf(’\n n = %d \n kozelito ertek: %10.8f \n ... 

hiba: %10.8e \n \n’,n,pii,eps); 

A futtatás eredménye: 

>> stirling(1e-4) 

pi szamitasa Stirling-fromulaval 

n = 1668 

kozelito ertek: 3.14190677 

hiba: 9.99850013e-005 

Az eredmények: 

eps 10 −1 10 −2 10 −3 10 −4 

n 3 18 168 1668 

3.3. if 

A parancsok feltételes elvégzése. Szintaxis: 

if kifejezés1 

parancs1; 

parancs2; 

elseif kifejezés2 

parancsok 

else 

parancsok 

end 

Természetesen az elseif rész kihagyható, az else sem kötelező egyszintes if esetén. A feltételvizsgálatnál 

több kifejezés is összekapcsolható a logikai és &, vagy | ill. a nem ~ operátorokkal. Majd ha lesz valami jó, 

nemtriviális ötletem példaprogramra, írok egyet.

3. FEJEZET. CIKLUSUTASÍTÁSOK, ELÁGAZÁSOK 15 

3.4. switch 

Kapcsolás egy kifejezés több, előre megadott értéke esetén (ez általában megoldható if-el is, de akkor az 

eseményvizsgálat lassítja a programot). Tegyük fel pl., hogy adva van egy nap nevű string változónk: 

switch nap 

case {’hetfo’,’szerda’} 

program=’mozi’ 

case ’kedd’ 

program=’szinhaz’ 

case ’pentek’, program=’koncert’ 

otherwise, program=’Meg nem tudom...’ 

end 

C/C++ programozók figyelmébe: a Matlab-ban nem kell break parancs minden case után, csak az aktuális 

parancsok kerülnek hívásra.

4. fejezet 

Nemlineáris feladatok 

4.1. Polinomok zérushelyei 

Legyen adva az alábbi m-edrendű polinom: 

p(x) = 

m∑ 

a i x i = a 0 + a 1 x + a 2 x 2 + a 3 x 3 + · · · + a m x m . 

i=0 

Ekkor a fenti polinomnak pontosan m darab zérushelye van (multiplicitásokkal számolva), valósak és esetleg 

komplexek. A gyököket a roots(a) paranccsal kereshetjük meg, ahol a egy vektor, mely az együtthatókat 

tartalmazza x hatványai szerint csökkenő sorrendben, azaz a = [a m , a m−1 , . . . a 1 , a 0 ]. A függvény kimenete 

szintén egy vektor, mely a gyököket tartalmazza. Példaként számítsuk ki a 

polinom zérushelyeit (ahol i a képzetes egységgyök): 

p(x) = −4 + (3 + 5i)x − 2ix 2 + x 3 

>> a=[ 1 -2i 3+5i -4]; roots(a) 

ans = 

-1.2403 + 3.4313i 

1.1345 - 0.5762i 

0.1058 - 0.8551i 

4.2. Optimalizációs feladatok 

Logikailag ez a feladat megelőzi a nemlineáris egyenletrendszerek zérushelyeinek kérdését, ugyanis azokat is 

erre fogjuk visszavezetni. 

Nézzük előre az egy ismeretlen szerinti optimalizációt! Keressük azt az x 0 értéket, melyre 

f(x 0 ) = Min! és x 1 ≤ x 0 ≤ x 2 . 

(Egy maximumfeladatot analóg módon, −f(x 0 ) minimumfeladataként lehet megfogalmazni.) A alkalmazandó 

16

4. FEJEZET. NEMLINEÁRIS FELADATOK 17 

fminbnd.eps 

4.1. ábra. Az f(x) = (x − 1) 2 sin(10x) függvény és a két megtalált minimumhely. 

Matlab függvény a fminbnd(fun,x1,x2), mely a fun függvény x1 és x2 közötti egyik, lokális minimumhelyét 

próbálja megkeresni. Példaként keressük meg a 

f(x) = (x − 1) 2 sin(10x) 

függvény minimumát az 0 ≤ x ≤ 2 intervallumon! A kapcsolódó példaprogram (fminbnd demo.m) két 

iterációt indít, egyet a 0 ≤ x ≤ 2 intervallumon, másikat a 1 ≤ x ≤ 2-en. Mint az a 4.1 ábrán látszik, 

két különböző minimumhelyet talált meg az eljárás, ami erősen óvatósságra int a könnyelmű használattal 

kapcsolatban. A függvényhívás bal oldalán elegendő egy érték is (tehát pl. x1 az [x1,y1] helyett), ekkor 

csak minimumhely koordinátáját adja meg az eljárás. Az optimset paranccsal különböző opciókat állíthatunk 

be, itt az összes iterációs lépésről lekérdeztük az információt. Hasonlóan beállítható a tolerancia (TolX), a 

maximális iterációk száma (MaxIter) és a függvény kiértékeléseinek maximális száma (MaxFunEvals). A 

grafikával kapcsolatban a részleteket a 6. fejezet tartalmazza. 

function fmin1D_demo 

fmin1D demo.m 

[x1,y1] = fminbnd(@fv,0,2); 

[x2,y2] = fminbnd(@fv,1,2,optimset(’Display’,’iter’)); 

fplot(@fv,[0,2]), hold on 

plot(x1,y1,’rx’,’Markersize’,15), hold on 

plot(x2,y2,’r+’,’Markersize’,15), hold off 

xlabel(’x’), ylabel(’y’), grid on 

function y=fv(x) 

y=(x-1)^2*sin(10*x); 

A program kimenete: 

>> fmin1D_demo


Func-count x f(x) Procedure 

1 1.38197 0.138606 initial 

2 1.61803 -0.173796 golden 

3 1.76393 -0.546067 golden 

4 1.8541 -0.22152 golden 

5 1.73995 -0.543538 parabolic 

6 1.75356 -0.549226 parabolic 

7 1.75369 -0.549227 parabolic 

8 1.75381 -0.549228 parabolic 

9 1.75384 -0.549228 parabolic 

10 1.75377 -0.549228 parabolic 

Ha egy többváltozós függvény minimum- vagy maximumhelyeit szeretnénk megkeresni, az fminsearch 

eljárást kell használnunk. Az fminserach demo program az ún. Rosenbrock-féle banánfüggvény minimumát 

keresi: 

f(x, y) = 100(y − x 2 ) 2 + (1 − x) 2 , 

mely a minimumkereső eljárások egyik tesztfeladata. A minimumhely koordinátái (x, y) = (1, 1), az eljárást 

az (x 0 , y 0 ) = (−1.2, 1) pontból indítjuk, így annak át kell kelnie a két pont közti ” 

csúcson” (ld. 4.2 ábra). 

function fmin2D_demo 

fmin2D demo.m 

x0=-1.2; y0=1; z0=banan([x0 y0]); 

[x,z] = fminsearch(@banan,[x0,y0]) 

ezsurf(’100*(y-x^2)^2+(1-x)^2’,[-1.3,1.3,0.5,1.5]), hold on 

plot3(x0,y0,z0,’r*’,’Markersize’,30), hold on 

plot3(x(1),x(2),z,’y*’,’Markersize’,30), hold off 

xlabel(’x’), ylabel(’y’), zlabel(’z’), grid on 

function y=banan(x) 

y=100*(x(2)-x(1)^2)^2+(1-x(1))^2; 

4.3. Nemlineáris függvények zérushelyei 

Itt megint azzal az egyszerű esettel kezdjük, amikor egyváltozós nemlineáris függvény zérushelyét kell megtalálnunk. 

A rendelkezésünkre álló beépített Matlab függvény az fzero(fun,x0), mely a fun függvény 

zérushelyét keresi x0 közelében. Használata teljesen analóg az fminbnd használatával. Amennyiben x0 egy 

vektor, pl. [x1 x2], az eljárás feltételezi, hogy fun(x1) és fun(x2) előjele különböző (ellenkező esetben 

hibaüzenettel tér vissza) és az adott intervallumon azt a pontot keresi meg, ahol fun előjelet vált. 

Meglepő módon, nincsen 1 az fminsearch-el analóg eljárárás, azaz olyan függvény, mely nemlineáris egyenletrendszerek 

zérushelyeit keresi meg. Egy egyszerű trükkel azonban könnyen felhasználhatjuk az fminsearch 

1 azaz én nem találtam meg...


banan.eps 

4.2. ábra. A banánfüggvény, az iteráció kiindulópontja (piros csillag) és a megtalált minimumhely (sárga 

csillag). 

eljárást ilyen célra. Legyen adva ugyanis az alábbi nemlineáris egyenletrendszer: 

F 1 (x 1 , x 2 , . . . , x n ) = 0, 

F 2 (x 1 , x 2 , . . . , x n ) = 0, 

. 

F n (x 1 , x 2 , . . . , x n ) = 0. 

Ha most valamilyen (x 0 1, x 0 2, . . . , x 0 n) értékeket behelyettesítünk a fenti egyenletbe, nyilván nem fog teljesülni, 

hanem valamilyen nemnulla hiba lesz az eredmény: F i (x 0 1 , x0 2 , . . . , x0 n ) = r i. Ezek után a fenti egyenlet zérushelyének 

koordinátáira igaz lesz, hogy 

R(x 1 , x 2 , . . . , x n ) = 

n∑ 

ri 2 

i=1 

= Min! = 0. 

Példaként tekintsük az alábbi differenciálegyenlet rendszert (DER), mely egy sorbakapcsolt ventillátor, cső, 

tartály és fojtás dinamikus viselkedését írja le: 

d 

dt Q 

d 

dt ∆p 

= f(Q) − ∆p = F 1(Q, ∆p) 

= Q − a√ ∆p = F 2 (Q, ∆p), 

ahol a ventillátor jelleggörbéjét a 

f(Q) = 0.27 + 0.18 

(1 + 3 2 (4Q − 1) − 1 ) 

2 (4Q − 1)3 

(4.1) 

függvény írja le. Ki szeretnénk számolni a DER egyensúlyi helyzeteit, melyekben a rendszer nyugalomban van, 

azaz minden változó idő szerinti deriváltja zérus. Tehát meg kell keresnünk az F 1 (Q, ∆p) = 0, F 2 (Q, ∆p) = 0 

nemlineáris egyenletrendszer megoldásait. Grafikailag a megoldást a ventillátor jelleggörbe ∆p v = f(Q) 

és a fojtás jelleggörbe ∆p f = 1 

a 

Q 2 metszéspontja adja. A kapcsolódó Matlab program ventillator.m 

2 

közvetlenül a nemlineáris egyenletrendszert oldja meg az előzőekben leírt séma szerint.


ventillator.eps 

4.3. ábra. Ventillátor- és fojtásjelleggörbe ill. a kiszámolt metszéspont. 

1 function ventillator 

ventillator.m 

2 

3 a=0.6; 

4 

5 q0=0.5; dp0=0.6; 

6 [x,z] = fminsearch(@hiba,[q0,dp0],[],a); 

7 

8 xx=0:0.01:0.9; 

9 yv=jelleggorbe(xx); 

10 yf=1/a^2*xx.^2; 

11 plot(xx,yv,xx,yf,x(1),x(2),’ro’) 

12 axis([0 0.9 0 0.8]), grid on 

13 xlabel(’Q’), ylabel(’\Delta p’) 

14 

15 function R=hiba(x,a) 

16 

17 Q =x(1); dp=x(2); 

18 r1 = jelleggorbe(Q)-x(2); 

19 r2 = Q-a*sqrt(dp); 

20 R=r1^2+r2^2; 

21 

22 function dp=jelleggorbe(q) 

23 

24 dp=0.27+0.18*(1+1.5*(4*q-1)-0.5*(4*q-1).^3); 

Külön magyarázatot igényel a 6. sorban az üres szögletes zárójel. Az a változó szeretnénk a főprogram 3. 

sorában beállítani és aztán átadni az összes többi eljárásnak is. Ezt megtehetjük az fminsearch argumentumlistájában, 

de ott a kezdeti értékek után az options változónak kell állnia és csak azután kerülhetnek 

be az egyéb extra argumentumok. Ezért, bár semmilyen opciót nem kívánunk igénybe venni, ki kell tennünk 

a szögletes zárójelet és csak azután kerülhet be az a változó. 

Ártatlannak tűnhet még a 24. sor végén kitett pont a ∧3 előtt, azonban ez nagyon is fontos. Ugyanis ha a 

jellegörbe eljárást csak skalár értékkel hívnánk meg, ez a pont nem kellene, de a 9. sorban az xx vektor


szerepel az argumentumban és így az eljárásnak egy vektort kell a harmadik hatványra emelnie a 24. sorban. 

Természetesen ezt elemenként szertnénk elvégezni, ezért ki kell tenni a pontot. A grafikával kapcsolatban a 

részleteket a 6. fejezet tartalmazza.

5. fejezet 

I/0 

Legegyszerűbben a sorvégi pontosvessző elhagyásával vagy a disp() paranccsal jeleníthetjük meg a parancsablakban 

egy változó, string, stb. értékét. Formázott adatkivitelt a C nyelvhez hasonló operátorokkal 

valósíthatunk meg. 

A formázás szintaktikája a következő: 

io.eps 

Fontosabb értékek: 

zászló + A szám előjelét mindig kiírja. 

- Balra igazítja a számot a mezőben. 

0 A lefoglalt mezőben a kihasználatlan karaktereket 0-val tölti fel 

(és nem az alapértelmezett szóközzel). 

mezőszélesség 

Az eredménynek lefoglalt karakterek száma. 

pontosság 

A tizedesvesszőtől jobbra megjelenítendő jegyek száma. 

formázás módja %d Decimális megjelenítés (egész típus számára). 

%e Exponenciális (tudományos) formátum. 

%f Lebegőpontos megjelenítés. 

%g Legjobb formátum az adott szám számára. 

%s String megjelenítése. 

Pozicionálás mezők között: 

\n új sor 

\t tabulátor 

5.1. Formázott kivitel (output) 

A formázott adatkivitel legfontosabb parancsa az fprintf(), amellyel mind képernyőre, mind fájlba írhatunk: 

22

5. FEJEZET. I/0 23 

képernyőre: 

fprintf(formátum,a,b,c) 

Itt a formátum egy sztring, pl. 

’a=%g \t b=%+10.7e vegul egy egesz: c=%d es jon a sorleptetes:\n’ 

fájlba: 

azonosító = fopen(filenév,jogok) 

fprintf(azonosító,formátum,a,b,c) 

fclose(azonosító) 

Az fopen() parancs megnyitja a filenév állományt a megadott jogokkal (amit el lehet hagyni, ekkor csak 

olvasásra). Megnyitás után az fprintf() a már leírt szintaktikával működik, de az argumentumlista elején 

a kimenet azonosítóját meg kell adni. Végül pedig lezárjuk a fájlt az fclose() paranccsal. 

A jogok lehetnek: 

r olvasás (read), ez az alapbeállítás. 

w file megnyitása/létrehozása írásra (write), már létezű file esetén a 

tartalom elvész. 

a létező file megnyitása/létrehozása hozzáírásra (append). 

r+ file megnyitása írásra és olvasásra. 

w+ file megnyitása/létrehozása írásra és olvasásra, már létezű file 

esetén a tartalom elvész. 

a+ file megnyitása/létrehozása írásra és olvasásra, már létezű file 

esetén a tartalom nem vész el, az új adatokat a végéhez fűzi. 

5.1.1. Mátrix kiírása fájlba 

A kovetkezo program formazva, elemrol elemre menti el M mátrix tartalmat (demo io 1.m). 

demo io 1.m 

% Az adatok: 

M= [ 1.2345 2.56 3.009 -4.01 

-5.45e4 6245 76543 -453458 

9 8 1.23e-5 0]; 

% Fajlnyitas 

adatfajl = fopen(’demo_io_1.dat’,’w’); 

% Iras tabulatorral tagolva, legalkalmasabb formatumban 

for i=1:length(M(:,1)) 

for j=1:length(M(1,:)) 

fprintf(adatfajl,’%g \t’,M(i,j)); 

end; 

fprintf(adatfajl,’\n’); 

end; 

% Kihagyunk ket sort.... 

fprintf(adatfajl,’\n\n’); 

% Iras fix szelesen, tabulatorral, tudomanyos formatumban


for i=1:length(M(:,1)) 

for j=1:length(M(1,:)) 

fprintf(adatfajl,’%+10.5e \t’,M(i,j)); 

end; 

fprintf(adatfajl,’\n’); 

end; 

% Fajl lezarasa 

fclose(adatfajl); 

5.2. Formázott beolvasás (intput) 

A legegyszerűbb eset az, ha a beolvasandó fájlban struktúráltan, mátrixszerűen, csak numerikus értékek 

vannak, ekkor megúszhatjuk egy load() paranccsal. Bonyolultabb esetben (pl. mérési eredmények) azonban 

a fájlnak fejléce van, nem egy mátrixot akarunk kiolvasni hanem több számot, stb... 

5.2.1. Adatfájlból beolvasás 

Tegyük fel pl., hogy az adatfájlunk így néz ki (adatok.dat): 

adatok.dat 

Meres helye: BME Vizgepek labor 

Meres ideje: 2002.12.25 

Merest vegezte: Hos Csaba 

Mintaveteli frekvencia: 10200 Hz 

adatfile felepitese: t,p1,p2 

0.1 1.1 2.1 

0.2 1.3 2.01 

0.3 1.6 1.9 

0.4 1.8 1.4 

Ekkor az alabbi script segitsegevel kiolvashatunk mindent (demo io 2.m): 

fp=fopen(’adatok.dat’,’r’); 

demo io 2.m 

% A 13. karaktertol a sorvegig olvassuk a nevet: 

temp=fseek(fp,13,’bof’); % bof >> beginning of file 

hely=fgetl(fp); 

% az aktualis poziciotol sorvegig 

disp(hely); 

temp=fseek(fp,13,’cof’); % cof >> current position in the file 

datum=fscanf(fp,’%4f.%2f.%2f\n’); 

% a datum 3 elemu vektorban van az ev, honap, nap 

disp(datum’); 


nev=fgetl(fp); 

disp(nev);



frek=fscanf(fp,’ %g Hz’); 

disp(frek); 

% 2 sort ugrunk 

for i=1:2 

temp=fgetl(fp); 

end; 

% 3 oszlopu matrixot olvasunk, ameddig csak lehet (>> inf) 

A=fscanf(fp,’%g %g %g’,[3 inf]); 

A=A’; % igy lesz jo... 

disp(A); 

% lezarjuk az adatfajlt, ahogy azt illik 

fclose(fp);

6. fejezet 

Grafika 

A grafikák készítését is áthatja a vektor-alapú szemlélet: pl. a plot(x,y) parancs az x és y vektorok által 

megadott pontokat rajzolja ki. Parancssorból (scriptből) az ábra formázása elkészíthető és a már elkészült 

ábra is tovább alakítható, de a grafikus ablakon beállított formázások újrarajzoláskor elvesznek. A rajzok 

elmenthetőek xxx.fig formátumban, ami a Matlab-bal bármikor megnyitható és tovább alakítható. Exportálni 

is lehet számos grafikai típusban (.bmp, .gif, .jpg, .eps, .ps), de ezek utólag már nem alakíthatóak (Matlabbal). 

Tehát az ábrákat érdemes először xxx.fig formátumban teljesen elkészíteni és csak utána exportálni. 

Íme egy kis példa 2D grafikára (demo 2d grafika.m) : 

sin.eps 

6.1. ábra. A demo 2d grafika.m script kimenete. 

demo 2d grafika.m 

% x és y vektorok elkeszitese: 

x = -pi:.1:pi; 

y = sin(x).*cos(x); 

% Rajzolas: 

26

6. FEJEZET. GRAFIKA 27 

plot(x,y,’r-.’); 

%Beallitasok: 

grid; xlabel(’-\pi \leq \phi \leq \pi’); ylabel(’sin(\phi) cos(\phi)’); 

title(’Az y(\phi)=sin(\phi)cos(\phi) fuggveny grafikonja’) 

% x tengelyen a jelolo atallitasa: 

set(gca,’XTick’,-pi:pi/2:pi); 

set(gca,’XTickLabel’,{’-pi’,’-pi/2’,’0’,’pi/2’,’pi’}); 

Egy másik példa 3D grafikára (demo 3d grafika.m) : 

demo 3d grafika.m 

[X,Y] = meshgrid([-2:0.1:2]); 

Z = sin(X.*Y); 

% Elso abra rajzolasa (vonalasan) 

figure(1); 

plot3(X,Y,Z); 

% Masodik abra rajzolasa (feluletkent) 

figure(2); 

ezmeshc(’sin(x*y)’,[-2,2,-2,2]); 

xlabel(’x’); ylabel(’y’); zlabel(’z’); 

title(’A sin(xy) fuggveny.’); 

sinxy.eps 

6.2. ábra. A demo 3d grafika.m script második ablaka.

7. fejezet 

Interpoláció 

7.1. Egydimenziós interpoláció 

Egydimenziós interpoláció esetén az yi = interp1(X,Y,xi,módszer) eljárást használjuk, ahol X és Y tartalmazza 

az adatokat és az xi pontokban szeretnénk az interpolált értékeket megkapni. A beépített módszerek: 

’nearest’ 

’linear’ 

’spline’ 

’pchip’ 

’v5cubic’ 

Legközelebbi szomszéd” interpoláció. 

” 

Lineáris interpoláció (alapbeállítás). 

Harmadfokú spline interpoláció. 

Harmadfokú szakaszos Hermite interpoláció. 

Harmadfokú interpoláció az Matlab 5-bűl. 

A ’nearest’, ’linear’, és ’v5cubic’ módszerek esetén interp1(X,Y,xi,módszer) NaN (Not-a-Number) üzenettel 

tér vissza xi azon elemeire, melyek az x értékei által meghatározott szakaszon kívül esnek. A többi módszer 

ez esetben extrapolál. 

7.2. Többdimenziós interpoláció 

Kétdimenziós interpoláció esetén az 

zi = interp2(x,Y,z,xi,yi,módszer) 

eljárást használhatjuk, teljesen analóg módon az előzőekkel. Mindezek egyszerű általánosítása a 

vi = interp3(x,Y,z,v,xi,yi,zi,módszer) 

háromdimenziós és a 

yi = interp3(x1,x2,x3,y,x1i,x2i,x3i,módszer) 

sokdimenziós interpoláció. 

28

8. fejezet 

Görbeillesztés 

Az alap Matlab csomagban csak a polinomiális görbeillesztés található meg előre kész eljárás formájában. A 

p = polyfit(x,y,n) 

parancs eredménye p vektor, mely az n-edfokú polinom együtthatóit tartalmazza csökkenű kitevő szerint. 

Ha egyszer ezeket az együtthatókat kiszámítottuk, tetszőleges xi pontokban 

yi = polyval(p,xi) 

paranccsal számíthatjuk ki a függvény értékét. 

A polyfit pelda.m program az f(x) = x 2 sin(5x) függvényhez illeszt poinomot a (0, π/2) intervallumon, 

majd kiszámítja a kapott polinom eltérését az osztáspontokban a norm parancs segítségével. 

polyfit pelda.m 

function polyfit_pelda 

X=0:0.01:pi/2; Y=sin(5*X).*X.^2; 

for i=1:1:10 

p=polyfit(X,Y,i); 

yy=polyval(p,X); 

hiba=norm(Y-yy,2); 

fprintf(’\nfokszam: %2d, hiba=%5.3e’,i,hiba); 

end 

>> polyfit_pelda 

fokszam: 1, hiba=9.571e+00 




fokszam: 5, hiba=8.731e-01 






29

9. fejezet 

Közönséges differenciálegyenletek 

(ODE) megoldása 

Amennyiben közönséges differenciálegyenleteket szeretnénk numerikusan megoldani, az első lépés mindenképpen 

az, hogy elsőrendű alakra kell átírni az ún. Cauchy-átírással. Ez általánosan úgy történik, hogy ha adva van 

a 

d (n) z 

( 

) 

dx n = G x; z (n−1) , z (n−2) , . . . , z 

függvény, akkor új változókat vezetünk be: y 1 = z, y 2 = z ′ = z (1) , y 3 = z ′′ = z (2) ,...,, y n−1 = z (n−1) . Így 

megoldandó a 

⎛ ⎞ ⎛ 

⎞ 

y 1 F 1 (x; y 1 , y 2 , . . . , y n ) 

d 

y 2 

⎜ ⎟ 

dx ⎝ . ⎠ = F 2 (x; y 1 , y 2 , . . . , y n ) 

⎜ 

⎟ 

⎝ . ⎠ 

y n F n (x; y 1 , y 2 , . . . , y n ) 

közönséges differenciálegyenlet rendszer (a Cauchy-átírás a példákon keresztül könyebben megérthető). Kezdeti 

érték feladatról beszélünk, ha az y(x 0 ) = ( y 0 1 , y0 2 , . . . , y0 n) 

kezdeti értékből kiindulva kíváncsiak vagyunk 

y(x 1 ) értékére. Peremérték feladatról beszélünk, ha y(x 0 ) mellett elő van írva y(x 1 ) is, ekkor azonban a megoldás 

létezéséhez általában meg kell adni a DE-ben egy szabad paramétert is. A DE jobb oldalához tartozó 

Jacobi mátrix elemeit következőképpen számíthatjuk: 

J ij = ∂F i(x; y 1 , y 2 , . . . , y n ) 

∂y j 

ahol i, j = 1 . . . n. 

9.1. Kezdeti érték feladatok (IVP) 

A megoldó szintaktikája a következő: 

[t,y] = megoldó(odefun,tspan,y0,options) 

ahol megoldó a numerikus módszert jelöli, odefun a DE jobb oldalát meghatározó függvényt, tspan vektor 

a megoldás intervallumát ([x_eleje x_vége]), y0 a kezdeti feltételek vektora és options a nem kötelező, 

esetleges további beállításokat tartalmazza. 

A numerikus megoldók az alábbiak lehetnek: 

30

9. FEJEZET. KÖZÖNSÉGES DIFFERENCIÁLEGYENLETEK (ODE) MEGOLDÁSA 31 

NEM Merev feladatok: 

ode45 

ode23 

ode113 

Explicit, egylépéses, negyedrendű Runge-Kutta képlet. Általában 

ez lehet az első próbálkozás. 

Szintén egylépéses Runge-Kutta típusú módszer. Enyhén 

merev feladatoknál gazdaságosabb lehet, mint az ode45. 

Változó rendű, többlépéses Adams-Bashforth-Moulton PE- 

CE megoldó. Ha nagyon pontos megoldásra van szükség 

vagy a DE nagyméretű (a jobb oldal kiszámítása drága), 

gazdaságosabb lehet, mint az ode45. 

Merev (stiff) feladatok: 

ode15s 

ode23s 

ode23t 

ode23tb 

Változó rendű többlépéses módszer. Ha az ode45 nem 

működik és gyanús, hogy ez a DE merevsége miatt van, 

ez lehet az elsű nekifutás. 

Ezek is mind merev megoldók, a pontos dokumentáció a 

Help-ben megtalálható. 

Az options változó fontosabb lehetőségei: 

Hiba (pontosság) beállítása 

RelTol 

AbsTol 

NormControl 

Relatív hiba. 

Abszolút hiba. 

A relatív hibát hibrid módon, a megoldás normájával 

számítja. 

Megoldó kimenet 

OutputFcn 

OutputSel 

Refine 

Stats 

A felhasználó által beállítható kimeneti függvény (ilyen lehet 

pl. az odeplot függvény). 

A megoldásmátrix mely indexeit adja át a kimeneti fv.-nek. 

Ha a megoldó túl nagyokat lép és nem vagyunk megelégedve 

a megoldás felbontásával, ezzel átállíthatjuk az elmentett 

lépések sűrűségét, így a program maga nem lassul. 

Statisztika 

Jacobi mátrix 

Jacobian A Jacobi mátrixot explicit módon, függvény alakjában a 

felhasználó definiálja. 

JPattern A Jacobi mátrix nemnulla elemei helyére 1-et, máshova 0-t 

kell írni. így a megoldó a nulla elemeknek megfelelű deriváltakat 

meg sem próbálja kiszámítani, ami gyorsítja a 

programot. 

Vectorized Vektorizálás. (Én nem igazán értem, miért jó. Ha valaki 

elmesélné, hálás lennék.) 

Lépésköz


Esemény figyelés 

InitialStep Javasolt kezdőlépés. 

MaxStep Maximális lépésköz. Ha a kiszámított megoldást túl 

durvának tartjuk és sűríteni szeretnénk a pontokat, a refine 

parancsot használjuk! 

Events 

Ha valamilyen esemény bekövetkezését szeretnénk nyomon 

követni (pl. ütközés, valamilyen határérték elérése, stb.) ezt 

kapcsoljuk be. Ilyenkor az integrálás megállítható. 

9.1.1. Szabadsugár sebességeloszlása 

Egy kétdimenziós szabadsugár sebességeloszlásának számítása az alábbi kezdeti érték feladatra vezet: 

F ˙ F = ¨F 2 , ahol F (0) = 1 és ˙ F (0) = 0. 

Bevezetve az y 1 = F és az y 2 = ˙ F új koordinátákat kapjuk az elsőrendű DE rendszert: 

) ( ) 

(ẏ1 y2 

= 

ẏ 2 − √ y 1 y 2 

(A negatív előjelű gyök kell ẏ 2 egyenletében, különben a megoldások a végtelenhez tartanak.) Az alábbi kis 

program megoldja a feladatot (szabadsugar.m) . 

szabadsugar.eps 

9.1. ábra. A szabadsugár feladat megoldása. 

szadadsugar.m 

function szabadsugar 

[t,y] = ode45(@f,[0 2.5],[0; 1]); 

plot(t,y(:,2)); 

xlabel(’\xi’); ylabel(’F’); 

title(’Szabadsugar’);


function dydt = f(t,y,mu) 

dydt = [ y(2) 

-sqrt(y(1)*y(2))]; 

9.1.2. Egy merev feladat: a Van der Pol egyenlet 

Balthazar van der Pool 1927-ben egy vákuumcsövet tartalmazó egyszerű áramkör vizsgálata közben időnként 

zajokat figyelt meg. Az áramkört modellező egyenlet 

ẍ + µ ( x 2 − 1 ) ẋ + x = 0 

valóban öngerjesztett rezgéseket mutat bizonyos µ paramétertartományokban (ami meglepő volt, hiszen 

explicit időfüggés nincs az egyenletekben, azaz senki sem ’rázza’ a rendszert). Hogy a numerikus megoldót 

használni tudjuk, először Cauchy átírással elsőrendű rendszerré alakítjuk az y 1 = x és y 2 = ẋ új változók 

segítségével, amivel az egyenlet az 

) ( 

) 

(ẏ1 

y 

= 

2 

ẏ 2 µ ( ) 

1 − y1 

2 y2 − y 1 

alakot ölti. A (van der Pol.m) példaprogramban átállítjuk a relatív hibát 10 −4 -re és az ode15s megoldót 

használjuk, mert a feladat merev (gyors-lassú mozgást végez a rendszer). 

van der Pol.m 

function van_der_Pol(mu) 

options = odeset(’RelTol’,1e-4); 

[t,y] = ode15s(@vdp,[0 3000],[2; 0],options,mu); 

plot(t,y(:,1)); 

xlabel(’t’); ylabel(’y_1’); 

title([’van der Pol egyenlet, \mu=’,num2str(mu)]); 

function dydt = vdp(t,y,mu) 

dydt = [ y(2) 

mu*(1-y(1)^2)*y(2)-y(1)]; 

9.1.3. Eseménykezelés: vízcsepp alakja 

A csapból lassan kifolyó vízcsepp y(x) alakját a 

y ′′ 

(1 + y ′2 ) + y ′ 

3/2 x (1 + y ′2 ) = 1/2 2y′′ (0) − ρg 

σ y 

egyenlet írja le, ahol σ a felületi feszültség, ρ a folyadék sűrűsége. Az egyenletet numerikus célokra átírva 

kapjuk a


van_der_Pol.eps 

9.2. ábra. A van der Pol egyenlet megoldása. 

) ( 

) 

(ẏ1 

y 2 

= 

ẏ 2 (A − By 1 ) ( 1 + y2) 2 3/2 

− 

y 2 

( ) 

t 

1 + y 

2 

2 

A (csepp.m) programban a numerikus megoldás során figyeljük y 2 értékét (ami a felületet leíró görbe meredeksége) 

és ha már majdnem függőleges (itt y 2 > 10 4 ), abbahagyjuk az integrálást. Ezt valósítja meg az 

events(t,x) eljárás. 

function csepp 

global A B 

A=1; 

B=0.1343; 

csepp.m 

options = odeset(’Events’,@events); 

[t,x] = ode45(@f_csepp,[1e-5 10],[0; 0],options); 

plot(t,x(:,1),’k’,-t,x(:,1),’k’); 

title([’Vizcsepp alak, A=’,num2str(A)]); 

xlabel(’x’); 

ylabel(’y’); 

%----------------------------------------------------- 

function dxdt = f_csepp(t,x) 

global A B 

dxdt = [x(2); 

(A-B*x(1))*(1+x(2)^2)^(3/2)-x(2)/t*(1+x(2)^2)]; 

%------------------------------------------------------ 

function [value,isterminal,direction] = events(t,x) 

value = abs(x(2))-10^4; 

isterminal = 1; % megall az integralas 

direction = 0; % mindket iranyban


csepp.eps 

9.3. ábra. A vízcsepp alakja. 

9.2. Perem érték feladatok (BVP) 

A peremérték feladatok esetén egyrészről ugyanúgy definiálni kell a DE jobb oldalát, mint a kezdeti érték 

feladatoknál, de két további eljárásra is szükség van: a peremfeltételeket definiáló függvényre és a megoldót 

inicializáló eljárásra. Nagyon fontos, hogy ’jó’ kiindulófüggvényt válasszunk az iterációhoz, mert ez jelentősen 

megkönnyíti a megoldást. 

BVP megoldó szintaktika: 

sol = bvp4c(odefun,bcfun,solinit), 

ahol 

odefun tartalmazza a DE jobb oldalát. Formája a szokásos dydx = odefun(x,y), ahol x skalár, y és dydx 

pedig oszlopvektor. 

bcfun definiálja a peremfeltételeket nullára rendezve. Formája res = bcfun(ya,yb), ahol ya és yb oszlopvektorok, 

melyek a megoldást reprezentálják a tartomány elején és végén. res egy oszlopvektor, mely 

a rezíduumokat tartalmazza. 

solinit inicializálja a megoldást x által kifeszített hálón y értékekkel. A peremfeltételeket a=solinit.x(1) 

és b=solinit.x(end) helyeken értelmezzük. Ez az eljárás opcionális, az inicializáló vektorok feltöltése 

másként is lehetséges (pl. adatfájlból). 

sol az eredményeket tartalmazó struktúra. Mivel a felhasznált numerikus megoldó mozgóhálós kollokációs 

módszer, az x-ben definiált kezdeti hálót a megoldó felülírta. 

Érdemes még a bvpinit és a deval eljárásokat használnunk; az első az inicializálást könnyíti meg, a második 

pedig a kapott eredmények kiértékelését. Fontos még tudnunk, hogy a peremfeltételek száma: 

N peremfeltételek = N ODE + N paraméterek , 

ui. egyes esetekben szabad paramétereket kell hagyni a DE rendszerben a megoldás létezésének biztosítására. 

A következő példákban extra paraméterek keresésével nem foglalkozunk (ld. Help: Matthieu egyenlet sajátértéke),


de pl. ilyenre vezet periodikus megoldások keresése is, de ekkor a peremfeltétel egy ismeretlen x = T helyen 

van. Ilyenkor a T ismeretlen periódussal átskálázzuk az x változót és így már jól definiált a feladat: 

y ′ (x) = T F (x, y) ahol y(0) = y(1), 

és még egy peremfeltételt elő kell írni T szabad paraméter miatt, ami általában a fázisra vonatkozik. 

9.2.1. Couette áramlás sebességgradienssel 

Két síklap közötti lamináris, stacioner áramlást leírja az 

∂p 

∂x = µ ∂2 v 

∂y 2 , 

egyenlet, ahol a x a hosszirányú, y a keresztirányú koordináta. Ha a ∂p 

∂x 

nyomásgradiens konstans, a fenti 

egyenlet zárt alakban megoldható. Két speciális eset a Poiseuille-áramlás (mindkét lap áll és a nyomásgradiens 

nemzérus, ekkor a sebességeloszlás parabolikus) és a Couette-áramlás (ekkor az egyik lap mozog, nincs 

nyomásgradiens, a sebességprofil pedig lineáris). Ha van nyomásgradiens és a felső lap is mozog, akkor is 

megoldható a feladat zárt alakban, a sebességprofil egy ’ferde tengelyű’ parabola. Ha a két lap távolsága 

h = 1m, az mozgó fal sebessége v 0 = 2m/s és az áramló közeg víz, akkor mivel Re = vh/ν ≈ 10 3 , az áramlás 

még a lamináris tartományban van. A probléma peremértékfeladatként megfogalmazva: 

y ′ 1 = y 2 

y ′ 2 = 1 

ρ ν 

a tapadás törvénye miatt a peremfeltételek pedig az y(0) = 0 és y(1) = v 0 alakot öltik. A Matlab program 

így néz ki : 

∂p 

∂x , 

function couette 

couette.m 

global P v0 nu 

P = -0.01; v0 = 2; nu = 0.001; 

% Megoldas inicializalasa: 

solinit=bvpinit(linspace(0,1,10),@mat4init); 

% Megoldo hivasa: 

sol=bvp4c(@mat4ode,@mat4bc,solinit); 

% Eredmenyek interpolalasa: 

xint = linspace(0,1,100); 

Sxint = deval(sol,xint); 

% Szinezes csusztatofeszultseg szerint: 

tau_max=max(Sxint(2,:)); 

tau_min=min(Sxint(2,:)); 

for i=1:length(Sxint(1,:)) 

szin=(Sxint(2,i)-tau_min)/(tau_max-tau_min); 

plot(Sxint(1,i),xint(i),’+’,’MarkerEdgeColor’,[szin 0.5*szin 0.75-0.5*szin]);


hold on; 

end; 

hold off; 

title([’Adatok: dp/dx=’,num2str(P),’ \nu=’,num2str(nu)],’FontSize’,14); 

xlabel(’aramlasi sebesseg, v’,’FontSize’,14); 

ylabel(’keresztemtszet, x’,’FontSize’,14); 

%--------------------------------------------- 

function dydx=mat4ode(x,y) 

global P nu 

dydx=[ y(2); P/nu]; 

%---------------------------------------------- 

function res=mat4bc(ya,yb) 

global v0 

res=[ ya(1); yb(1)-v0]; 

%--------------------------------------------- 

function yinit=mat4init(x) 

global v0 

yinit = [ v0*x^2; 2*v0*x ]; 

couette.eps 

9.4. ábra. Sebességeloszlás Couette áramlás esetén nyomásgradienssel, τ csúsztatófeszültség szerint színezve.

10. fejezet 

Fourier analízis 

Fourier analízist és frekvenciaspektrumot az fft(y,N) paranccsal végezhetünk, ahol N 2 egész számú hatványa 

(mivel a Matlab gyors Fourier transzformációt alkalmaz). Inverz transzormáció az ifft paranccsal 

számítható. 

Például vegyünk egy 1000Hz-el mintavételezett jelet, mely egy 50 és egy 120 Hz-es komponenset tartalmaz, 

de el van rontva egy véletlenszerű, zérusátlagú zajjal. Végezzük el a Fourier-transzformációt és számítsuk ki 

a komplex amplitúdó abszolúrtékét (fft demo.m ). 

t = 0:0.001:0.6; 

x = sin(2*pi*50*t)+sin(2*pi*120*t); 

y = x + 2*randn(size(t)); 

n=8; 

Y = fft(y,2^n); 

Pyy = Y.* conj(Y) / 2^n; 

f = 1000*(0:2^(n-1))/2^n; 

hossz=min(length(Pyy),length(f)); 

subplot(2,1,1) 

plot(t,x), xlabel(’t’), ylabel(’x(t)’) 

grid on, axis([0 0.6 -2.5 2.5]) 

subplot(2,1,2) 

plot(f(1:hossz),Pyy(1:hossz)) 

xlabel(’f [Hz]’), ylabel(’amplitudo’) 

grid on 

fft demo.m 

38

10. FEJEZET. FOURIER ANALÍZIS 39 

fft.eps 

10.1. ábra. Eredeti időjel és a spektrum.

11. fejezet 

Példaprogramok 

11.1. Karakterisztikák módszere 

Hidraulikus tranziensek számítása esetén a csövekben az áramlást az 1D mozgásegyenlet és a kontinuitási 

egyenlet 

∂v 

∂t + 1 ∂p 

ρ ∂x = S és ∂ρ 

∂t + ∂ρv 

∂x = 0. 

Tegyük fel, hogy a sűrűség csak a nyomás függvénye, azaz ρ = ρ(p), így ∂ρ/∂t = dρ/dp × ∂p/∂t. Vezessük 

be a hangsebességet: dρ/dp = a −2 . Adjuk hozzá a mozgásegyenlethez a kontinitási egyenlet λ szorosát: 

∂v 

∂t + λ ( 

∂p ∂v 

a 2 ∂t + λρ ∂x + 1 ) 

∂p 

λρ 2 = S. 

∂x 

Amennyiben az ismeretlen λ szorzót ± a dx 

ρ 

-nak választjuk, az (x, t) síkon két speciális irányban 

dt = ± egy - 

egy közönséges differenciálegyenletet kapunk: 

d 

dz 

(p ± ρav) = ∓ρag 

dt dx ∓ ρaS. 

A numerikus módszer ezek után egyszerű. A fenti differenciálegyenletet egy egyenközű rácson oldjuk meg, 

ahol az aktuális i-edik pontban a jellemzőket az i − 1 ből indított a meredekségű és az i + 1-edik pontból 

indított −a meredekségű karakterisztika segítségével határozzuk meg. 

Két programot készítettünk: egy önálló megoldót kar.m és egy vezérlő programot: kar driver.m. A megoldó 

bemenete a cső egyes paraméterei, a ’régi’ p és v nyomáseloszlás, ill. a peremfeltételek típusa és értéke (2 

db). Ezek alapján kiszámítja és visszaadja a ∆t-vel későbbi csőállapotot. A vezérlőprogram ezt az eljárást 

ismétli, ill. előkészíti a számítást és megjeleníti az eredményeket. 

40

11. FEJEZET. PÉLDAPROGRAMOK 41 

kar.m 

function [puj,vuj]=kar(adatok,p,v,PF0_tipus,PF0_ertek,PFN_tipus,PFN_ertek) 

D = adatok{1}(1); % csoatmero 

L = adatok{1}(2); % csohossz 

N = adatok{1}(3); % csodarabok szama (csomopontok szama: N+1) 

a = adatok{1}(4); % hangsebesseg 

ro = adatok{1}(5); % suruseg 

g = 9.81; 

dx = L/N; 

dt = dx/a; 

roa = ro*a; 

dzdx = adatok{2}; 

nu = 1e-6; 

lambda=0.02; 

for i=2:N 

ar = p(i-1)+ro*a*v(i-1); 

br = p(i+1)-ro*a*v(i+1); 

vuj(i) = (-2*dt*roa*g*dzdx(i)+ar-br)/roa/(2+dt*lambda/2/D*(abs(v(i+1))+abs(v(i-1)))); 

puj(i) = ( -dt*roa*g*dzdx(i)+ar)-roa*(1+dt*lambda/2/D* abs(v(i-1)))*vuj(i); 

end 

% Peremfeltetelek beallitasa. 

perem_1 = p(2)-ro*a*v(2) + dt*roa*g*dzdx(1); 

perem_N = p(N)+ro*a*v(N) - dt*roa*g*dzdx(N+1); 

szorzo1 = roa*(1+dt*lambda/2/D*abs(v(2))); 

szorzoN = roa*(1+dt*lambda/2/D*abs(v(N))); 

switch PF0_tipus 

case ’p’ 

puj(1) = PF0_ertek; 

vuj(1) = (puj(1)-perem_1)/szorzo1; 

case ’v’ 

vuj(1) = PF0_ertek; 

puj(1) = perem_1 + ro*a*vuj(1); 

otherwise 

error(’Ismeretlen peremfeltétel!’); 

end 

switch PFN_tipus 

case ’p’ 

puj(N+1) = PFN_ertek; 

vuj(N+1) = -(puj(N+1)-perem_N)/ro/a; 

case ’v’ 

vuj(N+1) = PFN_ertek; 

puj(N+1) = perem_N-szorzoN*vuj(N+1); 

otherwise 

error(’Ismeretlen peremfeltétel!’); 

end


function kar_driver 

kar driver.m 

% adatok 

D=0.05; A=D^2*pi/4; L=10; N=10; a=1000; 

ro=1000; lambda=0.02; tmax=0.1; 

% inicializalas 

t=0; dt=L/N/a; x=0:L/N:L; dzdx=zeros(1:N); 

% cell{} tip. vektorral több adattipust be lehet csomagolni 

adatok{1}=[D L N a ro]; adatok{2}=dzdx; 

% Inicializálás (t=0-hoz tartozó állapot) 

p=2e5*ones(1,N+1); v=zeros(1,N+1); i=1; 

% indulamandula 

while t


11.2. Nyíltfelszínű csatornaáramlás 

Nyíltfelszínű stacioner csatornaáramlás esetén 

y + z + v2 

2g + h′ = állandó, 

ahol y(x) a folyadékfelszín alakja, z a csatorna fenekének magassága, v az áramlási sebesség, h ′ pedig a 

veszteségmagasság. Ez utóbbi számítása a Chézy képlettel történik: 

dh ′ 

dx = 

v2 

C 2 , ahol R h = A R h K 

R1/6 

h 

és C = 

n . 

Itt A(y) a nedvesített felület, K(y) a nedvesített kerület, n pedig az cső érdességétől függő tényező. Figyelembe 

véve a kontinuitást, azaz hogy Q = Av = állandó, a fenti képlet kicsit megdolgozva a 

Q2 

A 2 C 2 R h 

dy 

dx = i − 

1 − Q2 B 

alakot ölti, ahol i a csatorna lejtése, B a folyadéktükör szélessége és g a gravitációs gyorsulás. 

A feladatot kezedti érték feladatként fogalmazzuk meg, azaz előírunk egy kezdeti folyadékszintet és térfogatáramot. 

Ismert, hogy ha a térfogatáram kisebb, mint az egyenes felszínhez tartozó normál térfogatáram, a folyadékszint 

duzzad, ha pedig nagyobb, akkor gyorsul a mozgás és kialakulhat a rohanás jelensége. Ezt kezelendő 

eseményfigyelést alkalmazunk, azaz a program automatikusan abbahagyja az integrálást, ha bekövetkezik 

az y = 0 esemény (rohanas(x,y)). 

Az alábbi program (nyiltfelszin.m) az egyszerűség kedvéért b szélességű, téglalap keresztmetszetű csatornát 

feltételez . Futtassuk le a programot Q = 0.2, 0.25, 0.298, 0.299, 0.3[m 3 /s] térfogatáramokkal! 

A 3 g 

nyiltfelszin.eps 

11.2. ábra. A nyiltfelszin.m program grafikus kimenete.


function nyiltfelszin 

global B n g Q ii 

nyiltfelszin.m 

Q = 0.298; % eloirt terfogataram 

y0= 0.6; % szint a csatorna elején 

ii = 0.001; % hidraulikai lejtes 

n = 0.01; % csoerdesseg 

B = 0.5; % csatorna szelesseg 

g = 9.81; % gravitacio 

L = 1000; % csohossz 

Rh = y0*B/(2*y0+B); 

C = Rh^(1/6)/n; 

Qn = y0*B*C*sqrt(ii*Rh); 

fprintf(’\n Nyiltfelszinu csatornaaramlas\n’); 

fprintf(’\n %g m-es cs}oeleji felszinhez tartozó térfogatáram: %g m^3/s’,y0,Qn); 

% Megoldo hivasa: 

options=odeset(’events’,@rohanas); 

[x,y]=ode45(@nyiltfelszin_de,[0 L],y0,options); 

% A csatorna alja és az ahhoz képesti folydékszint (rajzoláshoz): 

for i=1:length(x) 

yy(i)=ii*(1-x(i)/L)*L; 

yf(i)=yy(i)+y(i); v(i) =Q/y(i)/B; 

end 

figure(1) 

subplot(2,1,1), plot(x,yy,x,yf); 

title([’Nyiltfelszin}u csatornaáramlás: i=’,num2str(ii),’ 

ylabel(’folyadekfelszin, y [m]’,’FontSize’,12) 

legend(’csatorna feneke’,’folyadék felszíne’) 

axis([0 L 0 yf(1)*1.2]) 

Q=’,num2str(Q)],’FontSize’,12); 

subplot(2,1,2), plot(x,v); 

xlabel(’csohossz, x [m]’,’FontSize’,12); 

ylabel(’aramlasi sebesseg, v [m/s]’,’FontSize’,12); 

%--------------------------------------------- 

function dydx=nyiltfelszin_de(x,y) 

global B n g Q ii 

A=y(1)*B; Rh=y(1)*B/(2*y(1)+B); C=Rh^(1/6)/n; 

dydx=[ (ii-Q^2/A^2/C^2/Rh)/(1-Q^2*B/A^3/g)]; 

%--------------------------------------------- 

function [val,ter,dir]=rohanas(x,y) 

val=y(1); % Az esemény definiciója 

ter=1; % Állítsuk meg az integrálást. 

dir=0; % Mindkét irányban (1: + -> -, 2: - -> +)


11.3. Függőlegesből vízszintesbe vezető ívben mozgó anyagdugó 

Pneumatikus anyagszállítás témakörében felmerülő probléma, hogy egy függőlegesből vízszintesbe vezető 

90 o -os ívben hogyan mozog az anyagdugó. Tegyük fel, hogy az anyagdugó hossza nagyobb, mint az ív, azaz 

L > R π/2. Ekkor a mozgás 3 szakaszra osztható: 

• az anyagdugó tölti az ívet, 

• az anyagdugó az ívben mozog és 

• az anyagdugó ürül az ívből. 

A független változók az anyagdugó elejének (ill. végének) α szögelfordulása és az anyagdugó sebessége v a ,. 

helyzete z és gyorsulása a a . A mozgásegyenletek az egyes szakaszokban: 

1. szakasz (telítődés): 0 ≤ α ≤ π 2 

{ α ′ = 

√ 

z 

z ′ k 

= F 1 (α, z) = C 31 + Π 0 Π 2 d hs 

ρ g2 p 2 (v g2 − Rz) 2 + p 2 2 − µ 2 

(cos α − α) − 

sin α−α 

2 

− αµRz 2 

2. szakasz (mozgás az ívben): z + R π 2 ≤ L: ⎧ 

⎨ v a ′ = a a 

a ′ a = F 2 (a a , v a ) 

⎩ 

z a ′ = v a 

3. szakasz (ürülés): 0 ≤ α ≤ π 2 

{ 

α ′ = z 

z ′ = F 3 (α, z) 

Nincs értelme itt pontosan definiálni az egyes változókat és fizikai konstansokat, ezt az előadásjegyzete alapján 

mindenki megteheti. (Egyébként F 1 a legegyszerűbb mozgásegyenlet, ezért ezt írtam ki.) Azt viszont vegyük 

észre, hogy az egyenleteket egymás után szakaszosan kell megoldani éspedig úgy, hogy eseménykezeléssel 

meg kell állítani az integrálást és a végállapotból indítani a következő szakasz megoldását. Ez az 1. és a 3. 

szakaszban viszonylag egyszerű, mert α értékét kell figyelni, ami az egyik független változó. Ellenben a 2. 

szakaszban az elmozdulást kell figyelni, amire (eredetileg) nincs egyenlet (csak v a -ra és a a -ra), ezért csatolunk 

egy harmadik diff. egyenletet, mely az egyszerűen a z = ∫ v a kapcsolatból nyerhető. Így már tudjuk követni 

az anyagdugó helyzetét is. A példaprogram megtalálható az interneten www.hds.bme.hu. A kimenet a 11.3 

ábrán látható, az egyes szakaszok különböző szinekkel vannak feltüntetve.


pneu_iv.eps 

11.3. ábra. A pneu iv.m program grafikus kimenete.

Matlab Hogyan - Hidrodinamikai Rendszerek Tanszék

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?