Samenvatting dictaat programmeren III (M. Oude Alink, P. Oost, M. Timmer )

Samenvatting dictaat programmeren III (M. Oude Alink, P. Oost, M. Timmer. 2008-2009) Hoofdstuk 1: Zoeken & Sorteren Er bestaan al heel veel standaardfuncties in Matlab voor zoeken en sorteren van lijsten: find  voor het zoeken van een waarde sort  rij sorteren (oplopend) issorted  kijken of een rij al gesorteerd is >> sort([3 1 8 5]) ans = 1 3 5 8 >> issorted([1 3 4 5]) ans = 1 >> issorted([1 3 5 4]) ans = 0

Je kan een rijtje ook van groot naar klein sorteren: >> A=[5 1 3 6 4]; >> B=sort(A) B= 1 3 4 5 6 >> C=B(length(B):-1:1) C= 6 5 4 3 1

Zoeken Kijken of, waar en hoe vaak een getal voorkomt in een lijst. - Ongesorteerde lijsten: alle elementen afgaan (lineair zoeken) tot je het element met de bepaalde waarde hebt gevonden. Als je alleen wil weten OF de waarde voorkomt: gebruik while lus en stop zodra je de waarde gevonden hebt. Als je wil weten HOEVAAK de waarde voorkomt: gebruik een for-lus en doorloop de hele lijst. - Gesorteerde lijsten: zoekt sneller (let op: een ongesorteerde lijst sorteren kost wel weer tijd!). Als je bijvoorbeeld het rijtje [1,3,3,4,4,4,5,6,6,7,7,8,9] hebt en je wil weten of er een 8 inzit, deel je eerst het rijtje in tweeën. Zit er links een 8 in? Zo nee, dan deel je de rechterhelft weer in tweeën. Zit daar links een 8 in? Zo ga je steeds verder. Duidelijkere uitleg in het dictaat  Sorteren Basisoperaties op een gesorteerde lijst - Element toevoegen: Als deze al in de lijst staat, zoek je het plaatsnummer op en plaats je het element 1 erachter. Als deze nog niet in de lijst staat, kijk je wel getal het dichtst in de buurt komt en plaatst hem er dan voor/achter (afhankelijk van of het gevonden getal groter of kleiner dan je element is). >> v v= 1 3 5 7 9 >> find(v==7) ans = 4 >> v=[v(1:3),7,v(4:length(v))]

Samenvatting programmeren III dictaat – TBK 2011-2012

v= 1

3

5

7

7

9

- Element verwijderen: heel eenvoudig. >> v=[1 3 5 7 9] v= 1 3 5 7 9 >> v(4)=[] v= 1 3 5 9

- Element wijzigen: kan eigenlijk niet, omdat dan de lijst niet meer gesorteerd is. Wel kan je de oude term verwijderen en de nieuwe term daarna invoegen. Sorteren van een bestaande lijst Zoeken kost tijd. Bij een ongesorteerd is dit gemiddeld n/2 stappen (we zeggen n stappen), bij binair 2logn=a*logn (we zeggen log n) stappen. Voor een grote n geldt logn

Bubble sort Eenvoudig maar moeilijk te begrijpen. We pakken steeds twee elementen en wisselen ze om als ze niet in de juiste volgorde staan. Zo ga je door tot het n-1 en n de element. Dan staat het grootste getal achteraan: hij ‘bubbelt’ naar achter. Dit herhaal je dus. Aantal stappen: (n-1)+(n-2)+(n-3)+…+3+2+1. Sommatie is dit

Quick Sort Behoorlijk ingewikkeld: verdeel-en-heersprincipe. Verdelen in simpele kleinere probleempjes (recursie). Pak een willekeurig element uit de lijst: het pivot-element. De ene groep bevat alle elementen kleiner dan pivot, andere groter. Beide groepen sorteer je vervolgens apart en plak je achter elkaar. Deze methode is vooral erg snel.

Andere sorteeralgoritmen Selection Sort: werkt net iets anders dan insertion sort. Waar we bij insertion sort telkens een getal pakten en dat op de goede plek in onze al gesorteerde deelrij zetten, pakken we bij selection sort telkens het minimum in het ongesorteerde deel van de lijst en zetten dat achteraan het gesorteerde deel van de lijst. Merge Sort: net iets anders dan quick sort. Hierbij deelt hij de rijtjes gewoon door tweeen; dit gaat door tot je rijtjes hebt van nog maar 1 element.


Hoofdstuk 2: Testen & Debuggen Bugs zijn fouten die slechts in bijzondere omstandigheden opvallen. Het is een fout in een programma waardoor hij niet doet wat hij moet doen. (denk aan milennuim-bug). Debuggen kost veel tijd maar is erg belangrijk! Testen Hierbij vergelijk je de output met wat je had verwacht. Als dit niet overeenkomt, kan een waarschuwing gegeven worden . Testen is moeilijker dan je denkt! Bugs Er zijn vele verschillende soorten bugs. Typfouten komen het vaakst voor. Dit geeft al vaak een rood kringeltje of je krijgt een simpele error. Veelal geven bugs geen foutmelding. Denk bijvoorbeeld aan *20 ipv *2. Je krijgt gewoon een logische output, maar niet het gewenste antwoord. Er zijn ook bugs die slechts af en toe optreden, dus wanneer bepaalde unieke situaties zich voordoen waar het script geen rekening mee heeft gehouden. Een eenvoudig voorbeeld function res = faculteit(x) if x==0 || xx==1 res=1; else res=x*faculteit(x-1); end

Het testen van een dergelijke functie zou zelfs een snelle computer jaren kosten. Daarom kijken we alleen naar de getallen -2,0,1,5,0.5,pi. Bij het testen van -2 geeft hij een error. Dit omdat als x<0 geldt x-1<0 en dus zal de recursie altijd worden uitgevoerd. Hiervoor voeren we de volgende foutmelding er bij in. function res = faculteit(x) if x==0 || x==1 res=1; elseif x<0 error('x mag niet kleiner dan 0 zijn'); else res=x*faculteit(x-1); end

Bij invullen van 0.5 krijgen we echter de foutmelding ‘x mag niet kleiner dan 0 zijn’! Dit omdat je dan nooit op x==0 of x==1 uitkomt. Uiteindelijk zal de gedebugde functie er zo uitzien: function res = faculteit(x) if x==0 || x==1 res=1; elseif round(x)~=x error('x moet een geheel getal zijn'); elseif x<0 error('x mag niet kleiner dan 0 zijn'); else res=x*faculteit(x-1); end

Breakpoints Als het opsporen moeilijker is, kan je een breakpoint invoegen. Deze breekt de functie tussendoor even af en geeft de waardes van alle variabelen. Samenvatting programmeren III dictaat – TBK 2011-2012

-

-

Normale breakpoints: Hierbij wordt altijd de executie van de code onderbroken  Klik in de editor naast een regelnummer: je krijgt een rood bolletje. Conditionele breakpoints: alleen stoppen als een conditie waar is. Dit is bij lussen bijvoorbeeld handig. (rechtermuisknop bolletje: ‘Set/modify condition’: bolletje wordt geel.). Een normale breakpoint is dus eigenlijk een conditionele breakpoint met conditie true. Error breakpoints: Bij een error is de functie bij een bepaalde regel gestopt. Die regel kan je opvragen door in het menu van de editor op ‘Debug  Stop if Errors/Warnings’ te klikken.

Met `Step' (F10) gaan we een regel verder in de huidige functie. Dit betekent dat als we een andere functie aanroepen in deze regel, die andere functie volledig wordt uitgevoerd. Met `Step In' (F11) gaan we een regel verder. Dit betekent dat als we een andere functie aanroepen in deze regel, we naar de eerste regel van die andere functie springen. Veel standaard Matlab-functies zijn op een speciale manier gemaakt, zoals bijvoorbeeld length, waardoor je daar niet in kunt springen, maar daar zal in het algemeen ook niet het probleem liggen. Met `Step Out' (Shift+F11) wordt de huidige functie helemaal afgemaakt, en zijn we weer terug in de functie die deze functie had aangeroepen. In het geval van een functie-aanroep is `Step In'`Step Out' dus gelijk aan `Step'. Met `Continue' (F5) wordt doorgegaan tot het volgende breakpoint. Dit kan hetzelfde of een ander breakpoint zijn.

Hoofdstuk 3: Bestanden We hebben tot nu toe grafieken geplot en hier eigen getallen aan toegevoegd. Het zal echter vaak voorkomen dat we getallen uit metingen halen. Deze metingen wil je niet 1x gebruiken maar ook opslaan en hergebruiken. Opslaan kan met de functie save, terughalen met load. Handig als je een applicatie heb die uren rekent voor een antwoord. Dan sla je die gegevens op. Ook kan je als je de gegevens opslaat er later nog aan werken. Bestandtypen .mat=speciale Matlab bestanden ‘plain-text’ variant (ook te lezen in Windows Kladblok). Opslaan We kunnen alle variabelen in de workspace opslaan in het bestand `test.mat' met save test.mat. Als de bestandsnaam spaties bevat moeten er apostrofs omheen: save ’t e s t.mat’. Als we er geen extensie achter zetten slaat Matlab het automatisch op met de extensie .mat, dus het voorgaande is gelijk aan save test. We kunnen er echter ook voor kiezen om enkel een bepaalde variabele op te slaan en niet de gehele workspace: >> x = [1 2 3; 4 5 6] >> y = [7 8 9]; >> save testbestand x % nu bewaren we alleen x >> clear all % alle variabelen zijn weg >> load testbestand % alleen x is weer terug

Indien we de variabelen in plain-text willen opslaan moeten we de optie -ASCII gebruiken: save -ASCII test.txt x. Een probleem met het opslaan in plain-text is dat alleen de waarden van de variabelen wordt bewaard en we dus niet meer kunnen zien welke waarden bij welke variabele hoort. Indien je meerdere variabelen wilt opslaan zal je dus _of per variabele een bestand moeten aanmaken, _of het op moeten slaan in Matlab-formaat. Tot slot kan je de workspace ook via het menu (File -> Save Workspace As...) of met de sneltoets Control + S opslaan of individuele variabelen door er met de rechter muisknop in het Workspace op te klikken en te kiezen voor Save As. Samenvatting programmeren III dictaat – TBK 2011-2012

Openen Save vervangen voor load. Openen kan ook via fileopen of Control+ O Openen en opslaan in functies Zie dictaat.

Hoofdstuk 4: Plaatjes Plaatjes in Matlab zijn grote matrices. Ieder getal staat voor een bepaalde kleurwaarde. Je kunt deze plaatjes dus ook bewerken (draaien, spiegelen etc) op dezelfde manier als dat we met matrices doen. Zwart-wit plaatjes Een grote matrix met getallen tussen de 0 (zwart) en wit (255). Openen:

>> I=imread('cameraman.tif'); (niet de ; vergeten, anders geeft hij de hele matrix!!) >> imshow(I) >> imshow(I') >> imwrite(I','cameraman_gedraaid.bmp') >> Ondersteboven=flipud(I); >> imshow(Ondersteboven) >> imwrite(Ondersteboven,'cameraman_ondersteboven.bmp')

Kleurenplaatjes Ook dit zijn weer grote matrices, dit maal met drie lagen; een roodwaarde, groenwaarde en blauwwaarde. >> I=imread('kaarsen.jpg'); >> imshow(I) >> Rood(:,:,[2,3])=zeros(size(Rood(:,:,[2,3]))); >> Groen(:,:,[1,3])=zeros(size(Groen(:,:,[1,3]))); >> Blauw(:,:,[1,2])=zeros(size(Blauw(:,:,[1,2]))); >> imshow(Rood) >> imshow(Groen) >> imshow(Blauw)

Hoofdstuk 5: Plotten van functies met twee variabelen Lijnen in een 3D ruimte >> t=0:0.001:6*pi; >> x=cos(t); >> y=sin(t); >> z=t/10; >> plot3(x,y,z)

Dit lijkt dus heel erg veel op plot(…), maar nu in 3d. Samenvatting programmeren III dictaat – TBK 2011-2012

Plotten van oppervlakten Hiervoor gebruiken we surf(), van surface(oppervlakte). X en Y kunnen verschillende stapgroottes hebben. Om toch een mooi plaatje te plotten, maak je gebruik van meshgrid. >> x=1:4; >> y=1:0.5:2; >> [X Y]=meshgrid(x,y) X= 1 2 3 4 1 2 3 4 1 2 3 4 Y= 1.0000 1.0000 1.0000 1.5000 1.5000 1.5000 2.0000 2.0000 2.0000 >> Z=X.^2+Y Z= 2.0000 5.0000 10.0000 2.5000 5.5000 10.5000 3.0000 6.0000 11.0000 >> surf(X,Y,Z)

1.0000 1.5000 2.0000 17.0000 17.5000 18.0000

Matlab heeft ‘peaks’ die je kan gebruiken om snel plot-functies te demonstreren: >> surfl(peaks)

Hoofdstuk 6: Symbolische expressies Tot nu toe hebben we variabelen als getallen beschouwd, nu gaan we werken met symbolen. Expressies en variabelen Voor symbolenfuncties plotten heb je ezplot (easy plot), ezsurf etc. nodig en niet de gewone plotfuncties. >> ezplot('2*sin(x)',[0 2*pi]); >> ezsurf('sin(x)+cos(y)',[0 2*pi],[0 4*pi])

Je kunt bovenstaande regel ook schrijven zonder de functie in ‘ ‘ te zetten (string vorm). Dit doe je door de functie syms te gebruiken. >> syms x y


>> ezsurf(sin(x)+cos(y),[0 2*pi], [0 4*pi])

Substitutie Variabelen substitueren door getallen of een symbolische expressive met subs. >> syms x y a b >> y=x^2+a*b y= x^2 + a*b >> y=subs(y,a,3) y= x^2 + 3*b >> y=subs(y,b,cos(x)) y= 3*cos(x) + x^2

Differentiëren Met diff(y,a) met y de functie en a het aantal keer dat je wil differentiëren. >> syms x y >> y=cos(x) y= cos(x) >> diff(y) ans = -sin(x) >> diff(y,4) ans = cos(x)

Integraal *Onbepaalde (dus zonder grenzen) met int: >> syms x >> int(x.^2+1) ans = (x*(x^2 + 3))/3

* Bepaalde (dus met linker- en rechtergrens): >> syms x >> res=int(atan(x),0,pi/4) res = (pi*atan(pi/4))/4 - log(pi^2/16 + 1)/2 >> a=double(res) a= 0.2827

Als je een grens op (min) oneindig wil hebben, typ je uiteraard inf. *Partieel: geef duidelijk aan welke variabele je wil differentiëren. >> syms x y z >> z=x+y+1; >> int(z,x) ans = (x + y + 1)^2/2 >> int(z,y) ans = (x + y + 1)^2/2

Expressies manipuleren Haakjes weghalen met expand: >> syms a b >> c=expand((a+b)^3) c= a^3 + 3*a^2*b + 3*a*b^2 + b^3


Ontbinden in factoren met factor: >> factor(c) ans = (a + b)^3

Onder 1 noemer brengen met numden: >> syms c d >> [teller noemer]=numden(a/b+c/d) teller = a*d + b*c noemer = b*d

Vereenvoudigen met simplify: >> simplify((a^2+2*a+1)/(a+1)) ans = a+1 Vergelijkingen oplossen Dit doen we met solve. * Een variabele: (let op, ‘x’ is niet eens nodig!) >> solve('3*x-4=0','x') ans = 4/3

* Twee of meer variabelen:

>> format long >> res=solve('x^y=2','y^x=4','x','y') res = x: [1x1 sym] y: [1x1 sym] >> res.x ans = 1.2592623887511489957478398090772 >> res.y ans = 3.0068050814267298232924587320535

* Meerdere antwoorden met 1 variabele: antwoord is een array >> res=solve('x^4=1') res = 1 -1 i -i

* Meerdere antwoorden met meerdere variabelen: >> res=solve('x^2=y','y^2=1') res = x: [4x1 sym] y: [4x1 sym] >> res.x ans = 1 -1 i


-i >> res.y ans = 1 1 -1 -1

Hoofdstuk 7: Cell-arrays en structures Cell-arrays Met cell-arrays kunnen we gehele arrays, matrices en teksten als één variabele te groeperen. Een cell-array is haast hetzelfde als normale arrays en matrices, alleen gebruik je { } en ( ) in plaats van [ ].

>> x=cell(2,3) x= [] [] [] [] [] [] >> x{2,2}=1:5 x= [] [] [] [] [1x5 double] [] >> x{1,3}=2 x= [] [] [2] [] [1x5 double] []

Wijzigen en opvragen van cell arrays lijkt heel erg op dat van matrices: >> y={5, 3:2:15; rand(8), 'onzin'} y= [ 5] [1x7 double] [8x8 double] 'onzin' >> y{2,1}=[1,2;3,4]; >> y{2,1}(2,2)=7; %wijzig de matrix in element y(2,1) >> y{2,1} ans = 1 2 3 7 >> y(1,1:2) ans =


[5] [1x7 double]

Structures Cellarrays kan je ook duidelijker structureren door fiels een naam te geven: >> s1.naam='Klaas'; >> s1.studie='TBK'; >> s1.eten='pizza'; >> s1 s1 = naam: 'Klaas' studie: 'TBK' eten: 'pizza'

Dit kan ook via struct:

>> s1=struct('naam','Klaar','studie','TBK','eten','pizza') s1 = naam: 'Klaar' studie: 'TBK' eten: 'pizza'

Meerdere studenten toevoegen Hier zijn twee manieren voor: >> studenten(1) = struct('naam','piet','cijferWP1',6.7,'cijferWP2',7.8); studenten(2) = struct('naam','mies','cijferWP1',7.4,'cijferWP2',7.5); OF studentenA = struct('naam',{'piet', 'mies'},'cijferWP1',{6.8, 7.4},'cijferWP2',{7.8, 7.5}); Opvragen van de cijfers van Mies: >> studentenA(2) ans = naam: 'mies' cijferWP1: 7.400000000000000 cijferWP2: 7.500000000000000 Omzetten Je kunt matrices in een cell-array zetten en andersom:

Ook structuren zijn in cell-arrays te zetten. Dit met struct2cell en cell2struct. >> s s= naam: 'piet' cijferWP1: 6.700000000000000 cijferWP2: 7.800000000000000 >> C=struct2cell(s) C= 'piet' [6.700000000000000] Samenvatting programmeren III dictaat – TBK 2011-2012

[7.800000000000000] >> f=fieldnames(s) f= 'naam' 'cijferWP1' 'cijferWP2' >> s=cell2struct(C,f) s= naam: 'piet' cijferWP1: 6.700000000000000 cijferWP2: 7.800000000000000

Hoofdstuk 8: Spreadsheets Spreadsheets (excel) kunnen geopend worden in Matlab en andersom Lezen en schrijven Het schrijven van een willekeurige matrix naar excel, vervolgens lezen in Matlab. Daarna kan je het bestand ook in Excel openen! >> x=[2 4;1 1;0 7] x= 2 4 1 1 0 7 >> xlswrite('voorbeeld1',x); >> y=xlsread('voorbeeld1') y= 2 4 1 1 0 7 Naast de naam kan je ook aangeven op welke plek je je (cell)array/matrix wil hebben. >> stukjetekst={'kip','varken','koe','paard'}; xlswrite('dieren',stukjetekst,'B2:E2') >> xlswrite('diertjes',stukjetekst,'B2:E2') LET OP: GEEN ‘stukjetekst’, haakjes gewoon weglaten. Anders plaatst hij het woord zelfs (stukjetekst) in het excelbestand!!

Er staan nog wat voorbeeldjes in het dictaat voor als je geen Excel hebt, maar ik ga er vanuit dat iedereen dit heeft. Anders moet je zelf het dictaat er nog maar even op naslaan.


Samenvatting dictaat programmeren III (M. Oude Alink, P. Oost, M. Timmer )

Recommend Documents