Funktionale Programmierung ALP I. Die Natur rekursiver Funktionen SS Prof. Dr. Margarita Esponda. Prof. Dr.

Transkript

1 ALP I Die Natur rekursiver Funktionen SS 2011

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

3 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(c) ), in dem h n-mal auf c = f(0) angewendet wird.

4 Die Natur rekursiver Funktionen Folgende Faltungsfunktion stellt eine Verallgemeinerung der Funktionen mit dieser einfachen Grundform dar: data Natural = Zero S Natural deriving (Eq, Show) fold :: (a->a) -> a -> Natural -> a fold h c Zero = c fold h c (S n) = h (fold h c n)

5 Rekursionsarten Lineare Rekursion Rekursive Funktionen, die in jedem Zweig ihrer Definition maximal einen rekursiven Aufruf beinhalten, werden als linear rekursiv bezeichnet. Beispiel: f 0 = 1 f n n<0 = 2 * (f (n+1)) otherwise = 3 * (f (n-1))

6 Rekursionsarten 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. Das bedeutet, dass keine weiteren Operationen nach der Auswertung der Rekursion berechnet werden müssen.

7 Endrekursion Beispiel: Eine nicht endrekursive Funktion ist folgende Definition der Fakultätsfunktion: factorial 0 = 1 factorial n = n * factorial (n-1) Ablauf einer Berechnung: factorial 6 => 6 * factorial 5 => 6 * (5 * factorial 4) => 6 * (5 * (4 * factorial 3)) => 6 * (5 * (4 * (3 * factorial 2))) => 6 * (5 * (4 * (3 * (2 * factorial 1)))) => 6 * (5 * (4 * (3 * (2 * (1 * factorial 0))))) => 6 * (5 * (4 * (3 * (2 * (1 * 1))))) => 6 * (5 * (4 * (3 * (2 * 1)))) => 6 * (5 * (4 * (3 * 2))) => 6 * (5 * (4 * 6)) => 6 * (5 * 24) => 6 * 120 => 720 Der Ausführungsstapel wächst bei jedem rekursiven Aufruf und Teilausdrücke müssen ständig zwischengespeichert werden. Die Endberechnungen finden erst beim Abbau des Ausführungsstapels statt.

8 Endrekursion Beispiel einer endrekursiven Definition der Fakultätsfunktion quickfactorial n = factorial_helper 1 n where factorial_helper a 0 = a factorial_helper a n = factorial_helper (a*n) (n-1) Ablauf einer Berechnung: quickfactorial 6 => factorial_helper 1 6 => factorial_helper 6 5 => factorial_helper 30 4 => factorial_helper => factorial_helper => factorial_helper => factorial_helper => 720 Es müssen keine Zwischenausdrücke gespeichert werden. Endrekursive Funktionen können aus diesem Grund oft vom Übersetzer (Compiler) optimiert werden, indem diese in einfache Schleifen verwandelt werden.

9 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 1 ] 1... => [x n ] ++ [x n-1 ] ++ [x 2 ] ++ [x 1 ] 1 => [] ++ [x n ] [x 2 ] ++ [x 1 ] 1 bis hier (n+1) Reduktionen!

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

11 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... => (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) Reduktionen n

12 Wichtiges Beispiel von Endrekursion foldl-funktion: foldl :: (b -> a -> b) -> b -> [a] -> b foldl f z [] = z foldl f z (x:xs) = foldl f (f z x) xs foldl.1 foldl.2 Hier werden Zwischenergebnisse akkumuliert und weitergeleitet. Mit Hilfe von Faltungs-Operatoren können sehr leicht endrekursive Funktionen definiert werden. Beispiel: reverse_reloaded = foldl (flip (:)) [] flip :: (a -> b -> c) -> b -> a -> c flip f x y = f y x

13 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.2 => 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 ] =>...

14 Berechnung der Fibonacci-Zahlen Wie viele Reduktionsschritte brauchen wir, um fib n zu berechnen? fib 0 1 fib = 1 fib 2 fib 3 fib 4 fib 5 fib Reduktionen + = = = = 13 Die Anzahl der Reduktionen für fib n ist gleich fib (n+1) Die rekursive Berechnung der Fibonacci- Zahlen hat eine exponentielle Komplexität O( (1,618...) n )

15 2. Lösung Endrekursive Funktion Berechnung der Fibonacci-Zahlen quickfib funktioniert nur, wenn diese mit den ersten zwei Fibonacci-Zahlen gestartet wird. fib' n = quickfib 0 1 n Zähler where quickfib a b 0 = a quickfib a b n = quickfib b (a+b) (n-1) quickfib.1 quickfib.2 Innerhalb jedes rekursiven Aufrufs wird eine neue Fibonacci-Zahl berechnet und der Zähler verkleinert. Die neue Zahl und ihr Vorgänger werden beim nächsten rekursiven Aufruf als Parameter weitergegeben. Anzahl der Reduktionen Für die Berechnung von quickfib n benötigen wir n Reduktionen, d.h. wir haben nur einen linearen Aufwand O(n)

16 Eine effiziente tree2list-funktion Noch ein Beispiel für die Verbesserung der Effizienz einer Funktion ist die Funktion tree2list. data Tree = Nil Leaf Int Node Int Tree Tree tree2list :: Tree -> [Int] tree2list Nil = [] tree2list (Leaf n) = [n] tree2list (Node n l r) = tree2list l ++ [n] ++ tree2list r Die Verwendung der (++)-Funktion verursacht wieder einen quadratischen Berechnungsaufwand.

17 Eine effiziente tree2list-funktion Hier benutzen wir die gleiche Technik wie bei der rev-funktion, indem wir eine Art Akkumulator für Zwischenergebnisse einbauen: data Tree = Nil Leaf Int Node Int Tree Tree tree2list' :: Tree -> [Int] tree2list' t = tree2liste' t [] tree2liste' :: Tree -> [Int] -> [Int] tree2liste' Nil ns = ns tree2liste' (Leaf n) ns = n:ns tree2liste' (Node n l r) ns = (tree2liste' l (n:(tree2liste' r ns)))