I Aufwand = Anzahl benötigter Operationen. I programmspezifische Operationen nicht gezählt. I Aufwand wird durch einfaches Zählen ermittelt

Transkript

1 Aufwand eines Algorithmus Aufwand I Aufwand von Algorithmen I Landau-Symbol O I time.h, clock t, clock() I Aufwand = Anzahl benötigter Operationen Zuweisungen Vergleiche arithmetische Operationen I programmspezifische Operationen nicht gezählt Deklarationen & Initialisierungen Schleifen, Verzweigungen etc. Zählvariablen I Aufwand wird durch einfaches Zählen ermittelt I Konventionen zum Zählen nicht einheitlich I in der Regel ist Aufwand für worst case interessant d.h. maximaler Aufwand im schlechtesten Fall 83 8 Landau-Symbol O (= groß-o) I oft nur Größenordnung des Aufwands interessant Beispiel: Maximum suchen 1 double maximum(vector<double> &v) { 2 int i = 0; 3 double max = 0; 5 int n = (int) v.size(); max = v[0]; 7 for (i=1; i<n; ++i) { 8 if (v[i] > max) { 9 max = v[i]; 10 } 12 return max; 13 } I Aufwand: 2 Zuweisung n 1 Schritte mit jeweils 1 Vergleich 1 Zuweisung (worst case!) I insgesamt 2 + 2(n 1) = 2n Operationen I Schreibweise f = O(g) für x! x 0 heißt lim sup x!x0 f(x) g(x) < 1 d.h. f(x) apple C g(x) für x! x 0. d.h. f wächst höchstens so schnell wie g I Beispiel: Maximum suchen Aufwand 2n = O(n) für n!1 I häufig entfällt für x! x 0 dann Grenzwert x 0 kanonisch z.b. 2n = O(n) I Sprechweise: Algorithmus hat linearen Aufwand, falls Aufwand O(n) bei Problemgröße n Maximumssuche hat linearen Aufwand Algorithmus hat fastlinearen Aufwand, falls Aufwand O(n log n) bei Problemgröße n Algorithmus hat quadratischen Aufwand, falls Aufwand O(n 2 ) bei Problemgröße n Algorithmus hat kubischen Aufwand, falls Aufwand O(n 3 ) bei Problemgröße n 85 8

2 Minsort Matrix-Vektor Multiplikation 1 void MVM(vector<vector<double> > &A, 2 vector<double> &x, 3 vector<double> &y, int m, int n) { 5 int i = 0; int j = 0; 7 8 for(i=0; i<m; ++i) { 9 y[i] = 0.; 10 for(j=0; j<n; ++j) { 11 y[i] = y[i] + A[i][j]*x[j]; 12 } 13 } 1 } I m Schritte 1 Zuweisung jeweils n mal 1 Multiplikation 1 Addition 1 Zuweisung I Insgesamt 3mn + m Operationen I Aufwand O(mn) bzw. Aufwand O(n 2 ) für m = n d.h. quadratischer Aufwand für m = n 87 1 void minsort(vector<double> &vec){ 2 int j,k,argmin; 3 double tmp; int n = vec.size(); 5 for (j=0; j<n-1; ++j) { 7 argmin = j; 8 for (k=j+1; k<n; ++k) { 9 if (vec[argmin] > vec[k]) { 10 argmin = k; 12 } 13 if (argmin > j) { 1 tmp = vec[argmin]; 15 vec[argmin] = vec[j]; 1 vec[j] = tmp; 17 } 18 } 19 } I n-1 Schritte 1 Zuweisung jeweils n (j + 1) = n j 1 mal 1 Vergleich 1 Zuweisung (worst case!) jeweils 1 Vergleich jeweils 3 Zuweisungen (worst case!) I Insgesamt 5(n 1) + P n 1 j=1 (n j 1)2 = 5(n 1) + 2 P n 2 k=0 k (n 2)(n 1) = 5(n 1) = n 2 +2n 3, d.h. quadratischer Aufwand O(n 2 ) 88 Zeitmessung I Wozu Zeitmesssung? Vergleich von Algorithmen Vergleich von Implementierungen überprüfen theoretischer Voraussagen I theoretische Voraussagen linearer Aufwand 2 Problemgröße ) 2 Rechenzeit quadratischer Aufwand 2 Problemgröße ) Rechenzeit etc. I Bibliothek time.h Datentyp clock t für Zeitvariablen für Ausgabe Typecast nicht vergessen! Funktion clock() liefert Rechenzeit seit Programmbeginn Konstante CLOCKS PER SEC zum Umrechnen: Zeitvariable/CLOCKS PER SEC liefert Angabe in Sekunden 89 Vergleich von Laufzeit 2 #include <time.h> 3 double maximum(vector<double> &vec); 5 void minsort(vector<double> &vec); 7 int main() 8 { 9 clock_t t1,t2; 10 int i = 0; 11 double max = 0; 12 int n = 0; 13 1 cout << "Geben Sie die Dimension ein: " << endl; 15 cin >> n; 1 vector<double> v(n,0); 17 for(i=0; i<n; ++i) { 18 cout << "v[" << i << "]= "; 19 cin >> v[i]; 20 cout << endl; 21 } t1 = clock(); 2 max = maximum(v); 25 t2 = clock(); 2 cout << "Maximum: " << 27 ((double)(t2-t1)/clocks_per_sec) 28 << endl; t1 = clock(); 31 minsort(v); 32 t2 = clock(); 33 cout << "Minsort: " << 3 ((double)(t2-t1)/clocks_per_sec) 35 << endl; 3 } 90

3 Vergleich von Laufzeit n t max t minsort Vererbung I was ist Vererbung? I geerbte Felder und Methoden I Methoden redefinieren I Aufruf von Basismethoden I Linearer Aufwand liefert sehr gute Rechenzeit I Quadratischer Aufwand für große N spürbar I Fazit: Algorithmen sollen kleinen Aufwand haben Ziel der numerischen Mathematik nicht immer möglich Was ist Vererbung Was ist Vererbung 2 I im Alltag klassifizieren wir Objekte I wir teilen unsere Umgebung in Kategorien ein ein Auto ist ein Fortbewegungsmittel ein Hund ist ein Säugetier eine SPD-Matrix ist immer noch eine Matrix I alle Säugetiere können sich bewegen und atmen Hunde haben zusätzlich spezielle Eigenschaften... bellen, mit dem Schwanz wedeln... I Die Kategorien lassen sich weiter unterteilen Ferrari und Porsche beschreiben spezielle Autos I ganze Hierarchien entstehen Unterkategorien sind jeweils Erweiterungen Eigenschaften der Basiskategorie haben alle ) ist-ein-beziehung I C++ stellt Kategorien durch Klassen dar I spezielle werden von allgemeineren abgeleitet I diesen Vorgang nennt man Vererbung 93 9

4 Was ist Vererbung 3 Die Syntax der Vererbung I Vererbung in C++ bildet Wirklichkeit ab Spezialisierung durch zusätzliche Methoden allgemeine Methoden sind direkt verfügbar Fähigkeit bewegen muss bei Auto nicht separat implementiert werden I Syntax: ) das wurde von Fortbewegungsmittel geerbt class Car : public Fortbewegungsmittel I Ableitung erfolgt durch (:) I auto erbt alle Methoden und Felder von fortbewegungsmittel auto ist eine abgeleitete Klasse fortbewegungsmittel ist die Basisklasse I Alle Matrizen haben Einträge I reguläre Matrizen sind invertierbar I für SPD bietet sich zusätzlich Cholesky an Ein Beispiel - ctn d Ein Beispiel 2 #include <string.h> 3 using namespace std; 5 class Fortbewegungsmittel { 7 protected: 8 double speed; 9 public: 10 Fortbewegungsmittel(){}; 11 ~Fortbewegungsmittel(){}; 12 Fortbewegungsmittel(double s){speed = s;}; 13 double getspeed(){return speed;}; 1 void setspeed(double s){speed = s;}; 15 void move(); 1 }; class Car : public Fortbewegungsmittel 19 { 20 private: 21 string color; 22 public: 23 Car(){}; 2 void fahren(); 25 string getcolor(){return color;}; 2 void setcolor(string c){color = c;}; 27 }; 1 /* class definitions */ 2 3 void Fortbewegungsmittel::print() { 5 cout << "Geschwindigkeit: " << getspeed() << endl; 7 } 8 9 void Fortbewegungsmittel::move() 10 { 11 cout << "Ich habe mich bewegt" << endl; 12 } 13 1 void Car::fahren() 15 { 1 cout << "Ich bin gefahren" << endl; 17 } int main() 20 { 21 Fortbewegungsmittel fahrrad(10); 22 Car mycar; 23 mycar.setspeed(50); 2 mycar.setcolor("rot"); 25 fahrrad.move(); 2 mycar.fahren(); 27 mycar.move(); 28 } I Ausgabe:Ich habe mich bewegt Ich bin gefahren Ich habe mich bewegt 97 98

5 Das Schlüsselwort protected I Problem: private Daten sind bei abgeleiteten Klassen nicht verfürbar Deklaration als public nicht sinnvoll I Lösung: protected I Daten sind für alle abgeleiteten Klassen sichtbar für alle anderen jedoch wie private 1 class Basis 3 private: int privat; 5 protected: int protect; 7 public: 8 int publik; 9 }; class Abgelitten : public Basis 1 13 void zugriff() 1 { 15 a = privat; // Das gibt Ärger! 1 a = protect; // Das funktioniert. 17 a = publik; // Das funktioniert sowieso. 18 } 19 }; int main(){ 22 Basis myvar; 23 int a; 2 a = myvar.privat; // Das läuft nicht. 25 a = myvar.protect; // Das auch nicht. 2 a = myvar.publik; // Das funktioniert. 27 } 99 Konstruktoren der Basisklasse aufrufen I Vererbung bedeutet eine ist-ein-beziehung Jedes Auto ist ein Fortbewegungsmittel I Das merkt man am Aufruf Zuerst wird der Konstruktor der Basisklasse aufgerufen Danach der Konstruktor der abgeleiteten Klasse Bei Destruktoren anders herum I Entsprechend stellen Konstruktoren oft Erweiterungen dar z.b. zusätzliche Felder werden initialisiert I daher: Basisklassenkonstruktor aufrufen 1 Car::Car(double s, string c): 2 Fortbewegungsmittel(s), 3 color(c) { 5 cout << "car-konstruktor" << endl; } 100 Funktionen redefinieren 2/2 Funktionen redefinieren 1/2 I Funktionen können in der abgeleiteten Klasse komplett neu gestaltet (redefiniert) werden 1 void Fortbewegungsmittel::print() 3 cout << "Geschwindigkeit: " << getspeed() << endl; 5 } 7 void Car::print() 8 { 9 cout << "Geschwindigkeit: " << getspeed() 10 << ", Farbe: " << getcolor() << endl; I nicht verwechseln mit überladen mehrere Methoden mit unterschiedlicher Signatur I in jedem Fall wird immer die richtige Methode aufgerufen I Problem: Basismethoden werden verdeckt eine redefinierte Methode verdeckt alle Basismethoden 1 void Fortbewegungsmittel::print(); 2 void Fortbewegungsmittel::print(int s); 3 void Fortbewegungsmittel::print(int s, double c); 5 void Car::print(); 7 /* Implementierung */ 8 9 int main() 10 { 11 Car mycar; 12 mycar.print(); // OK 13 mycar.print(10); // funktioniert nicht 1 } I kein Zugriff mehr auf überladene Basisfunktionen I Lösung: Basisfunktion manuell aufrufen vollständigen Namen verwenden mycar.fortbewegungsmittel::print(10);

6 Ein Beispiel 2/3 Ein Beispiel 1/3 2 using namespace std; 3 class Punkt{ 5 protected: int x; 7 int y; 8 public: 9 Punkt(int x, int y); 10 int getx(){return x;}; 11 int gety(){return y;}; 12 void bewegen(int x, int y); //überladen 13 void bewegen(int x); 1 void bewegen(); 15 void print(); 1 void center(); 17 }; class Kreis : public Punkt{ 20 private: 21 int radius; 22 public: 23 Kreis(int x, int y, int radius); 2 int getrad(){return radius;}; 25 void bewegen(int r); //redefiniert 2 void print(); 27 }; I unterscheide zwischen überladen und redefinieren Punkt::Punkt(int x, int y){ 2 this->x = x; 3 this->y = y;} 5 void Punkt::bewegen(int x, int y){ this->x = this->x+x; 7 this->y = this->y+y;} 8 9 void Punkt::bewegen(int x){ 10 this->x = this->x+x;} void Punkt::bewegen(){ 13 this->x = this->x-3; 1 this->y = this->y-;} 15 1 void Punkt::print(){ 17 cout << "X: " << getx() << ", Y: " 18 << gety() << endl;} void Punkt::center(){ 21 x=0; y=0;} Kreis::Kreis(int x, int y, int radius): 2 Punkt(x,y) 25 { 2 this->radius = radius; 27 } void Kreis::bewegen(int r){ 30 x = x+radius+r;} void Kreis::print(){ 33 cout << "X: " << getx() << ", Y: " << 3 gety() << ", Radius: " << getrad() << endl;} 10 Ein Beispiel 3/3 1 int main() 3 Punkt P1(3,7); P1.print(); 5 P1.bewegen(13); P1.print(); 7 8 Kreis K1(3,7,12); 9 K1.print(); 10 K1.bewegen(3); 11 K1.print(); 12 K1.Punkt::bewegen(3,); 13 K1.print(); 1 K1.center(); 15 K1.print(); 1 } I Ausgabe:X: 3, Y: 7 X: 1, Y: 7 X: 3, Y: 7, Radius: 12 X: 18, Y: 7, Radius: 12 X: 21, Y: 11, Radius: 12 X: 0, Y: 0, Radius: 12 I in UML: Vererbung mit Matrizen 1/3 2 #include <string> 3 #include <vector> #include <assert.h> 5 using namespace std; 7 class Matrix{ 8 protected: 9 int m,n; //dimensions 10 vector<vector<double> > entries; 11 public: 12 int getm(){return m;}; 13 int getn(){return n;}; 1 double getentry(int i, int j); 15 void setentry(int i, int j, double entry); 1 void plot(); 17 Matrix(); 18 Matrix(int m, int n, int init); 19 }; class SquareMatrix : public Matrix{ 22 // stores square matrices 23 public: 2 SquareMatrix computelu(); 25 double computedet(); 2 SquareMatrix(int n, int init); 27 };

7 Vererbung mit Matrizen 2/3 1 /* class definitions*/ 2 /* get & set implementation*/ 3 void Matrix::plot(){ 5 for(int i = 0; i < getm(); i++){ for(int j = 0; j < getn(); j++){ 7 cout << "Eintrag " << i << ", " << j 8 << ": " << getentry(i,j) << endl; 9 } 10 } Matrix::Matrix(): 1 m(1), n(1), 15 entries(vector<vector<double> >(m, vector<double>(n, 0))){} 1 17 Matrix::Matrix(int m, int n, int init): 18 m(m), n(n), 19 entries(vector<vector<double> >(m, vector<double>(n, init))){} SquareMatrix SquareMatrix::computeLU(){ 22 // Implementation LU decomposition 23 } 2 25 double SquareMatrix::computeDet(){ 2 // Implementation determinant 27 } SquareMatrix::SquareMatrix(int n, int init): 30 Matrix(n, n, init){} Vererbung mit Matrizen 3/3 1 int main() 3 Matrix mat1(3,,2); mat1.plot(); 5 SquareMatrix mat2(2,1); mat2.plot(); 7 } I Ausgabe:Eintrag 0, 0: 2 Eintrag 0, 1: 2 Eintrag 0, 2: 2 Eintrag 0, 3: 2 Eintrag 1, 0: 2 Eintrag 1, 1: 2 Eintrag 1, 2: 2 Eintrag 1, 3: 2 Eintrag 2, 0: 2 Eintrag 2, 1: 2 Eintrag 2, 2: 2 Eintrag 2, 3: 2 Eintrag 0, 0: 1 Eintrag 0, 1: 1 Eintrag 1, 0: 1 Eintrag 1, 1: Übersicht - Vererbung I Vererbung macht den Code leichter zu warten I Verebung erhöht die Wiederverwendbarkeit massiv I genaue Implementierung der Basisklasse unwichtig I abgeleitete Klasse erbt alle Methoden und Felder sofern der Zugriff dies erlaubt I neue Implementierung für geerbte Methoden möglich Methoden redefinieren I Achtung: verdeckt alle gleichnamigen Basismethoden (dies kann natürlich gewollt sein) Zugriff über vollen Funktionsnamen I Fazit: verwende Vererbung immer wenn (sinnvoll) möglich verwende Code wieder wenn möglich senkt die Fehlerquote erleichtert spätere Änderungen One more thing I es muss nicht immer public vererbt werden Basisklasse abgeleitete Klasse public protected private public public protected private protected protected protected private private hidden hidden hidden I Sichtbarkeit ändert sich durch Art der Vererbung Zugriff kann nur verschärft werden andere außer public machen selten Sinn