1 / 84

Funktionale Programmierung

Funktionale Programmierung. IFB 1/2002. Klaus Becker. Teil 1. Programmieren mit Funktionen. an Mosel, Saar und Ruwer. Kirchtürme. Kirchtürme. Dachberechnungen.

delu
Télécharger la présentation

Funktionale Programmierung

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Funktionale Programmierung IFB 1/2002 Klaus Becker

  2. 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. Pyramiden-dreieck Übergangs-dreieck Übergangstrapez Dachstruktur ADach = 4 * AÜbergangsTrapez + 4 * AÜbergangsDreieck + 8 * APyramidenDreieck

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

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

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

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

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

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

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

  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 // Funktionsaufruf 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)) + 4 * ADreieck(sA(10),hÜD(10,5,4)) + 8 * ADreieck(sA(10),hPD(5,20))  ... ...  306.012 // 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-deklarationenFunktionsaufruf Beschreiben Problem-kontext Benutzer Verein-fachen Derive Benutzer Lösung Funktionswert Deuten Beschreiben - Vereinfachen - Deuten

  19. ADreieck(g,h) := 0.5*g*h ATrapez(a,c,h) := 0.5*(a+c)*h ... ADach(10,5,4,20) (31675 - 21950· 2) +... 306.012 Derive als Programmiersystem Beschreiben: Vereinfachen: 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. 10000) 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. 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. VECTOR Term Term: xn nat. Zahl Laufvariable: n nat. Zahl Anfangswert: 0 [1, x, x2, x3] nat. Zahl Endwert: 3 nat. Zahl Schrittweite: 1 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)

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

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

  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: x2 - 1(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. Warteschlange: [[4, [31,62,75,92]], [3, []], [7, [102,101,77]]] Struktur Implementierung Warteschlange .. Sequenz Liste Druckauftrag Datenmodellierung Druckauftrag: Struktur Implementierung Druckauftrag [4, [31,62,75,92]] Adresse, Daten Liste Verbund Zahl Daten .. Sequenz Liste Zahl Vereinfachte Warteschlange: [4, 3, 7]

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

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

  38. Implementierung 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 )

  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 Liste letztes Element L OL Liste ohne das letzte Element Liste L ME Element a Liste, mit a als neuem erstem Element Liste L

  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: Listenel. x Liste Schlange: L Bsp.: Stelle(2, [3,5,2,7,2,9,4])  3

  48. 4 3 4 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]) Rekursive Problemreduktion: Reduktion des Problems auf ein entsprechendes, aber „verkleinertes“ Problem

  49. Reduktionsregeln 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]) Reduktionsregeln: Stelle(x, [])  0 Stelle(x, [e|R])  IF(x=e, 1, 1+Stelle(x,R)) Reduktionsregeln sind Problemreduktionsschemata.

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

More Related