ALP I. Funktionale Programmierung

Transkript

1 ALP I Funktionale Programmierung Zusammengesetzte Datentypen in Haskell WS 2012/2013

2 Zusammengesetzte Datentypen Tupel List String

3 Zusammengesetzte Datentypen Tupel-Datentyp Ein Tupel ist eine Ansammlung von zwei oder mehreren Daten, die unterschiedliche Datentypen besitzen können. Mit Hilfe von Tupeln können zusammengehörige Daten als Einheit behandelt werden. Beispiele: Studierende ( "Peter", "Meyer", ) :: ( String, String, Int ) ( 2.5, 3.0 ) :: ( Double, Double ) Punkt

4 Funktionsdefinition mit Tupeln: Tupel-Typ distance :: (Double, Double) -> (Double, Double) -> Double distance (x1,y1) (x2,y2) = sqrt (squarex + squarey ) where squarex = (x1-x2) * (x1-x2) squarey = (y1-y2) * (y1-y2)

5 Tupel-Datentyp rgbcolor :: (Int, Int, Int) [Char] rgbcolor (red, green, blue) = case (red, green, blue) of (0,0,0) "black" (255,255,255) "white" (255,0,0) "red" (0,255,0) "green" (0,0,255) "blue" otherwise "other color"

6 Tupel-Typ Ein Tupel-Typ hat folgende allgemeine Form: ( t 1, t 2,, t n ), wobei t 1, t 2,, t n beliebige Datentypen sind Zwei einfache Funktionen für Tupel sind: fst (x, y) = x snd (x, y) = y Die erwartete Tupel-Struktur wird in den Argumenten sichtbar

7 Tupel-Typ Funktionsdefinition mit Tupeln: distance :: (Double, Double) -> (Double, Double) -> Double distance p1 p2 = sqrt(xd^2 + yd^2) where xd = (fst p1) - (fst p2) yd = (snd p1) - (snd p2)

8 Pattern-Matching mynot :: Bool -> Bool mynot True = False mynot False = True oder :: Bool -> Bool -> Bool oder False False = False oder x y = True oder0 :: Bool -> Bool -> Bool oder0 False False = False oder0 False True = True oder0 True False = True oder0 True True = True und :: Bool -> Bool -> Bool und True True = True und = False beliebige Argumente vom Typ Bool

9 Pattern-Matching In Haskell ist es möglich durch Pattern-Matching eine Auswahl verschiedener Funktionsgleichungen zu definieren. Allgemeine Form: f p 11 p 12 p 1n = e 1 f p 21 p 22 p 2n = e 2.. f p k1 p k2 p kn = e k Die p ij Muster werden von oben nach unten und von links nach rechts geprüft.

10 Typ-Synonyme Typ-Synonyme werden verwendet, um die Lesbarkeit von Programmen mit Hilfe von aussagekräftigen Typ-Namen zu verbessern. Allgemeine Form: type Typname =. Beispiele: type Student = (String, String, Int) type Point = (Double, Double)

11 Typ-Synonyme Funktionsdefinition mit Typ-Synomyme: type Point = (Double, Double) distance :: Point -> Point -> Double distance (x1,y1) (x2,y2) = sqrt (sumsq (x1-x2) (y1-y2)) where sumsq x y = x*x + y*y

12 Typ-Synonyme type Complex = (Double, Double) realpart :: Complex -> Double realpart ( real, img ) = real imgpart :: Complex -> Double Text imgpart ( real, img ) = img sumc :: Complex -> Complex -> Complex sumc (r1,i1) (r2,i2) = (r1+r2, i1+i2) absc :: Complex -> Double absc ( real, img ) = sqrt( real*real + img*img )

13 Rekursion Rekursion ist ein fundamentales Konzept in der Mathematik - eine Denkform für Problembeschreibung - enge Beziehung zur mathematischen Induktion Rekursion ist ein fundamentales Konzept in der Informatik - eine Methode zur Problemlösung Rekursive Funktionsdefinitionen sind die wichtigste Programmiertechnik in funktionalen Programmiersprachen. 13

14 Typisches Beispiel: Rekursive Funktionen Die Fakultätsfunktion Wie viele Permutationen kann eine Reihe von Objekten maximal haben? factorial :: Int -> Int factorial n = if n==0 then 1 else n * factorial (n-1) factorial :: Int -> Int factorial n n==0 = 1 otherwise = n*factorial (n-1) richtig aber nicht schön factorial :: Integer -> Integer factorial n n==0 = 1 True = n*factorial (n-1)

15 Rekursive Funktionen Die Fakultätsfunktion Pattern-Matching factorial :: Int -> Int factorial 0 = 1 factorial n = n * factorial (n-1) bigfactorial :: Integer -> Integer bigfactorial 0 = 1 bigfactorial n = n * bigfactorial (n-1)

16 Rekursive Funktionen Die Fakultätsfunktion Pattern-Matching factorial :: Int -> Int factorial n = n * factorial (n-1) factorial 0 = 1 Warning: Pattern match(es) are overlapped In the definition of `factorial': factorial 0 =... Ok, modules loaded: factorial 0 *** Exception: stack overflow

17 noch ein Klassiker: Rekursive Funktionen Größter gemeinsamer Teiler von zwei natürlichen Zahlen a, b Euklid (originaler Algorithmus) ggt :: Integer Integer Integer ggt p q p>q = ggt (p-q) q p==q = p Probleme? p<q = ggt p (q-p)

18 Rekursive Funktionen ggt :: Integer Integer Integer ggt p q p>q = ggt (p-q) q p==q = p p<q = ggt p (q-p) ggt 20 8 (20-8) 8 ggt 12 8 ggt (12-8) 8 ggt 8 4 ggt 4 4 Probleme? ggt 8 0 ggt (8-0) 0 ggt 8 0 ggt :( 4

19 Rekursive Funktionen 1. Lösung: ggt a b b == 0 = a otherwise = ggt b (a `mod` b) 2. Lösung: ggt a b a == 0 && b == 0 =??? b == 0 = a otherwise = ggt b (a `mod` b)

20 Pizzaproblem (Jakob Steiner, 1826) Wie viele Pizza-Teile entstehen maximal, wenn eine Pizza mit n geraden Schnitten aufgeteilt wird? maxsurfaces :: Int -> Int maxsurfaces 0 = 1 maxsurfaces n = maxsurfaces (n - 1) + n

21 Rekursive Funktionen Berechnung des goldenen Schnitts Zwei positive reelle Zahlen stehen im Verhältnis der goldenen Zahl, wenn a b = a + b a gilt, mit a > b > 0. Goldener Schnitt = Φ = 1+ 1 Φ goldenratio :: Int -> Double goldenratio n n == 0 = 1 n > 0 = / goldenratio (n-1) otherwise = error "not defined for negative numbers"

22 Fibonacci-Zahlen Problem: Zu Beginn eines Jahres gibt es genau ein Paar neugeborener Kaninchen. Ein Paar neugeborener Kaninchen ist erst nach einem Monat fortpflanzungsfähig, sodass erst nach zwei Monaten ein neues Kaninchenpaar zur Welt gebracht werden kann. Jedes nicht neugeborene Kaninchen bekommt ein neues Kaninchenpaar monatlich. Wie viele Kaninchen gibt es nach einem Jahr, wenn keines der Kaninchen stirbt? 22

23 Fibonacci-Zahlen

24 Fibonacci-Zahlen Der Stammbaum einer Drohne 13 8 Ururgroßeltern 5 Urgroßeltern 3 Großeltern 2 Mutter 1 Drohne 24

25 Fibonacci-Zahlen

26 Blumen Fibonacci-Zahlen

27 Fibonacci-Zahlen fib(0) fib(1) fib(2)

28 Fibonacci-Zahlen fib(0) fib(1) fib(2) fib(3)

29 Fibonacci-Zahlen fib(0) fib(1) fib(2) fib(3) fib(4)

30 Fibonacci-Zahlen fib(0) fib(1) fib(2) fib(3) fib(4) fib(5)

31 Fibonacci-Zahlen fib(0) fib(1) fib(2) fib(3) fib(4) fib(5) fib(6) fib(7) fib(n-2) + fib(n-1) fib(n) Formale rekursive Definition: fib ( 0 ) = 0 fib ( 1 ) = 1 fib ( n ) = fib ( n-2 ) + fib ( n-1 ) für alle n>1 31

32 Berechnung der Fibonacci-Zahlen Beispiel: fib 7 fib 7 1. Lösung fib 0 = 0 fib 1 = 1 fib n = fib (n-1) + fib (n-2) fib 5 fib 6 fib 3 fib 4 fib 4 fib 5 fib 1 fib 2 fib 2 fib 3 fib 2 fib 3 fib 3 fib 4 fib 0 fib 1 fib 0 fib 1 fib 1 fib 2 fib 0 fib 1 fib 1 fib 2 fib 1 fib 2 fib 2 fib 3 fib 0 fib 1 fib 0 fib 1 fib 0 fib 1 fib 1 fib 2 wiederholte Berechnungen der fib-funktion fib 0 fib 1

33 Berechnung der Fibonacci-Zahlen Beispiel: fib 7 fib 7 fib 5 fib 6 fib 3 fib 4 fib 4 fib 5 fib 1 fib 2 fib 2 fib 3 fib 2 fib 3 fib 3 fib 4 fib 0 fib 1 fib 0 fib 1 fib 1 fib 2 fib 0 fib 1 fib 1 fib 2 fib 1 fib 2 fib 2 fib 3 fib 0 fib 1 fib 0 fib 1 fib 0 fib 1 fib 1 fib 2 Fallgrube Wenn wir fib 40 mit unserer rekursiven Implementierung berechnen, wird: fib 39 einmal berechnet fib 38 2 mal berechnet fib 37 3 mal berechnet fib 36 5 mal berechnet fib 35 8 mal berechnet... fib 0 fib 1 fib mal berechnet Beim Aufruf von fib 40 werden Funktionsaufrufe gemacht

34 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 Anzahl der rekursive Aufrufe ist eine exponentielle Funktion von n.

35 Berechnung der Fibonacci-Zahlen 2. Lösung 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) 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,

36 Fibonacci-Zahlen 3. Lösung mit Tupeln: nextfib :: (Integer, Integer) -> (Integer, Integer) nextfib (a,b) = (b, a+b) fib n = fst ( fibtuple n ) Text fibtuple n n==0 = (0, 1) otherwise = nextfib (fibtuple (n-1)) 36

37 Listen Listen sind die wichtigsten Datenstrukturen in funktionalen Programmiersprachen Listen stellen Sammlungen von Objekten dar, die den gleichen Datentyp besitzen Listen sind dynamische Datenstrukturen, die mit Hilfe folgender Daten-Konstruktoren erzeugt werden können Symbol Name Bedeutung [ ] nil leere Liste (:) cons am Anfang anfügen

38 Listen Listen sind rekursive Strukturen: Eine Liste ist entweder leer [] oder ein konstruierter Wert, der aus einem Listenkopf x und einer Restliste xs besteht. head tail x : xs Der Typ einer Liste, die Elemente des Typs t enthält, wird mit [t] bezeichnet.

39 Beispiele: Ausdrücke mit Listen Ausdruck Datentyp [1, 2, 3] :: [Integer] 1: [0,3,7] :: [Integer] [ [0.3, 0.0], [] ] :: [[Double]] 'a' : "Hello" :: [Char] [( 3, 0 ), ( 2, 1)] :: [ (Integer, Integer) ] [ True, True, False ] :: [ Bool ] Allgemeine Syntax: [ e 1, e 2, e 3,,e n ] Syntaktische Abkürzung: e 1 :[e 2 :[e 3 : :e n :[]]] e 1 :e 2 : :e n :[]

40 Ausdrücke mit Listen Beispiele: equiv. [1, 2, 3] 1:[2, 3] 1 : 2 : 3 : [] "hello" ['h', 'e', 'l', 'l', 'o'] 'h' : "ello" [( 3, 0 ), ( 2, 1)] ( 3, 0 ) : [( 2, 1)] [[3, 0 ], [2, 1]] [3, 0] : [2, 1] : []

41 Funktionen mit Listen kopf :: [ Integer ] -> Integer kopf (x:xs) = x kopf [] = error "ERROR: empty list" rumpf :: [ Integer ] -> [ Integer ] rumpf (x:xs) = xs rumpf [] = error "ERROR: empty list"

42 Funktionen mit Listen Addiert alle Zahlen innerhalb einer Liste summe :: [Integer] -> Integer summe ls = if ls == [] then 0 else ( kopf ls ) + summe (rumpf ls) Lösung mit Pattern-Matching über der Listenstruktur summe :: [Integer] -> Integer summe [] = 0 summe (x : xs) = x + summe xs

43 Funktionsdefinitionen mit Listen multlist :: [Integer] -> Integer multlist [] = error "the function is not defined for []" multlist [x] = x multlist (x:xs) = x * multlist xs laenge :: [Int] -> Int laenge [] = 0 laenge (x:xs) = 1 + laenge xs

44 Zehnersystem Binärsystem div 2 = mod dec2bin :: Int -> [Int] dec2bin n n<2 = [n] otherwise = dec2bin (n`div`2) ++ [n `mod`2]

45 Funktionen mit Listen Verkettungsoperator drehe [] = [] drehe (x:xs) = drehe xs ++ [x] drehe [1,2,3] drehe [2,3] ++ [1] drehe [3] ++ [2] ++ [1] drehe [] ++ [3] ++ [2] ++ [1] [] ++ [3] ++ [2] ++ [1]

46 Funktionen mit Listen = 1* * * * * *2 0 = 2(2(2(2(2(1)+0)+1)+1)+0)+1 binary2decimal xs = bin2dec ( drehe xs) bin2dec :: [Int] -> Int bin2dec [] = 0 bin2dec (x:xs) = x + 2*(bin2dec xs)

47 Funktionen mit Listen bitxor :: [Int] -> [Int] -> [Int] bitxor [] [] = [] bitxor (x:xs) (y:ys) = (exoder x y): (bitxor xs ys) bitxor = error "the two lists are not of the same length" exoder :: Int -> Int -> Int exoder x y x==y = 0 otherwise = 1