Teil 2 - Softwaretechnik. Modul: Programmierung B-PRG Grundlagen der Programmierung 1 Teil 2. Übersicht. Softwaretechnik

Transkript

1 Grundlagen der Programmierung 1 Modul: Programmierung B-PRG Grundlagen der Programmierung 1 Teil 2 Softwaretechnik Prof. Dr. O. Drobnik Professur Architektur und Betrieb verteilter Systeme Institut für Informatik Fachbereich Informatik und Mathematik Teil 2 - Softwaretechnik Übersicht 1. Einführung 2. Entwurf von Algorithmen. Verifikation, Testen und Debugging 4. Vorgehensmodelle WS 2008/09 Überblick der Vorlesung Korrektheit Kap. Testen Debugging Entwicklungsphasen und Vorgehensmodelle Kap. 4 Softwaretechnik (Systematisierung der Sw-Entwicklung) Einführung Kap. 1 Kap. 2 Entwurf von Algorithmen Programmentwicklung als Vorgang Beispiele Entwurfsmethoden Konkrete Problemlösungen Grundlagen der Programmierung 1 Softwaretechnik Kapitel 1 - Einführung 1. Systematische Entwicklung von Programmen: Beispiel: größter gemeinsamer Teiler (ggt) 2. Algorithmenentwurf Beispiel: Suchen Naiver Ansatz Alternativer Ansatz Folie

2 Lernziele Entwurf von Algorithmen Problem: Suchen in Listen 2 alternative Lösungsansätze Systematisches Testen Einführung in die Softwaretechnik Programmentwicklung als Vorgang Problem: ggt(b,c) Begriffe Spezifikation Korrektheit 1. Systematische Entwicklung von Programmen: Beispiel: größter gemeinsamer Teiler (ggt) Problem: ggt(b,c) Ermittlung des größten gemeinsamen Teilers (ggt) zweier natürlicher Zahlen b,c > 0 Definition von ggt(b,c): ggt(b,c) = max{ k : k b k c k ε Nat k > 0 } Es bedeutet: k b : k teilt b ohne Rest : logisches Und (Konjunktion), Aussagenlogik Beispiel: ggt(24,9)= Folie 5 Folie 6 Begriff Spezifikation Spezifikation: Beschreibung der Funktionalität eines Programms, d.h. welches Problem ist zu lösen, ohne einen konkreten Lösungsweg oder Lösungsschritte vorzuschreiben. Funktionaler Zusammenhang zwischen Ein- und Ausgabe des Programms: Gegeben: Zwei natürliche Zahlen b,c > 0 Eingabe: b,c Gesucht: ggt(b,c) Ausgabe: x = ggt(b,c) Entwurf einer konkreten Lösung Entwurf eines Algorithmus: Entscheidung: Algorithmus von Euklid (ca. 00 v. Ch., Algorithmus ist wahrscheinlich 200 Jahre älter). Für b>0, c>0 gilt: 1) ggt(b,b) = b 2) ggtt(b,c) = ggt(b-c,c) für b > c ) ggt(b,c) =ggt(c,b) Folie 7 Folie 8

3 Beispiel ggt(24,9) ggt(24,9) = ggt(24-9,9) 2) ggt(15,9) = ggt(15-9,9) 2) ggt(6,9) = ggt(9,6) ) ggt(9,6) = ggt(9-6,6) 2) ggt(,6) = ggt(6,) ) ggt(6,) = ggt(6-,) 2) ggt(,) = 1) Ansatz für Algorithmus Für b>0, c>0 gilt: 1) ggt(b,b) = b 2) ggtt(b,c) = ggt(b-c,c) für b > c ) ggt(b,c) =ggt(c,b) Ansatz für Algorithmus: Solange 2) und ) anwenden, bis 1) gilt. Folie 9 Folie 10 Algorithmus: Flußdiagramm Python-Programm Eingabe: b, c Zuweisung: x=b; y=c def ggt(b,c): if (b <= 0 or c <= 0): # Prüfen der Bedingung x == y? ja 1) nein x > y? ja 2) nein ) u. 2) raise Fehler in ggt: b, c > 0 nicht erfüllt! x, y = b, c while x!= y: if x > y: x = x y # Regel 2) else: Ausgabe: x return x y = y x # Regel 2) und ) Folie 11 Folie 12

4 Ablaufprotokoll für ggt(24,9) Aufzeichnung der Werte aller Variablen vor und nach jedem Verarbeitungsschritt. Überprüfung eines Programms mit Papier und Bleistift. z.b. Darstellung mittels Tabelle: erste Spalte: Nummer der Programmzeile weitere Spalten: Werte von Variablen Python-Programm def ggt(b,c): if (b <= 0 or c <= 0): # Prüfen der Vorbedingung raise Fehler in ggt: b, c > 0 nicht erfüllt! x, y = b, c # Zeile 1 while x!= y: # Zeile 2 if x > y: x = x y # Zeile else: y = y x # Zeile 4 return x Folie 1 Folie 14 Ablaufprotokoll Ablaufprotokoll für ggt(24,9): Zeile 1 2, 2, 2,4 2, 2 x return y Vergleich x, y 24 > 9 15 > 9 6 < 9 6 > == x = x - y 15 6 y = y - x Daraus folgt: unser Programm liefert das für den Testfall ggt(24,9) zu erwartende Ergebnis, mehr nicht! Diskussion der Korrektheit Korrektheit: Algorithmus bzw. Programm erfüllt Spezifikation Naheliegender Ansatz: Testen Festlegen eines Testfalls: Vorgeben einer spezifischen Eingabe und der für diese Eingabe gemäß Spezifikation zu erwartenden Ausgabe Ausführung des Programms mit dieser Eingabe Vergleich des Ergebnisses der Programmausführung mit der zu erwartenden Ausgabe Problem: Erschöpfendes Testen i. a. nicht möglich Systematisches Testen Folie 15 Folie 16

5 Systematisches Testen Orientierung an Bedingungen Systematische Festlegung von repräsentativen Testfällen Orientierung: Durchlaufen aller Anweisungen Durchlaufen aller Verzweigungen Durchlaufen aller Pfade im Programm Erster Ansatz: Orientierung an Verzweigungen (Bedingungen) 1. Bedingung b 0 c 0 b > 0 c > 0 2.Bedingung 2. Bedingung x y ( b c ) x = y ( b = c ) Bedingungen: 1) b 0 c 0 2) x y : a) b 0 c 0 x = y (b = c) b) b > 0 c > 0 x > y (b > c) x < y (b < c) Mögliche Testfälle: 1) b 0 c 0 2) b > 0 c > 0 b = 0 c = -2 b = c : b = c = 100 b = - c = 0 b > c : b = 24, c = 9 b = 0 c = 0 b < c : b = 16, c =25 b = 4 c = 0 b = 0 c = 5 Folie 17 Folie 18 Systematische Entwicklung von Programmen 2. Algorithmenentwurf Beispiel: Suchen Phasen: Aktivitäten Analysieren Problem Problembeschreibung Was soll Programm lösen? Dokumente: Niederschriften Spezifikation Problem: Suchen Ist ein vorgegebenes Element T in einer aufsteigend sortierten Liste X von Elementen aus der Menge D enthalten? Entwerfen Implementieren Algorithmus Entwurf der Lösung: Wie? Konzept des Programms Algorithmus Beispiel: X = [10, 20, 0, 40] a) T = 45 : T X Ausgabe: None b) T = 0 : T X Ausgabe: 2, da T==X[2] Algorithmus als Programm in einer konkreten Sprache Programm Testen Testat: Warum? Testfälle und Ergebnisse Folie 19 Folie 20

6 Problembeschreibung Spezifikation: Gegeben: Menge D, z.b. natürliche Zahlen. Sortierte Liste X[0 N 1] von Elementen des Typs D X[0] X[1] X[2]... X[N 1]. T Є D. Eingabe: X, T Gesucht: Ist T Element von X? Ausgabe: Falls Ja: Position M mit T == X[M] Falls Nein: None Algorithmusentwurf: Naiver Ansatz Vergleiche T mit jedem Element von X T == X[0] : ja : M = 0, fertig nein : weiter T == X[1] : ja : M = 1, fertig nein : weiter T == X[N-1] : ja : M = N - 1, fertig nein : Ausgabe None, fertig Folie 21 Folie 22 Python Programm Laufzeit des Algorithmus Der Algorithmus bricht ab, sobald T in X gefunden wird. def search_naive(x,t): N = len(x) for i in range (0,N-1): if T == X[i]: return i return None Ist T nicht in X enthalten, so muß die gesamte Liste X untersucht werden. Enthält die Eingabe N Elemente, so benötigt der Algorithmus maximal N Schritte. Naiver Ansatz berücksichtigt nicht die Information, daß die Liste sortiert ist. Folie 2 Folie 24

7 Algorithmusentwurf: Alternativer Ansatz Entwurf Binäre Suche Schrittweise Reduktion des Suchbereichs auf Basis der Spezifikation durch systematische Reduktion des Suchbereichs: Grenzen L (Low), U (Upper) ausgehend vom Bereich 0 N 1, derart, dass falls T Є X[0 N 1] gilt, muss T Є X[L U] mit 0 L U N 1 gelten. Schlüsselidee Ausnutzung der Sortierung Reduktion des Suchbereichs durch Vergleich seines mittleren Elements mit T und Verwerfen des irrelevanten halben Bereichs usw. solange, bis T gefunden wird: T Є X, oder ein leerer Bereich erhalten wird. Initialisiere Bereich Schleife: { Schlüsselidee } if Bereich == leer: return None Berechne Position M als Ausgangspunkt für die Bereichsreduktion Wird T während des Reduktionsprozesses in X gefunden: return Position von T in X : M Folie 25 Folie 26 Schlüsselidee Ausgehend vom Bereich 0 N 1 sicherstellen, dass falls T Є X[0 N 1] gilt, T Є X[L U] mit 0 L U N 1 gelten muss. Formalisierung: Prädikat P T Є X[0 N 1] (T Є X[L U] Λ 0 L U N 1) : logische Implikation Invariante: Prädikat, das immer gültig ist. Schlüsselidee hat den Charakter einer Invarianten. Verfeinerung des Entwurfs Wir stellen sicher, dass alle Aktionen das Prädikat P respektieren. 1.Darstellung von Bereich Indizes L (Low) und U (Upper) für obere und untere Grenze des Bereichs 2. Initialisierung des Bereichs L = 0, U = len(x) 1.. Prüfe auf leeren Bereich Der Bereich [L U] ist leer, falls L > U. Wir terminieren die Schleife mit return None 4.Mitte des Bereichs (Divide) M = (L + U)/2 Folie 27 Folie 28

8 Verfeinerung des Entwurfs 5. Vergleiche T mit X[M] und führe entsprechende Aktion zur Bewahrung von P aus (Conquer). (a) X[M] < T: Wir wissen: X[0] X[1] X[M] < T T ist nicht außerhalb von X[L U] d.h. T muß in X[M+1 U] sein. Bereichsreduktion:L = M + 1 Invariante P gilt nach wie vor! (b) X[M] == T: T Є X, M Position, Schleife beenden. (c) X[M] > T: Symmetrisch zu (a) mit Bereichsreduktion U = M 1. Python Programm def binary_search(x,t): L, U = 0, len(x)-1 while True: if L > U: return None M = (L+U) / 2 if X[M] < T: L = M+1 elif X[M] == T: return M else: U = M-1 Folie 29 Folie 0 Laufzeit des Algorithmus Für N=7: Maximal Schritte X X X X X X X ( ) ( N ) Abschätzung für Anzahl der Schritte: = log2 N + 1 log da in jedem Schritt der Suchraum halbiert wird. s 2 Zum Vergleich: Naiver Ansatz benötigt s = N Schritte. Literatur [CLRS07] T. Cormen, C. Leiserson, R. Rivest, C. Stein; Algorithmen Eine Einführung, 2007, Oldenbourg, ISBN [LL06] J. Ludewig, H. Lichter, Software Engineering, 2006, Dpunkt Verlag, ISBN [OW02] T. Ottmann, P. Widmayer Algorithmen und Datenstrukturen, 2002, Spektrum Akademischer Verlag, ISBN [SE02] R. Sedgewick. Algorithms, 2002, Pearson Studium, ISBN Folie 1 Folie 2