Grundlagen der Programmierung 2 [1.5ex] Haskell: Auswertung [1.5

Wieviel Vorfahren?
...
Grundlagen der Programmierung 2
...
Oma-Mh
7
...
...
Opa-M
...
Oma-Vg
7
...
Opa-V
3 Vater
Mutter k
Haskell: Auswertung
...
ich
Prof. Dr. Manfred Schmidt-Schauß
Aufgabe:
Wieviele Vorfahren hat ein Mensch nach n
Generationen?
anzahlInGeneration n = if n == 0 || n == 1 then 2
else 2 * anzahlInGeneration (n-1)
Sommersemester 2017
anzahlVorfahren n =
if n == 0 then 0
else anzahlInGeneration (n) + anzahlVorfahren (n-1)
Grundlagen der Programmierung 2 (Ausw-B)
1
Aufrufhierarchie und Rekursive Definitionen
– 2/92 –
Beispiel: Aufrufhierarchie
Jetzt die Definition dazu:
f, g, fi seien Haskell-definierte Funktionen.
f referenziert g direkt,
wenn g im Rumpf von f vorkommt.
f referenziert g
wenn
f referenziert direkt g,
oder es gibt Funktionen f1 , . . . , fn ,
so dass gilt: f referenziert direkt f1 ,
f1 referenziert direkt f2 , . . . ,
fn referenziert direkt g.
wenn f sich selbst direkt referenziert.
wenn f sich selbst referenziert.
f ist direkt rekursiv,
f ist rekursiv,
Verschränkte Rekursion:
Grundlagen der Programmierung 2 (Ausw-B)
quadrat x
= x*x
quadratsumme x y = (quadrat x) + (quadrat y)
quadratsumme referenziert direkt die Funktion quadrat,
quadratsumme referenziert direkt die (eingebaute) Funktion +
quadratsumme referenziert die Funktionen {quadrat, ∗, +}
Die Funktion quadratsumme ist somit nicht rekursiv
wenn f die Funktion g referenziert
und g die Funktion f .
(auch für allgemeinere Fälle)
– 3/92 –
Grundlagen der Programmierung 2 (Ausw-B)
– 4/92 –
Beispiel: Fakultät
Beispiel: Fakultät
0! := 1
n! := n ∗ (n − 1)!
Anwendung:
rekursive Definition:
wenn n > 0
fakultaet:: Integer -> Integer
fakultaet x = if x <= 0 then 1
else x*(fakultaet (x-1))
n! ist die Anzahl aller Permutationen
der Elemente einer n-elementigen Menge.
Beispiel:
Die Funktion fakultaet ist rekursiv, da sie im Rumpf der Definition
sich selbst referenziert
Menge mit 3 Elementen {A, B, C}:
6 Permutationen: ABC, ACB, BAC, BCA, CAB, CBA
3! = 3 ∗ 2! = 3 ∗ 2 ∗ 1! = 3 ∗ 2 ∗ 1 ∗ 0! = 3 ∗ 2 ∗ 1 ∗ 1 = 6
Grundlagen der Programmierung 2 (Ausw-B)
– 5/92 –
Entwurf rekursiver Funktionen
Grundlagen der Programmierung 2 (Ausw-B)
– 6/92 –
Entwurf rekursiver Funktionen
Am Beispiel fakultaet:
der Basisfall:
der Rekursionsfall:
Ergebnis: 0 wenn das Argument x ≤ 1 ist.
Ergebnis: x*(fakultaet (x-1)), wenn x > 1 ist.
zwei Fälle sind beim Entwurf rekursiver Funktionen zu beachten
Terminierung:
der Basisfall:
der Rekursionsfall:
keine weitere Rekursion
neuer rekursiver Aufruf
•
•
Terminierung der Aufrufe für alle Eingabefälle sollte man prüfen.
. . . Natürlich auch Korrektheit.
Grundlagen der Programmierung 2 (Ausw-B)
– 7/92 –
Argumente werden mit jedem rekursiven Aufruf kleiner
fakultaet x ruft fakultaet (x-1) auf für x ≥ 1.
Der Basisfall hat das kleinste Argument
*Main> fakultaet 3 ←6
*Main> fakultaet 40 ←815915283247897734345611269596115894272000000000
Grundlagen der Programmierung 2 (Ausw-B)
– 8/92 –
Eine Definition mit Lücke
Beispiel: größter gemeinsamer Teiler: ggt
ggt:: Integer -> Integer -> Integer
ggt a b =
if
b == 0
then a
else ggt b (rem a b)
fakultaet_nt:: Integer -> Integer
fakultaet_nt x = if x == 0 then 1
else x*(fakultaet_nt (x-1))
Annahme: a,b ≥ 0
Diese Funktion terminiert nicht bei negativen Eingaben:
fakultaet_nt (-5) ruft fakultaet_nt (-6) auf usw.
Grundlagen der Programmierung 2 (Ausw-B)
Basisfall:
Rekursionsfall:
Terminierung:
– 9/92 –
Auswertung von Haskell-Programmen
?
?
?
b=0
b>0
b > (a ‘rem‘ b) ≥ 0;
also . . .
Grundlagen der Programmierung 2 (Ausw-B)
– 10/92 –
Auswertung von Haskell-Programmen
operationale Semantik von Haskell:
Transformationen eines Ausdrucks
(bzw. des main-Ausdrucks des Programms)
Auswertung von
bis ein einfacher Ausdruck erreicht ist.
Haskell-Programmen
⇒ Transformations-Semantik
Ausdrücke sind implizit durch Syntaxbäume eindeutig dargestellt.
Grundlagen der Programmierung 2 (Ausw-B)
– 11/92 –
Grundlagen der Programmierung 2 (Ausw-B)
– 12/92 –
Syntaxbaum: Beispiele
Baum
if x <= 0 then 1 else x*(quadrat (x-1))
<=
x
|
ifThenElse
1
t
!
0
*∗
x
Baum
%
quadrat
−

x
x
•O
&
•_
1
x*(quadrat (x-1))
?•
•_
Grundlagen der Programmierung 2 (Ausw-B)
z
$
?•
•g
•
7•
$
quadrat
−
x
•
•_
∗
x
Baum (auf dem Kopf stehend)
•
•O
•
•
•

w
'
•
•
•

•
•

1
– 13/92 –
Baum im Informatiker-Park
Grundlagen der Programmierung 2 (Ausw-B)
– 14/92 –
Syntaxbaum: Beispiele
Zwei Syntaxbäume zum Ausdruck
1-2-3:
−

1
2
(1 − (2 − 3))
−
~
3
−
−
1


3
((1 − 2) − 3)
2
Nur einer passt zum Ausdruck 1-2-3 in Haskell.
Grundlagen der Programmierung 2 (Ausw-B)
– 15/92 –
Grundlagen der Programmierung 2 (Ausw-B)
– 16/92 –
Auswertung von Haskell-Programmen
Auswertung von Haskell-Programmen
Prinzip der Berechnung in Haskell:
Auswertung
Eindeutige Festlegung der Ausführung durch eine Strategie:
zwei Möglichkeiten (u.a.):
normale Reihenfolge der Auswertung,
(Haskell benutzt eine verbesserte Variante)
applikative Reihenfolge der Auswertung,
(z.B. in Python, ML, OCaml, Lisp)
Grundlagen der Programmierung 2 (Ausw-B)
– 17/92 –
Transformation bleibt stecken, aber kein Basiswert wird erreicht
(wird verhindert durch Typisierung)
•
Transformationsfolge terminiert nicht
Grundlagen der Programmierung 2 (Ausw-B)
– 18/92 –
sei die Haskell-Definition von f
Zahl + Zahl
Zahl ∗ Zahl
...
(Rf [t1 /x1 , . . . tn /xn ])
paralleles (unabhängiges) Ersetzen
von xi durch die Argumente ti für i = 1, . . . , n
Beispiel
quadrat x = x*x
•
Arithmetische Auswertungen
Auswertung:
(f t1 . . . tn ) →
Folge von Transformationen eines Ausdrucks
• in normaler Reihenfolge (Normalordnung)
• unter Benutzung der Funktions-Definitionen
bis ein Basiswert erreicht ist
Fehler-Möglichkeiten für Transformationsfolgen:
Definitionseinsetzung (δ-Reduktion)
f x1 . . . xn = Rf
=
Ergebnis durch Ausrechnen“
”
mittels vorprogrammierter Operationen
genauso
Beachte: Wenn s op t arithmetisch ausgewertet werden soll,
dann müssen zuerst die Ausdrücke s und t
zu Zahlen ausgewertet werden!
Rquadrat ist hier: x*x
quadrat 11 → x*x[11/x] = 11*11
Grundlagen der Programmierung 2 (Ausw-B)
– 19/92 –
Grundlagen der Programmierung 2 (Ausw-B)
– 20/92 –
Beispiel:
Boolesche Auswertungen
Programm:
v && w
main = quadrat 5
quadrat x = x*x
v || w
oder
not w
Definitionen von und, oder, nicht,
äquivalent zu den vordefinierten:
Auswertung als Folge von Transformationen:
main
→
(Definitions-Einsetzung)
quadrat 5
→
(Definitions-Einsetzung)
5 * 5
→
(arithmetische Auswertung)
25
Grundlagen der Programmierung 2 (Ausw-B)
oder
x && y = if x then y
else False
x || y = if x then True else y
not x = if x then False else True
– 21/92 –
Auswertung der Fallunterscheidung
Grundlagen der Programmierung 2 (Ausw-B)
– 22/92 –
Transformationen, Reduktionen
Fallunterscheidung (if-Reduktion)
Definition:
Wir nennen eine Transformation auch Reduktion
und eine Folge von Programmtransformationen auch
Reduktionsfolge (oder Auswertung).
(if True then e1 else e2 ) → e1
(if False then e1 else e2 ) → e2
Beachte: Reduktionen / Transformationen sind zunächst überall im
Ausdruck erlaubt.
Erst eine Auswertungs-Strategie macht die Auswertung eindeutig.
Beachte
(if b then e1 else e2 )-Auswertung
erfordert automatisch, dass zuerst b ausgewertet werden muss.
Grundlagen der Programmierung 2 (Ausw-B)
– 23/92 –
Grundlagen der Programmierung 2 (Ausw-B)
– 24/92 –
Transformationen, Reduktionen
Beispiel
Motivation für diese Transformationssemantik:
•
•
•
•
x && y = if x then y
x || y = if x then True
bot
= bot
eindeutige Festlegung der (Haskell-)Auswertung
Umgang mit nichtterminierenden Argumenten
Unendliche Listen
diese kommt ohne Übersetzung/Compilation aus
Beispiel-Auswertungen dazu
True && True → if True
True && False → if True
True || True → if True
True || False → if True
Motivation für Normalordnung (s.u.):
• korrekte Programmtransformationen
• einfache Programm-Logik
• Hohe Modularität wird ermöglicht
• Implizite Parallelität wird unterstützt
True && bot
True || bot
else False
else y
then
then
then
then
True else False
False else False
True else True
True else False
→ if True then bot else False
→ if True then True else bot
→
→
→
→
True
False
True
True
→ bot → bot . . .
→ True
bot terminiert nicht bei Auswertung!
Grundlagen der Programmierung 2 (Ausw-B)
– 25/92 –
Transformationsmöglichkeiten
Grundlagen der Programmierung 2 (Ausw-B)
– 26/92 –
Reduktionsstrategien
Wichtige Reduktionsstrategien
3 verschiedene Auswertungen für quadrat (4+5) :
D
A
A
A
→ (4 + 5) ∗ (4 + 5) −
→ 9 ∗ (4 + 5) −
→ 9∗9 −
→ 81
quadrat(4 + 5) −
quadrat(4 + 5) → (4 + 5) ∗ (4 + 5) → (4 + 5) ∗ 9 → 9 ∗ 9 → 81
quadrat(4 + 5) → quadrat 9
→ 9∗9
→ 81
Applikative Reihenfolge:
Argumentauswertung vor Definitionseinsetzung
Beobachtungen:
• Das Ergebnis ist gleich
• Die Anzahl der Reduktionen kann verschieden sein
Verzögerte Reihenfolge:
Normale Reihenfolge mit Sharing
Normale Reihenfolge:
Definitionseinsetzung vor Argumentauswertung
(informell)
Grundlagen der Programmierung 2 (Ausw-B)
– 27/92 –
Grundlagen der Programmierung 2 (Ausw-B)
– 28/92 –
Eindeutigkeit der Ergebnisse
Applikative Reihenfolge der Auswertung
Satz
Sei t ein Ausdruck in Haskell.
Wenn
∗,appl.R.
t −−−−−→ a,
t
∗,norm.R.
−−−−−−→
•
b
•
•
∗,verz.R.
t −−−−−→ c
und a, b, c sind Basiswerte (d.h. Integer, Zahlen,. . . , Boolesche
Werte).
Dann gilt a = b = c.
Grundlagen der Programmierung 2 (Ausw-B)
– 29/92 –
Applikative Reihenfolge der Auswertung
Grundlagen der Programmierung 2 (Ausw-B)
– 30/92 –
Beispiel: applikative Auswertung
Werte den Ausdruck t applikativ aus!
Fälle:
• t ist Basiswert. fertig.
• t ≡ s1 t1 ,
Wenn s1 kein Funktionsname und keine Anwendung,
dann werte s1 applikativ aus (rekursiv)
• t ≡ f t1 . . . tn .
Wenn ar(f ) ≤ n, dann (rekursiv) applikativ auswerten:
ti , 1 ≤ i ≤ ar(f ) von links nach rechts.
Wenn ar(f ) ≤ n und alle ti Basiswerte, dann Definitionseinsetzung (δ-Reduktion).
Wenn n < ar(f ), dann fertig: keine Reduktion.
• t ≡ if b then e1 else e2 .
Wenn b Basiswert, dann if-Reduktion
Wenn b kein Basiswert, dann werte b applikativ aus (rekursiv)
Grundlagen der Programmierung 2 (Ausw-B)
Argumentauswertung vor Definitionseinsetzung
wird in den meisten Programmiersprachen benutzt
z.B. in Python, C, ML, ....
wird nicht in Haskell verwendet.
Diskussion der Vor- / Nachteile später . . .
– 31/92 –
Wo im Ausdruck applikativ auswerten?
quadrat (quadrat ((quadrat 2) + (quadrat 3)))
quadrat (quadrat ((quadrat 2) + (quadrat 3)))
Grundlagen der Programmierung 2 (Ausw-B)
– 32/92 –
Beispiel für applikative Reihenfolge
fakultaet: applikative Reihenfolge
main = fakultaet 4
fakultaet x = if x <= 1 then 1
else x*(fakultaet (x-1))
quadrat x = x*x
applikativ
2 Beispiel-Auswertungen (applikative Reihenfolge)
quadrat(4 + 5)
→
quadrat 9
quadrat(quadrat(2 + 3))
quadrat 25
→
→
→
9∗9
→
81
quadrat(quadrat 5)
25 ∗ 25
Grundlagen der Programmierung 2 (Ausw-B)
→
→
625
– 33/92 –
fakultaet: applikative Reihenfolge (2)
Grundlagen der Programmierung 2 (Ausw-B)
– 34/92 –
Beispiel: applikative Reihenfolge der Auswertung
4*(if False then 1 else 3*(fakultaet (3-1)))
4*(3*(fakultaet (3-1)))
4*(3* (fakultaet 2))
4*(3*(if 2 <= 1 then 1 else 2*(fakultaet (2-1))))
4*(3*(if False
then 1 else 2*(fakultaet(2-1))))
4*(3*(2*(fakultaet (2-1))))
4*(3*(2*(fakultaet 1))
4*(3*(2*(if 1 <= 1 then 1 else 1*(fakultaet(1-1)))))
4*(3*(2*(if True
then 1 else 1*(fakultaet(1-1)))))
4*(3*(2*1))
4*(3*2)
(4*6)
24
18 Auswertungsschritte
Grundlagen der Programmierung 2 (Ausw-B)
fakultaet 4
if 4 <= 1 then 1 else 4*(fakultaet (4-1))
if False then 1 else 4*(fakultaet (4-1))
4*(fakultaet (4-1))
4*(fakultaet 3)
4*(if 3 <= 1 then 1 else 3*(fakultaet (3-1)))
– 35/92 –
main = const 5 (fakultaet 4)
fakultaet x = if x <= 1 then 1
else x*(fakultaet (x-1))
const x y = x
1
18
1
main →
− const 5 (fakultaet 4) −→ const 5 24 →
− 5
Anzahl der Reduktionen: 20
Grundlagen der Programmierung 2 (Ausw-B)
– 36/92 –
Normale Reihenfolge der Auswertung
•
•
Beschreibung: normale Reihenfolge
werte t in normaler Reihenfolge aus. Fälle:
• t ist Basiswert. fertig.
• t ≡ s1 t1 ,
Wenn s1 kein Funktionsname und keine Anwendung.
Dann normale R. auf s1
• t ≡ f t1 . . . tn und f keine eingebaute Funktion,
Wenn ar(f ) ≤ n, dann Definitionseinsetzung auf f t1 . . . tar(f ) .
Wenn ar(f ) > n: keine Reduktion.
• t ≡ f t1 . . . tn und f ist eingebaute Funktion
Wenn ar(f ) ≤ n und Argumente von f keine Basiswerte,
dann normale R. auf ar(f ) Argumente von links nach rechts.
Wenn ar(f ) ≤ n, und ar(f ) Argumente von f sind Basiswerte,
dann eingebaute Funktion aufrufen.
Wenn ar(f ) > n: keine Reduktion.
• t ≡ if b then e1 else e2 .
Wenn b Basiswert, dann if-Reduktion
Wenn b kein Basiswert, dann normale R. auf b
Definitionseinsetzung vor Argumentauswertung
wird in Haskell benutzt
Grundlagen der Programmierung 2 (Ausw-B)
– 37/92 –
Beispiel: normale Reihenfolge-Auswertung
Grundlagen der Programmierung 2 (Ausw-B)
– 38/92 –
Beispiel für normale Reihenfolge
quadrat x = x*x
Wo im Ausdruck auswerten (entsprechend normaler Reihenfolge) ?
(quadrat (2 + 3)) ∗ (quadrat (2 + 3))
quadrat (quadrat(2 + 3))
(quadrat(2 + 3)) ∗ (quadrat(2 + 3))
((2 + 3) ∗ (2 + 3)) ∗ (quadrat(2 + 3))
(5 ∗ (2 + 3)) ∗ (quadrat(2 + 3))
(5 ∗ 5) ∗ (quadrat(2 + 3))
25 ∗ (quadrat(2 + 3))
25 ∗ ((2 + 3) ∗ (2 + 3))
25 ∗ (5 ∗ (2 + 3))
25 ∗ (5 ∗ 5)
25 ∗ 25
625
(quadrat (2 + 3)) ∗ (quadrat (2 + 3))
Grundlagen der Programmierung 2 (Ausw-B)
2 Beispiel-Auswertungen
quadrat(4 + 5) → (4 + 5) ∗ (4 + 5) → 9 ∗ (4 + 5) → 9 ∗ 9 → 81
– 39/92 –
Grundlagen der Programmierung 2 (Ausw-B)
→
→
→
→
→
→
→
→
→
→
– 40/92 –
Beispiel: Auswertung
Beispiel: normale Reihenfolge der Auswertung (2)
4*(fakultaet(4-1)))
4*(if (4-1)<= 1 then 1 else (4-1)*(fakultaet((4-1)-1)))
4*(if 3 <= 1 then 1 else (4-1)*(fakultaet((4-1)-1)))
4*(if False then 1 else (4-1)*(fakultaet((4-1)-1)))
4*((4-1)*(fakultaet((4-1)-1)))
4*(3*(fakultaet((4-1)-1)))
main = fakultaet 4
fakultaet x = if x <= 1 then 1
else x*(fakultaet (x-1))
4*(3*(if ((4-1)-1) <= 1 then 1 else ((4-1)-1)*(fakultaet(((4-1)-1)-1)))))
4*(3*(if(3-1)<= 1 then 1 else ((4-1)-1)*(fakultaet(((4-1)-1)-1))))
4*(3*(if 2 <= 1 then 1 else ((4-1)-1)*(fakultaet(((4-1)-1)-1))))
4*(3*(if False then 1 else ((4-1)-1)*(fakultaet(((4-1)-1)-1))))
4*(3*(((4-1)-1)*(fakultaet(((4-1)-1)-1))))
4*(3*((3-1)*(fakultaet(((4-1)-1)-1))))
4*(3*(2*(fakultaet(((4-1)-1)-1))))
4*(3*(2*(if (((4-1)-1)-1) <= 1 then 1 . . . )))
Auswertung (in normaler Reihenfolge:)
fakultaet 4
if 4 <= 1 then 1 else 4*(fakultaet(4-1))
if False then 1 else 4*(fakultaet(4-1))
4*(fakultaet(4-1))
Grundlagen der Programmierung 2 (Ausw-B)
– 41/92 –
Beispiel: normale Reihenfolge der Auswertung (4)
– 42/92 –
Beispiel: normale Reihenfolge der Auswertung
4*(3*(2*(if (((4-1)-1)-1) <= 1 then 1 . . . )))
4*(3*(2*(if ((3-1)-1) <= 1 then 1 . . . )))
4*(3*(2*(if 2-1 <= 1 then 1 . . . )))
4*(3*(2*(if 1 <= 1 then 1 . . . )))
4*(3*(2*(if True then 1 . . . )))
4*(3*(2*1))
4*(3*2)
4*6
24
Das sind 24 Auswertungsschritte
Grundlagen der Programmierung 2 (Ausw-B)
Grundlagen der Programmierung 2 (Ausw-B)
main = const 5 (fakultaet 4)
fakultaet x = if x <= 1 then 1
else x*(fakultaet (x-1))
const x y = x
1
main →
−
1
const 5 (fakultaet 4) →
− 5
Anzahl der Reduktionen:
2
(20 bei applikativer Reihenfolge)
– 43/92 –
Grundlagen der Programmierung 2 (Ausw-B)
– 44/92 –
Beispiel für verschiedene Reduktionsstrategien
Verzögerte Reihenfolge der Auswertung
quadrat x = x*x
3 Auswertungen für
quadrat (4+5) :
1
quadrat(4 + 5) → (4 + 5)∗(4+5) → 9∗(4 + 5) → 9 ∗ 9 → 81
normale Reihenfolge der Auswertung
2
quadrat(4 + 5) → (4+5)∗(4 + 5) → (4 + 5)∗9 → 9 ∗ 9 → 81
Irgendeine Auswertung
3
quadrat(4 + 5) → (quadrat 9) → 9 ∗ 9 → 81
applikative Reihenfolge der Auswertung
Grundlagen der Programmierung 2 (Ausw-B)
– 45/92 –
Beispiele
Definition verzögerte Reihenfolge der Auswertung (lazy reduction):
• wie normale Reihenfolge
• aber: gerichteter Graph statt Syntax-Baum
• Vermeidung von unnötiger Doppelauswertung
durch gemeinsame Unterausdrücke (Sharing)
• Die gemeinsamen (d.h. shared) Unterausdrücke sind durch
die Funktionsrümpfe festgelegt.
Grundlagen der Programmierung 2 (Ausw-B)
– 46/92 –
Beispiel in gerichteter-Graph-Darstellung
Normale Reihenfolge:
∗
quadrat
4 Reduktionen: (normale Reihenfolge)
quadrat(4 + 5) → (4 + 5) ∗ (4 + 5) → 9 ∗ (4 + 5) → 9 ∗ 9 → 81
3 Reduktionen (verzögerte Reihenfolge)
quadrat(4 + 5) → (4 + 5)(1) ∗ (4 + 5)(1) → 9 ∗ 9 → 81
4
|
+
→
+
"
5
4
{
#
Verzögerte
Reihenfolge:
{
{
"
5
4
"
→
4
5
quadrat
+
4
Grundlagen der Programmierung 2 (Ausw-B)
→ 9
+
→
9
∗
→ 81
9
5
∗
#
Applikative
Reihenfolge:
– 47/92 –
4
quadrat
+
4
Grundlagen der Programmierung 2 (Ausw-B)
5
+
∗
#
→
+
∗
}
→
#
9
{
→ 81
5
∗
quadrat
→
→ 81
9
9
9
5
– 48/92 –
Verzögerte Auswertung: Beispiel
Beispiel . . .
4*(if 3 <= 1 then 1 else 3*(fakultaet(3-1)))
4* (if False then 1 else 3*(fakultaet(3-1)))
4*(3*(fakultaet(3-1)))
4*(3*(if (3-1)<= 1 then 1 else (3-1)*(fakultaet((3-1)-1))))
4*(3*(if 2 <= 1 then 1 else 2*(fakultaet(2-1))))
4*(3*(if False then 1 else 2*(fakultaet(2-1))))
4*(3*(2*(fakultaet(2-1))))
4*(3*(2*(if (2-1)<= 1 then 1 else (2-1)*(fakultaet ((2-1)-1)))))
4*(3*(2*(if 1 <= 1 then 1 else 1*(fakultaet(1-1)))))
4*(3*(2*(if True then 1 else 1*(fakultaet(1-1)))))
4*(3*(2*1))
4*(3*2)
4*6
24
(18 Auswertungsschritte)
fakultaet x = if x <= 1 then 1
else x*(fakultaet (x-1))
Rot: die Stelle, die reduziert wird
Grün: die Stelle, die identisch mit der roten ist
fakultaet 4
if 4 <= 1 then 1 else 4*(fakultaet(4-1))
if False then 1 else 4*(fakultaet(4-1))
4*(fakultaet(4-1))
4*(if (4-1) <= 1 then 1 else (4-1)*(fakultaet((4-1)-1)))
4*(if 3 <= 1 then 1 else 3 * (fakultaet( 3 -1)))
Grundlagen der Programmierung 2 (Ausw-B)
– 49/92 –
Grundlagen der Programmierung 2 (Ausw-B)
– 50/92 –
Optimale Anzahl der Reduktionen
Übersicht Reduktionsanzahl zu Beispielen
Es gilt:
(fakultaet 4)
verzögerte R.
applikative R.
normale R.
18
18
24
•
verzögerte Reduktion
hat optimale Anzahl von Reduktionsschritten. !
Es gilt immer:
# verzögerte R. ≤ # normale R.
# verzögerte R. ≤ # applikative R.
main
2
20
2
•
Im allgemeinen gilt:
# applikative R. und # normale R. sind unvergleichbar
•
Wenn alle Reduktionsschritte für das Ergebnis benötigt werden:
# verzögerte R. ≤ # applikative R. ≤ # normale R.
main = const 5 (fakultaet 4)
Grundlagen der Programmierung 2 (Ausw-B)
– 51/92 –
Grundlagen der Programmierung 2 (Ausw-B)
– 52/92 –
Reduktions-Strategien und Korrektheit
Auswertungsprozesse
In deterministischen Programmiersprachen (z.B. Haskell)
mit verzögerter (oder normaler) Reihenfolge der Auswertung gilt:
Reduktionen zur Compile-Zeit
sind korrekte Programmtransformationen
d.h. die Semantik bleibt erhalten
Auswertungsprozesse
Das ist i.a. falsch in Programmiersprachen, die die applikative
Reihenfolge verwenden.
Grundlagen der Programmierung 2 (Ausw-B)
– 53/92 –
Rekursive Auswertungsprozesse
Wir betrachten bei der Analyse von Auswertungsprozessen nur
die applikative Reihenfolge
Grundlagen der Programmierung 2 (Ausw-B)
bei applikativer Reihenfolge der Auswertung
(Nicht jeder Zwischenzustand ist angegeben)
(fakultaet 6)
(6 * (fakultaet (6-1)))
(6 * (5 * (fakultaet (5-1))))
(6 * (5 * (4 * (fakultaet (4-1)))))
(6 * (5 * (4 * (3 * (fakultaet (3-1))))))
(6 * (5 * (4 * (3 * (2 * (fakultaet (2-1)))))))
(6 * (5 * (4 * (3 * (2 * 1)))))
(6 * (5 * (4 * (3 * 2))))
(6 * (5 * (4 * 6)))
(6 * (5 * 24))
(6 * 120)
720
Beispiel: Auswertung der rekursiven Fakultätsfunktion
fakultaet x
– 54/92 –
Auswertungsprozess, linear rekursiv
Wir betrachten jetzt Auswertungsprozesse, die durch eine einzige
rekursive Funktion erzeugt werden
0! := 1
n! := n ∗ (n − 1)!
Grundlagen der Programmierung 2 (Ausw-B)
wenn n > 1
= if x <= 1 then 1
else x*(fakultaet (x-1))
– 55/92 –
Grundlagen der Programmierung 2 (Ausw-B)
– 56/92 –
Auswertungsprozess, linear rekursiv
Alternative Berechnungen der Fakultät
Produkt
Zähler
Iteriere folgende Regel:
(fakultaet 6) Auswertungsprozess ist linear rekursiv
Charakteristisch:
•
nur eine rekursive Funktionsanwendung
in jedem Ausdruck der Reduktionsfolge
•
Zwischenausdrücke sind nicht beschränkt.
Grundlagen der Programmierung 2 (Ausw-B)
– 57/92 –
Fakultät: andere Definitionsform
Produkt ∗ Zähler
Zähler + 1
fakt_iter produkt zaehler max =
if zaehler > max
then produkt
else fakt_iter (zaehler*produkt) (zaehler + 1) max
fakultaet_lin n =
fakt_iter 1 1 n
Grundlagen der Programmierung 2 (Ausw-B)
– 58/92 –
Endrekursion
Verwendung lokaler Funktionen mit let . . . in . . .
Eine Endrekursion ist eine lineare Rekursion.
Zusätzlich muss gelten:
• In jedem Rekursionsaufruf:
der rekursive Aufruf
berechnet direkt den Rückgabewert
ohne Nachverarbeitung nach der Rekursion
fakultaet_lin n =
let fakt_iter produkt zaehler max =
if zaehler > max
then produkt
else fakt_iter (zaehler*produkt)
(zaehler + 1)
max
in
fakt_iter 1 1 n
Grundlagen der Programmierung 2 (Ausw-B)
⇒
⇒
Z.B. funktion a b c
– 59/92 –
Grundlagen der Programmierung 2 (Ausw-B)
ruft auf
aber nicht
funktion d e f
g * (funktion d e f)
– 60/92 –
Auswertungsprozess, endrekursiv
Iterativer Auswertungsprozess
Iterativer Auswertungsprozess bei applikativer Auswertung:
Auswertung von (fakultaet_lin 5) bei verzögerter Reihenfolge
der Auswertung
(fakultaet lin 5)
(fakt iter 1 1 5)
(fakt iter (1*1) (1+1) 5)
(fakt iter (2*(1*1)) (2+1) 5)
(fakt iter (3*(2*(1*1))) (3+1) 5)
(fakt iter (4*(3*(2*(1*1)))) (4+1) 5)
(fakt iter (5*(4*(3*(2*(1*1))))) (5+1) 5)
(5*(4*(3*(2*(1*1)))))
120
Grundlagen der Programmierung 2 (Ausw-B)
Haskell
– 61/92 –
Grundlagen der Programmierung 2 (Ausw-B)
– 62/92 –
Iteration in Haskell
Endrekursion i.a. nicht optimiert.
d.h. Wert wird durch alle Stufen der
Rekursion zurückgegeben
Endrekursion ist optimiert.
am Ende wird der Wert unmittelbar
zurückgegeben.
Bei verzögerter Auswertung:
Eine rekursive Funktion f ist iterativ , wenn
f t1 . . . tn für Basiswerte ti
bei applikativer Reihenfolge der Auswertung
einen iterativen Prozess ergibt.
Deshalb braucht man in imperativen Programmiersprachen:
Iterationskonstrukte
for ...do,
while,
repeat ...until.
Diese entsprechen iterativen Auswertungsprozessen
Grundlagen der Programmierung 2 (Ausw-B)
lin 6)
1 1 6)
1 2 6)
2 3 6)
6 4 6)
24 5 6)
120 6 6)
720 7 6)
Iterativer Prozess:
Charakteristisch: ist eine Endrekursion
Argumente sind Basiswerte
(bzw. Größe des Gesamtausdrucks bleibt beschränkt.)
optimierte Rückgabe des Wertes
Optimierung der Endrekursion
imperative Programmiersprachen
(fakultaet
(fakt iter
(fakt iter
(fakt iter
(fakt iter
(fakt iter
(fakt iter
(fakt iter
720
Viele (nicht alle) linear rekursive Funktionen
kann man zu iterativen umprogrammieren.
Zum Beispiel: fakultaet zu fakultaet lin
– 63/92 –
Grundlagen der Programmierung 2 (Ausw-B)
– 64/92 –
Baumrekursion
Auswertungsprozess zu fib
in applikativer Reihenfolge:
Der Auswertungs-Prozess ergibt folgende Zwischen-Ausdrücke:
Beispiel Berechnung der Fibonacci-Zahlen
1, 1, 2, 3, 5, 8, 13, 21, . . .
fib 5
fib 4 + fib 3
(fib 3 + fib 2) + fib 3
((fib 2 + fib 1) + fib 2) +
(((fib 1 + fib 0) + fib 1) +
(((1+0) + fib 1) + fib 2) +
((1 + fib 1) + fib 2) + fib
((1+1) + fib 2) + fib 3
(2 + fib 2) + fib 3
(2 + (fib 1 + fib 0)) + fib
.......

falls n = 0
 0
1
falls n = 1
F ib(n) :=

F ib(n − 1) + F ib(n − 2) sonst
fib n = if n <= 0 then 0
else if n == 1 then 1
else fib (n-1) + fib(n-2)
Grundlagen der Programmierung 2 (Ausw-B)
– 65/92 –
Auswertungsprozess zu fib
4
fib 3
fib 2)
fib 3
3
3
+ fib 3
2
1
Grundlagen der Programmierung 2 (Ausw-B)
3
2
2
0
3
2
1
1
2
0
1
1
0
0
Das ist Baumrekursion
Charakteristisch: Ausdrücke in der Reduktionsfolge
4
1
– 66/92 –
5
5
1
3
Grundlagen der Programmierung 2 (Ausw-B)
1
2
+ fib 3
Auswertungsprozess zu fib: Baum der Aufrufe
fib 5
fib 4 + fib 3
(fib 3 + fib 2) + fib 3
((fib 2 + fib 1) + fib 2) +
(((fib 1 + fib 0) + fib 1) +
(((1+0) + fib 1) + fib 2) +
((1 + fib 1) + fib 2) + fib
3
fib 3
fib 2)
fib 3
3
1
•
•
•
1
0
0
– 67/92 –
können unbegrenzt wachsen
können mehrere rekursive Aufrufe enthalten
Aber: nicht geschachtelt
(d.h. die Argumente eines rekursiven Aufrufs
enthalten keine rekursiven Aufrufe)
Grundlagen der Programmierung 2 (Ausw-B)
– 68/92 –
Geschachtelte Rekursion
Optimierte Ackermannfunktion
Ist der allgemeine Fall
wird normalerweise selten benötigt, da i.a. nicht effizient
berechenbar. Beispiel: Die Ackermannfunktion
----ack 0
ack 1
ack x
ack x
Ackermanns Funktion
y
=
0
=
0 | x >= 2
=
y | x > 0 && y > 0 =
---1
2
x+2
ack (ack (x-1) y) (y-1)
benutzt folgende Programmier-Technik in Haskell:
Mehrere Definitionsgleichungen einer Funktion
Reihenfolge: der Fallabarbeitung
von oben nach unten wird probiert, welche Definitionsgleichung
passt:
1) Argumente anpassen
2) Bedingung rechts vom | prüfen
Grundlagen der Programmierung 2 (Ausw-B)
– 69/92 –
Optimierte Ackermannfunktion (2)
----ackopt
ackopt
ackopt
ackopt
ackopt
ackopt
Ackermanns Funktion "optimiert" ---0 y = 1
1 0 = 2
x 0 = x+2
x 1 = 2*x
x 2 = 2^x
x y | x > 0 && y > 0 =
ackopt (ackopt (x-1) y) (y-1)
Grundlagen der Programmierung 2 (Ausw-B)
Tabelle der Rekursionsprozesse:
*Main> anzahlStellen (ackopt 5 3) ←19729
2
des Ergebnisses (ackopt 5 3) = 265536 = 22
• sehr schnell wachsende Funktion
• man kann nachweisen: man braucht geschachtelte Baum-Rekursion
um ack zu berechnen
• hat Anwendung in der Komplexitätstheorie
impliziert“
22
geschachtelt
baumrekursiv
”−−−−−−
−−−
→
19729 ist die Anzahl der Dezimalstellen
baumrekursiv
linear rekursiv
endrekursiv
iterativ
Grundlagen der Programmierung 2 (Ausw-B)
– 70/92 –
– 71/92 –
Grundlagen der Programmierung 2 (Ausw-B)
mehrere rekursive Unterausdrücke auch in
den Argumenten der rekursiven Unterausdrücke erlaubt
mehrere rekursive Unterausdrücke erlaubt,
aber Argumente der rekursiven Unterausdrücke ohne weitere Rekursion
maximal ein rekursiver Unterausdruck
linear rekursiv und Gesamtresultat ist Wert
des rekursiven Unterausdrucks
endrekursiv und Argumente des rekursiven
Unterausdrucks sind Basiswerte
– 72/92 –
Optimierung und Analyse
Optimierung: Iteration statt Rekursion
Beispiel
Berechnung von (fib
5)
5
Im folgenden: Analyse auf Laufzeit und Speicherbedarf von:
4
fib
3
fakultaet
ggt
2
1
fib 3 wird
fib 2 wird
fib 1 wird
Grundlagen der Programmierung 2 (Ausw-B)
– 73/92 –
Optimierung: Iteration statt Rekursion
wobei Φ =
√
1+ 5
2
1
1
2
0
1
1
0
0
2 mal berechnet
3 mal berechnet
5 mal berechnet
Grundlagen der Programmierung 2 (Ausw-B)
– 74/92 –
≈ 1.6180 (goldener Schnitt)
Beobachtung:
zur Berechnung von fib(n) benötigt man
nur die Werte fib(i) für 1 ≤ i ≤ n.
Idee:
Berechnung einer Wertetabelle für fib.
Verbesserte Variante:
aus fibn−1 und fibn−2 berechne fibn
Ohne Doppelberechnung von Funktionswerten
(fibn−1 , fibn−2 ) → (fibn−1 + fibn−2 ), fibn−1 )
|
{z
}
= fibn
Fazit:
# Reduktionen für fib(n) ist exponentiell
d.h. die Laufzeit von fib ist exponentiell in n
Rechenvorschrift:
Grundlagen der Programmierung 2 (Ausw-B)
2
Iterative Version von Fib
Genauer und Allgemeiner:
Bei Berechnung von fib n für n ≥ 2
wird fib(1) jeweils (fib n)-mal berechnet
Φn
(fib n) ≈ √
5
3
– 75/92 –
Grundlagen der Programmierung 2 (Ausw-B)
(a, b) → (a + b, a)
– 76/92 –
Iterative Version von fib: Funktionen
fib_lin n
=
fib_iter a b zaehler =
Prozess für (fib lin 5)
(fib
(fib
(fib
(fib
(fib
(fib
5
(fib_iter 1 0 n)
if zaehler <= 0
then b
else fib_iter (a + b)
a
(zaehler - 1)
Grundlagen der Programmierung 2 (Ausw-B)
– 77/92 –
Analyse der fib-Optimierung
Für
•
•
•
•
lin 5)
iter 1
iter 1
iter 2
iter 3
iter 5
0
1
1
2
3
5)
4)
3)
2)
1)
Grundlagen der Programmierung 2 (Ausw-B)
– 78/92 –
Analyse von Programmen
Abschätzung und Messung des Ressourcenbedarfs
von Haskell-Programmen,
bei verzögerter Auswertung:
(fib_lin n) gilt:
ist operational äquivalent zu fib
benötigt linear viele Reduktionen abhängig von n
Größe der Ausdrücke ist beschränkt
Platzbedarf ist konstant (d.h. unabhängig) von n.
Zeit:
Anzahl der Transformationsschritte
Platz: (Gesamt-Speicher):
Maximale Größe der Ausdrücke
Arbeitsspeicher:
Maximale Größe der Ausdrücke
(ohne die Eingabe)
(unter Vernachlässigung der Darstellungsgröße der Zahlen)
erzeugt iterativen Auswertungsprozess (applikative R.)
arithmetische und Boolesche Operationen
= 1 Transformationsschritt.
Grundlagen der Programmierung 2 (Ausw-B)
– 79/92 –
Grundlagen der Programmierung 2 (Ausw-B)
– 80/92 –
Analyse von Programmen (2)
Beispiel: Fibonacci-Funktion fib
Angabe des Ressourcenbedarf eines Algorithmus
in Abhängigkeit von der Größe der Eingabe.
Notation für Algorithmus alg bei Eingabe der Größe n:
redalg (n)
maximale Anzahl der Reduktionen bei verzögerter
Auswertung für alle Eingaben der Größe n.
P latzalg (n)
Platzbedarf: maximale Größe der Ausdrücke (des
gerichteten Graphen) bei verzögerter Auswertung
für alle Eingaben der Größe n.
Die Eingaben nicht mitzählen
Grundlagen der Programmierung 2 (Ausw-B)
– 81/92 –
Beispiel fakultaet n
fakultaet x
redfib (n) ≈ 1.6n (einfach exponentiell)
Bezugsgröße: Zahl n
Achtung: Die Komplexitätstheorie verwendet
i.a. die Speicher-Größe der Eingabe
Grundlagen der Programmierung 2 (Ausw-B)
– 82/92 –
Beispiel fakultaet n: Nachweis
Nachzuweisen ist: fakultaet (n-1) benötigt 5 ∗ (n − 2) + 4 für n ≥ 2
bei verzögerter Reihenfolge der Auswertung:
Induktions-Basis:
= if x <= 1 then 1
else x*(fakultaet (x-1))
fakultaet (2-1)
if (2-1) <= 1 then 1 else ...
if 1 <= 1 then 1 else ...
if True then 1 else ...
1
fakultaet n benötigt 5 ∗ (n − 1) + 3 Reduktionsschritte.
bei verzögerter Reihenfolge der Auswertung
(Kann man durch Beispielauswertungen raten)
Z.B. fakultaet 4 benötigt 18 Reduktionsschritte.
Das sind 4 Reduktionsschritte.
Da 5 ∗ (2 − 1 − 1) + 4 = 4, gilt die Formel in diesem Fall.
Nachweis mit vollständiger Induktion ....
Grundlagen der Programmierung 2 (Ausw-B)
fib n = if n <= 0 then 0
else if n == 1 then 1
else fib (n-1) + fib(n-2)
– 83/92 –
Grundlagen der Programmierung 2 (Ausw-B)
– 84/92 –
Beispiel fakultaet n: Nachweis
Beispiel fakultaet n: Nachweis
Nachzuweisen ist: fakultaet (n-1) benötigt 5 ∗ (n − 2) + 4 für n > 2
bei verzögerter Reihenfolge der Auswertung:
Induktions-Schritt:
fakultaet (n-1)
if (n-1) <= 1 then ...
if n1 <= 1 then ...
-- n1 ist Basiswert > 1
if False then ...
n1*fakultaet (n1-1) -- Wert n2 als Ind hypothese zaehlt nicht
n1*n2
-- Produkt-Berechnung zaehlt noch dazu
n3
Das sind 5 + 5 ∗ (n1 − 2) + 4 = 5 ∗ (n − 2) + 4 Reduktionsschritte
Grundlagen der Programmierung 2 (Ausw-B)
fakultaet n
if n <= 1 then ...
n ist > 1
if False then ...
n*fakultaet (n-1) -- siehe Nachweis oben
n*n2
-- Produkt-Berechnung zaehlt noch dazu
n3
Das sind 4 + 5 ∗ (n − 2) + 4 = 5 ∗ (n − 1) + 3 Reduktionsschritte
Für n = 4 ergibt das 5 ∗ 3 + 3 = 18 Reduktionsschritte für
fakultaet 4.
– 85/92 –
Komplexitäten von Algorithmen
Beachte:
Nachzuweisen ist: fakultaet n benötigt 5 ∗ (n − 1) + 3 für n > 1
bei verzögerter Reihenfolge der Auswertung:
Induktions-Schritt:
Grundlagen der Programmierung 2 (Ausw-B)
– 86/92 –
Asymptotischen Komplexitäten
breite Streuung des Ressourcenbedarfs ist möglich für
die Menge aller Eingaben einer bestimmten Größe.
Als Beispiel hatten wir das Ergebnis:
Komplexitäten von Platz und Zeit:
fakultaet (n-1) benötigt 5 ∗ (n − 1) + 3 Reduktionen für n > 2.
Ressourcenbedarf verschiedene Varianten:
Abschätzung von 5 ∗ (n − 1) + 3 nach oben (als Funktion von n):
im schlimmsten Fall
im besten Fall
im Mittel
Grundlagen der Programmierung 2 (Ausw-B)
(worst-case)
(best-case)
Minimum von # Reduktionen
bzw. Minimum der Größe der Ausdrücke.
(average case)
Welche Verteilung?
– 87/92 –
5 ∗ (n − 1) + 3
≤
6·n
Geschrieben als
λn.(5 ∗ (n − 1) + 3) ∈ O(n).
! Multiplikative und additive Konstanten werden ignoriert.
Grundlagen der Programmierung 2 (Ausw-B)
– 88/92 –
Einige Komplexitäten
O(1)
O(log(n))
O(n)
O(n ∗ log(n))
O(n2 )
O(n3 )
O(nk )
O(2n )
Analyse zum größten gemeinsamen Teiler
ggT(a, b) (Euklids Algorithmus)
konstant
logarithmisch
linear
fastlinear (oder auch n-log-n)
quadratisch
kubisch
polynomiell
exponentiell
Teile a durch b; ergibt Rest r,
wenn r = 0, dann ggT(a, b) := b
wenn r 6= 0, dann berechne ggT(b, r).
Beispiel ggT(30, 12) = ggT(12, 6) = 6
ggt a b =
n ist die Größe der Eingabe (i.a Bit-Anzahl)
Grundlagen der Programmierung 2 (Ausw-B)
– 89/92 –
Komplexität des Euklidischen Algorithmus
if b == 0
then a
else ggt b (rem a b)
Grundlagen der Programmierung 2 (Ausw-B)
Vergleichstabelle (Zusammenfassung)
Aufruf
Zeitaufwand - Abschätzung
Arithmetische Operationen als O(1) angenommen
SATZ (Lamé, 1845):
Wenn der Euklidische ggt-Algorithmus k Schritte benötigt,
dann ist die kleinere Zahl der Eingabe ≥ f ib(k).
fakultaet n
fib n
fib lin n
ggt m n
m+n
m∗n
quadratsumme m n
Platz- und Zeitbedarf von ggt: O(log(n))
Begründung:
Wenn n die kleinere Zahl ist und der Algorithmus k Schritte
benötigt,
dann ist n ≥ f ib(k) ≈ 1.6180k
Also ist Anzahl der Rechenschritte k = O(log(n))
Grundlagen der Programmierung 2 (Ausw-B)
– 90/92 –
O(n)
O(1, 62n )
O(n)
O(log(max(m, n)))
O(1)
O(1)
O(1)
m, n :: Int
m, n :: Int
m, n :: Int
Arithmetische Operationen auf großen Zahlen
m+n
O(log(m + n))
m∗n
O(log(m + n))
quadratsumme m n O(log(m + n))
– 91/92 –
Grundlagen der Programmierung 2 (Ausw-B)
m, n :: Integer
m, n :: Integer
m, n :: Integer
– 92/92 –