Funktionale Programmierung ALP I. Algebraische Datentypen und Abstrakte Datentypen. SS 2013 Prof. Dr. Margarita Esponda. Prof. Dr.

Transkript

1 Funktionale Programmierung AP I Algebraische Datentypen und Abstrakte Datentypen SS 2013

2 Abstrakt Datentypen Beispiel: Algebraischen Datentypen für Bäume data SBTree = SBTree SBTree AP I: Margarita Esponda, 12. Vorlesung,

3 Abstrakt Datentypen Einfache binäre Bäume data SBTree = SBTree SBTree deriving Show type Depth = Integer gensbtree :: Depth -> SBTree gensbtree 0 = gensbtree (n+1) = (gensbtree n) (gensbtree n) Ein balancierter Baum mit der eingegebenen Tiefe wird erstellt. gensbtree 3 AP I: Margarita Esponda, 12. Vorlesung,

4 Abstrakt Datentypen Berechnung aller Knoten des Baumes nodes :: SBTree -> Integer nodes = 1 nodes ( leftt rightt) = 1 + nodes leftt + nodes rightt nodes (gensbtree 3) 15 AP I: Margarita Esponda, 12. Vorlesung,

5 Abstrakt Datentypen Tiefe des Baumes depth :: SBTree -> Integer depth = 0 depth ( lt rt) = (max (depth lt) (depth rt)) + 1 depth ( ( ) ) ( ) 3 AP I: Margarita Esponda, 12. Vorlesung,

6 Abstrakt Datentypen jointrees :: SBTree -> SBTree -> SBTree jointrees lefttree righttree = lefttree righttree jointrees leftt rightt leftt rightt leftt rightt leftt rightt AP I: Margarita Esponda, 12. Vorlesung,

7 Abstrakt Datentypen balanced :: SBTree -> Bool balanced = True balanced ( lt rt) = (balanced lt) && (balanced rt) && depth lt == depth rt balanciert balanciert nicht balanciert AP I: Margarita Esponda, 12. Vorlesung,

8 Abstrakt Datentypen Algebraischer Datentyp für Binäre Suchbäume Beispiel: data Tree = eaf Int ode Int Tree Tree il Die gespeicherte Information ist sortiert AP I: Margarita Esponda, 12. Vorlesung,

9 Algebraische Datentypen für Binäre Suchbäume Operationen für Binäre Suchbäume data BSTree a = il ode a (BSTree a) (BSTree a) deriving ( Show, Eq ) -- findet das kleinste Element smallest:: (Ord a) => BSTree a -> a smallest (ode x il _) = x smallest (ode x lefttree _) = smallest lefttree

10 Algebraische Datentypen für Binäre Suchbäume Algebraischer Datentyp für Binäre Suchbäume data BSTree a = il ode a (BSTree a) (BSTree a) deriving ( Show, Eq ) -- findet das größte Element biggest:: (Ord a) => BSTree a -> a biggest(ode x _ il) = x biggest(ode x _ righttree) = biggest righttree -- spiegelt einen Baum mirror:: (Ord a) => BSTree a -> BSTree a mirror il = il mirror (ode x xl xr) = ode x (mirror xr) (mirror xl)

11 Algebraische Datentypen für Binäre Suchbäume Traversierung binärer Bäume Baumtraversierung bedeutet, alle Knoten des Baumes in einer bestimmten Reihenfolge zu besuchen. Preorder: Inorder: Postorder: evelorder: Wurzel linker Unterbaum rechter Unterbaum linker Unterbaum - Wurzel rechter Unterbaum linker Unterbaum rechter Unterbaum - Wurzel von oben nach unten in jeder Ebene von links nach rechts AP I: Margarita Esponda, 12. Vorlesung,

12 Traversierung binärer Bäume Inorder inker Unterbaum - Wurzel - Rechter Unterbaum F D I B E G J A C H A B C D E F G H I J AP I: Margarita Esponda, 12. Vorlesung,

13 Algebraische Datentypen für Binäre Suchbäume Traversierung von Binärbäumen -- verwandelt einen sortierten Baum in eine sortierte iste inorder :: (Ord a) => BSTree a -> [a] inorder il = [] inorder (ode x ltree rtree) = inorder ltree ++ x : inorder rtree

14 Algebraische Datentypen -- verwandelt einen Baum in eine iste preorder :: (Ord a) => BSTree a -> [a] preorder il = [] preorder (ode x ltree rtree) = x : preorder ltree ++ preorder rtree F D I B E G J A C H F D B A C E I G H J

15 Binärbäume Binärbäume einfachste Baumstrukturen ausgeglichene Bäume Beispiele: AV-Bäume Red-Black-Bäume B-Bäume usw. Die wichtigste Voraussetzung für die effiziente Verwaltung von Datenmengen mit Hilfe von Bäumen ist, dass die Bäume balanciert sind. AP I: Margarita Esponda, 12. Vorlesung,

16 Algebraische Datentypen Suchen il il il il il il il il il il il il il il search :: (Ord a) => a -> BSTree a -> Bool search _ il = False search k (ode x ltree rtree) k==x = True k<x = search k ltree otherwise = search k rtree

17 Algebraische Datentypen 6 11 Einfügen il il 16 il il 7 19 il il il il il il il il 16 il il il il il 6 il il il il

18 Algebraische Datentypen Einfügen insert :: (Ord a) => a -> BSTree a -> BSTree a insert a il = ode a il il insert a (ode x ltree rtree) a<x = ode x (insert a ltree) rtree otherwise = ode x ltree (insert a rtree)

19 Algebraische Datentypen Minimum Minimum und Maximum Maximum Der erste Knoten, der keine linken Kinder mehr hat, beinhaltet das kleinste Element. -- findet das kleinste Element smallest (ode x il _) = x smallest (ode x lefttree _) = smallest lefttree -- findet das größte Element biggest(ode x _ il) = x biggest(ode x _ righttree) = biggest righttree

20 Algebraische Datentypen öschen mit "Brute force" list2tree [] = il list2tree (x:xs) = insert x (list2tree xs) remove _ [] = [] remove y (x:xs) y==x = xs otherwise = x:(remove y xs) delete a il = il delete a tree = list2tree(remove a (preorder tree))

21 Algebraische Datentypen achfolger 1. Fall 53 Es gibt einen rechten Unterbaum Minimum

22 Algebraische Datentypen 2. Fall achfolger Es gibt keinen rechten Unterbaum Maximum 39 Wie können wir nach oben laufen?

23 Algebraische Datentypen Delete-Operation ( öschen ) 1. Fall öschen eines Knotens ohne Kinder 2. Fall öschen eines Knotens mit nur einem Kind il

24 Algebraische Datentypen 3. Fall öschen öschen eines Knotens mit zwei Kindern Der Knoten, den man löschen möchte, wird durch seinen achfolger ersetzt Der achfolger von 27 ist das Minimum des rechten Unterbaumes. Das Minimum ist entweder ein Blatt oder hat maximal ein rechtes Kind.

25 Algebraische Datentypen öschen öschen eines Knotens mit zwei Kindern Wir brauchen eine join-funktion, die aus zwei Kinder- Bäumen einen baut join

26 Algebraische Datentypen öschen etwas besser delete :: (Ord a) => a-> BSTree a-> BSTree a delete x il = il delete x (ode y ltree rtree) x < y = ode y (delete x ltree) rtree x == y = join ltree rtree x > y = ode y ltree (delete x rtree)

27 Algebraische Datentypen Join-Funktion join :: (Ord a) => BSTree a-> BSTree a-> BSTree a join xtree il = xtree join xtree ytree = ode e xtree ntree where (e, ntree) = splitmin ytree -- splitmin :: BSTree a -> (a, BSTree a) splitmin (ode x il tree) = (x, tree) splitmin (ode x ltree rtree) = (f, ode x ntree rtree) where (f, ntree) = splitmin ltree

28 Algebraische Datentypen Probleme mit einfachen binären Suchbäumen nicht balancierter Binärbaum balancierter Binärbaum

29 Algebraische Datentypen Algebraische Datentypen -- für arithmetische Ausdrücke data Expr = it Int Add Expr Expr Sub Expr Expr Mult Expr Expr eval :: Expr -> Int eval (it n) = n eval (Add x y) = eval x + eval y eval (Sub x y) = eval x - eval y eval (Mult x y) = eval x * eval y eval (Mult (Add (it 3) (it 4)) (it 3)) => 21

30 Funktionale Programmierung Haskell Typsystem Monomorphe Funktionen Der Datentyp wird genau durch die Signatur bestimmt Beispiel: asciicode :: Char -> Int Polymorphe Funktionen Typvariablen in der Signatur lassen beliebige Datentypen zu Beispiel: length :: [a] -> [a]

31 Funktionale Programmierung Einschränkung von Typen Mit Hilfe von vordefinierten Typ-Klassen können polymorphe Funktionen mit Einschränkung definiert werden Verwendung eines Kontextes Beispiel: equalist :: Eq a => [a]->[a]->bool nur für Datentypen mit Gleichheitsoperator add2ist:: um a => [a] -> a -> [a] add2ist xs y = map (+y) xs nur numerische Typen mit definierten arithmetischen Operationen

32 Funktionale Programmierung Einige vordefinierte Typ-Klassen Klassenname Eigenschaften Funktionen Show, Read anzeigbar oder lesbar (a String), (String a) show, read Eq vergleichbar (==), (/=) Ord sortierbar compare, (<), (>), (<=), (>=), min, max,.. Enum aufzählbar succ, pred, [..] um allgemeine Zahlen (+), (-), (*), negate, abs Integral ganzzahlig mod, div, quot, rem Fractional Kehrwert-Funktion (/), recip,...

33 Funktionale Programmierung Typ-Anpassung In Haskell ist Typ-Anpassung für numerische Werte wie in anderen Programmiersprachen nicht erlaubt. Beispiel: mod Fehler: <interactive>:1:10: Ambiguous type variable `t' in the constraints: `Fractional t' arising from the literal `1.5' at <interactive>:1:10-12 `Integral t' arising from a use of `mod' at <interactive>:1:0-6 Probable fix: add a type signature that fixes these type variable(s) Explizites Type-Casting muss stattfinden fromintegral (mod 3 2) + 1.5

34 Funktionale Programmierung Typ-Klassen Typen werden durch die Operationen, die auf ihren Werten definiert werden sollen, beschrieben. Class um a where (+) :: a -> a -> a (*) :: a -> a -> a (-) :: a -> a -> a... Typklassen sind abstrakte Schnittstellen, weil keine Implementierung vorgegeben wird.

35 Funktionale Programmierung Instanzen von Typ-Klassen Mit einer Instanz-Deklaration definieren wir, welche Typen zu welchen Typ-Klassen gehören. instance um Int Vordefinierte primitive Funktionen where x+y = primadd x y neg x = primegateint x... instance Eq Char where x == y = ord x == ord y

36 Funktionale Programmierung Instanzen von Typ-Klassen Der Instanz-Typ einer Klasse muss die vorgeschriebenen Operationen einer Typ-Klasse implementieren. Implementierung: instance (Eq a) => Eq [a] where (==) [] [] = True (==) [] (x:xs) = False (==) (x:ys) [] = False (==) (x:xs) (y:ys) = x == y && xs == ys

37 Funktionale Programmierung Instanzen von Typ-Klassen data Menge a = Menge [a] instance (Eq a) => Eq (Menge a) where Menge xs == Menge ys = subset xs ys && subset ys xs subset :: Eq a => a -> a -> Bool subset xs ys = all ( elem ys) xs instance (Ord a) => Ord (Menge a) where Menge xs <= Menge ys = subset xs ys...

38 Funktionale Programmierung Subklassen Klassen dürfen andere Klassen umfassen class (Eq a, Show a) => um a where (+), (-), (*) :: a -> a -> a negate :: a -> a abs, signum :: a -> a frominteger :: Integer -> a -- Minimal complete definition: -- All, except negate or (-) x - y = x + negate y -- Default-Definitionen negate x = 0 - x

39 Funktionale Programmierung Mehrere Oberklassen class Enum a where fromenum :: a -> Int toenum :: Int -> a... class um a where (+) :: a -> a -> a neg :: a -> a... Integral erbt die Operationen von Enum und um und fügt noch weitere Operationen class (Enum a, um a) => Integral a where hinzu. Ausprägungen von quot, rem, div, mod :: a -> a -> a Integral müssen folglich auch quotrem, divmod :: a -> a -> (a, a) Ausprägungen von Enum und even, odd :: a -> Bool um sein. tointeger :: a -> Integer toint :: a -> Int

40 Funktionale Programmierung Klassenhierarchie Eq Show Ord um Enum Real Fractional Integral Floating

41 Algebraische Datentypen Standard Klassenhierarchie Prelude AP I: Margarita Esponda, 12. Vorlesung,

42 Funktionale Programmierung Abstrakte Datentypen Konkrete Datentypen konkrete Darstellung der Information innerhalb einer Sprache isten, Bäume usw. Datentypen Abstrakte Datentypen definiert durch die Operationen unabhängig von einer konkreten Darstellung des Datentyps.

43 Funktionale Programmierung Abstrakte Datentypen - sind Datentypen, die durch die auf ihren Werten erlaubten Operationen definiert sind und dessen Implementierung den utzern des Typs verborgen (Datenkapselung) ist - in Haskell werden abstrakte Datentypen mit Hilfe des Modul-Konzepts implementiert

44 Funktionale Programmierung Module in Haskell Ein Haskell-Modul ist eine Datei mit folgender Struktur: module <ame> (<Exportliste>) where ur die Datentypen und Funktionen, die in <Exportliste> angegeben werden, sind nach außen sichtbar. Wenn <Exportliste> weggelassen wird, sind alle Definitionen automatisch nach außen sichtbar.

45 Funktionale Programmierung Module in Haskell module Stapel (Stapel, push, pop, top, createstack, isempty, show) where createstack :: Stapel a isempty :: Stapel a -> Bool push :: a-> Stapel a -> Stapel a pop :: Stapel a -> Stapel a top :: Stapel a -> a data Stapel a = Empty S a (Stapel a)...

46 Funktionale Programmierung module Stapel createstack = Empty isempty Empty = True isempty _ = False Module in Haskell push x s = S x s pop Empty = error "pop from an empty stack..." pop (S _ s) = s top Empty = error "top from an empty stack..." top (S x _) = x

47 Algebraische Datentypen Abstrakte Datentyp für Mengen module Menge (Menge, emptyset, isempty, inset, insertset, list2set, subset, (\\), ( ), (&&&), powerset ) where data Menge a = Menge [a] instance Eq a => Eq (Menge a) where (==) s1 s2 = subset set1 set2 && subset s2 s1 instance (Show a) => Show (Menge a) where... AP I: Margarita Esponda, 12. Vorlesung,

48 Algebraische Datentypen Abstrakte Datentyp für Mengen module Menge.... emptyset :: (Menge [Int]) isempty :: Eq a => Menge a -> Bool inset :: Eq a => a -> Menge a -> Bool ( ) :: Eq a => Menge a -> Menge a -> Menge a (\\) :: Eq a => Menge a -> Menge a -> Menge a (&&&) :: Eq a => Menge a -> Menge a -> Menge a subset :: Eq a => Menge a -> Menge a -> Bool powerset :: Eq a => Menge a -> Menge (Menge a) AP I: Margarita Esponda, 12. Vorlesung,

49 Algebraische Datentypen Abstrakte Datentyp für Mengen module Menge.... emptyset = Menge [] isempty (Menge []) = True isempty _ = False inset x (Menge ys) = elem x ys AP I: Margarita Esponda, 12. Vorlesung,

50 Algebraische Datentypen Abstrakte Datentyp für Mengen module Menge Vereinigung von zwei Mengen ( ) (Menge (x:xs)) m = insertset x ((Menge xs) m) ( ) (Menge []) m = m -- Differenzmenge (\\) (Menge xs) m = Menge [x x<-xs, not(inset x m)] -- Schnittmenge (&&&) (Menge xs) m = Menge [x x<-xs, (inset x m)] AP I: Margarita Esponda, 12. Vorlesung,

51 Algebraische Datentypen Abstrakte Datentyp für Mengen module Menge.... subset (Menge []) _ = True subset _ (Menge []) = False subset (Menge (x:xs)) m = (inset x m) && (subset (Menge xs) m) powerset (Menge xs) = Menge powermenge where powermenge = map Menge (powerist xs) powerist :: [a] -> [[a]] powerist [] = [[]] powerist (x:xs) = (powerist xs) ++ (map (x:) (powerist xs)) AP I: Margarita Esponda, 12. Vorlesung,