Exercise 3
Compare changes
Some changes are not shown
For a faster browsing experience, some files are collapsed by default.
3_Data_Types_Multiple_Dispatch_de.ipynb
0 → 100644
+ 757
− 0
```
```
Wenn wir jedoch mit dem Standardverhalten des Konstruktors nicht zufrieden sind, können wir unseren eigenen Konstruktor definieren, der ein benutzerdefiniertes Verhalten implementiert. Zum Beispiel könnten wir an einem Konstruktor interessiert sein, der eine Zeichenkette im Format `TT.MM.JJJJ` als Eingabe akzeptiert.
```
```
```
```
`Jedes Jahr, das genau durch vier teilbar ist, ist ein Schaltjahr, mit Ausnahme von Jahren, die genau durch 100 teilbar sind. Diese Jahrhundertjahre sind jedoch Schaltjahre, wenn sie genau durch 400 teilbar sind. Zum Beispiel sind die Jahre 1700, 1800 und 1900 keine Schaltjahre, aber die Jahre 1600 und 2000 sind es.`
```
```
```
```
```
```
```
```
```
```
```
```
```
```
```
```
```
```
```
```
```
```
```
```
In Julia sind konkrete Typen immer ein Blatt des Typbaums, d.h., sie können nicht voneinander abgeleitet werden. Für jemanden, der mit C++ oder Python vertraut ist (wie einige von uns), mag dies zunächst einschränkend erscheinen, aber es entfernt eine Menge unnötiger Komplexität aus der Typenhierarchie. Wir werden jetzt keine weiteren Informationen geben, der Grund wird am Ende dieses Notebooks klarer sein.
Um das Konzept des Mehrfachdispatchs vollständig zu verstehen, werden wir eine Analogie verwenden. Wir werden so tun, als ob eine Programmiersprache ein Werkzeug zum Schreiben eines Kochbuches ist. Ein Rezept kombiniert eine Zubereitungsmethode (zum Beispiel Backen, Braten) mit einer Zutat (zum Beispiel Kartoffeln, Karotten, Fisch).
- Die erste Möglichkeit besteht darin, das Buch nach Zubereitungsmethoden zu organisieren: Jedes Kapitel erklärt ausführlich eine Zubereitungsmethode. Zum Beispiel haben wir **Kapitel 1: Backen**, **Kapitel 2: Braten** und so weiter. Der Nachteil dieses Ansatzes ist, dass wir immer dann, wenn wir eine neue Zutat hinzufügen, mehrere Kapitel ändern müssen. Dieser Ansatz, der sich auf die Aktion und nicht auf die Zutaten konzentriert, ist typisch für funktionale Programmiersprachen.
- Die zweite Möglichkeit besteht darin, das Buch nach Zutaten zu organisieren: Jedes Kapitel konzentriert sich auf eine Zutat. Zum Beispiel haben wir **Kapitel 1: Kartoffeln**, **Kapitel 2: Fisch** und so weiter. Der Nachteil dieses Ansatzes ist, dass wir immer dann, wenn wir ein neues Rezept hinzufügen, erneut mehrere Kapitel ändern müssen. Dieser Ansatz konzentriert sich auf die Zutaten (Daten) und ist typisch für objektorientierte Programmierung, bei der wir etwas Ähnliches haben könnten wie:
- Julia verfolgt einen dritten Ansatz namens **Mehrfachdispatch**, bei dem die Aktion von den Daten entkoppelt wird. In unserem hypothetischen Kochbuch haben wir Kapitel wie **Kapitel 1: Kartoffeln backen**, **Kapitel 2: Kartoffeln braten**, **Kapitel 3: Fisch backen**, **Kapitel 4: Fisch braten** und so weiter. Jedes dieser Kapitel enthält etwas Ähnliches wie:
```
```
```
```
In beiden Fällen bedeutet die Syntax `str::String` und `n::Integer`, dass die jeweilige Methode nur während der Zuordnung berücksichtigt wird, wenn das Argument `str` vom Typ `String` ist und `n` ein `Integer` (oder Untertyp) ist. Da Julia immer zur spezifischsten Methode dispatcht, falls mehrere Methoden übereinstimmen, ist dies alles, was wir tun müssen:
```
```
```
```
```
```
```
```
```
```
```
```
```
```
```
In der Programmiersprachen-Theorie fallen Typsysteme traditionell in zwei Kategorien. In **dynamisch typisierten** Sprachen wird der Typ eines Werts oder Ausdrucks nur zur Laufzeit abgeleitet, was in der Regel flexibleren Code ermöglicht. Beispiele hierfür sind Python oder MATLAB. Im Gegensatz dazu erfordern sogenannte **statisch typisierte** Sprachen (denken Sie an FORTRAN oder C++), dass die Typen bereits vor der Laufzeit bekannt sind, wenn das Programm kompiliert wird. Dies ermöglicht eine gründlichere Überprüfung auf Fehler (die sich in nicht übereinstimmenden Typen äußern können), und es führt normalerweise zu einer Leistungssteigerung, da mehr Informationen über die Speicherlayout des Programms zur Kompilierzeit bekannt sind. Als Ergebnis können Aspekte wie Vektorisierung, kontinuierliche Ausrichtung von Daten und Vorbelegung von Speicher leichter genutzt werden.
Wenn der Code vor der Ausführung vorkompiliert wird, hat der Compiler Informationen über den Typ aller Variablen im Programm. Er wird dann die beste mögliche Methode für jede dieser Variablen suchen. Wenn eine spezifische und hoch effiziente Methode gefunden wird, wird diese verwendet. Wenn eine spezifische Methode fehlt, wird die nächste Möglichkeit im Typbaum verwendet, die immer noch funktioniert, wenn auch nicht so effizient.
**Hinweis:** Diese Suche ist der Grund, warum es nicht möglich ist, abstrakte Typen zu instanziieren. Die Verwendung von Variablen abstrakter Typen würde diesen Vorgang unnötig kompliziert machen. Außerdem spiegelt es auch die Realität wider: Ein generisches Gemüse existiert physisch nicht, wir haben nur Kartoffeln, Karotten, Auberginen und so weiter.
Diese Übung befasst sich mit dem Schreiben eines benutzerdefinierten Datentyps für Polynome, einer Reihe von Konstruktoren dafür und Funktionen zum Durchführen von Operationen an ihnen. **Hinweis:** Das Schreiben benutzerdefinierter Polynome auf diese Weise ist weder effizient noch bequem, aber es ist ein gutes Beispiel für die bisher behandelten Themen.
- Implementieren Sie einen neuen abstrakten Datentyp `AbstractPolynomial`. Dann implementieren Sie einige konkrete Untertypen, `PolynomialDegree0`, `PolynomialDegree1`, `PolynomialDegree2` und `PolynomialArbitraryDegree`. **Tipp:** Verwenden Sie eine Zuordnungstabelle, um die Koeffizienten auf konsistente Weise zwischen den verschiedenen Untertypen zu speichern: Sie können die Potenz von `x` als Schlüssel für den Koeffizientenwert verwenden.
- Schreiben Sie einen Konstruktor für jeden von ihnen, der die Koeffizienten als Eingabe erhält. **Tipp:** Verwenden Sie `args::Real...`, um eine beliebige Anzahl von Argumenten zu sammeln. Die Angabe des Typs ist wichtig, um Unklarheiten beim Aufruf mit einem Argument zu vermeiden (versuchen Sie, `Real` nicht anzugeben, um das Problem zu sehen).
- Schreiben Sie eine Funktion `Polynomial` mit mehreren Methoden: Abhängig von der Anzahl der Argumente sollte sie den richtigen Konstruktor aufrufen. **Tipps:** Sie können die Kurzform `Polynomial(c0) = PolynomialDegree0(c0)` verwenden, um den Code kürzer zu schreiben, und Sie sollten erneut `args...` verwenden, um eine beliebige Anzahl von Argumenten zu unterstützen.
- Implementieren Sie eine Methode der `+` Funktion, die zwei `AbstractPolynomial` zusammenzählt. Es sollte mit jeder Kombination der konkreten Typen funktionieren. Es sollte auch eine Schleife über die Koeffizienten verwenden. **Hinweis:** Das Implementieren einer Methode für eine Funktion der Kernbibliothek erfordert zunächst das Importieren von `import Base.:+`.
- Zuletzt führen Sie eine Leistungsbewertung der `+` Funktion für zwei `PolynomialDegree1`-Polynome und für zwei `PolynomialArbitraryDegree`-Polynome vom Grad 1 durch. **Tipps:** Generieren Sie zufällige Koeffizienten mit `rand()`, wiederholen Sie den Vorgang einige Tausend Mal, um eine messbare Laufzeit zu erhalten, verwenden Sie die Makro `@time`, um die Zeit zu messen.
```