WS 2011/2012. RobertGiegerich. November 12, 2013

Transkript

1 WS 2011/2012 Robert AG Praktische Informatik November 12, 2013

2 Haskell-Syntax: Ergänzungen Es gibt noch etwas bequeme Notation für Fallunterscheidungen, die wir bisher nicht benutzt haben. Bisher kennen wir: in Ausdrücken: if condition then ausdruck else ausdruck in Definitionen: Muster (pattern matching) in Gleichungen

3 Neue Fallunterscheidungen rechts... Pattern matching in Ausdrücken: Einfache Form 1 case expr of 2 pat1 - > expr1 3 pat2 - > expr2 4 pat3 - > expr Example 1 > endswith :: String - > String 2 > endswith xs = case ( reverse xs) of 3 > [] -> "no end at all!" 4 > a: as - > if A <= a && a <= Z then " capita 5 > else if a <= a && a <= z then " small 6 > else " not a letter."

4 Neue Fallunterscheidungen rechts... jetzt zusätzlich mit Wächtern: 1 case expr of 2 pat1 guard1 - > expr1 3 pat2 guard2 - > expr2 4 pat3 guard3 - > expr Example 1 > endswith :: String -> String 2 > endswith xs = case ( reverse xs) of 3 > [] -> "no end at all!" 4 > a: as A <= a && a <= Z - > " capital letter. 5 > a:as a <= a && a <= z -> " small letter." 6 > _ -> " not a letter."

5 ... und links: Wächter in Funktionsdefinitionen Bewachte Gleichungen 1 > fn pat1 pat > guard1 = expr1 3 > guard2 = expr2 4 >... syntaktische Zucker für Funktionsdefinitionen guards (Wächter) sind Ausdrücke (vom Typ Bool) sie ersetzen geschachtelte if-ausdrücke auf der rechten Seite Example 1 howmanyequal n m p 2 (n == m) && (m == p) = 3 3 (n == m) (m == p) (n == p) = 2 4 otherwise = 0

6 Felder: Datenstrukturen mit konstantem Zugriff Felder nennt man auch, Vektoren, Matrizen,... Konstanter Zugriff heisst: Zugriff auf Elemente mit Aufwand unabhängig von der Größe der Datenstruktur. Gegenbeispiel Musik: Finden der n-ten Note erfordert Durchlauf der Datenstruktur in n oder mehr Schritten. Allerdings: Die Noten sind nicht nummeriert. Besseres Gegenbeispiel: Listen hier sind die Elemente ab 0 nummeriert...

7 Zugriff auf Listenelemente Listen beherbergen viele Elemente gleichen Typs. Sequentielle Abarbeitung ist einfach und effizient, z.b. 1 map f [] = [] 2 map f ( x: xs) = f x : map f xs Random Zugriff auf einzelne Elemente durch operator!! hängt von der Listenlänge ab: 1 (x:xs)!! 0 = x 2 (x:xs)!! n = xs!!(n -1) Abhilfe schafft der Datentyp Array a b

8 Datentyp Array a b auf Deutsch Felder Modul Array stellt Datentyp Array a b und Funktionen darauf bereit a ist der Datentyp des Index, b der Elementtyp Operator! für element-zugriff bietet effizienten Random-Access Indextyp erlaubt mehrere Dimensionen Funktion array liefert ein Array zurück 1 a r r a y : : ( I x a ) => ( a, a ) > [ ( a, b ) ] > Array a b 2 3 t = a r r a y ( low, h i g h ) l i s t _ o f _ e n t r i e s =... 1 (!) :: (Ix a) => Array a b -> a -> b

9 Beispiel: 2D Array 1 > module Arr 2 > where 3 > import Array 4 5 > t a b l e : : Array ( Char, I n t ) I n t 6 > t a b l e = a r r a y ( ( a, 0 ), ( c, 2) ) 7 > [ ( ( a, 0 ), 0 ), 8 > ( ( a, 1 ), 1 ), 9 > ( ( a, 2 ), 2 ), 10 > ( ( b, 0 ), 3 ), 11 > ( ( b, 1 ), 4 ), 12 > ( ( c, 0 ), 6 ), 13 > ( ( c, 1 ), 7 ), 14 > ( ( b, 2 ), 5 ), 15 > ( ( c, 2 ), 8 ) 16 > ] > a c c e s s a b = t a b l e! ( a, b ) 19 > a c c e s s 2 = ( t a b l e! )

10 Alternative Example Pattern Matching als Alternative für read-only Felder vs. Feldgröße 1 access a 0 = 0 2 access a 1 = 1 3 access a 2 = 2 4 access b 1 =

11 Beispiel: Umwandlung String in Char Array 1 2 > s2a : : S t r i n g > Array I n t Char 3 > s2a xs = l i s t A r r a y ( 0, length xs 1) xs

12 Akkumulierende Manchmal kann man die Einträge eines Feldes nicht auf einmal ausrechnen. Dafür gibt es die Funktion 1 > accumarray :: Ix a = > 2 (b -> c -> b) -> b -> (a,a) -> [(a,c)] -> Array a b 3 4 akkumulierende Bereich Ergebnis 5 Fkt. Startwert Elemente Der Aufruf accumarray f s (lo,up) assocslist erlaubt fehlende wie mehrfache Auftreten des Indices in den Associations initialisiert alle Elemente mit dem Startwert s akkumuliert mehrfache Auftreten (i,x),...,(i,y),...,(i,z) in der Form (((s f x) f y) f z) in Element i

13 Akkumulierende Beispiel: Zählen der Buchstabenhäufigkeit in einem Text 1 > frq :: String - > Array Char Int 2 > frq t = accumarray (+) 0 ( A, z ) ( zip t ones ) 3 > where ones = 1: ones Damit z.b. 1 Arr > frq " abraham "! a Arr > frq " abraham "! U 4 0

14 Tabellierung von Funktionen 1 Gegeben eine Funktion, die aufwendig zu berechnen ist: 2 > s i d : : I n t > I n t 3 > s i d x = ( x +1) (x 1) (x 2) ( x+2)+(x round 3. 1 ) 1 Wenn die Werte (aus einem bekannten Intervall) immer wieder gebraucht werden, nimmt man eine interne Tabelle 2 > f i d : : I n t > I n t 3 > f i d = ( f! ) where 4 > f = a r r a y ( 0, ) 5 > [ ( x, ( x +1) ( x 1) (x 2) ( x+2)+(x round 3. 1 ) ) 6 > x < [ ] ] Das funktioniert schneller, aber nur über dem vorgesehenen Intervall.

15 Tabellierung von Funktionen 1 Tabellierung ist eine allgemeine Technik. Können wir eine Funktion tabulate schreiben, die andere Funktionen in tabellierte Funktionen verwandelt? Was wäre ihr Typ? 2 > t a b u l a t e : : ( Int, I n t ) > ( I n t > a ) > ( I n t > a ) Und was muss sie tun? Wir fordern x, f: (tabulate f) x = f x nur schneller! 1 > t a b u l a t e ( lo, up ) f = ( t! ) where 2 > t = a r r a y ( lo, up ) ( z i p domain (map f domain ) ) 3 > domain = [ l o.. up ]

16 Tabellierung von Funktionen 1 Damit nun einfach für beliebige Funktionen über einem Intervall, aber hier am Beispiel sid 2 > t i d : : I n t > I n t 3 > t i d = t a b u l a t e ( 1, ) s i d Betrachte die Anzahl der Rechenschritte bei mehrfachen Aufrufen von sid 42, fid 42, tid 42...

17 Primzahl natürliche Zahl > 1 nur teilbar durch 1 und sich selbst Erster Versuch: Hier ist direkt die Definition progammiert: Sieb des Eratosthenes 1 > primesslow : : I n t e g r a l a => [ a ] 2 > primesslow = [ n n < [ 2.. ], d i v i s o r s n == [ 1, n ] ] 3 > where 4 > d i v i s o r s : : I n t e g r a l a => a > [ a ] 5 > d i v i s o r s n = [ d d < [ 1.. n ], n mod d == 0 ]

18 Sieb des Eratosthenes Aus der Liste aller Zahlen werden sukzessive die Vielfachen der bereits gefundenen herausgesiebt... 1 > primes :: Integral a => [a] 2 > primes = sieve [ 2..] where Sieb des Eratosthenes 3 4 > sieve :: Integral a => [a] -> [a] 5 > sieve (a:xs) = a: sieve [n n<-xs, n mod a /= 0]

19 Spezifikation des Sortierproblems: genauer: per Vergleich Eingabe: Liste l Elemente vom Typ T T ist eine Instanz der Typklasse Ord Ausgabe: sortierte Liste r length l = length r für alle x l: length [ a a <- l, a == x] = length [ b b <- r, b == x] is_ordered l Insertion Sort Quicksort

20 Insertion Sort 1 > isort :: Ord a => [a] -> [a] 2 > isort [] = [] 3 > isort ( x: xs) = insert x ( isort xs) where 4 5 > insert x [] = [x] 6 > insert x (y:ys) 7 > x <= y = x:y:ys 8 > x > y = y:( insert x ys) Insertion Sort Quicksort

21 Quicksort Quicksort noch bekannt aus der ersten Vorlesung...? 1 > qsort :: Ord a => [a] -> [a] 2 > qsort [] = [] 3 > qsort (a:xs) = qsort [b b <- xs, b < a] ++ 4 > [a] ++ 5 > qsort [ b b <- xs, b >= a] Insertion Sort Quicksort

22 Zum Ende noch ein Rätsel Unsere Programm enthält die Definition 69 > xx = round 4.5 Wie berechnen xx zweimal und betrachten die Rechenschritte: 1 2 Arr > :s +s 3 Arr > xx ( 425 reductions, 844 cells ) Insertion Sort Quicksort 6 7 Arr > xx (20 reductions, 30 cells ) Wieso ist die zweite Berechnung schneller? Was ist überhaupt eine Reduktion?