1 / 110

Funktionale Programmierung

Funktionale Programmierung. Klaus Becker 2004. Teil 1. Programmieren mit Funktionen. an Mosel, Saar und Ruwer. Kirchtürme. Aus welchen Flächen sind die Dächer aufgebaut? Welche Parameter bestimmen das Aussehen?. Dachstruktur. Pyramiden-dreieck. Übergangs-dreieck. Übergangstrapez. hP.

belle
Download Presentation

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 Klaus Becker 2004

  2. Teil 1 Programmieren mit Funktionen

  3. an Mosel, Saar und Ruwer

  4. Kirchtürme Aus welchen Flächen sind die Dächer aufgebaut? Welche Parameter bestimmen das Aussehen?

  5. Dachstruktur Pyramiden-dreieck Übergangs-dreieck Übergangstrapez

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

  7. Dachrenovierung Problem: Wie viele Schiefer wird benötigt, um ein Kirchturmdach neu zu decken? Ziel: Es soll ein Programm entwickelt werden, mit dem man für verschieden dimensionierte Kirchturmdächer den Gesamtflächeninhalt berechnen kann.

  8. hP bA hÜ bQ Funktionale Modellierung ADach 10.0 bQ 5.0 bA ... 4.0 hÜ 20.0 hP Spezifikation: Die Funktion ADach soll aus den Dachparame-tern den Flächeninhalt des zugehörigen Kirch-turmdachs berechnen. Dachparameter

  9. Teilprobleme Berechnung des Flächeninhalts eines Pyramidendreiecks Pyramiden-dreieck Berechnung des Flächeninhalts eines Übergangsdreiecks Übergangs-dreieck Berechnung des Flächeninhalts eines Übergangstrapezes Übergangstrapez

  10. Pyramidendreieck Zur Berechnung des Flächeninhalts eines Pyramidendreiecks benötigt man die Seitenlänge sA des Achtecks und die Höhe hPD des Pyramidendreiecks. hP hPD bA sA hÜ bQ Dachparameter

  11. Übergangsdreieck Zur Berechnung des Flächeninhalts eines Übergangsdreiecks benötigt man die Seitenlänge sA des Achtecks und die Höhe hÜD des Übergangsdreiecks. hP bA sA hÜ hÜD bQ Dachparameter

  12. Übergangstrapez Zur Berechnung des Flächeninhalts eines Übergangstrapezes benötigt man die Seitenlänge sA des Achtecks, die Seitenlänge bQ des Quadrates und die Höhe hÜT des Übergangstrapezes. hP bA sA hÜ hÜT bQ Dachparameter

  13. Funktionale Modellierung sA bA sA: Funktion zur Berechnung der Seitelänge des Achtecks bA: Eingabeparameter hP hPD bA sA hÜ hÜD hÜT bQ

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

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

  16. Berechnungsvorschriften sA bA sA(bA) := bA * tan(/8) /8 Gegenkathete sA/2 tan(/8) = = Ankathete bA/2 Überprüfen Sie die Korrektheit der oben angegebenen Berechnungsvorschrift. Entwickeln Sie die noch fehlenden Berechnungsvorschriften für hPD, hÜD, hÜT.

  17. Berechnungsvorschriften sA bA sA(bA) := bA * tan(/8) hPD bA hP hÜD bQ bA hÜ hÜT bQ bA hÜ

  18. Zur Kontrolle 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Ü

  19. Flächeninhalt des Dachs Pyramiden-dreieck Übergangs-dreieck ADach = 4 * AÜbergangsTrapez + 4 * AÜbergangsDreieck + 8 * APyramidenDreieck Übergangstrapez

  20. Hilfsfunktionen ADreieck ATrapez g a h c h ADreieck(g,h) := 0.5*g*h ATrapez(a,c,h) := 0.5*(a+c)*h c h h g a

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

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

  23. Berechnungsprogramm 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)) ADach(10, 5, 4, 20)

  24. Funktionale Programme Funktions-deklarationen ADreieck(g,h) := 0.5*g*h ... 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)) Funktionsaufruf ADach(10, 5, 4, 20) Ein funktionales Programm besteht aus einer endlichen Menge von Funktionsdeklarationen und einem Berechnungsausdruck (Funktionsaufruf).

  25. Derive als Programmiersystem Funktions-deklarationenFunktionsaufruf Beschreiben Problem-kontext Benutzer Verein-fachen Derive Benutzer Lösung Funktionswert Deuten Beschreiben - Vereinfachen - Deuten

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

  27. Die Arbeit von Derive // 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 / Funktionsanwendung.

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

  29. Modellierungskonzept Miniwelt „Dreieck“: Modellwelt „Dreieck“: A g A A h h A(g, h) := 0.5*g*h g 1. Sicht:Mit Funktionen beschreibt man Abhängigkeiten zwischen Objekten.

  30. Modellierungskonzept Miniwelt „Dreieck“: Modellwelt „Dreieck“: A g A A h h A(g, h) := 0.5*g*h g A(6, 3) 9 2. Sicht:Mit funktionalen Ausdrücken beschreibt man Objekte.

  31. Die Arbeit von Derive Berechnungs-ausdruck ADach(10, 5, 4, 20) ADreieck(g,h) := 0.5*g*hATrapez(a,c,h) := 0.5*(a+c)*hsA(bA) := bA * tan(/8) ... Funktions-deklarationen Derive Berechnungs-ergebnis 306.012 Derive arbeitet als Reduktionsmaschine. Es erzeugt mit Hilfe der vorgegebenen Funktionsdeklarationen aus dem Berechnungsausdruck das Berechnungsergebnis (bzw. es reduziert eine abstrakte Objektbeschreibung in eine konkrete).

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

  33. Teil 2 Datentypen / Datenstrukturen

  34. Zeichenprogramm Es soll ein Programm erstellt werden, mit dem man Kirchturmdächer veranschaulichen kann. Es soll dabei möglich sein, die Dachparameter beliebig vorzugeben.

  35. Datenrepräsentation S Dach: Q1Q2 Q2Q3 ... Q1A1 Q1A2 ... A1A2 A2A3 ... A1S A2S ... Dachgerüst .. Sequenz Kante Kante Verbund Punkt Punkt A3 A2 A1 Punkt Verbund Q2 Q1 Q3 Q4 x-Koord. y-Koord. z-Koord.

  36. Datenrepräsentation mit Listen Punkt als Liste mit x-, y- und z-Koordinate: [0, 0, 10] Kante als Liste mit Anfangs- und Endpunkt: [[0, 0, 1], [2, 0, 0]] Kantengerüst eines Turms als Liste von Kanten: [ [[2, 2, 0], [-2, 2, 0]], [[-2, 2, 0], [-2, -2, 0]], [[-2, -2, 0], [2, -2, 0]], ... ] Die Datenstrukturen „Sequenz“ und „Verbund“ werden mit Hilfe von Listen beschrieben.

  37. Listen in DERIVE Liste:Folge von Objekten (Zahlen, Terme, Listen) Beispiele: [0, 1, 2, 3] // Liste mit Zahlen [1, x, x2, x3] // Liste mit Termen [[], [0], [[0]]] // Liste mit Listen [1, [1], x] // gemischte Liste

  38. hP hÜ bQ Funktionale Modellierung S Eckpunkte: Q1 Koordinaten des Punktes bQ A1 bA Koordinaten des Punktes hÜ A1 bA S Q1 hÜ Koordinaten des Punktes hP

  39. hP hÜ bQ Berechnungsvorschriften Q2 Q1 A2 A3 S(0 | 0 | hÜ+hP) A1 A4 S A8 A5 A7 A6 Q3 Q4 sA A1(bA/2 | sA/2 | hÜ) bA Q1(bQ/2 | bQ/2 | 0) (0 | 0 | 0)

  40. Funktionales Programm Exkpunkte: Q1(bQ) := [bQ/2, bQ/2, 0] Q2(bQ) := ... A1(bA, hÜ) := [bA/2, sA(bA)/2, hÜ] A2(bA, hÜ) := ... S(hÜ, hP) := [0, 0, hÜ+hP] Kantengerüst: KantenGerüst(bQ, bA, hÜ, hP) := [ [Q1(bQ), Q2(bQ)], [Q2(bQ), Q3(bQ)], ... ] Funktionsaufruf: KantenGerüst(4, 2, 2, 8)

  41. Berechnungsergebnis Kantengerüst: [ [[2, 2, 0], [-2, 2, 0]], [[-2, 2, 0], [-2, -2, 0]], ...] Schwierigkeit: Darstellung im zwei-dimensionalen Koordinatensystem

  42. Projektion Problem: Projektion vom einem dreidimensionalen Koordinatensystem in ein zweidimensionales Koordinatensystem z (1|2|1) y x y (1.7|1.7) x

  43. Projektion eines Punktes z z z (0|0|1) y y y (0|1|0) (1|0|0) x x x y y y (0|1) (0.35|0.35) (1|0) x x x

  44. Projektion eines Punktes z ProjektionPunkt Koordinaten der Projektion P (a|b|c) y x ProjektionPunkt(P) := [P1 + 0.35*P2, 0.35*P2 + P3] y (a+0.35b|0.35b+c) x

  45. DIMENSION Liste Anzahl der Listenelemente Liste: L Bsp.: DIMENSION([3,5,7,2,9,4])  6 Listenoperationen in Derive 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 statt ELEMENT([3,5,7,2,9,4], 2)

  46. VECTOR Term Term: xn nat. Zahl Laufvariable: n nat. Zahl Anfangswert: 0 [1, x, x2, x3] nat. Zahl Endwert: 3 nat. Zahl Schrittweite: 1 Listenoperationen in Derive Bsp.: VECTOR(x^n, n, 0, 3)  [1, x, x2, x3] VECTOR(i^2, i, 0, 10, 2)  VECTOR([1, 2, 3, 4]i, i, 2, 4) 

  47. Implementierung in Derive ProjektionPunkt(P) := [P1 + 0.35*P2, 0.35*P2 + P3] ProjektionKante(K) := [ProjektionPunkt(K1), ProjektionPunkt(K2)] ProjektionKantenliste(L) := VECTOR(ProjektionKante(L i), i, 1, DIMENSION(L))

  48. Alternative Implementierung ProjektionPunkt(P) := [P1 + 0.35*P2, 0.35*P2 + P3] ProjektionKante(K) := VECTOR(ProjektionPunkt(K i), i, 1, DIMENSION(K)) ProjektionKantenliste(L) := VECTOR(ProjektionKante(L i), i, 1, DIMENSION(L))

  49. Exkurs: Funktionen als Objekte ProjektionKante(K) := VECTOR(ProjektionPunkt(K i), i, 1, DIMENSION(K)) ProjektionKantenliste(L) := VECTOR(ProjektionKante(L i), i, 1, DIMENSION(L)) Ziel: Wende eine Funktion auf alle Listenelemente an.

  50. Exkurs: Funktionen als Objekte Ziel: Wende eine Funktion auf alle Listenelemente an. ApplyListe Liste, bei der die Funktion auf alle Listenelemente angewandt wurde Funktion Funktion: f Liste Liste: L Beispiele: ApplyListe(xx2, [1, 2, 3, 4])  [1, 4, 9, 16]ApplyListe(x2x, [1, 2, 3, 4])  [2, 4, 6, 8] Achtung:Funktionen können in gängigen funktionalen Sprachen als Eingabeobjekte neuer Funktionen benutzt werden. In Derive ist das allerdings so nicht möglich.

More Related