Funktionale Programmierung ALP I. Funktionen höherer Ordnung SS Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda

Transkript

1 ALP I SS 2011

2 Funktionstypen Funktionen haben einen Datentyp, der folgende allgemeine Form hat: functionname :: T 1 -> T 2, wobei T 1, T 2 wiederum beliebige Datentypen sind Beispiel: T 1 T 2 Der Datentyp einer Funktion ist rechtsassoziativ. add :: Integer -> ( ) add x y = (+) x y ( Integer -> Integer ) Die Funktionsapplikation dagegen ist linksassoziativ.

3 Currying Eine Funktion mit mehr als einem Argument kann als eine Verschachtelung von Funktionen interpretiert werden, in der jede Funktion nur ein Argument bekommt. Haskell hat implizites Currying! Beispiel: ( ( ) ) mult :: Int Int Int Int mult x y z = x * y * z mult a b c => => ( mult a ) b c ((mult a ) b) c Die mult-funktion ist curryfiziert!

4 Currying f ::t 1 t 2... t n t 1 t 2. ṫ n 1 f t n t 1 t 2 f ( f t 1 ) ( ( f t 1 ) t 2 ) t 3. t n 1 (..(( ft 1 ) t 2 ).. t n 1 ) t n

5 Funktionstypen Eine nicht curryfizierte Definition der mult-funktion sieht wie folgt aus: mult :: (Integer, Integer, Integer) -> Integer Eine partielle Auswertung mit nur einem Argument ist nicht möglich, weil beide Argumente, als Tupel verpackt, eingegeben werden müssen. Anwendungsbeispiel: mult (3, 4, 2) 24

6 Sektionen Jede arithmetische Infix-Operation kann in eine Curried-Funktion verwandelt werden, indem der Operator in runden Klammern und als Präfix-Funktion geschrieben wird. Beispiel: (+) 3 4 dann sieht eine partielle Auswertung der Funktion wie folgt aus: (+ 3) 4 Funktion, die zu einem beliebigen Argument die Zahl 3 addiert Im allgemeinen, wenn ein Infix-Operator ist, werden Ausdrücke mit der Form ( x) oder (x ) Sektionen genannt.

7 Eine Funktion wird als Funktion höherer Ordnung bezeichnet, wenn Funktionen als Argumente verwendet werden oder wenn eine Funktion als Ergebnis zurück gegeben wird. Beispiel: twotimes :: ( a -> a ) -> a -> a twotimes f x = f ( f x ) Anwendung: twotimes quadrat 3 => quadrat (quadrat 3) => 81

8 Typische Beispielsfunktion: map :: (a -> b) -> [a] -> [b] map f [] = [] map f (x:xs) = f x : map f xs map f [2, 3, 6, 0] => [f(2), f(3), f(6), f(0)] Die Funktion f wird auf jedes Element der Liste angewendet map (^2) [2, 3, 6, 0] => [4, 9, 36, 0]

9 Eine andere Definition der map-funktion mit Listen-Generatoren ist: map :: (a -> b) -> [a] -> [b] map f xs = [ f x x<-xs ] Anwendung: map length ["Eins", "Zwei", "Drei", "Vier"] => [4, 4, 4, 4]

10 Die filter-funktion Die filter-funktion soll aus einer Liste nur die Elemente auswählen, die eine bestimmte Bedingung erfüllen. Beispiel: filter (<3) [2,5,0,1,7] => [2,0,1]

11 Die filter-funktion 1. Definition: filter :: (a -> Bool) -> [a] -> [a] filter p [] = [] filter p (x:xs) Bedingung p x = x : filter p xs otherwise = filter p xs 2. Definition: filter :: (a -> Bool) -> [a] -> [a] filter p xs = [ x x <- xs, p x ]

12 Beispiel: Die filter-funktion Quicksort-Algorithmus mit Hilfe der filter-funktion qsort :: (Ord a) => (a -> a -> Bool) -> [a] -> [a] qsort p [] = [] qsort p [x] = [x] qsort p (x:xs) = qsort p (filter (p x) xs) ++ [x] ++ qsort p (filter (np x) xs) where np x y = not (p x y)

13 Nehmen wir an, wir möchten alle Zahlen innerhalb einer Liste miteinander addieren addall:: (Num a) => [a] -> a addall [] = 0 addall (x:xs) = x + addall xs oder die Und-Operation über alle Elemente einer Liste berechnen trueall:: [Bool] -> Bool trueall [] = True trueall (x:xs) = x && (trueall xs)

14 Gemeinsamkeiten von beiden Funktionen sind: - Binär-Operator - konstanter Wert, wenn die Liste leer ist. - gleiches Rekursions-Muster Wir können eine verallgemeinerte Funktion definieren, die beide Probleme löst Verallgemeinerungen sind immer gut! Beispiel: trueall = betweenall (&&) True addall = betweenall (+) 0 multall = betweenall (*) 1

15 Verallgemeinerungen sind immer gut! betweenall :: (a -> a -> a) -> a -> [a] -> a Binäre Operation Wert der Funktion, wenn die Liste leer ist betweenall f k [] = k betweenall f k (x:xs) = f x (betweenall f k xs)

16 foldr-funktion In Haskell ist bereits eine allgemeine Funktion vordefiniert, die Faltungs-Operator genannt wird Definition: foldr f z [] = z foldr (*) 1 [1,2,3,4] foldr f z (x:xs) = f x (foldr f z xs) 1 : : 2 : 3 : 4 [ ] * 1 * => => 24 2 * 3 * 4 1

17 foldr-funktion Haskell: foldr :: (a b b) b [a] b foldr f z [] = z foldr f z (x:xs) = f x (foldr f z xs) Beispiel: len :: [a] Int len xs = foldr oneplus 0 xs where oneplus :: a Int Int oneplus x n = 1 + n

18 Folgende Standard-Funktionen von Haskell können mit Hilfe des Faltungs-Operators definiert werden: Beispiele: sum = foldr (+) 0 product = foldr (*) 1 or and = foldr ( ) False = foldr (&&) True

19 foldl-funktion Definition: foldl :: (b a b) b [a] b foldl f z [] = z foldl f z (x:xs) = foldl f (f z x) xs foldl f k [8,6,4,2] : f 8 : 6 : => f f : 2 [ ] k f 8 6

20 Beispiele: Faltungs-Operatoren foldr (*) 1 [1..5] => 120 Fakultät-Funktion factorial n = foldr (*) 1 [1..n] Potenz-Funktion für positive ganzzahlige Potenzen pow b n = foldl (*) 1 (take n [b,b..b]) foldr max 0 [-6,3,6,12,14,0,23]?

21 zip-funktion zip (x:xs) (y:ys) zip xs ys = [] = (x,y) : zip xs ys Die zip-funktion kombiniert die Elemente aus zwei Listen und liefert eine Liste von Tupeln zurück. Beispiel: zip [1..] ["abcd"] [(1,'a'), (2,'b'), (3,'c'), (4,'d')]

22 zipwith-funktion Die zipwith-funktion bekommt zwei Listen und eine Funktion als Parameter und berechnet eine neue Liste, indem jeweils die Elemente der beiden Listen mit der angegebenen Funktion verknüpft werden. zipwith :: (a -> b -> c) -> [a] -> [b] -> [c] zipwith f (x:xs) (y:ys) = (f x y):(zipwith f xs ys ) zipwith f = [] Beispiel: zipwith (^) [1, 2, 3] [0, 3, 2] [1, 8, 9]

23 Anwendungsbeispiel der zipwith-funktion: Skalar-Produkt von zwei Vektoren v 1. v2 v 1 = (x 1, x 2,.., x n ) v 2 = (y 1, y 2,.., y n ) ist v 1. v2 = x 1. y 1 + x 2. y x n. y n skalarprod ::[Int] -> [Int] -> Int skalarprod xs ys = foldl (+) 0 (zipwith (*) xs ys)

24 Funktionskomposition g f A B C f g (.) :: (b c) (a b) (a c) (.) f g x = f (g x) (f. g) x = f (g x)

25 Funktionskomposition Beispiele: ungerade x = (not. gerade) x ungerade = not. gerade equiv. Anwendung: ungerade 4 (not. gerade) 4 not (gerade 4) not True False

26 Funktionskomposition Beispiele: twotimes f = f. f Anwendung: ungerade 4 (not. gerade) 4 not (gerade 4) not True False

27 Funktionskomposition Beispiele: rep f n n<0 = error "rep is not defined for n<0" n>0 = f. (rep f (n-1)) n==0 = id where id x = x Anwendung: rep not 3 True not (rep not 2 True) not (not (rep not 1 True)) not (not (not (rep not 0 True))) not (not (not (id True))) not (not (not (True))) False

28 all-funktion Entscheidet, ob alle Elemente einer Liste eine gegebene Bedingung erfüllen. all :: (a Bool) [a] Bool all p xs = and [p x x xs] Beispiel: all even [2,4,6,8] => True all (==3) [3,4,3,0,3] => False

29 any-funktion Entscheidet, ob mindestens ein Element einer Liste eine gegebene Bedingung erfüllt. any :: (a Bool) [a] Bool any p xs = or [p x x xs] Beispiel: any even [2,3,6,8] => True any (==3) [3,4,3,0,3] => True

30 Wir können einen allgemeineren Quicksort-Algorithmus definieren, in dem die Vergleichsoperation angegeben wird. qsort v [] = [] qsort v [x] = [x] qsort v (x:xs) = qsort v [s s<-xs, v s x]++[x]++qsort v [b b<-xs, not (v b x)] Anwendungsbeispiel: qsort (<) [3,2,1, 5,4] oder qsort (>=) [3,2,1, 5,4]

31 takewhile-funktion So lange eine Bedingung erfüllt wird, werden Elemente aus einer Liste genommen. takewhile :: (a Bool) [a] [a] takewhile p [] = [] takewhile p (x:xs) p x = x : takewhile p xs otherwise = [] Beispiel: takewhile (<9) [2, 5, 7, 9, 11] => [2, 5, 7]

32 dropwhile-funktion So lange eine Bedingung erfüllt wird, werden Elemente aus einer Liste gelöscht. dropwhile :: (a Bool) [a] [a] dropwhile p [] = [] dropwhile p (x:xs) p x = dropwhile p xs otherwise = x:xs Beispiel: dropwhile isspace " Hello" => "Hello"

33 Berechnung der Fibonacci-Zahlen rekursiv: fib 0 = 0 fib 1 = 1 fib n = fib (n-2) + fib (n-1) Die rekursive Berechnung der Fibonacci-Zahlen hat eine exponentielle Komplexität O((1,618...) n )

34 Folgende Funktion berechnet die Fibonacci-Zahlen in linearer Zeit O(n) fibs :: [Integer] fibs = 0 : 1 : zipwith (+) fibs (tail fibs) fibs 0 : 1 : 1 : 2 : 3 : 5 : 8 :... tail fibs 1 : 1 : 2 : 3 : 5 :... zipwith (+) 1 : 2 : 3 : 5 : 8 :... Anwendungsbeispiel: take 40 fibs