Verifikation von Programmen
|
|
- Matthias Ackermann
- vor 6 Jahren
- Abrufe
Transkript
1 Verifikation von Programmen OOPM, Ralf Lämmel
2 380 Was tun? (Mit den Spezifikationen) Dokumentation Überprüfen der Bedingungen zur Laufzeit Verifizieren der Bedingungen vor Laufzeit Ableitung einer korrekten Implementation aus Spezifikation Verwendung der Spezifikation zur Testdatengenerierung
3 381 Entwicklung korrekter Programme 1. Ansatz OOPM Aufstellung einer Spezifikation (Problembeschreibung). Erstellung einer Implementation (Problemlösung). Beweis über Einhaltung der Spezifikation durch Programm. 2. Ansatz Aufstellung einer Spezifikation. Schrittweise Ableitung einer (effizienten) Implementation. Korrektheit folgt aus Konstruktion. OOPM
4 382 Programme mit Spezifikation = Tripel { P } S { Q } S ist eine Anweisung. P und Q sind Zusicherungen (Bedingungen) P heißt Vorbedingung. Q heißt Nachbedingung.
5 383 Formale Bedeutung von Tripeln { P } S { Q } Zwei Optionen: Totale Korrektheit: Jede Ausführung von S ausgehend von einem Zustand, in dem P gilt, wird normal zum Halt kommen in einem Zustand, in dem Q gilt. Partielle Korrektheit: Jede Ausführung von S ausgehend von einem Zustand, in dem P gilt, wird entweder nicht normal zum Halt kommen (z.b. nicht terminieren) oder normal zum Halt kommen in einem Zustand, in dem Q gilt.
6 384 Spezifikation für die Division mit Rest { x >= 0 && y > 0 } q = 0; r = x; while (r >= y) { r = r - y; q = q + 1; } { x == y * q + r && r < y && r >= 0 && q >= 0 } Wie können wir einen Beweis angehen?
7 Ein Tripel wird zerlegt in viele Teilbeweise mit kleineren Tripeln. { x >= 0 && y > 0 } q = 0; {? } r = x; {? } while (r >= y) { {? } r = r - y; {? } q = q + 1; Betrachtung der Optionen für S in { P } S { Q } Zuweisung Anweisungssequenz While-Schleife {? } } { x == y * q + r && r < y && r >= 0 && q >= 0 } (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 385
8 Zusammenfassung der Beweisschritte für Division mit Rest { x >= 0 && y > 0 } q = 0; {? } r = x; 7.Zuweisung 6.Zuweisung {? } while (r >= y) { 5.Zuweisung {? } r = r - y; {? } 4.Zuweisung q = q + 1; {? } 3.Sequenz } { x == y * q + r && r < y && r >= 0 && q >= 0 } QED 1.Sequenz 2.While Der Beweis beginnt von hinten. (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 386
9 387 Beweisschritte für Sprachkonstruktionen Zuweisung Anweisungssequenz While-Schleife
10 OPTION Annahme Nur Q ist gegeben. Vorgehensweise Ermittle P aus Q. Beispiel Beweis einer Zuweisung { P } v = t; { Q } Ersetze v in Q durch t. Instanzierung v t P Q x y y==0 x==0 { y==0 } x = y; { x==0 } Wir lesen also die Vorbedingung P aus dem Programm ab.
11 OPTION Annahme Beweis einer Zuweisung { P } v = t; { Q } P und Q sind gegeben. Vorgehensweise Ermittle P aus Q. Ersetze v in Q durch t. Instanzierung v t P x y y==0 P y>=0 Q x>=0 Überprüfe dass P P Beispiel { y==0 } x = y; { x>=0 } P is notwendig für Q. P ist stärker als P. P ist hinreichend für Q.
12 OPTION Beweis einer Zuweisung { P } v = t; { Q } Annahme Nur P ist gegeben. Vorgehensweise Keine allgemeine, systematische Vorgehensweise
13 391 Beweis einer Anweisungssequenz { P } A1; A2 { Q } Annahme Nur Q ist gegeben. Vorgehensweise Zerlege das Problem. { P } A1 { R } { R } A2 { Q } Instanzierung A1 A2 x++; x++; P x>0 R x>1 Q x>2 Führe die Teilbeweise. Beispiel { x>0 } x++; x++; { x>2 } Zwischenrechnung nächste Seite
14 392 Zwischenrechnung Zu zeigen: { x > 1 } x++; { x > 2 } Beweis: Zuckerexpansion für x++ {? } x=x+1; { x > 2 } Ablesen der Vorbedingung { x+1 > 2 } x=x+1; { x > 2 } Vereinfachung von x+1 > 2 { x > 1 } x++; { x > 2 } wzbw.
15 393 Beweis einer While-Schleife { P } while (B) S { Q }?
16 394 // Vor der Schleife Die wesentliche Idee ist, dass eine Schleife eine Invariante I bewahrt. Sie gilt überall. while (B) I gilt hier. // Am Anfang des Schleifenkörpers I gilt hier. B gilt auch. S // Am Ende des Schleifenkörpers I gilt hier. // Nach der Schleife I gilt hier. B gilt nicht.
17 395 Beweis einer Schleife { P } while (B) S { Q } Annahme Nur Q ist gegeben. Vorgehensweise Identifiziere die Invariante I. Zerlege das Problem. { I && B } S { I } I &&!B Q Führe die Teilbeweise. Beispiel { x>=y } while (x>y) x--; { x==y } Instanzierung B x>y S x-- P x>=y Q x==y I x>=y
18 396 Anwendung auf Division mit Rest Schleifeninvariante r >= y { I } Schleifenbedingung r := x; Type to enter text { I && B } r = r - y { I &&!B } q = q + 1 { I } Wie ist I hier beschaffen?
19 397 Ermittlung der Invariante & Co I x == q * y + r && r >= 0 && q >= 0 Heureka! I &&!B x == q * y + r && r < y && r >= 0 && q >= 0 Letzteres ist die Nachbedingung des Programms.
20 { P } S1 { Q }, { Q } S2 { R } { P[x/t] } x = t { P } { P } S1; S2 { R } Mechanisierung der Beweisschritte auf der Basis formaler Regeln { I && B } S { I } { I } while (B) S { I &&!B } P Q, { Q } S { R } { P } S { R } (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 398
21 399 Hoare-Regel für die While-Schleife Voraussetzung { I && B } S { I } { I } while (B) S { I &&!B } Schlussfolgerung B ist die Schleifenbedingung. S ist der Schleifenkörper. I ist die Schleifeninvariante. I muss (fast) überall gelten: - vor und nach der Schleife. - vor und nach jedem Schleifendurchlauf.
22 400 Einsetzen in die Schleife { I && B } S { I } { I } while B S { I &&!B } r >= y { I } Schleifeninvariante Schleifenbedingung r := x; Type to enter text { I && B } r = r - y { I &&!B } q = q + 1 { I }
23 401 Vorkommende Bedingungen { I && B } S { I } { I } while B S { I &&!B } B r >= y (Ablesen aus dem Programm) I x == q * y + r && r >= 0 && q >= 0 Heureka!!B r < y (Symbolische Negation von B) I &&!B x == q * y + r && r < y && r >= 0 && q >= 0 Letzteres ist die Nachbedingung des Programms.
24 402 Einsetzen in die Schleife { I && B } S { I } { I } while B S { I &&!B } r >= y { I x == q * y + r && r >= 0 && q >= 0 } Type to enter text { I && B... && r >= y } r = r - y Zu zeigen! q = q + 1 { I x == q * y + r && r >= 0 && q >= 0 } { I &&!B... && r < y }
25 403 Zu zeigen: Korrektheit des Schleifenkörpers Type to enter text { I && B... && r >= y } r = r - y q = q + 1 { I x == q * y + r && r >= 0 && q >= 0 } Plan: Wir führen unsere Beweise weiterhin von hinten.
26 404 Betrachtung von Anweisungsfolgen { I && B... && r >= y } r = r - y??? q = q + 1 { I x == q * y + r && r >= 0 && q >= 0 }
27 405 Hoare-Regel für die Anweisungsverkettung { P } S1 { Q }, { Q } S2 { R } { P } S1; S2 { R } Zwei Anweisungen S 1 und S 2, welche nacheinander ausgeführt werden, können zu einem Programmstück S 1 S 2 zusammengesetzt werden, wenn die Nachbedingung von S 1 mit der Vorbedingung von S 2 identisch ist.
28 406 TODO: Ablesen der Zwischen- und Vorbedingungen von hinten anfangend Type to enter text {??? } r = r - y {??? } q = q + 1 { I x == q * y + r && r >= 0 && q >= 0 }
29 407 Hoare-Regel (Axiom) für Zuweisung { P[x/t] } x = t { P } Das ist ein Axiom -- eine Regel ohne Prämissen. Substitution von x durch t. Wir setzen hier voraus, dass t keine Seiteneffekte hat.
30 408 Hintere Zuweisung in der Schleife { x == (q + 1) * y + r && r >= 0 && q + 1 >= 0 } q = q + 1 { x == q * y + r && r >= 0 && q >= 0 } Ermittlung der Vorbedingung aus der Nachbedingung. Substituiere q durch q + 1.
31 409 TODO: Ablesen der Vorbedingung Type to enter text {??? } r = r - y { x == (q + 1) * y + r && r >= 0 && q + 1 >= 0 } q = q + 1 { x == q * y + r && r >= 0 && q >= 0 } Nun müssen wir weiter nach vorn gehen.
32 410 Vordere Zuweisung in der Schleife { x == (q + 1) * y + (r - y) && r - y >= 0 && q + 1 >= 0 } r = r - y { x == (q + 1) * y + r && r >= 0 && q + 1 >= 0 } Ermittlung der Vorbedingung aus der Nachbedingung. Substituiere r durch r - y.
33 411 Betrachtung von Anweisungsfolgen { x == (q + 1) * y + (r - y) && r - y >= 0 && q + 1 >= 0 } r = r - y { x == (q + 1) * y + r && r >= 0 && q + 1 >= 0 } q = q + 1 { x == q * y + r && r >= 0 && q >= 0 } Die innere Bedingung war nur Mittel zum Zweck.
34 412 Betrachtung von Anweisungsfolgen { x == (q + 1) * y + (r - y) && r - y >= 0 && q + 1 >= 0 } r = r - y q = q + 1 { x == q * y + r && r >= 0 && q >= 0 } Die innere Bedingung war nur Mittel zum Zweck.
35 413 Anpassung von Bedingungen Haben : Mechanisch abgeleitete Vorbedingung { x == (q + 1) * y + (r - y) && r - y >= 0 && q + 1 >= 0 } r = r - y q = q + 1 { x == q * y + r && r >= 0 && q >= 0 }
36 414 Anpassung von Bedingungen Soll : Ursprüngliche Spezifikation des Schleifenkörpers { I && B x == q * y + r && r >= 0 && q >= 0 && r >= y } r = r - y q = q + 1 { x == q * y + r && r >= 0 && q >= 0 } { I && B } S { I } { I } while B S { I &&!B }
37 415 Anpassung von Bedingungen Soll x == q * y + r && r >= y && r >= 0 && q >= 0 Haben x == (q + 1) * y + (r - y) && r - y >= 0 && q + 1 >= 0 Plan: Wir ordnen die einzelnen Operanden der Konjunktionen aus den beiden Formeln einander zu.
38 Anpassung von Bedingungen Soll x == q * y + r && r >= y && r >= 0 && q >= 0 Haben x == (q + 1) * y + (r - y) && r - y >= 0 && q + 1 >= 0 Nebenrechnung x == (q + 1) * y + (r - y) x == q * y + y + r - y (Ausmultiplizieren) (... +y und... -y) x == q * y + r (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 416
39 417 Anpassung von Bedingungen Soll... && r >= y && r >= 0 && q >= 0 Haben... && r - y >= 0 && q + 1 >= 0 Nebenrechnung r - y >= 0 (Addiere y) r >= y
40 418 Anpassung von Bedingungen Soll... &&... && r >= 0 && q >= 0 Haben... &&... && q + 1 >= 0 Soll Haben q >= 0 q + 1 >= 0 Die Ableitung der Vorbedingung aus der Nachbedingung ergibt die schwächste, solche Bedingung. Wir können auch mehr fordern.
41 419 Anpassung von Bedingungen Soll... &&... && r >= 0 &&... Haben... &&... &&... Soll Haben r >= 0 true Die Ableitung der Vorbedingung aus der Nachbedingung ergibt die schwächste, solche Bedingung. Wir können auch mehr fordern.
42 420 Schwäche/Stärke von Bedingungen Zielstellung: Vorbedingungen so schwach wie möglich. Nachbedingungen so stark wie möglich. Definitionen x ist schwächer als y wenn y x. x ist echt schwächer als y wenn nicht auch x y.
43 421 Hoare-Regel für die Verstärkung der Vorbedingung P Q, { Q } S { R } { P } S { R }
44 422 Die Schleife ist bewiesen. { I && B } S { I } { I } while B S { I &&!B } r >= y { I x == q * y + r && r >= 0 && q >= 0 } Type to enter text { I && B... && r >= y } r = r - y q = q + 1 { I } { I &&!B... && r < y }
45 Fortsetzung des Gesamtbeweises (ohne neue Ideen) q = 0 { x >= 0 && y > 0 } r = x r >= y { x == q * y + r && r >= 0 && q >= 0 } Verbleibender Programmteil r = r - y r := x; q = q + 1 { x == q * y + r && r < y && r >= 0 && q >= 0 } (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 423
46 424 Hintere Zuweisung { x == q * y + x && x >= 0 && q >= 0 } r = x { x == q * y + r && r >= 0 && q >= 0 }
47 425 Vordere Zuweisung { x == 0 * y + x && x >= 0 && 0 >= 0 } q = 0 { x == q * y + x && x >= 0 && q >= 0 }
48 426 Vordere Zuweisung (nach Vereinfachung) { x >= 0 } q = 0 { x == q * y + x && x >= 0 && q >= 0 }
49 427 Betrachtung von Anweisungsfolgen { x >= 0 } q = 0 { x == q * y + x && x >= 0 && q >= 0 } r = x { x == q * y + r && r >= 0 && q >= 0 } Die innere Bedingung war nur Mittel zum Zweck.
50 Betrachtung von Anweisungsfolgen { x >= 0 } q = 0 r = x { x == q * y + r && r >= 0 && q >= 0 } Die innere Bedingung war nur Mittel zum Zweck. (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 428
51 429 Anpassung von Bedingungen Soll x >= 0 && y > 0 Haben x >= 0 Soll Haben Die Ableitung der Vorbedingung aus der Nachbedingung ergibt die schwächste, solche Bedingung. Wir können auch mehr fordern -- etwa mit dem Ziel der Terminierung im Auge.
52 Das Programm mit Spezifikation ist korrekt. { x >= 0 && y > 0 } q = 0 r = x r >= y r = r - y r := x; q = q + 1 { x == q * y + r && r < y && r >= 0 && q >= 0 } Q.E.D. (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 430
53 431 Zusammenfassung der Methode zum Beweis der Korrektheit mit Hoare-Regeln Programme mit Spezifikationen: { Vorbedingung } Programm { Nachbedingung } Vor- und Nachbedingungen sind logische Formeln: Hoare- Tripel Formeln beschreiben Annahmen über Variablenbelegungen. Es gibt Korrektheitsregeln für jede Anweisungsform. Vorgehenweise beim Korrektheitsbeweis Ergänze alle Programmstücke mit Vor- und Nachbedingungen. Überprüfe alle Tripel auf Korrektheit gemäß Regeln.
54 432 Beweisregeln A1,..., An A0 Jedes Ai ist... entweder ein Hoare-Tripel oder eine prädikatenlogische Formel. Benutzung Boolescher Ausdrücke der Programmiersprache.
55 433 Arten von Regeln Programmiersprachenabhängige Regeln Zuweisung If-Anweisung... Programmiersprachenunabhängige Regeln Anpassung von Vor- und Nachbedingungen Prädikatenlogische Regeln
56 Hoare-Regel für If-Then-Else { P && B } S1 { R }, { P &&!B } S2 { R } { P } if (B) S1 else S2 { R } P && B S 1 P B Ja Nein P &&!B S 2 R R R (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 434
57 Hoare-Regel für If-Then { P && B } S { R }, P &&!B R { P } if (B) S { R } P && B S P B Ja Nein P &&!B Leere Anweisung R R R (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 435
58 436 Hoare-Regel für die Verstärkung der Vorbedingung P Q, { Q } S { R } { P } S { R }
59 437 Hoare-Regel für die Abschwächung der Nachbedingung { P } S { Q }, Q R Diese Regel wird im Beispielbeweis nicht verwendet. { P } S { R }
60 Im Beispiel verwendete Regeln { P } S1 { Q }, { Q } S2 { R } { P[x/t] } x = t { P } { P } S1; S2 { R } { I && B } S { I } { I } while (B) S { I &&!B } P Q, { Q } S { R } { P } S { R } (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 438
61 439 2 Fangfragen { x >= 0 && y > 0 } Können wir die Vorbedingung abschwächen so dass auch Division mit Rest für negative Zahlen korrekt modelliert ist oder müssen wir zusätzlich das Programm ändern? q = 0; r = x; while (r y) { r = r - y; q = q + 1; } Schließen wir aus, dass x und y nicht geändert wurden? Taugt die Beweismethode dazu? { x == y q + r && r < y && r >= 0 && q >= 0 }
62 440 Situationen beim Beweisen Tote Schleife Endlosschleife Inkorrekte Schleife Erfolgreicher Beweis...
63 441 Tote Schleife { I &&!B } B r := x; Type { I to && enter B } text { I &&!B } S { I } Die Schleifenbedingung ist definitiv vor der Schleife unerfüllt.
64 442 Endlosschleife { I } B r := x; Type to enter text { I && B } S { I && B } { I &&!B } Der Schleifenkörper stellt immer wieder die Gültigkeit der Schleifenbedingung her.
65 443 Inkorrekte Schleife { I } B Type to enter text { I &&!B } S { I } { I &&!B } Der Schleifenkörper verlangt, dass die negierte Schleifenbedingung zum Eintritt in die Schleife gelten muss.
66 444 Erfolgreicher Beweis { I } B r := x; Type to enter text { I && B } S { I } { I &&!B } Die Vorbedingung (eventuell durch Abschwächung) lässt sich aus der Nachbedingung ableiten.
67 Zusammenfassung Einfache Programme sind nicht einfach korrekt. Softwareentwickler benötigen mathematische Fähigkeiten. Softwareentwicklung benötigt Beweisautomatisierung. Kosten von Korrektheit motivieren Wiederverwendung. Ausblick Schnittstellen Zeiger Abstrakte Datentypen
68 Weitere Verifikationsbeispiele (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 446
69 { 447 Verifikationsbeispiel: Schnelle Potenzierung Problem Berechne x n Naive Methode x n = x *... * x n mal Kosten: n - 1 Multiplikationen Wie geht das schneller?
70 448 Schnelle Potenzierung Zu berechnen: x n Fall 1: n ist gerade, etwa n = 2k Berechne x = x 2. Gib x k zurück. Fall 2: n ist ungerade, etwa n = 2k + 1 Berechne x = x 2. Gib x * x k zurück. Dies ergibt O(log n) Multiplikationen.
71 449 Imperative, iterative Implementation Schneller Exponentation public static int power(int x, int n) { int k = n; int p = x; int y = 1; while (k>0) if (k % 2 == 0) { p = p * p; k = k / 2; } else { y = y * p; k = k - 1; } return y; }
72 450 Formierung eines Hoare-Tripels { n >= 0 } int k = n; int p = x; int y = 1; while (k>0) if (k % 2 == 0) { p = p * p; k = k / 2; } else { y = y * p; k = k - 1; } { y == x n }
73 451 Was ist die Schleifen-Invariante I? Ansatz: Wie stehen die Programmvariablen in Beziehung? x und n sind konstant. Wir setzen n = 10. y p k x n 1 x 10 x 10 1 x 2 5 x 10 x 2 x 2 4 x 10 x 2 x 4 2 x 10 x 2 x 8 1 x 10 x 10 x 8 0 x 10 y * p k x 10 x 10 x 10 x 10 x 10 x 10 Wie man leicht sieht: I y * p k == x n && k >= 0
74 452 Verifikation der While-Schleife { I y * p k == x n && k >= 0 } while k > 0 Type to enter text { I B... && k > 0 } if (k % 2) == 0 { p := p * p; k := k / 2; } else { y = y * p; k = k - 1; } { I } { I!B... &&!(k > 0) }
75 453 Verifikation der Fallunterscheidung { I && B y * p k == x n && k >= 0 && k > 0 } { B k % 2 == 0 } Ja Nein { I && B && B } y * p k == x n && k >= 0 && k > 0 && k % 2 == 0 { I && B &&!B } y * p k == x n && k >= 0 && k > 0 &&!(k % 2 == 0) p := p * p; k := k / 2; { I } y = y * p; k = k - 1; { I } { I y * p k == x n && k >= 0 }
76 Hoare-Regel für If-Then-Else { P && B } S1 { R }, { P &&!B } S2 { R } { P } if B S1 else S2 { R } P && B S 1 P B Ja Nein P &&!B S 2 R R R (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 454
77 Fall 1: Then -Zweig { I && B && B } y * p k == x n && k >= 0 && k > 0 && k % 2 == 0 Soll? y * (p * p) k / 2 == x n && k / 2 >= 0 p = p * p; Haben y * p k / 2 = x n && k / 2 >= 0 k = k / 2; { I } y * p k == x n && k >= 0 (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 455
78 456 Fall 1: Then -Zweig Soll y * p k == x n && k >= 0 && k > 0 && k % 2 == 0 y * (p * p) k / 2 == x n && k >= 0 && k > 0 && k % 2 == 0 y * (p * p) k / 2 == x n && k / 2 >= 0 && k > 0 && k % 2 == 0 y * (p * p) k / 2 == x n && k / 2 >= 0 Haben
79 457 Fall 2: Else -Zweig Übungsaufgabe
80 458 Verifikationsbeispiel: Berechnung des Quadrats einer Zahl Restriktionen: ohne Verwendung von * mit Verwendung von +. Eine Option für den Lösungsansatz:
81 459 Veranschaulichung der Generierung der Quadratzahlen Quelle:
82 Imperative, iterative Implementation i = 0 k = -1 y = 0 i < n i = i + 1 r := x; k = k + 2 y = y + k 3 (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 460
83 Formierung eines Hoare-Tripels { P } i = 0 k = -1 y = 0 i < n i = i + 1 r := x; k = k + 2 y = y + k { Q } 3 Welches sind die Vor- und Nachbedingungen? (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 461
84 462 Aufstellung der Spezifikation { n >= 0 } i = 0 k = -1 y = 0 i < n r := x; i = i + 1 k = k + 2 y = y + k { y = n*n } 3
85 463 Beweis von hinten { n >= 0 } i = 0 k = -1 y = 0 i < n r := x; i = i + 1 k = k + 2 y = y + k { y = n*n } 3 Wir wenden die Beweisregel für While-Schleifen an.
86 464 Hoare-Regel für die While-Schleife { I && B } S { I } { I } while B S { I &&!B }
87 465 Anwendung der Schleifenregel i < n { I } Type to enter text i = i + 1 { I && B } k = k + 2 y = y + k { I } { I &&!B } 6
88 466 Was ist die Schleifen-Invariante I? Ansatz: Wie stehen die Programmvariablen in Beziehung? n ist konstant. Wir setzen n = 4. i k y n k == 2*i - 1 y == i*i 0 <= i <= n I k == 2*i - 1 && y == i*i && i <= n
89 467 Verifikation der Schleife i < n { I k == 2*i - 1 && y == i*i && i <= n } Type to enter text i = i + 1 k = k + 2 y = y + k { I && B... && i < n } Zu vereinfachen! { I } { I &&!B... &&!(i < n) } i <= n && i < n i < n
90 468 Verifikation des Schleifenkörpers i < n Type to enter text { k == 2*i 1 && y == i*i && i < n } { k + 2 == 2*(i+1) 1 && y + k + 2 == (i+1)* (i+1) && i+1 <= n } i = i + 1 { k + 2 == 2*i 1 && y + k + 2 == i*i && i <= n } k = k + 2 Soll Haben { k == 2*i 1 && y + k == i*i && i <= n } y = y + k { k == 2*i 1 && y == i*i && i <= n } k + 2 == 2*(i + 1) 1 k + 2 == 2*i k == 2*i 1 y + k + 2 == (i +1)* (i +1) y + k == i*i + 2*i + 1 y + 2*i == i*i + 2*i + 1 y + 2*i + 1 == i*i + 2*i + 1 y == i*i i+1 <= n i < n
91 469 Restliche Zuweisungen zu verifizieren { n >= 0 } i = 0 Type to enter k = -1 y = 0 i < n r := x; i = i + 1 k = k + 2 y = y + k { y = n*n } 3
92 Restliche Zuweisungen zu verifizieren { n >= 0 } { -1 == 2*0-1 && 0 == 0*0 && 0 <= n } i = 0 { -1 == 2*i - 1 && 0 == i*i && i <= n } k = -1 y = 0 { k == 2*i - 1 && 0 == i*i && i <= n } { k == 2*i - 1 && y == i*i && i <= n } -1 == 2*0-1 && 0 == 0*0 && 0 <= n n >= 0 (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 470
93 { 471 Eine Übungsaufgabe Problem (wie zuvor): Berechnen des Quadrats einer Zahl ohne Verwendung von * mit Verwendung von +. Eine andere Option für ein Lösungsansatz: n 2 = n n n mal Aufgabe: Programm Spezifikation Korrektheitsbeweis
Teil X. Programmverifikation. Spezifikation eines Algorithmus einer Funktion einer Prozedur. Vorbedingungen Parameter Wertebereiche
Teil X Programmverifikation STRUKTURIERTES PROGRAMMIEREN Vorlesung im Wintersemester 2015 Prof. E.G. Schukat-Talamazzini Stand: 24. Juli 2015 Robert W Floyd 1936 2001 Sir Charles Antony Richard Hoare *1934
Mehr5. Spezifikation und Verifikation von Programmen. Hier: Spezifikation einfacher Programme
5. Spezifikation und Verifikation von Programmen Programmentwicklung: genaue Kenntnis der gewünschten Leistungen offensichtlich unabdingbar In größeren Systemen: Anforderungsdefinition legt fest: - Funktionalität
MehrÜbersicht. Schleifen. Schleifeninvarianten. Referenztypen, Wrapperklassen und API. 9. November 2009 CoMa I WS 08/09 1/15
Übersicht Schleifen Schleifeninvarianten Referenztypen, Wrapperklassen und API CoMa I WS 08/09 1/15 CoMa I Programmierziele Linux bedienen Code umschreiben strukturierte Datentypen Anweisungen und Kontrollstrukturen
MehrDr. Monika Meiler. Inhalt
Inhalt 4 Einführung in die Programmiersprache Java (Teil II)... 4-2 4.4 Strukturierte Programmierung... 4-2 4.4.1 Strukturierung im Kleinen... 4-2 4.4.2 Addierer (do-schleife)... 4-3 4.4.3 Ein- Mal- Eins
Mehr1. Teilklausur. Modul "OOPM Vorlesung/Übung" 16.12.2008. Gruppe A
Objektorientierte Programmierung und Modellierung WS 2008/2009 Institut für Informatik Prof. Dr. Ralf Lämmel Dr. Manfred Jackel 1. Teilklausur Modul "OOPM Vorlesung/Übung" 16.12.2008 Gruppe A Name Vorname
MehrDr. Monika Meiler. Inhalt
Inhalt 4 Anweisungen... 4-2 4.1 Strukturierte Programmierung... 4-2 4.1.1 Geschichte... 4-2 4.1.2 Strukturierung im Kleinen... 4-2 4.2 Einige Beispielanwendungen... 4-4 4.2.1 Addierer (do-schleife)...
MehrVBA-Programmierung: Zusammenfassung
VBA-Programmierung: Zusammenfassung Programmiersprachen (Definition, Einordnung VBA) Softwareentwicklung-Phasen: 1. Spezifikation 2. Entwurf 3. Implementierung Datentypen (einfach, zusammengesetzt) Programmablaufsteuerung
MehrMaster Technische Informatik. Seminar Informatik- SS 2010. Formale Programmverifikation: theoretische Grundlagen und Beispiele
Master Technische Informatik Seminar Informatik- SS 2010 (Betreuer: Prof. Nissen) Formale Programmverifikation: theoretische Grundlagen und Beispiele Bearbeiterin: Dorota Buczynski Matrikelnr. 11035857
Mehr4 Greedy-Algorithmen (gierige Algorithmen)
Greedy-Algorithmen (gierige Algorithmen) Greedy-Algorithmen werden oft für die exakte oder approximative Lösung von Optimierungsproblemen verwendet. Typischerweise konstruiert ein Greedy-Algorithmus eine
MehrOft kommt es darauf an, Potenzen a n mod m zu berechnen. Dabei kann n eine sehr groÿe Zahl sein.
Oft kommt es darauf an, Potenzen a n mod m zu berechnen. Dabei kann n eine sehr groÿe Zahl sein. 3 1384788374932954500363985493554603584759389 mod 28374618732464817362847326847331872341234 Wieso kann ein
Mehr2. Vorlesung. Slide 40
2. Vorlesung Slide 40 Knobelaufgabe Was tut dieses Programm? Informell Formal Wie stellt man dies sicher? knobel(a,b) { Wenn a = 0 dann return b sonst { solange b 0 wenn a > b dann { a := a - b sonst b
MehrAssertions (Zusicherungen)
April 10, 2005 Oberseminar Software-Entwicklung Inhalt 1. Einführung (Motivation, Tony Hoare, Programmverifikation) 2. Design by Contract (Idee, Eiffel) 3. Praxis: Programming by Contract for Python 4.
MehrProgrammiertechnik II
Analyse von Algorithmen Algorithmenentwurf Algorithmen sind oft Teil einer größeren Anwendung operieren auf Daten der Anwendung, sollen aber unabhängig von konkreten Typen sein Darstellung der Algorithmen
MehrTeil 2 - Softwaretechnik. Modul: Programmierung B-PRG Grundlagen der Programmierung 1 Teil 2. Übersicht. Softwaretechnik
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
MehrInteraktionen zwischen Objekten durch Senden von Nachrichten und Reagieren auf empfangene Nachrichten
Objekt Objekt kapselt Variablen und Routinen Interaktionen zwischen Objekten durch Senden von Nachrichten und Reagieren auf empfangene Nachrichten Eigenschaften jedes Objekts: Identität (identisch = mehrere
MehrGrundlagen der Programmierung (Vorlesung 14)
Grundlagen der Programmierung (Vorlesung 14) Ralf Möller, FH-Wedel Vorige Vorlesung Verifikation von Anweisungen und Anweisungsfolgen Schleifen Inhalt dieser Vorlesung Funktionen und Prozeduren Lernziele
MehrGrundlagen der Künstlichen Intelligenz
Grundlagen der Künstlichen Intelligenz 27. Aussagenlogik: Logisches Schliessen und Resolution Malte Helmert Universität Basel 28. April 2014 Aussagenlogik: Überblick Kapitelüberblick Aussagenlogik: 26.
MehrTheoretische Informatik
Theoretische Informatik Einheit 1 Mathematische Methodik 1. Problemlösen 2. Beweistechniken 3. Wichtige Grundbegriffe Methodik des Problemlösens Klärung der Voraussetzungen Welche Begriffe sind zum Verständnis
MehrAbschnitt: Algorithmendesign und Laufzeitanalyse
Abschnitt: Algorithmendesign und Laufzeitanalyse Definition Divide-and-Conquer Paradigma Divide-and-Conquer Algorithmen verwenden die Strategien 1 Divide: Teile das Problem rekursiv in Subproblem gleicher
MehrJava Einführung Operatoren Kapitel 2 und 3
Java Einführung Operatoren Kapitel 2 und 3 Inhalt dieser Einheit Operatoren (unär, binär, ternär) Rangfolge der Operatoren Zuweisungsoperatoren Vergleichsoperatoren Logische Operatoren 2 Operatoren Abhängig
MehrGrundlagen der Programmierung Prof. H. Mössenböck. 14. Schrittweise Verfeinerung
Grundlagen der Programmierung Prof. H. Mössenböck 14. Schrittweise Verfeinerung Entwurfsmethode für Algorithmen Wie kommt man von der Aufgabenstellung zum Programm? Beispiel geg.: Text aus Wörtern ges.:
MehrProgrammieren I. Kontrollstrukturen. Heusch 8 Ratz 4.5. www.kit.edu. Institut für Angewandte Informatik
Programmieren I Kontrollstrukturen Heusch 8 Ratz 4.5 KIT Universität des Landes Baden-Württemberg und nationales Großforschungszentrum in der Helmholtz-Gemeinschaft www.kit.edu Arten von Kontrollstrukturen
Mehr1. Der Begriff Informatik 2. Syntax und Semantik von Programmiersprachen. I.2. I.2. Grundlagen von von Programmiersprachen.
1. Der Begriff Informatik 2. Syntax und Semantik von Programmiersprachen I.2. I.2. Grundlagen von von Programmiersprachen. - 1 - 1. Der Begriff Informatik "Informatik" = Kunstwort aus Information und Mathematik
MehrVerträge für die funktionale Programmierung Design und Implementierung
1 Verträge für die funktionale Programmierung Design und Implementierung RALF HINZE Institut für Informatik III, Universität Bonn Römerstraße 164, 53117 Bonn, Germany Email: ralf@informatik.uni-bonn.de
MehrEinfache Rechenstrukturen und Kontrollfluss II
Einfache Rechenstrukturen und Kontrollfluss II Martin Wirsing in Zusammenarbeit mit Moritz Hammer und Axel Rauschmayer http://www.pst.informatik.uni-muenchen.de/lehre/ss06/infoii/ SS 06 Ziele Lernen imperative
MehrPrimitive Datentypen
Primitive Datentypen 2 Arten von Datentypen: primitive Datentypen (heute) Objekte (später) Java ist streng typisiert, d.h. für jede Variable muß angegeben werden was für eine Art von Wert sie aufnimmt.
MehrEinfaches Programmtesten
http://www.constructionphotography.com Einfaches Programmtesten OOPM, Ralf Lämmel Naives Testen versus systematisches Testen (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 76 (C) Ralf Lämmel, OOPM,
MehrWirtschaftsinformatik I
Wirtschaftsinformatik I - Tutorium 6/ 7 (April 2010) Zusatzinformationen - Lösungsvorschläge Wirtschaftsinformatik I Tutorium Jochen Daum (4.Semester BWL) Universität Mannheim Rechtshinweis: Diese Präsentation
MehrAlgorithmen und algorithmische Sprachkonzepte
Algorithmen und algorithmische Sprachkonzepte Programme und Algorithmen Foliensatz von A. Weber zur Vorlesung Informatik I, Bonn, 2002/03 Überarbeitet und ergänzt von W. Küchlin zu Informatik I, Tübingen
MehrSEP 114. Design by Contract
Design by Contract SEP 114 Design by Contract Teile das zu entwickelnde Programm in kleine Einheiten (Klassen, Methoden), die unabhängig voneinander entwickelt und überprüft werden können. Einheiten mit
MehrRekursion. Annabelle Klarl. Einführung in die Informatik Programmierung und Softwareentwicklung
Rekursion Annabelle Klarl Zentralübung zur Vorlesung Einführung in die Informatik: http://www.pst.ifi.lmu.de/lehre/wise-12-13/infoeinf WS12/13 Aufgabe 1: Potenzfunktion Schreiben Sie eine Methode, die
MehrFormale Methoden in der Informatik Wiederholung klassische Logik Konkrete Datentypen (algebraische Strukturen) Abstrakte Datentypen
Was bisher geschah Formale Methoden in der Informatik Wiederholung klassische Logik Konkrete Datentypen (algebraische Strukturen) Abstrakte Datentypen Syntax: Signatur Semantik: Axiome (FOL-Formeln, meist
MehrProbeklausur: Programmierung WS04/05
Probeklausur: Programmierung WS04/05 Name: Hinweise zur Bearbeitung Nimm Dir für diese Klausur ausreichend Zeit, und sorge dafür, dass Du nicht gestört wirst. Die Klausur ist für 90 Minuten angesetzt,
MehrProgrammieren in C. C Syntax Datentypen, Operatoren und Kontrollstrukturen. Prof. Dr. Nikolaus Wulff
Programmieren in C C Syntax Datentypen, Operatoren und Kontrollstrukturen Prof. Dr. Nikolaus Wulff Elementare Typen Imperative und objektorientierte Programmiersprachen bieten i.d.r. einen Satz elementarer
MehrÜbersicht Programmablaufsteuerung
Übersicht Programmablaufsteuerung Konditionale Verzweigung: if - else switch-anweisung Schleifenkonstrukte: while, do - while for Schleife Sprung-Anweisungen: break, continue, goto, return Anweisungen
MehrLogik für Informatiker
Vorlesung Logik für Informatiker 3. Aussagenlogik Einführung: Logisches Schließen im Allgemeinen Bernhard Beckert Universität Koblenz-Landau Sommersemester 2006 Logik für Informatiker, SS 06 p.1 Beispiel:
MehrLaufzeit und Komplexität
Laufzeit und Komplexität Laufzeit eines Algorithmus Benchmarking versus Analyse Abstraktion Rechenzeit, Anzahl Schritte Bester, Mittlerer, Schlechtester Fall Beispiel: Lineare Suche Komplexitätsklassen
MehrStudientag zum Kurs 1793
Studientag zum Kurs 1793 Software Engineering I Methodische Entwicklung objektorientierter Desktop-Applikationen Ziele Den Kurstext aus einer anderen Sicht kennenlernen Vorbereitung auf die mündliche Prüfung
MehrVisual Basic / EXCEL / Makroprogrammierung Unterrichtsreihe von Herrn Selbach
Visual Basic / EXCEL / Makroprogrammierung Unterrichtsreihe von Herrn Selbach Übungsaufgaben zum Kapitel 1 1. Aufgabe In einer EXCEL Tabelle stehen folgende Zahlen: Definiere einen CommandButton, der diese
Mehr1. Musterlösung. Problem 1: Average-case-Laufzeit vs. Worst-case-Laufzeit
Universität Karlsruhe Algorithmentechnik Fakultät für Informatik WS 06/07 ITI Wagner Musterlösung Problem : Average-case-Laufzeit vs Worst-case-Laufzeit pt (a) Folgender Algorithmus löst das Problem der
Mehr620.900 Propädeutikum zur Programmierung
620.900 Propädeutikum zur Programmierung Andreas Bollin Institute für Informatik Systeme Universität Klagenfurt Andreas.Bollin@uni-klu.ac.at Tel: 0463 / 2700-3516 Lösung der Aufgaben (1/2) Lösung Aufgabe
MehrGliederung. Tutorium zur Vorlesung. Gliederung. Gliederung. 1. Gliederung der Informatik. 1. Gliederung der Informatik. 1. Gliederung der Informatik
Informatik I WS 2012/13 Tutorium zur Vorlesung 1. Alexander Zietlow zietlow@informatik.uni-tuebingen.de Wilhelm-Schickard-Institut für Informatik Eberhard Karls Universität Tübingen 11.02.2013 1. 2. 1.
Mehr5. Tutorium zu Programmieren
5. Tutorium zu Programmieren Dennis Ewert Gruppe 6 Universität Karlsruhe Institut für Programmstrukturen und Datenorganisation (IPD) Lehrstuhl Programmierparadigmen WS 2008/2009 c 2008 by IPD Snelting
MehrInformationsblatt Induktionsbeweis
Sommer 015 Informationsblatt Induktionsbeweis 31. März 015 Motivation Die vollständige Induktion ist ein wichtiges Beweisverfahren in der Informatik. Sie wird häufig dazu gebraucht, um mathematische Formeln
MehrDas Briefträgerproblem
Das Briefträgerproblem Paul Tabatabai 30. Dezember 2011 Inhaltsverzeichnis 1 Problemstellung und Modellierung 2 1.1 Problem................................ 2 1.2 Modellierung.............................
Mehr2: Zahlentheorie / Restklassen 2.1: Modulare Arithmetik
Stefan Lucks Diskrete Strukturen (WS 2009/10) 57 2: Zahlentheorie / Restklassen 2.1: Modulare Arithmetik Uhr: Stunden mod 24, Minuten mod 60, Sekunden mod 60,... Rechnerarithmetik: mod 2 w, w {8, 16, 32,
Mehr1 Syntax von Programmiersprachen
1 Syntax von Programmiersprachen Syntax ( Lehre vom Satzbau ): formale Beschreibung des Aufbaus der Worte und Sätze, die zu einer Sprache gehören; im Falle einer Programmier-Sprache Festlegung, wie Programme
Mehr1. Grundzüge der Objektorientierung 2. Methoden, Unterprogramme und Parameter 3. Datenabstraktion 4. Konstruktoren 5. Vordefinierte Klassen
1. Grundzüge der Objektorientierung 2. Methoden, Unterprogramme und Parameter 3. Datenabstraktion 4. Konstruktoren 5. Vordefinierte Klassen II.2.3 Datenabstraktion - 1 - public class Rechteck { Selektoren
MehrKapitel 7: Formaler Datenbankentwurf
7. Formaler Datenbankentwurf Seite 1 Kapitel 7: Formaler Datenbankentwurf Die Schwierigkeiten der konzeptuellen Modellierung sind zu einem großen Teil dadurch begründet, dass sich die relevanten Strukturen
MehrAlgorithmische Kernsprache. Zuweisung, einfache und bedingte Anweisung, Blöcke, Schleifen, return, debugging.
Algorithmische Kernsprache Zuweisung, einfache und bedingte Anweisung, Blöcke, Schleifen, return, debugging. Ausdrücke Anweisungen Ausdrücke bezeichnen einen Wert Kontext stellt Werte von Variablen Werte
MehrInformatik. Studiengang Chemische Technologie. Michael Roth WS 2012/2013. michael.roth@h-da.de. Hochschule Darmstadt -Fachbereich Informatik-
Informatik Studiengang Chemische Technologie Michael Roth michael.roth@h-da.de Hochschule Darmstadt -Fachbereich Informatik- WS 2012/2013 Inhalt Teil VII Einstieg in Java I Michael Roth (h_da) Informatik
MehrEinführung in die Informatik Control Structures and Enumerations
Einführung in die Informatik Control Structures and Enumerations If, while, for und Enumerations Wolfram Burgard Cyrill Stachniss 6.1 Motivation Bisher bestanden die Rümpfe unserer Methoden aus einzelnen
Mehr1 Aussagenlogische Formeln
1 Aussagenlogische Formeln Aufgabe 1.1 Transformieren Sie die Formel in disjunktive Normalform (DNF). ((:A! :B) ^ D)! ((A _ C) $ (:B ^ D)) Lösung 1.1 Schrittweise Transformation: Schritt 1: ((:A! :B) ^
MehrTeil IV. Grundlagen der Programmierung
Teil IV Grundlagen der Programmierung Überblick 1 Einleitung zu C und C++ Aufbau von Programmen/Dateien Steueranweisungen Funktionen Mehr zu Datentypen: Felder, Zeiger und Strukturen Arbeit mit Dateien
MehrZum Einsatz von Operatoren im Informatikunterricht
Friedrich-Schiller-Universität Jena Fakultät für Mathematik und Informatik Professur für Didaktik der Informatik/Mathematik Claudia Strödter E-Mail: claudia.stroedter@uni-jena.de Zum Einsatz von Operatoren
MehrC-Vorrangregeln. Version 1.3 6.7.2009. email: tb@ostc.de Web: www.ostc.de
C-Vorrangregeln Version 1.3 6.7.2009 email: tb@ostc.de Web: www.ostc.de Die Informationen in diesem Skript wurden mit größter Sorgfalt erarbeitet. Dennoch können Fehler nicht vollständig ausgeschlossen
MehrEinführung in die Java- Programmierung
Einführung in die Java- Programmierung Dr. Volker Riediger Tassilo Horn riediger horn@uni-koblenz.de WiSe 2012/13 1 Rückblick Datentypen (int, long, double, boolean, String) Variablen und Variablendeklarationen
MehrSuchen und Sortieren Sortieren. Heaps
Suchen und Heaps (Folie 245, Seite 63 im Skript) 3 7 21 10 17 31 49 28 14 35 24 42 38 Definition Ein Heap ist ein Binärbaum, der die Heapeigenschaft hat (Kinder sind größer als der Vater), bis auf die
MehrSOMA Reverse Engineering
SOMA Reverse Engineering Univ.Prof. Dr. Franz Wotawa Institut für Softwaretechnologie wotawa@ist.tugraz.at Inhalt Was versteht man unter Reverse Engineering? Techniken/Methoden Probleme VU Software Maintenance
MehrSchritt 1. Schritt 1. Schritt 3. - Analysieren des Problems und Spezifizierung einer Lösung.
I. Programmierung ================================================================== Programmierung ist die Planung einer Abfolge von Schritten (Instruktionen), nach denen ein Computer handeln soll. Schritt
MehrEinfache Ausdrücke Datentypen Rekursive funktionale Sprache Franz Wotawa Institut für Softwaretechnologie wotawa@ist.tugraz.at
Inhalt SWP Funktionale Programme (2. Teil) Einfache Ausdrücke Datentypen Rekursive funktionale Sprache Franz Wotawa Institut für Softwaretechnologie wotawa@ist.tugraz.at Interpreter für funktionale Sprache
MehrAlgorithmen & Programmierung. Aspekte von Algorithmen
Algorithmen & Programmierung Aspekte von Algorithmen Algorithmus (Wdh.) Aufgabe Beschreibung einer Abfolge von Schritten zur Lösung eines Problems in einer beliebigen Sprache Charakteristika eines Algorithmus
MehrProgrammiervorkurs WS 2012/2013. Schleifen und Methoden
Programmiervorkurs WS 2012/2013 Schleifen und Methoden Ein Befehl soll mehrfach ausgeführt werden, z.b.: public class MyCounter { System.out.println(1); Ein Befehl soll mehrfach ausgeführt werden, z.b.:
MehrSOI 2013. Die Schweizer Informatikolympiade
SOI Die Schweizer Informatikolympiade Lösung SOI Wie schreibe ich eine gute Lösung? Bevor wir die Aufgaben präsentieren, möchten wir dir einige Tipps geben, wie eine gute Lösung für die theoretischen
MehrSpezifikation der zulässigen Parameter. Bemerkungen: Bemerkungen: (2) Design by Contract:
Spezifikation der zulässigen Parameter Bemerkungen: Bei jeder (partiellen) Funktion muss man sich überlegen und dokumentieren, welche aktuellen Parameter bei einer Anwendung zulässig sein sollen. Der Anwender
MehrProgrammierung in Python
Programmierung in Python imperativ, objekt-orientiert dynamische Typisierung rapid prototyping Script-Sprache Funktionales und rekursives Programmieren P raktische Informatik 1, W S 2004/05, F olien P
MehrÜbungen zu C++ Kapitel 1
Übungen zu C++ Kapitel 1 Aufgabe 1 Ergänze den Text. a) Die sechs logischen Einheiten eines Computers sind Eingabe-Einheit, Ausgabe-Einheit, RAM, ALU, CPU, Plattenspeicher. b) Die Programme, welche Hochsprachenprogramme
Mehr5.1 Drei wichtige Beweistechniken... 55 5.2 Erklärungen zu den Beweistechniken... 56
5 Beweistechniken Übersicht 5.1 Drei wichtige Beweistechniken................................. 55 5. Erklärungen zu den Beweistechniken............................ 56 Dieses Kapitel ist den drei wichtigsten
MehrKapitel 11: Wiederholung und Zusammenfassung
Wiederholung und Zusammenfassung 1: Begriff und Grundprobleme der Informatik Begriff Informatik Computer als universelle Rechenmaschine Grenzen der Berechenbarkeit Digitalisierung Problem der Komplexität
MehrSWP Prüfungsvorbereitung
20. Juni 2011 1 Grammatiken 2 LL(1) 3 EXP 4 Datentypen 5 LP Grammatiken Angabe Erstellen Sie First- und Follow-Mengen aller Non-Terminale der folgenden Grammatik. S a S S B y B A C A A b b A x A ɛ C c
MehrTheoretische Grundlagen des Software Engineering
Theoretische Grundlagen des Software Engineering 7: Einführung Aussagenlogik schulz@eprover.org Logisches Schließen 2 gold +1000, 1 per step, Beispiel: Jage den Wumpus Performance measure death 1000 10
MehrDatenstruktur zum Speichern einer endlichen Menge M von Zahlen. Genauer:
Binäre Suchbäume (binary search trees, kurz: bst) Datenstruktur zum Speichern einer endlichen Menge M von Zahlen. Genauer: Binärbaum T mit n := M Knoten Jeder Knoten v von T ist mit einer Zahl m v M markiert.
MehrEinführung Datentypen Verzweigung Schleifen Funktionen Dynamische Datenstrukturen. Java Crashkurs. Kim-Manuel Klein (kmk@informatik.uni-kiel.
Java Crashkurs Kim-Manuel Klein (kmk@informatik.uni-kiel.de) May 7, 2015 Quellen und Editoren Internet Tutorial: z.b. http://www.java-tutorial.org Editoren Normaler Texteditor (Gedit, Scite oder ähnliche)
MehrFehler die bei der Programmerstellung passieren können teilweise vom Compiler erkannt werden
Exceptions Fehler die bei der Programmerstellung passieren können teilweise vom Compiler erkannt werden int a; double b=10; a = 10 * b; System.out.println(a); Fehler die während der Programmausführung
MehrEndlicher Automat (EA)
Endlicher Automat (EA) siehe auch Formale Grundlagen 3 1 Motivation: Automaten für die Modellierung, Spezifikation und Verifikation verwenden! Definition Ein Endlicher Automat A = (S,I,Σ,T,F) besteht aus
MehrSteueranweisungen. Eike Schallehn Grundlagen der Informatik für Ingenieure Wintersemester 08/09 2 32
Steueranweisungen Bisher Programme mit Funktionen als einfache Folge von Befehlen Ablauf von Programmen darüber hinaus steuerbar über Bedingte Ausführung: Ausführung von Programmteilen (Befehlen oder Programmblöcken)
MehrTheorie der Informatik
Theorie der Informatik 6. Formale Sprachen und Grammatiken Malte Helmert Gabriele Röger Universität Basel 17. März 2014 Einführung Beispiel: Aussagenlogische Formeln Aus dem Logikteil: Definition (Syntax
MehrDer Aufruf von DM_in_Euro 1.40 sollte die Ausgabe 1.40 DM = 0.51129 Euro ergeben.
Aufgabe 1.30 : Schreibe ein Programm DM_in_Euro.java zur Umrechnung eines DM-Betrags in Euro unter Verwendung einer Konstanten für den Umrechnungsfaktor. Das Programm soll den DM-Betrag als Parameter verarbeiten.
MehrProlog basiert auf Prädikatenlogik
Software-Technologie Software-Systeme sind sehr komplex. Im Idealfall erfolgt die Programmierung problemorientiert, während die notwendige Übertragung in ausführbare Programme automatisch erfolgt. Prolog-Philosophie:
MehrII. Grundlagen der Programmierung. 9. Datenstrukturen. Daten zusammenfassen. In Java (Forts.): In Java:
Technische Informatik für Ingenieure (TIfI) WS 2005/2006, Vorlesung 9 II. Grundlagen der Programmierung Ekkart Kindler Funktionen und Prozeduren Datenstrukturen 9. Datenstrukturen Daten zusammenfassen
MehrWiederholung ADT Menge Ziel: Verwaltung (Finden, Einfügen, Entfernen) einer Menge von Elementen
Was bisher geschah abstrakter Datentyp : Signatur Σ und Axiome Φ z.b. ADT Menge zur Verwaltung (Finden, Einfügen, Entfernen) mehrerer Elemente desselben Typs Spezifikation einer Schnittstelle Konkreter
MehrSome Software Engineering Principles
David L. Parnas: Some Software Engineering Principles Marco Oppel 30.06.2004 Seminar Software-Architektur Institut für Informatik Humboldt Universität zu Berlin 1 Problemstellung Software Engineering Multi-Personen
MehrKapitel 2: Formale Sprachen Kontextfreie Sprachen. reguläre Grammatiken/Sprachen. kontextfreie Grammatiken/Sprachen
reguläre Grammatiken/prachen Beschreibung für Bezeichner in Programmiersprachen Beschreibung für wild cards in kriptsprachen (/* reguläre Ausdrücke */)?; [a-z]; * kontextfreie Grammatiken/prachen Beschreibung
Mehr2.4.3 Polymorphie (Wiederholung von Alp2)
2.4.3 Polymorphie (Wiederholung von Alp2) Sparbuch einsparbuch = new Sparbuch(3.0); Konto einkonto; KontoDrucker = new KontoDrucker(); KontoDrucker.setzeKonto(einSparbuch); einkonto = einsparbuch; Wie
MehrÜbungsaufgaben zur Vorlesung Modellbasierte Softwareentwicklung Wintersemester 2014/2015 Übungsblatt 8
Prof. Dr. Wilhelm Schäfer Paderborn, 8. Dezember 2014 Christian Brenner Tristan Wittgen Besprechung der Aufgaben: 15. - 18. Dezember 2014 Übungsaufgaben zur Vorlesung Modellbasierte Softwareentwicklung
MehrEinführung in die Informatik für Hörer aller Fakultäten II. Andreas Podelski Stephan Diehl Uwe Waldmann
Einführung in die Informatik für Hörer aller Fakultäten II Andreas Podelski Stephan Diehl Uwe Waldmann 1 Einführung in die Informatik für Hörer aller Fakultäten II Andreas Podelski Stephan Diehl Uwe Waldmann
MehrFB Informatik. Fehler. Testplan
Fehler #include int i,n,summe; int summe (int); cout 0) cin>n; i=summme(n); cout
MehrSortierte Folgen 250
Sortierte Folgen 250 Sortierte Folgen: he 1,...,e n i mit e 1 apple applee n kennzeichnende Funktion: M.locate(k):= addressof min{e 2 M : e k} Navigations Datenstruktur 2 3 5 7 11 13 17 19 00 Annahme:
MehrGrammatiken. Einführung
Einführung Beispiel: Die arithmetischen Ausdrücke über der Variablen a und den Operationen + und können wie folgt definiert werden: a, a + a und a a sind arithmetische Ausdrücke Wenn A und B arithmetische
MehrBinäre Suchbäume (binary search trees, kurz: bst)
Binäre Suchbäume (binary search trees, kurz: bst) Datenstruktur zum Speichern einer endlichen Menge M von Zahlen. Genauer: Binärbaum T mit n := M Knoten Jeder Knoten v von T ist mit einer Zahl m v M markiert.
MehrP r o g r a m m a b l a u f s t e u e r u n g
Jede Programmiersprache braucht Konstrukte zur Steuerung des Programmablaufs. Grundsätzlich unterscheiden wir Verzweigungen und Schleifen. Schleifen dienen dazu, bestimmte Anweisungen wiederholt auszuführen,
MehrHello World. Javakurs 2014, 1. Vorlesung. Sebastian Schuck. basierend auf der Vorlage von Arne Kappen. wiki.freitagsrunde.org. 3.
Hello World Javakurs 2014, 1. Vorlesung Sebastian Schuck basierend auf der Vorlage von Arne Kappen wiki.freitagsrunde.org 3. März 2014 This work is licensed under the Creative Commons Attribution-ShareAlike
Mehr3.2 Binäre Suche. Usr/local/www/ifi/fk/menschen/schmid/folien/infovk.ppt 1
3.2 Binäre Suche Beispiel 6.5.1: Intervallschachtelung (oder binäre Suche) (Hier ist n die Anzahl der Elemente im Feld!) Ein Feld A: array (1..n) of Integer sei gegeben. Das Feld sei sortiert, d.h.: A(i)
Mehr22. Algorithmus der Woche Partnerschaftsvermittlung Drum prüfe, wer sich ewig bindet
22. Algorithmus der Woche Partnerschaftsvermittlung Drum prüfe, wer sich ewig bindet Autor Volker Claus, Universität Stuttgart Volker Diekert, Universität Stuttgart Holger Petersen, Universität Stuttgart
MehrSpec# Einführung. Formale Software-Entwicklung Seminar SS 07 Universität Karlsruhe Hilal Akbaba
Spec# Einführung Formale Software-Entwicklung Seminar SS 07 Universität Karlsruhe Hilal Akbaba Inhalt Einführung in C# Das Spec# System Die Konstrukte Vererben der Verträge System Architektur Einführung
MehrModul 122 VBA Scribt.docx
Modul 122 VBA-Scribt 1/5 1 Entwicklungsumgebung - ALT + F11 VBA-Entwicklungsumgebung öffnen 2 Prozeduren (Sub-Prozeduren) Eine Prozedur besteht aus folgenden Bestandteilen: [Private Public] Sub subname([byval
MehrKlausur zur Einführung in die objektorientierte Programmierung mit Java
Klausur zur Einführung in die objektorientierte Programmierung mit Java im Studiengang Informationswissenschaft Prof. Dr. Christian Wolff Professur für Medieninformatik Institut für Medien-, Informations-
MehrThe B Method. B ist eine Methode zur Spezifikation zum Entwurf zur Implementierung von Software Systemen. Bücher zur B-Methode
The B Method B ist eine Methode zur Spezifikation zum Entwurf zur Implementierung von Software Systemen. Bücher zur B-Methode P. Schmitt: Formal Specification and Verification of Software p.1 The B Method
MehrEinführung in die Informatik Grammars & Parsers
Einführung in die Informatik Grammars & Parsers Grammatiken, Parsen von Texten Wolfram Burgard Cyrill Stachniss 12.1 Einleitung Wir haben in den vorangehenden Kapiteln meistens vollständige Java- Programme
MehrC++ - Operatoren. Eigene Klassen mit neuen Funktionen
C++ - Operatoren Eigene Klassen mit neuen Funktionen Übersicht Klassen bisher Eigene Operatoren definieren 2 Bisher Durch Kapselung, Vererbung und Polymorphy können nun eigene Klassen definiert werden,
Mehr