Diskrete Modellierung

Transkript

1 Diskrete Modellierung Wintersemester 2018/19 Martin Mundhenk Uni Jena, Institut für Informatik 22. Oktober 2018

2 Vorlesung Diskrete Modellierung Grundlagen der Programmierung mit Python (Teil 2) (Winter 2018/19) Die Vorlesung/Übung orientiert sich am Buch Introduction to Programming in Python An Interdisciplinary Approach von Robert Sedgewick, Kevin Wayne und Robert Dondero (Addison Wesley, 2015) Die Webseite zum Buch ist auch für diese Vorlesung nützlich.

3 Organisatorisches Vorlesung montags, 16:15-17:45 Uhr, Raum 3325 Ernst-Abbe-Platz 2 Übung donnerstags, 8-10 Uhr, Raum 3410 (Linux-Pool 2) EAP2 Zur Teilnahme brauchen Sie eine Nutzerkennung beim KSZ! (KSZ... Kompetenz- und Service-Zentrum der Fakultät für Mathematik und Informatik) Es gibt ein wöchentliches Übungsblatt (ca. 12). Abgabe montags 16 Uhr (an pythonkurs@uni-jena.de) Zur Zulassung zur Modulprüfung müssen jeweils mindestens 50% der Punkte der Übungsblätter aus der ersten und der zweiten Hälfte erreicht sein. Die Abschlussprüfung ist mündlich und dauert ca. 30 Minuten. Prüfungstermine werden am Ende der Vorlesungszeit vereinbart. Bei der Abschlussprüfung kann ein Programmierprojekt vorgestellt werden.

4 0.0.4 Inhaltsverzeichnis 3. Objektorientiertes Programmieren 3.1 Benutzung von Daten-Typen 3.2 Erzeugen von Daten-Typen 3.3 Entwurf von Daten-Typen 3.4 Zwei Anwendungsbeispiele 4. Algorithmen und Datenstrukturen 4.1 Rechenzeit 4.2 Schnelles Sortieren 4.3 Keller und Warteschlangen 4.4 Symboltabellen 4.5 Anwendungsbeispiel: Small-World-Phänomen Die Nummerierung der Kapitel entspricht der Nummerierung im Buch von Sedgewick et al.

5 3 Objektorientiertes Programmieren Bisher haben wir nur elementare Datentypen (int, float, string, bool, []) benutzt, mit denen man Zahlen etc. und Folgen davon speichern und verarbeiten kann. Jetzt werden wir lernen, wie man komplexere Datentypen benutzt, definiert und entwirft. Ein Ziel ist, Daten und Operationen auf Daten mit Namen ansprechen zu können. Ein anderes Ziel ist, Operationen auf Daten mit den Daten zusammen zu implementieren Objektorientiertes Programmieren 3.1 Benutzung von Daten-Typen 3.2 Erzeugen von Daten-Typen 3.3 Entwurf von Daten-Typen 3.4 Zwei Anwendungsbeispiele

6 Erzeugen von Datentypen Darstellung der Potenziale, die von elektrischen Punktladungen in der Fläche erzeugt werden Wir haben eine Fläche, auf der sich in einigen Punkten elektrische Ladungen befinden. Jede einzelne Ladung bewirkt in jedem Punkt der Fläche ein elektrisches Potenzial, das sich nach dem Gesetz von Coulomb berechnet. Das elektrische Potenzial in jedem Punkt ist die Summe der von jeder Punktladung bewirkten Potenziale. Die beiden Bilder stellen graphisch die Potenziale dar, die von einer bzw. zwei Punktladungen in der Fläche bewirkt werden (rot=hoch, blau=niedrig). Wir wollen solche Bilder berechnen.

7 Die benötigten technischen Details Potenzial in px, yq bezgl. p ist k q0 r Wodurch wird eine Punktladung beschrieben? ihr Punkt px 0, y 0 q auf der Fläche (x- und y-koordinate) r px 0, y 0 q Punktladung p mit Ladung q 0 px, yq ihre elektrische Ladung q 0 Was bewirkt eine Punktladung? ein elektrisches Potenzial in jedem Punkt der Fläche Das elektrische Potenzial V im Punkt px, yq bewirkt durch die Ladung q 0 im Punkt px 0, y 0 q ist k q0 Abstand von px 0, y 0 q zu px, yq Dabei ist k N m2 C 2 die Coulombsche Konstante.

8 3.2.3 Der Datentyp Charge Ein Datentyp besteht aus einer Menge von Werten und einer Menge von Funktionen auf den Werten. Wir wollen einen Datentyp Charge für Punktladungen und von ihnen bewirkte Potenziale implementieren. Jede Punktladung p wird durch die Koordinaten des Punktes px0, y 0q und den Wert der Ladung q0 bestimmt (Werte/Daten). Das durch diese Punktladung (Punkt px0, y0q mit Ladung q0) an Punkt px, yq bewirkte Potenzial ist k (Funktion von der Punktladung und x und y). q0 Abstand von px0, y0q zu px, yq

9 Die API für Charge Die API (application programming interface) beschreibt, wie man den Datentyp benutzen kann. Unser Datentyp Charge soll Folgendes beschreiben: eine Ladung an einem Punkt in der Ebene, d.h. den Wert der Ladung q0 und die Koordinaten des Punktes px0, y0q das Potenzial an Punkt px, yq, das durch die Punktladung bewirkt wird. Operation Charge(x0,y0,q0) c.potentialat(x, y) str(c) Beschreibung eine neue Punktladung an Punkt px0, y 0q mit Ladung q0 das Potenzial an Punkt px, y q bewirkt durch Punktladung c q0 in (x0,y0) zur Darstellung von c als String

10 3.2.5 Die Implementierung von Charge In Python beschreibt man Datentypen durch Klassen. Die Klasse Charge muss die Werte q0, x0, y0 für eine Punktladung speichern können (Konstruktor), für jeden Punkt px, yq das Potenzial, das von der Punktladung im Punkt px0, y0q bewirkt wird, bestimmen können (Methoden), und eine Punktladung als string darstellen können (spezielle Funktionen).

11 # Die Datei charge.py mit der Klasse Charge. # Eine besser kommentierte Fassung ist auf der Webseite zur Vorlesung. import sys, stdio, math class Charge: # Ein Konstruktor def init (self, x0, y0, q0): self._xkoord = x0 self._ykoord = y0 self._ladung = q0 # Eine Methode def potentialat(self, x, y): COULOMB = 8.99e9 dx = x - self._xkoord dy = y - self._ykoord r = math.sqrt(dx*dx + dy*dy) if r == 0.0: if self._ladung > 0: return float('inf') else: return -float('inf') return COULOMB * self._ladung / r def test(): c = Charge(0.51, 0.63, 21.3) print(c) print(c.potentialat(0.7,0.8)) if name ==' main ': test() # Eine spezielle Funktion def str (self): text = str(self._ladung) + ' in (' + str(self._xkoord) + ', ' + str(self._ykoord) + ')' return text

12 3.2.7 Der Konstruktor Signatur spezielle Parameter-Variable gewöhnliche Parameter-Variablen def init ( self, x0, y0, q0 ): self. xkoord = x0 Instanz-Variablen self. ykoord = y0 Funktions-Rumpf self. ladung = q0 Der Rückgabewert des Konstruktors ist stets self (auch ohne return-anweisung). self ist eine Referenz auf das neu erzeugte Objekt.

13 3.2.8 Konstruktor-Abarbeitung auf dem Objekt-Level Charge c = Charge(0.1,0.2,3.0) self x0 [ init (self,0.1,0.2,3.0)] y0 0.1 q

14 3.2.8 Konstruktor-Abarbeitung auf dem Objekt-Level Charge c = Charge(0.1,0.2,3.0) self x0 [ init (self,0.1,0.2,3.0)] y0 0.1 q0 0.2 self. xkoord = x0 self x0 y0 q0 Charge xkoord

15 3.2.8 Konstruktor-Abarbeitung auf dem Objekt-Level Charge c = Charge(0.1,0.2,3.0) self x0 [ init (self,0.1,0.2,3.0)] y0 0.1 q0 0.2 self. xkoord = x0 self. ykoord = y0 self x0 y0 q0 Charge xkoord ykoord

16 3.2.8 Konstruktor-Abarbeitung auf dem Objekt-Level Charge c = Charge(0.1,0.2,3.0) self x0 [ init (self,0.1,0.2,3.0)] y0 0.1 q0 0.2 self. xkoord = x0 self. ykoord = y0 self. ladung = q0 self x0 y0 q0 Charge xkoord ykoord ladung

17 Konstruktor-Abarbeitung auf dem Objekt-Level Charge c = Charge(0.1,0.2,3.0) self x0 [ init (self,0.1,0.2,3.0)] y0 0.1 q0 0.2 self. xkoord = x0 self. ykoord = y0 self. ladung = q0 [return self] self x0 y0 q0 c Charge xkoord ykoord ladung Charge xkoord ykoord ladung

18 Methoden Signatur spezielle Parameter-Variable gewöhnliche Parameter-Variablen def potentialat( self, x, y ): COULOMB = 8.99e9 lokale Variablen dx = x - self. xkoord dy = y - self. ykoord Instanz-Variablen r = math.sqrt(dx*dx, dy*dy) Funktions-Aufruf if r == 0.0:... return Anweisung return COULOMB * self. ladung / r 3.2.9

19 Variablen in Methoden Parameter-Variablen Bsp.: self, x, y Aufgabe: Übergabe von Argumenten beim Aufruf der Methode Gültigkeitsbereich (scope): Methode Instanz-Variablen Bsp.: xkoord, ykoord Aufgabe: Speicherung von Werten des Datentyps Gültigkeitsbereich (scope): Klasse lokale Variablen Bsp.: dx, dy Aufgabe: Speicherung von temporären Werten beim Rechnen Gültigkeitsbereich (scope): Methode

20 Spezielle Funktionen und Konventionen Die Funktion str(c) in der API: nach Konvention wird beim Aufruf str(c) die Methode c. str () angewendet. Beim Aufruf von print(c) wird von Python print(str(c)) ausgeführt (etc.). Die Schreibweise mit Unterlänge am Anfang eines Variablen- oder Methodennamens wird dann benutzt, wenn der Name nur innerhalb der Implementierung der Klasse benutzt werden soll. In Python gibt es keine Möglichkeit, die Benutzung dieser Variablen- und Methodennamen zu verbieten. Andere Programmiersprachen bieten Konzepte dafür.

21 Erzeugen eines Datentyps Kurze Zusammenfassung 1. Angabe der API Ziel: einfache Benutzung des Datentyps von Klienten Klarheit über Struktur des Datentyps: welche Daten und welche Methoden? 2. Implementierung einer Klasse in Python Konstruktur init mit self als erster Parameter-Variable gefolgt von den gewöhnlichen Parameter-Variablen Methoden gemäß der API mit self als erster Parameter-Variable gefolgt von den gewöhnlichen Parameter-Variablen spezielle Funktionen, deren Namen von doppelten Unterlängen eingeschlossen sind mit self als erster Parameter-Variable 3. Testen der Implementierung

22 Abschließendes Beispiel: Visualisierung von Potenzialen Wir wollen Punktladungen aus einer Datei einlesen (alle Punkte haben Koordinaten px, yq mit 0 ď x, y ď 1), die Potenziale aller Punkte eines Bildes mit Auflösung 400 ˆ 400 und Koordinaten 0 ď x, y ď 1 berechnen (das Potenzial in Punkt px, yq ist die Summe der von allen Punktladungen in px, y q bewirkten Potenziale) % more charges.txt und graphisch darstellen, z.b. verschiedene Graustufen hohes Potential ist hell und niedriges Potential ist dunkel.

23 Die Struktur des Programms 1. Lies von der Kommandozeile den Namen der Datei mit den Punktladungen. 2. Berechne für jedes Pixel des Bildes das Potenzial. 3. Bestimme abhängig von der Spannbreite aller Potenziale deren Darstellung als Farbe. 4. Setze für jedes Pixel des Bildes die Farbe. 5. Zeige das Bild an. Wir implementieren eine Variante, bei der man zusätzlich zwischen drei Darstellungsarten wählen kann.

24 Welche Datenstrukturen wollen wir benutzen? Charge zur Darstellung der Punktladungen. Picture zur Darstellung des Ergebnis-Bildes. Der Zugriff auf die einzelnen Punkte des Bildes ist dabei sehr einfach. Color zur Darstellung der Farben. InStream zum Einlesen der Datei.

25 Die API von InStream

26 potenzialbild.py import sys, stdio, stddraw, stdarray, math from charge import Charge from color import Color from picture import Picture from instream import InStream # Lies einen Dateinamen von der Kommandozeile # und öffne die Datei mit diesem Namen. dateiname = sys.argv[1] eingabe = InStream(dateiname) # Lies die Art der Darstellung t von der Kommandozeile. t = 1 if len(sys.argv)>2: t = int(sys.argv[2]) # Die Datei enthält zeilenweise die Punktladungen bestehend # aus der x- und der y-koordinate des Punktes und der Ladung q # (alles float). Die Datei wird eingelesen, die Punktladungen # werden erzeugt und in einem Array gespeichert. punktladungen = [] while not eingabe.isempty(): x = eingabe.readfloat() y = eingabe.readfloat() q = eingabe.readfloat() punktladungen += [Charge(x,y,q)] # Die Ausgabe ist ein quadratisches Bild mit aufloesung*auf aufloesung = 400 # Es wird das Potenzial für jedes Pixel berechnet. # potenziale ist ein 2d-Array, in dem die Pixel-Potenziale # gespeichert werden. # Es wird später für die Darstellung als Picture # verwendet. # allepotentiale ist ein 1d-Array, in dem alle Potenziale # gespeichert werden. # Es wird später für die Umrechnung der Potenziale in # Farben verwendet. potenziale = stdarray.create2d(aufloesung,aufloesung) allepotenziale = [] for s in range(aufloesung): for z in range(aufloesung): # Die (x,y)-koordinaten des Punktes in Spalte s und # Zeile z werden bestimmt. x = 1.0 * s / aufloesung y = 1.0 * z / aufloesung # Das Potenzial im Punkt wird berechnet. v = 0.0 for p in punktladungen: v += p.potentialat(x,y) potenziale[s][z] = v allepotenziale += [v]

27 # Sortiere das Array mit allen Potenzialen. # Wir stellen uns das Array aufgeteilt in 256 Abschnitte vor. Jeder Abschnitt steht für eine "Farbe" von allepotenziale.sort() abschnittlaenge = len(allepotenziale) // 256 # Erzeuge ein (leeres) Bild. bild = Picture(aufloesung,aufloesung) # Male jedes Pixel des Bildes mit einer Farbe, die das Potenzial des Pixels (aus potenziale[][]) darstellt. for s in range(aufloesung): for z in range(aufloesung): # Stelle fest, in welchem der 256 Abschnitte von allepotenziale das Potenzial des Pixels (s,z) liegt. # Dieser Wert wird in graustufe gespeichert. graustufe = 0 while potenziale[s][z] > allepotenziale[(graustufe+1)*abschnittlaenge-1] and graustufe<=254: graustufe += 1 # Stelle den Wert von graustufe als Farbe dar. # Die erste Variante ist die Darstellung als Graustufe. if t==1: farbe = Color(graustufe,graustufe,graustufe) # 2.Variante: stelle Farbstufe 0 als blau (kalt) und Farbstufe 255 als rot (warm) dar # und mische die dazwischenliegenden Farbstufen aus Rot- und Blau-Bestandteilen zusammen. elif t==2: farbe = Color(graustufe,0,255-graustufe) # 3.Variante : male "Isobaren" aus Potenzialen mit gleicher Farbstufe im Abstand 5. else: if graustufe % 5 == 0: farbe = Color(0,0,0) else: farbe = Color(255,255,255) # Trage den Farbpunkt in bild ein (die Zeilen in bild werden andersherum gezählt als # in unserer Vorstellung von der Fläche mit den Punktladungen) bild.set(s,bild.height()-1-z, farbe)

28 # Zeige bild auf dem Bildschirm an. stddraw.setcanvassize(bild.width(),bild.height()) stddraw.picture(bild) stddraw.show() Die Umwandlung von Potenzialen in Graustufen kann auf verschiedene Weise dargestellt werden. python potenzialbild.py charges.txt 1 python potenzialbild.py charges.txt 3 python potenzialbild.py charges.txt 2

29 Zusammenfassung Wir haben die ersten Schritte dazu gesehen, wie man einen Datentyp entwirft, eine API dafür angibt und den Datentyp in Python als Klasse implementiert. Wir werden noch mehr Schritte dazu sehen.