Programmeringsmetodik DV1 Programkonstruktion 1. Moment 4 Om rekursion. PK1&PM1 HT-06 moment 4 Sida 1 Uppdaterad

Transkript

1 Programmeringsmetodik DV1 Programkonstruktion 1 Moment 4 Om rekursion PK1&PM1 HT-06 moment 4 Sida 1 Uppdaterad

2 Summera godtyckligt antal tal (* sumupto n Type: int->int Pre: n >= 0, n <= 7 Post: Summan av talen från 0 till n Ex.: sumupto 4 = 10 sumupto 0 = 0 *) fun sumupto 0 = 0 sumupto 1 = 0+1 sumupto 2 = sumupto 3 = sumupto 4 = sumupto 5 = sumupto 6 = sumupto 7 = n>7, då?? Detta är uppenbarligen ingen framkomlig väg... PK1&PM1 HT-06 moment 4 Sida 2 Uppdaterad

3 Analys av summeringsproblemet För att summera talen från 0 till n kan jag lösa det enklare problemet att summera från 0 till n-1 och sedan lägga till n! Om n=0 kan jag direkt säga att summan är 0. Exempel: summera talen från 0 till 4. Ett enklare problem är att summera från 0 till 3. Summan av det enklare problemet blir 6? Lägg till 4. Nu har vi 6+4=10 vilket är summan av talen från 0 till 4. Hur fick jag tag på summan av talen från 0 till 3? På samma sätt! Ett enklare problem är att summera från 0 till 2. Summan av det enklare problemet blir 3? Lägg till 3. Nu har vi 3+3=6 vilket är summan av talen från 0 till 3. Etcetera PK1&PM1 HT-06 moment 4 Sida 3 Uppdaterad

4 Fullständigt resonemang för summeringen Summera talen från 0 till 4. Ett enklare problem är att summera från 0 till 3. Ett enklare problem är att summera från 0 till 2. Ett enklare problem är att summera från 0 till 1. Ett enklare problem är att summera från 0 till 0. Summan är 0! Summan är 0+1 = 1. Summan är 1+2 = 3. Summan är 3+3 = 6. Summan är 6+4=10. Denna metod kallas rekursion. (Från latinets recurso att återvända.) PK1&PM1 HT-06 moment 4 Sida 4 Uppdaterad

5 Rekursion i ML (* sumupto n Type: int->int Pre: n >= 0 Post: Summan av talen från 0 till n Ex.: sumupto 4 = 10 sumupto 0 = 0 *) fun sumupto(0) = 0 Basfall Rekursivt anrop sumupto(n) = sumupto(n-1) + n sumupto 4 > sumupto(4-1)+4 > sumupto(3)+4 här beräknas summan av talen från 0 till 3 > 6+4 > 10 PK1&PM1 HT-06 moment 4 Sida 5 Uppdaterad

6 Den fullständiga beräkningen fun sumupto(0) = 0 Basfall sumupto(n) = sumupto(n-1) + n sumupto 4 > sumupto(4-1)+4 > sumupto(3)+4 > (sumupto(3-1)+3)+4 > (sumupto(2)+3)+4 > ((sumupto(2-1)+2)+3)+4 > ((sumupto(1)+2)+3)+4 > (((sumupto(1-1)+1)+2)+3)+4 > (((sumupto(0)+1)+2)+3)+4 > (((0+1)+2)+3)+4 > ((1+2)+3)+4 > (3+3)+4 > 6+4 > 10 Rekursivt anrop PK1&PM1 HT-06 moment 4 Sida 6 Uppdaterad

7 Hur skall man förstå detta? fun sumupto 0 = 0 sumupto n = sumupto(n-1) + n Rekursion är en variant av principen att dela upp problemet i enklare delar och sedan sätta ihop resultatet av delarna. En rekursiv funktion anropar sig själv, men problemet är ändå enklare eftersom argumenten är mindre (precis vad detta betyder återkommer vi till). När det rekursiva anropet är klart sätter man ihop resultatet (additionen i exemplet). Varje rekursivt anrop är som en rysk docka. PK1&PM1 HT-06 moment 4 Sida 7 Uppdaterad

8 Bindningar i rekursion fun sumupto 0 = 0 sumupto n = sumupto(n-1) + n sumupto 2 > sumupto(n-1)+n [n-->2] > sumupto(2-1)+n [n-->2] > sumupto 1 +n [n-->2] > (sumupto(n-1)+n [n-->1])+n [n-->2] > (sumupto(1-1)+n [n-->1])+n [n-->2] > (sumupto 0 +n [n-->1])+n [n-->2] > (0+n [n-->1])+n [n-->2] > (0+1 [n-->1])+n [n-->2] > (1 [n-->1])+n [n-->2] > 1+n [n-->2] > 1+2 [n-->2] > 3 [n-->2] > 3 PK1&PM1 HT-06 moment 4 Sida 8 Uppdaterad

9 Exempel: Euklides algoritm Största gemensamma delaren (gcd) till 126 och 168 Start. m n r Är n=0? Nej. Ja. Stopp. Låt r vara resten när m delas med n. Låt m vara n. Låt n vara r För att beräkna gcd för m och n, lös det enklare problemet att beräkna gcd för n och resten vid division av m med n! PK1&PM1 HT-06 moment 4 Sida 9 Uppdaterad

10 gcd i ML (* gcd(m,n) Type: int*int->int Pre: m,n>=0 Post: Största gemensamma delaren till m och n Ex.: gcd(126,168) = 42 *) fun gcd(m,0) = m gcd(m,n) = gcd(n, m mod n) gcd(126,168) > gcd(168,126 mod 168) > gcd(168,126) > gcd(126,168 mod 126) > gcd(126,42) > gcd(42,126 mod 42) > gcd(42,0) > 42 PK1&PM1 HT-06 moment 4 Sida 10 Uppdaterad

11 Terminering Hur vet man att rekursionen någonsin avslutas (terminerar)? Vad innebär det att den inte gör det? Inte självklart att rekursionen terminerar... felaktiga argument: sumupto ~1 > sumupto(~1-1) + ~1 > sumupto(~2) + ~1 > (sumupto(~2-1) + ~2) + ~1 > (sumupto(~3) + ~2) + ~1 >... Förvillkoret måste utesluta sådana argument! eller en liten felskrivning: fun sumupto(0) = 0 sumupto(n) = sumupto(n+1) + n PK1&PM1 HT-06 moment 4 Sida 11 Uppdaterad

12 Rekursionsvarianter Varje rekursivt anrop måste lösa ett enklare fall än det föregående. Ett tillräckligt enkelt fall måste kunna lösas utan rekursion. Varje rekursivt anrop av sumupto(n) har ett mindre värde av n än det föregående. Fallet när n=0 (basfallet) hanteras utan rekursion. Samtidigt kan inte n bli mindre än 0. En rekursionsvariant är ett heltalsuttryck sådant att: Det blir mindre för varje rekursivt anrop. Det kan inte bli mindre än något bestämt värde (normalt 0). För detta bestämda värde (och ev. andra) löses problemet utan rekursion. Finns en rekursionsvariant är terminering garanterad. Rekursionsvarianten är en del av programdokumentationen! PK1&PM1 HT-06 moment 4 Sida 12 Uppdaterad

13 Konkret tolkning av varianten Eftersom varianten minskar med 1 (minst!) för varje rekursivt anrop och inte kan bli mindre än 0 (typiskt) så ger varianten en gräns för hur många rekursiva anrop som behövs. Är varianten 10 krävs maximalt 10 rekursiva anrop för att beräkna funktionen. Detta ger även ett tips om hur man kan hitta varianten. Det finns funktioner där man inte (eller inte med rimlig ansträngning) kan ge en gräns för antalet rekursiva anrop men som ändå säkert terminerar. Då får man använda andra tekniker, t.ex. välgrundade ordningar. Vi kommer endast i undantagsfall att stöta på sådana funktioner i denna kurs. PK1&PM1 HT-06 moment 4 Sida 13 Uppdaterad

14 Rekursion och matematisk induktion Det finns ett nära förhållande mellan rekursion och induktion. Exempel: Bevisa att en rekursionsvariant garanterar terminering! Låt T(n) betyda att ett anrop av funktionen med argument som har variantvärdet n terminerar. Fullständig induktion över n (naturligt tal, ok ty varianten är inte < 0) T(0) gäller direkt (basfallet). Vi vill visa att T(n) gäller. Vi vet (induktionsantagande) att T(n ) för alla n <n Alla rekursiva anrop som behövs för att beräkna funktionen har en variant n <n, alltså terminerar de eftersom vi vet att T(n ). Alltså kommer det givna anropet att terminera. PK1&PM1 HT-06 moment 4 Sida 14 Uppdaterad

15 gcd terminerar... Pre: m,n>=0... fun gcd(m,0) = m gcd(m,n) = gcd(n, m mod n) n är en rekursionsvariant för gcd. m mod n är alltid (definitionsmässigt) mindre än n. n kan inte vara mindre än 0 (eftersom förvillkoret anger att n från början inte är mindre än 0 och m mod n inte kan bli mindre än 0). fallet n=0 hanteras utan rekursion. PK1&PM1 HT-06 moment 4 Sida 15 Uppdaterad

16 Alt. 1 Varianter på defensiv programmering fun sumupto n = if n < 0 then raise Domain else sumupto'(n) fun sumupto'(0) = 0 sumupto'(n) = sumupto'(n-1) + n Alt. 2 fun sumupto(0) = 0 sumupto(n) = if n < 0 then raise Domain else sumupto(n-1) + n Alt. 3 fun sumupto(n) = Påverkas förvillkoret i detta fall? if n <= 0 then 0 else sumupto(n-1) + n PK1&PM1 HT-06 moment 4 Sida 16 Uppdaterad

17 Exempel: räkna uppåt till basfallet (* sumrange(i,n) Type: int*int->int Pre: n >= i-1 Post: Summan av talen från i till n. Ex.: sumrange(0,4) = 10 sumrange(2,4) = 9 sumrange(5,4) = 0 *) (* Variant: n-i+1 *) fun sumrange(i,n) = if i>n then 0 else sumrange(i+1,n)+i; (* sumupto n Type: int->int Pre: n >= 0 Post: Summan av talen från 0 till n Ex.: sumupto 4 = 10 sumupto 0 = 0 *) fun sumupto n = sumrange(0,n); PK1&PM1 HT-06 moment 4 Sida 17 Uppdaterad

18 Undvik onödiga begränsningar Varför förvillkor n>=i-1? Varför inte n>=i eller t.o.m. n>i? Varför någon alls? sumrange(i,n) summerar tal från i till n. Antalet tal är n-i+1. Vad händer om antalet är 1, 0 eller 1? Kan man tala om summan av ett tal, noll tal, 1 tal?!? Varför är basfallet i sumrange skrivet som det är? if i>n then 0 varför inte if i>=n then i eller t.o.m. if i>=n+1 then i+n Man bör försöka hitta en naturlig tolkning av summa som är så generell som möjligt utan att krångla till programmet. Då får man ett program som är flexibelt och kan användas i många situationer. PK1&PM1 HT-06 moment 4 Sida 18 Uppdaterad

19 Tolkning av konstiga summor Summerar man två delar av en talserie och adderar delsummorna får man summan av hela talserien = =21 1, 2, 3, 4, 5, 6 1, 2, 3, 4, 5, = = =21 1= = =21 Låt nu en delserie innehålla ett tal. Regeln gäller fortfarande om man antar att summan av ett tal är talet självt. Låt en delserie vara tom dvs innehålla noll tal. Regeln gäller fortfarande om man antar att summan av noll tal är 0. En talserie bestäms av sitt första och sista tal. En serie med noll tal får ett sista tal (n) som är ett mindre än det första talet (i). Därför bör sumrange kunna hantera alla fall där n>=i-1. PK1&PM1 HT-06 moment 4 Sida 19 Uppdaterad

20 Exempel: räkna tecken (* countchar(s,c) Type: string*char->int Pre: (ingen) Post: Antalet förekomster av c i s Ex.: countchar("hej, du glade",#"d")=2 countchar("hej, du glade",#"q")=0 *) (* Variant: size s *) fun countchar("",_) = 0 countchar(s,c) = countchar(string.substring(s,1,size s -1),c) + (if String.sub(s,0)=c then 1 else 0) PK1&PM1 HT-06 moment 4 Sida 20 Uppdaterad

21 En annan ansats till teckenräkning Vid rekursion över strängar är rekursionsargumentet en delsträng. Delsträngen behöver inte konstrueras uttryckligen istället kan den vara underförstådd (implicit) genom att använda en position i strängen som extra argument och göra rekursion över positionen. Strängargumentet s ersätts av två argument s och pos. s är den ursprungliga strängen, pos är positionen. När man använder s får man skriva String.sub(s,pos) istället för String.sub(s,0) Det rekursiva anropet har s och pos+1 istället för String.substring(s,1,size s-1) Denna teknik är viktig om det är komplicerat att konstruera uttrycket i det rekursiva anropet. PK1&PM1 HT-06 moment 4 Sida 21 Uppdaterad

22 Exempel: räkna tecken på annat sätt (* countchar2'(s,c,pos) Type: string*char*int->int Pre: 0<=pos<=size s Post: Antalet förekomster av c i s från och med position pos. Ex.: countchar2'("hej, du glade",#"d",3)=2 countchar2'("hej, du glade",#"d",13)=0 *) (* Variant: size s - pos *) fun countchar2'(s,c,pos) = if pos >= size s then 0 else countchar2'(s,c,pos+1) + (if String.sub(s,pos)=c then 1 else 0) (* countchar2(s,c) Type: string*char->int Pre: (ingen) Post: Antalet förekomster av c i s Ex.: countchar2("hej, du glade",#"d")=2 countchar2("hej, du glade",#"q")=0 *) fun countchar2(s,c) = countchar2'(s,c,0) PK1&PM1 HT-06 moment 4 Sida 22 Uppdaterad

23 Exempel: räkna tecken baklänges (* countchar3'(s,c,pos) Type: string*char*int->int Pre: 0<=pos<=size s Post: Antalet förekomster av c i s före position pos. Ex.: countchar3'("hej, du glade",#"d",7)=1 countchar3'("hej, du glade",#"d",3)=0 *) (* Variant: pos *) fun countchar3'(s,c,0) = 0 countchar3'(s,c,pos) = countchar3'(s,c,pos-1) + (if String.sub(s,pos-1)=c then 1 else 0); (* countchar3(s,c) Type: string*char->int Pre: (ingen) Post: Antalet förekomster av c i s Ex.: countchar3("hej, du glade",#"d")=2 countchar3("hej, du glade",#"q")=0 *) fun countchar3(s,c) = countchar3'(s,c,size s); PK1&PM1 HT-06 moment 4 Sida 23 Uppdaterad

24 En annan analys av summeringsproblemet Start. Låt summan vara 0. Är n=0? Ja. Stopp. Nej. Addera n till summan. Subtrahera 1 från n. Konstruktionen kallas för en loop. (Det spelar ingen roll om vi adderar n eller n) PK1&PM1 HT-06 moment 4 Sida 24 Uppdaterad

25 Iteration i ML Basfall fun sumupto n = sumuptoaux(n,0) Rekursivt anrop fun sumuptoaux(0,sum) = sum sumuptoaux(n,sum) = sumuptoaux(n-1,sum+n) En hjälpfunktion sumuptoaux implementerar loopen. Tekniken kallas iteration (svansrekursion) och är ett specialfall av rekursion. Argumentet sum kallas för ackumulator. Obs att nya värden för n och sum beräknas samtidigt. sumupto 2 > sumuptoaux(2,0) > sumuptoaux(2-1,0+2) > sumuptoaux(1,2) > sumuptoaux(1-1,2+1) > sumuptoaux(0,3) > 3 PK1&PM1 HT-06 moment 4 Sida 25 Uppdaterad

26 Bindningar i iteration fun sumuptoaux(0,sum) = sum sumuptoaux(n,sum) = sumuptoaux(n-1,sum+n) sumuptoaux(2,0) > sumuptoaux(n-1,sum+n)[n >2,sum >0] > sumuptoaux(2-1,sum+n)[n >2,sum >0] > sumuptoaux(1,sum+n) [n >2,sum >0] > sumuptoaux(1,0+n) [n >2,sum >0] > sumuptoaux(1,0+2) [n >2,sum >0] > sumuptoaux(1,2) [n >2,sum >0] > sumuptoaux(n-1,sum+n)[n >1,sum >2] [n >2,sum >0] skuggas bort helt > sumuptoaux(1-1,sum+n)[n >1,sum >2] > sumuptoaux(0,sum+n) [n >1,sum >2] > sumuptoaux(0,2+n) [n >1,sum >2] > sumuptoaux(0,2+1) [n >1,sum >2] > sumuptoaux(0,3) [n >1,sum >2] > 3 PK1&PM1 HT-06 moment 4 Sida 26 Uppdaterad

27 Funktionsspecifikationen för sumuptoaux sumuptoaux(n,sum) Type: int*int->int För att n skall vara en rekursionsvariant krävs att n inte är mindre än 0 inte ens från början: Pre: n>=0 Eftervillkoret är inte att sumuptoaux summerar av talen 0 till n. Så är den avsedd att användas men det är inte vad den faktiskt gör. Post: Summan av sum och talen från 0 till n. Exempel behövs också... Ex.: sumuptoaux(3,0) = 6 sumuptoaux(4,5) = 15 sumuptoaux(0,2) = 2 Rekursionsvarianten anges som del av programdokumentationen. Variant: n PK1&PM1 HT-06 moment 4 Sida 27 Uppdaterad

28 Kodningsmönster för iteration Flödesschema för funktionen foo: Kod för funktionen foo: Start. A. Ja. T? C. Stopp. Nej. B. fun foo x = fooaux A fun fooaux x = if T then C else fooaux B PK1&PM1 HT-06 moment 4 Sida 28 Uppdaterad

29 Exempel: räkna uppåt med iteration (* sumuptoaux(n,i,sum) Type: int*int*int->int Pre: n>=i-1 Post: Summan av sum och talen från i till n. Ex.: sumuptoaux(4,0,0) = 10 sumuptoaux(4,2,1) = 10 *) (* Variant: n-i+1 *) fun sumuptoaux(n,i,sum)=if i>n then sum else sumuptoaux(n,i+1,sum+i); (* sumupto n Type: int->int Pre: n >= 0 Post: Summan av talen från 0 till n Ex.: sumupto 4 = 10 sumupto 0 = 0 *) fun sumupto n = sumuptoaux(n,0,0); PK1&PM1 HT-06 moment 4 Sida 29 Uppdaterad

30 Exempel: räkna tecken med iteration (* countcharaux(s,c,count) Type: string*char*int->int Pre: (ingen) Post: Summan av count och antalet förekomster av c i s. Ex.: countcharaux("hej, du glade",#"d",0)=2 countcharaux("hej, du glade",#"q",5)=5 *) (* Variant: size s *) fun countcharaux("",c,count) = count countcharaux(s,c,count) = countcharaux(string.substring(s,1,size s -1), c, if String.sub(s,0)=c then count+1 else count) (* countchar(s,c) Type: string*char->int Pre: (ingen) Post: Antalet förekomster av c i s Ex.: countchar("hej, du glade",#"d")=2 countchar("hej, du glade",#"q")=0 *) fun countchar(s,c) = countcharaux(s,c,0); PK1&PM1 HT-06 moment 4 Sida 30 Uppdaterad

31 Minnesbehov Iteration behöver konstant minne. Rekursion i allmänhet behöver minne i proportion till antalet rekursiva anrop eftersom en del av beräkningen väntar. sumupto 2 > sumupto(2-1)+2 > sumupto(1)+2 > (sumupto(1-1)+1)+2 > (sumupto(0)+1)+2 > (0+1)+2 > 1+2 > 3 Detta påverkar också beteendet vid icke-terminering. Uttrycket blir hela tiden större... Minnet tar efterhand slut. Detta kan också drabba ett korrekt terminerande program om de rekursiva anropen är många och kräver mycket minnesutrymme. PK1&PM1 HT-06 moment 4 Sida 31 Uppdaterad

32 Beräkningsordning i rekursion foo och foo' plockar isär en sträng men sätter genast ihop den igen. fun fooaux("",ack) = ack fooaux(s,ack) = fooaux(string.substring(s,1,size s -1), String.substring(s,0,1) ^ ack) fun foo s = fooaux(s,"") fun foo' "" = "" foo' s = String.substring(s,0,1) ^ foo'(string.substring(s,1,size s -1) foo("abc") = "cba" foo'("abc") = "abc" Användning av ackumulator ger annan ordning i resultatet! PK1&PM1 HT-06 moment 4 Sida 32 Uppdaterad

33 Flera basfall Vänd på tecknen i en sträng! Problemuppdelning: Byt plats på första och sista tecknet Byt plats på tecknen emellan Vad händer om strängen har jämnt antal tecken? Udda? Två basfall för variantvärden 0 resp. 1. (* Variant: size s *) fun revstring "" = "" revstring s = if size s = 1 then s else String.substring(s,size s -1,1) ^ revstring(string.substring(s,1,size s-2)) ^ String.substring(s,0,1) PK1&PM1 HT-06 moment 4 Sida 33 Uppdaterad

34 Testning av rekursion Grundprinciperna gäller: All kod. Gränsfall (inklusive triviala fall) Typiska (icke-triviala) fall som täcker hela specifikationen Gränsfall är t.ex. vid testning av sumrange: inga tal / ett tal / två tal (kanske)...vid testning av revstring: tom sträng / sträng med ett tecken / sträng med två tecken / sträng med tre tecken (kanske)...vid testning av countchar: tom sträng / sträng med ett tecken / längre sträng med 0, 1 resp. 2 tecken som stämmer / tecken som (inte) stämmer på plats 0 resp. 1 i strängen... PK1&PM1 HT-06 moment 4 Sida 34 Uppdaterad