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

Transkript

1 ALP I Funktionen höherer Ordnung Teil 2 SS 2013

2 Funktionen höherer Ordnung 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)

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

4 Funktionen höherer Ordnung 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)

5 Funktionen höherer Ordnung betweenall :: (a -> a -> a) -> a -> [a -> a betweenall f k [ = k betweenall f k (x:xs) = f x (betweenall f k xs) betweenall f k [x1, x2,, xn-1, xn f x1 (betweenall f k [x2,, xn-1, xn) f x1 (f x2 (betweenall f k [x3,, xn-1, xn)) f x1 (f x2 (f x3 (betweenall f k [x4,, xn-1, xn)))... f x1 (f x2 (f x3 (.. (f xn-1 (f xn (betweenall f k [)))...) f x1 (f x2 (f x3 ( (f xn-1 (f xn k))) )... f x1 w2

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

7 Faltungs-Operatoren Beispiele: foldr (*) 1 [1..4 (*) 1 (foldr (*) 1 [2,3,4) (*) 1 ((*) 2 (foldr (*) 1 [3,4)) (*) 1 ((*) 2 ((*) 3 (foldr (*) 1 [4))) (*) 1 ((*) 2 ((*) 3 ((*) 4 (foldr (*) 1 [)))) (*) 1 ((*) 2 ((*) 3 ((*) 4 1))) (*) 1 ((*) 2 ((*) 3 4)) (*) 1 ((*) 2 12) (*) Fakultät-Funktion factorial n = foldr (*) 1 [1..n

8 Funktionen höherer Ordnung Folgende Standard-Funktionen von Haskell können mit Hilfe des Faltungs-Operators definiert werden: Beispiele: sum :: (Num a) => [a -> a sum = foldr (+) 0 product :: (Num a) => [a -> a product = foldr (*) 1 or :: [Bool -> Bool or = foldr ( ) False or :: [Bool -> Bool and = foldr (&&) True

9 Die Natur rekursiver Funktionen Rekursive Funktionen haben oft folgende allgemeine Form: f 0 = c f (n+1) = h (f n ) Diese Art der Definitionen wird oft als Strukturelle Rekursion über die natürlichen Zahlen bezeichnet.

10 Die Natur rekursiver Funktionen Eine Funktionsdefinition dieser Form über die natürlichen Zahlen sieht aus wie folgt: Sei = die natürliche Zahl n. Wenn wir die 0 mit c und (1+) mit h ersetzen, bekommen wir folgenden Ausdruck h(h(h( h(h(c)) ))), in dem h n-mal auf c = f(0) angewendet wird. f 0 = 0 f (n+1) = (1+) (f n) f 0 = c f (n+1) = h (f n)

11 Die Natur rekursiver Funktionen Folgende Faltungsfunktion stellt eine Verallgemeinerung der Funktionen mit dieser einfachen Grundform dar: natfold :: (a->a) -> a -> Integer -> a natfold h c 0 = c natfold h c (n+1) = h (natfold h c n) Eigene Potenz-Funktion: potenz(n,m) = n m für n,m Ν potenz :: Integer Integer Integer potenz n m = natfold (*n) 1 m

12 Rekursionsarten Lineare Rekursion Rekursive Funktionen, die in jedem Zweig ihrer Definition maximal einen rekursiven Aufruf beinhalten, werden als linear rekursiv bezeichnet. Endrekursion (tail recursion) Linear rekursive Funktionen werden als endrekursive Funktionen klassifiziert, wenn der rekursive Aufruf in jedem Zweig der Definition die letzte Aktion zur Berechnung der Funktion ist.

13 Funktionen höherer Ordnung foldl-funktion Definition: foldl :: (a -> b -> a) -> a -> [b -> a foldl f z [ = z foldl f z (x:xs) = foldl f (f z x) xs foldl f z [x 1,x 2,,x n foldl f (f z x 1 ) [x 2,,x n foldl f (f (f z x 1 ) x 2 ) [x 3,,x n... foldl f (f...(f (f (f z x 1 ) x 2 ) x 3 ) ) [ (f...(f (f (f z x 1 ) x 2 ) x 3 ) )

14 Funktionen höherer Ordnung foldl f z [ = z foldl f z (x:xs) = foldl f (f z x) xs foldl (*) 1 [8,6,4 foldl (*) ((*) 1 8) [6,4 foldl (*) 8 [6,4 foldl (*) ((*) 8 6) [4 8 : : 6 : 4 [ z * * 8 * 6 4 foldl (*) 48 [4 foldl f ((*) 48 4) [ foldl f 192 [ 192

15 Die foldl-funktion Wichtiges Beispiel von Endrekursion foldl :: (b -> a -> b) -> b -> [a -> b foldl f z [ = z foldl f z (x:xs) = foldl f (f z x) xs Hier werden Zwischenergebnisse akkumuliert und weitergeleitet. Mit Hilfe von Faltungs-Operatoren können sehr leicht endrekursive Funktionen definiert werden.

16 Beispiele: maxi :: (Ord a) => [a -> a maxi (x:xs) = foldl max x xs length :: [a -> Int length xs = foldl addone 0 xs where addone a b = a + 1 pow :: Integer -> Integer -> Integer pow b n = foldl (*) 1 (take n [b,b..b)

17 Beispiele endrekursiver Funktionen Klassisches Beispiel einer nicht endrekursiven Definition ist: Die Standarddefinition der reverse-funktion rev :: [a -> [a rev [ = [ rev (x:xs) = rev xs ++ [x Berechnungsaufwand von rev: Reduktionen rev [x 1, x 2,, x n => rev [x 2,, x n ++ [x 1 1 => rev [x 3,, x n ++ [x 2 ++ [x => [x n ++ [x n-1 ++ [x 2 ++ [x 1 1 => [ ++ [x n [x 2 ++ [x 1 1 bis hier (n+1) Reduktionen!

18 Berechnungsaufwand von rev bis hier (n+1) Reduktionen! (++) :: [a -> [a -> [a (++) [ ys = ys (++) (x:xs) ys = x:(xs ++ ys) => [ ++ [x n ++ [x n [x 2 ++ [x 1 => [x n ++ [x n [x 2 ++ [x 1 1 => [x n, x n [x 2 ++ [x 1 2 => [x n, x n-1,x n [x 2 ++ [x 1 3 =>.... => [x n, x n-1,,x 1 n Die gesamte Anzahl der Reduktionen ist: Reduktionen Quadratischer Ausführungsaufwand!

19 Eine effizientere Version von rev quickrev xs = rev_helper xs [ where rev_helper [ ys = ys rev_helper (x:xs) ys = rev_helper xs (x:ys) Berechnungsaufwand: quickrev [x 1, x 2,, x n => rev_helper [x 1,,x n [ 1 => rev_helper [x 2,,x n (x 1 :[) 1 => rev_helper [x 3,,x n (x 2 :x 1 :[) 1 Reduktionen n... => (x n :,,x 2 :x 1 :[) 1 => (x n :,,x 2 :[x 1 ) 1 n... => (x n :,, x 3 :[x 2,x 1 ) 1 lineare Komplexität 2n = O(n)

20 foldl f z [ = z foldl f z (x:xs) = foldl f (f z x) xs Die reverse-funktion mit Faltungsoperator f z reverse_reloaded :: [a -> [a reverse_reloaded xs = foldl (flip (:)) [ xs Die flip-funktion vertauscht die Argumente für die Funktion f flip :: (a -> b -> c) -> b -> a -> c flip f x y = f y x

21 Berechnungsverlauf: reverse_reloaded [x 1, x 2,, x n foldl.2 => foldl (flip (:)) [ [x 1, x 2,, x n => foldl (flip (:)) ((flip (:)) [ x 1 ) [x 2,x 3,, x n => foldl (flip (:)) ((:) x 1 [) [x 2,x 3,, x n => foldl (flip (:)) (x 1 :[) [x 2,x 3,, x n foldl.2 => foldl (flip (:)) [x 1 [x 2,x 3,, x n => foldl (flip (:)) ((flip (:)) [x 1 x 2 ) [x 3,, x n => foldl (flip (:)) ((:) x 2 [x 1 ) [x 3,, x n => foldl (flip (:)) (x 2 :[x 1 ) [x 3,, x n => foldl (flip (:)) [x 2, x 1 [x 3,, x n foldl.2 =>...

22 Funktionen höherer Ordnung 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)

23 Funktionen höherer Ordnung 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

24 Funktionen höherer Ordnung Funktionskomposition f g A B C g f (.) :: (b c) (a b) (a c) (.) g f x = (g (f x)) Beispiel: ungerade = not. gerade