Informatika1-2019/Gyakorlat10

A MathWikiből
(Változatok közti eltérés)
(Új oldal, tartalma: „Előző gyakorlat - Fel - Következő gyakorlat = MatLab = Az [ht…”)
 
1. sor: 1. sor:
 
[[Informatika1-2019/Gyakorlat9|Előző gyakorlat]] - [[Informatika1-2019#Gyakorlatok|Fel]] - [[Informatika1-2019/Gyakorlat11|Következő gyakorlat]]
 
[[Informatika1-2019/Gyakorlat9|Előző gyakorlat]] - [[Informatika1-2019#Gyakorlatok|Fel]] - [[Informatika1-2019/Gyakorlat11|Következő gyakorlat]]
  
= MatLab =
+
= MatLab feladatok =
  
Az [http://www.mathworks.com/products/matlab/ MatLab] program alkalmas különböző matematikai számításokat numerikusan elvégzésére, köztük
+
== LER ==
* lineáris (mátrix) egyenletek megoldása
+
Számoljuk ki az alábbi egyenletrendszerek összes megoldását, illetve állapítsuk meg, hogy van-e megoldásuk.
* differenciál-egyenletek, megoldása
+
* szabályozástechnika
+
 
+
Neve a ''Matrix Laboratory'' rövidítése, a 70-es években kezdte el fejleszteni ''Cleve Moler'', a ''University of New Mexico'' egyetem számítástudományi tanszékének vezetője.
+
Azóta a [https://www.mathworks.com mathworks] cég [https://en.wikipedia.org/wiki/Proprietary_software fizetős] terméke lett.
+
 
+
Van egy [https://en.wikipedia.org/wiki/Open_source ingyenes] alternatívája, az [http://www.gnu.org/software/octave/ Octave].
+
 
+
== Kezdeti lépések ==
+
 
+
=== Hozzáférés a programhoz ===
+
Ha otthonról dolgozunk, akkor a következő lehetőségek legalább egyikével éljünk:
+
* A BME-től kaphatunk licenszet: https://net.bme.hu/sw/. Kövessük az utasításokat a honlapon (BME-s hálózaton belülről érhető el).
+
* vagy http://software.eik.bme.hu/Mathworks/Matlab_and_Simulink/
+
* [[Putty használata|Putty]]-al lépjünk be a <tt>leibniz</tt>-re és írjuk be a terminálba, hogy <tt>matlab</tt>
+
A Leibniz-en telepítve van, gépteremből is használhatjuk.
+
 
+
=== Számológép ===
+
 
+
Egy terminálban adjuk ki a következő parancsot:
+
 
+
matlab -nojvm
+
 
+
A MatLab egy fejlettebb számológépként is használható. Írjuk be az alábbiakat:
+
2 + 3
+
majd üssünk <tt>Enter</tt>-t. Ennek hatására:
+
> 2 + 3
+
ans =  5
+
Próbáljuk ki ezeket is:
+
2 - 3
+
2 * 3
+
2 / 3
+
floor (2 / 3)
+
mod (2, 3)
+
2^3
+
sqrt (2)
+
log (2)
+
log (3)
+
log (8) / log (2)
+
exp (1)
+
pi
+
cos (pi / 2)
+
(180 / pi) * acos (0.5)
+
 
+
Kilépni így lehet
+
exit
+
 
+
== Adattípusok ==
+
Minden szám alapértelmezésben lebegőpontos, akkor is, ha véletlenül egész:
+
1000 / 9
+
ans = 111.11
+
Viszont megadhatjuk, hogy egészekként értelmezze a számokat:
+
int32 (1000) / int32 (9)
+
ans = 111
+
MatLab-ban egy szám mindaddig valós, amíg komplexnek nem bizonyul:
+
sqrt (2)
+
sqrt (-2)
+
 
+
=== A számábrázolások ===
+
* <tt>double</tt>: dupla lebegő pontos, 64 bit (8 byte)
+
** valós: 8 byte
+
** komplex: 16 byte
+
* <tt>single</tt>: szimpla lebegő pontos, 32 bit (4 byte)
+
** valós 4 byte
+
** komplex: 8 byte
+
* <tt>int32</tt>: 32 bites kettes komplemens egész (4 byte)
+
* <tt>int8</tt>: 8 bites kettes komplemens egész: -128..127 (1 byte)
+
* <tt>uint32</tt>: 32 bites előjel nélküli egész (4 byte)
+
* <tt>uint8</tt>: 8 bites előjel nélküli egész: 0..255 (1 byte)
+
A méret nagyon is számít:
+
log(single(1.0001))
+
log(double(1.0001))
+
int32(100+100)
+
int8(100+100)
+
 
+
=== Mátrixok ===
+
Az <tt>MatLab</tt>-ban '''minden szám egy mátrix'''
+
* számok: <tt>1x1</tt>
+
* vektorok:
+
** sorvektor: <tt>1xn</tt>
+
** oszlopvektor: <tt>nx1</tt>
+
* matrix: <tt>nxm</tt>
+
Ennek alapos oka van, amit majd később fogunk megérteni és ami a MatLab leglényegéhez vezet bennünket. [https://en.wikipedia.org/wiki/MATLAB#History Bővebben itt].
+
 
+
Sorvektor:
+
[1 2 3 4]
+
[1, 2, 3, 4]
+
Oszlopvektor:
+
[1; 2; 3; 4]
+
Ez '''nem''' oszlopvektor:
+
[[1], [2], [3], [4]]
+
Mátrix:
+
[1 2; 3 4]
+
[1, 2; 3, 4]
+
Speciális mátrixok:
+
* <tt>zeros</tt>: csupa 0
+
* <tt>ones</tt>: csupa 1
+
* <tt>eye</tt>: diagonálisban 1, máshol 0
+
* <tt>diag</tt>: négyzetes diagonális mátrix, megadott főátlóval
+
zeros (2, 3)
+
eye (2, 3)
+
ones (3, 1)
+
diag ([1, 2, 3, 4])
+
 
+
Próbáljuk ki:
+
size (5)
+
size ([1, 2, 3])
+
size ([1; 2; 3])
+
 
+
=== Tartományok ===
+
A tartományok speciális sorvektorok, próbáljuk ki:
+
1:10
+
Ha nem egyesével akarunk ugrani:
+
1:0.1:2
+
1:2:10
+
Komplex számmal nem lehet, mert azok nem rendezhetőek!<br>
+
Az eredmény mindig <tt>double</tt> lesz, de utána konvertálhatjuk:
+
int32 (1:0.5:10)
+
 
+
Leszálló tartományok:
+
4:-1:1
+
 
+
Üres tartomány:
+
4:1:1
+
4:1
+
 
+
Diagonális mátrixot megadhatunk így is:
+
> diag(1:4)
+
ans =
+
  1 0 0 0
+
  0 2 0 0
+
  0 0 3 0
+
  0 0 0 4
+
 
+
== Műveletek mátrixokkal ==
+
Mivel minden szám egyben egy <tt>1x1</tt>-es mátrix, így ezek mindig használhatóak.
+
 
+
=== Transzponált ===
+
Transzponált egyszerűen '''vesszővel''' (<tt>'</tt>):
+
> [1 2; 3 4]'
+
ans =
+
  1 3
+
  2 4
+
> _
+
Vagy
+
> (1:4)'
+
ans =
+
  1
+
  2
+
  3
+
  4
+
Komplex mátrixokra a vessző [http://mathworld.wolfram.com/ConjugateTranspose.html adjungálást] jelent, azaz a transzponált elemenkénti konjugáltját:
+
> [1 2i; 3i 4]'
+
ans =
+
  1 - 0i  0 - 3i
+
  0 - 2i  4 - 0i
+
Konjugálást így csinálhatunk: <tt>(2 + 1i)'</tt>
+
 
+
=== Összeadás ===
+
1 + (1:4)
+
eye (2, 2) + ones (2, 2)
+
[1; 2; 3; 4] - [4; 3; 2; 1]
+
 
+
=== Szorzás ===
+
Minden szorzás mátrixszorzás:
+
> [1 2; 3 4]*[1 2; 3 4]
+
ans =
+
    7  10
+
  15  22
+
Hatványozás szintén, így az invertálás is:
+
[1 2; 3 4]^2
+
[1 2; 3 4]^-1
+
A szorzásnál a méreteknek kompatibiliseknek kell lenniük:
+
ones (2, 3) * ones (3, 5)
+
Sorvektor szorozva oszlopvektorral a skalárszorzás, fordítva diádszorzatnak hívjuk:
+
[1,2,3]*[1;2;3]
+
[1;2;3]*[1,2,3]
+
 
+
=== Tagonként vagy mátrixként ===
+
Ha a hatványozást ismételt mátrixszorzásként értelmezi, akkor ez mi?
+
[1 2; 3 4]^0.5
+
És ez mi?
+
sqrt([1 2; 3 4])
+
 
+
Bizonyos műveletek ''tagonként hatnak'' ha egy mátrixra alkalmazzuk, míg mások mátrix-műveletként. De tudunk váltani köztük.
+
> (1:4)^2
+
error: for A^b, A must be a square matrix
+
Hibát ad, mert két <tt>1x4</tt>-es mátrixnak nem értelmes a szorzata. De:
+
> (1:4).^2
+
ans =
+
  1  4  9 16
+
Minden műveleti jel olyan, hogy '''ha elé pontot rakunk, akkor elemenként hat'''. Például az összeadásnál a mátrix összeadás és az elemenkénti összeadás ugyan az, nincsen <tt>.+</tt> művelet.
+
> [1 2; 3 4] * [1 2; 3 4]
+
ans =
+
    7  10
+
  15  22
+
> [1 2; 3 4] .* [1 2; 3 4]
+
ans =
+
    1    4
+
    9  16
+
Hatványozás hasonlóan:
+
> [1 2; 3 4]^-1
+
ans =
+
  -2.00000  1.00000
+
  1.50000  -0.50000
+
> [1 2; 3 4].^-1
+
ans =
+
  1.00000  0.50000
+
  0.33333  0.25000
+
 
+
A nevesített függvények általában elemenként hatnak:
+
sin (0:0.1:2*pi)
+
exp ([0,-1;1,0])
+
A műveleti jelek pedig mátrix műveletként (<tt>*, ^, /, \</tt>)
+
 
+
== Változók ==
+
Ahhoz hogy ne csak egy soros dolgokat tudjunk számolni, az adatokat ''változókban'' tároljuk.
+
a = 2
+
b = 3
+
a + b
+
Mindig van egy <tt>ans</tt> nevű változónak, amiben az ''utoljára kiszámolt érték'' található.<br>
+
Ha nincsen érték adva egy változónak, akkor nem tudunk hivatkozni rá:
+
> a / q
+
error: `q' undefined
+
 
+
A pontosvesszővel (<tt>;</tt>) '''csendes számolást''' végezhetünk, ekkor a parancs eredménye nem lesz kiírva:
+
a = 2;
+
b = 3;
+
a + b
+
 
+
Akkor hasznos, ha az eredményt úgyis elmentjük egy változóba és külön nem akarjuk látni. Később is megnézhetjük.
+
 
+
A <tt>whos</tt> paranccsal megnézhetjük az aktuálisan tárolt változóinkat.
+
> whos
+
Variables in the current scope:
+
  Attr Name        Size                    Bytes  Class
+
  ==== ====        ====                    =====  =====
+
        a          1x1                          8  double
+
        ans        1x1                          8  double
+
        b          1x1                          8  double
+
Total is 3 elements using 24 bytes
+
 
+
Egy változó értékét bármikor felülírhatjuk:
+
> a = 2;
+
> a = [1 2; 3 4];
+
> whos
+
Variables in the current scope:
+
  Attr Name        Size                    Bytes  Class
+
  ==== ====        ====                    =====  =====
+
        a          2x2                        32  double
+
 
+
== Indexelés ==
+
Legyen <tt>M</tt> egy <tt>3x3</tt>-as mátrix. Ennek az i-edik sorának j-edik eleme a következő.
+
M = rand(3,3);
+
i = 1;
+
j = 3;
+
M(i,j)
+
 
+
Mátrixok összefűzése:
+
[M M]
+
[M; M]
+
Részsorozat kiválasztása a tartományok használatával:
+
l = 0:0.1:1;
+
l (:)
+
l (1:11)
+
l (1:5)
+
l (5:end)
+
l (1:2:11)
+
Sőt:
+
l (1:2:11) = 0
+
 
+
Részmátrix hasonlóan, csak két indexszel.
+
A = [1 2 3; 4 5 6; 7 8 9];
+
A (1:3, 1:2)
+
A (1:2, 1:3)
+
Egy sor kihagyása:
+
A ([1, 3], :)
+
Vagy részmátrix kiválasztása:
+
S = ones (8, 8);
+
S (3:6, 3:6) = -1
+
Vagy adott indexekre:
+
S = ones (8, 8);
+
S ([1 2 8], [2 6]) = 8
+
 
+
Mátrix kilapítása:
+
A = eye (3, 3);
+
A (:)
+
 
+
== Összegzés ==
+
 
+
* A mátrix sorait összegzi a <tt>sum(&#9679;, 1)</tt>
+
* A mátrix oszlopait összegzi a <tt>sum(&#9679;, 2)</tt>
+
 
+
Azon dimenzió szerint összegez, ami a második paraméter. Ha nincsen második paraméter, akkor 1-nek tekinti.
+
Az összes elemet kilapítással összegezhetjük:
+
 
+
sum(A(:))
+
 
+
== Vektorizáció ==
+
Az MatLab-ban általában egyszerre sok dolgot számolunk, nem csak egy értéken értékelünk ki egy függvényt.
+
Például az <tt>X</tt> mátrix minden sorának számoljuk ki a normáját (<tt>X</tt> lehet <tt>nx3</tt>-as, ahol <tt>n</tt> nagyon sok):
+
X = rand (10, 3);
+
sqrt (sum (X.^2, 2))
+
ans =
+
  0.99105
+
  0.86977
+
  1.29362
+
  0.91697
+
  1.26149
+
  0.84024
+
  1.45410
+
  1.19791
+
  1.01153
+
  1.07420
+
Belülről kifelé haladva elemezzük a függvényeket:
+
* <tt>X.^2</tt>: kiszámolja az elemenkénti négyzetet
+
* <tt>sum(&#9679;, 2)</tt>: összegzi a mátrix sorait egy oszlopvektorba (a 2 azt jelenti, a tömb második dimenziója, azaz a 2. index mentén)
+
* <tt>sqrt</tt>: elemenként gyököt von
+
 
+
Számoljuk ki a <tt>2x^2-3x+1</tt> függvényértékeket, ahol <tt>x</tt> egy sorvektor:
+
x=0:0.1:1;
+
fx=2.*x.^2 - 3.*x + 1
+
 
+
A ''vektorizáció'' lényege, hogy ahol lehet mátrix és vektor műveletekre vezessük vissza a számításainkat, mert '''1000 darab számpár összeszorzása lassabb, mint két darab 1000 hosszú vektor szorzása'''!
+
 
+
== Függvények ==
+
Írjuk be a következőket egy <tt>f.m</tt> nevű fájlba!
+
function fx = f (x)
+
  fx = 1 / (x^2 + 1);
+
end
+
 
+
Ha a fájl neve megegyezik a függvénnyel és abban a mappában van, ahonnan a programot indítottuk, akkor így használhatjuk:
+
> f(3)
+
ans = 0.10000
+
 
+
Függvények megadása:
+
function <<az eredmény>> = <<a függvény neve>> (<<változók>>)
+
  ...
+
end
+
A függvény hasában bármit számolhatunk, de a végén adjunk értéket <tt><<az eredmény>></tt> változónak. A függvény hasában érdemes csendes számítást végezni, itt használjunk mindenütt pontosvesszőt ('''<tt>;</tt>''') a sor végén!
+
 
+
Egy másik függvény:
+
function R = remove_last (x)
+
  R = x (1:end-1);
+
end
+
Ezt egy <tt>remove_last.m</tt>  fájlba tegyük. Példa:
+
> remove_last (1:5)
+
ans =
+
  1  2  3  4
+
 
+
== Feladatok ==
+
 
+
=== Elemi sorműveletek elvégzése ===
+
Hozzunk létre egy egyjegyű nemnegatív egészekből álló 4x5-ös mátrixot, majd cseréljük ki két sorát, szorozzuk be a második sorát 2-vel és adjuk az első sorának kétszeresét a harmadik sorhoz! (A mátrix redukált lépcsős alakjának meghatározására azért a <tt>rref</tt> függvényt használjuk!)
+
 
+
=== Mi ez? ===
+
Figyeljük meg a következőket.
+
A=[1 2 3; 4 5 6; 7 8 9];
+
B=[9 8 7; 6 5 4; 3 2 1];
+
trace (A*B')
+
A(:)' * B(:)
+
Mi a <tt>trace(A*B')</tt>?
+
 
+
=== LER ===
+
Számoljuk ki a következő lineáris egyenletrendszer megoldását:
+
  x + 2y = 3
+
4x + 5y = 6
+
1. megoldás:
+
A = [1 2; 4 5]
+
b = [3; 6]
+
x = A^-1 * b
+
2. megoldás:
+
x = A \ b
+
 
+
=== Még LER ===
+
Oldjuk meg a következő egyenletrendszereket:
+
  
 +
=== a ===
 
   x + 5y = 1
 
   x + 5y = 1
 
  2x + 4y = 2
 
  2x + 4y = 2
  
 +
=== b ===
 
   x + 5y = 1
 
   x + 5y = 1
 
  2x + 4y = 2
 
  2x + 4y = 2
 
  5x - 6y = -1
 
  5x - 6y = -1
  
 +
=== c ===
 
   x + 2y + 5z = 1
 
   x + 2y + 5z = 1
 
  5x + 4y + 6z = 2
 
  5x + 4y + 6z = 2
  
=== Nagy mátrix okosan ===
+
Írjuk meg a fenti általános LER megoldót egy függvénybe!
 
+
* Készítsük el a következő mátrixot okosan! (Minél kevesebb karaktert használva.)
+
1 2 2 2 2 2 2 2 2 2
+
2 2 2 2 2 2 2 2 2 2
+
2 2 3 2 2 2 2 2 2 2
+
2 2 2 4 2 2 2 2 2 2
+
2 2 2 2 5 2 2 2 2 2
+
2 2 2 2 2 6 2 2 2 2
+
2 2 2 2 2 2 7 2 2 2
+
2 2 2 2 2 2 2 8 2 2
+
2 2 2 2 2 2 2 2 9 2
+
2 2 2 2 2 2 2 2 2 10
+
  
* És most ezt:
+
== Trükkös mátrix ==
  0  1  0  0  0  0  0  0  0
+
-1  0  1  0  0  0  0  0  0
+
  0 -1  0  1  0  0  0  0  0
+
  0  0 -1  0  1  0  0  0  0
+
  0  0  0 -1  0  1  0  0  0
+
  0  0  0  0 -1  0  1  0  0
+
  0  0  0  0  0 -1  0  1  0
+
  0  0  0  0  0  0 -1  0  1
+
  0  0  0  0  0  0  0 -1  0
+
  
* Sakktáblaszabály
+
Állítsuk elő az alábbi mátrixot:
  1  -1  1  -1  1
+
  -1  1  -1  1  -1
+
  1  -1  1  -1  1
+
  -1  1  -1  1  -1
+
  1  -1  1  -1  1
+
  
=== Függvény mátrixokon ===
+
    1    2    3    4    5    6    7    8    9    10
 +
    2    3    4    5    6    7    8    9    10    11
 +
    3    4    5    6    7    8    9    10    11    12
 +
    4    5    6    7    8    9    10    11    12    13
 +
    5    6    7    8    9    10    11    12    13    14
 +
    6    7    8    9    10    11    12    13    14    15
 +
    7    8    9    10    11    12    13    14    15    16
 +
    8    9    10    11    12    13    14    15    16    17
 +
    9    10    11    12    13    14    15    16    17    18
 +
    10    11    12    13    14    15    16    17    18    19
  
Írjunk függvényt, mely az adott mátrix minden elemére alkalmazza a <tt>2sin<sup>2</sup>x + 1</tt> függvényt.
+
=== szorzótábla ===
 +
Készítsünk modulo-7 szorzótáblát:
  
=== Részmátrix ===
+
    0    0    0    0    0    0    0
 +
    0    1    2    3    4    5    6
 +
    0    2    4    6    1    3    5
 +
    0    3    6    2    5    1    4
 +
    0    4    1    5    2    6    3
 +
    0    5    3    1    6    4    2
 +
    0    6    5    4    3    2    1
  
Írjunk függvényt, mely egy 5x5-ös mátrix 2. és 4. sorából és 1., 3. és 5. oszlopából álló mátrixot adja.
+
=== általánosan ===
 +
Készítsünk függvényt, ami egy adott ''n'' számra elkészíti a modulo-n szorzótáblát, de csak ha ''n'' prím szám. Ha nem prím, adjon vissza egy <math>n\times n</math>-es csupa nulla mátrixot.
  
=== Részmátrixon függvény ===
+
isprime
  
Írjuk meg az elõzõ két függvény kombinációját, mely az adott mátrix 2. és 4. sorából és 1., 3. és 5. oszlopából álló mátrixon alkalmazza a <tt>2sin<sup>2</sup>x + 1</tt> függvényt.
+
== Összegzések ==
  
=== Minden második oszlop ===
+
=== a ===
 +
Írjunk olyan függvényt, ami térbeli pontoknak meghatározza a súlypontját. Ehhez generáljunk egy <math>n\times3</math>-as véletlen mátrixot, melynek minden sora egy 3-dimenziós pontot reprezentál.
 +
Ez legyen a függvény bemenete. Kimenete pedig egy
  
Írjunk függvényt, mely tetszőleges mátrix minden második oszlopából álló mátrixot adja vissza. (Segítség, a <tt>size</tt> sorvektorban megadja a mátrix dimenzióját.)
+
=== a ===
 +
Írjunk olyan függvényt, ami egy mátrixnak kiszámolja az elemeinek abszolút értékének átlagát
  
=== Függvény alkalmazás csak adott elemeken ===
+
=== b ===
 +
Írjunk olyan függvényt, ami egy mátrixnak kiszámolja az elemeinek abszolút értékének soronkénti összegének maximumát.
 +
<math>M = \max_{i}\sum_{j} |A_{i,j}|</math>
  
Írjunk függvényt, mely a kapott mátrix csak minden második oszlopán hajtja végre a <tt>2sin<sup>2</sup>x + 1</tt> függvényt. (Az eredmény mátrix dimenziója ugyanaz, mint a kapott mátrix.)
+
=== c ===
 +
Írjunk olyan függvényt, ami egy mátrixnak kiszámolja az elemeinek abszolút értékének oszloponkénti összegének maximumát.
 +
<math>m = \max_{j}\sum_{i} |A_{i,j}|</math>
  
=== Segíts magadon ===
+
=== d ===
* https://www.mathworks.com/matlabcentral/answers
+
* http://www.mathworks.com/help/matlab/
+
* Google
+
  
=== Numerikus deriválás ===
 
Deriváljuk az <tt>f(x)=2x^2-3x+1</tt> függvényt numerikusan! Adott egy <tt>x</tt> sorvektor, ami az abszcissza értékeket tartalmazza, <tt>fx</tt> pedig a hozzájuk tartozó függvényértékeket.
 
x = 0:0.1:1
 
fx = 2.*x.^2 - 3.*x + 1
 
Ekkor a függvény [https://en.wikipedia.org/wiki/Numerical_differentiation numerikus deriváltja]:
 
df = (fx(2:end) - fx(1:end-1)) ./ 0.1
 
Nem egyenletes lépésközzel pedig:
 
df = (fx(2:end) - fx(1:end-1)) ./ (x(2:end) - x(1:end-1))
 
  
 
[[Informatika1-2019/Gyakorlat9|Előző gyakorlat]] - [[Informatika1-2019#Gyakorlatok|Fel]] - [[Informatika1-2019/Gyakorlat11|Következő gyakorlat]]
 
[[Informatika1-2019/Gyakorlat9|Előző gyakorlat]] - [[Informatika1-2019#Gyakorlatok|Fel]] - [[Informatika1-2019/Gyakorlat11|Következő gyakorlat]]

A lap 2019. november 20., 21:06-kori változata

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

Tartalomjegyzék

MatLab feladatok

LER

Számoljuk ki az alábbi egyenletrendszerek összes megoldását, illetve állapítsuk meg, hogy van-e megoldásuk.

a

 x + 5y = 1
2x + 4y = 2

b

 x + 5y = 1
2x + 4y = 2
5x - 6y = -1

c

 x + 2y + 5z = 1
5x + 4y + 6z = 2

Írjuk meg a fenti általános LER megoldót egy függvénybe!

Trükkös mátrix

Állítsuk elő az alábbi mátrixot:

    1     2     3     4     5     6     7     8     9    10
    2     3     4     5     6     7     8     9    10    11
    3     4     5     6     7     8     9    10    11    12
    4     5     6     7     8     9    10    11    12    13
    5     6     7     8     9    10    11    12    13    14
    6     7     8     9    10    11    12    13    14    15
    7     8     9    10    11    12    13    14    15    16
    8     9    10    11    12    13    14    15    16    17
    9    10    11    12    13    14    15    16    17    18
   10    11    12    13    14    15    16    17    18    19

szorzótábla

Készítsünk modulo-7 szorzótáblát:

    0     0     0     0     0     0     0
    0     1     2     3     4     5     6
    0     2     4     6     1     3     5
    0     3     6     2     5     1     4
    0     4     1     5     2     6     3
    0     5     3     1     6     4     2
    0     6     5     4     3     2     1

általánosan

Készítsünk függvényt, ami egy adott n számra elkészíti a modulo-n szorzótáblát, de csak ha n prím szám. Ha nem prím, adjon vissza egy n\times n-es csupa nulla mátrixot.

isprime

Összegzések

a

Írjunk olyan függvényt, ami térbeli pontoknak meghatározza a súlypontját. Ehhez generáljunk egy n\times3-as véletlen mátrixot, melynek minden sora egy 3-dimenziós pontot reprezentál. Ez legyen a függvény bemenete. Kimenete pedig egy

a

Írjunk olyan függvényt, ami egy mátrixnak kiszámolja az elemeinek abszolút értékének átlagát

b

Írjunk olyan függvényt, ami egy mátrixnak kiszámolja az elemeinek abszolút értékének soronkénti összegének maximumát.

M = maxi | Ai,j |
j

c

Írjunk olyan függvényt, ami egy mátrixnak kiszámolja az elemeinek abszolút értékének oszloponkénti összegének maximumát.

m = maxj | Ai,j |
i

d

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

Személyes eszközök