KURZUS: Számítási módszerek

MODUL: Matematikai számítások MATLAB-bal

4. lecke Függvényábrázolás, grafika

Cél: A legtöbb gyakorlati feladat esetén jelentősen megkönnyíti a munkánkat és az eredmények meggyőző bemutatásához is hozzájárul, ha a megoldáshoz, illetőleg a szemléltetéshez megfelelően választott grafikai eszközöket használunk.

A MATLAB ezen a területen nagyon erős. A rendszer az egyszerűbb kétdimenziós ábrák készítését és hangolását magától értetődő alapként kínálja, de ezen túlmenően is igen sok hasznos szolgáltatással rendelkezik. Az elkészült ábrák különféle formátumú és felbontású fájlokba menthetők, sőt akár animáció készítésére is lehetőséget nyújtanak. Az eszköztár tervezésénél és összeállításánál külön, kiemelten figyeltek a mérnöki munka támogatására.

A mostani leckében az a célunk, hogy ezt a nagyon hasznos, de meglehetősen összetett, bonyolult grafikai "csomagot" praktikus példákon és egyszerűbb gyakorlati feladatokon keresztül mutassuk be, legalább addig a mélységig, ami az esetleges későbbi önálló tanuláshoz már szilárd alapot adhat.

Követelmények: Ön akkor sajátította el megfelelően a tananyagot, ha (a MATLAB segítségével)

  • ki tudja rajzoltatni az alapfüggvények grafikonját a plot és az fplot utasítás felhasználásával;
  • képes megadott képlet alapján saját függvényt készíteni, és a függvényt tudja ábrázolni a plot és az fplot utasítások segítségével;
  • képes függvény parancssori (anonymous) és sorközi (inline) megadására és ábrázolására;
  • képes a függvényábrákat hangolni (egyes szükséges jellemzőket módosítani);
  • el tud helyezni több függvényrajzot egy ábrán (a subplot utasítással);
  • megadott képlet alapján tud forgatómátrixot készíteni, és pontokkal adott alakzatot el tud forgatni;
  • meg tudja határozni az alapfüggvények és a saját függvények nevezetes pontjait (a megadott pontosságig);
  • meg tudja határozni két adott függvény metszéspontjait - különbségfüggvény felhasználásával (a megadott pontosságig);
  • képes a nevezetes pontokat és a metszéspontokat a függvényábrákon plusz elemként elhelyezni;
  • tud határozott integrált (függvény alatti területet) számolni a quad parancs segítségével.

Időszükséglet: A tananyag elsajátításához (a feladatok megoldásával együtt) hozzávetőlegesen 3 órára lesz szüksége.

Kulcsfogalmak

  • Plot és fplot utasítás, vezérlők, hangolás;
  • Saját függvény, függvény parancssori (anonymus) és sorközi (inline) megadása;
  • Forgatómátrix;
  • Függvényvizsgálat, nevezetes pontok, szélsőértékek;
  • Függvény alatti terület (határozott integrál).
A plot parancs

A rendszer grafikai lehetőségeinek megismerését egy nagyon egyszerű feladattal kezdjük: Ábrázoljuk a [0, 0] és az [1, 1] pontok által meghatározott szakaszt!

A megoldáshoz a plot parancsot használjuk (legegyszerűbb szintaktika), a megfelelő utasítás és az eredmény:

>> plot([0 1], [0 1])
Egyszerű plot utasítás
1. ábra

A plot paranccsal síkbeli pontokat az őket összekötő vonalakkal (szakaszokkal) együtt rajzolhatjuk fel. Külön vektorban adjuk meg az egyes pontok x-, illetve y-koordinátáit - plot(x, y). A parancs a megadott koordinátapárok alapján egy Figure ablakban beméretezi pontsorozatot, és a sorozat szomszédos pontjait egyenes szakaszokkal összeköti (automatikusan). A plot parancs az ábraelemek stílusára vonatkozó információkat is tartalmazhat (további paraméter(ek), lásd később).

Az elkészült ábra átméretezhető, ill. többféle módon is módosítható (menü és kis eszköztár a Figure ablakon, néhány lehetőséget később tárgyalunk).

Próbálja ki a MATLAB-ban a következő parancsot: plot([0 0], [1 1]). Mit vár, mi kerül a képernyőre? Értelmezze az eredményt!

Az alapértelmezett rajzolási szín a kék, de ez a parancs nem kötelező harmadik paraméterével módosítható. Példa:

>> plot([0 1 2], [0 2 1], 'r'% piros színű töröttvonal

Rajzolja ki a töröttvonalat zöld, majd fekete színnel! Ha szükséges, tanulmányozza a Súgót, illetve nézze meg a plot utasítás lehetséges harmadik paramétereit bemutató táblázatot!

Ez alapján látható, hogy a függvényábrázolási feladat megoldásához (a plot paranccsal) az szükséges, hogy egy megfelelően sűrű vektorba legyártsuk az alappontokat (linspace parancs vagy kettőspont operátor), majd erre húzzuk rá a függvényt.

A következő feladatban a sin(x) függvény grafikonját rajzoltatjuk ki a [ 2π , 2π ] intervallumban 1001 pont segítségével. Először elkészítjük az alappontokat:

>> x = linspace(-2*pi, 2*pi, 1001);  % szigorúan kiíratás nélkül!

Majd beírjuk a rajzoló parancsot:

>> plot(x, sin(x))

Az ábrát célszerű átméretezni, hogy az x és az y tengely skálázása nagyjából arányos legyen.

Egyszerű függvényrajz (szinusz függvény)
2. ábra

Az alappontok megfelelően sűrű előállítása ennél a feladatnál kulcslépés, mert anélkül a grafikonunk nem lesz korrekt.

Szemléltetésként rajzoltassuk ki ugyanerre az ábrára a szinusz függvény egy olyan közelítő rajzát, amely csak 11 alappontot tartalmaz!

>> hold on  % vászon kimerevítése, az előző ábra folytatását kérjük
>> x2 = linspace(-2*pi, 2*pi, 11);  % csak 11 alappont
>> plot(x2, sin(x2), 'r'% második függvény piros színnel
"Szép" és "csúnya" függvényrajz
3. ábra

A hold on kiadása után minden ábra/rajz egymásra kerül mindaddig, amíg ezt a hold off paranccsal felül nem bíráljuk.

Célszerű a hold on parancsot alkalmazni ilyen esetekben, mert ugyan a plot direkt módon is kínál lehetőséget több függvény kirajzoltatására a plot(x1, y1, sztring1, x2, y2, sztring2, ...) szintaktikával (a sztring megadását lásd a következő részben), a hosszúra nyúló paraméterlista azonban növeli tévesztés kockázatát.

Végezze el a "szép" és a "csúnya" szinuszfüggvény egy ábrára történő kirajzoltatását a plot(x1, y1, sztring1, x2, y2, sztring2, ...) szintaktikával! (Előtte adja ki a hold off parancsot.)

Megjegyezzük, hogy adódhatnak olyan speciális feladatok, amikor még a hosszú paraméterlista ellenére is érdemes az "egybegyúrt" plotot választani. Tipikus példa a sok szakadási hellyel rendelkező, de nagyon egyszerű szabállyal leírható lépcsősfüggvény:

>> plot([0 1], [0 0], [1 2], [1 1], 'b', [2 3], [2 2], 'b', ...
[3 4], [3 3], 'b', [4 5], [4 4], 'b', [5 6], [5 5], 'b', ...
[6 6], [6 6], 'b')
Az egészrész függvény bemutatása
0.4. ábra

A plot parancs további paraméterei a grafikus elemek megjelenítését szabályozzák. Beállítható a rajzoló vonal vastagsága, stílusa, színe; kérhető jelölők megjelenítése és megadható azok stílusa (méret, típus, szín).

A szabályozás egyik lehetséges módja az, amikor egy sztringet adunk meg a parancs harmadik paramétereként (ilyen volt a fenti 'r' sztring is). Az egyes grafikus elemek esetén használható beállításokat a következő táblázat tartalmazza.

Ábraelemek megjelenésére vonatkozó beállítások (sztringkódok)
Pont (jelölő) VonalSzín
.    pont
*  csillag
x  x betű
o  kör
+  plusz jel
s  négyzet
d  rombusz
<,>,v,^  háromszögek
p  ötszög
h  hexagon
-      folytonos
- -  szaggatott
:      pontozott
-.  folytonos és pontozott
y  sárga
r  piros
g  zöld
w  fehér
m  magenta
c  cián
b  kék
k  fekete

1. táblázat

A vezérlők (sztringkódok) alkalmazásával most kirajzolunk egy véletlen háromszöget szaggatott-pontozott vonalas összekötéssel, a csúcsokban pedig * jeleket helyezünk el:

>> x = rand(1, 3); y = rand(1, 3);  % x és y 3 elemű véletlen vektor
>> x(1, 4) = x(1, 1), y(1, 4) = y(1, 1)
% az utolsó koordinátát megismételjük, hogy záródjon az alakzat
x =
    0.8147    0.9058    0.1270    0.8147
y =
    0.9134    0.6324    0.0975    0.9134
>> hold off  % új ábra
>> plot(x, y, '*-.b'% rajzolás: kék szín, * a pontokba
Véletlen háromszög
5. ábra

A táblázat és a példa alapján készítsen önállóan néhány hasonló ábrát sztringkódok megfelelő megadásával (pl. a csúcsokban kis négyzetek vagy körök, az összekötő vonal szaggatott, a vonal színe sárga, zöld vagy fekete).

Még finomabb szabályozást végezhetünk el, ha a "grafikus tulajdonság neve és értéke" párok felsorolásával adjuk meg a kívánt beállításokat. Szintaktika: plot(x, y, tulajdonság neve, tulajdonság értéke); itt a név-érték párok ismételhetők. Néhány fontosabb megadási lehetőség:

Ábraelemek megjelenésére vonatkozó beállítások (név-érték párok)
ColorA vonal színeSzínkód (lásd az előző táblázatban);
vagy RGB kódolással: 3 számérték (vektorban), 0 és 1 közötti valós számok
LineStyleA vonal stílusaMint a fenti táblázatban: - -- : -.
LineWidthA vonal vastagságaAz érték megadható
MarkerA jelölő típusaMint a fenti táblázatban
MarkerSizeA jelölő méreteAz érték megadható

2. táblázat

Egyszerű példaként ismételjük meg a szinusz függvényt kirajzoltató utasításokat úgy, hogy a vonalvastagságot megváltoztatjuk, és a vonalszínt az RGB skálán állítjuk be (az RGB paletta használata esetén a piros, zöld és kék alapszínek intenzitása 0 és 1 közötti érték lehet).

>> plot(x, sin(x),'LineWidth',3,'Color',[0.7 0.7 0])
% vastag vonal olívzöld színnel (az ábrát most nem mutatjuk)

Próbáljon ki Ön is különböző vonalvastagságokat és színeket!

>> x = rand(1, 20); y = rand(1,20);  % véletlen sorozatok
>> x = sort(x); y = sort(y);  % rendezés, növekvő töröttvonal lesz
>> plot(x,y,'LineWidth',4,'Marker','h','MarkerSize',8,'Color',...
[0.3 0.3 0.1],'MarkerEdgeColor',[0.7 0.1 0.9])
Véletlen növekvő törött vonal
6. ábra

Tanulmányozza a Súgót a további szabályozható tulajdonságok megismeréséért! Önállóan kísérletezzen további példákkal!

A get paranccsal egy plot struktúra összes tulajdonságát (attribútumát) lekérdezhetjük, utána ezek a set paranccsal módosíthatók.

>> x = linspace(-2*pi, 2*pi, 101);
>> h = plot(x, sin(x)); get(h)  % lekérjük h adatait
          DisplayName: ''
                Color: [0 0 1]
            LineStyle: '-'
            LineWidth: 0.5000
                Marker: 'none'
            MarkerSize: 6
      MarkerEdgeColor: 'auto'
      MarkerFaceColor: 'none'
                XData: [1x101 double]
% a listának csak egy részletét közöljük
>> set(h, 'LineWidth', 1.5)  % a vonalvastagság beállítása

Az ábrázolás, illetve a get-set páros lehetőségeinek további illusztrálása céljából egy komplex számsíkon generált vektoros példát is bemutatunk. Az exp(iφ) képlet felhasználásával körbeforgatunk egy egységvektort a síkon az origó körül, és ezzel elkészítjük egy körvonal pontjait. Az ábra méretezését négyzetessé alakítjuk, feliratot helyezünk az ábrára, majd egy hangolható tulajdonságot módosítunk (felirat mérete).

Fontos (a példában jól látható): a get-set páros nemcsak a teljes plot struktúrára, hanem annak egyes részeire is alkalmazható!

>> z = exp(i*linspace(0, 2*pi, 181))
z =
  Columns 1 through 3
  1.0000            0.9994 + 0.0349i  0.9976 + 0.0698i
  Columns 4 through 6
  0.9945 + 0.1045i  0.9903 + 0.1392i  0.9848 + 0.1736i
% komplex vektorok, a válasznak csak egy részletét közöljük
>> plot(z); axis square;
% az ábra méretezését négyzetesre alakítjuk
>> h = title('Kör', 'Color', 'R');
% feliratot teszünk az aktív rajzra, a szín legyen piros
% továbbá az objektum mutatót feljegyezzük (h)
>> get(h)
% megjelenítjük a felirat objektum hangolható tulajdonságait
% a válasznak csak egy részletét közöljük
Color = [1 0 0]
FontName = Helvetica
FontSize = [10]
HorizontalAlignment = center
LineStyle = -
LineWidth = [0.5]
>> set(h, 'FontSize', 20) % beállítjuk a betűméretet
Körvonal rajza (ábrahangolással)
7. ábra

A plot parancs egyszerű lehetőséget biztosít inverz függvény direkt kirajzoltatására: a megadásánál az x és az y sorozatot felcseréljük. A szintaktika ekkor tehát plot(y, x).

Példaként rajzoltassuk ki a sin( x ) függvény inverzét a [-1, 1] intervallumban! (Az ábrára most feliratot is szeretnénk.)

A plot(y, x) szintaktikával a megoldás a következő:

>> x = linspace(-pi/2, pi/2, 101);  % alappontok
>> y = sin(x); plot(y, x);  % függvényrajz
>> title('szinusz függvény inverze'% felirat
Inverz függvény
8. ábra

Kihasználva, hogy a rendszer beépítve ismeri az arkusz szinusz függvényt, "sima" plottal is dolgozhatunk:

>> x = linspace(-1, 1, 101); plot(x, asin(x))  % inverz függvény

Megjegyezzük, hogy ilyen jellegű feladatok megoldásához kell bizonyos matematikai tudás (pl. hol van értelmezve az inverz függvény), ahogy ezt az Excel modul függvényábrázolásos leckéjében részletesen is taglaltuk.

Saját függvény készítése

Bár a rendszer beépített függvényei önmagukban is nagy változatosságot biztosítanak, a feladatokban emellett összetett függvények ábrázolására is szükségünk van. Ezt persze megtehetjük úgy, hogy az előzőek szerint beírjuk a plot parancsba a megfelelő függvényt előállító képletet (miután az alappontok vektorát létrehoztuk).

>> x = -12.5:0.02:12.5; plot(x, x.*sin(x))
% vigyázzunk a pontozott műveletre!
Szorzatfüggvény ábrája
9. ábra

Készítse el ugyanezen a módon az xcos( x ) függvény ábráját egy szabadon választott intervallumban!
Próbálja ki, hogy mi történik, ha a plotnál nem pontozott szorzást használ!

Ugyanilyen típusú feladatokra néhány más hasonló megoldás is létezik a MATLAB-ban (pl. implicit megadás, lásd később), rögtön érezhető azonban, hogy ez a módszer nem szerencsés abban az esetben, ha a függvényt előállító képlet bonyolultabb. (További probléma, hogy esetünkben a függvény csak a plot belsejében létezik - később nem használható.)

Alternatív megoldásként első ötletként a direkt értékadás kínálkozik, ez természetesen segít abban, hogy a rajzoló utasítás egyszerű maradjon.

>> fv = x.*sin(x);  % az x vektor az előző
>> plot(x, fv)  % az előző rajzot kapjuk

Ennek a megadásnak azonban nagyon könnyen felderíthetjük egy igen komoly hátrányát. Abban reménykedve, hogy a "fv" objektum hordozza a számunkra fontos matematikai jellemzőket, le akarjuk kérdezni a függvényértéket egy adott pontban:

>> fv(1)  % függvényérték lekérdezése - próba
ans =  -0.8290
>> fv(1.01)
??? Subscript indices must either be real positive integers or logicals.

Az első válasz csak a függvény fejbeli kiértékelése, illetve az ábra elemzése után tűnhet gyanúsnak (pozitív, 1-nél kisebb választ várnánk), a második esetben azonban már első pillantásra nyilvánvaló, hogy nagy baj van: a struktúra nem jött létre úgy, ahogy mi szerettük volna.

Írassuk ki ezt a plot struktúrát:

>> fv
fv =
  Columns 1 through 6
  -0.8290  -1.0766  -1.3229  -1.5679  -1.8114  -2.0535
  Columns 7 through 12
  -2.2939  -2.5327  -2.7696  -3.0047  -3.2378  -3.4688
% csak a struktúra elejét közöljük

Ebből látjuk, hogy valójában nem a függvény 1 helyen felvett értékét kaptuk meg, hanem a plot struktúra első elemének y koordinátáját, azaz esetünkben a függvény értékét a -12,5 helyen. A helyes válasz az előző kérdésünkre ténylegesen:

>> 1*sin(1)
ans =    0.8415

Magyarázza meg, hogy a rendszer miért nem tudta végrehajtani az "fv(1.01)" parancsot!

Szeretnénk egy valami módon külön létező, immár helyes "fv" objektumot! Ez azért is nagyon előnyös lenne, mert lehetőséget adna az elkészített függvényképlet későbbi, többszöri felhasználására. Hasonlóan, ezzel azok a gyakorlatban kézenfekvően előforduló esetek is jól kezelhetőek lennének, amikor a függvényt előállító képlet már máshol meg van adva, és most csak hivatkozni/felhasználni szeretnénk. Az általunk elképzelt, ideális függvényobjektum tehát a függvények definiálására az aktuális munkamenettől szeparált módon biztosítana lehetőséget.

Ilyen "tiszta" megoldást nyújt az, ha a függvények definícióit a már megismert M-fájlokban helyezzük el.

A létrehozáshoz válasszuk a File/New/Function (vagy: Function M-file) menüpontot!

Saját függvény készítése - az Editor ablaka
10. ábra

A megjelenő ablak "kottát" mutat a kitöltéshez, és ebből azonnal látjuk azt is, hogy a felhasználói függvények általános szintaktikája a MATLAB-ban a következő:

function [kimenő paraméter(ek)] = függvénynév(bemenő paraméterek)
    utasítások;
end  % függvénynév

A visszatérési paraméterek/értékek listáját, ha az több elemet tartalmaz, akkor szögletes zárójelbe kell tenni (tehát csak egy output paraméter esetén ez a zárójel elhagyható). A lista elemei közé szóközöket kell írni. A bemenő (formális) paraméterek listájának elemeit vesszőkkel választjuk el.

Célszerű, ha a függvény neve megegyezik annak az M-fájlnak a nevével, amelyben van (a MATLAB ezt javasolja). Tehát a fájlunk neve függvénynév.m lesz. Ebben leírjuk mit és hogyan kell számolni a bemenő értékekből kiindulva, és a visszatérő formális paraméterek is itt kapnak értéket. Az M-fájlok az ismert módon kommentárokat is tartalmazhatnak (% jellel indítva), ezek írása a későbbi, illetve a külsős felhasználás miatt javasolt. Az automatikusan generált, de számunkra felesleges sorok (kommentek, üres sorok) célszerűen törlendők.

A MATLAB a kitöltéshez egyszerű és barátságos kezelőfelületet biztosít. A sorok számozottak, a kulcsszavak szintaktikai szerepüknek megfelelő színekkel jelennek meg (syntax highlighting).

Saját függvény készítése - warning üzenet és javítási javaslat a szerkesztőben
11. ábra

A szerkesztő a beírás közben jelzi az észlelt szintaktikai és szemantikai hibákat, és segítséget (tippet) is ad a javításhoz.

A jelzett hibák kétféle szintűek lehetnek: a piros hiba fatális, ilyen előfordulása esetén nem használható az eljárás; a narancs hiba pedig ún. warning (figyelmeztetés), ekkor az eljárás nagyon valószínűleg futtatható ugyan, de a működésében káros mellékhatásokra kell számítanunk.

Készítsen hibás saját függvényt úgy, hogy szándékosan egy fatális hibát vét (pl. hibás bemenő paramétert használ)! Figyelje meg, hogyan próbál a rendszer segíteni a javításban!

A beépített gondos ellenőrzés ellenére a MATLAB "jóváhagyása" még nem jelenti 100% biztosan azt, hogy az eljárás/függvény valóban hibátlan, és különösen azt nem, hogy valóban az is történik majd, mint amit szeretnénk (amit előre elterveztünk). Tipikus ilyen nem jelzett, gyakran problémát okozó hiba a pontozott műveletek nem-alkalmazása (amikor pedig szükségesek lennének).

Legyen a feladatunk most az x 5 8 x 3 +2 függvény ábrázolása a [-3, +3] intervallumban. Ha az elkészült saját függvényünk neve "f1", akkor a kirajzolás a következő módon hajtható végre:

>> x = -3:0.02:3;  % például
>> plot(x, f1(x))

A f1.m nevű függvény M-fájl tartalmát és az elkészült függvényrajzot a 12. és 13. ábrán mutatjuk be.

Polinomfüggvény
12. ábra
Polinomfüggvény rajza
13. ábra

Készítsen saját függvényt az x*cos(x) előállítására. Rajzoltassa ki a függvény ábráját a [-12.5, +12.5] intervallumban!

A saját függvény készítése során figyelje meg, hogy milyen hibákat jelez a szerkesztő!

Saját függvény készítésénél természetesen nemcsak a független paraméter használható, hanem további változó paraméterek is megadhatók. A következő példánkban saját függvényt írunk az

y=amplitúdó e csillapítást sin(2π/Tt + fázisszög)

szabállyal adott csillapított rezgőmozgást leíró képlet megvalósítására, majd ábrázoljuk is a függvényünket.

Válasszuk a paramétereket a következők szerint: amplitúdó - A (értéke: 5), csillapítás - b (értéke: 0,2), t - idő (változó vektor, előállítását lásd lent), T - periódusidő (értéke: 10), fázisszög - fi0 (értéke: π/4 ). A függvény és az m-fájl neve legyen "rezgo".

Az elkészült M-fájl tartalmát a következő ábra mutatja.

A paraméterek megadása eszerint a következő:

>> A = 5; b = 0.2; T = 10; fi0 = pi/4; t = linspace(0, 2*T, 181);

Végül meghívjuk és kirajzoltatjuk a függvényt, majd rácsot rakunk az ábrára:

>> plot(t, rezgo(A, b, T, fi0, t)); grid on
Csillapított rezgőmozgás függvénye
14. ábra
Csillapított rezgőmozgás rajza
15. ábra

Bár a továbbiakban leggyakrabban a függvény M-fájlokat fogjuk alkalmazni összetett függvényobjektumok létrehozására, bemutatjuk azokat a további lehetőségeket is, amelyeket a MATLAB ezen felül nyújt felhasználói függvények definiálására.

Lehetséges a közvetlen függvénydefiníció (parancssorban), ez az ún. anonymous megadás. Ilyenkor a @ (kukac) jel használatával dolgozunk, a független változókat zárójelben fel kell sorolni.

>> fw = @(x) x.^2.*sin(x) + 1  % függvénydefiníció
fw =
    @(x)x.^2.*sin(x)+1
>> fw(2.2)  % függvényérték a 2,2 helyen
ans =    4.9131
>> s = -3:0.1:3; plot(s, fw(s))  % ábrázolás
Trigonometrikus függvény rajza 1. (parancssori, anonymus megadással)
16. ábra

Szintén jól használható az inline (sorközi) megadás, ilyenkor a függvény egy sztringben definiált legális kifejezés.

>> f = inline('3*sin(2*x^2)'% függvénydefiníció
f =
    Inline function:
    f(x) = 3*sin(2*x^2)
>> f(1.2)  % függvényérték az 1,2 helyen
ans =
    0.7759
>> argnames(f)  % biztonsági ellenőrzés: mi az f argumentuma
ans =
    'x'
>> fplot(f, [-pi pi])  % ábrázolás fplottal
% ilyenkor nem kell pontozott művelet
Trigonometrikus függv ény rajza 2. (inline, sorközi megadással)
17. ábra

Készítsen parancssori és sorközi megadással egy-egy tetszőlegesen választott polinom- vagy trigonometrikus függvényt. Rajzoltassa ki a függvények ábráját a plot paranccsal egy-egy megfelelő intervallumban!

Megjegyezzük, hogy parancssori és sorközi megadásnál a definiált függvények valójában változóként - mégpedig szimbolikus változóként - jönnek létre (lásd a következő példákat az fplotnál és következő ábrát).

Az fplot parancs

Az fplot utasítás segítségével szintén ki tudjuk rajzoltatni az ismert (megadott) egyváltozós függvények grafikonját. Fontos eltérés a plot utasítástól, hogy x alappontokat külön nem kell készítenünk, mert a függvény automatikus, változó osztással kerül kiértékelésre (a rendszer a gyorsabb függvényérték-változásoknál sűrűbben, máshol ritkábban készít alappontokat).

A szintaktikában van néhány apró eltérés. A függvény neve idézőjelek között vagy a @ szimbólum után adandó meg (függvénymutató; hivatkozás a függvény objektumra), azokban az esetekben, ha a függvény beépített, ill. akkor is, ha saját függvényként készítettük el. A határok szögletes zárójelek közé írandók. (A szögletes zárójelen belüli szeparáló vessző elhagyható.)

Példaként bemutatjuk a szinusz függvény és az előző "f1" polinomfüggvény kirajzoltatásának lehetőségeit:

>> fplot('sin', [-2*pi, 2*pi])  % a 2. ábra rajzát kapjuk
>> fplot(@sin, [-2*pi, 2*pi])  % a 2. ábra rajzát kapjuk
>> fplot('f1', [-3, 3])  % a 13. ábra rajzát kapjuk
>> fplot(@f1, [-3, 3])  % a 13. ábra rajzát kapjuk

A szögletes zárójel nem hagyható el!

>> fplot('sin', -3 3)  % hibás megadás
??? fplot('sin', -3 3)
                    |
Error: Unexpected MATLAB expression.

Előző saját függvényét ( xcos( x )  előállítása) rajzoltassa ki az fplot utasítás segítségével! (Idézőjeles és kukacos megadással/hivatkozással egyaránt.)

Parancssori, illetve sorközi megadású függvényeknél más a szintaktika. Ilyenkor a függvény nevét "simán" írjuk be. Idézőjel vagy kukac jel használata ekkor hibához vezet (ezeket az objektumokat ugyanis változóként kezeli a MATLAB). Előző "f" és "fw" függvényeinkre:

>> fplot(fw, [-3, 3])   % parancssori megadás, a 16. ábra rajzát kapjuk
>> fplot(f, [-pi, pi])  % sorközi megadás, a 17. ábrát kapjuk
>> fplot(@fw, [-3, 3])  % hibás megadás
??? Error: "fw" was previously used as a variable, conflicting
with its use here as the name of a function or command.
A parancssori és a sorközi megadású függvények változóként jönnek létre
18. ábra

Az előző szakaszban, a parancssori és a sorközi megadással készített függvényeit rajzoltassa ki az fplot paranccsal is egy-egy megfelelő intervallumban!

A fplot parancs további jellegzetessége, a kirajzolni kívánt (saját) függvénynél nem kell pontozott műveleteket használni. Ezzel együtt is az a biztonságos, és a "MATLAB-os-korrektségnek" is az felel meg, ha kirakjuk a pontot a megfelelő helyekre.

>> fw = @(x) x.^2.*sin(x) + 1  % ez a korrekt
fw =
    @(x)x.^2.*sin(x)+1
>> fw = @(x) x^2*sin(x) + 1  % de ez is megfelel, ha...
fw =
    @(x)x^2*sin(x)+1
>> fplot(fw, [-3, 3])  % ...fplot paranccsal rajzolunk

Saját függvényét (x*cos(x) előállítása) módosítsa oly módon, hogy sima szorzást alkalmazzon! Próbálja ki az fplot utasítással, hogy a rajzoltatás így is sikeres!

Ahogy fent említettük, az fplotos rajzoltatásnál a rendszer automatikusan generál alappontokat. Ezt a viselkedést szemléltetjük a következő példával, bepillantva a "kulisszák mögé". Függvényünk az fw1.m fájlban adott:

function y = fw1(t);
  y = t*exp(-t^2)*sin(4*t);
end

Először elkészítjük a vonalas függvényrajzot.

>> fplot('fw1',[0, 4], 'r'% a rajz a következő  ábrán látható

Ezután következik a megfelelő generált pontsorozat megjelenítése. Itt kihasználjuk azt, hogy ha az fplot hívás [x y] visszaadott értékeit eltároljuk, akkor a grafikon nem jelenik meg, de az fplothoz szükséges x, y koordinátapárok feljegyződnek.

>> [x, y] = fplot('t*exp(-t^2)*sin(4*t)',[0,4]);
% csak feljegyzés, rajz nélkül

Az x, y koordinátapárokkal eltárolt pontokat végül - összekötés nélkül! - egy sima plot hívással kirajzoltatjuk.

>> plot(x, y, 'k.');  % pontsorozat rajza, összekötés nélkül
Függvényrajz és az fplot parancshoz generált pontsorozat bemutatása
19. ábra

Az ábrán jól látható, hogy azokon a helyeken, ahol az y értékek változása kicsi, ill. a függvény közel lineáris, a rendszer csak ritkásan generál alappontokat. Az "erősebben görbülő" helyeken (ahol a meredekség gyorsan változik) viszont az alappont-sorozat sűrű.

A szinusz függvénnyel mutassa be Ön is az fplot utasítás automatikusan generált alappont-sorozatát.

Megjegyezzük, hogy a megismerteken túl még további hasznos rajzoló függvények is vannak a MATLAB-ban (például az ezplot, amely különösen alkalmas szimbolikus környezetben történő rajzoltatásra), ezek a mi korlátozott terjedelmű tananyagunkban nem szerepelnek.

Számítási módszerek tananyagunkban szintén nem tárgyaljuk a háromdimenziós grafikát (hasonlóan terjedelmi okokból).

A subplot parancs

A MATLAB rendszer arra is kínál megfelelő eszközt, hogy több rajzot egy ábrán helyezzünk el (subplot utasítás - ilyenkor egy képekből álló táblázat megfelelő cellájába illesztjük be a következő plot utasítással elkészülő képet.). Ez a lehetőség különösen akkor hasznos és kényelmes, ha a rajzok hasonló vagy rokon függvényeket mutatnak be, és ezeket szeretnénk összehasonlítani (mint az előző példánál).

A subplot(n, m, p) utasítás az n sorú és m oszlopú képtáblázat p-edik, sorfolytonosan számozott celláját teszi aktívvá. A plot utasítás itt helyezi el a következő képet. A képek a szokásos módon egyesével hangolhatók, módosíthatók.

Példaként egy 1×3-as képtáblázatba elhelyezzük három egyszerű trigonometrikus függvény rajzát (megfelelő feliratokkal). A kiadandó parancsok a következők:

>> x = -10:0.1:10; figure(1)  % új ábra megnyitása
>> y = sin(x); subplot(1,3,1); plot(x,y)  % 1. rajz
>> axis square, title('sin(x)'% felirat
>> y = sin(x)./x; subplot(1,3,2); plot(x,y)  % 2. rajz
>> axis square, title('sin(x)/x'% felirat
>> y = sin(x)./(x.^2+1); subplot(1,3,3); plot(x,y)  % 3. rajz
>> axis square, title('sin(x)/(x^2+1)'% felirat
Trigonometrikus függvények rajza egy ábrán
20. ábra

Helyezze el a 19. ábrán bemutatott két rajzot egy ábrán (egy 2×1-es képtáblázatba) a subplot paranccsal!

A rajzok hangolásához használható fontosabb parancsok

Miután az ábrára kirajzoltuk a megfelelő függvény(eke)t, szükség lehet még a rajz további hangolására (pl. feliratok elhelyezése, skálázás módosítása). Ilyen típusú módosításokat már korábban is végeztünk néhány esetben a megfelelő parancsokkal. A következő táblázatban összefoglaljuk mindazon fontosabb parancsokat, amelyek a rajzok hangolásához, ill. készítéséhez felhasználhatók.

A rajzok készítéséhez és hangolásához használható fontosabb parancsok
A parancs neve (szintakszis) A parancs hatása
clf grafikus ablak tartalmának törlése
axis([xmin xmax ymin ymax])a koordinátarendszer határainak beállítása a megadott értékekre
axis autoa határok visszaállítása az automatikus beállításra
axis equalaz x és y irányú egység azonos hosszúságú
axis normalx és y irányban automatikus nyújtás/összenyomás megengedett
axis off/ona koordinátarendszert elrejti, bekapcsolja
grid on/offrács be- és kikapcsolása
title('cím')grafika címének magadása
xlabel('felirat'), ylabel('felirat')x/y-tengely felirata
text(x, y, 'string')adott pozícióra kiír egy szöveget
legend('string', ..., poz.)jelmagyarázat megadása (a pozíció 1, 2, 3 vagy 4)
hold on/offa meglevő ábrába helyezi el a következő függvényrajzot, vagy újba
figure(n)új ablak létrehozása, illetve váltás egy létező ablakra, ahol n az ablak mutatója (mindig pozitív egész)
gcfaz aktuális ablak mutatóját adja vissza

3. táblázat

Példaként megjelenítjük egy ábrán a szinusz függvényt és inverzét. Az ábrára több feliratot is felrakunk, és jelmagyarázatot is készítünk.

>> x = linspace(-pi/2, pi/2, 101); y = sin(x);
>> plot(x, y, 'r'); hold on; plot(y, x, 'b'); axis auto
>> xlabel('x tengely'), ylabel('y tengely'% tengelyek felirata
>> title('Szinusz függvény és inverze'% diagramcím
>> text(-2.5, 1.7, '(c) Maci Laci'% szöveg, koordinátával
>> legend('sin(x)', 'arcsin(x)', 2);  % pozíció megadása
>> grid on, axis equal, hold off% rács
Szinusz függvény és inverze, hangolt ábrán
21. ábra

A jelmagyarázatnál természetesen ugyanazokat a színeket használja a MATLAB, mint a függvényábrák készítésénél (vigyázat, a feliratokat a készítés sorrendjében kell beírni!). A magyarázat pozíciója a jobb felső saroktól kezdve (1-es szám) az óramutató járásával ellentétesen haladva egyesével növekedően azonosítódik.

Próbálja ki a jelmagyarázat elhelyezésének különböző lehetőségeit (pozíciószám megváltoztatása)!

Módosítsa az ábrára kiírt felirat (text parancs) pozícióját úgy, hogy a jobb felső, ill. a jobb alsó sarokba kerüljön át!

Forgatómátrixok

Az Excel számítások modul elején már megismerkedtünk a z tengely körüli adott szögű forgatás mátrixával.

Olvassa el újra a vonatkozó részt az Excel számítások modul 1. leckéjében!

Emlékeztetőül felidézzük, hogy egy lineáris térbeli x vektor T lineáris transzformációjának y eredményvektorát a transzformáció T mátrixának és az x vektornak a mátrixszorzatával számítjuk.

y = T(x) = Tx

A következőkben elkészítjük az origó körüli ( fokos forgatást megvalósító mátrixot, és ennek felhasználásával elforgatunk egy adott háromszöget (az xy síkon dolgozunk, így 3×3-as helyett most 2×2-es forgatómátrixot veszünk). Legyen például α=80° , a háromszög pontjai pedig rendre A(1, 1), B(4, 0) és C(3, 4).

Tudjuk, hogy az ( fokos forgatást megvalósító mátrix alakja A=[ cos(α) sin(α); sin(α) cos(α) ] , ahol az α szög értéke radiánban adott. A MATLAB-ban van lehetőség arra is, hogy a szögeket fok értékkel írjuk be, ekkor a cosd és a sind függvényeket használjuk az előállításhoz (d = degree, fok), az eredményt radiánban kapjuk.

Egy pont elforgatottját tehát az

[ x' y' ]=[ cos(α) sin(α) sin(α) cos(α) ][ x y ]

képlettel állítjuk elő. Elkészítjük a forgatómátrixot:

>> alfa = 80;
>> A = [cosd(alfa) -sind(alfa); sind(alfa) cosd(alfa)]
A =
    0.1736  -0.9848
    0.9848    0.1736

A háromszög pontjait felvesszük koordinátánként egy megfelelő kétsoros mátrixban, és próbaként kirajzoljuk az eredeti háromszöget:

>> X = [1 4 3; 1 0 4];
>> plot(X(1,:),X(2,:))  % még nem záródik az alakzat!

Vegyük észre, hogy az alakzat nem záródik, az utolsó pontot a rendszer nem köti össze az elsővel!

Három pont kirajzoltatása a plot paranccsal
22. ábra

Az összekötést úgy biztosíthatjuk, hogy az utolsó utáni pozícióba (azonosítás: end+1) új elemként felvesszük az első pont koordinátáit, így már a plot zárt alakzatot rajzol.

>> X(:,end+1) = X(:,1)
X =
    1    4    3    1
    1    0    4    1
>> plot(X(1,:),X(2,:),'r'% így már az alakzat zárt

A következő lépésben előállítjuk az elforgatott pontok koordinátáit, azaz összeszorozzuk a transzformációs mátrixot a vektorkoordinátákkal.

>> X_uj = A*X
X_uj =
  -0.8112    0.6946  -3.4183  -0.8112
    1.1585    3.9392    3.6490    1.1585

A továbbiakban a már meglevő ábrára kirakjuk az új háromszöget (kék színnel).

>> hold on;
>> plot(X_uj(1,:),X_uj(2,:),'b'% elforgatott háromszög (zárt)

Ha feliratokat is elhelyezünk magyarázatként, akkor - megfelelő átméretezés után - a 23. ábra szerinti képet kapjuk.

Háromszög forgatása
23. ábra

A text parancs segítségével önállóan rakja fel az ábrára a feliratokat!

A következő példában egy hasonló, de összetettebb feladatot oldunk meg. Egy házikó rajzát készítjük el, és körbeforgatjuk. A rajzoló és a forgató eljárást egy-egy saját függvényben (function M-fájl) helyezzük el, ezek neve rendre: dot2dot.m és forgat.m. A körbeforgatást technikailag úgy oldjuk meg, hogy az alakzat régi képét mindig letöröljük, és új képet rajzolunk.

Az első lépésben létrehozzuk az alakzat pontjait tartalmazó vektort (mátrixot) oly módon, hogy annak első sora az x, a második pedig az y koordinátákat tartalmazza.

>> X = [-6 -6 -7 0 7 6 6 -3 -3 0 0; -7 2 1 8 1 2 -7 -7 -2 -2 -7];

Rajzoltassa ki az X mátrix pontjait a plot parancs segítségével a megszokott módon.

Látjuk, hogy - hasonlóan a fenti háromszöghöz - az alakzat most még nem záródik, ezért az ismert módon az utolsó utáni pozícióba át kell másolnunk az első pont koordinátáit. A megfelelő plot utasítással együtt a következő ábrán bemutatott paraméteres M-fájlt kapjuk.

Alakzat kirajzoltatása: a dot2dot M-fájl
24. ábra
Alakzat kirajzoltatása: az eredmény a fenti X mátrixra
25. ábra

Ezután elkészítjük a megfelelő paraméteres forgató eljárást. A függvénynél megadható a forgatás szöge és az elforgatandó alakzat koordinátáit tartalmazó mátrix, a visszaadott érték az új, elforgatott alakzat pontjait tartalmazó mátrix. (Folyamatos forgatást az eljárás többszöri meghívásával lehet elérni.)

A forgató eljárás
26. ábra

Végül a két saját függvény felhasználásával körbeforgatjuk a házikót.

>> for i=0:360 dot2dot(forgat(X, i)), pause(0.1), end;

Itt az ötlet az, hogy a régi ábrát mindig eldobva nagyon rövid kihagyással kirajzoljuk az alakzat új képét, és ez a megjelenítés a felhasználó számára a folyamatos mozgás érzetét kelti (animáció).

Egy 0-tól 360 fokig lépdelő ciklus biztosítja azt, hogy az óramutató járásával ellentétesen haladva körbeérjünk az origó körül.

Az X mátrix megfelelő módosításával a bemutatott példa alapján (és az eljárások megfelelő felhasználásával) forgasson körbe egy négyszöget az origó körül.

Utolsó forgatómátrixos példánkban egy másik, egyszerű animációt készítünk: egy egységvektort forgatunk körbe az origó körül. Az előző példában bemutatott eljárást követjük, forgatómátrixot adunk meg, és ezzel generáljuk az új képeket, mindig újrarajzolva az ábrát. Most is 0-tól 360-ig lépdelő ciklust használunk (kétfokos lépésközzel, kis várakozási idővel az ábrák rajzolása között).

>> x = [0 1; 0 0];
% 1 hosszú vektor, végpontjai az x tengelyen
>> fok = 2;
>> T = [cosd(fok) -sind(fok); sind(fok) cosd(fok)];
% forgatás mátrixa
>> for fi = 0:fok:360
    plot(x(1,:),x(2,:),'.-'), axis([-1 1 -1 1]);  % rajz
    pause(0.1);  % várakozás
    x = T*x;  % az x vektor új pozíciója
  end  % ciklus vége

A ciklus beírásánál a sorok végén Shift+Entert használunk, ezzel mindig új sort nyit a szerkesztő. Az "end" megadása után kérjük a végrehajtást, egy záró Enterrel.

Láthatjuk, hogy a MATLAB valóban körbeforgatja az egységvektort az origó körül.

Teljes függvényvizsgálat

A MATLAB nagyon hatékony támogatást nyújt a matematikai tanulmányainkból ismert klasszikus függvényvizsgálati feladat megoldásához. Ebben az alfejezetben egy konkrét példa kidolgozásán keresztül áttekintjük azokat a lépéseket, amelyeket célszerű követni a megoldáshoz, és bemutatjuk azokat a parancsokat is, amelyekre - a függvény ábrázolásán túlmenően - szükségünk lesz.

A feladatunk az, hogy ábrázoljuk az f:x12cos( 0,07x )sin( 1,2x )+1 függvényt a [20, 27] intervallumban, majd határozzuk meg a nevezetes pontjait, (zérushelyek, minimum- és maximumhelyek), végül pedig számoljunk függvény alatti területet (numerikus közelítéssel).

Ezt az összetett feladatot Ön is csinálja meg lépésenként, a leírást gondosan követve.

Először hozzuk létre a megszokott módon az f3.m szöveges fájlt (saját függvény), majd ábrázoljuk a függvényünket. Az ábrára most rácsot is rakunk, hogy ezzel is javítsuk az áttekinthetőséget.

Az f3.m fájl tartalma:

function y = f3(x)
  y = 12*cos(0.07*x).*sin(1.2*x) + 1;
end

A megfelelő rajzoló utasítás (a függvény grafikonját a következő ábrán mutatjuk be):

>> fplot('f3', [20 27]), grid on

A következő lépés a nevezetes pontok leolvasása az ábráról. Bármilyen technikával is dolgozunk itt (manuális leolvasás vagy egérrel történő kattintás) ezzel mindig egy-egy közelítő értéket kapunk, amit majd pontosítani kell a megfelelő függvénnyel.

A rajzablak eszköztárán található Data Cursor eszköz arra ad lehetőséget, hogy a választott pontokra kattintva azok koordinátáit egyesével letapogassuk. Ezután a koordináták direkt értékadással írhatók bele a megfelelő változókba. (Azonnal látjuk, hogy ez így nehézkes!)

A Data Cursor eszköz és a ginput
27. ábra

Ennél kényelmesebb - bár a leolvasási pontosságot önmagában nem javítja meg -, ha a ginput függvényt használjuk. Ilyenkor az ábráról egérrel letapogatott koordináták automatikusan a megadott változókba íródnak - szintaxis: [p q] = ginput, a pozíció az Enterrel nyugtázható. Ha a ginput(n) alakot használjuk, akkor a p és q vektorok n eleműek lesznek, azaz folyamatosan n darab pont érzékelését végezhetjük el.

A mi feladatunk most az, hogy az előbbi ábráról olvastassuk be a következő pontok közelítő értékeit a megadott sorrendben:

  • két zérushely;
  • két lokális maximumpont;
  • egy lokális minimumpont.

Ehhez tehát a következő parancsot adjuk ki (majd egyesével kattintunk a pontokra, a megfelelő sorrendre ügyeljünk!):

>> [p q] = ginput(5)

A letapogatás végén a kiíratásnál mindenképpen célszerű ellenőrizni, hogy a p és q vektorok (nagyjából) megfelelő értékeket kaptak-e.

Esetünkben például a következőt láthatjuk a képernyőn (kis eltérés lehetséges egy másik beolvasásnál):

p =
  20.4113
  26.4274
...
q =
  -0.0015
  -0.0015
... % a rendszer válaszainak csak az első 2-2 sorát közöljük

Ebből látszik, hogy a zérushelyeknél jól dolgoztunk, hiszen az y koordináták közel 0-ák. A letapogatott nevezetes pontok koordinátáit ezután a következők szerint pontosítjuk.

A zérushelyek keresését az fzero('függvény', hol) paranccsal végezhetjük el. Esetünkben a hely megadásánál a p vektor első és második elemét kell használni, az y koordináták pedig nullák lesznek.

>> zhx = [fzero('f3', p(1)) fzero('f3', p(2))], zhy = [0 0]
zhx =
  20.4175  26.4355
zhy =
    0    0

A minimumhely kereséséhez az fminbnd('függvény', alsó határ, felső határ) parancsot használjuk. Figyeljünk arra, hogy - az előző esettől eltérően - egy konkrét pont helyett itt egy alkalmas kisebb intervallumot kell megadni (második és harmadik paraméter; most: a p(5) környezetében), abban vizsgálódik a rendszer.

>> minx = fminbnd('f3', p(5)-0.5, p(5)+0.5), miny = f3(minx)
minx =  23.0410
miny =    0.7046

Megjegyezzük, hogy az fminbnd függvénynél (és az fzeronál is) még egy negyedik paraméter is megadható, amellyel például a közelítés pontosságát lehet szabályozni. Szintén lehetséges, hogy a parancsoknál egy extra visszatérési értéket tároljunk el, amely a működés sikeres vagy sikertelen voltát mutatja. Ennek részleteit nem tárgyaljuk, az érdeklődők a súgóban megnézhetik.

A másik típusú szélsőértékkel kapcsolatban kiemeljük, hogy külön maximumhely-kereső eljárás a MATLAB-ba nincs beépítve. Ilyenkor az fminbnd keresést a -f(x) függvényre alkalmazzuk. Most a p vektor harmadik és negyedik elemét használjuk.

>> maxx(1)=fminbnd('-f3(x)',p(3)-0.5,p(3)+0.5); maxy(1)=f3(maxx(1));
>> maxx(2)=fminbnd('-f3(x)',p(4)-0.5,p(4)+0.5), maxy(2)=f3(maxx(2))
maxx =
  21.6015  25.1194
maxy =
    1.4995    3.1388

A következő lépésben a meghatározott pontokat feltesszük fekete, piros és zöld körökkel a grafikonra.

>> hold on
>> plot(zhx,zhy,'ko'), plot(maxx, maxy,'ro'), plot(minx, miny,'go')

Mit látnánk a képernyőn a második sorban szereplő plot utasítások hatására, ha előtte nem adnánk ki a hold on parancsot?

Nevezetes pontok a függvényábrán
28. ábra

Az ábrára célszerű jelmagyarázatot helyezni (legend parancs), hogy az egyes ábraelemek szerepe világosan beazonosítható legyen. Figyelni kell azonban arra, hogy a megadási sorrend azonos legyen az ábraelemek sorrendjével.

>> legend('függvény','zérushelyek','max. helyek','min. hely',2)

Mit látnánk a képernyőn, ha elhagynánk a 'függvény' sztringet a felsorolásból?

Az ábrának címfeliratot adunk:

>> title('f(x) = 12*cos(0.07*x)*sin(1.2*x) + 1')

Feladatunk még a függvény alatti terület (határozott integrál) meghatározása a zérushelyek között. Ezt a feladatot sok esetben pontos számítással is meg lehet oldani - szimbolikus határozott integrálással - mi azonban a megoldásunkhoz most egy megfelelően jó numerikus közelítő módszert választunk.

A MATLAB-ban több beépített függvény is létezik erre a feladatra (ezt a súgót böngészve - numerikus integrálási módszerek - hamar felderíthetjük).

A quad függvény a súgóban a numerikus integrálási módszerek csoportjában
29. ábra

Mi egy univerzális "jó eszközt" használunk, a quad parancsot (a quad rövidítés a kvadratúra szóból származik, amely a módszert azonosítja). Ez a függvény a határozott integrált az adaptív, rekurzív Simpson szabállyal számítja ki, és megfelelően pontosan dolgozik. A szintaktika:

quad(függvénymutató, alsó határ, felső határ, tolerancia).

A függvénymutató ugyanúgy adható meg, mint az fplot eljárásnál: használhatunk saját függvényt, beépített függvényt, anonymous függvényt stb. Ugyanez a megjegyzés érvényes az fzero és az fmindbnd függvényre is. A tolerancia (pontosság) paraméter elhagyható.

A képlet esetünkben:

>> integral = quad('f3', zhx(1), zhx(2), eps)
integral =    9.2893

Számolja ki a szinusz függvény alatti területet a quad paranccsal a [0, pi] intervallumon. Parancssori (anonymous) megadással számolja ki az x*sin(x) függvény alatti területet a [0, pi] intervallumon.

A numerikus integrálásnál előjelesen dolgozik a MATLAB, tehát ha az elemzett függvény grafikonja az y tengely alá esik (a vizsgált tartományon), akkor a parancs negatív értéket ad válaszul (a terület azonban matematikai értelmezés szerint nemnegatív). Ez a jelenség akkor okozhat különösen kellemetlen hibát, ha az elemzett függvény a vizsgált tartományon "fel- és lekanyarog", azaz egyszer az y tengely felett, egyszer pedig alatta fut. Ilyenkor hangsúlyosan figyelnünk kell arra, hogy mindig csak az azonos előjelű szakaszokat vizsgáljuk (pl. zérushelytől zérushelyig).

Megjegyezzük még, hogy a quad parancsnál - hasonlóan, mint a plot parancsnál - fontos a pontozott műveletek használata. Ha erről elfelejtkezünk, akkor megadástól függően vagy pontatlan (hibás) választ kapunk, vagy hibaüzenetet. Az előbbi különösen azért kellemetlen, mert ilyenkor a hiba felismerése is jóval nehezebb.

>> f = inline('3*sin(2*x.^2)'% pontozott definíció
f =
    Inline function:
    f(x) = 3*sin(2*x.^2)
>> quad(f, 0, pi/4)  % helyes válasz
ans =    0.8686
>> f = inline('3*sin(2*x^2)'% pont nélküli megadás
f =
    Inline function:
    f(x) = 3*sin(2*x^2)
>> quad(f, 0, pi/4)  % hibaüzenet, csak az első néhány sort közöljük
??? Error using ==> inlineeval at 15
Error in inline expression ==> 3*sin(2*x^2)
Matrix must be square.

Visszatérve a feladatunkhoz (teljes függvényvizsgálat) a text paranccsal felrakjuk az ábrára a terület értékét - ehhez természetesen megfelelő koordinátákat adunk meg:

>> text(20.5, -2.5, ['Zérushelyek közötti határozott integrál: ' ...
num2str(integral)])

A num2str függvényt azért kellett bevetni, mert az integral változó numerikus (szám) típusú, a text függvény viszont szöveges paramétert vár.

A kész ábra, jelmagyarázattal és a függvény alatti terület feltüntetésével
30. ábra

Végül az ábránkat mentsük el. Ezt megtehetjük a File/Save As... paranccsal (a Figure ablakon), vagy a print utasítással. A MATLAB nagyon sok különféle grafikus fájltípust támogat, ezeket a print súgójában vagy a Save As... lenyíló listájában tekinthetjük át (pl. ps, psc, eps, epsc, jpeg, tiff, png, pdf).

Ha a print parancsot választjuk, akkor a mentés elvégezhető például a következő módon:

>> print -djpeg90 -r300 abra1  % az aktuális könyvtárba mentünk

A -d kapcsoló után adandó meg a típus, a -r kapcsoló után pedig a felbontás (dpi-ben). Ha nem adunk meg külön típust, akkor ps kiterjesztésű (post script) fájlt kapunk. További részletek a súgóban olvashatók.

Önellenőrző kérdések

1. Készítse el a plot(x1, y1, sztring1, x2, y2, sztring2, ...) szintaktikával a törtrészfüggvény (egy részének a) következő rajzát:

2. Készítsen el egy 2 sugarú körvonalat a komplex síkon és rajzoltassa ki a pontjait! Az ábra feliratát (Kör) hangolja meg: a szín legyen zöld, a méret pedig 18-as.

3. Próbálja ki a MATLAB által ismert különböző megadási lehetőségeket az 1,2 x 2 e 0,5x függvénnyel! Hozzon létre saját függvényt M-fájlban, írja be a képletet sorközi (inline) módon és közvetlen, parancssori függvénydefinícióval (anonymous megadás)! Ábrázolja a létrehozott függvénypéldányokat az fplot paranccsal a [0, 20] intervallumban!

4. Készítse el az előző feladat saját függvényének paraméteres változatát is! Ábrázolja így is a függvényt!

Útmutató: Legyen a függvény alakja a x b e cx . A híváskor lehessen megadni az a, b, c paraméterek konkrét értékét! Például: x = 0:0.1:20; plot(x, f1(1.2, 2, -.5, x)).

5. Rajzoltassa ki egy ábrára a koszinusz függvényt (megfelelő szakasz) és inverzét! Készítsen jelmagyarázatot és az ábrán helyezzen el megfelelő feliratokat (tengelyek, ábracím)! Az interaktív megoldás előállítása után készítsen ehhez a feladathoz scriptet - script M-fájlt!

6. Készítse el az origó körüli 80 fokos (óramutató járásával ellentétes) forgatást megvalósító transzformáció mátrixát!

A választ 4 tizedesjegy pontossággal adja meg!
Mennyi a forgatómátrix első sorának első eleme?

A mátrix alakja a következő: FM=[ cosα, sinα; sinα, cosα ]

A választ 4 tizedesjegy pontossággal adja meg!
Forgassa el a mátrix felhasználásával az A(5, 1) pontot! Mennyi az új A' pont y koordinátája?

7. Módosítsa a leckében szereplő dot2dot ábrarajzoló függvényt, hogy a hívása dot2dot(c, X) legyen, ahol c a nyújtási tényező!

Tipp: az axis(10*[-1 1 -1 1]) soron kell változtatni a 10 értékén.

8. Az X = [1; 0] mátrixból kiindulva állítsa elő forgatásokkal és bővítésekkel az eredetileg üres Y mátrixot úgy, hogy Y egy szabályos négyszög csúcsait tartalmazza! Rajzoltassa is ki az alakzatot! (Használja fel a forgat és a dot2dot függvényeket.)

9. A mellékelt m-fájlkód a 10cos( 0,1x )sis( x )+1  függvény megvalósítására készült.

function [ z ] = fv1( x1 )
    y=10*cos(0.1*x)*sin(x)+1;
end

Javítsa ki a hibákat és mentse el a függvényt!

Mennyi a függvény értéke a 22 helyen? (A választ 4 tizedesjegy pontossággal adja meg)

Válasz:

Ábrázolja a függvényt a [18, 42] intervallumon! Hány zérushelye van a függvénynek az intervallumban?

Válasz: