Funktionale Programmierung IFB 12002 Klaus Becker Funktionale Programmierung

Funktionale Programmierung IFB 1/2002 Klaus Becker

Funktionale Programmierung 2 © KB 2002 Teil 1 Programmieren mit Funktionen

Funktionale Programmierung 3 © KB 2002 an Mosel, Saar und Ruwer

Funktionale Programmierung 4 © KB 2002 Kirchtürme

Funktionale Programmierung 5 © KB 2002 Kirchtürme

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

Dachstruktur Funktionale Programmierung 7 Pyramidendreieck Übergangsdreieck 4 * AÜbergangs. Trapez + 4 * AÜbergangs. Dreieck + 8 * APyramiden. Dreieck Übergangstrapez © KB 2002 ADach =

Dachparameter Funktionale Programmierung 8 Pyramidendreieck Übergangsdreieck b. A hÜ Übergangstrapez © KB 2002 h. P b. Q

Funktionale Modellierung Funktionale Programmierung 9 © KB 2002 4. 0 2. 0 3. 0 10. 0 ADach b. Q b. A hÜ h. P . . . h. P b. A hÜ b. Q

10 Funktionale Modellierung ADach = Funktionale Programmierung 4 * AÜbergangs. Trapez + 4 * AÜbergangs. Dreieck + 8 * APyramiden. Dreieck ADreieck g h ADreieck(g, h) = 0. 5*g*h © KB 2002 ATrapez a c h ATrapez(a, c, h) = 0. 5*(a+c)*h

11 Funktionale Modellierung Funktionale Programmierung ADach(b. Q, b. A, hÜ, h. P) = © KB 2002 4 * ATrapez(b. Q, s. A, hÜT) + 4 * ADreieck(s. A, hÜD) h. P + 8 * ADreieck(s. A, h. PD) h. PD b. A s. A hÜT hÜ hÜD b. Q

12 Funktionale Modellierung s. A Funktionale Programmierung b. A © KB 2002 h. PD b. A h. P hÜD b. Q b. A hÜT b. Q b. A hÜ h. PD s. A hÜT hÜ hÜD b. Q

13 Funktionale Modellierung s. A Funktionale Programmierung b. A © KB 2002 h. PD b. A h. P 4*ATrapez(b. Q, s. A, hÜT) + 4*ADreieck(s. A, hÜD) + hÜD b. Q b. A hÜ 8*ADreieck(s. A, h. PD) ADach(b. Q, b. A, hÜ, h. P) = 4*ATrapez(b. Q, s. A(b. A), hÜT(b. Q, b. A, hÜ)) + hÜT b. Q b. A hÜ ADach(b. Q, b. A, hÜ, h. P) = 4*ADreieck(s. A(b. A), hÜD(b. Q, b. A, hÜ)) + 8*ADreieck(s. A(b. A), h. PD(b. A, h. P))

14 Funktionale Modellierung s. A Funktionale Programmierung b. A © KB 2002 s. A(b. A) = b. A * tan( /8) h. PD b. A h. PD(b. A, h. P) = ((b. A/2)2 + h. P 2) hÜD b. Q b. A hÜ hÜD(b. Q, b. A, hÜ) = ((( 2 * b. Q - b. A)/2)2 + hÜ 2) hÜT b. Q b. A hÜ hÜT(b. Q, b. A, hÜ) = (((b. Q - b. A)/2)2 + hÜ 2)

15 Funktionales Programm ADreieck(g, h) = 0. 5*g*h Funktionale Programmierung ATrapez(a, c, h) = 0. 5*(a+c)*h © KB 2002 s. A(b. A) = b. A * tan( /8) h. PD(b. A, h. P) = ((b. A/2)2 + h. P 2) hÜD(b. Q, b. A, hÜ) = ((( 2 * b. Q - b. A)/2)2 + hÜ 2) hÜT(b. Q, b. A, hÜ) = (((b. Q - b. A)/2)2 + hÜ 2) ADach(b. Q, b. A, hÜ, h. P) = 4 * ATrapez(b. Q, s. A(b. A), hÜT(b. Q, b. A, hÜ)) + 4 * ADreieck(s. A(b. A), hÜD(b. Q, b. A, hÜ)) + 8 * ADreieck(s. A(b. A), h. PD(b. A, h. P)) Funk. Progr. bestehen aus Funktionsdeklarationen.

Auswertung 16 ADach(10, 5, 4, 20) Funktionale Programmierung © KB 2002 // Funktionsaufruf 4 * ATrapez(10, s. A(5), hÜT(10, 5, 4)) + 4 * ADreieck(s. A(10), hÜD(10, 5, 4)) + 8 * ADreieck(s. A(10), h. PD(5, 20)) 4 * ATrapez(10, 5 * tan( /8), hÜT(10, 5, 4)) + 4 * ADreieck(s. A(10), hÜD(10, 5, 4)) + 8 * ADreieck(s. A(10), h. PD(5, 20)) . . . 306. 012 // Funktionswert Die Auswertung erfolgt durch Termersetzung.

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

Funktionale Programmierung 18 © KB 2002 Methodik: Arbeitsschritte Problemkontext Beschreiben Benutzer Funktionsdeklarationen Funktionsaufruf Derive Lösung Benutzer Deuten Vereinfachen Funktionswert Beschreiben - Vereinfachen - Deuten

Funktionale Programmierung 19 Derive als Programmiersystem Beschreiben: ATrapez(a, c, h) : = 0. 5*(a+c)*h. . . ADach(10, 5, 4, 20) Vereinfachen: (31675 - 21950· 2) +. . . 306. 012 Deuten: © KB 2002 ADreieck(g, h) : = 0. 5*g*h Der Flächeninhalt des Dachs. . .

20 Übungen - Aufgabe 1 Funktionale Programmierung Es soll ein Programm zur Kalkulation der Herstellungskosten eines Buches entwickelt werden. Folgende Informationen sollen dabei modelliert werden: © KB 2002 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. 10000) die Gesamtherstellungskosten errechnen.

Hinweise zu Aufgabe 1 21 Funktionale Programmierung 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 5 4 Implementieren Sie abschließend die Funktionen mit DERIVE. © KB 2002

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

Funktionale Programmierung 23 © KB 2002 Lösung zu Aufgabe 1 Bogen : = 0. 43 Druck : = 0. 27 Satz : = 17. 5 Binden : = 1. 83 Bogen. Anzahl(Seiten) : = FLOOR(Seiten - 1, 16) + 1 Papier. Kosten(Seiten, Auflage) : = Bogen. Anzahl(Seiten)·Bogen·Auflage Setz. Kosten(Seiten) : = Seiten·Satz Druck. Kosten(Seiten, Auflage) : = Bogen. Anzahl(Seiten)·Druck·Auflage Binde. Kosten(Auflage) : = Auflage·Binden Kosten(Seiten, Auflage) : = Papier. Kosten(Seiten, Auflage) + Setz. Kosten(Seiten) + Druck. Kosten(Seiten, Auflage) + Binde. Kosten(Auflage)

24 Lösung zu Aufgabe 2 Funktionale Programmierung Funktiondeklaration ohne Spezifikation des Funktionsterms f(x) : = © KB 2002 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)

Funktionale Programmierung 25 © KB 2002 Teil 2 Datentypen / Datenstrukturen

Funktionale Programmierung 26 © KB 2002 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: Funktionale Programmierung [0, 0] Rechteck als Streckenzug: [[0, 0], [2, 4], [0, 0]] Rechteckfigur als Folge von Rechtecken: [ [[0, 0], [2, 4], [0, 0]], [[2, 0], [4, 16], [2, 0]], [[4, 0], [6, 36], [4, 0]] ] © KB 2002

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

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

Programm 30 Unterteilungsstellen: Funktionale Programmierung 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), RO(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) © KB 2002

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

32 Derive-Implementierung Funktionsdeklarationen: Funktionale Programmierung 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), RO(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(-x 2 + 4, 0, 2, 10) © KB 2002

Funktionale Programmierung 33 © KB 2002 Datentypen / Datenstrukturen Elementare Datentypen: Zahlen: 3; 5. 1; . . . (Wahrheitswerte, Zeichenketten) Funktionen: Terme: x 2 - 1 (Zuordnungen: x x 2 - 1) Listen: inhomogen: [x 2 - 1, 0, [ ] ] (homogen: [[0], [0, 1, 2], [0, 1, 2, 3]])

Funktionale Programmierung 34 © KB 2002 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: Struktur Implementierung Druckauftrag Funktionale Programmierung [4, [31, 62, 75, 92]] Adresse, Daten Liste Verbund Zahl Daten . . Sequenz Zahl Warteschlange: [[4, [31, 62, 75, 92]], [3, []], [7, [102, 101, 77]]] Struktur Implementierung Warteschlange Sequenz . . Druckauftrag © KB 2002 Liste Vereinfachte Warteschlange: [4, 3, 7] Liste

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

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

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

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

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

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

Funktionale Programmierung 42 © KB 2002 Ü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] Mit Hilfe des vordefinierten SUM-Operators kann die gewünschte Anzahl bestimmt werden.

Lösung zu Aufgabe 3 43 L : = [3, 5, 2, 8, 6, 5, 1] Funktionale Programmierung 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] © KB 2002

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

Funktionale Programmierung 45 © KB 2002 Teil 3 Kontrollstrukturen

Funktionale Programmierung 46 © KB 2002 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 Funktionale Programmierung Problem: © KB 2002 An welcher Stelle befindet sich der erste Auftrag von Rechner x? Spezifikation: Adresse: Schlange: Stelle x L Listenel. Liste Bsp. : Stelle(2, [3, 5, 2, 7, 2, 9, 4]) 3 Stelle, an der sich der erste Auftrag von x befindet

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

49 Reduktionsregeln Reduktionsschritte: Funktionale Programmierung 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. © KB 2002

50 DERIVE-Implementierung Reduktionsregeln: Funktionale Programmierung Stelle(x, []) 0 © KB 2002 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))))

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

52 Rekursive Problemreduktion Reduktionsschritte: Funktionale Programmierung Del. Er(3, []) [] © KB 2002 Del. Er (3, [3, 8, 3]) [8, 3] Del. Er(3, [1, 2, 1, 3, 8, 3]) [1 | Del. Er(3, [2, 1, 3, 8, 3])] [1, 2, 1, 8, 3] Reduktionsregeln: Del. Er(x, []) [] Del. Er(x, [e|R]) IF(x=e, R, ME(e, Del. Er(x, R)))

53 DERIVE-Implementierung Reduktionsregeln: Funktionale Programmierung Del. Er(x, []) [] © KB 2002 Del. Er(x, [e|R]) IF(x=e, R, ME(e, Del. Er(x, R))) Implementierung: Del. Er(x, L) : = IF(DIMENSION(L)=0, [], IF(x=ER(L), OE(L), ME(ER(L), Del. Er(x, OE(L)))))

54 Reduktionskonzept Reduktionsregeln: Problemreduktionsschemata Funktionale Programmierung Del. Er(x, []) [] Del. Er(x, [e|R]) IF(x=e, R, ME(e, Del. Er(x, R))) Reduktionskette: Anwendung der Reduktionsregeln Del. Er(3, [1, 2, 1, 3, 8, 3]) ME(1, Del. Er(3, [2, 1, 3, 8, 3])) ME(1, ME(2, Del. Er(3, [1, 3, 8, 3]))) ME(1, ME(2, ME(1, Del. Er(3, [3, 8, 3])))) ME(1, ME(2, ME(1, [8, 3]))) [1, 2, 1, 8, 3] © KB 2002 Funktionsaufruf Funktionswert

55 Zusammenfassung Funktionale Programmierung Kontrollstrukturen © KB 2002 Del. Er(x, L) : = IF(DIMENSION(L)=0, Fallunterscheidung [], IF(x=ER(L), OE(L), ME(ER(L), Del. Er(x, OE(L))))) Komposition Rekursion

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

57 Übung - Aufgabe 5 Funktionale Programmierung Entwickeln Sie funktionale Programme zur Bearbeitung der folgenden Anfragen: © KB 2002 - 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 Funktionale Programmierung Miniprojekt: Wir betrachten die folgende Erweiterung des Warteschlangen-Programms: © KB 2002 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: Funktionale Programmierung Wie viele Aufträge hat Rechner x in der Schlange? © KB 2002 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), 1+Anzahl(x, OE(L)), Anzahl(x, OE(L))))

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

61 Lösung zu Aufgabe 5 Anfrage: Funktionale Programmierung Welche Rechner haben einen Auftrag in der Schlange? © KB 2002 Reduktionsregeln: Benutzer([]) [] Benutzer([e|R]) ME(e, Benutzer(Del. Alle(e, R)) Implementierung: Benutzer(L) : = IF(DIMENSION(L)=0, [], ME(ER(L), Benutzer(Del. Alle(ER(L), OE(L)))))

Funktionale Programmierung 62 © KB 2002 Teil 4 Funktionale Programmierung

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

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

65 Programmierstile Funktionale Programmierung Anfrage Programm: T([x, y], [a, b]) x = b, y = a Inferenzmaschine 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 © KB 2002 Erfassen u. Beschreiben von Sachverhalten

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

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

Funktionale Programmierung 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(b. Q, b. A, hÜ, h. P) = 4 * ATrapez(b. Q, s. A(b. A), hÜT(b. Q, b. A, hÜ)) + 4 * ADreieck(s. A(b. A), hÜD(b. Q, b. A, hÜ)) + © KB 2002 8 * ADreieck(s. A(b. A), h. PD(b. A, h. P))

69 Referentielle Transparenz Funktionale Programmierung Funktionale Programme sind i. a. referentiell transparent. © KB 2002 ADach(b. Q, b. A, hÜ, h. P) = 4 * ATrapez(b. Q, s. A(b. A), hÜT(b. Q, b. A, hÜ)) + 4 * ADreieck(s. A(b. A), hÜD(b. Q, b. A, hÜ)) + 8 * ADreieck(s. A(b. A), h. PD(b. A, h. P)) 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 Funktionale Programmierung . . . © KB 2002 Mit Hilfe eines Programms sollen Würfelserien erzeugt und ausgewertet werden. Das Programm soll insbesondere eine Häufigkeitsverteilung erstellen.

Funktionale Programmierung 71 Programm - Version 1 Wuerfeln : = RANDOM(6) + 1 Wuerfel. Serie(n) : = VECTOR(Wuerfeln, m, 1, n) Wuerfel. Serie(10) [4, 4, 5, 5, 2, 3, 4, 5] Häufigkeit(i, n) : = DIMENSION(SELECT(x = i, x, Wuerfel. Serie(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! © KB 2002

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

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

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

Warum funktional? 75 Grund 1: (nach B. J. Mac. Lennan, Functional Programming) Funktionale Programmierung Programmieren erfolgt ohne Wertzuweisungen. Vorteile: - Programme sind einfacher zu verstehen. - Programme können systematischer erzeugt werden. - Es ist einfacher, Programme zu beurteilen. Beispiel: ADach(b. Q, b. A, hÜ, h. P) = 4 * ATrapez(b. Q, s. A(b. A), hÜT(b. Q, b. A, hÜ)) + 4 * ADreieck(s. A(b. A), hÜD(b. Q, b. A, hÜ)) + © KB 2002 8 * ADreieck(s. A(b. A), h. PD(b. A, h. P))

Warum funktional? 76 Grund 2: (nach B. J. Mac. Lennan, Functional Programming) Funktionale Programmierung unterstützt parallele Verarbeitung. © KB 2002 Grund: referentielle Transparenz Beispiel: ADach(b. Q, b. A, hÜ, h. P) = 4 * ATrapez(b. Q, s. A(b. A), hÜT(b. Q, b. A, hÜ)) + 4 * ADreieck(s. A(b. A), hÜD(b. Q, b. A, hÜ)) + 8 * ADreieck(s. A(b. A), h. PD(b. A, h. P))

77 Warum funktional? Funktionale Programmierung Grund 3: (nach B. J. Mac. Lennan, Functional Programming) © KB 2002 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? Funktionale Programmierung Grund 4: (nach B. J. Mac. Lennan, Functional Programming) © KB 2002 Funktionale Programmierung wird sehr viel in der KI (künstliche Intelligenz) verwendet. Grund 5: (nach B. J. Mac. Lennan, Functional Programming) Funktionale Programmierung erlaubt es, schnell Prototypen zu entwickeln (Programme als ausführbare Spezifikationen). Grund 6: (nach B. J. Mac. Lennan, Functional Programming) Funktionale Programmierung ist eng verknüpft mit der theoretischen Informatik: liefert ein Programmiermodell, das sich gut eignet, allgemeine Fragestellungen zu untersuchen.

Funktionale Sprachen Funktionale Programmierung 79 © KB 2002 -Kalkül (Church und Kleene; 30 er Jahre) LISP (Mc. Carthy; um 1960) LOGO (Papert; 80 er Jahre) ML (Milner 1984; Caml) Miranda (Turner 1985) Haskell (Hudak u. a. 1992)

80 Funktionale Sprachen Reduktionsregeln: Funktionale Programmierung Del. Er(x, []) [] © KB 2002 Del. Er(x, [e|R]) IF(x=e, R, [e | Del. Er(x, R)] ) Implementierung mit Derive: Del. Er(x, L) : = IF(DIMENSION(L)=0, [], IF(x=ER(L), OE(L), ME(ER(L), Del. Er(x, OE(L)))))

81 Funktionale Sprachen Reduktionsregeln: Funktionale Programmierung Del. Er(x, []) [] © KB 2002 Del. Er(x, [e|R]) IF(x=e, R, [e | Del. Er(x, R)] ) Implementierung in LOGO: PR Del. Er : x : L PRÜFE : L = [ ] WW RG [] WF PRÜFE : x = ER : L WW RG OE(L) WF RG ME ER : L Del. Er : x OE : L

82 Funktionale Sprachen Reduktionsregeln: Funktionale Programmierung Del. Er(x, []) [] Del. Er(x, [e|R]) IF(x=e, R, [e | Del. Er(x, R)] ) Implementierung in CAML: let rec Del. Er = function (x, []) -> [] | (x, e: : r) -> if x = e then r else e: : Del. Er(x, r); ; Del. Er : `a * `a list -> `a list = <fun> © KB 2002

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

84 Literatur [Becker 99] K. Becker: Funktionale Programmierung. Materialien zum Lehrplan Informatik. LMZ 1999. (http: //informatikag. bildung-rp. de/html/funktprog. html) Funktionale Programmierung [Becker 00] K. Becker: Problemlösen mit dem Computeralgebrasystem Derive informatisch betrachtet. (http: //informatikag. bildung-rp. de/html/derive. html) © KB 2002 [Fischbacher 97] T. Fischbacher: Funktionale Programmierung. In: LOG IN 17 (1997) Heft 3 / 4, S. 24 -26. [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. 46 -50. [Schwill 93] A. Schwill: Funktionale Programmierung mit Caml. In: LOG IN 13 (1993) Heft 4, S. 20 -30. [Mac. Lennan ? ? ] B. J. Mac. Lennan: 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.