NB! Sidene er mer eller mindre de samme som sidene i første forelesning

Transkript

1 INF , Notater til 2. forelesning NB! Sidene er mer eller mindre de samme som sidene i første forelesning Kondisjonaler og predikater / tester / booleske uttrykk Betingelsesuttrykket cond Absoluttverdien til et tall x x, hvis x > 0 x = 0, hvis x = 0 x, hvis x < 0 (define (abs x) (cond ((> x 0) x) ((= x 0) 0) ((< x 0) (- x)))) Primitven (minus) med kun ett argument har tilsynelatende en annen semantikk enn den samme primitiven med flere argumenter, idet den første returnerer negasjonen av sitt argument. Men forskjellen forsvinner når vi setter inn identitetselementet som første argument. -1 (- 1) (- 0 1) Merk forskjellen mellom dette og (- 1 0), som evaluerer til 1. 65

2 Generelt (cond (<p 1 > <e 1 >) (<p 2 > <e 2 >)... (<p n > <e n >)) Det engelske ordet for parentesene etter cond er clauses. Vi kunne for eksempel kalle dem cond-ledd. Disse angir de enkeltvise betingelser og konsekventer, som til sammen angir hele cond-setningen. p står for predikat, mens e står for expression (uttrykk) Et predikat evaluerer alltid til én av de to booleske verdiene #t og #f. (Vi vil i denne teksten av og til skrive true og false som synonymer for disse.) 66

3 Vi bruker termen predikat først og fremst om - funksjoner som tar ett argument og returnerer true eller false avhengig av om argumentet har en bestemt egenskap, og - funksjoner som tar to argumenter og returnerer true eller false avhengig av om argumentene står i en bestemt relasjon til hverandre. (number? 25) #t (number? "hei") #f (string=? "hei" "hallo") #f (> 5 2) #t Også booleske variabler kan sies å være predikater (argumentløse predikater). (define sant #t) Siden sant ikke tar argumenter, returnerer den alltid samme verdi, når definisjonssetningen først er utført. 67

4 Ellers snakker vi like gjerne om tester og vi sier da at - en cond-clause består av en test fulgt av et annet uttrykk Evalueringen av et cond-uttrykk utføres slik at - hver enkelt test evalueres i tur og orden - inntil løpende test eventuelt evalueres til true, og - i så fall evalueres det etterfølgende uttrykket i den aktuelle clause og resultatet av dette blir også resulatet av hele cond-uttrykket. Hvis ingen av testene evaluerer til true, blir verdien til cond-uttrykket ubestemt. I Scheme returneres i slike tilfeller verdien #<void>. En typisk cond clause innholder en test og et etterfølgende uttrykk, men strengt tatt kan den inneholde testen alene, eller ett eller flere etterfølgende uttrykk. Uansett vil alle uttrykken i claus'en evalueres, og så vil resultatet av evalueringen av det siste uttrykket, som kan være testen, returneres. Dette kommer vi nærmere tilbake til. 68

5 Retur av en ubestemt verdi fra et cond-uttrykk gir ikke noe umiddelbart kjøreavbrudd, men en cond-setning som ikke er garantert å evaluere til en bestemt verdi, vil normalt representere en logisk brist i et program, som kan gi gale resultater eller kjøreavbrudd på et senere punkt. (define (dagnavn->dagnum dagnavn) (cond ((eq? dagnavn 'mandag) 1) ((eq? dagnavn 'tirsdag) 2) ((eq? dagnavn 'onsdag) 3) ((eq? dagnavn 'torsdag) 4) ((eq? dagnavn 'fredag) 5))) (define (hverdag? dagnavn) (< (dagnavn->dagnum dagnavn) 6)) > (hverdag? 'lørdag) <: expected argument of type <real number>; given #<void> Prosedyren hverdag? bruker prosedyren < for å sammenligne to tall. Siden ingen av cond-claus'ene i dagnavn->dagnum sjekker for 'lørdag, er returverdien derfra ubestemt, mens < krever to tallargumenter. 69

6 I alle andre tilfeller I cond-setningen over for beregning av absoluttverdien til x angis alle muligheter eksplisitt, men dermed er den siste testen overflødig i den forstand at dersom x hverken er større enn eller lik 0, så må x være mindre enn 0. For slike formål har vi nøkkelordet else (som kan oppfattes som et synonym for true). (define (abs x) (cond ((> x 0) x) ((= x 0) 0) (else (- x)))) 70

7 Ett av to Nå er det heller ingen grunn til å skille mellom de tilfellene at x er større en 0 og at x er lik 0, siden det er verdien til x som skal returneres uansett. Vi kan uttrykke dette slik: (define (abs x) (cond ((>= x 0) x) (else (- x)))) Dette er en binær test idet den skiller mellom to tilfeller som til sammen dekker alle mulige. Valguttrykket if Siden binære tester er svært vanlige, har vi en egen konstruksjon for disse. (define (abs x) (if (>= x 0) x (- x))) Generelt: (if <test> <konsekvent> <alternativ>) Egentlig er det if som er den tilgrunnliggende formen, og cond, så vel som and og or (se under), er avledninger av denne 71

8 Spesialformene and og or og prosedyren not Det regner og det er onsdag (and det-regner det-er-onsdag) Det regner eller det er onsdag (or det-regner det-er-onsdag) Det regner, men det er ikke onsdag (and det-regner (not det-er-onsdag)) Det hverken regner eller er onsdag (and (not det-regner) (not det-er-onsdag))) (not (or det-regner det-er-onsdag)) Enten regner det eller så er det onsdag (and (or det-regner det-er-onsdag) (not (and det-regner det-er-onsdag))) 72

9 x er et skuddår hvis x er delelig med 4 og x er ikke delelig med 100 eller x er delelig med 400. x er delelig med y hvis x / y er et heltall, hvilket vil si det samme som at x / y ikke gir noen rest. For rest-beregningen bruker vi Scheme-primitiven (remainder x y) ==> resten etter heltallsdelingen av x på y. Vi definerer delelighetspredikatet divisible? vha. remainder. (define (divisible? x y) (= 0 (remainder x y))) og vi kan så definerere skuddårspredikatet vha. divisible?. (define (skuddår? x) (and (divisible? x 4) (or (not (divisible? x 100)) (divisible? x 400)))) Alternativt: (define (skuddår? x) (or (divisible? x 400) (and (divisible? x 4) (not (divisible? x 100))))) 73

10 Vi kan uttrykke det samme vha. betingelsesformen cond. (define (skuddår? x) (cond ((divisible? x 400)) ; hvis testen slår til, returners #t implisitt ((divisible? x 100) #f) ; her må vi returnere #f eksplisitt. ((divisible? x 4)) ; hvis testen slår til, returners #t implisitt (else #f))) Merk testrekkefølgen. Bytter vi om f.eks først og andre clause, får vi ikke fanget opp delelighet med 400. NB! Dette er et helt annet poeng enn det at et imperativt program er sekvensielt, dvs. at rekkefølgen i utførelsen av programmets prosedyrer kan ha betydning for sluttresultatet. Et imperativt program er en sekvens av tilstander, gitt ved de foranderlige verdiene til programmets variabler, f.eks. slik at hvis prosedyren p endrer verdien til variabelen v og prosedyren q bruker v, så er resultatet av kallet på q bestemt av om p kalles før eller etter q. 74

11 Gitt prosedyrehodet (define (skuddår? x) så er følgene tre uttrykk er ekvivalente: (if (divisible? år 4) (if (divisible? år 100) (if (divisible? år 400) #t ; delelig både på 4, 100 og 400 #f) ; delelig på 4 og 100, men ikke på 400 #t) ; delelig på 4, men ikke på 100 #f) ; ikke delelig på 4 (cond ((divisible? x 400)) ((divisible? x 100) #f) ((divisible? x 4)) (else #f)) (or (divisible? x 400) (and (divisible? x 4) (not (divisible? x 100)))) 75

12 Månedslengder (define (månedslengde måned år) (cond ((= måned 1) 31) ((= måned 2) (if (skuddår år) 29 28)) ((= måned 3) 31) ((= måned 4) 30) ((= måned 5) 31) ((= måned 6) 30) ((= måned 7) 31) ((= måned 8) 31) ((= måned 9) 30) ((= måned 10) 31) ((= måned 11) 30) ((= måned 12) 31) (else (error "Ulovlig måned: " måned)))) 76

13 Vha. or kan vi omformulere denne slik Er vi sikre på at 1 måned 12, kan vi bruke 30 eller 31 som default verdi (det som gjelder i alle de tilfeller vi ikke har sjekket). (define (månedslengde måned år) (define (månedslengde måned år) (cond ((or (= måned 1) (cond ((or (= måned 4) (= måned 3) (= måned 6) (= måned 5) (= måned 9) (= måned 7) (= måned 11) (= måned 8) 30) (= måned 10) ((= måned 2) (= måned 12)) (if (skuddår år) 29 28)) 31) (else 31))) ((= måned 2) (if (skuddår år) 29 28)) ((or (= måned 4) (= måned 6) (= måned 9) (= måned 11)) 30) (else (error "Ulovlig måned: " måned)))) 77

14 For de som måtte være interessert På semestersiden for INF slå opp R5RS under Ressurser og case i indeksen til R5RS. ;; Trygg måned ;; Utrygg måned (define (månedslengde m y) (define (månedslengde m y) (case m (case m (( ) 31) (( ) 31) (( ) 30) (( ) 30) (else (if (skuddår? y) 29 28)))) ((2) (if (skuddår? y) 29 28)) (else (error "Ulovlig måned: " måned)))) Case forutsetter at alle de verdiene det testes for er distinkte. 78

15 Spesialformer I likhet med if og cond, er and og or spesialformer (mens not er en vanlig funksjon). Spesialformer skiller seg fra funksjoner bl.a. mht. evalueringen av argumenter. Alle argumenter til en prosedyre evalueres, fra venstre mot høyre, eller omvendt før kallet utføres. Argumentene til en spesialform evalueres etter tur, i den rekkeølgen de står, men hvert enkelt argument evalueres bare når det eventuelt blir nødvendig. Vi skiller mellom Dette tilsvarer skillet mellom ivrig (eager) og applikativ og lat (lazy) evaluering. normal evalueringsorden. 79

16 Den tilgrunnleggende kondisjonale spesialformen er if, og cond, and og or er avledninger av denne. Semantikken til and og or er utsagnslogisk, slik at - et and-uttrykk evaluerer til true hvis og bare hvis alle dets operandene evaluerer til true, og - et or-uttrykk evaluerer til true hvis og bare hvis minst én av dets operander evaluerer til true. Semantikke for booleske verdier er i alle språk binær, men hva som brukes for å representere dette, varierer. - I bl.a. Pascal, C++ og Java brukes false og true, - mens verdiene i C er 0 for usant og 1 for sant, - og som vi har sett, er verdiene i Scheme #f og #t. 80

17 I C er det i tillegg slik at når vi betrakter et tall som en boolesk verdi, så er alle andre tall enn 0 ensbetydende med 1. Gitt constanten TRUE = 1 og en heltallsvariabel b 0: if (TRUE) ; if (b) ; if (b!= 0) ; Scheme går enda lenger, ettersom alle andre verdier enn #f er enbsbetydende med #t. Gitt variabelen TRUE = #t og en variabel b #f: NB dette er ikke Scheme-uttrykk if TRUE ; if b ; (if (not (equal? b #f) ))); C Scheme (1 == 2) 0 (= 1 2) #f (2 == 2) 1 (= 2 2) #t if (x == 1) ; if (x) ; (if (= x #t) ) (if x ) 3? 4 : 5; 4 (if 3 4 5) 4 81

18 I Scheme returneres alltid verdien til det uttrykket som evalueres sist. (or 1 2 3) 1 ; det er nok at ett sant argument til or evalueres. (if 1 2 3) 2 ; testen gir true og konsekventene er det siste som evalueres (and 1 2 3) 3 ; alle sanne argumenter til and må evalueres. (cond (1 2 3) ; når testen i en cond-clause slår til, evalueres alle etterfølgene uttrykk i denne clause (se neste side) (4 5) (cond (1) (6 7)) 3 (2) (3)) 1 (cond ((string=? "ja" "nei")) ("vet ikke")) "vet ikke" De to siste cond-setningene viser at hvis siste test i et cond-uttrykk aldri kan evaluere til #f, så trenger vi ikke cond. 82

19 Sekvenser av uttrykk Vise typer uttrykk kan inneholde sekvenser. Dette gjelder prosedyrekropper og cond-clauses, og vi kan forme konsekventen og/eller alternativet i en if-setning til en sekvens vha. den syntaktiske formen begin (se eksemplet under). Vi har en melding m med adressat a og kanskje en c som skal ha en kopi, og hvis det er en c, må vi sende ett eksemplar av m til hver av a og c sammen med en beskjed om kopieringen (if (har-cc? m) (begin (send-til-adressat-med-beskjed-om-cc m a c) (send-til-cc-med-beskjed-om-adressat m a c)) (send-til adressat m a)) 83

20 Poenget med en sekvens er å få til en effekt om ikke nødvendigvis blinkende lys og ringende bjeller før vi returnerer den aktuelle verdien, eller å få til en sekvens av to eller flere effekter, som i eksemplet over. Dette bruker vi bl.a. til å skrive Scheme-programmer der innlesing og utskrift av data er essensielle formål. Vi kan også bruke det i debuggingsøyemed, når vi skriver ut en eller flere variabelerdier til skjermen samtidig som vi lar de funksjonelle beregningen gå sin gang, En effekt forårsaket av et funksjonelt program kalles gjerne en side-effect for å poengtere at det essensielle, i et funksjonelt program er den returnerte funksjonsverdien. 84

21 Statisk (manifest) versus dynamisk (latent) typing Fra R5RS:1.1: Scheme has latent as opposed to manifest types. Types are associated with values (also called objects) rather than with variables. (Some authors refer to languages with latent types as weakly typed or dynamically typed languages.) Other languages with latent types are APL, Snobol, and other dialects of Lisp. Languages with manifest types (sometimes referred to as strongly typed or statically typed languages) include Algol 60, Pascal, and C. C/C++/Java: String s = "hei"; forhåndsangivelse av type int i = s * 5; compile-time-feil Scheme: (define s "hei") ingen typeangivelse (* s 5) run-time-feil I prinsipper er det altså slik at gitt f.eks. (define v 5), så er verdien til v et heltall, mens v i og for seg ikke har noen type. I praksis tillater vi oss allikevel å si "v er en heltallsvariabel" eller ganske enkelt "v er et heltall ", i stedet for "v har en heltallsverdi". Men merk at siden Scheme har destruktive mekanismer vil typen til verdien til en variabel kunne endres, f.eks. slik (set! v "hallo"), og det er ikke fullt så uproblematisk å si at v nå en streng og ikke lenger et heltall. 85

22 Et regneeksempel: Å finne en kvadratrot Rent matematisk er kvadratroten av x, = x = den y som er slik at y 0 og y 2 = x, men for konkret å finne roten av x må vi ha en anvisning for hvordan vi kan regne oss frem til svaret en algoritme. Her følger en slik anvisning. 1. Gjett på et tall y. 2. Sjekk forskjellen mellom x og y 2, og hvis den er liten nok 3. returner y, eller 4. forbedre gjettingen til gjennomsnittet av y og x/y, dvs. (y + x/y)/2, og gå tilbake til 2. La y k = (y k 1 + x/y k 1 )/2. Da virker ovenstående fordi uansett om y k er større eller mindre enn x så ligger y k+1 mellom x og y k ( x < (y k + x/y k )/2 < y 0 ), så, enten er y k > x for alle k >= 0, eller så er y 0 < x, og y k > x for alle k > 0, og uansett minsker avstanden mellom y k og x for økende k. 86

23 Litt mer detaljert La = y x. (Merk at for å unngå 0-divisjon eller negativ rot må y > 0, og dermed må > x.) (y + x/y) 2 + x Da får vi = x + se mellomregningen under. 2 2( x + ) Uansett om er positiv eller negativ, dvs. uansett om y er større eller mindre enn x, så vil (y + x/y)/2 være størren enn x. Videre, hvis y > x så vil x/y < y og dermed vil (y + x/y)/2 < (y + y)/2, som er det samme som y. Så hvis y 0 > x får vi x < y 1 < y 0, x < y 2 < y 1, osv. dvs. vi nærme oss x ovenfra. Og hvis y 0 < x så vil y 1 > x, og vi nærmere oss x ovenfra fra og med andre runde. ( x + + x/( x + )) x 2( x + ) 2 + x Mellomregning = + 2 2( x + ) 2( x + ) 87

24 Her sier vi det samme på en litt annen måte Vi forutsetter at x > 1, og dermed at x > 1. Vi skal holde på til (y + x/y)/2 er tilstrekkelig nær x, eller m.a.o. til (y + x/y)/2 x et gitt, tilstrekkelig lite, tall. a = absoluttverdien til a. Algoritmen virker fordi (y + z 2 /y)/2 z for alle y og z. For å se det, skriver vi om ulikheten som følger (y + z 2 /y)/2 z (y 2 + z 2 )/2y z y 2 + z 2 2yz y 2 2yz + z 2 0 (y z) 2 0. Fordi (y z) 2 er et kvadrat, er ulikheten alltid tilfredstilt. Dette betyr at uansett hvilken verdi vi gjetter på, dvs. hvilken y vi starter med, så vil vi ha (y + x/y)/2 x Hvis y > x så er y > x/y og dermed er y > (y + x/y)/2, og hvis vi indekserer y-ene, slik at y k+1 = (y k + x/y k )/2, ser vi at Så lenge y > x, så er y k+1 < y k. Dvs. y blir mindre for hver runde, og vi nærmer oss x ovenfra. 88

25 I Scheme kan vi uttrykke alt dette ved følgende prosedyrer: (define (kvadratrot x) (løpende-rotgjetting 1.0 x)) (define (løpende-rotgjetting y x) (if (godt-nok-gjettet? y x) y (løpende-rotgjetting (forbedre y x) x))) (define (godt-nok-gjettet? y x) (< (abs (- (kvadrat y) x)) 0.001)) (define (forbedre y x) (gjennomsnitt y (/ x y))) (define (kvadrat x) (* x x)) (define (gjennomsnitt a b) (/ (+ a b) 2)) 89

26 I programmering dreier alt seg dypest sett om løkker, om vi akkumulerer data, f.eks. ved å addere eller multiplisere tall, eller leser tekstlige data fra fil, om vi søker etter et gitt datum i en mengde data eller vi søker løsningen på et problem. Punktene 1-4 representerer en løkke. 1. gjett 2. test 3 hvis suksess, returner eller 4 forbedre gjetting og gå tilbake til 2. Vi starter med en initiell gjetting i punkt 1. start og fortsetter med gjentatte tester i punkt 2 og test forbedret gjetting i punkt 4 fortsett inntil testen gir oss basistilefellet ferdig hvorpå vi returnerer den relevante verdien i punkt 3. exit. 90

27 Vi har to termer for løkker: iterasjon (gange / gåing) generelt: løkker spesifikt: løkker med oppdatering av relevante (tilstands)variabler rekursjon (løp / løping) løkker ved prosedyrer som kaller seg selv med oppdaterte argumenter. Så å si alle språk har mekanismer for iterasjon i den spesifikke betydningen. Dette gjelder også Scheme, men måten å implementere løkker på i et funksjonelt språk, er ved rekursjon. I et språk som f.eks. java vil rekursjon alltid kreve mer plass og tid enn iterasjon, fordi prosedyrestakken fylles opp med én prosedyre for hvert rekursivt kall, og programmet må bruke tid på å nøste seg ut av rekursjonen. Som vi straks skal se, er dette ikke noe problem i Scheme, fordi Scheme gjenkjenner iterative prosesser som sådan, og returnerer umiddelbart etter siste rekursive kall. 91

28 Her ser vi hvordan de ulike argumentene endres for suksessive kall på gjetteprosedyren for x = 2. y y 2 x x/y (y + x/y)/ /1 ( )/2 = 1 = 2 = /1.5 ( )/2 = 0.25 = = / ( )/2 = = = =

29 Abstrahering Vi kan se på forholdet mellom de ulike prosedyrene som et abstraksjonshierarki. kvadratrot løpende-rotgjetting godt-nok-gjettet? forbedre kvadrat abs gjennomsnitt Poenget er at hvert nivå skal være fullstendig forståelig ut fra sine egne premisser. Hadde det ikke vært slik, ville vi heller ikke ha vært i stand til å programmere i f.eks. Scheme uten å kjenne til og forstå hvordan alle Scheme-primitivene var implementert. NB! Vi skal om et par uker se på abstraksjonsbarrierer i forbindelse med definisjon av sammensatte datatyper. Dette har aspekter som ikke kommer frem i ovenstående. 93

30 Blokkstrukturer og interne definisjoner 1. definisjoner 2. uttrykk 3. blokkstart 4. definisjoner 5. uttrykk 6. blokkstart 7. definisjoner 8. uttrykk 9. blokkslutt 10. uttrykk 11. blokkslutt 12. uttrykk Med programmeringsspråket Algol (fra begynnelsen av 1960-tallet) ble blokkstrukturer innført, bl.a. for å kunne operere med lokale definisjoner. Dette var hverken med i FORTRAN eller den opprinnelige Lisp (de to første høynivåspråkene), men er med i Scheme. 94

31 Dette kan vi utnytte i definisjonen av kvadratrot, når vi sier at - prosedyrehodet utgjør blokkstart og - prosedyrens sluttparentes utgjør blokkslutt. (define (kvadratrot x) (define (godt-nok-gjettet? y) (< (abs (- (kvadrat y) x)) 0.001)) (define (forbedre y) (gjennomsnitt y (/ x y))) (define (løpende-rotgjetting y) (if (godt-nok-gjettet? y) y (løpende-rotgjetting (forbedre y)))) (løpende-rotgjetting 1.0)) Parameteren x, som ikke endres under beregningene, er synlig innenfor hele blokken og trenger ikke å sendes som argument til de lokale prosedyrene. Merk ellers at de generelle nytterutinene kvadrat og gjennomsnitt ikke hører til prosedyren. Kanskje noe overraskende gir hverken C, C++ eller Java mulighet for lokale prosedyrer kun lokale variabler. 95

32 96

33 Prosedyrale prosesser Lineær rekursjon og iterasjon Vi ser på fakultetesfunksjonen n! = 1 2 (n-1) n Vi ser at funksjonen kan defineres reksursivt slik: n! = n(n-1)! Dette danner utgangspunktet for følgende Scheme-implementasjon: (define (fakultet n) (if (= n 1) 1 (* n (fakultet (- n 1))))) 97

34 For å se hvordan denne virker, bruker vi substitusjonsmodellen (fakultet 6) (* 6 (fakultet 5)) ; kan ikke mutiplisere før vi har evaluert (a) = (fakultet 5) (*6 (* 5 (fakultet 4))) ; kan ikke mutiplisere før vi har evaluert (b) = (fakultet 4) (* 6 (* 5 (* 4 (fakultet 3)))) ; kan ikke mutiplisere før vi har evaluert (c) = (fakultet 3) (* 6 (* 5 (* 4 (* 3 (fakultet 2))))) ; kan ikke mutiplisere før vi har evaluert (d) = (fakultet 2) (* 6 (* 5 (* 4 (* 3 (* 2 (fakultet 1)))))) ; kan ikke mutiplisere før vi har evaluert (e) = (fakultet 1) ; Vi har basistilfellet som evaluerer til 1 (* 6 (* 5 (* 4 (* 3 (* 2 1))))) ; Vi setter inn 1 i (e), som evaluerer til 2 (* 6 (* 5 (* 4 (* 3 2)))) ; Vi setter inn 2 i (d) som evaluerer til 6 (* 6 (* 5 (* 4 6))) ; Vi setter inn 6 i (c) som evaluerer til 24 (* 6 (* 5 24)) ; Vi setter inn 24 i (b) som evaluerer til 120 (* 6 120) ; Vi setter inn 120 i (a) som evaluerer til ; Vi returnerer

35 En alternativ løsning går ut på å - telle seg opp fra 1 til n eller ned fra n til 1 - samtidig som vi tar med oss et produkt - som suksessivt økes ved at det multipliseres ved telleren. (define (fakultet-iterativ n produkt) (if (= n 1) produkt (fakultet-iterativ (- n 1) (* produkt n)))) Her er en suksesjon av kall: (fakultet-iterativ 6 1) (fakultet-iterativ 5 6) ; 6 * 1 = 6 (fakultet-iterativ 4 30) ; 5 * 6 = 30 (fakultet-iterativ 3 120) ; 4 * 30 = 120 (fakultet-iterativ 2 360) ; 3 * 120 = 360 (fakultet-iterativ 1 720) ; 2 * 360 =

36 De to prosedyrene er begge rekursivt definert i den forstand at de kaller seg selv, men de gir opphav til to ulike prosesser hhv. en rekursiv og en iterativ prosess. - Den rekursive prosessen er kjennetegnet ved - funksjonsverdien selv går inn i det totale regnestykket, hvilket gir en kjede av utsatte operasjoner som vokser frem til siste rekursive kall, og deretter krymper, ettersom vi får returverdiene fra de enkelt kallene, innenfra og utover, og disse kan settes inn som operander i de enkelt operasjonene slik at disse kan utføres. - Den iterative prosesses er kjennetegnet ved at det er prosedyrens argumenter som går inn i regnestykket, og slik opptrere som variabler som suksessivt får sine verdier oppdatert. Dette er tema for første obligatoriske oppgave. 100

37 Halerekursjon La p være en rekursiv prosedyre, der kallet på p ligger ytterst i kroppen til p. Dette kalles halerekursjon (tail recursion), fordi når p returnerer, så er alt som skal gjøres gjort. La p kalles fra et sted q utenfor p. Alle beregningene i den løkken som dette genererer utføres ved oppdatering av argumentene til p, og dermed er ikke returverdien fra p relevant, før vi er tilbake ved q. Ved det innerste kallet på p, vil resultatet allerede foreligge i de oppdaterte argumenten, og vi kan hoppe direkte med dette reultatet til q. Alle Scheme-implementasjoner forutsettes å kunne oppdage når det foreligger halerekursjon, og sende returverdien direkte fra det innerste kallet til stedet for det ytterste kallet. 101

38 Tracing De fleste Scheme-omgivelser har mekanismer for tracing ettersporing av prosedyrekall. (I Racket må man først skrive (require racket/trace)). Her ser vi bare aktuelle argumentverdier og returverdier. (trace fakultet fakultet-iterativ) (fakultet 6) (fakultet-iterativ 6 1) (fakultet 5) (fakultet-iterativ 5 6) (fakultet 4) (fakultet-iterativ 4 30) (fakultet 3) (fakultet-iterativ 3 120) (fakultet 2) (fakultet-iterativ 2 360) (fakultet 1) (fakultet-iterativ 1 720) Ved tracing i DrSchemes suspenderes denne underliggende halerekursjonsmeknismen, og tracingen av fakultet-iterativ gir dermed inntrykk av en rekursiv prosess, 102

39 Allmenntilfellet og basistilfellet Testen i de to fakultetsprosedyrene skiller mellom det som gjelder generelt, for n > 1, allmenntilfellet, og det som gjelder spesielt, for n = 1, basistilfellet. Det siste er avgjørende for at prosessen skal terminere. Her er en alternativ iterativ versjon der vi teller opp, og der basistilfellet består i at vi har talt oss opp til og med n: (define (fakultet-iterativ i n produkt) (if (> i n) produkt (fakultet-iterativ (+ i 1) n (produkt * i)))) 103

40 Tre-rekursjon Fra Leonardo Pisano alias Fibonacci: Liber Abaci 1202: "En man gjerder inne et [ungt] kaninpar. Hvor mange kaninpar produseres fra dette i løpet av et år, når vi antar at hvert par får et nytt par i måneden, og et nytt par trenger en måned på å bli produktive?" mnd akkummulerte par (1) Vi har ett ungt par A 1 (2) Par A blir modent og parer seg 1 (3) Par A føder par B og parer seg igjen 2 (4) Par A føder par C og parer seg nok engang, og par B blir modent og parer seg. 3 (5) Par A og B føder par D og E og parer seg igjen, og par C blir modent og parer seg 5 (6) Parene A, B og C føder par F, G og H og parer seg igjen, og parene D og E blir modne og parer seg 8 Herfra blir det for mye styr (7) De 5 svangre parene fra runde (6) føder 5 nye og parer seg igjen, å holde rede på hvert par, mens de 3 nye parene fra runde (6) blir modne og parer seg 13 så vi nøyer oss med å telle dem (8) De 8 svangre parene fra runde (7) føder 8 nye par og parer seg igjen mens de 5 nye parene fra runde (7) blir modne og parer seg 21 (9) De 13 svangre parene fra runde (8) føder 13 nye par og parer seg igjen mens de 8 nye parene fra runde (8) blir modne og parer seg 34 (10) De 21 svangre parene fra runde (9) føder 21 nye par og parer seg igjen mens de 13 nye parene fra runde (9) blir modne og parer seg 55 (11) De 34 svangre parene fra runde (10) føder 34 nye par og parer seg igjen mens de 21 nyeene fra runde (10) par blir modne og parer seg 89 (12) De 55 svangre parene fra runde (11) føder 55 nye par

41 Basistilfellet er greit: I måned 1 er første par ennå ikke kjønssmodne, så det blir ingen besvangring i måned 1 og ingen fødsler i måned 2 og dermed er antall par i andre måned = antall par i første måned = 1. Allmenntilfellet, fra og med tredje måned, er mer komplisert enn for fakultetsberegningen, fordi vi må ta hensyn til både hvor mange som ble født og hvor mange som ble svangre i forrige måned, og det siste er avhengig av hvor mange som ble født i måneden før forrige. For k > 2 vil alle par i måned k 2, både tidligere fødte og nyfødte, være kjønnsmodne måneden etter, så antall besvangringer i måned k 1 = antall par i måned k 2, antall fødte i måned k = antall par i måned k 2, Dermed får vi at antall par i måned k = antall par i måned k 1 + antall besvangrede i måned k 1 = antall par i måned k 1 + antall par i måned k 2 Ut fra dette kan vi definere fibonaccifunksjonen slik i Scheme 105

42 (define (fibonacci n) (cond ((= n 1) 1) ((= n 2) 1) (else (+ (fibonacci (- n 1)) (fibonacci (- n 2)))))) Om vi lar funksjonen også være definert for 0, med funksjonsverdien 0, så får vi stadig fibonacci(2)= fibonacci(1)+ fibonacci(0)= = 1 Funksjonen blir da seende slik ut. (define (fibonacci n) (cond ((= n 0) 0) ((= n 1) 1) (else (+ (fibonacci (- n 1)) (fibonacci (- n 2)))))) Eller med andre ord (define (fibonacci n) (if (< n 2) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))))) 106

43 Et problem med denne algoritmen er alle de gjentatte beregningene. fib(5)==> 5 fib(4)==> 3 fib(3)==> 2 fib(3)==> 2 fib(2)==> 1 fib(2)==> 1 fib(1)==> 1 fib(2)==> 1 fib(1)==> 1 fib(1)==> 1 fib(0)==> 0 fib(1)==> 1 fib(0)==> 0 fib(1)==> 1 fib(0)==> 0 107

44 For å unngå dette benytter vi oss av at, siden fib k = fib k-1 + fib k-2 så er første tall i summen i én runde andre tall i summen i neste runde. (define (fibonacci n) (fib-iter n)) (define (fib-iter fib k-1 fib k-2 k n) (if (= k n) (+ fib k-1 fib k-2 ) (fib-iter (+ fib k-1 fib k-2 ) fib k-1 (+ k 1) n))) fib k = fib k-1 + fib k-2 fib k-1 fib k-2 k n Men for at denne algoritmen skal virke, må vi kalle prosedyren med k = 2, og vi kan dermed ikke bruke den for n <

45 For å tillempe algoritmen slik at den virket for alle n 2, kunne vi ha lagt inn spesielle tester i fibonacci for n < 2. Alternativt kan vi - la telleren ligge én runde foran summen, og - returnere fib k-1 når k = n. Eller, slik det gjøres i læreboka, - la telleren ligge to runder foran, men vi må da - telle ned fra n til 0 og - returnere fib k-2 når n = 0. (define (fib-iter fib k-1 fib k-2 n) (if (= n 0) fib k-2 (fib-iter (+ fib k-1 fib k-2 ) fib k-1 (- n 1)))) fib k-1 fib k-2 n (= antall runder igjen) Merk at siden n ikke inngår i noe regnestykke, så er det likegyldig om vi teller opp eller ned Uansett skal prosedyren kalles med fib k-1 = 1 og fib k-2 =

46 Kort om eksponenter potenser (powers) og logaritmer En potens er et produkt av n like faktorer, f.eks. kan skrives som 5 4. (1) a 0 = 1 (6) a n a m = a n+m (2) a 1 = a (7) a n /a m = a n m (3) a 2 = a a, a 3 = a a a, (8) (a n ) m = a n m (4) a p = 1/a p (9) x n = e n log x (5) a p/q = q (a p ) = ( q a) p (10) x = b l og b x Ad (10) Gitt en base (et grunntall) b, så er logaritmen til x, det tallet b må opphøyes i for å gi x. Det følger av (1), at log 1 = 0, for en hvilken som helst base. Tallet e er det tallet for hvilket (11) log e e = 1. log e x kalles den naturlige logaritmen til x og skrives vanligvis bare 'log x' eller 'ln x'. Algoritme for å finne log 2 x: Gå ut fra at log 2 x = 1 + log 2 x/2 for hele positive n, og at log 2 0 = 0. For alle baser > 0 bryter funksjonen sammen har funksjonene en singularitet for x = 0, dvs. det finnes ingen a og b slik at b a = er ubestemt. Vi kunne jo bli enige om at 0 0 skulle være 0, men det finne en rekke gode grunner til heller å la 0 0 være

47 Eksponensiering Algoritme for å regne ut b n : Gå i løkke inntil n = 0 og - gang b med seg selv og - reduser n med 1. Rekursivt Iterativt (define (expt b n) (if (= n 0) 1 (* b (expt b (- n 1))))) (define (expt-iter b produkt n) (if (= n 0) produkt (expt-iter b (* produkt b) (- n 1))) Begge prosessene har lineært tidsforbruk. Den rekursive har også lineært plassforbruk, mens den iterative har plassforbruk =

48 Hvordan kan vi effektivisere eksponensieringsalgoritmen? Det beste vi kan håpe på er en reduksjon fra linær til logaritmisk vekst. Og dette kan vi også få til vha. suksessive halveringer på tilsvarende måte som ved binært søk (mer om det siden). b^16 (b b b b b b b b b b b b b b b b) (b^8)^2 (b b b b b b b b ) 2 ((b^4)^2)^2 ((b b b b) 2 ) 2 (((b^2)^2)^2)^2 (((b b) 2 ) 2 ) 2 ((((b)^2)^2)^2)^2 (((b) 2 ) 2 ) 2 ) 2 112

49 Dette gårt greit når eksponenten er en potens av 2. (define (fast-expt-p2 b n) (if (= n 1) b (square (fast-expt-p2 b (/ n 2))))) Men vi ønsker å gjøre dette generelt, og vi tar da utganspunkt i følgende (a) b n = (b n/2 ) 2 for like n (b) b n = b b n-1 for odde n Rasjonaliseringsgevinsten ligger i (a) og vi bruker (b), om nødvendig, for å komme til (a) i neste runde. Dette gir følgende Scheme-prosedyre (define (fast-expt b n) (cond ((= n 0) 1) ((even? n) (square (fast-expt b (/ n 2)))) (else (* b (fast-expt b (- n 1)))))) 113

50 (Merk at basistilfellet i fast-expt-p2 er n = 1, mens det i alle de andre variantene, inklusive fast-expt, er n = 0. Grunnen er at n i fast-expt-p2 reduseres utelukkende ved divisjon med 2, mens den i alle de andre variantene reduseres ved subtraksjon i alle fall for odde n. I fast-expt-p2 vil n før eller siden bli 1, og hadde vi fortsatt med reduksjon etter dette, ville vi ha fått en brøk med 1 som teller og voksende potenser av 2 som nevner, og aldri nådd 0. I fast-expt derimot, vil vi, for en eventuelt n = 2, få n = 1 i neste runde, og deretter en reduksjon til n = 0, fordi 1 er odde.) 114

51 Permutasjoner og faktoriell vekst Her er et tre som viser alle permutasjoner av strengen "abcd": a b c d a b c d b a a a c d b b d c d c a a a b b b c c c d d d b c d a c d a b d a b c c b b d a a b a a b a a d d c c d c d d b c c b a a a a a a b b b b b b c c c c c c d d d d d d b b c c d d a a c c d d a a b b d d a a b b c c c d b d b c c d a d a c b d a d a b b c a c a b d c d b c b d c d a c a d b d a b a c b c a b a - For det første får vi fire permutasjoner med hver av de fire bosktavene i første posisjon. - For hver av disse får vi tre permutasjoner med hver av de tre etterfølgende bokstavene i andre posisjon. - Og for hver av disse igjen får vi to permutasjoner med hver av de to etterfølgende bokstavene i tredje posisjon. - Endelig får vi for hver av disse én permutasjon. Alt i alt får vi = 4! = 24 permutasjoner, og vi ser lett at med en 5-tegns streng, får vi 5 ganger så mange, dvs. 5! = 120, permutasjoner, og generelt får vi for n verdier n! permutasjoner. 115

52 Tids- og plassbehov Lærebokas uttrykk "order of growth" har ingen god overettelse i norsk. Vi kan kalle det vekstordenen til ressursbehovet for beregningen av en funksjon for økende input, eller størrelsesordenen til et ressursbehov (tids- eller plassbehov) for et gitt input, n. Hvis f og g er funksjoner, og k 1 og k 2 er konstanter, og ressursbehovet for beregningen av f(n) ligger mellom k 1 g(n) og k 2 g(n), sier vi for følgende verdier av g at veksten til f er av følgende typer. ln n logaritmisk n, lineær n P plynomisk (g P, dvs. g er et polynom) x n eksponentiell n! faktoriell Noen ganger fingraderer vi og skiller mellom f.eks. radikal vekst (g(n) = n), kvadratisk vekst (g(n) = n 2 ) og kubisk vekst (g(n) = n 3 ). 116

53 Her er noen eksempler: Søking kan gjøres linært, med lineært tidsforbruk, eller, hvis mengden er sortert, stegvis med radikalt tidforbruk eller binært med logaritmisk tidforbruk lineært søk s linær tid ( n) > stegvis søk s radikal tid > ( 2 n) < - - binært søk s logaritmisk tid s ( log 2 n) s - - s - - s s Ingen av disse gir noe plassforbruk (ut over 1, og den plass data allerede opptar). En rekke velkjente enkle arlogritmer for sortering har kvadratisk tidsforbruk, mens de raskteste, som Merge-sort, har et idéelt tidsforbruk på n log 2 n. Symbolet (stor theta) brukes for å angi veksten (the order of growth) i ressursbruken til en prosess. I lære boka innføres det en funksjon R(n) som gir ressursbehovet til en gitt prosess for input n. 117

54 Ressursene kan være antall regneoperasjoner, dvs. tid, eller antall bits, dvs. plass. Vi kunne like gjerne snakke om kompleksiteten C til en funksjon f C(f(n)). Gitt en funksjon g(n) og to konstanter k 1 og k 2, uavhengig av n, slik at k 1 g(n) C(f(n)) k 2 g(n), sier vi at C(f(n)) = (g(n)) eller, noe enklere, at kompleksiteten til f = (g), eller, aller enklest, at f (g). f kompleksitet linært søk (n) stegvis søk ( n) binært søk (log 2 n) vanlig sortering (n 2 ) merge-sort (nlog 2 n). 118

55 Forholdet mellom theta, big-o og little-o (fra Hardy and Wright 1979, pp. 7-8). Let n be an integer variable which tends to infinity and let x be a continuous variable tending to some limit. Also, let (n) or (x) be a positive function and f(n) or f(x) any function. Then the symbols O(x) (sometimes called "big-o") and o(x) (sometimes called "little-o") are known as the Landau symbols and defined as follows. 1. f = O( ) means that f < A for some constant A and all values of n and x, 2. f = o( ) means that f/ 0. A function is in big-theta of f if it is not much worse but also not much better than f. (f(n)) = O(f(n)) (f(n)). Big-omega notation is the inverse of the Landau symbol O, f(n) O(g(n)) g(n) (f(n)) f = størrelsen til f = antall kall på f eller det antall bits som skal til for å beskrive en løsning f.eks. et rekursjonstre eller utføre beregningen. 119

56 Angivelser av kompleksitet kan være tilsynelatende ganske grove. F.eks dekker (n 2 ) hele spekteret an 2 + bn + c mens polynomisk tid dekker det betydelig større spektret a 1 n m + a 2 n m a m-1 n 2 + a m n, men når n blir tilstrekkelig stor blir verdiene til leddene etter det første så små at vi ikke bryr oss om dem. Ellers er det slik at eksponentiell og fakultær vekst gjør problemløsningen praktisk umulig for n over en viss størrelse faktisk slik at noen problemer ville kreve mer enn universets levetid, eller at beskrivelsen av problemets løsning ville kreve flere atomer enn det finnes i hele universet. Et problemer med eksponensiell vekst går typisk ut på å finne alle mulige kombinasjoner av ett eller annet (eks: powerset). Et problemer med faktoriell vekst går ut på å finne alle permutasjoner av en liste (se over). Et tema innenfor programmeringsteori gjelder reduksjon av arbeidsmengde typisk fra eksponentiell til polynomisk tid, eller fra lineær til logaritmisk tid. Eksempel på det første: Vi skal finne rasketse vei gjennom et nettverk av gater fra A til B. Eksponentiell vekst får vi hvis vi rett og slett måler opp alle mulige veier for å kunne velge ut den korteste av disse. Vi kan imidlertid redusere dette til polynomisk vekst vha. snedige algoritmer som vi ikke skal ta opp her (men i oblig 2). 120