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

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

3. lecke Mátrixok/2

Cél: A mátrixokat bemutató, önmagában igen hosszú leckét két kisebb részre vágtuk szét, ez a második rész. A cél és a motiváció ugyanaz, mint az előző leckénél.

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

  • Elő tudja állítani a leckében megismert alap- és nevezetes mátrixok megadott méretű darabjait;
  • a leckében megismert alap- és nevezetes mátrixok darabjait egyértelműen képes azonosítani képernyőkép alapján;
  • el tud készíteni olyan tesztmátrixokat, amelyek a megismert alap- és nevezetes mátrixok darabjaiból (esetleg: egyszerű aritmetikai műveletekkel kombinálva) épülnek fel;
  • el tud készíteni olyan tesztmátrixokat, amelyek a megismert alap- és nevezetes mátrixok tükrözött és elforgatott darabjaiból épülnek fel;
  • tud konstruálni sávmátrixokat, alsó- és felsőháromszög mátrixokat;
  • diagonálmátrixból, alsó- és felsőháromszög mátrixokból vissza tudja állítani az eredeti mátrixot;
  • képes megadott paraméterekkel rendelkező véletlen mátrixok előállítására.

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

Kulcsfogalmak

  • Alapmátrixok (csupa nulla és csupa egyes mátrix, egységmátrix);
  • Nevezetes mátrixok (Pascal-, Hilbert-, Vandermonde-mátrix és a mágikus mátrix);
  • Véletlen mátrixok;
  • Mátrixokat manipuláló függvények (forgatás, tükrözés, shiftelés);
  • Sávmátrixok, alsó- és felsőháromszög mátrixok.
Speciális mátrixok

A MATLAB rendszerben több speciális, nevezetes mátrix (vektor) beépített paranccsal is előállítható. Ezen mátrixok között vannak egészen egyszerűek, és jóval bonyolultabbak is, amelyek pl. speciális numerikus feladatok megoldásánál tesztmátrixként szolgálhatnak.

Mi a Számítási módszerek tantárgy keretein belül elsősorban azokat a fontosabb alapmátrixokat (elemi mátrixok) tárgyaljuk, amelyeket feladataink megoldása során használunk. A mélyebben érdeklődők számára javasoljuk a gallery csoport tanulmányozását a súgóban (itt több mint 50 különböző speciális mátrix található, leírással, példákkal).

A gallery csoport a súgóban
1. ábra
Egységmátrix, csupa egyes és csupa nulla mátrix

A nevezetes mátrixok ezen csoportja könnyen megjegyezhető, mert az angol nevük alapján a tartalmuk egyértelmű és a méretmegadás azonos konvenciót követ (ones, zeros, eye).

Paraméterezésük is egyszerű, a méret és a típus adható meg. Itt a típus el is maradhat, a méret egyetlen, vagy több numerikus adat, amelyeknek az egész része számít számít (célszerű eleve egész adatot megadni).

Néhány példa már korábban is szerepelt, továbbiak:

>> A = ones(3)  % 3×3 méretű csupa egyesekből álló mátrix
A =
    1    1    1
    1    1    1
    1    1    1
>> B = ones(1.2, 3)  % 1×3 méretű csupa egyesekből álló mátrix
Warning: Size vector should be a row vector with integer elements.
B =
    1    1    1
>> C = zeros(3, 'int8'% 3×3 méretű 1 bájton tárolt 0 adatok
C =
    0    0    0
    0    0    0
    0    0    0
% A és C látszólag ugyanabba a típusba tartozik, de:
>> whos A C
  Name      Size            Bytes  Class    Attributes
  A        3x3                72  double         
  C        3x3                9  int8
>> D = eye(3, 5)
% 3×5-ös egységmátrix, csak a bal felső saroktól induló átlóban vannak egyesek,
% a többi elem nulla
D =
    1    0    0    0    0
    0    1    0    0    0
    0    0    1    0    0
>> A = [1:3; 4:6; 7:9]; E = eye(size(A));
% Az A mátrix méretét követő egységmátrix, most nem íratjuk ki

Hozzon létre egy 5×3-as csupa nulla mátrixot a megfelelő beépített paranccsal!

Hozzon létre ugyanilyen méretű csupa nulla mátrixot úgy is, hogy valamely egész típust használ! Hasonlítsa össze a két mátrix méretét!

Megjegyezzük, hogy a true() és false() parancsok is - megfelelő méretmegadással - felhasználhatók csupa egyes és csupa nullás mátrixok létrehozására. Ebben az esetben a megfelelő mátrix helyfoglalása természetesen a logikai típusnak megfelelő.

>> A = true(2, 3)
A =
    1    1    1
    1    1    1
>> whos A
  Name      Size            Bytes  Class      Attributes
  A        2x3                6  logical

Tudjuk, hogy a 0-val való osztás problémás művelet. Mik lesznek az eye(3)./zeros(3) hányados elemei?

Sorozatképző operátorok, parancsok

Szintén a speciális mátrixok közé soroljuk a kettőspont operátorral és a linspace paranccsal létrehozott oszlop- és sorvektorokat is. Ezeket korábban már tanultuk, ezért most csak egy újabb példát mutatunk be, egy érdekes alkalmazást.

Felveszünk egy fi vektorba kellően sűrű alappontokat 0-tól 2π -ig, majd az exp(i(fi) képlettel előállítjuk azon komplex számokat, amelyek forgásszöge a fi vektor elemeivel meghatározott, és 1 távolságra vannak az origótól. A pontokat végül kirajzoljuk.

>> fi = linspace(0 , 2*pi , 181);  % alappontok 0-tól 2*pi-ig
>> kor = exp(i*fi)  % körvonal pontjai, csak a válasz 2 sorát nézzük
kor =
  Columns 1 through 4
  1.0000            0.9994 + 0.0349i  0.9976 + 0.0698i  0.9945 + 0.1045i
  Columns 5 through 8
  0.9903 + 0.1392i  0.9848 + 0.1736i  0.9781 + 0.2079i  0.9703 + 0.2419i
  ...
>> plot(kor), axis square
Körvonal kirajzolása
2. ábra

Logaritmikusan skálázott vektorok is készíthetők a logspace paranccsal. A használat a linspace-nek megfelelő, csak a határok megadásánál figyelni kell arra, hogy 10 hatványok kitevőivel dolgozunk.

>> x = logspace(1, 2, 6) % 6 elemű logaritmikus vektor 10-től 100-ig
x =
  10.0000  15.8489  25.1189  39.8107  63.0957  100.0000
>> y = log10(x)  % logaritmusok
y =
    1.0000    1.2000    1.4000    1.6000    1.8000    2.0000
>> w = exp(log(10)*y)  % visszakapjuk az eredeti vektort
w =
  10.0000  15.8489  25.1189  39.8107  63.0957  100.0000
Pascal-, Hilbert-, Vandermonde-mátrix és a mágikus mátrix

A Pascal-mátrix a Pascal-háromszög elemeit (a binomiális együtthatókat) állítja elő, de téglalapos elrendezésben (a háromszög csúcsa az 1; 1 pozícióban van); az eredeti háromszög sorai így átlósan olvashatók ki a mátrixból.

>> P = pascal(6)  % a háromszög 5. sorának elemeit megjelöltük
P =
    1    1    1    1    1    1
    1    2    3    4    5    6
    1    3    6    10    15    21
    1    4    10    20    35    56
    1    5    15    35    70  126
    1    6    21    56  126  252

A bemutatott példához hasonlóan határozza meg a Pascal-háromszög 12. sorának középső elemét! (A háromszögben a sorok és az oszlopok számozása 0-tól indul.)

Érdekesség, hogy a Pascal-mátrix determinánsa mindig 1, ezért az inverz mátrix ilyenkor mindig egész számokból épül fel (ezt már korábban bemutattuk).

>> det(P)
ans =    1

Ellenőrizze, hogy a Pascal-mátrix inverzének determinánsa is 1. Milyen következtetés adódik ebből?

A Hilbert-mátrix egy speciális tesztmátrix, amelyben a természetes számok reciprokai szerepelnek a következő szabály szerint: h(i, j) = 1/(i + j - 1). A MATLAB-ban a hilb(méret) függvénnyel állítható elő (mindig négyzetes mátrixot kapunk).

>> H5 = hilb(5)
H5 =
    1.0000    0.5000    0.3333    0.2500    0.2000
    0.5000    0.3333    0.2500    0.2000    0.1667
    0.3333    0.2500    0.2000    0.1667    0.1429
    0.2500    0.2000    0.1667    0.1429    0.1250
    0.2000    0.1667    0.1429    0.1250    0.1111

Ezeket a törteket direkt módon mi is megadhatjuk, persze bonyolultabban.

H4 = [1./[1:4]; 1./[2:5]; 1./[3:6]; 1./[4:7]]
H4 =
    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

A pontos törtalakot is előállíthatjuk (karakterláncként) a rats(hilb(n)) paranccsal.

>> rats(hilb(4))
ans =
      1            1/2          1/3          1/4
      1/2          1/3          1/4          1/5
      1/3          1/4          1/5          1/6
      1/4          1/5          1/6          1/7

A Hilbert-mátrix fontos tulajdonsága, hogy számolásnál kismértékű változásokra is nagyon érzékeny (gyengén kondicionált), ezért szokták különböző numerikus eljárások tesztelésére használni.

A következő példában kiszámítjuk a Hilbert-mátrix inverzét speciálisan erre a célra beépített MATLAB eljárással és az inv függvénnyel is, majd bemutatjuk, hogy az utóbbi már kis méretek esetén is érzékelhetően pontatlan eredményt ad.

>> IH = invhilb(5)  % beépített speciális parancs, pontos eredmény
IH =
          25        -300        1050      -1400        630
        -300        4800      -18900      26880      -12600
        1050      -18900      79380    -117600      56700
      -1400      26880    -117600      179200      -88200
        630      -12600      56700      -88200      44100
>> ih = inv(H)  % "sima" inverz, az eredmény hibával terhelt
ans =
  1.0e+005 *
    0.0002  -0.0030    0.0105  -0.0140    0.0063
  -0.0030    0.0480  -0.1890    0.2688  -0.1260
    0.0105  -0.1890    0.7938  -1.1760    0.5670
  -0.0140    0.2688  -1.1760    1.7920  -0.8820
    0.0063  -0.1260    0.5670  -0.8820    0.4410
>> ih - IH  % megnézzük a hibát
ans =
  1.0e-007 *
  -0.0001    0.0018  -0.0072    0.0101  -0.0049
    0.0018  -0.0296    0.1176  -0.1675    0.0785
  -0.0072    0.1176  -0.4641    0.6560  -0.3047
    0.0101  -0.1675    0.6560  -0.9203    0.4248
  -0.0049    0.0785  -0.3047    0.4248  -0.1950

Ellenőrizze, hogy az inverz Hilbert-mátrix méretének növekedésével a hiba rendkívül gyorsan nő. (Többszörös nagyságrendi növekedés tapasztalható minden egyes méretnöveléskor!)

Nézze meg a hibát 6×6-os, 7×7-es és 8×8-as mátrixokra is.

*A hiba bemutatott gyors növekedésének egyszerű szemléletes indoklása lehet a következő: a MATLAB az inv parancsnál determinánsszámítást is végez (ezzel oszt), a Hilbert-mátrixok determinánsai pedig gyorsan csökkenő sorozatot alkotnak.

>> det(hilb(4)), det(hilb(7))
ans =  1.6534e-007
ans =  4.8358e-025

A Max függvény felhasználásával állapítsuk meg a hilb(4), hilb(5), hilb(6) mátrixok inverzeinek legnagyobb elemét!

A Vandermonde mátrix oszlopaiban egy oszlopvektor csökkenő kitevőjű hatványai állnak. Előállítására a vander() parancs szolgál (az oszlopvektort meg kell adnunk):

>> x = [1,2,3,4]';  % alap oszlopvektor, nem íratjuk ki
>> v4 = vander(x)  % Vandermonde-mátrix konstrukció
v4 =
    1    1    1    1
    8    4    2    1
    27    9    3    1
    64    16    4    1
>> [x.^3, x.^2, x.^1, x.^0]  % ellenőrzés: legyártjuk x hatványait
ans =
    1    1    1    1
    8    4    2    1
    27    9    3    1
    64    16    4    1

A mágikus mátrix egy speciális n×n-es mátrix, amely pozitív egész számokból épül fel (1-től n 2 -ig), fontos tulajdonsága, hogy elemeinek összege egy soron és egy oszlopon belül, továbbá a főátlóban és az antiátlóban is megegyezik. A MATLAB a mágikus mátrixot beépített függvénnyel elő tudja állítani (adott n-re mindig ugyanazt a mátrixot kapjuk; részletek: súgó).

>> A = magic(4)  % 4×4-es mágikus mátrix
A =
    16    2    3    13
    5    11    10    8
    9    7    6    12
    4    14    15    1
>> sum(A, 1)  % oszlopok összege, sum(A) is jó
ans =
    34    34    34    34
>> sum(A, 2)  % sorok összege, sum(A') is jó
ans =
    34
    34
    34
    34
>> sum(diag(A))  % főátló
ans =    34
>> sum(diag(flipud(A)))  % antiátló, tükröző függvénnyel, bemutatását lásd később
ans =    34

Készítse el az 5×5-ös mágikus mátrixot, és ellenőrizze, hogy az ismert tulajdonságok itt is teljesülnek. Az oszlopok és sorok összegének előállításához használja a sum(A) és a sum(A') parancsokat.

Határozza meg a 6×6-os Hilbert-mátrix elemeinek sorösszegét!

A megismert nevezetes mátrixokból sokféle különböző gyakorlati feladathoz készíthetünk építkezéssel alkalmas tesztmátrixot.

Példa: A következő tesztmátrix felépítéshez felhasználható az egységmátrix, a csupa nulla mátrix, a csupa egyes mátrix, a Pascal-mátrix, a Hilbert-mátrix és a mágikus mátrix. Építsük fel egyszerű mátrixműveletek (transzponálás is megengedett) segítségével a W tesztmátrixot!

W =
    1    1    2    0    0
    1    1    0    2    0
    1    1    0    0    2
    1    1    1    0    0
    1    2    3    0    0
    1    3    6    0    0

A megoldáshoz észrevesszük, hogy W négy részre bontható: bal felső sarkában egy 3×2-es csupa egyes mátrix, jobb felső sarkában egy 3×3-as egységmátrix kétszerese, bal alsó sarkában egy 3×3-as Pascal-mátrix, jobb alsó sarkában pedig egy 3×2-es csupa nulla mátrix található. Ellenőrzésként legyárthatjuk külön-külön a részmátrixokat, például:

>> eye(3)*2
ans =
    2    0    0
    0    2    0
    0    0    2

Végül összerakjuk a darabokat, és ellenőrizzük, hogy pontosan megkapjuk-e W-t.

>> W = [ones(3, 2) eye(3)*2; pascal(3) zeros(3, 2)]
W =
    1    1    2    0    0
    1    1    0    2    0
    1    1    0    0    2
    1    1    1    0    0
    1    2    3    0    0
    1    3    6    0    0
Véletlen mátrixok

A véletlen (álvéletlen) számokból felépülő mátrixok a MATLAB-ban fontos szerephez jutnak, hiszen pl. ily módon gyorsan lehet generálni általános, nagy méretű egyenletrendszert. Véletlen számok előállítására a rand() és a randi() függvény használható.

A rand függvény a [0, 1) intervallumon belüli (ál)véletlen számokat generál (hasonlóan, mint az Excel Vél függvénye), és ezekkel megadott méretű mátrix feltölthető. A randi függvény megadott határok közötti véletlen egészeket állít elő (egyenletes eloszlással), és ezekkel szintén fel tudunk tölteni adott méretű mátrixot. A méret mindkét esetben lehet egy darab szám (ez esetben négyzetes lesz a mátrix), vagy külön sor- és oszlopszám.

>> R = rand(3)  % véletlen 3×3-as mátrix
R =
    0.8147    0.9134    0.2785
    0.9058    0.6324    0.5469
    0.1270    0.0975    0.9575
>> uniform = rand(1, 6)  % véletlen sorvektor
uniform =
    0.9649    0.1576    0.9706    0.9572    0.4854    0.8003
>> uniform2 = rand(6, 1);  % véletlen oszlopvektor, kiíratás nélkül

A következő példában egy lottóhúzás eredményét szimuláljuk (az esetleges ismétlődést nem ellenőrizzük), majd rendezzük az eredményvektort.

>> L = randi([1 90], size(1:5))  % lottóhúzás szimuláció
L =
    60    4    77    85    62
>> sort(L)  % rendezés
ans =
    4    60    62    77    85

A randn() függvény standard normális eloszlású véletlen számokat (azaz: várható értékük 0, szórásuk 1) állít elő, a használat módja ugyanaz, mint amit a rand-nál megismertünk. A függvény segítségével most hisztogramot kérünk néhány száz adott várható értékű és szórású számról.

>> x = 2*randn(400, 1) + 10; hist(x)  % szórás: 2, várható érték: 10
Hisztogram (normális eloszlás)
3. ábra

Láthatjuk, hogy a minta a nem túl nagy elemszám ellenére is szépen kezdi kirajzolni a Gauss-görbét.

Ezzel szemben az egyenletes eloszlású véletlen adatok hisztogramja valóban nagyjából egyenletes lesz (lokális eltérések természetesen adódhatnak, a csipkézettség az elemszám növelésével csökkenthető).

>> x = rand(400,1); hist(x)  % egyenletes eloszlás
Hisztogram (egyenletes eloszlás)
4. ábra

Próbálja ki a fenti példákat 1000-1000 adatra úgy, hogy a hisztogram rekeszeinek a számát is módosítja (a hist parancs második paraméterként ez a szám megadható).

Mátrixokat manipuláló függvények
Tükrözés, forgatás, eltolás

A tükrözést, forgatást, eltolást megvalósító függvények látványos lehetőségeket adnak az eddig megismerteken túl további származtatott mátrixok előállítására, ill. újabb, bővített "építkezésre".

Az ebben és a következő alfejezetben bemutatott egyszerű példákat próbálja ki Ön is.

A flipud() (up-down; felülről lefelé) és fliplr() (left-right; balról jobbra) függőlegesen, ill. vízszintesen tükrözi a paraméterként megadott mátrixot. A parancsok önmaguk inverzei, egy adott tükrözést kétszer egymásután végrehajtva az eredeti mátrixot kapjuk meg újra.

>> A = [1:3; 4:6; 7:9];
>> flipud(A)  % függőleges tükrözés
ans =
    7    8    9
    4    5    6
    1    2    3
>> fliplr(fliplr(A))  % a tükrözött mátrixot újra tükrözzük
ans =
    1    2    3
    4    5    6
    7    8    9

Megemlítjük, hogy a flipdim() paranccsal kiváltható a flipud és a fliplr is. Ilyenkor második paraméterként a dimenziósorszámot meg kell adni.

>> flipdim(A, 1);  % függőleges tükrözés
>> flipdim(A, 2);  % vízszintes tükrözés

A rot90() parancs 90 fokonként balra forgatja el a megadott mátrixot (rotate - forgatás). A forgatások száma második, opcionális paraméterként megadható.

>> rot90(A)  % forgatás 90 fokkal balra
ans =
    3    6    9
    2    5    8
    1    4    7
>> rot90(A, 2)  % forgatás 2×90 fokkal balra
ans =
    9    8    7
    6    5    4
    3    2    1
>> eredeti = rot90(A, 4);  % visszakapjuk az eredeti mátrixot

A circshift() függvény mátrixok körkörös shiftelésére szolgál. Az eltolás felfelé és lefelé (ill. jobbra és balra) is elvégezhető. Ennek irányát és nagyságát a második paraméter határozza meg.

>> circshift(A, 1)  % függőleges körkörös eltolás lefelé 1 egységgel
ans =
    7    8    9
    1    2    3
    4    5    6
>> circshift(A, -2);  % eltolás felfelé 2 egységgel, az eredmény uaz

Ha vízszintes eltolást (is) szeretnénk, akkor a második paramétert dupla indexként kell megadni (y és x irányok, ebben a sorrendben).

>> circshift(A, [0 1])  % vízszintes körkörös eltolás jobbra 1 egységgel
ans =
    3    1    2
    6    4    5
    9    7    8

Próbálja ki a MATLAB-ban, hogy milyen eltolást hajt végre a circshift(mátrix, [1 2]) parancs.

A következőkben építkezéshez is felhasználjuk a most megismert mátrixfüggvényeket.

Feladatunk az, hogy a speciális mátrixfüggvények segítségével előállított megfelelő almátrixokból rakjuk össze az alábbi W mátrixot.

W =
    0    0    1    0    0    0    0
    0    1    0    0    0    0    0
    1    0    0    0    0    0    0
    0    0    0    0    0    0    1
    0    0    0    0    0    1    0
    0    0    0    0    1    0    0
    0    0    0    1    0    0    0

Látjuk, hogy a W mátrix 4 blokkra bontható, ezek mérete 3×3, 3×4; 4×3, 4×4.

A nem négyzetes blokkok zérusmátrixok, a négyzetes mátrixoknak pedig csak az anti-diagonálisa tartalmaz egyeseket. Ez utóbbiakat az egységmátrix (3×3-as, ill. 4×4-es példányainak) tükrözésével, vagy forgatásával állíthatjuk elő.

Eszerint a klasszikus összerakós megoldás (kiíratás nélkül):

>> W = [flipud(eye(3)), zeros(3,4); zeros(4,3), rot90(eye(4))];

Egy másik - direkt értékadásos - megoldás adódik annak felhasználásával, hogy a célmátrix fel nem töltött elemei automatikusan nullák lesznek. Így az értékadásokhoz csak a 4×4-es egységmátrix szükséges:

>> AE4 = rot90(eye(4)); W(1:3,1:3) = AE4(2:4,1:3); W(4:7,4:7) = AE4;

Még tömörebb képlethez jutunk abból az észrevételből, hogy a 7×7-es egységmátrix tükrözésével és körkörös eltolásával is előállítható a célmátrix.

>> W = flipud(circshift(eye(7), 4));
% A 7x7 egységmátrix sorait 4-gyel ciklikusan előretoltuk, majd tükröztük
>> A = circshift(flipud(eye(7)), 3);
% először tükrözünk, azután shiftelünk
Sávmátrixok, alsó- és felső háromszögmátrixok

A diag parancs felhasználásával kiemelhetjük egy mátrix főátlóját vagy valamelyik vele párhuzamos mellékátlóját (ennek sorszáma a második paraméterrel meghatározott - milyen messze vagyunk a főátlótól). Az eredmény egy oszlopvektor lesz.

>> D = [1:4; 11:14; 21:24; 31:34]  % tesztmátrix
D =
    1    2    3    4
    11    12    13    14
    21    22    23    24
    31    32    33    34
>> d = diag(D)  % főátló kiemelése
d =
    1
    12
    23
    34
>> d1 = diag(D, 1)  % a +1-es mellékátló kiemelése
d1 =
      2 
      13 
      24
>> d2 = diag(D, -1)'  % a -1-es mellékátló kiemelése, sorvektorba
d2 =
    11    22    33

Ha a diag parancs paramétere egy oszlopvektor, akkor a MATLAB egy megfelelő méretű négyzetes mátrix átlójában helyezi el az oszlopvektor elemeit (diagonális mátrix képződik). Az adott vektor a főátlóba vagy valamelyik mellékátlóba is elhelyezhető (ennek sorszáma a második paraméterrel meghatározott - milyen messze vagyunk a főátlótól). A mátrix többi eleme 0 lesz.

>> diag(diag(D))  % ugyanezt adja a diag(d) is
ans =
    1    0    0    0
    0    12    0    0
    0    0    23    0
    0    0    0    34
>> diag(diag(D, 1), 1)  % ugyanezt adja a diag(d1, 1) is
ans =
    0    2    0    0
    0    0    13    0
    0    0    0    24
    0    0    0    0

A parancs felhasználásával és mátrixösszeadással sávmátrixokat is készíthetünk.

>> diag(diag(D)) + diag(diag(D, 1), 1) + diag(diag(D, -1), -1)
ans =
    1    2    0    0
    11    12    13    0
    0    22    23    24
    0    0    33    34

Próbálja ki, hogy mit állít elő a diag(diag(D, -1), 1) + diag(diag(D, 1), -1) + diag(diag(D)) kifejezés! A MATLAB-os próba előtt írja le füzetébe a várható eredményt!

A tril és triu (l - lower, u - upper) függvények a mátrix alsó vagy felső háromszög alakú részét emelik ki, beleértve a főátlót is. Ha második paraméterként átlószám is szerepel, akkor a kiemelés a megjelölt mellékátlóig tart.

>> triu(D)
ans =
    1    2    3    4
    0    12    13    14
    0    0    23    24
    0    0    0    34
>> tril(D, -1)  % alsóháromszög, a -1-es átlóig
ans =
    0    0    0    0
    11    0    0    0
    21    22    0    0
    31    32    33    0

A következő példában az eredeti mátrixot a megfelelő függvényekkel három diszjunkt részre szeleteljük (alsó- és felsőháromszög, főátló), majd ezen részek összegeként visszakapjuk az eredeti mátrixot.

>> fent = triu(D, 1); lent = tril(D, -1); atlo = diag(diag(D)); ...
fent + lent + atlo
ans =
    1    2    3    4
    11    12    13    14
    21    22    23    24
    31    32    33    34

Az alfejezetet annak a script-fájlnak (M-fájlnak) a bemutatásával zárjuk, amely már az első MATLAB-os ismerkedésünknél is szerepelt. A parancs (függvény) megadott méretű sávmátrixot készít, és ennek főátlóját, ill. alsó- és felső mellékátlóját megadott elemekkel tölti fel.

Nyissunk meg a MATLAB editorral egy üres M-fájlt (a File/New menüpont alatt). Írjuk be vagy másoljuk be a következő kódot (a zöld komment sorok a működéshez nem szükségesek, de az értelmezést elősegítik):

function T = tridiag(a, b, c, n)
% tridiag  Tridiagonális mátrix.
% T = tridiag(a, b, c, n) visszatérő értéke egy n×n-es mátrix, ahol
% az a, b, c értékek a főátló, az alsó és a felső mellékátló
% elemeit jelentik.
T = a*diag(ones(n,1)) + b*diag(ones(n-1,1),1) + c*diag(ones(n-1,1),-1);

A fájlt mentsük el. A parancs ezután már használható:

>> tridiag(1, 2, 3, 4)
ans =
    1    2    0    0
    3    1    2    0
    0    3    1    2
    0    0    3    1

Az M-fájlok általánosan egy vagy több MATLAB utasítást tartalmaznak, amelyeket a gép az M-fájl nevének, mint parancsnak a kiadásával végrehajt.

Mi most speciálisan egy függvényt készítettünk, a visszatérési érték definiálása miatt. További példákat a következő leckében találunk.

Önellenőrző kérdések
1. A Pascal-mátrix segítségével állapítsa meg az ( a+b ) 7 kifejtésében az a 5 b 2 tag együtthatóját!

2. Határozza meg, hogy melyik Hilbert mátrixnak lesz először kisebb a determinánsa, mint az eps érték!

Felesleges zárójeleket és szimbólumokat ne használjon!
3. Építse fel az egységmátrix, a csupa nulla mátrix, a csupa egyes mátrix, a Pascal-mátrix, a Hilbert-mátrix, a mágikus mátrix és egyszerű mátrixműveletek (transzponálás is megengedett) segítségével a következő mátrixot

T =
    16     5     9     4     0     0
     2    11     7    14     0     0
     3    10     6    15     0     0
    13     8    12     1     0     0
     4     0     1     1     1     1
     0     4     1     1     1     1

4. Hisztogram kirajzolásával ellenőrizze, hogy sok (itt: 192 darab) egyenletes eloszlású véletlen szám összege már más eloszlású lesz!

Tipp: a sum(A) művelet az A mátrix oszlopainak összegét képezi egyetlen sorvektorba. Erre kérjünk hisztogramot.

Megoldás:

5. Hozzon létre olyan 5×5-ös méretű mátrixot, amely az antiátlójában csupa 5-ös elemet tartalmaz, a többi pozícióban pedig 0 áll.

Tipp: Használja valamelyik tükröző függvényt.

6. Állítsa elő a következő (még nem létező) mátrixot elemeire történő értékadásokkal! (lehetőleg a legkevesebbel)

     0    10     0     0     0     0     0     0     0     0
     0     0    10     0     0     0     0     0     0     0
     0     0     0    10     0     0     0     0     0     0
     0     0     0     0    10     0     0     0     0     0
     0     0     0     0     0    10     0     0     0     0
     0     0     0     0     0     0    10     0     0     0
     0     0     0     0     0     0     0    10     0     0
     0     0     0     0     0     0     0     0    10     0
     0     0     0     0     0     0     0     0     0    10
     0     0     0     0     0     0     0     0     0     0

Segítség:

a)clear A; A(1:9, 2:10) = 10*eye(9) az utolsó sor nélküli eredményt adja. Hogyan jöhet létre az utolsó sor?
b)Shiftelje az egységmátrix 10-szeresét függőlegesen negatív irányba, vagy vízszintesen pozitív irányba, és a felesleges elemet nullázza ki!

7. Hozzon létre a leckében bemutatott példa felhasználásával (módosításával) egy tridiag2 nevű M-fájt, amely olyan sávmátrixot készít a megadott elemekből, hogy az elemek a főátlóban, ill. a +2-es és a -2-es mellékátlóban szerepelnek (a +1-es és a -1-es mellékátlóba 0-ák kerülnek).

Minta:

>> tridiag2(1, 2, 3, 4)
ans =
     1     0     2     0
     0     1     0     2
     3     0     1     0
     0     3     0     1