Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Funktionale Programmierung

Ähnliche Präsentationen


Präsentation zum Thema: "Funktionale Programmierung"—  Präsentation transkript:

1 Funktionale Programmierung
IFB 1/2002 Klaus Becker

2 Programmieren mit Funktionen
Teil 1 Programmieren mit Funktionen

3 an Mosel, Saar und Ruwer

4 Kirchtürme

5 Kirchtürme

6 Dachberechnungen Es soll ein Programm erstellt werden, mit dem man für verschieden dimensionierte Kirchturmdächer den Gesamtflächeninhalt berechnen kann.

7 Dachstruktur Pyramiden-dreieck Übergangs-dreieck ADach =
4 * AÜbergangsTrapez + 4 * AÜbergangsDreieck + 8 * APyramidenDreieck Übergangstrapez

8 Dachparameter Pyramiden-dreieck hP Übergangs-dreieck bA hÜ bQ
Übergangstrapez

9 Funktionale Modellierung
ADach 4.0 bQ 2.0 bA ... 3.0 hP 10.0 hP bA bQ

10 Funktionale Modellierung
ADach = 4 * AÜbergangsTrapez + 4 * AÜbergangsDreieck + 8 * APyramidenDreieck g h ADreieck a c ATrapez ADreieck(g,h) = 0.5*g*h ATrapez(a,c,h) = 0.5*(a+c)*h

11 Funktionale Modellierung
ADach(bQ,bA,hÜ,hP) = 4 * ATrapez(bQ,sA,hÜT) + 4 * ADreieck(sA,hÜD) + 8 * ADreieck(sA,hPD) hP hPD bA sA hÜT hÜD bQ

12 Funktionale Modellierung
sA bA hPD bA hP hP hPD hÜD bQ bA bA sA hÜT hÜT hÜD bQ bQ bA

13 Funktionale Modellierung
sA bA ADach(bQ,bA,hÜ,hP) = 4*ATrapez(bQ,sA,hÜT) + 4*ADreieck(sA,hÜD) + 8*ADreieck(sA,hPD) hPD bA hP hÜD bQ bA ADach(bQ,bA,hÜ,hP) = 4*ATrapez(bQ,sA(bA),hÜT(bQ,bA,hÜ)) + 4*ADreieck(sA(bA),hÜD(bQ,bA,hÜ)) + 8*ADreieck(sA(bA),hPD(bA,hP)) hÜT bQ bA

14 Funktionale Modellierung
sA bA sA(bA) = bA * tan(/8) hPD bA hPD(bA,hP) = ((bA/2)2 + hP2) hP hÜD bQ hÜD(bQ,bA,hÜ) = (((2 * bQ - bA)/2)2 + hÜ2) bA hÜT bQ hÜT(bQ,bA,hÜ) = (((bQ - bA)/2)2 + hÜ2) bA

15 Funktionales Programm
ADreieck(g,h) = 0.5*g*h ATrapez(a,c,h) = 0.5*(a+c)*h sA(bA) = bA * tan(/8) hPD(bA,hP) = ((bA/2)2 + hP2) hÜD(bQ,bA,hÜ) = (((2 * bQ - bA)/2)2 + hÜ2) hÜT(bQ,bA,hÜ) = (((bQ - bA)/2)2 + hÜ2) ADach(bQ,bA,hÜ,hP) = 4 * ATrapez(bQ,sA(bA),hÜT(bQ,bA,hÜ)) + 4 * ADreieck(sA(bA),hÜD(bQ,bA,hÜ)) + 8 * ADreieck(sA(bA),hPD(bA,hP)) Funk. Progr. bestehen aus Funktionsdeklarationen.

16 Auswertung Die Auswertung erfolgt durch Termersetzung.
ADach(10,5,4,20)  4 * ATrapez(10,sA(5),hÜT(10,5,4)) + 4 * ADreieck(sA(10),hÜD(10,5,4)) + 8 * ADreieck(sA(10),hPD(5,20))  4 * ATrapez(10,5 * tan(/8),hÜT(10,5,4)) +  ... ... // Funktionsaufruf // Funktionswert Die Auswertung erfolgt durch Termersetzung.

17 Zusammenfassung Mit Funktionen kann man programmieren.
Die Programme bestehen aus Funktionsdeklarationen. Die Programmauswertung erfolgt durch Funktionsanwendung (Termersetzung).

18 Methodik: Arbeitsschritte
Funktions-deklarationen Funktionsaufruf Problem-kontext Beschreiben Benutzer Verein-fachen Derive Benutzer Lösung Funktionswert Deuten Beschreiben - Vereinfachen - Deuten

19 Derive als Programmiersystem
Beschreiben: ADreieck(g,h) := 0.5*g*h ATrapez(a,c,h) := 0.5*(a+c)*h ... ADach(10,5,4,20) Vereinfachen: ( · 2) +... Deuten: Der Flächeninhalt des Dachs ...

20 Übungen - Aufgabe 1 Es soll ein Programm zur Kalkulation der Herstellungskosten eines Buches entwickelt werden. Folgende Informationen sollen dabei modelliert werden: Die Buchkosten setzen sich aus den Papierkosten, Setzkosten, Druckkosten und Bindekosten zusammen. Das Papier wird in Bögen zum Preis von 0,43 E geliefert. Aus jedem Bogen lassen sich 16 Seiten schneiden. Der Druck kostet 0,27 E pro Bogen, der Satz 17,5 E pro Seite. Für das Binden eines Buches werden 1,83 E benötigt. Das zu erstellende Programm soll bei gegebener Seitenzahl (z.B. 366) und der Auflage (z.B ) die Gesamtherstellungskosten errechnen.

21 Hinweise zu Aufgabe 1 Modellieren Sie zunächst geeignete (Hilfs-) Funktionen. (Black-Box-Darstellung) Entwickeln Sie anschließend die zugehörigen Funktionsdeklarationen. Zur Berechnung der Anzahl der Bögen benötigt man eine Operation zur Durchführung der ganzzahligen Division. Benutzen Sie hierzu die folgende (in Derive vordefinierte) Operation: FLOOR 23 4 5 Implementieren Sie abschließend die Funktionen mit DERIVE.

22 Übungen - Aufgabe 2 Zur Berechnung von Flächeninhalten / Integralen wird ein Programm benötigt, das Rechtecksummen berechnen kann. Modellieren Sie zunächst geeignete (Hilfs-) Funktionen. (Black-Box-Darstellung) Erstellen Sie anschließend die Funktionsdeklarationen. Implementieren Sie abschließend die Funktionen mit DERIVE.

23 Lösung zu Aufgabe 1 Bogen := 0.43 Druck := 0.27 Satz := 17.5
Binden := 1.83 BogenAnzahl(Seiten) := FLOOR(Seiten - 1, 16) + 1 PapierKosten(Seiten, Auflage) := BogenAnzahl(Seiten)·Bogen·Auflage SetzKosten(Seiten) := Seiten·Satz DruckKosten(Seiten, Auflage) := BogenAnzahl(Seiten)·Druck·Auflage BindeKosten(Auflage) := Auflage·Binden Kosten(Seiten, Auflage) := PapierKosten(Seiten, Auflage) + SetzKosten(Seiten) + DruckKosten(Seiten, Auflage) + BindeKosten(Auflage)

24 Lösung zu Aufgabe 2 Funktiondeklaration ohne Spezifikation des Funktionsterms f(x) := Streifenbreite: d(a, b, n) := (b - a) / n Unterteilungsstelle: s(a, b, n, i) := a + i·d(a, b, n) Rechtecksumme: RS(a, b, n) := (d(a, b, n) ·f(s(a, b, n, i)), i, 0, n - 1)

25 Datentypen / Datenstrukturen
Teil 2 Datentypen / Datenstrukturen

26 Rechteckfiguren Es soll ein Programm erstellt werden, mit dem man Rechteckfiguren zu einer vorgegeben Funktion veranschaulichen kann. Es soll dabei möglich sein, das Intervall und die Streifenbreite vorzugeben.

27 Datenmodellierung mit Listen
Punkt als Koordinatenpaar: [0, 0] Rechteck als Streckenzug: [[0, 0], [2, 0], [2, 4], [0, 4], [0, 0]] Rechteckfigur als Folge von Rechtecken: [ [[0, 0], [2, 0], [2, 4], [0, 4], [0, 0]], [[2, 0], [4, 0], [4, 16], [2, 16], [2, 0]], [[4, 0], [6, 0], [6, 36], [4, 36], [4, 0]] ]

28 Listen in DERIVE Liste: Folge von Objekten (Zahlen, Terme, Listen)
[0, 1, 2, 3] [1, x, x2, x3] [[], [0], [[0]]] Erzeugung von Listen: - Aufzählung der Listenelemente - Generierung mit dem VECTOR-Operator [1, x, x2, x3] VECTOR(xn, n, 0, 3, 1) Term VECTOR nat. Zahl xn Laufvariable: 3 1 [1, x, x2, x3] n Anfangswert: Endwert: Schrittweite: Term:

29 Spezifikation der Funktionen
Rechteckpunkte: LU Intervallgrenze: a nat. Zahl Koordinaten der linken unteren Ecke von Rechteck Nummer i Intervallgrenze: b nat. Zahl Unterteilungen: n nat. Zahl nat. Zahl Nummer: i Rechteck: nat. Zahl Rechteck a Intervallgrenze: n i Koordinaten der Punkte des Streckenzugs zum Rechteck Nummer i b Unterteilungen: Nummer: Rechteckfigur: nat. Zahl RF a Intervallgrenze: n Koordinaten der Punkte des Streckenzugs zur Rechteckfigur b Unterteilungen:

30 Programm Unterteilungsstellen: d(a, b, n) := (b - a) / n
s(a, b, n, i) := a + i·d(a, b, n) Rechteckpunkte: LU(a,b,n,i) := [s(a,b,n,i-1), 0] RU(a,b,n,i) := [s(a,b,n,i), 0] LO(a,b,n,i) := [s(a,b,n,i-1), f(s(a,b,n,i-1))] RO(a,b,n,i) := [s(a,b,n,i), f(s(a,b,n,i-1))] Rechteck als Streckenzug: Rechteck(a,b,n,i) := [LU(a,b,n,i), RU(a,b,n,i), RO(a,b,n,i), LO(a,b,n,i), LU(a,b,n,i)] Rechteckfigur als Folge von Rechtecken: RF(a,b,n) := VECTOR(Rechteck(a,b,n,i), i, 1, n)

31 Funktion als Eingabeobjekt
Spezifikation: RF R  R f Randfunktion: Koordinaten der Punkte des Streckenzugs zur Rechteckfigur Intervallgrenze: a nat. Zahl Intervallgrenze: b nat. Zahl nat. Zahl Unterteilungen: n „Trick“: Term A(pply) T Einsetzungsterm: Neuer Term, bei dem x jeweils durch u ersetzt ist Funktionsterm: u Beispiele: A(x2, 4)  16; A(x2, y-1)  (y-1)2 A(T, u) := LIM(T, x, u) Implementierung in Derive:

32 Derive-Implementierung
Funktionsdeklarationen: A(T, u) := LIM(T, x, u) d(a, b, n) := (b - a) / n s(a, b, n, i) := a + i·d(a, b, n) LU(a,b,n,i) := [s(a,b,n,i-1), 0] RU(a,b,n,i) := [s(a,b,n,i), 0] LO(f,a,b,n,i) := [s(a,b,n,i-1), A(f, s(a,b,n,i-1))] RO(f,a,b,n,i) := [s(a,b,n,i), A(f, s(a,b,n,i-1))] Rechteck(f,a,b,n,i) := [LU(a,b,n,i), RU(a,b,n,i), RO(f,a,b,n,i), LO(f,a,b,n,i), LU(a,b,n,i)] RF(f,a,b,n) := VECTOR(Rechteck(f,a,b,n,i), i, 1, n) Funktionsaufruf: RF(-x2 + 4, 0, 2, 10)

33 Datentypen / Datenstrukturen
Elementare Datentypen: Zahlen: 3; 5.1; (Wahrheitswerte, Zeichen, Zeichenketten) Funktionen: Terme: x (Zuordnungen: x  x2 - 1) Listen: inhomogen: [x2 - 1, 0, [ ] ] (homogen: [[0], [0, 1], [0, 1, 2], [0, 1, 2, 3]])

34 Warteschlange Es soll ein Programm erstellt werden, mit dem man Druckaufträge zwischenspeichern kann. Der Zwischenspeicher soll nach dem FIFO-Prinzip (first in, first out) arbeiten.

35 Datenmodellierung .. .. Druckauftrag: Warteschlange:
Struktur Implementierung Druckauftrag [4, [31,62,75,92]] Adresse, Daten Verbund Liste Zahl Daten .. Sequenz Liste Zahl Warteschlange: [[4, [31,62,75,92]], [3, []], [7, [102,101,77]]] Warteschlange Druckauftrag .. Sequenz Struktur Implementierung Liste Vereinfachte Warteschlange: [4, 3, 7]

36 Warteschlangen-Operationen
Spezifikation: ER Schlange: L Liste erstes Element Liste OE L Schlange ohne das erste Element Schlange: ML Schlange: L Liste Schlange, mit a als neuem letztem Element Auftrag: a Element

37 Listenoperatoren von DERIVE
Vordefinierte Operatoren ELEMENT Liste: L Liste Listenelement an der Stelle i Nummer: i nat. Zahl Bsp.: ELEMENT([3,5,7,2,9,4], 2)  5 Kurzschreibweise: [3,5,7,2,9,4]  2 Liste DIMENSION L Anzahl der Listenelemente Liste: Bsp.: DIMENSION([3,5,7,2,9,4])  6

38 Implementierung IF-Operator ER(L) := ELEMENT(L,1)
OE(L) := VECTOR(ELEMENT(L,i), i, 2, DIMENSION(L)) ML(L,a) := VECTOR( IF(iDIMENSION(L), ELEMENT(L,i), a), i, , DIMENSION(L)+1) IF-Operator Syntax: IF( Bedingung, then-Ausdruck, else-Ausdruck ) Bsp.: IF( x = y, 1, 0) IF( x > 0, x2, -x2 )

39 Zusammenfassung elementare Datentypen Funktionen als Datenobjekte
Liste als zentrale Datenstruktur; zur Verarbeitung von Listen benötigt man elementare Listenoperationen

40 Methodik: Programmieren
Schritt 1: Spezifikation der Funktion a) Signatur (Typen der Parameter; Ergebnistyp) b) Verhalten (informelle Beschreibung; Beispiele) Schritt 2: Deklaration der Funktion Schritt 3: Implementierung der Funktion

41 Übung: Aufgabe 3 Implementieren und testen Sie die folgenden Operationen zur Listenverarbeitung: LE L Liste letztes Element OL Liste ohne das letzte Element L Liste ME a Element Liste, mit a als neuem erstem Element L Liste

42 Übung: Aufgabe 4 Eine Liste enthält die Ergebnisse einer Würfelwurfserie. Z.B.: [3, 2, 2, 6, 4, 5, 3, 6, 1, 5] Entwickeln Sie ein Programm, das zählt, wie oft eine bestimmte Augenzahl in der Würfelwurfserie vorgekommt. Hinweise: Entwickeln Sie zunächst eine Funktion, mit der man die interessierende Augenzahl (z. B. 6) herausfiltern kann. [3, 2, 2, 6, 4, 5, 3, 6, 1, 5]  [0, 0, 0, 1, 0, 0, 0, 1, 0, 0] Mit Hilfe des vordefinierten SUM-Operators kann dann die gewünschte Anzahl bestimmt werden.

43 Lösung zu Aufgabe 3 L := [3, 5, 2, 8, 6, 5, 1]
LE(L) := ELEMENT(L, DIMENSION(L)) LE(L) 1 OL(L) := VECTOR(ELEMENT(L, i), i, 1, DIMENSION(L) - 1) OL(L) [3, 5, 2, 8, 6, 5] ME(L, a) := VECTOR(IF(i = 0, a, ELEMENT(L, i)), i, 0, DIMENSION(L)) ME(L, 0) [0, 3, 5, 2, 8, 6, 5, 1]

44 Lösung zu Aufgabe 4 Filter(w, L) := VECTOR(IF(ELEMENT(L, i) = w, 1, 0), i, 1, DIMENSION(L)) Filter(6, [3, 4, 6, 2, 1, 6, 4]) [0, 0, 1, 0, 0, 1, 0] Zaehlen(w, L) := SUM(Filter(w, L)) Zaehlen(6, [3, 4, 6, 2, 1, 6, 4]) 2

45 Teil 3 Kontrollstrukturen

46 Bearbeitung von Anfragen
Das Programm zur Verwaltung von Druckaufträgen soll auch Anfragen von Benutzern bearbeiten können. Z.B.: An welcher Stelle befindet sich „mein Auftrag“ in der Warteschlange?

47 Spezifikation zur Anfrage
Problem: An welcher Stelle befindet sich der erste Auftrag von Rechner x? Spezifikation: Stelle Stelle, an der sich der erste Auftrag von x befindet Adresse: x Listenel. Schlange: L Liste Bsp.: Stelle(2, [3,5,2,7,2,9,4])  3

48 Rekursive Problemreduktion
Reduktionsschritte: Stelle(3, [])  0 Stelle(3, [3, 8, 3])  1 Stelle(3, [1, 2, 1, 3, 8, 3])  1 + Stelle(3, [2, 1, 3, 8, 3]) 4 3 Rekursive Problemreduktion: Reduktion des Problems auf ein entsprechendes, aber „verkleinertes“ Problem

49 Reduktionsregeln Reduktionsschritte: Reduktionsregeln:
Stelle(3, [])  0 Stelle(3, [3, 8, 3])  1 Stelle(3, [1, 2, 1, 3, 8, 3])  1 + Stelle(3, [2, 1, 3, 8, 3]) Reduktionsregeln: Stelle(x, [])  0 Stelle(x, [e|R])  IF(x=e, 1, 1+Stelle(x,R)) Reduktionsregeln sind Problemreduktionsschemata.

50 DERIVE-Implementierung
Reduktionsregeln: Stelle(x, [])  0 Stelle(x, [e|R])  IF(x=e, 1, 1+Stelle(x,R)) Implementierung: Stelle(x, L) := IF(DIMENSION(L)=0,0, IF(x=ER(L), 1, 1+Stelle(x,OE(L))))

51 eine Löschanfrage Problem: Spezifikation:
Lösche den ersten Auftrag von Rechner x. Spezifikation: LöscheErstes Liste ohne den ersten vorkommenden Auftrag von x Adresse: x Listenel. Schlange: L Liste Bsp.: LöscheErstes(2, [3,5,2,7,2,9,4])  [3,5,7,2,9,4]

52 Rekursive Problemreduktion
Reduktionsschritte: DelEr(3, [])  [] DelEr (3, [3, 8, 3])  [8, 3] DelEr(3, [1, 2, 1, 3, 8, 3])  [1 | DelEr(3, [2, 1, 3, 8, 3])] [1, 2, 1, 8, 3] [2, 1, 8, 3] [1, 2, 1, 8, 3] Reduktionsregeln: DelEr(x, [])  [] DelEr(x, [e|R])  IF(x=e, R, ME(e, DelEr(x,R)))

53 DERIVE-Implementierung
Reduktionsregeln: DelEr(x, [])  [] DelEr(x, [e|R])  IF(x=e, R, ME(e, DelEr(x,R))) Implementierung: DelEr(x, L) := IF(DIMENSION(L)=0, [], IF(x=ER(L), OE(L), ME(ER(L), DelEr(x, OE(L)))))

54 Reduktionskonzept Reduktionsregeln: Problemreduktionsschemata
DelEr(x, [])  [] DelEr(x, [e|R])  IF(x=e, R, ME(e, DelEr(x,R))) Reduktionskette: Anwendung der Reduktionsregeln DelEr(3, [1, 2, 1, 3, 8, 3])  ME(1, DelEr(3, [2, 1, 3, 8, 3]))  ME(1, ME(2, DelEr(3, [1, 3, 8, 3])))  ME(1, ME(2, ME(1, DelEr(3, [3, 8, 3]))))  ME(1, ME(2, ME(1, [8, 3])))  [1, 2, 1, 8, 3] Funktionsaufruf Funktionswert

55 Zusammenfassung Kontrollstrukturen Fallunterscheidung Komposition
DelEr(x, L) := IF(DIMENSION(L)=0, [], IF(x=ER(L), OE(L), ME(ER(L), DelEr(x, OE(L))))) Fallunterscheidung Komposition Rekursion

56 Methodik: Rekursion Schritt 1: Schritt 2: Schritt 3:
Entwurf typischer, exemplarischer Reduktionsschritte (Korrektheitsbetrachtungen, Terminationsbetrachtungen) Schritt 2: Verallgemeinerung zu Reduktionsregeln Schritt 3: Beschreibung mit einer rekursiven Funktion

57 Übung - Aufgabe 5 Entwickeln Sie funktionale Programme zur Bearbeitung der folgenden Anfragen: - Wie viele Aufträge hat Rechner x in der Schlange? - Lösche alle Aufträge von Rechner x in der Schlange. - Welche Rechner haben einen Auftrag in der Schlange? Gehen Sie dabei nach der oben beschriebenen Methode (exemplarische Reduktionsschritte; Reduktionsregeln; Implementierung in Derive) vor.

58 Übung - Aufgabe 6 Miniprojekt: Wir betrachten die folgende Erweiterung des Warteschlangen-Programms: Die Druckaufträge sollen jetzt zusätzlich mit Prioritätsangaben versehen werden (dringend, eilt nicht, brennt, ...). Diese Prioritätsangaben werden hier mit Zahlen kodiert (je kleiner die Zahl, desto höher ist die Priorität). Ein Druckauftrag wird im folgenden durch ein Zahlenpaar [Adresse, Prioritätsangabe] beschrieben. Welche Änderungen ergeben sich durch diese Erweiterung? Mit Hilfe einer Funktion „Umschalten“ soll man vom normalen „FIFO-Betrieb“ in den „Prioritätsbetrieb“ umschalten können. Die Druckaufträge sollen dann in der Warteschlange umsortiert werden.

59 Lösung zu Aufgabe 5 Anfrage: Reduktionsregeln: Implementierung:
Wie viele Aufträge hat Rechner x in der Schlange? Reduktionsregeln: Anzahl(x, [])  0 Anzahl(x, [e|R])  IF(x=e, 1+Anzahl(x,R), Anzahl(x,R)) Implementierung: Anzahl(x, L) := IF(DIMENSION(L)=0,0, IF(x=ER(L), Anzahl(x,OE(L)), Anzahl(x,OE(L))))

60 Lösung zu Aufgabe 5 Anfrage: Reduktionsregeln: Implementierung:
Lösche alle Aufträge von Rechner x in der Schlange. Reduktionsregeln: DelAlle(x, [])  [] DelAlle(x, [e|R])  IF(x=e, DelAlle(x,R), ME(e, DelAlle(x,R))) Implementierung: DelAlle(x, L) := IF(DIMENSION(L)=0, [], IF(x=ER(L), DelAlle(x,OE(L)), ME(ER(L), DelAlle(x, OE(L)))))

61 Lösung zu Aufgabe 5 Anfrage: Reduktionsregeln: Implementierung:
Welche Rechner haben einen Auftrag in der Schlange? Reduktionsregeln: Benutzer([])  [] Benutzer([e|R])  ME(e, Benutzer(DelAlle(e,R)) Implementierung: Benutzer(L) := IF(DIMENSION(L)=0, [], ME(ER(L), Benutzer(DelAlle(ER(L), OE(L)))))

62 Funktionale Programmierung
Teil 4 Funktionale Programmierung

63 ein Problem - drei Lösungen
imperative Lösung Tauschen(x, y) z := x x := y y := z Tauschen([x, y]) = [y, x] funktionale Lösung Tauschen([x, y], [a, b])  x = b, y = a Logik-basierte Lösung

64 Programmierstile Imperative Programmierung
Registerbelegung z := x x := y y := z Register-maschine Programm: Registerbelegung Imperative Programmierung Das Programm besteht aus Anweisungen. Die Registermaschine verändert die Register-belegung gemäß den Anweisungen. Algorithmisches Denken Erfassen u. Beschreiben von (zeitlichen) Abläufen

65 Programmierstile Logik-basierte Programmierung
Anfrage T([x, y], [a, b])  x = b, y = a Inferenz-maschine Programm: Ergebnis Logik-basierte Programmierung Das Programm besteht aus Fakten und Regeln. Die Inferenzmaschine sucht eine auf den Fakten und Regeln basierende logische Folgerungskette zur Klärung der Anfrage. Logisches Denken Erfassen u. Beschreiben von Sachverhalten

66 Programmierstile Funktionale Programmierung
Ausgangsterm Tauschen([x, y]) = [y, x] Reduktions-maschine Programm: Ergebnisterm Funktionale Programmierung Das Programm besteht a. Funktionsdeklarationen. Die Reduktionsmaschine vereinfacht den Aus-gangsterm mit Hilfe der Funktionsdeklarationen. Funktionales Denken Erfassen u. Beschreiben von Zuordnungen

67 Funktionales Denken Funktionsterme beinhalten Berechnungsregeln
Funktionen beschreiben Ein-/Ausgabe-Sit. bzw. Berechnungssituationen Funktionale Ausdrücke / Terme sind referentiell transparent Funktionale Ausdrücke /Terme beschreiben Problemwerte

68 Referentielle Transparenz
Jeder (Teil-)Term beschreibt einen bestimmten Wert, der nicht durch die Auswertung anderer (Teil-)Terme verändert werden kann. Die Auswertung eines (Teil-)Term verändert seine Form, aber nicht seinen Wert. - Term muss nur einmal dargestellt / ausgewertet werden - Reihenfolge der Auswertung irrelevant - parallele Auswertung ist möglich - keine Seiteneffekte, die das Verhalten komplizieren ADach(bQ,bA,hÜ,hP) = 4 * ATrapez(bQ,sA(bA),hÜT(bQ,bA,hÜ)) + 4 * ADreieck(sA(bA),hÜD(bQ,bA,hÜ)) + 8 * ADreieck(sA(bA),hPD(bA,hP))

69 Referentielle Transparenz
Funktionale Programme sind i. a. referentiell transparent. ADach(bQ,bA,hÜ,hP) = 4 * ATrapez(bQ,sA(bA),hÜT(bQ,bA,hÜ)) + 4 * ADreieck(sA(bA),hÜD(bQ,bA,hÜ)) + 8 * ADreieck(sA(bA),hPD(bA,hP)) Imperative Programme sind i. a. referentiell undurchsichtig. s := 0; x := x + 1 s := s + x; x := x + 1; s := s + 1;

70 Auswertung von Würfelserien
... Mit Hilfe eines Programms sollen Würfelserien erzeugt und ausgewertet werden. Das Programm soll insbesondere eine Häufigkeitsverteilung erstellen.

71 Programm - Version 1 Wuerfeln := RANDOM(6) + 1
WuerfelSerie(n) := VECTOR(Wuerfeln, m, 1, n) WuerfelSerie(10) [4, 4, 5, 5, 5, 5, 2, 3, 4, 5] Häufigkeit(i, n) := DIMENSION(SELECT(x = i, x, WuerfelSerie(n))) Häufigkeit(4, 100) 20 Häufigkeit(3, 100) 16 Verteilung(n) := VECTOR([i, Häufigkeit(i, n)], i, 1, 6) [[ 1, 16], [2, 16], [3, 13], [4, 20], [5, 16], [6, 16]] Nicht korrekt!

72 Programm - Version 2 Wuerfeln := RANDOM(6) + 1
WuerfelSerie(n) := VECTOR(Wuerfeln, m, 1, n) WuerfelSerie(10) [4, 4, 5, 5, 5, 5, 2, 3, 4, 5] Häufigkeit(i, L) := DIMENSION(SELECT(x = i, x, L)) Häufigkeit(5, [4, 4, 5, 5, 5, 5, 2, 3, 4, 5]) 5 Verteilung(L) := VECTOR([i, Häufigkeit(i, L)], i, 1, 6) Verteilung([4, 4, 5, 5, 5, 5, 2, 3, 4, 5]) [[ 1, 0], [2, 1], [3, 1], [4, 3], [5, 5], [6, 0]] Verteilung(WuerfelSerie(100)) [[ 1, 12], [2, 14], [3, 22], [4, 19], [5, 14], [6, 19]] Korrekt!

73 Der RANDOM-Operator Versuch 1: Versuch 2: VECTOR(RANDOM(2), i, 1, 3)
[0, 0, 1] [1, 0, 1] Versuch 2: h(x) := VECTOR(x, i, 1, 3) h(RANDOM(2)) [1, 1, 1] [0, 0, 0] Keine referentielle Transparenz!

74 Auswertungsstrategien
Versuch 1 - Auswertung: erst außen, dann innnen VECTOR(RANDOM(2), i, 1, 3)  [RANDOM(2), RANDOM(2), RANDOM(2)]  [0, 0, 1] Versuch 2 - Auswertung: erst innen, dann außen h(RANDOM(2)) // h(x) := VECTOR(x, i, 1, 3)  h(1)  VECTOR(1, i, 1, 3)  [1, 1, 1] Wenn keine referentielle Transparenz vorhanden ist, muss man detailliertes Wissen über die Arbeitsweise der ausführenden Maschine haben, um korrekte Programme zu erstellen.

75 Warum funktional? Grund 1: (nach B. J. MacLennan, Functional Programming) Programmieren erfolgt ohne Wertzuweisungen. Vorteile: - Programme sind einfacher zu verstehen. - Programme können systematischer erzeugt werden. - Es ist einfacher, Programme zu beurteilen. Beispiel: ADach(bQ,bA,hÜ,hP) = 4 * ATrapez(bQ,sA(bA),hÜT(bQ,bA,hÜ)) + 4 * ADreieck(sA(bA),hÜD(bQ,bA,hÜ)) + 8 * ADreieck(sA(bA),hPD(bA,hP))

76 Warum funktional? Grund 2: (nach B. J. MacLennan, Functional Programming) Funktionale Programmierung unterstützt parallele Verarbeitung. Grund: referentielle Transparenz Beispiel: ADach(bQ,bA,hÜ,hP) = 4 * ATrapez(bQ,sA(bA),hÜT(bQ,bA,hÜ)) + 4 * ADreieck(sA(bA),hÜD(bQ,bA,hÜ)) + 8 * ADreieck(sA(bA),hPD(bA,hP))

77 Warum funktional? Grund 3: (nach B. J. MacLennan, Functional Programming) Funktionales Programmieren erfolgt auf einem höheren Abstraktionsniveau. Beispiel: Sortieren ins(x, [])  [x] ins(x, [e|R])  IF(x < e, [x|[e| R]], [e|ins(x, R)]) sort([])  [ ] sort([e|R])  ins(e, sort(R))

78 Warum funktional? Grund 4: (nach B. J. MacLennan, Functional Programming) Funktionale Programmierung wird sehr viel in der KI (künstliche Intelligenz) verwendet. Grund 5: (nach B. J. MacLennan, Functional Programming) Funktionale Programmierung erlaubt es, schnell Prototypen zu entwickeln (Programme als ausführbare Spezifikationen). Grund 6: (nach B. J. MacLennan, Functional Programming) Funktionale Programmierung ist eng verknüpft mit der theoretischen Informatik: liefert ein Programmiermodell, das sich gut eignet, allgemeine Fragestellungen zu untersuchen.

79 Funktionale Sprachen -Kalkül (Church und Kleene; 30er Jahre)
LISP (McCarthy; um 1960) LOGO (Papert; 80er Jahre) ML (Milner 1984;  Caml) Miranda (Turner 1985) Haskell (Hudak u. a. 1992)

80 Funktionale Sprachen Reduktionsregeln: Implementierung mit Derive:
DelEr(x, [])  [] DelEr(x, [e|R])  IF(x=e, R, [e | DelEr(x,R)] ) Implementierung mit Derive: DelEr(x, L) := IF(DIMENSION(L)=0, [], IF(x=ER(L), OE(L), ME(ER(L), DelEr(x, OE(L)))))

81 Funktionale Sprachen Reduktionsregeln: Implementierung in LOGO:
DelEr(x, [])  [] DelEr(x, [e|R])  IF(x=e, R, [e | DelEr(x,R)] ) Implementierung in LOGO: PR DelEr :x :L PRÜFE :L = [ ] WW RG [] WF PRÜFE :x = ER :L WW RG OE(L) WF RG ME ER :L DelEr :x OE :L

82 Funktionale Sprachen Reduktionsregeln: Implementierung in CAML:
DelEr(x, [])  [] DelEr(x, [e|R])  IF(x=e, R, [e | DelEr(x,R)] ) Implementierung in CAML: let rec DelEr = function (x, []) -> [] | (x, e::r) -> if x = e then r else e::DelEr(x,r);; DelEr : `a * `a list -> `a list = <fun>

83 ... und in der Schule? Klarer Programmierstil Einfache, kurze, durchschaubare Programme Funktionale Programmierung Funktionales Denken „andere“ Form des Programmierens Fazit: Funktionale Programmierung ist gut / bestens geeignet für die Schule.

84 Literatur [Becker 99] K. Becker: Funktionale Programmierung. Materialien zum Lehrplan Informatik. LMZ (http://informatikag.bildung-rp.de/html/funktprog.html) [Becker 00] K. Becker: Problemlösen mit dem Computeralgebrasystem Derive - informatisch betrachtet. (http://informatikag.bildung-rp.de/html/derive.html) [Fischbacher 97] T. Fischbacher: Funktionale Programmierung. In: LOG IN 17 (1997) Heft 3 / 4, S [ISB 97] Staatliches Institut für Schulpädagogik und Bildungsforschung München (Hrsg.): Funktionales Programmieren in Gofer. Baustein zur Didaktik der Informatik. München, 1997. [Puhlmann 98] H. Puhlmann: Funktionales Programmieren - Eine organische Verbindung von Informatikunterricht und Mathematik. In: LOG IN 18 (1998) Heft 2, S [Schwill 93] A. Schwill: Funktionale Programmierung mit Caml. In: LOG IN 13 (1993) Heft 4, S [MacLennan ??] B.J. MacLennan: Functional Programming: Addison-Wesley ??. [Wagenknecht 94] Christian Wagenknecht: Rekursion. Ein didaktischer Zugang mit Funktionen. Bonn: Dümmlers Verlag 1994. [Wolff von Gudenberg 96] J. Wolff. von Gudenberg: Algorithmen, Datenstrukturen, Funktionale Programmierung. Eine praktische Einführung mit Caml Light. Bonn: Addison-Wesley 1996.


Herunterladen ppt "Funktionale Programmierung"

Ähnliche Präsentationen


Google-Anzeigen