Dagens föreläsning Programmering i Lisp Fö 7. Sammanfattning funktionell programmering Exempel på funktionella programspråk

Transkript

1 1 Dagens föreläsning Programmering i Lisp Fö 7 Kopplingen funktionella programmering och diskret matematik. Jämför vad ni hittills gjort i denna kurs och i den diskreta matematiken, med referenser in i läroboken Diskret matematik. Sammanfattning funktionell programmering Exempel på funktionella programspråk

2 2 DM-Kapitel 1. Mängder Mängder kan lätt representeras som listor i Lisp, men dubblerade element kan ej förekomma. Ordningen spelar ingen roll. DM-Avsnitt 1.2 I Övning 120.* föreslås att definiera mängdoperationerna union, snitt och differens, samt lägg till ett element och är ett element medlem i en mängd. Man kan också införa en funktion som jämför om två mängder är lika eller en delmängd av en annan mängd. DM-Avsnitt 1.3 I Lisp-föreläsning 5 i samband med reduce och den rekursiva och iterativa processlösningen, diskuterade vi olika egenskaper hos operatorer, kommutativ och associativ operator, samt vänster- resp högerassociativitet. I vilken ordning beräknas uttryck som (1 - (2 - (3 - (4-5)))) eller ((((1-2) - 3) - 4) - 5) Hur är det med +?

3 3 Vi kom då fram till att vi kunde använda samma operator i den rekursiva och iterativa processlösningen om operatorn var kommutativ och associativ. Från 1.3 ser vi dessa lagar för operatorn union. I nästa steg i Lisp-kursen kommer vi att ta upp Dataabstraktion och kommer då att använda mängder som ett sätt att beskriva datatyper. DM-Avsnitt 1.4 Vi kommer att använda begrepp som ordnade par och kartesiska produkt. DM-Avsnitt 1.8 Delmängd och potensmängd. Nu skall i uppgift 3A skriva en funktion som genererar potensmängden av en mängd, dvs alla delmängder man kan skapa.

4 4 DM Kapitel 4. Induktion I Lisp-kursen vill vi använda resonemanget med induktion för att skriva och verifiera rekursiva funktioner. Antag att det rekursiva anropet är korrekt. Lisp-föreläsning 6 tog upp DM 4.1 Induktionsprincipen. Exemplifierat med samma summering som i läroboken. När ni definierade de första rekursiva funktionerna över tal så exemplifierade på samma sätt som sid 52 i DM-boken hur man kunde se det rekursiva sambandet. DM 4.2 Välordningsprincipen. Det finns ett minsta element i en delmängd av tal i N. Vi kan även göra induktion över sekvenser, som inte tas upp i läroboken, utan man gör induktionsbevis över naturliga talen.

5 5 DM 4.4 Rekursiva definitioner. Se DM-exempel och fakultetsfunktionen i I DM-exempel ser ni sambandet för n-te potensen, som ni definierad i övning 108 med funktionen upphöjt-till.

6 6 Vad ni kan göra: Ni kan testa många samband i DM-övningarna (sid 58) genom att använda funktioner ni definierat i Lisp, tex summera de n första talen. Gör om den till en högre ordningens funktion, som tar termen i summan (som en funktion). (defun summera (n term) (summera-från n 1 term)) (defun summera-från (n i term) (if (> i n) 0 (+ (funcall term i) (summera-från n (+ i 1) term)))) (defun fak (n) (if (= n 0) 1 (* n (fak (- n 1))))) (defun square (n) (* n n)) (defun test-4.5 (n) (= (summera n # (lambda (k)(* k (fak k)))) (- (fak (+ n 1)) 1))) (defun test-4.6 (n) (= (summera n # (lambda (k) (* k k k))) (square (summera n # (lambda (k) k))))) (test-4.5 5) => t (test 4.6) = t

7 7 DM Kapitel 5 Kombinatorik Här kanske vi inte använder så mycket i programmeringen som sådant, utan mer hittar många bra exempel att lösa. DM Permutationer. Där definieras fakultet igen, och sätt att beräkna antalet permutationer. I Lisp-läroboken i avsnitt 8.2 en funktion som tar fran alla permutationer av elementen i en lista. (Senare i avsnitt 12.7 visas hur en rekursiv lösning mer systematiskt kan överföras till ett iterativ program.) DM 5.5 Kombinationer. På Lisp-föreläsning och övning 301 är att skriva en funktion som genererar alla kombinationer av elementen i ett godtyckligt antal listor. Egentligen löser vi här problemet att ta fram den kartesiska produkten av ett antal tupler. Se DM-avsnitt 1.4, men där ger man kartesiska produkten av 2 tupler, medan vi i denna uppgift tar fram med godtyckligt antal tupler.

8 8 DM 5.7 Binomialsatsen och 5.9 Pascals triangel. Sedan införs n över k, som kan beräknas med fakultet, som leder till binomialkoefficienterna, som kan beräknas med Pascals triangel, som är er Uppgift 2E. Vad kan ni göra: Även här kan ni med ganska enkla medel kunna skriva program som löser en del av övningarna från DM-kapitel 5 på sidan 82 och framåt.

9 9 DM-Kapitel 7. Grafer DM Avsnitt Grafer och enkla grafer. Här ges den allmänna defintionen av en graf. Här använd begreppet hörn, som motsvarande begrepp för en nod, som vi har använt här i Lisp-kursen. En båge kallas även en kant. DM Avsnitt Vägar. Här definieras väg som en sekvens bågar. DM avsnitt 7.4 Träd. Här ges den allmänna definitionen av ett träd, som är en graf utan cykler. Vi har mest använt begreppet binärt träd, då antalet utgående bågar är 2 (eller max 2).

10 10 DM Kapitel 10. Logik DM Avsnitt 10.2 Konnektiv och sanningsvärdestabeller. Vi använder detta i dels Lisp-övning 208, där de logiska konnektiven negation (icke/ not), disjunktion (eller/or) och konjunktion (och/eller) skall definieras. Sannigstabellerna ges i DMavsnitt I Lisp-uppgift 2A skall logiska uttryck beräknas.

11 11 Återblick funktionell programmering Program är funktioner. Funktionerna ses som matematiska funktioner, dvs avbildning av argument till värde. Funktioner gör ej eller beror på sidoeffekter. Funktionsanrop med samma argument skall ge samma värde (referential transparency). (f 1 2) => 2345 (f 1 2) => 4567 Ej möjligt! Beräkningsmodell: Substitutionsmodellen, ersätt funktionsanrop med funktionsdefinition och substituera formella parametrar med värdet av de aktuella parametrarna. Deklarativ programmering: Program beskriver mer vad som skall göras ej exakt hur. Program ses mer som en specifikation av problemet, men som även kan beräknas. Till gruppen hör även logikprogrammering.

12 12 Vi har hittills gått igenom den funktionella delmängden eller pure Lisp. - dataobjekt: tal, symboler och listor - uttryck - villkorliga uttryck - funktioner - högre ordningens funktioner - lokala variabler - lokala funktioner - ge globalt namn (med setq) till värden Icke-funktionella operationer är: Användning av setq, som tilldelning inne i funktioner. In- och utmatning. Datastrukturer som ändrar innehåll, t ex poster och arraystrukturer.

13 13 - Vi har lärt oss skriva algoritmer som bearbetar sekvenser och binär träd-strukturer. Ni har nu övat på detta. - Vi har identifierat olika typer av mallar eller mönster. - Vi kan traversera en sådan struktur, dvs gå igenom den element för element. Vi kan nu identifiera olika typer av algoritmmönster: sökning efter givet element (finns-bokstav? i Övn 118, forwardfind i Uppg 2B) mappning, transformera varje elements värde till ett nytt och skapa en struktur av samma slag. (positiva i Uppg 1A, högre ordningens funktion mapcar) filtrering, skapa en ny struktur med alla elementen som uppfyller ett villkor (ta-bort-vokaler i Uppg 119, filtrera i Uppg 1A, filter Övn 213) reduktion (ackumulering), t ex summera alla talen i en sekvens (räkna i Uppg 1A, högre ordningens funktion reduce) back-tracking, sök först bestäm sedan (efter-sista i Uppg 205, backfind i Uppg 2C) generering, från ett värde skapa nästa (generate-list i Uppg 2E)

14 14 Används funktionell programmering? Ericsson har tagit fram ett deklarativt språk ER- LANG ( baserat på funktionell programmering (ML) och logikprogrammering (Prolog). Innehåller processer för concurrent programming. Skiljer sig från LISP genom annan syntax och anrop genom mönstermatchning. member(x, [X _]) -> true member(x, [_ T]) -> member(x,t) member(x, []) -> nil member(a, [a, b, c, d]) > true (defun member (x l) (cond ((endp l) nil) ((eq x (first l)) t) (t (member x (rest l)))))

15 15 Exempel: Binärt sorteringsträd. Kan användas för att snabba upp sökningen i en tabell jämfört med exempelvis en sekvensiell lista (typ associationslista). Vi har en nyckel (key) och ett värde (value). Representation för ett sorterat-binärt-träd: löv: nil nod: {nyckel värde sorterat-binärt-träd sorterat-binärt-träd} Exempel: ett - one, två - two, tre - three, fyra - four Sorteringsträdet byggs upp genom ta en nyckel och ett värde i taget, traversera trädet och bygga ut ett löv: nil {ett one nil nil} {ett one nil {två two nil nil}} {ett one nil {två two {tre three nil nil} nil}} {ett one nil {två two {tre three {fyra four nil nil} nil} nil}}

16 16 Sökning i ett sorterat binärt träd. Erlangkod: lookup(key, nil) -> not-found lookup(key, {Key, Value, _, _}) -> {found, Value} lookup(key, {Key1, _, Smaller, _}) when Key < Key1 -> lookup(key, Smaller) lookup(key, {Key1, _, _, Bigger}) when Key > Key1 -> lookup(key, Bigger) motsvarande Lispkod: (defun lookup (key node) (cond ((eq node nil) not-found) ((eq key (first node)) (list found (second node))) ((string< key (first node)) (lookup key (third node))) (t (lookup key (fourth node)))))

17 17 Funktionella programspråk. Haskell Används som första programspråk på Chalmers. qsort [] = [] qsort (x:xs) = qsort elts_lt_x ++ [x] ++ qsort elts_greq_x where elts_lt_x = [y y <- xs, y < x] elts_greq_x = [y y <- xs, y >= x] (x:xs) --- x binds till första elementet och xs till resten ++ är append [y y <- xs, y < x] är en högre ordningens operation som skapar en lista med alla y där y tillhör xs och y är mindre än x. Andra egenskaper: strongly typed (stark typning), polymorphism non-strict functional programming languages => lazy evaluation (lat evaluering) till skillnad från eager evaluation Man kan hantera oändliga listor

18 18 Lat evaluering (defun f (test arg1 arg2)... (if test arg1 arg2)...) (f (= x 3) (/ x y) (/ x 0)) Om detta är enda stället där arg2 används och om x=3 så behövs inte arg2 som då inte beräknas. Om arg2 i detta fall beräknas får vi ju fel, division med 0! Strömmar, man kan hantera oändliga listor. Definition av alla heltalen. (defun heltal-från (n) (cons n (heltal-från (+ n 1)))) (setq heltal (heltal-från 1)) heltal = ( (fifth heltal) => 5 Antag vi har ström-add som adderar elementen i två strömmar parvis. (ström-add heltal heltal) => ( Vi definierar om heltalen: (setq ettor (cons 1 ettor)) (setq heltal (cons 1 (ström-add ettor heltal))) Vi definierar fibonaccitalen: (setq fib-tal (cons 0 (cons 1 (ström-add (rest fib-tal) fib-tal)))) fib-tal = ( (sixth fib-tal) => 8

19 19 Mer om detta kan man läsa i kurserna: TDDA69 Data- och programstrukturer TDDA43 Programmeringsteori