Contents
A command window használata
A Command window-ot lehet simán számolásra is használni
234*76
ans =
17784
vagy bonyolultabb kifejezéseket is tud értelmezni.
exp(i*pi)
ans = -1.0000 + 0.0000i
Viszont numerikus kerekítési hibák előfordulhatnak.
exp(i*pi)+1
ans = 0.0000e+00 + 1.2246e-16i
A dupla egyenlőságjellel kérdezzük meg, hogy egynlő-e? A kimenet azt mondja hogy nem. A 0 jelenti a logikailag hamis állítást az 1 (vagy bármilyen nem nulla szám) az igazat.
ans==0
ans = logical 0
Értékadás
Egy álatalunk kitalált nevű változónak a "=" -el adhatunk értéket.
a=3.2
a =
3.2000
b=4
b =
4
A who paranccsal kérdezhetjük meg már meglévő változóink neveit.
who
Your variables are: a ans b
Ha simán lefuttatunk egy parancsot és nem tároljuk el a választ akkor a válasz az "ans" (vagyis answer-válasz) nevű változóban tárolódik el. Ezzel a változóval ugyanúgy lehet bánni mint a többi válatozóval.
ans
ans = logical 0
Az értékadás úgy történik, hogy előzör kiértékalik a jobboldalt majd az így kapott értéket a baloldalba rakjuk.
ans=ans+1
ans =
1
A "whos" parancs az is kiírja, hogy a változóink mekkorák, és milyen pontossággal vannak (belül a Matlabban) ábrázolva.
whos
Name Size Bytes Class Attributes a 1x1 8 double ans 1x1 8 double b 1x1 8 double
c=5.6
c =
5.6000
Egy valós számnak az alakját a format paranccsal változtathatjuk
format long
c
c = 5.600000000000000
Itt csak a kiírás alakjét változtatjuk (nem a belső ábrázolásét).
Ha rámegyünk egy parancsra akkor F1-el segítséget kérhetünk róla. Vagy lefuttatjuk a 'doc parancsnév' parancsot akkor ugyazez töténik.
doc format
Ha a terminálba akarunk leírást kérni (mondjuk nincs grafikus felület a számítógépen) akkor a 'help parancsnév'-vel tehetjül ezt meg.
help format
FORMAT Set output format.
FORMAT with no inputs sets the output format to the default appropriate
for the class of the variable. For float variables, the default is
FORMAT SHORT.
FORMAT does not affect how MATLAB computations are done. Computations
on float variables, namely single or double, are done in appropriate
floating point precision, no matter how those variables are displayed.
Computations on integer variables are done natively in integer. Integer
variables are always displayed to the appropriate number of digits for
the class, for example, 3 digits to display the INT8 range -128:127.
FORMAT SHORT and LONG do not affect the display of integer variables.
FORMAT may be used to switch between different output display formats
of all float variables as follows:
FORMAT SHORT Scaled fixed point format with 5 digits.
FORMAT LONG Scaled fixed point format with 15 digits for double
and 7 digits for single.
FORMAT SHORTE Floating point format with 5 digits.
FORMAT LONGE Floating point format with 15 digits for double and
7 digits for single.
FORMAT SHORTG Best of fixed or floating point format with 5
digits.
FORMAT LONGG Best of fixed or floating point format with 15
digits for double and 7 digits for single.
FORMAT SHORTENG Engineering format that has at least 5 digits
and a power that is a multiple of three
FORMAT LONGENG Engineering format that has exactly 16 significant
digits and a power that is a multiple of three.
FORMAT may be used to switch between different output display formats
of all numeric variables as follows:
FORMAT HEX Hexadecimal format.
FORMAT + The symbols +, - and blank are printed
for positive, negative and zero elements.
Imaginary parts are ignored.
FORMAT BANK Fixed format for dollars and cents.
FORMAT RAT Approximation by ratio of small integers. Numbers
with a large numerator or large denominator are
replaced by *.
FORMAT may be used to affect the spacing in the display of all
variables as follows:
FORMAT COMPACT Suppresses extra line-feeds.
FORMAT LOOSE Puts the extra line-feeds back in.
Example:
format short, pi, single(pi)
displays both double and single pi with 5 digits as 3.1416 while
format long, pi, single(pi)
displays pi as 3.141592653589793 and single(pi) as 3.1415927.
format, intmax('uint64'), realmax
shows these values as 18446744073709551615 and 1.7977e+308 while
format hex, intmax('uint64'), realmax
shows them as ffffffffffffffff and 7fefffffffffffff respectively.
The HEX display corresponds to the internal representation of the value
and is not the same as the hexadecimal notation in the C programming
language.
See also DISP, DISPLAY, ISNUMERIC, ISFLOAT, ISINTEGER.
Reference page in Doc Center
doc format
Az ':' operátor
A 'a:b' operátorral felsoroljuk az összes elemet 1 lépésközzel az 'a' és 'b' elem közt pl:
v=1:10
v =
1 2 3 4 5 6 7 8 9 10
Az 'a:c:b' ugyanezt csinálja 'c' lépésközzel
v2=1:2:10
v2 =
1 3 5 7 9
A kifejezést nem zavarja ha nem egész számról kezdünk
0.5:13
ans = Columns 1 through 3 0.500000000000000 1.500000000000000 2.500000000000000 Columns 4 through 6 3.500000000000000 4.500000000000000 5.500000000000000 Columns 7 through 9 6.500000000000000 7.500000000000000 8.500000000000000 Columns 10 through 12 9.500000000000000 10.500000000000000 11.500000000000000 Column 13 12.500000000000000
Ha zavar minket, hogy a valós számokat tűl hosszan ábrázolja, akkor kiírathatjuk őket rövidebben is
format short
ans
ans =
Columns 1 through 7
0.5000 1.5000 2.5000 3.5000 4.5000 5.5000 6.5000
Columns 8 through 13
7.5000 8.5000 9.5000 10.5000 11.5000 12.5000
Látjuk hogy az 'ans' itt már nem 1x1-es
whos
Name Size Bytes Class Attributes a 1x1 8 double ans 1x13 104 double b 1x1 8 double c 1x1 8 double v 1x10 80 double v2 1x5 40 double
x1=1:2:13
x1 =
1 3 5 7 9 11 13
Ez a felsorolás tulajdonképpen egy vektor. A Matlab negyon szereti a vektorokat. A vektor elemeire zárójellel hivatkozhatunk, pl x(1) az első elem
x1(1) x1(3)
ans =
1
ans =
5
Ha olyan elemet kérdezünk ami még nincs, akkor hibát kapunk
x1(10)
Index exceeds the number of array elements (7).
Ha olyan elemét definiáljuk a vektorrnak ami "túlnyúl" a vektor elemein akkor a nem definiélt elemk 0-ék lesznek.
x1(10)=7
x1 =
1 3 5 7 9 11 13 0 0 7
A ' jellel lehet a vektort transzponálni
x2=x1'
x2 =
1
3
5
7
9
11
13
0
0
7
Ha elütünk valamit a program próbál segítni
y=Linspace(1,3,7)
Cannot find an exact (case-sensitive) match for 'Linspace' The closest match is: linspace in /home/local/MATLAB/R2019a/toolbox/matlab/elmat/linspace.m
A linspace(a,b,c) arra használatos, hogy készítsen egy vektort aminek elemei 'a' és 'b' között vannak egyenletes felosztással és 'c' dimenziós (vagyis 'c' elemből áll)
y=linspace(1,3,7)
y =
1.0000 1.3333 1.6667 2.0000 2.3333 2.6667 3.0000
Vektort úgy adunk meg hogy elemeit, szögeltes zárójelben, egymás után írjuk és köztük SPACET hagyunk, vagy vesszőt írnuk.
x2=[1 3 1]
x2 =
1 3 1
Az x2-t transzponálhatjuk és elrkhatjuk az x2-be. Így mér oszlopvektor
x2=x2'
x2 =
1
3
1
Ugyanígy oszlopvektort kapunk ha az elemek közé ;-t írunk
x2=[1; 3; 1]
x2 =
1
3
1
Mátrixot úgy kapunk hogy sovektorokat oszlopvektorba írunk
x2=[1 3; 3 4; 1 5]
x2 =
1 3
3 4
1 5
Beépített függvények
A lenght() függvény a vektor hosszát adja meg.
length(x1)
ans =
10
Tényleg, hiszen x1 értéke
x1
x1 =
1 3 5 7 9 11 13 0 0 7
volt. Ezzel a függvénnyel pl. lecsippenthetjük 'x1' vektor végét.
x1=x1(1:length(x1)-1)
x1 =
1 3 5 7 9 11 13 0 0
Itt a jobboldalon hivatkozok az 'x'-re az első elemétől az utolső előtti eleméig. Vagy ha az elejéből és a végéből is le akarok csippenteni akkor
x1=x1(2:length(x1)-1)
x1 =
3 5 7 9 11 13 0
Az 'x1' mérete nem egyenlő a hosszával
size(x1)
ans =
1 7
A vektornak nincs nullasik eleme 1-el kezdődik. x1(0)
A Mátrixok mérete Sor X Oszlop. Az 'x1' vektor is egy olyan mátrixnak van kezelve aminek egy sora van.
size(x2)
ans =
3 2
Tényleg:
x2
x2 =
1 3
3 4
1 5
Ha vektorokkal végzünk műveleteket például megszorozzuk őket konstanssal akkor az vektor műveletnek veszi (minden elemét megszorozza).
x1*5
ans =
15 25 35 45 55 65 0
Ha szorozni szeretnénk vektorokat egymással akkor azt mátrix műveletnek veszi
x1*x1
Error using * Incorrect dimensions for matrix multiplication. Check that the number of columns in the first matrix matches the number of rows in the second matrix. To perform elementwise multiplication, use '.*'.
x1*x1'
ans = 454
Így már kompatibilisek a dimenziók. A '.' azt jelenti hogy az utána jövő műveletet elemenkánt hatjuk végre.
x1.*x1
ans =
9 25 49 81 121 169 0
Így 'x1' minden elemét négyzetre emeltük
Fordítva szorozva a transzponálttal diádot kapun
x1'*x1
ans =
9 15 21 27 33 39 0
15 25 35 45 55 65 0
21 35 49 63 77 91 0
27 45 63 81 99 117 0
33 55 77 99 121 143 0
39 65 91 117 143 169 0
0 0 0 0 0 0 0
x1+x1
ans =
6 10 14 18 22 26 0
Ha egy művelet elemenként van értelmeze akkor nem llehet '.'-al használni
%x1.+x1
Logikai műveleteket is végrehajthatunk
0 & 1
ans = logical 0
2 & 1
ans = logical 1
A min() függvény megadja a vektor legkisebb elemét
min(x1)
ans =
0
Tényleg.
x1
x1 =
3 5 7 9 11 13 0
De ha úgy hívjuk meg hogy
[minertek, minhely]=min(x1)
minertek =
0
minhely =
7
Akkor nem csak a legkisebb értéket, hanem a vektor legkisebb elemének idexét is visszadja. Az ilyen függvényeket polimorfnak nevezzük.
A kimenetet elnyomhatjuk a dor végén egy ;-vel.
[minertek, minhely]=min(x1);
[minertek, minhely]=min(v2); minhely
minhely =
1
De az értékadás megtörtént.
Saját függvények
Készíthetünk saját függvényeket is. Pédául készíthetünk egy utolsoElem függvényt ami a vektor utolsó elemét adja meg. Egy újszkriptfájba elkészítjük a függvényt
type('utolsoElem.m')
function kimenet=utolsoElem(be)
kimenet=be(length(be));
end
Ezt a szriptfájlt aztán 'függvénynév'.m néven -most utolsoElem.m néven- metsük el.
utolsoElem(v2)
ans =
9
Tényleg ez az utolsó eleme.
v2
v2 =
1 3 5 7 9
Definiálhatunk több kimenetű függvényeket is.
type('OsszegSzorzat.m')
function [osszeg, szorzat]=OsszegSzorzat(be1,be2)
osszeg=be1+be2;
szorzat=be1.*be2;
end
[a1,a2]=OsszegSzorzat(v,v)
a1 =
2 4 6 8 10 12 14 16 18 20
a2 =
1 4 9 16 25 36 49 64 81 100
Ha nem adunk meg két kimeneti változót akkor csak az elsőnek ad értéket,
OsszegSzorzat(v,v)
ans =
2 4 6 8 10 12 14 16 18 20
Házi feladatok
Adjunk függvényt ami egy bemeneti vektorhoz kiadja a minimumát maximumát és összegét
function kimenet=tulajd(v)
kimenet=[min(v),max(v),sum(v)];
end
Adjunk meg olyan függvényt melynek bemenete két darab pozitív valósakból álló sorvektor, melyek rendre egy derékszögû háromszög két befogójának hosszát tartalmazzák. A kimenet legyen egy olyan sorvektor, amely rendre az első befogók meletti szögeket adja meg. (Bónusz: adjuk meg a szögeket fokban, nem radiánban)
function kimenet=szogek(be1,be2)
kimenet=atand(be2./be1);
end
Adjunk meg egy olyan függvényt aminek bemenete két ugyanolyan hosszú logikai vektor, kimenete pedig egy olyan sorvektor ami rendre a logikai értékek 'és'-ét tratalmazza (tehát kimenet(1)=bemenet1(1)& bemenet2(1), stb.) Bónusz készítsünk a bemenetekből és a kimenetből egy mátrixot ami tulajdonképpen egy logikai tábla.
function kimenettabla=logikaitabla(be1,be2)
kimenettabla=[be1; be2; be1 & be2];
end