Funktionale Programmierung Funktionale Programmierung

(1)

Funktionale Programmierung Funktionale Programmierung

IFB 1/2002

Klaus Becker

(2)

2

Funktionale Programmierung

Teil 1 Teil 1

Programmieren mit Funktionen

(3)

3

an Mosel, Saar und Ruwer

(4)

4

Kirchtürme

(5)

5

Kirchtürme

(6)

6

Dachberechnungen Dachberechnungen

Es soll ein Programm erstellt werden, mit dem man für

verschieden dimensionierte

Kirchturmdächer den Gesamtflächeninhalt berechnen kann.

Es soll ein Programm erstellt werden, mit dem man für

verschieden dimensionierte

Kirchturmdächer den

Gesamtflächeninhalt

berechnen kann.

(7)

7

Dachstruktur Dachstruktur

Pyramiden- dreieck

Übergangstrapez Übergangs-

dreieck ADach =

4 * AÜbergangsTrapez + 4 * AÜbergangsDreieck + 8 * APyramidenDreieck ADach =

4 * AÜbergangsTrapez + 4 * AÜbergangsDreieck + 8 * APyramidenDreieck

(8)

8

Dachparameter Dachparameter

bQ bA hP

hÜ Pyramiden-

dreieck

Übergangs- dreieck

(9)

9

Funktionale Modellierung Funktionale Modellierung

bQ bA hP

hÜ bQbA

hÜ hP

ADach 4.02.0

3.0 10.0

...

(10)

10

Funktionale Modellierung Funktionale Modellierung

ADach =

4 * AÜbergangsTrapez + 4 * AÜbergangsDreieck + 8 * APyramidenDreieck ADach =

4 * AÜbergangsTrapez + 4 * AÜbergangsDreieck + 8 * APyramidenDreieck

g h

ADreieck

a c

ATrapez

h

(11)

11

Funktionale Modellierung Funktionale Modellierung

bQ bA

hP

hÜ hPD

sA hÜT hÜD

ADach(bQ,bA,hÜ,hP) =

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

4 * ATrapez(bQ,sA,hÜT) + 4 * ADreieck(sA,hÜD) + 8 * ADreieck(sA,hPD)

(12)

12

Funktionale Modellierung Funktionale Modellierung

bQ bA

hP

hÜ hPD

sA hÜT hÜD

bA

sA

bA hP

hPD

bQ bA

hÜD

hÜ

bQ

hÜT

(13)

13

Funktionale Modellierung Funktionale Modellierung

bA

sA

bA hP

hPD

bQ bA

hÜD

hÜ

bQ bA

hÜT

hÜ

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

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

(14)

14

Funktionale Modellierung Funktionale Modellierung

bA

sA

bA hP

hPD

bQ bA

hÜD

hÜ

bQ

hÜT

sA(bA) = bA * tan(/8) sA(bA) = bA * tan(/8)

hPD(bA,hP) = ((bA/2)² + hP²) hPD(bA,hP) = ((bA/2)² + hP²)

hÜD(bQ,bA,hÜ) =

(((2 * bQ - bA)/2)² + hÜ²) hÜD(bQ,bA,hÜ) =

(((2 * bQ - bA)/2)² + hÜ²)

(15)

15

Funktionales Programm 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)² + hP²)

hÜD(bQ,bA,hÜ) = (((2 * bQ - bA)/2)² + hÜ²) hÜT(bQ,bA,hÜ) = (((bQ - bA)/2)² + hÜ²)

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

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)² + hP²)

hÜD(bQ,bA,hÜ) = (((2 * bQ - bA)/2)² + hÜ²) hÜT(bQ,bA,hÜ) = (((bQ - bA)/2)² + hÜ²)

Funk. Progr. bestehen aus Funktionsdeklarationen.

(16)

16

Auswertung Auswertung

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

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

// Funktionsaufruf

// Funktionswert

(17)

17

Zusammenfassung Zusammenfassung

Mit Funktionen kann man programmieren.

Die Programme bestehen aus Funktionsdeklarationen.

Die Programmauswertung erfolgt durch Funktionsanwendung

(Termersetzung).

(18)

18

Methodik: Arbeitsschritte Methodik: Arbeitsschritte

Beschreiben - Vereinfachen - Deuten Beschreiben - Vereinfachen - Deuten

Derive

Funktions- deklarationen Funktionsaufruf

Verein- fachen Problem-

kontext

Lösung

Beschreiben Benutzer

Funktionswert Deuten

Benutzer

(19)

19

Derive als Programmiersystem 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:

Deuten:

Der Flächeninhalt des Dachs ...

(31675 - 21950· 2) +...

306.012

(20)

20

Übungen - Aufgabe 1 Ü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)

21

Hinweise zu Aufgabe 1 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:

23

FLOOR

5 4

Implementieren Sie abschließend die Funktionen mit DERIVE.

(22)

22

Übungen - Aufgabe 2 Ü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)

23

Lösung zu Aufgabe 1 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)

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)

24

Lösung zu Aufgabe 2 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) 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)

25

Teil 2 Teil 2

Datentypen / Datenstrukturen

(26)

26

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

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)

27

Datenmodellierung mit Listen 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)

28

Listen in DERIVE Listen in DERIVE

Liste: Folge von Objekten (Zahlen, Terme, Listen)

[0, 1, 2, 3]

[1, x, x², x³] [[], [0], [[0]]]

Liste: Folge von Objekten (Zahlen, Terme, Listen)

[0, 1, 2, 3]

[1, x, x², x³] [[], [0], [[0]]]

Erzeugung von Listen:

- Aufzählung der Listenelemente - Generierung mit dem VECTOR-Operator [1, x, x², x³] VECTOR(xⁿ, n, 0, 3, 1)

Erzeugung von Listen:

- Aufzählung der Listenelemente - Generierung mit dem VECTOR-Operator [1, x, x², x³] VECTOR(xⁿ, n, 0, 3, 1)

Term

VECTOR nat. Zahl nat. Zahl

xⁿ Laufvariable:

0 [1, x, x , x ]

n Anfangswert:

Term:

(29)

29

Spezifikation der Funktionen Spezifikation der Funktionen

Rechteckpunkte:

nat. Zahl LU nat. Zahl nat. Zahl nat. Zahl

a Intervallgrenze:

n i

Koordinaten der linken unteren Ecke von Rechteck Nummer i b

Unterteilungen:

Nummer:

Intervallgrenze:

Rechteck:

nat. Zahl Rechteck nat. Zahl nat. Zahl nat. Zahl

a Intervallgrenze:

n i

Koordinaten der Punkte des

Streckenzugs zum Rechteck Nummer i b

Unterteilungen:

Nummer:

Intervallgrenze:

Rechteckfigur:

nat. Zahl RF nat. Zahl nat. Zahl

a Intervallgrenze:

n

Koordinaten der Punkte des

Streckenzugs zur Rechteckfigur b

Unterteilungen:

Intervallgrenze:

(30)

30

Programm Programm

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:

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

Unterteilungsstellen:

d(a, b, n) := (b - a) / n

s(a, b, n, i) := a + i·d(a, b, n)

(31)

31

Funktion als Eingabeobjekt Funktion als Eingabeobjekt

Spezifikation:

_RF

nat. Zahl nat. Zahl nat. Zahl

Intervallgrenze:

b n

Koordinaten der Punkte des Streckenzugs zur

Rechteckfigur a

Intervallgrenze:

Unterteilungen:

R  R

f Randfunktion:

„Trick“:

Term

A(pply) Term

T Einsetzungsterm:

Neuer Term, bei dem x

jeweils durch u ersetzt ist

Funktionsterm:

u

Beispiele: A(x², 4)  16; A(x², y-1)  (y-1)²

Implementierung in Derive:

(32)

32

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

(33)

33

Datentypen / Datenstrukturen Datentypen / Datenstrukturen

Elementare Datentypen:

Zahlen: 3; 5.1; ...

(Wahrheitswerte, Zeichen, Zeichenketten) Funktionen:

Terme: x

²

- 1

(Zuordnungen: x  x

²

- 1) Listen:

inhomogen: [x

²

- 1, 0, [ ] ]

(homogen: [[0], [0, 1], [0, 1, 2], [0, 1, 2, 3]]) Elementare Datentypen:

Zahlen: 3; 5.1; ...

(Wahrheitswerte, Zeichen, Zeichenketten) Funktionen:

Terme: x

²

- 1

(Zuordnungen: x  x

²

- 1) Listen:

inhomogen: [x

²

- 1, 0, [ ] ]

(homogen: [[0], [0, 1], [0, 1, 2], [0, 1, 2, 3]])

(34)

34

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

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)

35

Datenmodellierung Datenmodellierung

Druckauftrag:

[4, [31,62,75,92]]

Adresse, Daten

Druckauftrag

Zahl Daten

Zahl

..

Verbund

Sequenz

Struktur Implementierung

Liste

Warteschlange:

[[4, [31,62,75,92]], [3, []], [7, [102,101,77]]]

Warteschlange

Druckauftrag

..

Sequenz

Struktur Implementierung

Liste

Vereinfachte Warteschlange:

(36)

36

Warteschlangen-Operationen Warteschlangen-Operationen

Spezifikation:

Liste ER

L erstes Element

Schlange:

Liste OE

L Schlange ohne das erste

Element Schlange:

Liste ML Element

L Auftrag:

Schlange, mit a als neuem letztem Element

a Schlange:

(37)

37

Listenoperatoren von DERIVE Listenoperatoren von DERIVE

Vordefinierte Operatoren

Liste

ELEMENT nat. Zahl

L Nummer:

Listenelement an der Stelle i

i Liste:

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)

38

Implementierung 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) 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, x², -x²)

(39)

39

Zusammenfassung Zusammenfassung

elementare Datentypen Liste als zentrale

Datenstruktur;

zur Verarbeitung von Listen benötigt man elementare

Listenoperationen

Funktionen als Datenobjekte

(40)

40

Methodik: Programmieren Methodik: Programmieren

Schritt 1:

Spezifikation der Funktion

a) Signatur (Typen der Parameter; Ergebnistyp) b) Verhalten (informelle Beschreibung; Beispiele) Spezifikation der Funktion

a) Signatur (Typen der Parameter; Ergebnistyp) b) Verhalten (informelle Beschreibung; Beispiele)

Schritt 2:

Deklaration der Funktion Deklaration der Funktion

Schritt 3:

Implementierung der Funktion Implementierung der Funktion

(41)

41

Übung: Aufgabe 3 Übung: Aufgabe 3

Implementieren und testen Sie die folgenden Operationen zur Listenverarbeitung:

Liste LE

L letztes Element

Liste OL

L Liste ohne das letzte

Element

Element ME Liste

a Liste, mit a als neuem

erstem Element L

(42)

42

Übung: Aufgabe 4 Ü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)

43

Lösung zu Aufgabe 3 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 := [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)

44

Lösung zu Aufgabe 4 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

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)

45

Teil 3 Teil 3

Kontrollstrukturen

(46)

46

Bearbeitung von Anfragen 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“

Das Programm zur Verwaltung von Druckaufträgen soll auch Anfragen von Benutzern bearbeiten

können.

Z.B.: An welcher Stelle befindet sich „mein Auftrag“

(47)

47

Spezifikation zur Anfrage Spezifikation zur Anfrage

An welcher Stelle befindet sich der erste Auftrag von Rechner x?

Problem:

Listenel.

Stelle

Liste x

Schlange:

Stelle, an der sich der erste Auftrag von x befindet

L Adresse:

Bsp.: Stelle(2, [3,5,2,7,2,9,4])  3

Spezifikation:

(48)

48

Rekursive Problemreduktion Rekursive Problemreduktion

Reduktionsschritte:

Stelle(3, [])  0

Stelle(3, [1, 2, 1, 3, 8, 3])  1 + Stelle(3, [2, 1, 3, 8, 3]) Stelle(3, [3, 8, 3])  1

4 3

4

Rekursive Problemreduktion:

Reduktion des Problems auf ein entsprechendes, aber Rekursive Problemreduktion:

Reduktion des Problems auf ein entsprechendes, aber

(49)

49

Reduktionsregeln Reduktionsregeln

Reduktionsschritte:

Reduktionsregeln:

Stelle(x, [])  0

Stelle(x, [e|R])  IF(x=e, 1, 1+Stelle(x,R)) Stelle(x, [])  0

Stelle(x, [e|R])  IF(x=e, 1, 1+Stelle(x,R)) Stelle(3, [])  0

Stelle(3, [1, 2, 1, 3, 8, 3])  1 + Stelle(3, [2, 1, 3, 8, 3]) Stelle(3, [3, 8, 3])  1

Reduktionsregeln sind Problemreduktionsschemata.

(50)

50

DERIVE-Implementierung DERIVE-Implementierung

Reduktionsregeln:

Stelle(x, [])  0

Stelle(x, [e|R])  IF(x=e, 1, 1+Stelle(x,R)) 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)))) Stelle(x, L) :=

IF(DIMENSION(L)=0,0,

IF(x=ER(L), 1, 1+Stelle(x,OE(L))))

(51)

51

eine Löschanfrage eine Löschanfrage

Lösche den ersten Auftrag von Rechner x.

Problem:

Listenel.

LöscheErstes

Liste x

Schlange:

Liste ohne den ersten vorkommenden Auftrag von x

L Adresse:

Bsp.: LöscheErstes(2, [3,5,2,7,2,9,4])  [3,5,7,2,9,4]

Spezifikation:

(52)

52

Rekursive Problemreduktion Rekursive Problemreduktion

Reduktionsschritte:

DelEr(3, [])  []

DelEr(3, [1, 2, 1, 3, 8, 3])  [1 | DelEr(3, [2, 1, 3, 8, 3])]

DelEr (3, [3, 8, 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)

53

DERIVE-Implementierung DERIVE-Implementierung

Implementierung:

DelEr(x, L) :=

IF(DIMENSION(L)=0, [],

IF(x=ER(L), OE(L), ME(ER(L), DelEr(x, OE(L))))) DelEr(x, L) :=

IF(x=ER(L), OE(L), ME(ER(L), DelEr(x, OE(L)))))

Reduktionsregeln:

DelEr(x, [])  []

DelEr(x, [e|R])  IF(x=e, R, ME(e, DelEr(x,R))) DelEr(x, [])  []

(54)

54

Reduktionskonzept Reduktionskonzept

Reduktionskette: Anwendung der Reduktionsregeln 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])))) 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]))))

Reduktionsregeln: Problemreduktionsschemata Reduktionsregeln: Problemreduktionsschemata

DelEr(x, [])  []

DelEr(x, [e|R])  IF(x=e, R, ME(e, DelEr(x,R))) DelEr(x, [])  []

Funktionsaufruf

(55)

55

Zusammenfassung Zusammenfassung

Kontrollstrukturen

DelEr(x, L) :=

IF(x=ER(L), OE(L),

ME(ER(L), DelEr(x, OE(L)))))

Rekursion

Komposition Fallunterscheidung

(56)

56

Methodik: Rekursion Methodik: Rekursion

Schritt 1:

Entwurf typischer, exemplarischer Reduktionsschritte

(Korrektheitsbetrachtungen, Terminationsbetrachtungen) Entwurf typischer, exemplarischer Reduktionsschritte

(Korrektheitsbetrachtungen, Terminationsbetrachtungen)

Schritt 2:

Verallgemeinerung zu Reduktionsregeln Verallgemeinerung zu Reduktionsregeln

Schritt 3:

Beschreibung mit einer rekursiven Funktion Beschreibung mit einer rekursiven Funktion

(57)

57

Übung - Aufgabe 5 Ü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)

58

Übung - Aufgabe 6 Ü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

(59)

59

Lösung zu Aufgabe 5 Lösung zu Aufgabe 5

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)) 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)))) Anzahl(x, L) :=

IF(DIMENSION(L)=0,0, IF(x=ER(L),

1+Anzahl(x,OE(L)), Anzahl(x,OE(L))))

Anfrage:

(60)

60

Lösung zu Aufgabe 5 Lösung zu Aufgabe 5

Lösche alle Aufträge von Rechner x in der Schlange.

Reduktionsregeln:

Implementierung:

Anfrage:

DelAlle(x, [])  []

DelAlle(x, [e|R])  IF(x=e, DelAlle(x,R), ME(e, DelAlle(x,R))) DelAlle(x, [])  []

DelAlle(x, [e|R])  IF(x=e, DelAlle(x,R), ME(e, DelAlle(x,R)))

DelAlle(x, L) :=

IF(DIMENSION(L)=0, [], IF(x=ER(L),

DelAlle(x, L) :=

IF(DIMENSION(L)=0, [], IF(x=ER(L),

(61)

61

Lösung zu Aufgabe 5 Lösung zu Aufgabe 5

Welche Rechner haben einen Auftrag in der Schlange?

Reduktionsregeln:

Implementierung:

Anfrage:

Benutzer([])  []

Benutzer([e|R])  ME(e, Benutzer(DelAlle(e,R)) Benutzer([])  []

Benutzer([e|R])  ME(e, Benutzer(DelAlle(e,R))

Benutzer(L) :=

ME(ER(L), Benutzer(DelAlle(ER(L), OE(L))))) Benutzer(L) :=

ME(ER(L), Benutzer(DelAlle(ER(L), OE(L)))))

(62)

62

Teil 4 Teil 4

Funktionale Programmierung

(63)

63

ein Problem - drei Lösungen ein Problem - drei Lösungen

Tauschen(x, y) z := x

x := y y := z

Tauschen(x, y) z := x

x := y y := z imperative Lösung

Tauschen([x, y]) = [y, x]

funktionale Lösung

Tauschen([x, y], [a, b])

 x = b, y = a

Tauschen([x, y], [a, b])

 x = b, y = a

Logik-basierte Lösung

(64)

64

Programmierstile Programmierstile

Registerbelegung

Register- maschine Registerbelegung

Programm: z := x x := y y := z

Imperative Programmierung

Das Programm besteht aus Anweisungen.

Die Registermaschine verändert die Register- belegung gemäß den Anweisungen.

Imperative Programmierung

Das Programm besteht aus Anweisungen.

Die Registermaschine verändert die Register- belegung gemäß den Anweisungen.

(65)

65

Programmierstile Programmierstile

Ergebnis

Inferenz- maschine Anfrage

Programm: T([x, y], [a, b])

 x = b, y = a

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.

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 Logisches Denken

(66)

66

Programmierstile Programmierstile

Ergebnisterm

Reduktions- maschine Ausgangsterm

Programm: Tauschen([x, y])

= [y, x]

Das Programm besteht a. Funktionsdeklarationen.

Die Reduktionsmaschine vereinfacht den Aus- gangsterm mit Hilfe der Funktionsdeklarationen.

Das Programm besteht a. Funktionsdeklarationen.

Die Reduktionsmaschine vereinfacht den Aus- gangsterm mit Hilfe der Funktionsdeklarationen.

(67)

67

Funktionales Denken Funktionales Denken

Funktionale Ausdrücke /Terme

beschreiben Problemwerte

Funktionsterme beinhalten Berechnungsregeln Funktionen beschreiben

Ein-/Ausgabe-Sit. bzw.

Berechnungssituationen

Funktionale Ausdrücke / Terme

sind referentiell transparent

(68)

68

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

4 * ATrapez(bQ,sA(bA),hÜT(bQ,bA,hÜ)) + ADach(bQ,bA,hÜ,hP) =

4 * ATrapez(bQ,sA(bA),hÜT(bQ,bA,hÜ)) +

- Term muss nur einmal dargestellt / ausgewertet werden - Reihenfolge der Auswertung irrelevant

- parallele Auswertung ist möglich

- keine Seiteneffekte, die das Verhalten komplizieren

(69)

69

Referentielle Transparenz Referentielle Transparenz

Funktionale Programme sind i. a. referentiell transparent.

Imperative Programme sind i. a. referentiell undurchsichtig.

s := 0;

x := x + 1 s := s + x;

x := x + 1;

s := s + 1;

s := 0;

x := x + 1 s := s + x;

x := x + 1;

s := s + 1;

(70)

70

Auswertung von Würfelserien Auswertung von Würfelserien

Mit Hilfe eines Programms sollen Würfelserien

erzeugt und ausgewertet werden. Das Programm soll insbesondere eine Häufigkeitsverteilung

erstellen.

Mit Hilfe eines Programms sollen Würfelserien

erzeugt und ausgewertet werden. Das Programm soll insbesondere eine Häufigkeitsverteilung

erstellen.

...

(71)

71

Programm - Version 1 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]]

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

72

Programm - Version 2 Programm - Version 2

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

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

(73)

73

Der RANDOM-Operator Der RANDOM-Operator

Versuch 1:

VECTOR(RANDOM(2), i, 1, 3) [0, 0, 1]

VECTOR(RANDOM(2), i, 1, 3) [1, 0, 1]

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]

h(x) := VECTOR(x, i, 1, 3) h(RANDOM(2))

[1, 1, 1]

h(RANDOM(2)) [0, 0, 0]

Keine referentielle Transparenz!

(74)

74

Auswertungsstrategien Auswertungsstrategien

Versuch 1 - Auswertung: erst außen, dann innnen VECTOR(RANDOM(2), i, 1, 3)

 [RANDOM(2), RANDOM(2), RANDOM(2)]

 [0, 0, 1]

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]

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

(75)

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.

4 * ATrapez(bQ,sA(bA),hÜT(bQ,bA,hÜ)) + 4 * ADreieck(sA(bA),hÜD(bQ,bA,hÜ)) + ADach(bQ,bA,hÜ,hP) =

Beispiel:

(76)

76

Warum funktional?

Grund 2:

(nach B. J. MacLennan, Functional Programming)

Funktionale Programmierung unterstützt parallele Verarbeitung.

Grund: referentielle Transparenz

Beispiel:

(77)

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)]) 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)) sort([])  [ ]

sort([e|R])  ins(e, sort(R))

(78)

78

Warum funktional?

Grund 4:

Funktionale Programmierung wird sehr viel in der KI (künstliche Intelligenz) verwendet.

Grund 5:

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

(79)

79

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

80

Funktionale Sprachen Funktionale Sprachen

Reduktionsregeln:

DelEr(x, [])  []

DelEr(x, [e|R])  IF(x=e, R, [e | DelEr(x,R)] ) DelEr(x, [])  []

DelEr(x, [e|R])  IF(x=e, R, [e | DelEr(x,R)] )

Implementierung mit Derive:

DelEr(x, L) :=

IF(x=ER(L), OE(L), ME(ER(L), DelEr(x, OE(L))))) DelEr(x, L) :=

IF(x=ER(L), OE(L), ME(ER(L), DelEr(x, OE(L)))))

(81)

81

Funktionale Sprachen Funktionale Sprachen

Reduktionsregeln:

DelEr(x, [])  []

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

82

Funktionale Sprachen Funktionale Sprachen

Reduktionsregeln:

DelEr(x, [])  []

Implementierung in CAML:

let rec DelEr = function (x, []) -> [] |

(x, e::r) -> if x = e then r

else e::DelEr(x,r);;

let rec DelEr = function (x, []) -> [] |

(x, e::r) -> if x = e then r

else e::DelEr(x,r);;

(83)

83

... und in der Schule?

„andere“ Form des

Programmierens

Klarer

Programmierstil Einfache, kurze,

durchschaubare

Programme Funktionale Programmierung

Funktionales Denken

Fazit:

Funktionale Programmierung ist

gut / bestens geeignet für die

(84)

84

Literatur 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