LISP-Intensivkurs. Vierter Tag Vormittag. Übersicht: Objektorientierte Programmierung mit CLOS:

Transkript

1 LISP-Intensivkurs Vierter Tag Vormittag Übersicht: Objektorientierte Programmierung mit CLOS: Einführung und Begriffsbestimmung Klassen Instanzen Methoden Methodenkombinationen 1

2 Grundzüge Objektorientierter Programmierung Versuch einer Definition von P. Wegner 1987: Objektorientierung = Objekte + Klassen + Vererbung Objekte haben einen Zustand, dargestellt durch Variablen, und ein Verhalten, dargestellt durch Methoden. Hierbei ist die Idee des information hidings wichtig, bei dem die Manipulation des Zustands nur über ausgewählte Methoden des Objektes selbst realisiert wird. Objekte werden aufgrund von Ähnlichkeiten bzgl. Struktur und Verhalten gruppiert zu Klassen. Ein Objekt einer Klasse heißt dann Instanz dieser Klasse. Definition einer Klasse umfaßt: Variablen (Instanz/Klasse, Anfangswerte,... ) Methoden Vererbungsrelation 2

3 Mittels Vererbung können Varianten existierender Klassen definiert werden. Dies führt zu einer Klassenhierarchie. Die neue Klasse erbt Verhalten (z.b. Methoden) der Elternklasse(n); somit muß nur der Unterschied zu dieser Elternklasse(n) programmiert werden. Bei Vererbung von mehreren Elternklassen spricht man auch von multipler Vererbung. Auswahl objektorientierter Sprachen Simula, Smalltalk, C++, Oberon,... CommonLOOPS, Flavors, CLOS,... 3

4 Einfluß objekt-orientierter Vorgehensweise auf die Code- Qualität bezüglich: Korrektheit Klar definierte Module mit Interface; dies erleichtert es, diese Module als korrekt nachzuweisen, sowie Interaktionen zwischen Modulen zu analysieren. Vorsicht: CLOS unterstützt diese Form des Information-hiding nicht! Robustheit Generische Funktionen ermöglichen es zum Beispiel, daß eine Funktion zur Laufzeit Argumente von einem Typ akzeptiert, der beim Schreiben der Funktion selbst noch gar nicht definiert wurde. Beispiel: Default-Methoden Erweiterbarkeit Objekt-orientierte Systeme mit Vererbungsmechanismen erlauben es, neue, leicht abgewandelte Klassen zu definieren und ohne weiteren Aufwand in das existierende System mit einzubinden. Wiederverwendbarkeit Im objekt-orientierten Paradigma benutzt man entweder existierende Klassen einer Bücherei, oder aber man spezialisiert existierende Klassen durch Vererbung. Kompatibilität Eine objekt-orientierte Vorgehensweise unterstützt den Aufbau von Büchereien. Je mehr Programme Standardkomponenten benutzen desto mehr Kommunikation wird zwischen diesen Programmen möglich sein. 4

5 Programmieren in CLOS Definition von Klassen, die Daten nach Komponenten und Charakteristika organisieren Bilden von Objekten (oder: Instanzen) dieser Klassen; Struktur und Verhalten von Instanzen wird bestimmt durch ihre Klassen; Definition von Methoden, um klassenspezifische Operationen auszuführen Erweitere Charakteristika von Klassen durch Vererbung 5

6 Einführendes Beispiel Klassen-Definition (defclass rectangle () ((height :initarg :start-height :initform 5 :accessor rectangle-height) (width :initarg :start-width :initform 8 :accessor rectangle-width))) Generierung von Objekten (setf r1 (make-instance rectangle :start-height 50 :start-width 100)) Zugriff auf Slots (rectangle-height r1) (setf (rectangle-height r1) 75) 6

7 Strukturvererbung (defclass color-rectangle (rectangle) ((color :initform red :initarg :color :accessor color) (clearp :initform (y-or-n-p "Transparent?") :initarg :clearp :accessor clearp) (height :initform 10))) Instanzen von color-rectangle haben vier Slots: Neu color, clearp Vererbt height, width Problem: Was passiert bei sich widersprechender neuer und vererbter Information? Ansatz: Grundsätzlich überschreibt spezifischere Information die generellere oder vererbte. 7

8 Beispiel für multiple Vererbung (engl. multiple inheritance) (defclass color-mixin () ((color :initform red :initarg :color :accessor color))) (defclass color-rectangle-2 (color-mixin rectangle) ((clearp :initform nil :initarg :clearp :accessor clearp) (height :initform 10))) Mixin-Klassen zur Beschreibung unabhängiger Fragmente von Strukturen oder Verhalten; Instanziierbare Klassen werden dann meistens mit Hilfe mehrerer Mixins und einer Hauptklasse (sog. principal class) gebildet. Bemerkung: multiple Vererbung ist in vielen objekt-orientierten Programmiersprachen nicht möglich. 8

9 Beispiel: Generische Funktionen und Methoden (defgeneric paint (shape medium) (:documentation "Malt etwas auf etwas anderes")) Eine generische Funktion spezifiziert die gemeinsame Schnittstelle von Methoden, insbesondere den generischen Funktionsnamen und die Argumentliste; bei Aufruf einer generischen Funktion legt ein Laufzeit-Dispatcher eine Kombination von Methoden fest, die ausgeführt werden. (defmethod paint ((shape rectangle) ;; Methode-1 medium) (format t "~& Somehow paint rectangle ~a on medium ~a" shape medium)) (defmethod paint ((shape color-rectangle) ;; Methode-2 medium) (format t "~& Somehow paint color rectangle ~a on medium ~a" shape medium)) Aufruf der generischen Funktion paint: (paint r1 *standard-display*) resultiert in den Aufruf von Methode-1, da r1 vom Typ rectangle ist (s.o.). Welche Methode aufgerufen wird, hängt also vom Typ des Argumentes ab. 9

10 Methoden-Kombination Aufruf einer generischen Funktion (oder: Senden einer Message) resultiert möglicherweise in eine Sequenz von Methodenaufrufen. (defmethod paint :before ((shape color-rectangle) medium) (format t "Prepare brush for painting color rectangle ~a" shape)) (defmethod paint :after ((shape color-rectangle) medium) (format T "Clean brush")) Sei nun etwa: (setf cm (make-instance color-rectangle)) Beim Aufruf von paint mit einem Argument der Klasse color-rectangle (oder evtentuell einer Spezialisierung davon) wird zuerst die :before Methode, danach die Primärmethode und zuletzt die :after Methode der generischen Funktion paint aufgerufen. > (trace paint) > (paint cm) ENTER... EXIT... Das Resultat des Funktionsaufrufs der generischen Funktion berechnet sich aus dem Resultat der Primärmethode. 10

11 Klassen-Deklaration Syntax des defclass Makros: (defclass class-name (supercl-1... supercl-n) ((slot-name-1 slot-options-1)... (slot-name-m slot-options-m)) (:documentation "...")) Bemerkung: jede Klasse definiert einen CL Datentyp Beispiel: (defclass automobile () ((doors :initarg :doors :accessor doors) (color :initarg :color :accessor color))) (defclass sedan (automobile) ((engine-type :initarg :engine-type))) Slot-Spezifikationen: :reader :writer :accessor :allocation :instance lokaler Slot für jedes Objekt der Klasse allokiert (default) :allocation :class genau ein Slot für alle Objekte der Klasse gemeinsam :initform :initarg :type spezifiziert einen Datentyp für einen Slot 11

12 Class Precedence List (CPL) Kontrolle der Vererbung von Slots, Slot Optionen und Präzedenz von Methoden vollständige Ordnung einer Klasse und ihrer Superklassen; Ordnung von spezifisch zu weniger spezifisch; Algorithmus zur Berechnung der CPL beachtet die Regeln Regel 1 Klassen kleiner als ihre Superklassen Regel 2 eine direkte Superklasse ist kleiner als alle anderen Superklassen zur rechten in der Superklassen-Deklaration in defclass; Diese beiden Regeln reichen noch nicht aus, um eine eindeutige Ordnung zu charakterisieren; Klassen-Hierarchie: gerichteter azyklischer Graph (DAG) 12

13 Beispiel für CPL (defclass C1 () ()) (defclass C2 (C1) ()) (defclass C3 (C1) ()) (defclass C4 (C3) ()) (defclass C5 (C3) ()) (defclass C6 (C4 C5) ()) Somit: CPL(C6) = <C6, C4, C5, C3, C1, standard-object, t> Dies läßt sich auch mit dem Inspektor feststellen: (inspect (find-class C6)) Beispiel: (defclass A (B) ()) (defclass B (C) ()) (defclass C (A) ()) Zyklus (sollte Fehler erzeugen) 13

14 Vererbung von Slots und Slot-Optionen wird über die CPL gesteuert. Vererbung von Slots: Klassen erben Slots von ihren Superklassen. Falls ein Slot mehrmals in den Superklassen deklariert wurde, so müssen die verschiedenen Slot-Optionen kombiniert werden. Kombination von defclass Slot-Optionen: Entweder die spezifischere (bzgl. CPL) Information überschreibt die allgemeinere, oder aber die Information wird vereinigt. :reader Vereinigung :writer Vereinigung :accessor Vereinigung :initform Überschreibung :allocation Überschreibung :initarg Vereinigung :type Durchschnitt: (and type-1... type-n) Bemerkung: Kombination von :reader, :writer und :accessor folgt aus der normalen Methodenkombination. 14

15 Beispiel: (defclass C1 () ((S1 :initform 2.3 :type number) (S2 :allocation :class) (S4 :accessor C1-S4))) (defclass C2 (C1) ((S1 :initform 5 :type integer) (S2 :allocation :instance) (S3 :accessor C2-S3))) (describe (find-class C1)) ==>... (describe (find-class C2)) ==>... Bemerkung: Bei multipler Vererbung wird nach Definition der CPL immer von der am weitesten links stehenden Klasse überschrieben; z.b ist in (defclass A (B C)...) die Klasse B spezifischer als C. 15

16 Beispiel für multiple Vererbung (defclass motor-vehicle () ((engine-type :initarg :engine-type :accessor engine-type) (wheels :allocation :class :initform 4 :accessor wheels))) (defclass house () ((rooms :initarg :rooms :accessor rooms) (stove :initform electric :initarg :stove))) (defclass motor-home (motor-vehicle house) ()) (setf bago (make-instance motor-home :engine-type V8 :rooms 3 :stove propane)) (describe bago) #<Motor-Home #X1AB24D6> is an instance of the class MOTOR-HOME: The following slots have allocation :INSTANCE: ROOMS 3 STOVE PROPANE ENGINE-TYPE V8 The following slots have allocation :CLASS: WHEELS 4 16

17 Integration von CLOS in CL einige vordefinierte CL Typen haben eine korrespondierende Klasse mit demselben Namen wie der Typ Namen von Klassen sind CL Typ-Spezifikatoren Einige CL-Funktionen funktionieren auch auf CLOS-Objekten (typep object class) ==> t falls Klasse von object Subklasse von class oder Klasse von object ist class selbst; (subtypep class1 class2) ==> t falls Klasse class2 hat class1 als Subklasse oder class1 und class2 identisch sind; (type-of object) liefert (implementierungsabhängig?) den Typ von object. 17

18 CL Datentypen in CLOS Class Class Precedence List bignum (bignum integer rational number t) clos:array (clos:array t) bit-vector (bit-vector vector clos:array sequence t) character (character t) complex (complex number t) cons (cons list sequence t) double-float (double-float float number t) fixnum (fixnum integer rational number t) float (float number t) hashtable (hashtable t) integer (integer rational number t) list (list sequence t) null (null symbol list sequence t) number (number t) package (package t) readtable (readtable t) random-state (random-state t) ratio (ratio rational number t) rational (rational number t) sequence (sequence t) single-float (single-float float number t) string (string vector clos:array sequence t) symbol (symbol t) t (t) vector (vector clos:array sequence t) 18

19 Instanzen von Klassen (make-instance class-name :arg-1 value-1... :arg-n value-n) Beispiel: (setf her-sedan (make-instance sedan :doors 4 :color red :engine-type V6)) Konstruktoren: Es ist oft guter Stil, daß man eigene Konstruktoren definiert. (defun make-sedan (doors color engine-type) (make-instance sedan :doors doors :color color :engine-type engine-type)) 19

20 Zugang zu Slots und Slot-Werten vordefinierte Zugriffsmethoden durch defclass (doors her-sedan) ==> 4 (setf (doors her-sedan) 3) ==> 3 (doors her-sedan) ==> 3 alternativ: (slot-value her-sedan doors) ==> 4 (setf (slot-value her-sedan doors) 3) ==> 3 (slot-value her-sedan doors) ==> 3 Weitere Methoden zur Manipulation von Slots (slot-boundp instance slot-name), falls slot-name nicht existiert, wird slot-unbound aufgerufen; (slot-exists-p object slot-name) (slot-makunbound instance slot-name), falls slot-name nicht existiert, wird slot-missing aufgerufen; 20

21 Kontrolle über Instanzen Anzeige von Objekten (print-object object stream) Man schreibt sich seine eigenen print-object Methoden, um die Ausgabe von Objekten zu steuern; zum Beispiel: (defmethod print-object ((car sedan) stream) (format stream "#<~S ~A ~D>" (type-of car) (if (slot-boundp car doors) (doors car) "unknown") (color car))) Kontrolle über die Instanziierung von Objekten mit Hilfe von :after Methoden zu (initialize-instance instance &rest initargs) Denn initialize-instance wird aufgerufen von make-instance. 21

22 Generische Funktionen Generische Funktionen in CLOS korrespondieren zu Nachrichten (engl. messages) in anderen objektorientierten Sprachen. generische Funktionen sind Lisp-Funktionen ALSO: funcall,apply auf generische Funktionen möglich Unterschiede zu gewöhnlichen CL-Funktionen: Operation ist klassen-spezifisch benützt bei der Ausführung eine Menge von Methoden Definition generischer Funktionen: (defgeneric function-specifier (par-1... par-n) (:method method-1)... (:method method-m) (:documentation "...")) 22

23 Beispiel: (defgeneric foo (x) (:method ((x string)) (princ "it s a string")) (:method :before ((x string)) (princ "Hey Dude, ")) (:method ((x sequence)) (princ "it s a sequence")) (:method ((x integer)) (princ "it s an integer")) (:documentation "nonsense function")) (foo 4) ==> "it s an integer" Seiteneffekt: it s an integer (foo "hallo") ==> "it s a string" Seiteneffekt: Hey Dude, it s a string (foo (a b c)) ==> "it s a sequence" Seiteneffekt: it s a sequence (documentation # foo) ==> "nonsense function" Aufruf einer generischen Funktion: anwendbare Methoden werden ausgewählt Sequenz der Methoden-Ausführung wird festgelegt Methoden werden ausgeführt Rückgabewert der generischen Funktion wird aus den Rückgabewerten der Methoden berechnet Bemerkung: Oftmals werden die Methoden zu einer generischen Funktion nicht direkt mit in der Definition der generischen Funktion mitdefiniert. Für separate Definition von Methoden gibt es das defmethod Makro. 23

24 Methoden Methoden führen die klassen-spezifischen Operationen einer generischen Funktion aus. Ein Methoden-Objekt ist keine Lisp-Funktion! (defmethod function-specifier {method-qualifier}* (( var-1 class-1)... var-n... ( var-m (eql value)))... lisp code...) Bemerkung: Bei Methoden unterscheidet man zwischen Primärmethoden (engl. primary methods) und Hilfsmethoden (engl. auxiliary methods) - :after - :before Diese Unterscheidung kommt bei der Kombination von Methoden, wie sie von generischen Funktionen vorgenommen wird, zum Tragen. Bemerkung: defmethod deklariert implizit eine generische Funktion, falls eine solche noch nicht deklariert wurde: (defmethod add-one ((x number)) (+ x 1)) 24

25 Bemerkung: Lambda-Listen einer generischen Funktion und aller ihrer Methoden müssen kompatibel sein. Dabei heißen, im vereinfachten Falle, zwei Lambda-Listen kompatibel, falls sie die gleiche Anzahl von Parametern haben (wir ignorieren hier &rest, &optional und &key Parameter) Anwendbarkeit von Methoden: Eine Methode ist anwendbar, falls jeder der benötigten Parameter erfüllt wird durch das korrespondierende Argument (arg) der generischen Funktion. formaler Parameter Test (var-name class-name) (typep arg class-name) var (typep arg t) (var-name (eql form)) (eql arg form) Sortieren von Methoden: von spezifisch nach weniger spezifisch bzgl. CPL. Ausführung von Methoden: Es wird (im vereinfachten Falle) die spezifischste Methode ausgeführt. 25

26 Beispiel: (defclass C1 () ()) (defclass C2 (C1) ()) (defclass C3 (C2) ()) (setf c3 (make-instance C3)) (defmethod f ((x C1)) "Methode C1") (f c3) ==> "Methode C1" (defmethod f ((x C2)) "Methode C2") (f c3) ==> "Methode C2" (defmethod f ((x C3)) "Methode C3") (f c3) ==> "Methode C3" 26

27 Methoden-Kombination Standard-Methoden-Kombination: :before Methoden, Primärmethoden und :after Methoden werden in der folgenden Reihenfolge aufgerufen: :before Methoden werden von spezifisch (bzgl. CPL zu weniger spezifisch aufgerufen; die bezüglich CPL spezifischste Primärmethode wird ausgeführt; :after Methoden werden von weniger spezifisch nach spezifischer aufgerufen; Wert eines Aufrufs einer generischen Funktion ist (in unserem vereinfachten Falle) der Wert der aufgerufenen Primärmethode. Beispiel: (defclass C1 () ()) (defclass C2 (C1) ()) (defclass C3 (C2) ()) (setf c3 (make-instance C3)) 27

28 (defmethod f ((x C1)) (princ "Primaer C1 ")) (f c3) ==> "Primaer C1" Seiteneffekt: Primaer C1 (defmethod f ((x C2)) (princ "Primaer C2 ")) (f c3) ==> "Primaer C2" Seiteneffekt: Primaer C2 (defmethod f ((x C3)) (princ "Primaer C3 ")) (f c3) ==> "Primaer C3" Seiteneffekt: Primaer C3 (defmethod f :before ((x C1)) (princ "Before C1 ")) (defmethod f :after ((x C1)) (princ "After C1 ")) (f c3) ==> "Primaer C3" Seiteneffekt: Before C1 Primaer C3 After C1 (defmethod f :before ((x C2)) (princ "Before C2 ")) (defmethod f :before ((x C3)) (princ "Before C3 ")) (defmethod f :after ((x C2)) (princ "After C2 ")) (defmethod f :after ((x C3)) (princ "After C3 ")) (f c3) ==> "Primaer C3" Seiteneffekt: Before C3 Before C2 Before C1 Primaer C3 After C1 After C2 After C3 Damit ergibt sich also folgendes Bild: 28

29 b3->b2->b1 a1->a2->a3 ^ v ---> p ---> Außerdem gibt es bei der Methodenkombination: :around Methoden Aufruf weiterer Primärmethoden mit call-next-method neben der Standardmethodenkombination (s.o.) weitere Methodenkombinationen, die durch den Methodenkombinationstyp einer generischen Funktion angewandt werden können; Es lassen sich auch eigene Methodenkombinationstypen vom Programmierer definieren (nicht in Lucid aber in Genera 8.0) 29

30 Zugriffs-orientierte Programmierung es werden Methoden an Slots angehängt, die bei Schreiboder Lesezugriffen aktiviert werden Neuberechnung eines Slots kann verzögert werden, bis das Ergebnis gebraucht wird eine neue Belegung von Slots kann Methoden aktivieren Beispiel: jedesmal wenn sich die Höhe oder Länge eines Vierecks ändert, soll die Fläche berechnet werden. Die Frage ist dann nur, ob die Fläche sofort beim Schreiben eines neuen Wertes berechnet wird, oder aber erst verzögert bei einem Zugriff auf die Fläche des Vierecks. Ersteres erreicht man durch Spezialisierung von Schreibmethoden, und das zweite durch Spezialisierung von Lesemethoden. (defclass rectangle () ((height :initarg :start-height :accessor rectangle-height) (width :initarg :start-width :accessor rectangle-width) (area :accessor rectangle-area))) (setf r1 (make-instance rectangle :start-height 4 :start-width 6)) Spezialisierung von Lesemethoden: (defmethod rectangle-area :before ((shape rectangle)) (setf (rectangle-area shape) (* (rectangle-height shape) (rectangle-width shape)))) 30

31 (rectangle-area r1) ==> 24 (setf (rectangle-width r1) 7) (slot-value r1 area) ==> 24 (rectangle-area r1) ==> 28 Spezialisierung von Schreibmethoden: (defmethod (setf rectangle-height) :after (y (shape rectangle)) (setf (rectangle-area shape) (* (rectangle-height shape) (rectangle-width shape)))) (defmethod (setf rectangle-width) :after (y (shape rectangle)) (setf (rectangle-area shape) (* (rectangle-height shape) (rectangle-width shape)))) (setf (rectangle-height r1) 3) (slot-value r1 area) ==> 21 (setf (rectangle-width r1) 9) (slot-value r1 area) ==> 27 31

32 Individuelle Methoden mind. ein Parameter-Spezialisierer ist von der Form (var-name (eql object)) Beispiel: Abfangen von Division durch 0 mittels einer individuellen Methode. (defmethod divide ((dividend number) (divisor number)) (/ dividend divisor)) (defmethod divide ((dividend number) (zero (eql 0))) :infinity) (divide 5 3) ==> 5/3 (divide 3 0) ==> :infinity 32

33 Multimethoden Multimethoden sind dadurch gekennzeichnet, daß sie mehr als einen Parameter-Spezialisierer besitzen. Beispiel: Definition von conc, das eine Art append auf Listen und Vektoren realisiert. (defmethod conc ((x null) y) y) (defmethod conc (x (y null)) x) (defmethod conc ((x list) (y list)) (cons (first x) (conc (rest x) y))) (defmethod conc (( x vector) (y vector)) (let ((vect (make-array (+ (length x) (length y))))) (replace vect x) (replace vect y :start1 (length x)))) Beachte, daß im Falle eines nil Argumentes, zwei Methoden anwendbar sind; es wird aber die Methode für null aufgerufen, da diese Klasse spezifischer ist als list. (conc nil (a b c)) ==> (A B C) (conc (a b c) nil) ==> (A B C) (conc (a b c) (d e f) ==> (A B C D E F) (conc #(a b c) #(d e f)) ==> #(A B C D E F) Multimethoden sind anwendbar, falls jeder Parameter- Spezialisierer vom zugehörigen Parameter der generischen Funktion erfüllt wird. 33

34 Multimethoden werden geordnet, indem Parameter von links nach rechts betrachtet werden: lexikographische Ordnung. Bemerkung: Es ist in vielen Fällen unintuitiv, daß die Reihenfolge der Parameter die Ordnung auf Methoden bestimmt. 34

35 Abstrakte Datentypen in CLOS Bemerkung Der Stil von Methoden-Definitionen ist ähnlich dem von Funktions -Definitionen in funktionalen Sprachen: irgendeine funktionale Programmiersprache (Haskell, ML, Miranda) datatype a list = nil cons of a * ( a list); len nil = 0; len cons(a,l) = 1 + len l; In CLOS sind Datentypen list zusammen mit Untertypen null und cons vordefiniert. Mit dieser Typhierarchie lassen sich jetzt Funktionen über den Aufbau von Listen in einer ähnlichen Weise wie bei funktionalen Programmiersprachen schreiben (es gibt aber bisher noch kein Pattern-Matching). (defmethod len ((x null)) 0) (defmethod len ((ll cons)) (let ((a (first ll)) (l (rest ll))) (1+ (len l)))) 35

36 Verschiedenes Kontrolle über Fehlersituationen (no-applicable-method generic-function &rest function-args) (no-next-method generic-function calling-method &rest args) (slot-missing class instance slot-name operation &optional new-valu (slot-unbound class instance slot-name) Dynamische Modifikation generischer Funktionen, Methoden, Klassen, Instanzen Meta-Objekt Protokoll; noch nicht vollständig standardisiert noch keine vollständigen und effizienten Implementierungen z.b. Auflisten aller Slot-Namen einer Klasse: (defun class-slot-name (class-name) (mapcar # clos:slot-definition-name (clos:class-slots (find-class class-name)))) 36

37 Techniken: Methoden vs. Kontrollstrukturen (I) Rückblende: Anstelle eines cond-konstrukts ist die Fallunterscheidung durch case oft bequemer: > (case (second (1 2 3)) (1 "eins") (3 "drei") ((2 4) "gerade Zahl") (T "zu gross")) "gerade Zahl" In analoger Art kann mit typecase eine Fallunterscheidung über Typen durchgeführt werden: > (let* ((val (1 2)) (typename (typecase val (number "Zahl") (list "Liste") (string "Zeichenkette") (T "sonstwas")))) (format T "Ausgabe von ~A ~A" typename val)) Ausgabe von Liste (1 2) NIL Aufgabe: Erklären Sie, warum (typecase val...) nicht leicht durch (case (type-of val)...) simuliert werden kann. Schreiben Sie dazu obiges Beispiel entsprechend um und vergleichen Sie! 37

38 Techniken: Methoden vs. Kontrollstrukturen (II) Wenn eine Fallunterscheidung nach Typen vorgenommen werden soll, kann (!) ein typecase-konstrukt günstiger sein als eine Menge von Methoden: (defclass c0 () ((c0-slot :accessor c0-slot))) (defclass c1 (c0) ((c1-slot :accessor c1-slot))) (defclass c2 (c0) ((c2-slot :accessor c2-slot))) (defun complicated-output (obj) (format T "Hier kommt eine lange Ausgabe,~%") (format T "die sich nur durch ein Detail: ~A" (typecase obj (c1 (c1-slot obj)) (c2 (c2-slot obj)) (c0 (c0-slot obj)))) (format T " unterscheidet")) > (complicated-output (let ((inst (make-instance c0))) (setf (c0-slot inst) 2) inst)) Hier kommt eine lange Ausgabe, die sich nur durch ein Detail: 2 unterscheidet Dies kann übersichtlicher und schneller sein als: (defmethod complicated-output ((obj c0)) (format T "Hier kommt eine lange Ausgabe,~%") (format T "die sich nur durch ein Detail: ~A" (c0-slot obj)) (format T " unterscheidet")) (defmethod complicated-output ((obj c1))...) (defmethod complicated-output ((obj c2))...) 38

39 Zusammenfassung Objektorientierte Programmierung ist im allgemeinen charakterisiert durch: Klassen, die eine Menge von Objekten beschreiben Vererbungsbeziehungen zwischen Klassen Objekte, die u.u. mehreren Klassen zugeordnet werden können Methoden, die auf Objekten arbeiten CLOS bietet speziell die Möglichkeit von: Multipler Vererbung: Eine Klasse kann von mehreren anderen Klassen erben Multimethoden: Eine Methode kann durch mehrere Klassen spezialisiert werden Methoden können mit before- und after-methoden versehen werden Dadurch werden verschiedene Konfliktlösungsstrategien notwendig. 39

40 LISP-Intensivkurs Vierter Tag Nachmittag Übersicht: Projekt: Objekt-Orientierte Simulation 40

41 Projekt: Objekt-Orientierte Simulation Objekt-orientierte Sprachen eignen sich besonders für Simulationsaufgaben, wenn: durch Klassen bestimmte Prototypen festgelegt werden durch Instanzen eine sich verändernde Population von Individuen erzeugt werden kann durch Methoden Verhaltensmuster beschrieben werden können Eine der ersten OO-Sprachen (Simula) ist hauptsächlich für diesen Zweck entworfen worden. OO-Sprachen eignen sich wenig z.b. für die Simulation von Verbrennungsvorgängen in einem Motor, jedoch u.a. für: Warteschlangen-Theorie und Operations Research: Warteschlangen in einem Kaufhaus Jobabwicklung an einem Prozessor Transportvorgänge über ein Straßennetz Wachstumsvorgänge in Biologie und Medizin: Wachstum von Pflanzengesellschaften Entwicklung von Zellkulturen 41

42 OOS: Zollabfertigung an einer Grenze In diesem Fallbeispiel geht es darum, die Zollabfertigung an einer Grenze unter verschiedenen Nebenbedingungen zu simulieren. Dieses Beispiel gehört in die Gruppe der Simulationen von Warteschlangen-Problemen. Wesentlichste Akteure des Modells: Transportobjekte wie z.b. PKWs, LKWs, Passagier- und Frachtzüge Tore, an denen die Transportobjekte abgefertigt werden Wesentlichste Vorgänge des Modells: Vor der Grenze ankommende Transportobjekte werden in einer Eingangs-Warteschlange gespeichert Je nach Aussehen der Warteschlange können Tore neu geöffnet oder geschlossen werden Ist ein Tor nicht besetzt, kann ein Transportobjekt dort bearbeitet werden Nach Bearbeitung an einem Tor wird das entsprechende Objekt in eine Ausgangs-Warteschlange übertragen. Modellierung der Zeit: Zeit läuft in diskreten Schritten ab Zu jedem Zeitpunkt wird überprüft, welche Aktionen fällig werden 42

43 OOS: Ablauf der Simulation Die Simulation wird mit start gestartet und läuft eine bestimmte Anzahl von Zeiteinheiten lang. (defun start () (setf *in-q* NIL) (setf *out-q* NIL) (setf *gates* NIL) (let ((duration NIL)) (format T "Duration of simulation?: ") (setf duration (read)) (loop for time from 0 to duration do (read-new-entries time) (open-or-close-gates time) (dispatch-at-gate time) (fill-inactive-gates time) (print-state time)))) Die Funktionen können auf drei globale Variablen zugreifen: *in-q*: Liste der noch zu bearbeitenden Transportobjekte *out-q*: Liste der bereits bearbeiteten Transportobjekte *gates*: Liste der Tore 43

44 OOS: Übersicht über die Klassenstruktur tr-obj person vehicle way p-vehicle f-vehicle rail street gate rail-gate street-gate p-train f-train car truck 44

45 OOS: Klassenstruktur von tr-obj Durch Klasse tr-obj und Unterklassen werden die Transportobjekte beschrieben: tr-obj Transportobjekte allgemein. Slots: arrival-time: Ankunftszeit an der Grenze departure-time: Zeitpunkt der Wegfahrt von der Grenze person, vehicle Besondere Transportobjekte p-vehicle: Personenfahrzeuge, besondere vehicle. Zusätzlicher Slot: passengers: Personen im Fahrzeug, Liste von Instanzen von person f-vehicle: Frachtfahrzeuge, besondere vehicle. Zusätzlicher Slot: cargo: (Gewicht der) Ladung (nat. Zahl) Die Definitionen von tr-obj und person: (defclass tr-obj () ((arrival-time :initarg :arrival-time :accessor tr-obj-arrival-time) (departure-time :initarg :departure-time :initform NIL :accessor tr-obj-departure-time))) (defclass person (tr-obj) ()) 45

46 OOS: Klassenstruktur von way Die Klasse way beschreibt, auf welchem Weg sich ein Transportobjekt bewegt. Es gibt hierbei folgende Klassen: way Allgemeine Transportwege street Straße rail Schiene way und seine Unterklassen haben keine Slots. Aufgabe Definieren Sie die Unterklassen von tr-obj und way in Lisp mit den jeweils vorgestellten Slots. Wie lassen sich die folgenden Klassen am besten mit Hilfe der soeben besprochenen definieren?: car Personenwagen truck LKW p-train Personenzug f-train Frachtzug Sie brauchen hierfür keine weiteren Slots. 46

47 OOS: Klassenstruktur von gate Die Klasse gate beschreibt die Tore, an denen Objekte abgearbeitet werden: creation-time: Zeit, zu der das Tor erzeugt wurde inactive-time: Zeit, zu der das Tor inaktiv wurde current-obj: Das gerade bearbeitete Objekt (soweit Tor nicht inaktiv) obj-dep-time: Zeitpunkt, zu dem die Bearbeitung des aktuellen Objekts abgeschlossen ist. Aufgabe: Nicht alle Slots können hier zur gleichen Zeit belegt sein, und nicht alle Wertekombinationen sind zulässig. Formulieren Sie entsprechende Integritätsbedingungen! Die Klasse gate hat zwei Unterklassen: rail-gate: Hier können nur Züge abgefertigt werden (keine zusätzlichen Slots) street-gate: Hier können nur Straßenfahrzeuge abgefertigt werden. Zusätzlicher Slot: stress-factor der Grenzbeamten, der auf die Bearbeitungszeit Einfluß hat (siehe Fkt. processing-time) Konvention: Personen (Instanzen der Klasse person) können nur innerhalb von Fahrzeugen die Grenze passieren. Aufgabe: Definieren Sie die Klassen rail-gate und street-gate mit Hilfe der Klassen gate, rail und street. 47

48 OOS: Einlesen von neuen Objekten (I) Es soll während der Simulation möglich sein, neue Objekte in einfacher Listenform einzulesen: (defun read-new-entries (time intervals) (progn (format T "~%Enter new entries: ") (setf *in-q* (append *in-q* (conv-to-internal-format (read) time))))) Bemerkung: Man kann auch nur zu jedem n-ten Zeitschritt eine Eingabe anfordern Die Funktion conv-to-internal-format erwartet eine Liste von Objektbeschreibungen. Eine Objektbeschreibung sieht folgendermaßen aus: (p) für Personen (car ((p) (p))) für einen PKW mit zwei Passagieren (truck 12) für einen LKW mit einer Fracht von 12 Einheiten (pt ((p) (p))) für einen Personenzug mit zwei Passagieren (ft 12) für einen Frachtzug mit einer Fracht von 12 Einheiten 48

49 OOS: Einlesen von neuen Objekten (II) Aufgabe Vervollständigen Sie die Funktion conv-to-internal-format, die eine Liste von Objektbeschreibungen in eine Liste von Instanzen der entsprechenden Klassen verwandelt und diese Instanzen gleichzeitig mit einem aktuellen Zeitstempel versieht. Ansatzweise sieht die Funktion so aus: (defun conv-to-internal-format (entries time) (mapcar # (lambda (e) (case (first e) (p (make-instance person :arrival-time time))... )) entries)) 49

50 OOS: Ausgabe von Objekten Für die Ausgabe von Objekten wird die inverse Funktion conv-to-external-format benötigt, die für ein Objekt eine Listenrepräsentation erzeugt. Diese Funktion wird am besten als Methode realisiert, z.b. für die Klasse person: (defmethod conv-to-external-format ((obj person)) (p)) Aufgabe Schreiben Sie Methoden für die restlichen Klassen (für welche Klassen werden keine Methoden benötigt?). Schreiben Sie eine Funktion print-state (time), die den Zustand an der Grenze zu dem Zeitpunkt time ausgibt. Vorschlag für eine solche Ausgabe: Time: 11 ((CAR ((P) (P) (P)))) Rail: (FT 4) Street: (TRUCK 12) ((PT ((P) (P) (P))) (CAR ((P) (P)))) Time: 12 ((CAR ((P) (P) (P)))) Rail: --- Street: (TRUCK 12) ((FT 4) (PT ((P) (P) (P))) (CAR ((P) (P)))) 50

51 OOS: Abfertigung von Objekten Die Funktion dispatch-at-gate transferiert Objekte von einem Tor zur out-q, wenn ihre Zeit abgelaufen ist: (defun dispatch-at-gate (time) (mapc # (lambda (g) (let ((c-obj (gate-current-obj g))) (if (and c-obj (eql time (gate-obj-dep-time g))) (transfer-to-out-q c-obj g time) NIL))) *gates*)) Dabei sorgt die Funktion transfer-to-out-q dafür, daß Slot- Werte richtig gesetzt werden: (defun transfer-to-out-q (obj gate time) (setf (tr-obj-departure-time obj) time) (setf (gate-current-obj gate) NIL) (setf (gate-obj-dep-time gate) NIL) (setf (gate-inactive-time gate) time) (setf *out-q* (cons obj *out-q*))) 51

52 OOS: Belegung freier Tore (I) Die Funktion fill-inactive-gates belegt freie Tore mit Objekten aus der in-q, die zu dem Typ des Tors passen: (defun fill-inactive-gates (time) (mapc # (lambda (g) (if (gate-current-obj g) NIL (activate-gate g time))) *gates*)) Die Hauptaufgabe wird dabei von activate-gate geleistet, das das Tor g mit dem nächsten passenden Transport-Objekt belegt. Bei der Belegung von freien Toren kann man sich verschiedene Abarbeitungsstrategien vorstellen, z.b.: first come, first served: Objekte, die zuerst ankommen, werden auch zuerst bearbeitet Prioritäten nach Klasse : PKWs oder Personenzüge werden jedenfalls LKWs oder Frachtzügen vorgezogen Prioritäten nach minimaler Bearbeitungszeit: Es wird das Objekt mit minimaler Bearbeitungszeit bevorzugt. Frage: Welche Strategien sind fair in dem Sinn, daß jedes Objekt sicher einmal bearbeitet wird? 52

53 OOS: Belegung freier Tore (II) Aufgabe Realisieren Sie activate-gate (gate time). Bedenken Sie dabei, daß das Transportobjekt zu dem Typ des Tores passen muß (PKWs dürfen z.b. nicht an einem rail-gate abgearbeitet werden) bei Fehlen eines passenden Objekts das Tor auch unbesetzt bleiben kann Sie können verschiedene Abarbeitungsstrategien implementieren und diese z.b. durch Setzen einer globalen Variablen auswählen. Bei der übernahme eines Transportobjekts an ein Tor müssen bestimmte Slots gesetzt werden. Dies geschieht durch die Funktion transfer-to-gate. Wichtig ist hierbei vor allem die Berechnung von obj-dep-time, der Zeit, zu der das Tor wieder frei wird. (defun transfer-to-gate (obj gate time) (setf (gate-current-obj gate) obj) (setf (gate-obj-dep-time gate) (+ time (processing-time obj gate))) (setf (gate-inactive-time gate) NIL) (setf *in-q* (remove obj *in-q*))) 53

54 OOS: Berechnung der Bearbeitungszeit Die Bearbeitungszeit eines Objektes an einem Tor wird durch processing-time berechnet. Aufgabe Schreiben Sie processing-time als Multi-Methode entsprechend folgendem Beispiel: (defmethod processing-time ((obj person) (gate street-gate)) (street-gate-stress-factor gate)) Für andere Transportobjekte können z.b. folgende Regeln gelten: Die Bearbeitungszeit von PKWs und Personenzügen ergibt sich aus einem konstanten Betrag plus der Bearbeitungszeit für die jeweiligen Passagiere Die Bearbeitungszeit von LKWs und Frachtzügen ergibt sich aus einem konstanten Betrag plus Frachtgewicht (evtl. mit einem Faktor multipliziert) Natürlich können Sie auch mit anderen Bearbeitungszeiten experimentieren und deren Auswirkungen untersuchen. 54

55 OOS: Öffnen und Schließen von Toren Durch die Funktion open-or-close-gates können Tore in der Liste *gates* geöffnet oder geschlossen werden oder ihre Eigenschaften verändert werden. Bemerkung: Öffnung eines Tores bedeutet Anlegen einer neuen Instanz und Zufügen zu *gates*, Schließen bedeutet Entfernen einer Instanz. Szenarien: Im einfachsten Fall wird zu Beginn der Simulation von jeder Art Tor eines geöffnet und bleibt bis zum Ende unverändert offen In einem realistischeren Szenario werden Tore nach Bedarf geöffnet (z.b. wenn Länge der in-q eine bestimmte Größe überschreitet) Ein Tor wird geschlossen, wenn es eine bestimmte Zeit lang inaktiv gewesen ist. Der Streß-Faktor an einem Tor kann sich dynamisch ändern (z.b. in Abhängigkeit von der Länge der in-q oder Länge der Öffnungszeit des Tores) Aufgabe Schreiben Sie die Funktion open-or-close-gates und experimentieren Sie mit verschiedenen Szenarien. Vergessen Sie nicht, bei Öffnung eines Tores gewisse Slots korrekt zu setzen. 55

56 OOS: Auswertung eines Simulationslaufs Aufgabe Schreiben Sie eine Funktion statistics, die die nach einem Simulationslauf in der*out-q* enthaltenen Objekte nach folgenden Kriterien analysiert und die Resultate ausgibt: Anzahl der Personen, die die Grenze passiert haben Gesamtgewicht der Güter, die die Grenze passiert haben Minimale / maximale / mittlere Verweildauer an der Grenze (Differenz zwischen Ankunfts- und Abfahrtzeit) Sie können jetzt einige Fragen für typische Datensätze empirisch beantworten, so z.b.: Welche Abarbeitungsstrategie (first come, first served; nach Prioritäten) führt zu der kleinsten mittleren Verweildauer? Welche Fahrzeuge / Fahrzeugkombination sollte ein Spediteur wählen, um eine bestimmte Menge von Gütern möglichst schnell über die Grenze zu befördern? Das Modell ist beliebig erweiterungsfähig: Weitere Fahrzeugklassen Gütern kann ein Objekt-Status zuerkannt werden; dadurch evtl. realistischere Berechnung der Bearbeitungszeit Methoden zur Berechnung von Kosten ; Versuch der Minimierung dieser Kosten... 56