Föreläsning M: Introduktion till MATLAB
(Föreläsningen är gjord för kursen TDDD87 som har ett litet MATLAB-moment instucket emellan
Ada-laborationer. Studenterna känner till, variabler, satser, typer, styrsatser, underprogram och fält,
i Ada. Föreläsningen gör sig förmodligen best om föreläsaren kör en MATLAB-prompt live för
studenterna.)
På den här föreläsningen skall jag introducera er för verktyget MATLAB. Det används inom många
ingenjörsmässiga situationer och ni kommer ha nytta av det i kommande kurser. Föreläsningen är
också förberedande för de MATLAB-uppgifter som skall genomföras i den här kursen.
Nu kan det kännas tungt att börja med något helt nytt, särskilt när vi just har kommit igång med
Ada. Lyckligtvis kan man trösta sig med att det finns två ljusa sidor med att ta upp ett nytt
programmeringsspråk. Det första är att det är väldigt nyttigt för att förstå programmering i
allmänhet. Det som är nytt kan föra med sig nya tankesätt och ger förmodligen nya insikter i hur
man kan lösa problem. Den andra fördelen är att mycket är likt det ni redan har lärt er. Detta är
egentligen inte en slump, utan alla programmeringsspråk fungerar på mer eller mindre samma sätt.
Huruvida MATLAB är ett programmeringsspråk kan man diskutera. Låt oss inte göra det. Låt mig
istället berätta att MATLAB är ett verktyg för att utföra matematiska beräkningar. MATLAB är
alltså i sig ett program. Det finns dock en kommandoprompt i MATLAB där man kan skriva in
kommandon. När man trycker enter så exekveras kommandot. Låter det bekant? Just det - det är
precis så som ett terminalen (kallas också för kommandoskal) fungerar. Vi säger att MATLAB
interpreterar dessa kommandon. Det finns även möjlighet att gruppera ihop kommandon så att de
blir små program. När man kör sådana program så kommer MATLAB helt enkelt gå igenom
kommandona ett och ett och exekvera dem, precis som om de hade skrivits in i kommandofönstret.
Hittills är vi vana vid ett kompilerande språk, men nu går vi alltså över till något som interpreteras.
Istället för en kompilator, har man en interpretator. Oavsett vilket man har fungerar ju detta som en
tolk. Tänk er att jag skall agera tolk mellan min mormor (som bara talar engelska) och min farmor
(som bara talar svenska). Om min mormor vill skriva ett långt brev till min farmor, då tar jag brevet
i handen, går hem på kammaren och översätter allt ihop och lämnar över resultatet till farmor nästa
dag - det är kompilering. Däremot om min mormor bara vill säga ett par meningar till farmor, så tar
jag nog dem en och en - precis som interpretering. Ni förstår säkert att dessa två angreppssätt har
lite olika fördelar och nackdelar. Vid kompilering kan man upptäcka lite mer "övergripande"
problem, och kanske till och med rätta till dem, innan man levererar slutresultatet. Vid interpretering
har man dock istället större möjlighet att testa sig fram när man skall göra något.
Rent praktiskt blir det inte jättestor skillnad dock. Ni kommer skriva er kod på ett ställe, i det vi
kallar för ett skript eller en funktion. Och ni kommer att kunna köra dem på ett annat. Detta är ju
mycket likt hur vi redan har arbetat i kursen.
Vi kan börja med att titta lite på hur MATLAB hanterar variabler. Först av allt skall det sägas att
man i MATLAB inte behöver deklarera sina variabler. Man kan helt enkelt hitta på ett variabelnamn
och tilldela variabeln med en gång. Zimsalabim - så finns den! Här har vi ett par exempel:
namn = 'Anna­Maria Karlsson';
alder = 32;
skostorlek = 38.5
simkunnig = true
turnummer = [19 55 2 196];
Vi ser här exempel på lite olika data, en sträng, ett heltal, ett flyttal, en boolean och en vektor (mer
om dessa senare). Kommandona ovan är alltså tilldelningar, inte lika-med-jämförelser. Vill man
kontrollera huruvida något är lika med något annat så får man skriva ==, men vi kommer tillbaka
till det om en stund.
Det är viktigt att veta att man i MATLAB skiljer på små och stora bokstäver. Skriver jag
"SKOSTORLEK", är detta alltså inte samma variabel som "skostorlek".
Vi har nu fem variabler. Om vi skrev in dessa kommandon i kommandofönstret så finns detta
variabler tillgängliga på MATLABs "globala nivå". Semi-kolonen på varje rad har inte riktigt den
funktion som man kanske hade gissat. I Ada betyder ju semi-kolon att satsen är slut, här är det
istället tvång på att varje sats måste stå på en egen rad. Själva semi-kolonet undertrycker den
automatiska utskrift som MATLAB alltid gör när ett kommando exekveras. När man tilldelar
variabler på detta sätt skulle MATLAB bara bekräfta detta genom att skriva ut variabelns värde om
man inte hade haft semi-kolonet på slutet. I sina program vill man därför ofta ha semi-kolon efter
alla satser, annars blir det hejdlöst många utskrifter! Jag återkommer till in- och utmatning om en
stund. Om man nu verkligen vill låta en sats gå över flera rader så kan man bryta den, genom att
skriva "...". Detta betyder att satsen fortsätter på nästa rad.
Nästa stora skillnad från tidigare är att MATLAB inte är hårt typat. Det finns datatyper i MATLAB
men variabler är inte begränsade till den typ de var från början. D.v.s jag kan nu utan problem göra
detta:
alder = 27.5;
Det gamla värdet i variabeln "alder" försvinner och den får 27.5 istället. Hokus pokus - så har jag
förvandlat en integer till en float. Vilket trolleri! Vi fortsätter och tittar på lite fler tilldelningar:
pi = 3.14
x = pi / 2
y = sin(x)
positive = abs(x * ­y)
i = 3 / 2
i = ceil(3 / 2)
i = floor(3.0 / 2.0)
i = mod(3, 2)
i = i + 1
i = '2'
i = '0' + '1' b = true
b = (i < 8) % En kommentar
% i blir 97
% b blir 1
% b blir 0
Här behövs det förmodligen lite förklaring. Vi börjar uppifrån. Första tilldelningen är inget konstigt,
vi skapar en ny variabel "pi" som vi sätter till 3.14. Det finns redan en variabel "pi" i MATLAB som
är bra mycket mer precis än våra ynka två decimaler. Nu har vi dock tyvärr skrivit över den!
Lyckligtvis kan man "glömma" variabler genom att använda kommandot "clear pi" eller "clear". Det
senare "glömmer bort" alla variabler som man har skapat. Gör vi detta så får vi tillbaka vårt
ursprungliga pi.
Tilldelning nummer 2 hade inte gått så bra i ett hårt typat språk, men är nu helt okej.
Tilldelning nummer 3 använder sig av den inbyggda funktionen sin (sinus-funktionen). Man
behöver inte importera några paket i MATLAB, allt finns från start.
Tilldelning nummer 4 använder sig av en annan inbyggd funktion abs (absolutbelopp).
Tilldelning nummer 5 hade gett resultatet 1 i Ada - det är ju heltalsdivision. MATLAB är inte så
kinkigt med detta och vi får helt enkelt 1.5.
Tilldelning nummer 6 och 7 är exempel på avrundningar. nedåt och uppåt.
I tilldelning nummer 8 använder vi operatorn mod. I MATLAB måste man dock anropa detta som
en funktion med två parametrar.
Tilldelning nummer 9 behöver ingen extra förklaring.
I tilldelning nummer 10 ser vi återigen ett exempel på hur en variabel hux flux kan byta typ. Här ser
vi också exempel på hur man skriver en kommentar i MATLAB.
Tilldelning nummer 11 ser mystisk ut. Man kan faktiskt addera två tecken i MATLAB. I grund och
botten representerar MATLAB allt data som flyttal om man inte explicit anger något annat. Alltså
går det fin fint att skicka två tecken till operatorn '+'. Som svar får man summan av tecknens asciivärde.
Vi kan även använda booleans i MATLAB, tilldelning 12 och 13 är exempel på detta. Värdena true
och false är dock bara konstanter som står för talen 1 och 0.
Vi går vidare och tittar nu lite på in- och utmatning. Det finns i princip två kommandon som är bra
att känna till när man skall skriva ut data. Den första heter disp och kan hantera i princip vilken typ
av data som helst.
x = 199;
disp(x); % Skriver ut 199 i
% kommandofönstret
Dessutom får man alltid en nyrad efter utskriften med disp. Disp är dock ganska primitiv, den klarar
bara av att skriva ut en sak i taget. Vill man utföra lite mer intrikata utskrifter kan man använda sig
av kommandot fprintf. fprintf tar alltid en sträng som första parameter. Strängen kommer att skrivas
ut utan nyrad. Man kan dock tvinga fram en ny rad genom att inför tecknen "\n" någonstans i
strängen. "\n" är en speciell markör som talar om att vi vill ha ett radslut där. Det finns andra
markörer som gör att man kan infoga t.ex. tal i strängen:
y = 2.5;
z = 'pelle';
fprintf('%d är primtal,%3.3f är flyttal,\njag heter %s.', x, y, z);
Vi får då utskriften:
199 är primtal, 2.500 är flyttal,
jag heter pelle.
Jag vill också påminna om det tredje sättet att skriva ut saker; att helt enkelt inte avsluta en sats med
ett semikolon, då skriver MATLAB automatiskt ut resultatet.
315
% Skriver ut:
% ans =
% 315
Vad det gäller inmatning finns det egentligen bara ett kommando som ni behöver, input.
N = input('Mata in ett tal: ');
Här måste man komma ihåg att det som matas in måste vara ett korrekt MATLAB-uttryck. T.ex.
måste strängar matas in med sina citationstecken.
För det mesta behövs inte in- och utmatningsrutinerna dock, eftersom MATLAB-funktioner kan
anropas direkt från kommandofönstret med sina parametrar, och det resultat som returneras
automatiskt skrivs ut om semi-kolon inte används.
Nu går vi vidare och tittar på fler satser. Vi börjar med if-satsen. Den ser ut på följande sätt:
if Villkor Satser
elseif
Satser
else
Satser
end; Precis som i Ada så kan "Satser" vara vilken sekvens av satser som helst. Det är också lätt att
glömma att det heter "elseif" i MATLAB, inte "elsif" som i Ada. I övrigt ser det nästan precis ut
som Ada, vi har tappat ett "then" och "if" efter "end", men man vänjer sig ganska snabbt vid detta.
Vi tar direkt ett exempel:
choice = input('Enter a number: ');
if choice == 42 || choice == 9
some_text = 'right';
else
some_text = 'wrong';
end
disp(some_text);
Här låter vi användaren mata in ett tal. Om talet är 42 eller 9 sätts variabeln some_text (som inte
fanns sedan tidigare!) till 'right' och annars till 'wrong'. "||" innebär alltså eller. Märk också att jag
behöver skriva två likmedstecken för att göra en matematisk jämförelse eftersom det enkla
likmedstecknet används för tilldelning, lätt att göra fel på... Efter if-satsen skrivs texten ut.
En intressant variant här är om vi byter "else" mot "elseif choice == 15". Om vi sedan tänker oss att
användaren matar in något helt annat, t.ex. 0, då kommer vi varken gå in i den första if-grenen eller
den andra. Detta innebär att variabeln some_text aldrig sätts till ett värde, och på så sätt inte finns
när vi kommer ner till disp. Då kraschar programmet! Detta känns lite märkligt. Men ännu
märkligare blir det om vi kör programmet igen och matar in 42 - då fungerar det som det skall igen.
Om vi sedan kör programmet en tredje gång och matar in 0, då kraschar inte programmet utan
texten "right" kommer ut! Det funkar den tredje gången eftersom variabeln some_text ligger kvar
sedan en tidigare körning. På detta sätt fungerar det alltid om man kör kod direkt i
kommandofönstret eller kör ett skript som man har skrivit. Lyckligtvis får man lokala variabler när
man skriver funktioner, tillbaka till det senare.
Vi kan kort titta på vilka operatorer som vi har tillgång till. Jag har redan nämnt "==" och "||" (lika
med, resp. eller). Här är relationsoperatorerna:
==
~=
<
>
<=
=>
Den enda som egentligen ser lite märklig ut är "skiljt ifrån", "~=". De logiska operatorer vi har är
||
eller
&&
och
~
inte
Dessa tre finns också som funktioner, or(villkor1, villkor2), and(villkor1, villkor2), not(villkor).
Följande aritmetiska operatorer finns att leka med:
+
*
/
^
.*
./
Vi kommer tillbaka till de sista två senare.
Vi går nu vidare på loopar. Vi börjar med for-satsen som ser ut på följande sätt:
for styrvariabel = intervall
Satser
end
Ett konkret exempel på detta:
for i = 1:4 fprintf('Styrvariabeln är %d\n', i);
end % loop
Då skrivs följande ut:
Styrvariabeln är 1
Styrvariabeln är 2
Styrvariabeln är 3
Styrvariabeln är 4
Ett intervall har alltid formen N:M, där N <= M, eller N:S:M, där S är ett steg. Alltså kan man få i
att hoppa fler tal åt gången, t.ex. genom att skriva i=1:2:10. Då får man talen 1, 3, 5, 7, 9. Man kan
även få intervallet, och på så sätt också loopen, att gå baklänges genom att ha ett negativt steg. Då
måste startvärdet vara större än eller lika med slutvärdet. T.ex. så här 5:-1:1 som ger 5, 4, 3, 2, 1.
Man kan också stega med decimaltal om man vill. I övrigt fungerar for-satsen precis som i Ada med
undantaget att styrvariabeln i även finns efter att loopen gått klart. Som ni ser så har jag själv lagt
till kommentaren % loop efter for-satsens "end". Personligen tycker jag att det blir ganska rörigt
med alla "end" i MATLAB-kod, därför markerar jag vad det är för något jag "endar". Samtidigt blir
koden ännu mer lika Ada, vilket jag tycker är positivt.
I MATLAB finns även while-satsen.
while Villkor
Satser
end
Den är helt analog med den while som finns i Ada. Det finns dock ingen "loop"-loop i detta språk.
Vill man ha en evig loop får man alltså göra en while med ett villkor som alltid är sant, t.ex. X==X,
eller 1==1, eller helt enkelt bara "true".
while true
disp('Jag älskar dig!');
end % loop
Det finns även ett till alternativ här. Man kan faktiskt skriva en for-sats och sätta intervallet från 1
till oändligheten. Man brukar dock få en varning när man sedan kör koden. En sådan for-sats kan
vara praktisk för eviga loopar där man även vill ha en varvräknare.
for i = 1:inf
fprintf('Jag älskar dig');
end % loop
Även här finns det en sats för att avbryta en loop inifrån (som Adans "exit"), men här heter den
break. Det finns också en sats som heter continue. När man kommer till en sådan sats inne i en loop
så går man direkt upp till början av loopen igen. Här kommer ett exempel:
A = 10;
while A > 0
disp(A);
A = A + 1;
if mod(A, 2) == 0
continue;
elsif A == 7
break;
end % if
A = A ­ 2;
end % loop
Hur många varv går denna loop? Rätt bökigt. Mitt tips är att undvika framförallt continue men
också break så mycket som möjligt. Alla satser som gör konstiga hopp i koden är av ondo, det är
kanske därför continue inte finns i Ada...
Nu går vi över till underprogram. I MATLAB finns det bara funktioner. Man kan dock anropa en
funktion utan att ta hand om returvärdet, d.v.s. så som man hade skrivit en procedur i Ada.
Y = sin(X);
sin(X+pi/2);
Båda dessa är tillåtna i MATLAB, de är båda anrop till funktionen sin. Vi kommer dock inte få se
resultatet av det undre anropet, p.g.a. semikolonet. Funktioner placeras i separata filer, precis som
skript. Det som skiljer en funktion från ett skript rent syntaktiskt är att funktionen har ett
funktionshuvud längst upp i filen. Här är två exempel:
function funktionsnamn Satser
end
function ret = namn(para1, para2) Satser
end
Parametrarna skrivs som vanligt i en parentes efter funktionens namn. Eftersom datatyper inte är
något som MATLAB egentligen befattar sig med så skriver man inte ut något i den stilen. "in" eller
"out" behöver man inte heller fundera på, alla parametrar är "in". Jag repeterar detta sista: det finns
inga out-parametrar i MATLAB. Allt som kommer tillbaka från en funktion måste returneras. I
MATLAB returnerar man dock inte explicit med satsen return utan använder en returvariabel.
Namnet på returvariabeln skrivs i fuktionshuvudet innan namnet på funktionen och ett
likmedstecken. I MATLAB fungerar det som så att man sätter returvariabeln till det värde som man
vill returnera, när man sedan kommer ner till "end" i funktionen så returneras värdet automatiskt.
Man kan faktiskt använda satsen return, men utan värde. Den hoppar direkt ned till slutet av
funktionen bara.
Både returvariabel och parametrar är frivilligt. Man kan alltså ha en funktion som bara har
parametrar:
function min_funktion(para1, para2) Satser
end
Eller bara returvariabel:
function returvariabel = min_funktion Satser
end
Namnet på filen som funktionen ligger i skall vara samma som namnet på funktionen plus ".m". Det
senaste exemplet skulle alltså ligga på filen min_funktion.m.
Anrop till funktioner ser precis ut som i Ada. D.v.s. man skriver helt enkelt namnet på funktionen
och har eventuella aktuella parametrar inom parentes efteråt. Värdet som returneras från funktionen
kommer att byta plats med anropet, precis som vi är vana vid. Vi tar ett till exempel:
function summa = plus(tal1, tal2)
summa = tal1 + tal2;
end % plus
Denna funktion, som ligger på filen plus.m, kan alltså anropas från kommandofönstret, från ett
skript eller från en annan funktion på något av följande sätt:
Z = plus(15, 3); plus(Z, 2)
plus(1, plus(2, 3))
% Z blir 18
% 20 skrivs ut
% 6 skrivs ut
Eftersom det inte finns out-parametrar i MATLAB kan det vara besvärligt när man vill få tillbaka
flera värden från en funktion. Det finns dock möjlighet att returnera flera värden i MATLAB om
man använder klamrar, både i funktionshuvudet och anropet. Här är ett exempel på detta:
function [a b] = swap(a, b)
c = a;
a = b;
b = c;
end % swap
Exempel på anrop till swap:
Tal1 = 3;
Tal2 = 7;
[Tal1, Tal2] = swap(Tal1, Tal2);
disp(Tal1); % 7 Skrivs ut
disp(Tal2); % 3 Skrivs ut
Skulle man anropa en sådan funktion utan klamrarna så får man endast ut det första returvärdet.
Som nämnt tidigare är de variabler som skapas inuti en funktion lokala variabler. D.v.s. de kommer
endast att existera medan funktionen körs, de ligger inte kvar tills senare. Inuti funktionen kan man
heller inte komma åt de variabler som ligger på MATLABs "globala" nivå. Detta är bra då undviker
man att konstiga beroenden byggs upp mellan funktionen och den miljö i vilken funktionen
exekveras. Om vi nu jämför med skript så är dessa precis tvärt om. De har alltid tillgång till de
globala variablerna och kan inte heller ta parametrar eller returnera resultat. Vill man göra ett
ordentligt program är det därför oftast bättre att skapa sig en riktig funktion.
Man kan lägga flera funktioner på samma fil. Det är behändigt när man vill göra underprogram, till
sina underprogram. Det är bara att rada upp dessa underfunktioner under den första funktionen i
filen. Man måste då komma ihåg att dessa underfunktioner bara är åtkomliga inom filen.
Jag vill passa på att nämna att MATLAB har en bra hjälp-funktion. Skriver man help i
kommandofönstret så får man en rad topics att välja bland. Man kan också gå direkt för hjälpen för
ett specifikt kommando om man skriver namnet på kommandot efter help.
Nu går vi raskt vidare och kollar lite på vektorer. Vektorer i MATLAB är lika de fält/arrayer som vi
har jobbat med i Ada. Precis som i Ada kan man ha vektorer med olika innehåll. Man kan ha
vektorer av heltal, vektorer av tecken (strängar) o.s.v. En vektor kan ha mer än 1 dimension, i
sådana fall kallar vi det för en matris. Att skapa en vektor är inte svårt, man tilldelar helt enkelt en
variabel flera värden som man har inom klamrar:
v = [ 1 2 3 4 5 ];
v = [ 1, 2, 3, 4, 5 ];
Man kan ha komman mellan varje element, eller inte, resultatet blir detsamma. Värt att veta är att
MATLAB skiljer på rad och kolumnvektorer. Dessa två exempel blir båda radvektorer. Man kan
skapa en kolumnvektor genom att skilja elementen med ';'.
v = [ 1; 2; 3; 4; 5 ];
Eller genom att skriva elementen på egna rader:
v = [ 1
2
3
4
5];
De intervall som vi talade om i samband med for-satsen är egentligen också sätt att skapa vektorer
på.
v = 1:5; v = 1:2:10; v = 5:­1:1; % v blir [1 2 3 4 5]
% v blir [1 3 5 7 9]
% v blir [5 4 3 2 1]
Vi kan se dessa som "snabbsätt" att skapa vektorer som ökar eller minskar. Det finns två inbygda
kommandon för att skapa vektorer av bara nollor resp. ettor.
v = zeros(1,5); v = ones(5,1); % v blir [0 0 0 0 0]
% v blir [1
1
1
1
1]
Den första parametern anger alltså hur många rader man vill ha, och den andra hur många kolumner
man vill ha.
Man kan även skapa en tom vektor så här:
v = [];
Hakparenteserna innebär en sammanslagning av element. Vi kan ta ett par exempel till:
a = 1:5;
b = 6:9;
v = [a b] v = [v 10] % v blir [1 2 3 4 5 6 7 8 9]
% [1 2 3 4 5 6 7 8 9 10]
En flerdimensionell vektor (matris) följer samma principer.
m = [ 1 2 3; 4 5 6; 7 8 9];
m = [ 1:3; 4:6; 7:8];
m = [ 1 2 3
3 4 5
7 8 9 ];
ones(3) ones(3,3) % båda dessa ger matrisen
% [ 1 1 1
1 1 1
1 1 1 ]
Utöver detta finns det många andra spännande kommandon:
% Skapa enhetsmatris
m = eye(3) % m blir [ 1 0 0
0 1 0
0 0 1 ]
% Skapa diagonalmatris
m = diag([1 2 3])
% m blir [ 1 0 0
0 2 0
0 0 3 ]
% Rotation medurs
m2 = rot90(m) % Transponat
m3 = m2' % m2 blir [ 0 0 1
0 2 0
3 0 0 ]
% m3 blir [ 0 0 3
0 1 0
2 0 0 ]
Att få ut saker ur vektorer med indexering är också inget som skiljer sig särskilt från i Ada.
v = [2 4 6 8 10];
v(1) v(2:3)
v([1 5])
v([5 1])
v(5:­1:1)
v = [3 1 2];
v(v)
% ger 2
% ger [ 4 6 ]
% ger [ 2 10 ]
% ger [ 10 2 ]
% ger [ 10 8 6 4 2 ]
disp(v(6)) % Ger FEL! Det finns inget
% 6:e element!
v(6) = 12; % Helt OK.
% v blir [3 1 2 0 0 12]
% ger [ 2 3 1 ]
Motsvarande för matriser:
m(r, k) % Ger elementet på rad r och
% kolumn k i matrisen m.
m = [ 1 2 3; 4 5 6; 7 8 9];
m(2:3, 2:3) % Ger raderna 2 till 3, och
% kolumnerna 2 till 3, dvs:
% [ 5 6 % 8 9 ]
Man kan använda ordet "end" för att referera till matirsen (eller vektorns) sista kolumn eller rad.
m(end, end) % Elementet i det lägre
% högra hörnet i m (9).
m(1, 1:end)
% Ger Översta raden [1 2 3]
Om man indexerar med intervall så kan man utelämna siffror i intervallet. Då tolkas detta som
första resp. sista indexet.
m(2:, :2) % Ger raderna 2 till 3, och
% kolumnerna 1 till 2, d.v.s % [ 4 5 % 7 8 ]
m(:, 3) % Ger alla rader, och 3:e
% kolumnen:
% [ 3 % 6
% 9 ]
Med vektorer kan vi plocka ut exakt de rader och kolumner som vi vill ha ur matrisen.
m([1 3], 2) % Ger [ 2
% 8 ]
m([1 end], [1 end]) % Ger [ 1 3
% 7 9 ]
Fler skojjiga saker:
m = [ 1 2 3
4 5 6 ]
l = length(m); % ger största
% dimenisionen, d.v.s. 3
n = numel(m); % ger antal element, 6
s = size(v); % ger [ 2 3 ]
size(v, 1)
size(v, 2) % ger antalet rader, 2
% ger antalet kolumner, 3
Vi kan nu gå vidare och titta lite på hur man kan räkna med vektorer och matriser. Det är här som
MATLAB verkligen glänser.
v1 = [ 1 2 3];
v2 = v1 * 2; v2 = v1 * v1; v2 = v1 * v1'; v2 = v1 .* 2; v2 = v1 .* v1; v2 = v1' * v1; % v2 blir [ 2 4 6 ]
% Fel! (?)
% v2 blir 14
% v2 blir [ 2 4 6 ]
% v2 blir [ 1 4 9 ]
% v2 blir [ 1 2 3
2 4 6
3 6 9 ]
v2 = v1 ./ v1; % v2 blir [ 1 1 1 ]
v2 = v1 / 2; % blir [ 0.5 1.0 1.5 ]
sin(v) cos(v) sum(v1) prod(v1) % [ 0.8415 0.9093 0.1411 ]
% % Summan av talen i v1 (6)
% Produkten av v1 (6)
Operatorerna .* och ./ är alltså "elementvis" multiplicering/division. Då tar man element för element
och applicerar den skalära operationen. Kan vara pratkisk i vissa fall. Som ni ser klarar också
MATLABs inbyggda kommandon så som sin, cos m.fl. att ta matriser som indata.
Vi avslutar med att prata kort om ett av MATLABs verktyg för att visualisera data, nämligen plot.
Med kommandot plot kan man rita grafer och figurer. När man anropar kommandot plot kommer
det att öppnas ett nytt fönster där figuren hamnar. Nästa anrop till plot hamnar i samma fönster, och
den gamla figuren försvinner. Om man vill kan man ändra detta beteende så att figurerna
kombineras, det gör man genom att använda satsen "hold". Sätter man "hold" till "on" så kommer
nästa figur att ritas ovanpå den gamla. Med "hold off" kommer nästa utritning att återigen få den
föregående att försvinna. Vi tar två exempel:
plot(x, y);
plot([0 1 1 0 0], [0 0 1 1 0]);
Om parametrarna till plot är skalärer plottas det bara ut en punkt. Då vektorer skickas så dras det en
linjer mellan varje par av koordinater. Den andra satsen kommer att rita ut en kvadrat. Vill man
modifiera utseendet, t.ex. byta färg till rött, och få linjen sträckad, så kan man ange en
formateringssträng efter de två första parametrarna.
plot([0 1 1 0 0], [0 0 1 1 0], 'r­­x');
Med detta blir linjerna röda och streckade, punkterna markeras med kryss.
Man kan skicka fler parametrar till plot, för att göra mer avancerade figurer...
t = 0.0:0.01:2*pi;
u = 0:72:360;
plot(cos(t), sin(t), 'r', ...
cosd(u), sind(u), 'b');
Dessa tre satser kommer tillsammans att rita ut en röd cirkel med en blå regelbunden femhörning
inuti.
Vill man visualisera en matris kan man använda kommandot imagesc, detta är praktiskt i er
laborationsuppgift "Game of Life".
