Lektion 4 - Scheme (27/11)
Denna lektion ägnade vi åt att programmera
i det funktionella språket Scheme.
När vi programmerar scheme är det viktigt
att på första raden i programmet skriva:
#!/usr/bin/env /usr/local/bin/pmscheme
Denna rad säger till skalet (Bash) vem som
ska tolka filen. I detta fall vill vi att
Scheme ska tolka våran kod. Gör dina
scheme program i vanliga textfiler och gör
sedan textfilen körbar med chmod +x.
Ett enkelt Schemeprogram ser ut såhär:
#!/usr/bin/env /usr/local/bin/pmscheme
(display (+ 1 2))
Detta program skriver ut det som (+ 1 2)
returnerar, vilket är 3. Ett lite mer
avancerat exempel kan du se här:
#!/usr/bin/env /usr/local/bin/pmscheme
(define (cirkelArea radie)
(define pi 3.14)
(define (kvadrat x)
(* x x))
(* pi (kvadrat radie)))
(display "Arean på en cirkel med radien 4 är: ")
(display (cirkelArea 4))
I det här programmet definerar vi en
funktion som heter cirkelArea som tar ett
argument. Detta argument får namnet
radie. I funktionen defineras först en
intern variabel, pi. Denna variabel vill
funktionen ha för att lättare utföra sitt
uppdrag (att räkna ut arean på en
cirkel). Sedan defineras en intern
funktion som får namnet kvadrat. Denna
interna funktion tar ett argument och
returnerar argumentet * argumentet
(kvadraten). Funktionen avslutas sedan med
raden: (* pi (kvadrat radie)) I denna rad
används den interna variabeln pi, den
interna funktionen kvadrat och argumentet
radie.
Vi pratade också om rekursion under
lektionen. Rekursion är när en funktion
kallar på sig själv. Ett bra exempel som
vi nämnde på föreläsningen är när man
beräknar fakultet. Fakultet brukar
betecknas med "!" ex: 5! och är när man
tar och multiplicerar ett tal med alla de
talen som är mindre. 5! = 5*4*3*2*1
Fakultet kan man beskriva så här:
Ta talet som du vill beräkna fakulteten av
(i detta fall 5) och multiplicera det med
fakulteten av talet minus 1.
Fakulteten av 5 är: 5 * fakulteten av
4. Fakulteten av 4 är i sin tur: 4 *
fakulteten av 3. Fakulteten av 3 är 3 *
fakulteten av 2 och fakulteten av 2 är 2 *
fakulteten av 1. Nu vill vi sluta, så vi
bestämmer oss för att inte fortsätta när
vi kommit ned till 1.
Detta är precis så som rekursion fungerar,
för att den inte ska fortsätta hur länge
som helst måste vi ha ett avbrottsvillkor.
I Scheme kan man skriva en
fakultetsfunktion såhär:
(define (fakultet tal)
(if (<= 1 tal)
1
(* tal (fakultet (- tal 1))))
)
)
Vi definerar en funktion med namnet
fakultet. Funktionen tar ett argument,
kallat tal. Om tal är mindre eller lika
med 1 returneras 1. Annars returneras:
talet * fakulteten av talet-1.
Kom ihåg, rekursion har en förmåga att
vända ut och in på hjärnor!
Presentationen vi hade kan ni se
här.
|
Emelie förbereder en
online-lektion med Skype!
|
|
Mmm, varm glögg!
|
|
Lite mingel innan lektionen.
|
|
Squeeee!
|
|
Varm
glögg är ett måste i dessa kalla
trakter.
|
|
Labben är igång
|
|
Sofia och Mattias kodar
|
|
Hela klassen
|
|
Scheme är roligt, men knepigt!
|
|
Arvid hjälper till
|
|
Fokus i klassen
|
|
