Haskell und Python. pures Programmieren, Auswerten von Ausdrücken rekursives Programmieren, Typsystem. Python: Eine prozedurale Programmiersprache

Transkript

1 Haskell und Python Haskell: Eine funktionale Programmiersprache funktional, nicht-strikt, hat ein polymorphes und starkes Typsystem, flexible Datenstrukturen, gute Abstraktionseigenschaften, Ziele: pures Programmieren, Auswerten von Ausdrücken rekursives Programmieren, Typsystem Python: Eine prozedurale Programmiersprache prozedural; schwaches, dynamisches Typsystem, flexible Datenstrukturen, Objektorientierung. Ziele: Demonstration imperativer und prozeduraler Konzepte, Vergleich von Konzepten P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 1

2 Interpreter / Compiler Interpreter Compiler (Übersetzer) Ablaufumgebung führt ein Programm aus, (bzw. wertet ein Programm aus), Grundlage: Text des Programms Jeder Programmbefehl wird einzeln eingelesen und dann ausgeführt. erzeugt aus Programm einen ausführbaren Modul. Programmumstellungen, Optimierungen Effekt des Programms muss gleich bleiben. Hier erfolgt die Ausführung des Moduls Es gibt Zwischenformen P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 2

3 Laufzeit / Compilezeit Compilezeit: Laufzeit: Zeitraum der Analyse bzw. Übersetzung des Programms statische Typüberprüfung, Optimierung. Zeitraum der Ausführung des Programms Z.B. dynamische Typüberprüfung, Ein-Ausgabe. P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 3

4 Programmiersprachen: wesentliche Merkmale imperativ Programm ist Folge von Befehlen sukzessive Änderung des Speicherinhalts Ergebnis: letzter Zustand Ein imperatives Programm sagt präzise: was (welche Anweisung), wann (Reihenfolge der Anweisungen) womit (Speicherplatz/Variable) zu geschehen hat. prozedural: Strukturierung in (imperativen) Programmiersprachen Prozedur = Unterprogramm Aufruf mit Argumenten im Programm Ziel: Übersichtlichkeit; Wiederverwendbarkeit P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 4

5 Programmiersprachen: Merkmale (2) funktional: Programm strukturiert in Funktionsdefinitionen Ausdrücke = Anwendung von Funktionen auf Argumente Berechnung = Auswertung von Ausdrücken Varianten von funktionalen Programmiersprachen: nicht-strikt: Argumente werden so spät wie möglich ausgewertet strikt: Argumente werden vor Funktionsaufruf ausgewertet pur: Objekte haben nur einen Wert, keine Mutation nicht-pur: Objekte können verändert werden, Seiteneffekte möglich deklarativ: Idealfall: Spezifikation = deklaratives Programm Betonung auf Logik, weniger algorithmisch Beispiele: logische Programmierung, Prolog P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 5

6 Programmiersprachen: Merkmale (3) objektorientiert: Verwendung in imperativen Programmiersprachen Strukturierung des Programm in Klassen. Ziel: Übersichtlichkeit, Wiederverwendung Ausführung eines Programms: Erzeugung von Objekten Austausch von Nachrichten zwischen Objekten typisiert Alle Programmiersprachen haben Typisierung statische Typisierung: Programmtext dynamische Typisierung: Ausführungszeit des Programms schwache Typisierung: Typfehler zur Laufzeit sind möglich starke Typisierung: Typfehler zur Laufzeit sind nicht möglich P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 6

7 Haskell Wichtige Eigenschaften funktionaler Programmiersprachen Referentielle Transparenz Gleiche Funktion, gleiche Argumente = gleicher Wert Keine Seiteneffekte! Verzögerte Auswertung Nur die für das Resultat notwendigen Unterausdrücke werden (so spät wie möglich) ausgewertet. Polymorphes Typsystem Nur Ausdrücke mit Typ sind erlaubt es gibt Typvariablen. Das Typsystem garantiert: keine dynamischen Typfehler. Automatische Speicherverwaltung Anforderung und Freigabe von Speicher Funktionen sind Datenobjekte mögliche Verwendung: in Datenobjekten, als Argument, als Resultat. P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 7

8 Programmierung in Haskell Interpreter Hugs 98 und GHCi Grundprinzipien: Definition von Funktionen quadrat x = x*x Aufbau von Ausdrücken: Anwendung der Funktion auf Argumente, die wieder Ausdrücke sein können. 3*(quadrat 5) Nur der Wert von Ausdrücken wird bei der Auswertung zurückgegeben. 75 P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 8

9 Umgang mit dem Interpreter Aufruf: ghci (im richtigen Fenster) Online-Report >:h Hilfe >:t Ausdruck druckt den Typ des Ausdrucks >:set +t... Optionen ändern Module im Interpreter verwenden: :m +Char +Numeric... P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 9

10 Einfache Daten und Operatoren ganze Zahlen Typ Int mit n = beliebig lange ganze Zahlen (vom Typ Integer), rationale Zahlen 3%7 (Rational) Gleitkommazahlen 3.456e+10 (Float) Zeichen a Char Datenkonstruktoren True, False; Typ Bool Arithmetische Operatoren: +,,, /, Arithmetische Vergleiche: ==, <=, <... Logische Operatoren: &&,, not P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 10

11 Beispiel Definition eines Polynoms x 2 + y 2 : quadratsumme x y = quadrat x + quadrat y Auswertung:... Main> quadratsumme P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 11

12 Typen in Haskell Typ Konstanten, Funktionen Int 1,2,3,4,... Integer 1,2,3,4,... Float 1.23e45 Double 1.23e45 Integer -> Integer -> Integer (+) Integer -> Integer quadrat Integer -> Integer -> Integer quadratsumme P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 12

13 Typen in Haskell Beispiel Die Ausgabe des Interpreters für die Addition (+) ist komplizierter: (+) :: forall a. (Num a) => a -> a -> a D.h.: Für alle Typen a, die man als numerisch klassifiziert hat, d.h. die in der Typklasse Num sind, hat (+) den Typ a -> a -> a Z.B. gilt: (+)::Integer -> Integer -> Integer (+)::Double -> Double -> Double P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 13

14 (vereinfachte) Haskell-Syntax FunktionsDefinition ::= Funktionsname Parameter = Ausdruck Ausdruck ::= Bezeichner Zahl ( Ausdruck Ausdruck ) ( Ausdruck ) ( Ausdruck BinInfixOp Ausdruck ) Bezeichner ::= Funktionsname Datenkonstruktorname Parameter BinInfixOp BinInfixOp ::= + / Argumente einer Funktion: Anzahl der Argumente: formale Parameter. Stelligkeit der Funktion: (ar(f)) P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 14

15 Beispiel zur Grammatik quadratsumme x y = (quadrat x) + (quadrat y) quadratsumme Funktionsname x,y formale Parameter = gleiches Zeichen wie in Grammatik (quadrat x) + (quadrat y) Ausdruck der Form Ausdruck + Ausdruck + binärer Infix-Operator quadrat x Anwendung: quadrat ist ein Ausdruck und x ist ein Ausdruck P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 15

16 Haskell: Verschiedenes... Prelude: vordefinierte Funktionen, Typen und Datenkonstruktoren Präfix, Infix, Prioritäten ist möglich für Operatoren Konventionen zur Klammerung: s 1 s 2... s n ((... (s 1 s 2 ) s 3...) s n ) Kontextbedingungen in Funktionsdefinitionen: formale Parameter müssen verschiedenen sein; Keine undefinierten Variablen im Rumpf! Weitere Trennzeichen: {, } Semikolon ; Layout-sensibel: bewirkt Klammerung mit {, }. P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 16

17 Fallunterscheidung Syntax: if Ausdruck then Ausdruck else Ausdruck if, then, else sind reservierte (Schlüsselworte) und dürfen nicht als Funktionsnamen bzw. Parameternamen verwendet werden. Der erste Ausdruck ist eine Bedingung. Diese muss Typ Bool haben. Typisierung: if Bool... then typ else typ (if 1 then 1 else 2) ergibt einen Fehler P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 17

18 Bedingungen, Arithmetische Vergleiche Die Infixoperatoren ==, <, >, <=, >=, /= haben den Typ: Integer -> Integer -> Bool Achtung: = ist reserviert für Funktionsdefinitionen, und let Boolesche Ausdrücke sind kombinierbar mit not,, && (nicht, oder, und) Konstanten sind True, False. Eine kompliziertere Bedingung: 3.0 <= x && x < 5.0 P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 18

19 Darstellungen eines Programms Benutzer-Syntax: vom Programmierer benutzt Interne Syntax: Linearisierung ; entzuckerte Version; voll geklammert; alle Operatoren sind Präfix; kein Layout Ableitungsbaum (Herleitungsbaum): Vom Kompiler erzeugt Syntaxbaum: Eindeutige Darstellung des Programms in einem markierten Baum. Hierauf lässt sich eindeutig die Ausführung des Programms definieren. P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 19

20 Syntaxbaum: Beispiele if x <= 0 then 1 else x*(quadrat (x-1)) ifthenelse <= 1 x 0 x app quadrat x 1 P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 20

21 Syntaxbaum: Beispiele Zwei Syntaxbäume zu 1*2: 1 2 app app 2 1 P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 21

22 Aufrufhierarchie und Rekursive Definitionen f, g, f i seien Haskell-definierte Funktionen. f referenziert g direkt, f referenziert g (indirekt), f ist direkt rekursiv, f ist rekursiv, Verschränkte Rekursion: wenn g im Rumpf von f vorkommt. wenn es Funktionen f 1,..., f n gibt, so dass gilt: f referenziert direkt f 1, f 1 referenziert direkt f 2,..., f n referenziert direkt g. wenn f sich selbst direkt referenziert. wenn f sich selbst (indirekt) referenziert. wenn f die Funktion g referenziert und g die Funktion f auch für allgemeinere Fälle P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 22

23 Beispiel: Aufrufhierarchie quadrat x = x*x quadratsumme x y = (quadrat x) + (quadrat y) quadratsumme ruft direkt die Funktion quadrat auf, quadratsumme ruft direkt die (eingebaute) Funktion auf Die Funktion quadratsumme ist somit nicht rekursiv P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 23

24 Beispiel: Fakultät 0! := 1 n! := n (n 1)! n! ist die Anzahl aller Permutationen einer n-elementigen Menge. rekursive Definition: fakultaet:: Integer -> Integer fakultaet x = if x <= 0 then 1 else x*(fakultaet (x-1)) Diese Funktion ist rekursiv, da sie im Rumpf sich selbst wieder aufruft. P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 24

25 Entwurf rekursiver Funktionen Wichtig: zwei Fälle sind zu beachten den Basisfall: den Rekursionsfall: Ergebnis: 0 wenn das Argument x 1 ist. Ergebnis: x*(fakultaet (x-1)), wenn x > 1 ist. Terminierung bei rekursiven Aufrufen : Argumente werden mit jedem rekursiven Aufruf kleiner fakultaet x ruft fakultaet (x-1) auf für x 1. Der Basisfall hat das kleinste Argument Es funktioniert: Main> fakultaet 3 6 Main> fakultaet P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 25

26 Eine falsche Definition fakultaet_nt:: Integer -> Integer fakultaet_nt x = if x == 0 then 1 else x*(fakultaet_nt (x-1)) Diese Funktion terminiert nicht bei negativen Eingaben: fakultaet_nt (-5) ruft fakultaet_nt (-6) auf usw. Für weitere Definitionen von n!, siehe: P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 26

27 Beispiel: Berechnung von Schaltjahren Tropisches Jahr = Tage. Gregorianischen Kalender: Schaltjahre mit 366 Tagen als Korrektur Ein Jahr ist ein Schaltjahr, wenn es durch 4 teilbar ist, aber nicht durch 100. Jahre die durch 400 teilbar sind, sind wieder Schaltjahre. ist_ein_schaltjahr n = if n > 1582 then n mod 400 == 0 (n mod 4 == 0 && n mod 100 /= 0) else error "Jahreszahl vor Einfuehrung des Gregorianischen Kalenders" P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 27

28 Beispiel: nächstes Schaltjahr Ermittlung des nächsten Schaltjahres mit j n: naechstes_schaltjahr n = if (ist_ein_schaltjahr n) then n else naechstes_schaltjahr (n+1) *Main> naechstes_schaltjahr *Main> naechstes_schaltjahr *Main> P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 28

29 Schaltjahre: Orthodox Der orthodoxe Kalender hat bei den durch 100 teilbaren Jahreszahlen eine andere Definition der Schaltjahre: ist_ein_schaltjahr_ortho n = if n > 1582 then (n mod 100 == 0 && (n mod 900 == 200 n mod 900 == 600)) (n mod 4 == 0 && n mod 100 /= 0) else error "Jahreszahl vor Einfuehrung" P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 29

30 Mittlere Jahreslängen mittlere_jahreslaenge::double mittlere_jahreslaenge = mittlere_jahreslaenge_gregor = (mittlere_jahreslaenge_sum ) / mittlere_jahreslaenge_sum von bis summe = if von > bis then summe else if ist_ein_schaltjahr von then mittlere_jahreslaenge_sum (von+1) bis (summe + 366) else mittlere_jahreslaenge_sum (von+1) bis (summe + 365) mittlere_jahreslaenge_ortho::double mittlere_jahreslaenge_ortho = (mittlere_jahreslaenge_ortho_sum ) / mittlere_jahreslaenge_ortho_sum von bis summe = if von > bis then summe else if ist_ein_schaltjahr_ortho von then mittlere_jahreslaenge_ortho_sum (von+1) bis (summe + 366) else mittlere_jahreslaenge_ortho_sum (von+1) bis (summe + 365) P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 30

31 Unterschied Gregorianisch und Orthodox schaltjahr_anders n = if ist_ein_schaltjahr n == ist_ein_schaltjahr_ortho n then schaltjahr_anders (n+1) else n Welches Jahr ist das erste unterschiedliche nach 2004? P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 31

32 Problemanalyse und funktionale Abstraktion Zunächst: Algorithmen auf Zahlen Problemanalyse und Erstellung eines Algorithmus: Zerlegung in (einfachere) Teilprobleme Lösen der Teilprobleme mittels Unterfunktionen Zusammensetzen des Algorithmus Wichtig: was die Funktion leistet, d.h. welche Abbildung wird definiert. sekundär: wie die Funktion realisiert wird. Zentrale Leitideen beim Entwurf sind: Korrektheit Modularität Effizienz P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 32

33 Beispiel: Wurzel aus x mit dem Newtonschen Iterationsverfahren Spezifikation: x := y wobei y 2 = x und y 0 Newton-Verfahren (Heron-Verfahren) zur Näherung von x: Starte mit Schätzwert s für die Wurzel x Iteriere: s 0.5(s + x s ) bis alter und neuer Schätzwert keine große Differenz mehr aufweisen. P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 33

34 Beispiel Wurzelberechnung in Haskell wurzel x = wurzeliter 1.0 x wurzeliter schaetzwert x = if gutgenug schaetzwert x then schaetzwert else wurzeliter (verbessern schaetzwert x) x quadrat x = x*x gutgenug:: Double -> Double -> Bool gutgenug schaetzwert x = abs(((quadrat schaetzwert) - x) / x) < mittelwert:: Double -> Double -> Double mittelwert x y = (x + y) / 2.0 verbessern schaetzwert x = mittelwert schaetzwert (x / schaetzwert) *Main> wurzel *Main> P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 34

35 Semantik von Programmiersprachen Semantik = Bedeutung eines Programms (Programmtextes) ausgehend vom Syntaxbaum des Programms. Methoden der Semantik-Definition: Operationale Semantik Denotationale Semantik Transformations-Semantik logische Semantik P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 35

36 Operationale Semantik Spezifikation von Wirkung und Ablauf: Zustand: Speicherbelegung als Datenstruktur oder... Pro Programmkonstrukt: Angabe des Zustandsübergangs Haskell: Zustand = Ausdruck Übergange: sind Reduktionen, d.h. Änderungen der Ausdrücke. Python: Zustand = Umgebung Übergange: Veränderungen des Speicherinhalts. operationale Semantik = Spezifikation eines Interpreters Vorteil: Prinzipiell immer durchführbar P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 36

37 Zuordnung: Domain D: Denotationale Semantik Programm Funktion Menge der möglichen Funktionen und Objekte Pro Programmkonstrukt: rekursive Angabe der Konstruktion einer Funktion in D. Hürden: Mathematisches Vorwissen notwendig Domainkonstruktion kann schwierig sein P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 37

38 Transformations-Semantik Vorgehen zur Definition der Semantik eines Programms P : Semantik bereits für eine Untermenge der Programme erklärt Transformiere P... P Nehme die Semantik von P. Verwendung: Semantik einer vollen Programmiersprache erklärt durch: Semantik der Kernsprache Transformation: volle Sprache Kernsprache. Semantik von Haskell ist teilweise eine Transformationssemantik Vorteile: Vereinfacht Semantik-Definition Analog zur Arbeitsweise von Compilern P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 38

39 Logische Semantik Beschreibung der Programmkonstrukte und Eigenschaften von Programmen mittels logischer Axiome Herleiten von Programmeigenschaften durch logisches Schließen Z.B. in Prädikatenlogik: Für alle Eingaben n von natürlichen Zahlen liefert quadrat n das Ergebnis n 2. Als Formel: n : quadrat(n) = n 2 P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 39

40 Auswertung von einfachen Haskell-Programmen: Ziel: operationale Semantik von Haskell Vorteile einer operationalen Semantik: formal saubere Definition der Auswertung auch für Funktionen höherer Ordnung Unabhängigkeit von Compilern Unabhängigkeit vom Rechnertyp (Portabilität) P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 40

41 Einfache Haskell-Programme Definition: Basiswert ist entweder eine Zahl, Zeichen oder True,False. Einfache Haskell-Programme: dürfen benutzen: Basiswerte und entsprechende vordefinierte Operatoren Funktionsdefinitionen if-then-else Anwendung von Funktionen auf Argumente P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 41

42 Einfache Haskell-Programme (2) Definition: Ein (einfaches) Haskell-Programm besteht aus: Menge von Funktionsdefinitionen; entsprechend obiger Beschränkungen Ausdruck (main) vom Typ eines Basiswertes. Wert des Programms = Wert von main Beispiel quadrat x = x * x kubik x = x * x * x w = 2 main = if w >= 0 then quadrat w else kubik w P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 42

43 Berechnung und Auswertung Prinzip der Berechnung für einfache Haskell-Programme Auswertung = Folge von Transformationen von main bis ein Basiswert erreicht ist main t 1 t 2... t n... Es gibt drei Fälle: 1. Die Folge endet mit einem Basiswert 2. Die Folge endet, aber nicht mit einem Basiswert 3. Die Folge endet nicht Bei 2. und 3.: Wert undefiniert. P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 43

44 Berechnung und Auswertung: Notation P [t] Bedeutung: P [ ] ist ein Ausdruck P mit Platzhalter [ ] P [t] bedeutet den Ausdruck P mit t anstelle des Platzhalters Beispiel: P [ ] if s then [.] else 2, P [t] if s then t else 2. P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 44

45 Auswertung Einfache Haskell-Programm haben drei verschiedene Arten von Auswertungsschritten 1. Definitionseinsetzung (δ-reduktion) 2. Arithmetische Auswertung 3. Auswertung von Fallunterscheidungen P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 45

46 Definitionseinsetzung (δ-reduktion) Auswerten einer Anwendung von f auf n Argumente: P [(f t 1... t n )] P [(Rumpf f [t 1 /x 1,... t n /x n ])] Bedingungen: Die Definition von f ist: f x 1... x n = Rumpf f P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 46

47 Definitionseinsetzung (Rumpf f [t 1 /x 1,... t n /x n ]) entsteht durch (paralleles bzw. unabhängiges) Ersetzen von x i durch t i. t i kann ein Ausdruck sein; es muss kein Basiswert sein! P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 47

48 Einschub: Metanotation In Lehrbüchern, Skripten, Artikeln über Programmiersprachen, Logik usw.: Mischung von konkreter Syntax und Meta-Notation. Beispiele konkrete Syntax: Meta-Notation: die Funktion fakultaet... Sei f eine Funktion in Programm..., P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 48

49 Einschub: Metanotation: Beispiel Notation bei Definitionseinsetzungsregel : (Rumpf f [t 1 /x 1,... t n /x n ]) Hierbei sind alles Metavariablen: f Rumpf f t 1,..., t n x 1,..., x n steht für eine Funktion steht für den Rumpf dieser Funktion stehen für Ausdrücke: die Argumente stehen für die formalen Parameter der Funktion P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 49

50 Einschub: Metanotation: Beispiel gutgenug schaetzwert x = abs(((quadrat schaetzwert) - x)) / x < Bei Definitionseinsetzung für gutgenug : x 1 steht für den formalen Parameter schaetzwert und x 2 steht für den formalen Parameter x t 1 steht für den formalen Parameter P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 50

51 Arithmetische Auswertungen P [v op w] P [r] wenn: v, w arithmetische Basiswerte, op ein zweistelliger arithmetischer Operator, r Resultat von v op w P [op v] P [r] wenn: v arithmetischer Basiswert, op einstelliger arithmetischer Operator, r Resultat von op v Beachte: Wenn s op t ausgewertet werden soll, dann zuerst die Ausdrücke s, t auswerten. P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 51

52 Boolesche Auswertungen P [v op w] oder P [op w] wobei op einer der Operatoren &&,, not sein kann. Wird als Anwendung des Operators auf Argumente ausgewertet. Definitionen, in der Wirkung äquivalent zu den vordefinierten: x && y = if x then y else False x y = if x then True else y not x = if x then False else True P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 52

53 Auswertung der Fallunterscheidung Fallunterscheidung (if-reduktion) P [(if True then e 1 else e 2 )] P [e 1 ] P [(if False then e 1 else e 2 )] P [e 2 ] Beachte Diese zwei Regeln können nur angewendet werden, wenn der Bedingungsausdruck zu True oder False ausgewertet ist. P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 53

54 Transformationen, Reduktionen Wir nennen eine Transformation auch Reduktion und eine Folge von Programmtransformationen auch Reduktionsfolge (oder Auswertung). Beachte: Reduktionen / Transformationen sind zunächst überall im Ausdruck erlaubt. Erst eine Auswertungs-Strategie macht die Auswertung eindeutig. P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 54

55 Beispiel x && y = if x then y x y = if x then True bot = bot else False else y Auswertungen unter der Annahme der obigen Definition True && True if True then True else False True True && False if True then False else False False True True if True then True else True True True False if True then True else False True True && bot if True then bot else False bot bot... True bot if True then True else bot True P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 55

56 Beispiel: Programm: main = quadrat 5 quadrat x = x*x Auswertung als Folge von Transformationen: main quadrat 5 5 * 5 25 P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 56

57 Beispiel: Auswertung Programm: wurzel x = if not (x > x) then error "wurzel: not a number" else if x >= 0 then wurzeliter 1.0 x else error "wurzel: Eingabe negativ" wurzeliter schaetzwert x = if gutgenug schaetzwert x then schaetzwert else wurzeliter (verbessern schaetzwert x) x quadrat x = x*x gutgenug schaetzwert x = abs(((quadrat schaetzwert) - x) / x) < mittelwert x y = (x + y) / 2.0 verbessern schaetzwert x = mittelwert schaetzwert (x / schaetzwert) P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 57

58 Beispiel Auswertung Folge von Transformationen: wurzel 2.0 (Definitionseinsetzung) if not ( > 2.0) then error "wurzel: not a number" else if 2.0 >= 0 then wurzeliter else error "wurzel: Eingabe negativ" P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 58

59 Beispiel: Auswertung (2) (Auswertung arithmetischer Ausdruck) if not ( 2.1 > 2.0) then error "wurzel: not a number" else if 2.0 >= 0 then wurzeliter else error "wurzel: Eingabe negativ" (Auswertung arithmetischer Ausdruck) if not True then error "wurzel: not a number" else if 2.0 >= 0 then wurzeliter else error "wurzel: Eingabe negativ" (Auswertung Boolescher Ausdruck) if False then error "wurzel: not a number" else if 2.0 >= 0 then wurzeliter else error "wurzel: Eingabe negativ" P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3rd November2004) Seite 59

60 Beispiel: Auswertung (3) (if-auswertung) if 2.0 >= 0 then wurzeliter else error "wurzel: Eingabe negativ" if True then wurzeliter else error "wurzel: Eingabe negativ" wurzeliter if gutgenug then 1.0 else wurzeliter (verbessern ) 2.0 P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3rd November2004) Seite 60

61 Beispiel: Auswertung (4) (Definitionseinsetzung gutgenug ) if abs((( quadrat 1.0 ) - 2.0)) / 2.0 < then 1.0 else wurzeliter (verbessern ) 2.0 if abs(((1.0 * 1.0 ) - 2.0)) / 2.0 < then 1.0 else wurzeliter (verbessern ) 2.0 if abs(( )) / 2.0 < then 1.0 else wurzeliter (verbessern ) 2.0 if abs(-1.0) / 2.0 < then 1.0 else wurzeliter (verbessern ) 2.0 P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3rd November2004) Seite 61

62 Beispiel: Auswertung (5) if 1.0 / 2.0 < then 1.0 else wurzeliter (verbessern ) 2.0 if 0.5 < then 1.0 else wurzeliter (verbessern ) 2.0 if False then 1.0 else wurzeliter (verbessern ) 2.0 wurzeliter (verbessern ) 2.0 if gutgenug (verbessern ) 2.0 then (verbessern ) else wurzeliter (verbessern (verbessern ) 2.0) P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3rd November2004) Seite 62

63 Transformationsmöglichkeiten 3 Auswertungen für quadrat (4+5) : 1. quadrat(4 + 5) (4 + 5) (4 + 5) 9 (4 + 5) quadrat(4 + 5) (4 + 5) (4 + 5) (4 + 5) quadrat(4 + 5) (quadrat 9) Beobachtungen: Ergebnis ist gleich Anzahl der Reduktionen verschieden P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 63

64 Satz von Church und Rosser Satz (Church-Rosser I) Sei P ein Programm, R 1, R 2 zwei verschiedene Reduktionsfolgen für main mit jeweiligen Resultat-Basiswerten e 1 bzw. e 2 dann sind diese Basiswerte gleich, d.h. e 1 = e 2 P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 64

65 Werte von Programmen Definition: Sei P ein Programm und main von numerischem oder Booleschem Typ. Der Wert des Programms P ist: e undefiniert ( ) wenn es eine terminierende Reduktionsfolge, ausgehend von main gibt, die mit dem Basiswert e endet, wenn es keine mit einem Basiswert terminierende Reduktionsfolge ausgehend von main gibt. Damit gilt: Ein einfaches Haskell-Programm hat einen eindeutig definierten Wert unabhängig von der Art der Auswertung P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 65

66 Reduktionsstrategien Zwei wichtige Reduktionsstrategien Applikative Reihenfolge: Argumentauswertung vor δ-reduktion Normale Reihenfolge: δ-reduktion vor Argumentauswertung P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 66

67 Beschreibung: applikative Reihenfolge werte t 0 applikativ aus! Fälle: t 0 ist Basiswert. fertig. t 0 s t, Wenn s kein Funktionsname und keine Anwendung, dann applikativ s t 0 f t 1... t n. Wenn ar(f) n, dann applikativ t i, 1 i ar(f) von links nach rechts. Wenn ar(f) n und alle t i Basiswerte, dann δ-reduktion. Wenn n < ar(f), dann fertig: keine Reduktion. t 0 if b then e 1 else e 2. Wenn b Basiswert, dann if-reduktion Wenn b kein Basiswert, dann applikativ b P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 67

68 Beschreibung: normale Reihenfolge werte t 0 in normaler Reihenfolge aus. Fälle: t 0 ist Basiswert. fertig. t 0 s t, Wenn s kein Funktionsname und keine Anwendung. Dann normale R. auf s t 0 f t 1... t n und f keine eingebaute Funktion, Wenn ar(f) n, dann δ-reduktion auf f t 1... t ar(f). Wenn ar(f) > n: keine Reduktion. t 0 f t 1... t n und f ist eingebaute Funktion Wenn ar(f) n und Argumente von f keine Basiswerte, dann normale R. auf ar(f) Argumente von links nach rechts. Wenn ar(f) n, und ar(f) Argumente von f sind Basiswerte, dann eingebaute Funktion aufrufen. Wenn ar(f) > n: keine Reduktion. t 0 if b then e 1 else e 2. Wenn b Basiswert, dann if-reduktion Wenn b kein Basiswert, dann normale R. auf b P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 68

69 Beispiel für Reduktionen 3 Auswertungen für quadrat (4+5) : 1. quadrat(4 + 5) (4 + 5) (4 + 5) 9 (4 + 5) normale Reihenfolge der Auswertung 2. quadrat(4 + 5) (4 + 5) (4 + 5) (4 + 5) quadrat(4 + 5) (quadrat 9) applikative Reihenfolge der Auswertung P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 69

70 Prozeduraufrufe in anderen Programmiersprachen Prozeduraufruf mit Wertübergabe: call-by-value Es wird nur der Wert übergeben ähnlich zur applikative Reihenfolge Prozeduraufruf mit Namensübergabe: call-by-name Es wird nur der Name der Variablen übergeben hat entfernte Ähnlichkeit zur normalen Reihenfolge P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 70

71 Satz 2 von Church und Rosser SATZ (Church-Rosser-2) Sei P ein einfaches Haskell-Programm. Wenn es irgendeine Reduktionsfolge für main gibt, die mit einem Basiswert e terminiert, dann terminiert auch die normale Reihenfolge der Auswertung von main und liefert als Basiswert (Resultat) genau e. Die normale Reihenfolge ist ausreichend zur Auswertung Haskell benutzt normale Reihenfolge der Auswertung P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 71

72 Berechnungsvorschrift Eine Menge von Funktionsdefinitionen, ein Ausdruck und eine ausführbare Auswertungsstrategie ergibt eine Berechnungsvorschrift. Church-Rosser-1 und Church-Rosser-2 = Funktionsdefinitionen + Ausdruck = Algorithmus P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 72

73 Gegenbeispiel zu C.R. 2 bei applikativ Church-Rosser-2 gilt nicht für die applikative Reihenfolge: nt x = nt x proj x y = x main = proj 0 (nt 1) applikative Reihenfolge für main terminiert nicht: (nt 1) (nt 1) (nt 1) Deshalb: proj 0 (nt 1) proj 0 (nt 1) Die normale Reihenfolge liefert sofort 0. P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 73

74 Optimale Anzahl der Reduktionen Definition verzögerte Reihenfolge der Auswertung (lazy reduction): normale Reihenfolge gerichteter Graph statt Text Vermeidung von unnötiger Doppelauswertung durch gemeinsame Unterausdrücke (Sharing) Church-Rosser-2 gilt auch für verzögerte Reduktion! Falls ein Basiswert berechnet wird, gilt für #Reduktionsschritte: # verzögerte R # applikative R # normale R Es gilt: verzögerte Reduktion hat optimale Anzahl von Reduktionen Haskell verwendet verzögerte Reduktion P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 74

75 Beispiel 1. 4 Reduktionen: (normale R.) quadrat(4 + 5) (4 + 5) (4 + 5) 9 (4 + 5) Reduktionen: quadrat(4 + 5) (4 + 5) (4 + 5) (4 + 5) Reduktionen (applikative R.) quadrat(4 + 5) (quadrat 9) Reduktionen (verzögerte R.) quadrat(4 + 5) (4 + 5) (1) (4 + 5) (1) P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 75

76 Verzögerte Auswertung: komplexeres Beispiel fakultaet x = if x <= 0 then 1 else x*(fakultaet (x-1)) Die Reduktionsschritte: fakultaet 3 if 3 <= 0 then 1 else 3*(fakultaet (3-1)) if False then 1 else 3*(fakultaet (3-1)) 3* (fakultaet (3-1)) 3*(if (3-1) <= 0 then 1 else (3-1) *(fakultaet ( (3-1) -1))) P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 76

77 Beispiel... 3*(if 2 <= 0 then 1 else 2*(fakultaet (2-1))) 3* (if False then 1 else 2*(fakultaet (2-1))) 3*(2* (fakultaet (2-1)) ) 3*(2*(if (2-1) <= 0 then 1 else (2-1) *(fakultaet ( (2-1) -1)))) 3*(2*(if 1 <= 0 then 1 else 1*(fakultaet (1-1)))) 3*(2* (if False then 1 else 1*(fakultaet (1-1))) ) 3*(2*(1* (fakultaet (1-1)))) P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 77

78 Beispiel... 3*(2*(1*(if (1-1)<= 0 then 1 else(1-1)*(fakultaet ((1-1)-1))))) 3*(2*(1*(if 0 <= 0 then 1 else 0*(fakultaet (0-1))))) 3*(2*(1* (if True then 1 else 0*(fakultaet (0-1))))) 3*(2* (1*1)) 3*(2*1) 3*2 6 P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 78

79 Ein weiterer Vorteil der verzögerten Reduktion verzögerte Reduktionenen zur Compile-Zeit sind korrekte Programmtransformationen d.h. die operationale Semantik bleibt erhalten Das ist falsch bei applikativer Reihenfolge P raktische Informatik 1, W S 2004/05, F olien Haskell 1, (3. November2004) Seite 79