Funktionale Programmierung IFB 1/2002 Klaus Becker

Programmieren mit Funktionen Teil 1 Programmieren mit Funktionen

an Mosel, Saar und Ruwer

Kirchtürme

Kirchtürme

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

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

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

Funktionale Modellierung ADach 4.0 bQ 2.0 bA ... 3.0 hÜ hP 10.0 hP bA hÜ bQ

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

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Ü hÜD bQ

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

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Ü hÜT bQ bA hÜ

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Ü hÜT bQ hÜT(bQ,bA,hÜ) = (((bQ - bA)/2)2 + hÜ2) bA hÜ

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.

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)) +  ... ...  306.012 // Funktionsaufruf // Funktionswert Die Auswertung erfolgt durch Termersetzung.

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

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

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: (31675 - 21950· 2) +... 306.012 Deuten: Der Flächeninhalt des Dachs ...

Ü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. 10000) die Gesamtherstellungskosten errechnen.

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.

Ü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.

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)

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)

Datentypen / Datenstrukturen Teil 2 Datentypen / Datenstrukturen

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.

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]] ]

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:

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:

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)

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:

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)

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

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.

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]

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

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

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, 1, DIMENSION(L)+1) IF-Operator Syntax: IF( Bedingung, then-Ausdruck, else-Ausdruck ) Bsp.: IF( x = y, 1, 0) IF( x > 0, x2, -x2 )

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

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

Ü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

Ü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.

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]

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

Teil 3 Kontrollstrukturen

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?

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

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

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.

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))))

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]

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)))

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)))))

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

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

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

Ü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.

Ü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.

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), 1+Anzahl(x,OE(L)), Anzahl(x,OE(L))))

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)))))

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)))))

Funktionale Programmierung Teil 4 Funktionale Programmierung

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

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

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

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

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

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))

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;

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

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!

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!

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!

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.

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))

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))

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))

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.

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)

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)))))

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

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>

... 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.

Literatur [Becker 99] K. Becker: Funktionale Programmierung. Materialien zum Lehrplan Informatik. LMZ 1999. (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. 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. [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.