Compare revisions

YingXing · Michele Nottoli · Michele Nottoli · Michele Nottoli · Benjamin Stamm · Benjamin Stamm
--- a/0_Installation_de.ipynb
+++ b/0_Installation_de.ipynb
+%% Cell type:markdown id:31ac33c0-18a9-4cfa-8e04-3ee1a0c909eb tags:
+
+# Installation und Einrichtung
+Bitte befolge die in README.md beschriebenen Schritte 1-3, um Julia herunterzuladen und zu installieren, und das Notebook 0_Installation.ipynb in einen Jupyter-notebook zu öffnen.
+
+%% Cell type:markdown id:ff3c6951-2bc8-42b9-b2f4-acbb473300c6 tags:
+
+## Informationen zu Notebooks
+
+Notebooks sind Werkzeuge, um interaktiven Code auszuführen und die Ausgabe anzuzeigen. Sie sind sehr praktisch, um mit Code zu experimentieren und eine Programmiersprache neu zu lernen.
+
+Die Julia-Befehle werden in einer separaten Julia-Instanz im Hintergrund ausgeführt, der Browser ermöglicht die Interaktion mit den Notebooks (das Erstellen neuer Notebooks, das Ausführen und Modifizieren von ihnen). Beachte dass der Browser-Editor nicht mehr funktioniert wenn das Backend-Programm geschlossen wird.
+
+Wenn jedoch der Browser geschlossen wird, läuft das Backend weiter. Du kannst darauf zugreifen, indem Du die Adresse öffnest:
+[http://localhost:8888](http://localhost:8888)
+
+%% Cell type:markdown id:c974b7c0-119c-4223-ad80-dce5a3ceead3 tags:
+
+### Notebooks
+
+Notebooks sind Dateien, die durch die Erweiterung `.ipynb` gekennzeichnet sind. Mit dem interaktiven Datei-Explorer kannst Du sie öffnen.
+
+Die Notebooks enthalten Code, die Ausgabe des Codes und können zusätzliche Kommentare enthalten (wie diese hier). Das gesamte Material des Kurses enthält noch nicht die Ausgabe des Codes, Du erhälst sie, indem Du den Code zuerst ausführst.
+
+Die Notebooks werden automatisch alle paar Minuten gespeichert, um jedoch sicherzustellen, dass sie gespeichert sind, kannst Du "Strg + S" drücken.
+
+%% Cell type:markdown id:8c98e5f5-5a92-415a-b9ec-865972d45b6f tags:
+
+### Zellen
+
+Notebooks bestehen aus **Zellen**. Es gibt zwei Hauptarten: **Code** und **Markdown**. Dies ist eine Markdown-Zelle und wird verwendet, um Text auf eine formatierte Weise anzuzeigen.
+
+Die nächste ist eine Code-Zelle und wird verwendet, um Code auszuführen und dessen Ausgabe anzuzeigen. Um sie auszuführen, klicken Sie darauf und drücken Sie Shift + Enter.
+
+%% Cell type:code id:8074a659-e100-49db-b83c-f0738b25cf28 tags:
+
+``` julia
+println("Hello World!")
+```
+
+%% Cell type:markdown id:192dac00-072c-4699-bd06-9af6ae4e3055 tags:
+
+Wenn Du auf eine Code-Zelle klickst, kannst Du auch deren Inhalt ändern. Um eine Markdown-Zelle zu ändern, musst Du darauf doppelklicken (dies ist jedoch für diesen Kurs nicht erforderlich).
+
+Es ist auch möglich, eine Code-Zelle in eine Markdown-Zelle oder umgekehrt zu ändern. Gehe dazu im oberen Menü auf Ausführen, Zellentyp.
+
+Schließlich können neue Zellen hinzugefügt werden, indem Du das `+`-Symbol im oberen Menü verwendest.
+
+Jedes Mal, wenn es eine Übung für den Leser gibt, haben wir eine leere Code-Zelle hinzugefügt.
+
+%% Cell type:markdown id:e7730114-5064-46d1-b724-e92277ff2f90 tags:
+
+## Überprüfen, ob alles funktioniert
+
+Um zu überprüfen, ob die Installation erfolgreich war, führe die folgende Zelle aus.
+
+%% Cell type:code id:7bb04662 tags:
+
+``` julia
+using Plots
+
+p = plot(1, xlim=(0, 3π), ylim=(-1.5, 1.5), title="Sine", marker=2)
+N = 100
+@gif for i=1:N
+    x = (i-1) * 3π / N
+    push!(p, x, sin(x))
+end
+```
+
+%% Cell type:code id:c7d2870e tags:
+
+``` julia
+```
+%% Cell type:markdown id:31ac33c0-18a9-4cfa-8e04-3ee1a0c909eb tags:
+
+# Installation und Einrichtung
+Bitte befolge die in README.md beschriebenen Schritte 1-3, um Julia herunterzuladen und zu installieren, und das Notebook 0_Installation.ipynb in einen Jupyter-notebook zu öffnen.
+
+%% Cell type:markdown id:ff3c6951-2bc8-42b9-b2f4-acbb473300c6 tags:
+
+## Informationen zu Notebooks
+
+Notebooks sind Werkzeuge, um interaktiven Code auszuführen und die Ausgabe anzuzeigen. Sie sind sehr praktisch, um mit Code zu experimentieren und eine Programmiersprache neu zu lernen.
+
+Die Julia-Befehle werden in einer separaten Julia-Instanz im Hintergrund ausgeführt, der Browser ermöglicht die Interaktion mit den Notebooks (das Erstellen neuer Notebooks, das Ausführen und Modifizieren von ihnen). Beachte dass der Browser-Editor nicht mehr funktioniert wenn das Backend-Programm geschlossen wird.
+
+Wenn jedoch der Browser geschlossen wird, läuft das Backend weiter. Du kannst darauf zugreifen, indem Du die Adresse öffnest:
+[http://localhost:8888](http://localhost:8888)
+
+%% Cell type:markdown id:c974b7c0-119c-4223-ad80-dce5a3ceead3 tags:
+
+### Notebooks
+
+Notebooks sind Dateien, die durch die Erweiterung `.ipynb` gekennzeichnet sind. Mit dem interaktiven Datei-Explorer kannst Du sie öffnen.
+
+Die Notebooks enthalten Code, die Ausgabe des Codes und können zusätzliche Kommentare enthalten (wie diese hier). Das gesamte Material des Kurses enthält noch nicht die Ausgabe des Codes, Du erhälst sie, indem Du den Code zuerst ausführst.
+
+Die Notebooks werden automatisch alle paar Minuten gespeichert, um jedoch sicherzustellen, dass sie gespeichert sind, kannst Du "Strg + S" drücken.
+
+%% Cell type:markdown id:8c98e5f5-5a92-415a-b9ec-865972d45b6f tags:
+
+### Zellen
+
+Notebooks bestehen aus **Zellen**. Es gibt zwei Hauptarten: **Code** und **Markdown**. Dies ist eine Markdown-Zelle und wird verwendet, um Text auf eine formatierte Weise anzuzeigen.
+
+Die nächste ist eine Code-Zelle und wird verwendet, um Code auszuführen und dessen Ausgabe anzuzeigen. Um sie auszuführen, klicken Sie darauf und drücken Sie Shift + Enter.
+
+%% Cell type:code id:8074a659-e100-49db-b83c-f0738b25cf28 tags:
+
+``` julia
+println("Hello World!")
+```
+
+%% Cell type:markdown id:192dac00-072c-4699-bd06-9af6ae4e3055 tags:
+
+Wenn Du auf eine Code-Zelle klickst, kannst Du auch deren Inhalt ändern. Um eine Markdown-Zelle zu ändern, musst Du darauf doppelklicken (dies ist jedoch für diesen Kurs nicht erforderlich).
+
+Es ist auch möglich, eine Code-Zelle in eine Markdown-Zelle oder umgekehrt zu ändern. Gehe dazu im oberen Menü auf Ausführen, Zellentyp.
+
+Schließlich können neue Zellen hinzugefügt werden, indem Du das `+`-Symbol im oberen Menü verwendest.
+
+Jedes Mal, wenn es eine Übung für den Leser gibt, haben wir eine leere Code-Zelle hinzugefügt.
+
+%% Cell type:markdown id:e7730114-5064-46d1-b724-e92277ff2f90 tags:
+
+## Überprüfen, ob alles funktioniert
+
+Um zu überprüfen, ob die Installation erfolgreich war, führe die folgende Zelle aus.
+
+%% Cell type:code id:7bb04662 tags:
+
+``` julia
+using Plots
+
+p = plot(1, xlim=(0, 3π), ylim=(-1.5, 1.5), title="Sine", marker=2)
+N = 100
+@gif for i=1:N
+    x = (i-1) * 3π / N
+    push!(p, x, sin(x))
+end
+```
+
+%% Cell type:code id:c7d2870e tags:
+
+``` julia
+```
--- a/0_Installation_en.ipynb
+++ b/0_Installation_en.ipynb
+%% Cell type:markdown id:16b28ead tags:
+
+# Installation and Setup
+Please follow the steps 1-3 outlined in README.md to download and install Julia, and to open the notebook 0_Installation.ipynb in a Jupyter notebook.
+
+%% Cell type:markdown id:9161160b-87ff-4b12-bd5a-bca54228672d tags:
+
+## Information about notebooks
+
+Notebooks are tools to interactively run code and display output. They are quite convenient for experimenting with code.
+
+The julia commands are run in a backend julia instance, the browser let's you interact with the notebooks (create new ones, run them, modify them). If the backend program is closed, the browser editor will stop working.
+
+However, if the browser is closed, the backend will keep running. You can get back to it by opening the address:
+[http://localhost:8888](http://localhost:8888)
+
+%% Cell type:markdown id:a915cd2f-dc38-4679-8d79-c2204e2073cf tags:
+
+### Notebooks
+
+Notebooks are files characterized by the extension `.ipynb`. Using the interactive file explorer you can open them.
+
+The notebooks contain code, the output of the code, and can contain additional comments (like these ones). All the material of the course does not contain yet the output of the code, you will get it by running the code first.
+
+The notebooks are automatically saved every now and then, however to make sure they are saved, you can press "Ctrl + S".
+
+%% Cell type:markdown id:93606623-16a4-4263-9906-a79dd3fae22f tags:
+
+### Cells
+
+Notebooks are made up of **cells**. There are two main types: **code** and **markdown**. This is a markdown cell, it is used to display text in a formatted way.
+
+The next is a code cell, it is used to run code and display its output. To run it, click on it and press "Shift + Enter".
+
+%% Cell type:code id:8074a659-e100-49db-b83c-f0738b25cf28 tags:
+
+``` julia
+println("Hello World!")
+```
+
+%% Cell type:markdown id:5fc38ba1-65d0-490f-8c06-4136a7ff1372 tags:
+
+When you click on a code cell, you can also modify its content.
+To modify a markdown cell, you need to double click on it (however this is not required by this course).
+
+It is also possible to transform a code cell in a markdown cell, or the other way around. To do so, go in the top menu, Run, Cell Type.
+
+Finally, new cells can be added by using the `+` symbol in the top menu.
+
+Every time there is an exercise left to the reader, we added an empty code cell.
+
+%% Cell type:markdown id:d3d75953 tags:
+
+## Verifying that everything works
+
+To check if the installation was successfull, run the following cell.
+
+%% Cell type:code id:7bb04662 tags:
+
+``` julia
+using Plots
+
+p = plot(1, xlim=(0, 3π), ylim=(-1.5, 1.5), title="Sine", marker=2)
+N = 100
+@gif for i=1:N
+    x = (i-1) * 3π / N
+    push!(p, x, sin(x))
+end
+```
+
+%% Cell type:code id:c7d2870e tags:
+
+``` julia
+```
+%% Cell type:markdown id:16b28ead tags:
+
+# Installation and Setup
+Please follow the steps 1-3 outlined in README.md to download and install Julia, and to open the notebook 0_Installation.ipynb in a Jupyter notebook.
+
+%% Cell type:markdown id:9161160b-87ff-4b12-bd5a-bca54228672d tags:
+
+## Information about notebooks
+
+Notebooks are tools to interactively run code and display output. They are quite convenient for experimenting with code.
+
+The julia commands are run in a backend julia instance, the browser let's you interact with the notebooks (create new ones, run them, modify them). If the backend program is closed, the browser editor will stop working.
+
+However, if the browser is closed, the backend will keep running. You can get back to it by opening the address:
+[http://localhost:8888](http://localhost:8888)
+
+%% Cell type:markdown id:a915cd2f-dc38-4679-8d79-c2204e2073cf tags:
+
+### Notebooks
+
+Notebooks are files characterized by the extension `.ipynb`. Using the interactive file explorer you can open them.
+
+The notebooks contain code, the output of the code, and can contain additional comments (like these ones). All the material of the course does not contain yet the output of the code, you will get it by running the code first.
+
+The notebooks are automatically saved every now and then, however to make sure they are saved, you can press "Ctrl + S".
+
+%% Cell type:markdown id:93606623-16a4-4263-9906-a79dd3fae22f tags:
+
+### Cells
+
+Notebooks are made up of **cells**. There are two main types: **code** and **markdown**. This is a markdown cell, it is used to display text in a formatted way.
+
+The next is a code cell, it is used to run code and display its output. To run it, click on it and press "Shift + Enter".
+
+%% Cell type:code id:8074a659-e100-49db-b83c-f0738b25cf28 tags:
+
+``` julia
+println("Hello World!")
+```
+
+%% Cell type:markdown id:5fc38ba1-65d0-490f-8c06-4136a7ff1372 tags:
+
+When you click on a code cell, you can also modify its content.
+To modify a markdown cell, you need to double click on it (however this is not required by this course).
+
+It is also possible to transform a code cell in a markdown cell, or the other way around. To do so, go in the top menu, Run, Cell Type.
+
+Finally, new cells can be added by using the `+` symbol in the top menu.
+
+Every time there is an exercise left to the reader, we added an empty code cell.
+
+%% Cell type:markdown id:d3d75953 tags:
+
+## Verifying that everything works
+
+To check if the installation was successfull, run the following cell.
+
+%% Cell type:code id:7bb04662 tags:
+
+``` julia
+using Plots
+
+p = plot(1, xlim=(0, 3π), ylim=(-1.5, 1.5), title="Sine", marker=2)
+N = 100
+@gif for i=1:N
+    x = (i-1) * 3π / N
+    push!(p, x, sin(x))
+end
+```
+
+%% Cell type:code id:c7d2870e tags:
+
+``` julia
+```
--- a/1_Basics_de.ipynb
+++ b/1_Basics_de.ipynb
--- a/1_Basics_en.ipynb
+++ b/1_Basics_en.ipynb
--- a/2_Advanced_Data_Types_de.ipynb
+++ b/2_Advanced_Data_Types_de.ipynb
--- a/2_Advanced_Data_Types_en.ipynb
+++ b/2_Advanced_Data_Types_en.ipynb
--- a/README.md
+++ b/README.md
 # Julia-seminar

-Material für den Julia-Seminar-Kurs.
-Das Kursmaterial wurde aus zwei Quellen angepasst:
+Das Kursmaterial für dieses Julia-Seminar wurde aus zwei Quellen angepasst:
  - der [Kurs](https://github.com/mfherbst/2022-rwth-julia-workshop.git) von Michael Herbst ([MIT Lizenz](https://opensource.org/licenses/mit/)).
  - das Buch [ThinkJulia](https://benlauwens.github.io/ThinkJulia.jl/latest/book.html) von Allen Downey und Ben Lauwens ([Creative Commons Namensnennung-Nicht-kommerziell 3.0 Unported Lizenz](https://creativecommons.org/licenses/by-nc/3.0/deed.de)).

-Eine sehr umfangreiche Spickzettel findest du [hier](https://cheatsheet.juliadocs.org/).
+Einen sehr umfangreichen Spickzettel findest du [hier](https://cheatsheet.juliadocs.org/).

 ## Software und Material
-Der Kurs erfordert verschiedene Dinge: eine funktionierende Installation von [Julia 1.9](https://julialang.org/downloads/), [Jupyter](https://jupyter.org/), [IJulia.jl](https://github.com/JuliaLang/IJulia.jl), das Kursmaterial und verschiedene Abhängigkeiten. Um alles zu herunterzuladen und zu installieren, befolgst Du diese Schritte:
+Der Kurs erfordert verschiedene Dinge: eine funktionierende Installation von [Julia 1.9](https://julialang.org/downloads/), [Jupyter](https://jupyter.org/), [IJulia.jl](https://github.com/JuliaLang/IJulia.jl), das Kursmaterial und verschiedene Abhängigkeiten. Um alles herunterzuladen und zu installieren, befolgst Du diese Schritte:

 ### 1) Julia herunterladen
 Um dem Kurs zu folgen, benötigst du **Julia 1.9**.
@@ -26,28 +25,58 @@ Das [lädt das install.jl-Skript herunter](https://gitlab.mathematik.uni-stuttga

 ### 2) Alles andere (Experten-Version)

-Als Alternative kannst Du auch die folgenden Befehle manuell ausführen (dies setzt voraus, dass `git` und `julia` von der Kommandozeile aus verfügbar sind):
+Alternativ kannst Du auch die folgenden Befehle manuell ausführen (dies setzt voraus, dass `git` und `julia` von der Kommandozeile aus verfügbar sind):
 ```
 git clone https://gitlab.mathematik.uni-stuttgart.de/stammbn/Julia-seminar/
 cd Julia-seminar
 julia install-manual.jl
 ```

-### 3) Starten des Notebooks
-Um das Notebook zu starten, stelle sicher, dass Du Dich im Ordner `Julia-seminar` befindest, und führe dann `julia` aus: Eine interaktive Julia-Befehlszeile wird geöffnet. Führe darin folgenden Befehl aus:
+### 3) Das Notebook starten

+#### Aus der Julia REPL
+
+Um das Notebook zu starten, stelle sicher, dass Du dich im Ordner `Julia-Seminar` befindest, und führe dann `julia` aus: Eine interaktive Julia-Befehlszeile wird geöffnet. Führe darin den folgenden Befehl aus:
+
+```julia
+using Pkg
+Pkg.activate(pwd())
+using IJulia
+notebook(dir=pwd())
+```
+
+und das Notebook wird automatisch in einem Browser geöffnet.
+Navigiere zu den Dateien und öffne das Notebook Nummer 0.
+
+#### Über die Befehlszeile
+
+Alternativ kann man das Notebook auch über die Befehlszeile öffnen:
+
+
+```bash
+julia -L start_notebook.jl
 ```
-using IJulia; notebook(dir=pwd())
+
+### \* Für Benutzer mit mehreren Julia-Versionen
+
+Für Benutzer mit mehreren Julia-Versionen, falls der entsprechende Kernel in Jupyter Notebook nicht gefunden werden kann, führe bitte `installkernel("julia", "--project=@.")` (nur einmal) aus, bevor Du `notebook(dir=pwd())` ausführst, um zuerst den Kernel zu installieren:
+
+```julia
+using Pkg
+Pkg.activate(pwd())
+using IJulia
+installkernel("julia", "--project=@.")
+notebook(dir=pwd())
 ```
-und das Notebook wird automatisch im Browser geöffnet.
+
+Nun sollte man in Jupyter Notebook einen neuen Kernel finden, der mit der aktuellen Julia-Version verknüpft ist und den Namen `julia "Julia-Version"` trägt.

 ### Fehlerbehebung
 Wenn Du auf Probleme stößt, werfe einen Blick auf den [ausgezeichneten Problembehandlungsabschnitt](https://carstenbauer.github.io/WorkshopWizard.jl/dev/troubleshooting/) aus dem WorkshopWizard-Paket von Carsten Bauer (das von `install.jl` verwendet wird).

 # Julia-seminar

-Material for the Julia seminar course.
-The course material is adapted from two sources:
+Material for the Julia seminar course which is adapted from two sources:
  - the [course](https://github.com/mfherbst/2022-rwth-julia-workshop.git) from Michael Herbst ([MIT license](https://opensource.org/license/mit/)).
  - the book [ThinkJulia](https://benlauwens.github.io/ThinkJulia.jl/latest/book.html) from Allen Downey and Ben Lauwens ([Creative Commons Attribution-NonCommercial 3.0 Unported license](https://creativecommons.org/licenses/by-nc/3.0/deed.en)).

@@ -80,47 +109,44 @@ julia install-manual.jl
 ```

 ### 3) Starting the notebook
+
+#### From Julia REPL
+
 To start the notebook make sure to be in the folder `Julia-seminar` and then run `julia`: an interactive Julia command line will open. In there run this command

+```julia
+using Pkg
+Pkg.activate(pwd())
+using IJulia
+notebook(dir=pwd())
 ```
-using IJulia; notebook(dir=pwd())
-```
-and the notebook will automatically open in a browser.

+and the notebook will automatically open in a browser.
 Navigate the files and open notebook number 0.

-### Troubleshooting
-If you are facing issues, check out
-the [great troubleshooting section](https://carstenbauer.github.io/WorkshopWizard.jl/dev/troubleshooting/)
-from the WorkshopWizard package by Carsten Bauer (which is being used by `install.jl`).
-
-## For Developers: Setting Up `pre-commit`
-
-[`pre-commit`](https://pre-commit.com/) is a framework that helps to manage and maintain pre-commit hooks to ensure that your code adheres to a consistent style, prevents errors, and adheres to other quality assurance checks.
-
-1. **Install `pre-commit`:**
-   To ensure smooth development, install `pre-commit` using pip by running the following command:
+#### From command line

-   ```bash
-   pip install pre-commit
-   ```
+Alternatively, one can open the notebook from the command line:

-   For more information and installation options, visit the [`pre-commit`](https://pre-commit.com/) website.
-
-2. **Navigate to the Project Directory:**
-    Change into the project directory, i.e., `julia-seminar` by running:
+```bash
+julia -L start_notebook.jl
+```

-    ```bash
-    cd julia-seminar
-    ```
+### \* For users with multiple Julia versions

-3. **Install Hooks:**
-    Install the git hooks by executing:
+For users with multiple Julia versions, if the corresponding kernel cannot be found in Jupyter Notebook, please run `installkernel("julia", "--project=@.")` (only once) before executing `notebook(dir=pwd())` to first install the kernel:

-    ```bash
-    pre-commit install
-    ```
+```julia
+using Pkg
+Pkg.activate(pwd())
+using IJulia
+installkernel("julia", "--project=@.")
+notebook(dir=pwd())
+```

-    This command installs the pre-commit script alongside existing git hooks.
+Now, one should find a new kernel related to the current Julia version, named `julia "Julia-version"`, in Jupyter Notebook.

-Once the pre-commit hook is installed, it will automatically check your code for any issues before each commit. If the checks do not pass, you will be prompted to fix them before proceeding.
+### Troubleshooting
+If you are facing issues, check out
+the [great troubleshooting section](https://carstenbauer.github.io/WorkshopWizard.jl/dev/troubleshooting/)
+from the WorkshopWizard package by Carsten Bauer (which is being used by `install.jl`).
--- a/0_Installation.ipynb
+++ b/0_Installation.ipynb
 %% Cell type:markdown id:16b28ead tags:

 # Installation and Setup
+Please follow the steps 1-3 outlined in README.md to download and install Julia, and to open the notebook 0_Installation.ipynb in a Jupyter notebook.

 %% Cell type:markdown id:31ac33c0-18a9-4cfa-8e04-3ee1a0c909eb tags:

 # Installation und Einrichtung
-
-%% Cell type:markdown id:8829affd tags:
-
-## Software and material
-The course requires various things: a working installation of [Julia 1.9](https://julialang.org/downloads/), [Jupyter](https://jupyter.org/), [IJulia.jl](https://github.com/JuliaLang/IJulia.jl), the course material and various dependencies. To get everything follow these steps:
-
-### 1) Getting Julia
-For following the course you will need **Julia 1.9**.
-Julia can be easily obtained in binary form from [Julia downloads](https://julialang.org/downloads/).
-
-### 2) Getting all the rest
-
-To get the remaining files and dependencies start up `julia` and in the resulting REPL shell, copy and paste the following:
-```julia
-import Downloads
-script = Downloads.download("https://gitlab.mathematik.uni-stuttgart.de/stammbn/julia-seminar/-/raw/main/install.jl?ref_type=heads")
-include(script)
-```
-This [downloads the install.jl script](https://gitlab.mathematik.uni-stuttgart.de/stammbn/julia-seminar/-/raw/main/install.jl?ref_type=heads) and runs it from julia.
-
-### 2) Getting all the rest (expert version)
-
-As an alternative you can also also run the following commands manually (this requires to have `git` and `julia` available from the commandline):
-```
-git clone https://gitlab.mathematik.uni-stuttgart.de/stammbn/Julia-seminar/
-cd Julia-seminar
-julia install-manual.jl
-```
-
-### 3) Starting the notebook
-To start the notebook make sure to be in the folder `Julia-seminar` and then run `julia`: an interactive Julia command line will open. In there run this command
-
-```
-using IJulia; notebook(dir=pwd())
-```
-and the notebook will automatically open in a browser.
-
-### Troubleshooting
-If you are facing issues, check out
-the [great troubleshooting section](https://carstenbauer.github.io/WorkshopWizard.jl/dev/troubleshooting/)
-from the WorkshopWizard package by Carsten Bauer (which is being used by `install.jl`).
-
-%% Cell type:markdown id:b495d658-ab7a-41fb-819e-0fef02c10772 tags:
-
-## Software und Material
-Der Kurs erfordert verschiedene Dinge: eine funktionierende Installation von [Julia 1.9](https://julialang.org/downloads/), [Jupyter](https://jupyter.org/), [IJulia.jl](https://github.com/JuliaLang/IJulia.jl), das Kursmaterial und verschiedene Abhängigkeiten. Um alles zu herunterzuladen und zu installieren, befolgst Du diese Schritte:
-
-### 1) Julia herunterladen
-Um dem Kurs zu folgen, benötigst du **Julia 1.9**.
-Julia kann leicht in binärer Form von den [Julia-Downloads](https://julialang.org/downloads/) bezogen werden.
-
-### 2) Alles andere
-
-Um die verbleibenden Dateien und Abhängigkeiten zu erhalten, starte `julia` und kopiere im resultierenden REPL-Shell folgenden Code:
-```julia
-import Downloads
-script = Downloads.download("https://gitlab.mathematik.uni-stuttgart.de/stammbn/julia-seminar/-/raw/main/install.jl?ref_type=heads")
-include(script)
-```
-Das [lädt das install.jl-Skript herunter](https://gitlab.mathematik.uni-stuttgart.de/stammbn/julia-seminar/-/raw/main/install.jl?ref_type=heads) und führt es in Julia aus.
-
-### 2) Alles andere (Experten-Version)
-
-Als Alternative kannst Du auch die folgenden Befehle manuell ausführen (dies setzt voraus, dass `git` und `julia` von der Kommandozeile aus verfügbar sind):
-```
-git clone https://gitlab.mathematik.uni-stuttgart.de/stammbn/Julia-seminar/
-cd Julia-seminar
-julia install-manual.jl
-```
-
-### 3) Starten des Notebooks
-Um das Notebook zu starten, stelle sicher, dass Du Dich im Ordner `Julia-seminar` befindest, und führe dann `julia` aus: Eine interaktive Julia-Befehlszeile wird geöffnet. Führe darin folgenden Befehl aus:
-
-```
-using IJulia; notebook(dir=pwd())
-```
-und das Notebook wird automatisch im Browser geöffnet.
-
-### Fehlerbehebung
-Wenn Du auf Probleme stößt, werfe einen Blick auf den [ausgezeichneten Problembehandlungsabschnitt](https://carstenbauer.github.io/WorkshopWizard.jl/dev/troubleshooting/) aus dem WorkshopWizard-Paket von Carsten Bauer (das von `install.jl` verwendet wird).
+Bitte befolge die in README.md beschriebenen Schritte 1-3, um Julia herunterzuladen und zu installieren, und das Notebook 0_Installation.ipynb in einen Jupyter-notebook zu öffnen.

 %% Cell type:markdown id:9161160b-87ff-4b12-bd5a-bca54228672d tags:

 ## Information about notebooks

 Notebooks are tools to interactively run code and display output. They are quite convenient for experimenting with code.

 The julia commands are run in a backend julia instance, the browser let's you interact with the notebooks (create new ones, run them, modify them). If the backend program is closed, the browser editor will stop working.

 However, if the browser is closed, the backend will keep running. You can get back to it by opening the address:
 [http://localhost:8888](http://localhost:8888)

 %% Cell type:markdown id:ff3c6951-2bc8-42b9-b2f4-acbb473300c6 tags:

 ## Informationen zu Notebooks

 Notebooks sind Werkzeuge, um interaktiven Code auszuführen und die Ausgabe anzuzeigen. Sie sind sehr praktisch, um mit Code zu experimentieren und eine Programmiersprache neu zu lernen.

 Die Julia-Befehle werden in einer separaten Julia-Instanz im Hintergrund ausgeführt, der Browser ermöglicht die Interaktion mit den Notebooks (das Erstellen neuer Notebooks, das Ausführen und Modifizieren von ihnen). Beachte dass der Browser-Editor nicht mehr funktioniert wenn das Backend-Programm geschlossen wird.

 Wenn jedoch der Browser geschlossen wird, läuft das Backend weiter. Du kannst darauf zugreifen, indem Du die Adresse öffnest:
 [http://localhost:8888](http://localhost:8888)

 %% Cell type:markdown id:a915cd2f-dc38-4679-8d79-c2204e2073cf tags:

 ### Notebooks

 Notebooks are files characterized by the extension `.ipynb`. Using the interactive file explorer you can open them.

 The notebooks contain code, the output of the code, and can contain additional comments (like these ones). All the material of the course does not contain yet the output of the code, you will get it by running the code first.

 The notebooks are automatically saved every now and then, however to make sure they are saved, you can press "Ctrl + S".

 %% Cell type:markdown id:c974b7c0-119c-4223-ad80-dce5a3ceead3 tags:

 ### Notebooks

 Notebooks sind Dateien, die durch die Erweiterung `.ipynb` gekennzeichnet sind. Mit dem interaktiven Datei-Explorer kannst Du sie öffnen.

 Die Notebooks enthalten Code, die Ausgabe des Codes und können zusätzliche Kommentare enthalten (wie diese hier). Das gesamte Material des Kurses enthält noch nicht die Ausgabe des Codes, Du erhälst sie, indem Du den Code zuerst ausführst.

 Die Notebooks werden automatisch alle paar Minuten gespeichert, um jedoch sicherzustellen, dass sie gespeichert sind, kannst Du "Strg + S" drücken.

 %% Cell type:markdown id:93606623-16a4-4263-9906-a79dd3fae22f tags:

 ### Cells

 Notebooks are made up of **cells**. There are two main types: **code** and **markdown**. This is a markdown cell, it is used to display text in a formatted way.

 The next is a code cell, it is used to run code and display its output. To run it, click on it and press "Shift + Enter".

 %% Cell type:markdown id:8c98e5f5-5a92-415a-b9ec-865972d45b6f tags:

 ### Zellen

 Notebooks bestehen aus **Zellen**. Es gibt zwei Hauptarten: **Code** und **Markdown**. Dies ist eine Markdown-Zelle und wird verwendet, um Text auf eine formatierte Weise anzuzeigen.

 Die nächste ist eine Code-Zelle und wird verwendet, um Code auszuführen und dessen Ausgabe anzuzeigen. Um sie auszuführen, klicken Sie darauf und drücken Sie Shift + Enter.

 %% Cell type:code id:8074a659-e100-49db-b83c-f0738b25cf28 tags:

 ``` julia
 println("Hello World!")
 ```

 %% Cell type:markdown id:5fc38ba1-65d0-490f-8c06-4136a7ff1372 tags:

 When you click on a code cell, you can also modify its content.
 To modify a markdown cell, you need to double click on it (however this is not required by this course).

 It is also possible to transform a code cell in a markdown cell, or the other way around. To do so, go in the top menu, Run, Cell Type.

 Finally, new cells can be added by using the `+` symbol in the top menu.

 Every time there is an exercise left to the reader, we added an empty code cell.

 %% Cell type:markdown id:192dac00-072c-4699-bd06-9af6ae4e3055 tags:

 Wenn Du auf eine Code-Zelle klickst, kannst Du auch deren Inhalt ändern. Um eine Markdown-Zelle zu ändern, musst Du darauf doppelklicken (dies ist jedoch für diesen Kurs nicht erforderlich).

 Es ist auch möglich, eine Code-Zelle in eine Markdown-Zelle oder umgekehrt zu ändern. Gehe dazu im oberen Menü auf Ausführen, Zellentyp.

 Schließlich können neue Zellen hinzugefügt werden, indem Du das `+`-Symbol im oberen Menü verwendest.

-Jedes Mal, wenn eine Übung für den Leser übrig bleibt, haben wir eine leere Code-Zelle hinzugefügt.
+Jedes Mal, wenn es eine Übung für den Leser gibt, haben wir eine leere Code-Zelle hinzugefügt.

 %% Cell type:markdown id:d3d75953 tags:

 ## Verifying that everything works

 To check if the installation was successfull, run the following cell.

 %% Cell type:markdown id:e7730114-5064-46d1-b724-e92277ff2f90 tags:

 ## Überprüfen, ob alles funktioniert

 Um zu überprüfen, ob die Installation erfolgreich war, führe die folgende Zelle aus.

 %% Cell type:code id:7bb04662 tags:

 ``` julia
 using Plots

 p = plot(1, xlim=(0, 3π), ylim=(-1.5, 1.5), title="Sine", marker=2)
 N = 100
 @gif for i=1:N
    x = (i-1) * 3π / N
    push!(p, x, sin(x))
 end
 ```

 %% Cell type:code id:c7d2870e tags:

 ``` julia
 ```

 %% Cell type:markdown id:16b28ead tags:

 # Installation and Setup
+Please follow the steps 1-3 outlined in README.md to download and install Julia, and to open the notebook 0_Installation.ipynb in a Jupyter notebook.

 %% Cell type:markdown id:31ac33c0-18a9-4cfa-8e04-3ee1a0c909eb tags:

 # Installation und Einrichtung
-
-%% Cell type:markdown id:8829affd tags:
-
-## Software and material
-The course requires various things: a working installation of [Julia 1.9](https://julialang.org/downloads/), [Jupyter](https://jupyter.org/), [IJulia.jl](https://github.com/JuliaLang/IJulia.jl), the course material and various dependencies. To get everything follow these steps:
-
-### 1) Getting Julia
-For following the course you will need **Julia 1.9**.
-Julia can be easily obtained in binary form from [Julia downloads](https://julialang.org/downloads/).
-
-### 2) Getting all the rest
-
-To get the remaining files and dependencies start up `julia` and in the resulting REPL shell, copy and paste the following:
-```julia
-import Downloads
-script = Downloads.download("https://gitlab.mathematik.uni-stuttgart.de/stammbn/julia-seminar/-/raw/main/install.jl?ref_type=heads")
-include(script)
-```
-This [downloads the install.jl script](https://gitlab.mathematik.uni-stuttgart.de/stammbn/julia-seminar/-/raw/main/install.jl?ref_type=heads) and runs it from julia.
-
-### 2) Getting all the rest (expert version)
-
-As an alternative you can also also run the following commands manually (this requires to have `git` and `julia` available from the commandline):
-```
-git clone https://gitlab.mathematik.uni-stuttgart.de/stammbn/Julia-seminar/
-cd Julia-seminar
-julia install-manual.jl
-```
-
-### 3) Starting the notebook
-To start the notebook make sure to be in the folder `Julia-seminar` and then run `julia`: an interactive Julia command line will open. In there run this command
-
-```
-using IJulia; notebook(dir=pwd())
-```
-and the notebook will automatically open in a browser.
-
-### Troubleshooting
-If you are facing issues, check out
-the [great troubleshooting section](https://carstenbauer.github.io/WorkshopWizard.jl/dev/troubleshooting/)
-from the WorkshopWizard package by Carsten Bauer (which is being used by `install.jl`).
-
-%% Cell type:markdown id:b495d658-ab7a-41fb-819e-0fef02c10772 tags:
-
-## Software und Material
-Der Kurs erfordert verschiedene Dinge: eine funktionierende Installation von [Julia 1.9](https://julialang.org/downloads/), [Jupyter](https://jupyter.org/), [IJulia.jl](https://github.com/JuliaLang/IJulia.jl), das Kursmaterial und verschiedene Abhängigkeiten. Um alles zu herunterzuladen und zu installieren, befolgst Du diese Schritte:
-
-### 1) Julia herunterladen
-Um dem Kurs zu folgen, benötigst du **Julia 1.9**.
-Julia kann leicht in binärer Form von den [Julia-Downloads](https://julialang.org/downloads/) bezogen werden.
-
-### 2) Alles andere
-
-Um die verbleibenden Dateien und Abhängigkeiten zu erhalten, starte `julia` und kopiere im resultierenden REPL-Shell folgenden Code:
-```julia
-import Downloads
-script = Downloads.download("https://gitlab.mathematik.uni-stuttgart.de/stammbn/julia-seminar/-/raw/main/install.jl?ref_type=heads")
-include(script)
-```
-Das [lädt das install.jl-Skript herunter](https://gitlab.mathematik.uni-stuttgart.de/stammbn/julia-seminar/-/raw/main/install.jl?ref_type=heads) und führt es in Julia aus.
-
-### 2) Alles andere (Experten-Version)
-
-Als Alternative kannst Du auch die folgenden Befehle manuell ausführen (dies setzt voraus, dass `git` und `julia` von der Kommandozeile aus verfügbar sind):
-```
-git clone https://gitlab.mathematik.uni-stuttgart.de/stammbn/Julia-seminar/
-cd Julia-seminar
-julia install-manual.jl
-```
-
-### 3) Starten des Notebooks
-Um das Notebook zu starten, stelle sicher, dass Du Dich im Ordner `Julia-seminar` befindest, und führe dann `julia` aus: Eine interaktive Julia-Befehlszeile wird geöffnet. Führe darin folgenden Befehl aus:
-
-```
-using IJulia; notebook(dir=pwd())
-```
-und das Notebook wird automatisch im Browser geöffnet.
-
-### Fehlerbehebung
-Wenn Du auf Probleme stößt, werfe einen Blick auf den [ausgezeichneten Problembehandlungsabschnitt](https://carstenbauer.github.io/WorkshopWizard.jl/dev/troubleshooting/) aus dem WorkshopWizard-Paket von Carsten Bauer (das von `install.jl` verwendet wird).
+Bitte befolge die in README.md beschriebenen Schritte 1-3, um Julia herunterzuladen und zu installieren, und das Notebook 0_Installation.ipynb in einen Jupyter-notebook zu öffnen.

 %% Cell type:markdown id:9161160b-87ff-4b12-bd5a-bca54228672d tags:

 ## Information about notebooks

 Notebooks are tools to interactively run code and display output. They are quite convenient for experimenting with code.

 The julia commands are run in a backend julia instance, the browser let's you interact with the notebooks (create new ones, run them, modify them). If the backend program is closed, the browser editor will stop working.

 However, if the browser is closed, the backend will keep running. You can get back to it by opening the address:
 [http://localhost:8888](http://localhost:8888)

 %% Cell type:markdown id:ff3c6951-2bc8-42b9-b2f4-acbb473300c6 tags:

 ## Informationen zu Notebooks

 Notebooks sind Werkzeuge, um interaktiven Code auszuführen und die Ausgabe anzuzeigen. Sie sind sehr praktisch, um mit Code zu experimentieren und eine Programmiersprache neu zu lernen.

 Die Julia-Befehle werden in einer separaten Julia-Instanz im Hintergrund ausgeführt, der Browser ermöglicht die Interaktion mit den Notebooks (das Erstellen neuer Notebooks, das Ausführen und Modifizieren von ihnen). Beachte dass der Browser-Editor nicht mehr funktioniert wenn das Backend-Programm geschlossen wird.

 Wenn jedoch der Browser geschlossen wird, läuft das Backend weiter. Du kannst darauf zugreifen, indem Du die Adresse öffnest:
 [http://localhost:8888](http://localhost:8888)

 %% Cell type:markdown id:a915cd2f-dc38-4679-8d79-c2204e2073cf tags:

 ### Notebooks

 Notebooks are files characterized by the extension `.ipynb`. Using the interactive file explorer you can open them.

 The notebooks contain code, the output of the code, and can contain additional comments (like these ones). All the material of the course does not contain yet the output of the code, you will get it by running the code first.

 The notebooks are automatically saved every now and then, however to make sure they are saved, you can press "Ctrl + S".

 %% Cell type:markdown id:c974b7c0-119c-4223-ad80-dce5a3ceead3 tags:

 ### Notebooks

 Notebooks sind Dateien, die durch die Erweiterung `.ipynb` gekennzeichnet sind. Mit dem interaktiven Datei-Explorer kannst Du sie öffnen.

 Die Notebooks enthalten Code, die Ausgabe des Codes und können zusätzliche Kommentare enthalten (wie diese hier). Das gesamte Material des Kurses enthält noch nicht die Ausgabe des Codes, Du erhälst sie, indem Du den Code zuerst ausführst.

 Die Notebooks werden automatisch alle paar Minuten gespeichert, um jedoch sicherzustellen, dass sie gespeichert sind, kannst Du "Strg + S" drücken.

 %% Cell type:markdown id:93606623-16a4-4263-9906-a79dd3fae22f tags:

 ### Cells

 Notebooks are made up of **cells**. There are two main types: **code** and **markdown**. This is a markdown cell, it is used to display text in a formatted way.

 The next is a code cell, it is used to run code and display its output. To run it, click on it and press "Shift + Enter".

 %% Cell type:markdown id:8c98e5f5-5a92-415a-b9ec-865972d45b6f tags:

 ### Zellen

 Notebooks bestehen aus **Zellen**. Es gibt zwei Hauptarten: **Code** und **Markdown**. Dies ist eine Markdown-Zelle und wird verwendet, um Text auf eine formatierte Weise anzuzeigen.

 Die nächste ist eine Code-Zelle und wird verwendet, um Code auszuführen und dessen Ausgabe anzuzeigen. Um sie auszuführen, klicken Sie darauf und drücken Sie Shift + Enter.

 %% Cell type:code id:8074a659-e100-49db-b83c-f0738b25cf28 tags:

 ``` julia
 println("Hello World!")
 ```

 %% Cell type:markdown id:5fc38ba1-65d0-490f-8c06-4136a7ff1372 tags:

 When you click on a code cell, you can also modify its content.
 To modify a markdown cell, you need to double click on it (however this is not required by this course).

 It is also possible to transform a code cell in a markdown cell, or the other way around. To do so, go in the top menu, Run, Cell Type.

 Finally, new cells can be added by using the `+` symbol in the top menu.

 Every time there is an exercise left to the reader, we added an empty code cell.

 %% Cell type:markdown id:192dac00-072c-4699-bd06-9af6ae4e3055 tags:

 Wenn Du auf eine Code-Zelle klickst, kannst Du auch deren Inhalt ändern. Um eine Markdown-Zelle zu ändern, musst Du darauf doppelklicken (dies ist jedoch für diesen Kurs nicht erforderlich).

 Es ist auch möglich, eine Code-Zelle in eine Markdown-Zelle oder umgekehrt zu ändern. Gehe dazu im oberen Menü auf Ausführen, Zellentyp.

 Schließlich können neue Zellen hinzugefügt werden, indem Du das `+`-Symbol im oberen Menü verwendest.

-Jedes Mal, wenn eine Übung für den Leser übrig bleibt, haben wir eine leere Code-Zelle hinzugefügt.
+Jedes Mal, wenn es eine Übung für den Leser gibt, haben wir eine leere Code-Zelle hinzugefügt.

 %% Cell type:markdown id:d3d75953 tags:

 ## Verifying that everything works

 To check if the installation was successfull, run the following cell.

 %% Cell type:markdown id:e7730114-5064-46d1-b724-e92277ff2f90 tags:

 ## Überprüfen, ob alles funktioniert

 Um zu überprüfen, ob die Installation erfolgreich war, führe die folgende Zelle aus.

 %% Cell type:code id:7bb04662 tags:

 ``` julia
 using Plots

 p = plot(1, xlim=(0, 3π), ylim=(-1.5, 1.5), title="Sine", marker=2)
 N = 100
 @gif for i=1:N
    x = (i-1) * 3π / N
    push!(p, x, sin(x))
 end
 ```

 %% Cell type:code id:c7d2870e tags:

 ``` julia
 ```

--- a/1_Basics.ipynb
+++ b/1_Basics.ipynb
 %% Cell type:markdown id:7aad3586-d57e-4000-8688-aa5b53d48416 tags:

 # Basics

 %% Cell type:markdown id:aff6c2f6-3d10-412e-82aa-c199c98edbd7 tags:

 # Grundlagen

 %% Cell type:markdown id:bf904dbe-3197-4a91-bbb8-05e1c7f7dfee tags:

 ## Variables and elementary types

 Defining variables in Julia works like in most languages:

 %% Cell type:markdown id:3be02b91-9619-4cfd-b463-2add42babbcc tags:

 ## Variablen und elementare Datentypen

 Das Definieren von Variablen in Julia funktioniert wie in den meisten Sprachen:

 %% Cell type:code id:3c44023b-06c9-4420-9af3-da2ec37b02da tags:

 ``` julia
 int = 4      # An integer
 ```

 %% Cell type:code id:b2f9ba27-bf65-40d8-b0ac-e3d86c99dd40 tags:

 ``` julia
 str = "Hi"   # A string
 ```

 %% Cell type:code id:87a83355-5088-47d3-b698-2c6902aaa6a0 tags:

 ``` julia
 float = 1.2  # A floating-point number
 ```

 %% Cell type:code id:597523f1-4041-4fc6-9be2-2c94a93fd633 tags:

 ``` julia
 bool = true  # A boolean (also false)
 ```

 %% Cell type:markdown id:0c538bdb-f995-4589-bee7-0989c922090c tags:

 The type is automatically inferred:

 %% Cell type:markdown id:816bc593-70cc-4e0f-b461-c9022d9587f6 tags:

 Der Typ wird automatisch abgeleitet:

 %% Cell type:code id:b80c6777-3dea-4f45-98b3-0a3eee196183 tags:

 ``` julia
 typeof(int)
 ```

 %% Cell type:code id:1fb6cbd2-871f-40a4-ae84-e7ee46e75a61 tags:

 ``` julia
 typeof(str)
 ```

 %% Cell type:code id:a16a6f08-f19a-42e0-baac-aaa88ebba1af tags:

 ``` julia
 typeof(float)
 ```

 %% Cell type:markdown id:09d035eb-22aa-49f5-9fd1-a5b16973f386 tags:

 Julia supports a large range of integer and floating-point types out of the box, for example:

 %% Cell type:markdown id:d5e586cc-874a-46d5-9c7c-d1136d73492e tags:

 Julia unterstützt von Haus aus eine große Bandbreite von Ganzzahl- und Gleitkommazahlentypen, zum Beispiel:

 %% Cell type:code id:88f24b01-f4a5-4030-af2c-a5d30223d047 tags:

 ``` julia
 x = UInt8(1)              # 8-bit wide unsigned integer
 y = Int32(-1)             # 32-bit wide signed integer
 z = Float32(0.2)          # single precision
 α = Float16(-1.0)         # half precision
 β = ComplexF64(2. + 8im)  # Complex number (composed of two Float64)
 ```

 %% Cell type:markdown id:a615bbc0-732e-461f-8c4c-a972fa2be731 tags:

 If you give a variable an illegal name, you get a syntax error:

 %% Cell type:markdown id:bf9f6efc-6b47-415c-8504-35a2b1a80f18 tags:

 Wenn Sie einer Variable einen ungültigen Namen geben, erhalten Sie einen Syntaxfehler:

 %% Cell type:code id:1ca20515-6d66-40c3-84f1-2e24ece096cd tags:

 ``` julia
 1test = "hello"
 ```

 %% Cell type:code id:2c61f59e-2c2f-4049-8624-35e0712b2cf1 tags:

 ``` julia
 more@ = 1000000
 ```

 %% Cell type:code id:85040b19-b0a9-4baa-8748-5ea62f8b5633 tags:

 ``` julia
 struct = "another illegale variable name"
 ```

 %% Cell type:markdown id:cc36688b-c983-43f8-8bdf-9b82aae59909 tags:

 It turns out that `struct` is one of Julia’s keywords, and they cannot be used as variable names.

 - For more Julia's keywords, see [https://docs.julialang.org/en/v1/base/base/#Keywords](https://docs.julialang.org/en/v1/base/base/#Keywords).
 - For more details on `Variable`, see [https://docs.julialang.org/en/v1/manual/variables/](https://docs.julialang.org/en/v1/manual/variables/).

 %% Cell type:markdown id:2e5659b9-9e66-448a-a768-23d7085d7dac tags:

 Es stellt sich heraus, dass `struct` eines der Schlüsselwörter von Julia ist und nicht als Variablennamen verwendet werden kann.

 - Für weitere Schlüsselwörter von Julia, siehe [https://docs.julialang.org/en/v1/base/base/#Keywords](https://docs.julialang.org/en/v1/base/base/#Keywords).
- Für weitere Details über `Variable`, siehe [https://docs.julialang.org/en/v1/manual/variables/](https://docs.julialang.org/en/v1/manual/variables/).
+- Für weitere Details über `Variabeln`, siehe [https://docs.julialang.org/en/v1/manual/variables/](https://docs.julialang.org/en/v1/manual/variables/).

 %% Cell type:markdown id:de111dbe-f7ed-4e1a-8ec0-c5e65bd63bbf tags:

 ### Strings

 %% Cell type:markdown id:e099c88a-5848-4730-be7d-b7651bc3db29 tags:

 ### Zeichenketten

 %% Cell type:markdown id:1b3531e9-33db-4c51-b394-c1def6621519 tags:

 In general, you can’t perform mathematical operations on strings, even if the strings look like numbers, so the following are illegal:

 %% Cell type:markdown id:925cbca6-cce3-4084-96a2-fe0a5acdb1e9 tags:

 Im Allgemeinen können Sie mathematische Operationen nicht auf Zeichenketten ausführen, auch wenn die Zeichenketten wie Zahlen aussehen. Daher sind die folgenden Operationen nicht erlaubt:

 %% Cell type:code id:246f1db8-d734-413d-9237-b2434e071914 tags:

 ``` julia
 "2" - "1"
 "eggs" / "easy"
 "third" + "a charm"
 ```

 %% Cell type:markdown id:c94f1187-67f8-473e-910c-2eb145ed59dd tags:

 But there are two exceptions, * and ^.

 %% Cell type:markdown id:c2c39aa8-d98b-42dd-8e7c-09463f78d22c tags:

 Es gibt jedoch zwei Ausnahmen, * und ^.

 %% Cell type:code id:b3a0f6e1-e28b-4fb7-baa3-bb003de3dc24 tags:

 ``` julia
 "Hello " * "world"
 ```

 %% Cell type:code id:0c963c3c-47c7-4805-8be6-621b72fdb62e tags:

 ``` julia
 "hello! "^5
 ```

 %% Cell type:markdown id:362f9d04-eff9-4594-aa22-a9c8d601fb1e tags:

 For more details: [https://docs.julialang.org/en/v1/manual/strings/](https://docs.julialang.org/en/v1/manual/strings/).

 %% Cell type:markdown id:7b7ff4e3 tags:

 Für weitere Details: [https://docs.julialang.org/en/v1/manual/strings/](https://docs.julialang.org/en/v1/manual/strings/).

 %% Cell type:markdown id:61ff8194-669c-4ece-ba31-44e88ed808ac tags:

 ### Exercises

 %% Cell type:markdown id:43fe0add-b90d-4ed4-862e-37a4361d2354 tags:

 ### Übungen

 %% Cell type:markdown id:e0aecc9c-e77f-449e-8aff-e1ffcf5d7833 tags:

 Practice using Julia as a calculator:
  - The volume of a sphere with radius r is 4/3πr^3. What is the volume of a sphere with radius 5?

 %% Cell type:markdown id:3e392c67-df83-49fc-831d-12e157e4a85c tags:

 Üben Sie, Julia als Taschenrechner zu verwenden:

  - Die Formel für das Volumen einer Kugel mit Radius r lautet 4/3πr^3. Was ist das Volumen einer Kugel mit Radius 5?

 %% Cell type:code id:fc538246-418c-4ebe-b487-81feba4383c8 tags:

 ``` julia
+
 ```

 %% Cell type:markdown id:10f1604d-8e81-4f96-8b6f-95753f0b5c4f tags:

  - Suppose the cover price of a book is € 24.95, but bookstores get a 40 % discount. Shipping costs € 3 for the first copy and 75 cents for each additional copy. What is the total wholesale cost for 60 copies?

 %% Cell type:markdown id:32f7a6f1-6a19-4ebe-bd1b-846f861dc721 tags:

 - Angenommen, der Listenpreis eines Buches beträgt € 24,95, aber Buchhandlungen erhalten einen Rabatt von 40 %. Der Versand kostet € 3 für das erste Exemplar und 75 Cent für jedes zusätzliche Exemplar. Was sind die gesamten Großhandelskosten für 60 Exemplare?

 %% Cell type:code id:bd4150cf-005a-4087-aa92-5f4b18e4d197 tags:

 ``` julia
 ```

 %% Cell type:markdown id:dc9cddb9-717d-4ba0-b478-beb00afc46c8 tags:

 ## Conditionals and Boolean Expressions

 A boolean expression is an expression that is either true or false. The following examples use the operator ==, which compares two operands and produces true if they are equal and false otherwise:

 %% Cell type:markdown id:53e26ee8-c10d-42e4-bbb9-cb5f696139ba tags:

 ## Bedingungen und boolesche Ausdrücke

 Ein boolescher Ausdruck ist ein Ausdruck, der entweder wahr oder falsch ist. Die folgenden Beispiele verwenden den Operator ==, der zwei Operanden vergleicht und true zurückgibt, wenn sie gleich sind, andernfalls false:

 %% Cell type:code id:7de4ffe9-4730-47dd-b074-1525bf9937b1 tags:

 ``` julia
 5 == 5
 ```

 %% Cell type:code id:c02939dd-6f25-4916-8394-a5f95d0200df tags:

 ``` julia
 5 == 6
 ```

 %% Cell type:markdown id:9a108e63-7d58-489d-b7ef-49629c879d29 tags:

 The == operator is one of the relational operators; the others are:

 %% Cell type:markdown id:4722b7b7-3f80-454f-bd8b-f67912105f79 tags:

 Der == Operator ist einer der relationalen Operatoren; die anderen sind:

 %% Cell type:code id:b59cd314-fd03-4609-ac1b-7329a2c3cc38 tags:

 ``` julia
 x = 3; y = 4
 x != y               # x is not equal to y
 x ≠ y                # (to get the ≠ symbol, type \ne and then press TAB)
 x > y                # x is greater than y
 x < y                # x is less than y
 x >= y               # x is greater than or equal to y
 x ≥ y                # (to get the ≥ symbol, type \ge and then press TAB)
 x <= y               # x is less than or equal to y
 x ≤ y                # (to get the ≤ symbol, type \le and then press TAB)
 ```

 %% Cell type:markdown id:15e20f55-1a43-4d0d-94bc-d2de0ee2fe8c tags:

 There are three logical operators: && (and), || (or), and ! (not). The semantics (meaning) of these operators is similar to their meaning in English. For example, x > 0 && x < 10 is true only if x is greater than 0 and less than 10.

 %% Cell type:markdown id:01c9f186-294f-4659-bc32-cee3b6ff4f40 tags:

 Es gibt drei logische Operatoren: && (und), || (oder) und ! (nicht). Die Bedeutung dieser Operatoren entspricht weitgehend ihrer Bedeutung im Englischen. Zum Beispiel ist x > 0 && x < 10 nur dann wahr, wenn x größer als 0 und kleiner als 10 ist.

 %% Cell type:code id:d1e6e2ce-bb0c-4776-80b6-22ceb9c68397 tags:

 ``` julia
 x = 4
 x > 0 && x < 10
 ```

 %% Cell type:markdown id:da591654-6360-4f56-956b-07493d1d2247 tags:

 It is also worth mentioning that in combined logical expression not all conditions are necessarily executed.

 %% Cell type:markdown id:857cde91-3430-480c-9f24-bb9c465248d9 tags:

 Es ist auch erwähnenswert, dass bei kombinierten logischen Ausdrücken nicht alle Bedingungen notwendigerweise ausgeführt werden.

 %% Cell type:code id:e92abf7b-5414-4aee-abaf-a4e52b1c06d3 tags:

 ``` julia
 true  || println("The RHS of || is only run")
 false || println("if the LHS is false")
 ```

 %% Cell type:code id:c8a9d8ac-5378-4ebb-810b-9ae3194d670c tags:

 ``` julia
 iseven(3) && println("The RHS of || is only run")
 isodd(3)  && println("if the LHS is true")
 ```

 %% Cell type:markdown id:be0c63e0-35a9-43c7-9b30-d04072ee6904 tags:

 Finally, the ! operator negates a boolean expression, so !(x > y) is true if x > y is false, that is, if x is less than or equal to y.

 %% Cell type:markdown id:d8db49a8-6c6c-4abf-9a5b-5d27765ab1c7 tags:

 Schließlich kehrt der ! Operator einen booleschen Ausdruck um, sodass !(x > y) wahr ist, wenn x > y falsch ist, das heißt, wenn x kleiner oder gleich y ist.

 %% Cell type:code id:e43ab736-03e2-4040-a15e-48305037ba23 tags:

 ``` julia
 x = 4
 !(x > 0 && x < 10)
 ```

 %% Cell type:markdown id:7064ae20-6d63-40fc-85c5-080ace54e7b6 tags:

 Unsurprisingly Julia has the standard conditionals.

 %% Cell type:markdown id:fbe0d04d-29c9-4bd0-9cfb-0c57a3b3f877 tags:

 Es überrascht nicht, dass Julia die üblichen Bedingungsanweisungen hat.

 %% Cell type:code id:4f140e2c-a240-496d-904c-c60778397bcf tags:

 ``` julia
-x = 3; y = 5
+x = 3; y = 2

 if x < y
    println("x is less than y")
 elseif x > y
    println("x is greater than y")
 else
    println("x is equal to y")
 end
 ```

 %% Cell type:markdown id:4c57139e-da0c-48ef-a86f-4de80e1d7ca4 tags:

 There is also an inline conditional.

 %% Cell type:markdown id:64a3bf26-156f-40a8-8d8c-d4b2f838ef95 tags:

 Es gibt auch eine bedingte Inline-Anweisung.

 %% Cell type:code id:9d0801fd-b0d3-41e0-8b54-19a6b4539231 tags:

 ``` julia
-x = 3
+x = 6
 x < 5 ? "smaller than 5" : "larger or equal 5"
 ```

 %% Cell type:markdown id:b597c363-8066-470e-b1c8-edd00b114317 tags:

 For more details: [https://docs.julialang.org/en/v1/manual/control-flow/](https://docs.julialang.org/en/v1/manual/control-flow/).

 %% Cell type:markdown id:2539a6ec-e950-4b76-ad13-4ac9bb28ec26 tags:

 Für weitere Details siehe: [https://docs.julialang.org/en/v1/manual/control-flow/](https://docs.julialang.org/en/v1/manual/control-flow/)

 %% Cell type:markdown id:e4510840-0890-4217-8a8c-c24aa5d3405b tags:

 ## Iterations

-Julia implements the standard for and while constructs.
+Julia implements the standard `for` and `while` constructs.

 %% Cell type:markdown id:7c8eb301-3404-4d13-bc5d-f4e2f71cfa12 tags:

 ## Iterationen

-Julia implementiert die üblichen for- und while-Strukturen.
+Julia implementiert die üblichen `for`- und `while`-Befehle.

 %% Cell type:code id:9632f210-c713-4829-8187-cf5554adad87 tags:

 ``` julia
 for i in 1:5
    println("Hello from number $i")
 end
 ```

 %% Cell type:markdown id:f00caf15-4992-4c0a-8324-9d2be966346d tags:

 Where the `1:5` is a `Range`-object, but it could be any iterable. There are a few syntax variations, including:

 %% Cell type:markdown id:d0933cf7-b409-4c40-8184-70d0770a06b1 tags:

 Dabei ist `1:5` ein `Range`-Objekt, aber es könnte jede Art von iterierbarem Objekt sein. Es gibt einige syntaktische Variationen, einschließlich:

 %% Cell type:code id:70a9f620-e4ce-4367-b0f5-de37db3f48b5 tags:

 ``` julia
 result = 0
 # To get ∈ write \in and then press TAB
 for j ∈ 1:0.5:3  # Note the step parameter
    result += j
 end
 println(result)
 ```

 %% Cell type:code id:e83b2d88-b0f2-43f1-9187-65fbc75f0d3b tags:

 ``` julia
 n = 10
 while n > 0
    print(n, " ")
    n = n - 1
 end
 ```

 %% Cell type:markdown id:f19d5051-ce82-49cc-80aa-2434a6adc9d0 tags:

 The loops can be further controlled with the `break` and `continue` keywords.

 %% Cell type:markdown id:76563c39-4e45-4daf-b703-575909f70787 tags:

 Die Schleifen können mit den Schlüsselwörtern `break` und `continue` weiter gesteuert werden.

 %% Cell type:markdown id:d0ebce97-3054-4eba-821d-92f27793d752 tags:

 Sometimes you don’t know it’s time to end a loop until you get half way through the body. In that case you can use the `break` statement to jump out of the loop.

 %% Cell type:markdown id:b38f525d-db83-4fbf-808c-bf39080650f5 tags:

 Manchmal weiß man nicht, wann es an der Zeit ist, eine Schleife zu beenden, bis man sich bereits in der Mitte des Schleifenkörpers befindet. In diesem Fall können Sie das `break`-Statement verwenden, um aus der Schleife auszubrechen.

 %% Cell type:code id:9bb642e3-e3b1-488d-939f-6932feb62479 tags:

 ``` julia
 while true
    print("> ")
    line = readline()
    if line == "done"
        break
    end
    println(line)
 end
 println("Done!")
 ```

 %% Cell type:markdown id:98eee547-21fe-4022-bde5-b02ababa26dd tags:

 The `break` statement exits the loop. When a `continue` statement is encountered inside a loop, control jumps to the beginning of the loop for the next iteration, skipping the execution of statements inside the body of the loop for the current iteration. For example:

 %% Cell type:markdown id:873c3625-3b99-48e5-9821-9b696a8f8a12 tags:

-Das `break`-Statement beendet die Schleife. Wenn ein `continue`-Statement in einer Schleife auftritt, springt die Kontrolle zum Anfang der Schleife für die nächste Iteration, wobei die Ausführung der Anweisungen im Körper der Schleife für die aktuelle Iteration übersprungen wird. Zum Beispiel:
+Das `break`-Statement beendet die Schleife. Wenn ein `continue`-Statement in einer Schleife auftritt, springt die Kontrolle zum Anfang der Schleife für die nächste Iteration, wobei die Ausführung der Anweisungen im Innern der Schleife für die aktuelle Iteration übersprungen wird. Zum Beispiel:

 %% Cell type:code id:7f1c2595-8836-4308-9769-f4140d402582 tags:

 ``` julia
 for i in 1:10
    if i % 3 == 0
        continue
    end
    print(i, " ")
 end
 ```

 %% Cell type:markdown id:b8eac9e9-dff9-4b86-88a7-e14f27b7f677 tags:

 For more detials: [https://docs.julialang.org/en/v1/base/collections/#lib-collections-iteration](https://docs.julialang.org/en/v1/base/collections/#lib-collections-iteration).

 %% Cell type:markdown id:d2e93721 tags:

 Für weitere Details: [https://docs.julialang.org/en/v1/base/collections/#lib-collections-iteration](https://docs.julialang.org/en/v1/base/collections/#lib-collections-iteration).

 %% Cell type:markdown id:990cefae-abfe-4649-8d68-3fac1b1e268b tags:

 ### Exercises

 %% Cell type:markdown id:625f1e1b-ab4d-425d-b848-94385ddcb690 tags:

 ### Übungen

 %% Cell type:markdown id:bdb2eef9-bdee-4cf3-8bab-d6c1d46ecc2f tags:

 The mathematician Srinivasa Ramanujan found an infinite series that can be used to generate a numerical approximation of 1/π

 $$ \frac{1}{\pi} = \frac{2\sqrt{2}}{9801} \sum_{k=0}^\infty \frac{(4k)! (1103 + 26390 k)}{(k!)^4 396^{4 k}}$$

-Use this formula to compute an estimate of π. It should use a while loop ot compute terms of the summation untile the last term is smaller than 1e-15. Afterwards, you can check the result by comparing it to π (to get π in Julia, write \pi and then press TAB).
+Use this formula to compute an estimate of π. It should use a while loop ot compute terms of the summation untile the last term is smaller than 1e-15. Afterwards, you can check the result by comparing it to π (to get π in Julia, write \pi and then press TAB). Hint: use the builtin function `factorial`.

 %% Cell type:markdown id:6a0dcd06-0926-4529-ac33-0aee315f85cf tags:

 Der Mathematiker Srinivasa Ramanujan fand eine unendliche Reihe, die verwendet werden kann, um eine numerische Näherung von 1/π zu generieren:

 $$ \frac{1}{\pi} = \frac{2\sqrt{2}}{9801} \sum_{k=0}^\infty \frac{(4k)! (1103 + 26390 k)}{(k!)^4 396^{4 k}}$$

-Verwenden Sie diese Formel, um eine Schätzung von π zu berechnen. Sie sollte eine While-Schleife verwenden, um die Terme der Summation zu berechnen, bis der letzte Term kleiner als 1e-15 ist. Anschließend können Sie das Ergebnis überprüfen, indem Sie es mit π vergleichen (um π in Julia zu erhalten, schreiben Sie \pi und drücken dann die TAB-Taste).
+Verwenden Sie diese Formel, um eine Schätzung von π zu berechnen. Sie sollte eine While-Schleife verwenden, um die Terme der Summation zu berechnen, bis der letzte Term kleiner als 1e-15 ist. Anschließend können Sie das Ergebnis überprüfen, indem Sie es mit π vergleichen (um π in Julia zu erhalten, schreiben Sie \pi und drücken dann die TAB-Taste). Hinweis: Verwenden Sie die integrierte Funktion `factorial`.

-%% Cell type:code id:9243c8ee-b3b9-4e23-a829-d20fc8bf0b16 tags:
+%% Cell type:code id:dbe40300-8333-4271-aa43-49f973fa03a6 tags:

 ``` julia
 ```

 %% Cell type:markdown id:d4a870c3-7679-4775-94ce-4e7266a2bebe tags:

 ## Functions

 %% Cell type:markdown id:e2072b09-53e0-4354-984b-13813e93fef1 tags:

 ## Funktionen

 %% Cell type:markdown id:682a3feb-0b82-479d-9803-3011a1e6e521 tags:

 We have already seen one example of a function call:

 %% Cell type:markdown id:8fde350c-f73a-44b7-9459-b8f6d79120cf tags:

 Wir haben bereits ein Beispiel für einen Funktionsaufruf gesehen:

 %% Cell type:code id:addaa346-7a88-4c18-9f1e-295665959a9d tags:

 ``` julia
 println("Hello, World!")
 ```

 %% Cell type:markdown id:3434842c-2af0-4f6a-a70b-a59fb8fcc4af tags:

 The name of the function is println. The expression in parentheses is called the argument of the function.
 It is common to say that a function “takes” an argument and “returns” a result. The result is also called the return value.

 %% Cell type:markdown id:ef1e8206-add5-49f9-ab4c-4b730164aee6 tags:

 Der Name der Funktion ist println. Der Ausdruck in Klammern wird als Argument der Funktion bezeichnet.
 Es ist üblich zu sagen, dass eine Funktion ein Argument "nimmt" und ein Ergebnis "zurückgibt". Das Ergebnis wird auch als Rückgabewert bezeichnet.

 %% Cell type:markdown id:f63d270a-7149-4ffd-bc31-f746560a37ac tags:

 Julia provides functions that convert values from one type to another. The parse function takes a string and converts it to any number type, if it can, or complains otherwise:

 %% Cell type:markdown id:bd083417-b51a-4f0e-a150-56a0f9c33569 tags:

 Julia bietet Funktionen, die Werte von einem Typ in einen anderen konvertieren. Die Funktion `parse` nimmt einen String und wandelt ihn in jeden Zahlen-Typ um, wenn es möglich ist, oder gibt andernfalls eine Fehlermeldung aus:

 %% Cell type:code id:1f05465a-4863-4205-9c73-26f0e93f049b tags:

 ``` julia
 parse(Int64, "32")
 ```

 %% Cell type:code id:e6ac9994-9cbb-4004-889d-a657b8396063 tags:

 ``` julia
 parse(Int64, "Hello")
 ```

 %% Cell type:markdown id:793c9620-7b6e-443c-8765-8136fbfcb071 tags:

 Julia provides several mathematical functions.
  - abs, sqrt, cbrt, exp, log, log10, log2
  - sin, cos, tan, asin, acos, atan
  - sinh, cosh, tanh, asinh, acosh, atanh
  - floor: Largest integer not greater than x.
  - ceil: Smallest integer not less than x.
  - round: Nearest integer to x.
  - trunc: Integer part of x.

 For more details: [https://docs.julialang.org/en/v1/base/math/#Mathematical-Functions](https://docs.julialang.org/en/v1/base/math/#Mathematical-Functions).

 %% Cell type:markdown id:9176592b-e9f3-46fd-9909-8b73da750434 tags:

 Julia stellt verschiedene mathematische Funktionen zur Verfügung:
  - abs, sqrt, cbrt, exp, log, log10, log2
  - sin, cos, tan, asin, acos, atan
  - sinh, cosh, tanh, asinh, acosh, atanh
  - floor: Größte ganze Zahl, die nicht größer als x ist.
  - ceil: Kleinste ganze Zahl, die nicht kleiner als x ist.
  - round: Nächstgelegene ganze Zahl zu x.
  - trunc: Ganzzahliger Teil von x.

 Für weitere Details: [https://docs.julialang.org/en/v1/base/math/#Mathematical-Functions](https://docs.julialang.org/en/v1/base/math/#Mathematical-Functions).

 %% Cell type:markdown id:d048851b-8eac-4dc3-81b7-ea1d625a1db2 tags:

 So far, we have only been using the functions that come with Julia, but it is also possible to add new functions.
 Defining functions follows a rather intuitive syntax. The value obtained by evaluating the last expression of a `function` block will be automatically returned:

 %% Cell type:markdown id:f43cb468-832a-4cab-b8a3-15bb9bcbfb0d tags:

 Bisher haben wir nur die Funktionen verwendet, die mit Julia geliefert werden, aber es ist auch möglich, neue Funktionen hinzuzufügen.
 Die Definition von Funktionen folgt einer recht intuitiven Syntax. Der Wert, der durch Auswerten des letzten Ausdrucks eines `function`-Blocks erhalten wird, wird automatisch zurückgegeben:

 %% Cell type:code id:fd2f4828-47f5-4df4-b5bd-a42625487b5a tags:

 ``` julia
 function mymult(x, y)
    x * y
 end
 ```

 %% Cell type:markdown id:08bab11e-df61-4906-a925-b93184e5c600 tags:

 For one-line functions one may also use a convenient short-hand:

 %% Cell type:markdown id:e8dfb238-54be-4a95-9eda-4ce1fa5cfd74 tags:

 Für Einzeiler-Funktionen kann man auch eine praktische Kurzschreibweise verwenden:

 %% Cell type:code id:5ed8292a-96e2-49ad-8f00-3c07b9483637 tags:

 ``` julia
 mysquare(x) = mymult(x, x)
 ```

 %% Cell type:markdown id:13b7892e-df8a-462f-a84c-107276d8e499 tags:

 Both such functions are fully generic in the argument types

 %% Cell type:markdown id:9b688bbf-08b6-4fba-babe-b16b6e1119be tags:

-Für Einzeiler-Funktionen kann man auch eine praktische Kurzschreibweise verwenden:
+Beide Funktionen sind in den Argumenttypen vollständig generisch

 %% Cell type:code id:49ceeeff-5291-460d-800d-5ed11a03b13e tags:

 ``` julia
 @show mysquare(2)           # Use integer arithmetic
 @show mymult(-1, 3. + 2im)  # Use complex arithmetic
 @show mysquare(" abc ");    # Use string concatenation
 ```

 %% Cell type:markdown id:15ece147-0384-4c1b-a8c3-d11a795bd1b7 tags:

 Notice, that for each type combination a separate piece of code will be compiled even though we only *defined* the functionality a single time. This compilation takes place on first use of a particular tuple of types.

 %% Cell type:markdown id:6add8ab6-7f66-431b-9e9e-e52d45379483 tags:

 Beachten Sie, dass für jede Kombination von Typen ein separater Codeabschnitt kompiliert wird, obwohl wir die Funktionalität nur einmal *definiert* haben. Diese Kompilierung findet beim ersten Gebrauch eines bestimmten Tupels von Typen statt.

 %% Cell type:code id:7e5dcfeb-960a-47f3-b2f8-f6f0906d2f24 tags:

 ``` julia
 mymult
 ```

 %% Cell type:markdown id:934dc8e8-564b-4566-9eb0-a96df39f0870 tags:

 and may be passed around to other functions, for example:

 %% Cell type:markdown id:3be89ab5-16f3-4633-bb8d-fd74cf39ddec tags:

 und können an andere Funktionen übergeben werden, zum Beispiel:

 %% Cell type:code id:171b1a83-c076-4ac4-a309-9d607ea0b5a4 tags:

 ``` julia
 """The fold function, applying f from the left and accumulating the results"""
 function myfold(f, x, y, z)
    f(f(x, y), z)
 end
 myfold(mymult, "Hello", " Julia ", "World")
 ```

 %% Cell type:markdown id:f31327e4-5d69-4dfb-a4bf-ed1e419b1be3 tags:

 Julia makes a distinction between **functions** and **methods**. Roughly speaking **function**s specify *what* is done and **methods** specify *how* this is done.

 Methods are concrete implementations in form of a list of Julia expressions to be executed, when the function name is used in the code. Multiple methods may be defined for the same function name. They differ in the number of arguments or in the supported argument types (more on this in the next notebook). When a particular function name is used in the code, Julia looks at the types of the arguments and uses this information to **dispatch** to the best-fitting method.

 For our `myfold` example, one could easily imagine a few more method implementations, for example:

 %% Cell type:markdown id:09a40182-e59f-42e4-b11e-0c3aedd0e7a6 tags:

 Julia unterscheidet zwischen **Funktionen** und **Methoden**. Grob gesagt geben **Funktionen** an, *was* gemacht wird, und **Methoden** geben an, *wie* dies gemacht wird.

 Methoden sind konkrete Implementierungen in Form von einer Liste von Julia-Ausdrücken, die ausgeführt werden, wenn der Funktionsname im Code verwendet wird. Für den gleichen Funktionsnamen können mehrere Methoden definiert werden. Sie unterscheiden sich in der Anzahl der Argumente oder in den unterstützten Argumenttypen (dazu mehr im nächsten Notebook). Wenn ein bestimmter Funktionsname im Code verwendet wird, betrachtet Julia die Typen der Argumente und verwendet diese Informationen, um zur am besten passenden Methode zu **dispatchen**.

 Für unser `myfold`-Beispiel könnte man sich leicht einige weitere Methodenimplementierungen vorstellen, zum Beispiel:

 %% Cell type:code id:c249f818-6544-42fe-b387-34058e5f5890 tags:

 ``` julia
 myfold(f, x) = x
 myfold(f, x, y) = f(x, y)
 ```

 %% Cell type:code id:88f62159-2a1b-4a5a-8434-0e91810f2c69 tags:

 ``` julia
 methods(myfold)
 ```

 %% Cell type:markdown id:879d9441-ece1-4f07-a496-6aef71fd2e91 tags:

 So now `myfold` works transparently with 1, 2 or 3 arguments:

 %% Cell type:markdown id:cc818df4-a037-4ba2-8588-1afe4a6de222 tags:

 Nun funktioniert `myfold` transparent mit 1, 2 oder 3 Argumenten:

 %% Cell type:code id:d67f9c21-2c5c-43fd-a7e4-a4ce74281bf0 tags:

 ``` julia
 @show myfold(mymult, 2., 3.)
 @show myfold(+, 1)
 @show myfold(==, false, false, true)
 ```

 %% Cell type:markdown id:59fa4c2a-a1fa-4a1b-9529-68f821589206 tags:

 We can also check which method is actually employed using the `@which` macro:

 %% Cell type:markdown id:5a9a652b-80c4-482f-80b8-2c5340e61a21 tags:

 Wir können auch überprüfen, welche Methode tatsächlich verwendet wird, indem wir das `@which`-Makro verwenden:

 %% Cell type:code id:0fa105fb-b3ad-405a-85f1-598a12cbc655 tags:

 ``` julia
 @which myfold(*, 1, 2)
 ```

 %% Cell type:markdown id:73fa3be7-67a8-4817-9d94-e04765513dd3 tags:

 Standard functions (like `+` or `*`) are by no means special and behave exactly the same way as custom functions ... including the ability to define new methods for them:

 %% Cell type:markdown id:4046d2e8-2018-4f4f-b816-2a6156301f39 tags:

 Standardfunktionen (wie `+` oder `*`) sind keineswegs speziell und verhalten sich genau wie benutzerdefinierte Funktionen ... einschließlich der Möglichkeit, neue Methoden für sie zu definieren:

 %% Cell type:code id:d771af33-5174-4a95-b8e3-ac1c29eb71e9 tags:

 ``` julia
 import Base: + # we have to import functions to override/extend them
 +(x::String, y::String) = x * " " * y
 ```

 %% Cell type:code id:32429003-4879-4a37-ad3c-153857a360dd tags:

 ``` julia
 "Hello" + "World!"
 ```

 %% Cell type:markdown id:8fdf6362-7ca3-4d32-a542-26df56b83108 tags:

 (**Important note:** Since we neither own the `+` function nor the `String` type, this is known as **type piracy** and should in general be avoided!)

 %% Cell type:markdown id:ee25eff6-f56e-4230-b52d-6020dcc29bb2 tags:

 (**Wichtiger Hinweis:** Da wir weder die `+` Funktion noch den `String` Typ besitzen, handelt es sich hierbei um **Typenpiraterie** und sollte im Allgemeinen vermieden werden!)

 %% Cell type:markdown id:89ffcdef-cf06-438f-8448-4bf6dfd1af7e tags:

 Now standard functions relying on `+` just magically work:

 %% Cell type:markdown id:a2c9d8cf-0462-415c-a466-edb33b3aadec tags:

 Nun funktionieren Standardfunktionen, die auf `+` angewiesen sind, einfach magisch:

 %% Cell type:code id:75b4afeb-a3f4-40d7-8b23-b961b01c41bc tags:

 ``` julia
 sum(["a", "b", "c", "d", "e"])
 ```

 %% Cell type:markdown id:d8edaaf0-3de7-4a63-b0bd-bff53ba060f4 tags:

 Variables and parameters are local, they exist only inside the functions where they are defined:

 %% Cell type:markdown id:013b3faf-5f12-482b-956e-de97a2a4830d tags:

 Variablen und Parameter sind lokal, sie existieren nur innerhalb der Funktionen, in denen sie definiert sind:

 %% Cell type:code id:d02e6bca-6723-4a05-82ee-1f30ba127bd5 tags:

 ``` julia
 function multiply_and_print(a, b)
    product = a * b
    println(product)
 end

 multiply_and_print(2, 3)
 println(product)
 ```

 %% Cell type:markdown id:29968f96-5766-4cb7-8538-3bef9aeb8cc9 tags:

 It may not be clear why it is worth the trouble to divide a program into functions. There are several reasons:
  - Creating a new function gives you an opportunity to name a group of statements, which makes your program easier to read and debug.
  - Functions can make a program smaller by eliminating repetitive code. Later, if you make a change, you only have to make it in one place.
  - Dividing a long program into functions allows you to debug the parts one at a time and then assemble them into a working whole.
  - Well-designed functions are often useful for many programs. Once you write and debug one, you can reuse it.
  - In Julia, functions can improve performance a lot.

 %% Cell type:markdown id:0a398295-22e0-45dc-b43c-5f1915a16364 tags:

 Es mag nicht klar sein, warum es sich lohnt, ein Programm in Funktionen zu unterteilen. Es gibt mehrere Gründe dafür:

- Das Erstellen einer neuen Funktion bietet Ihnen die Möglichkeit, eine Gruppe von Anweisungen zu benennen, was Ihr Programm leichter lesbar und einfacher zu debuggen macht.
+- Das Erstellen einer neuen Funktion bietet die Möglichkeit, eine Gruppe von Anweisungen zu benennen, was das Programm leichter lesbar und einfacher zu debuggen macht.
 - Funktionen können ein Programm kleiner machen, indem sie wiederholten Code eliminieren. Später, wenn Sie eine Änderung vornehmen, müssen Sie sie nur an einer Stelle vornehmen.
 - Das Aufteilen eines langen Programms in Funktionen ermöglicht es Ihnen, die Teile nacheinander zu debuggen und dann zu einem funktionierenden Ganzen zusammenzufügen.
 - Gut gestaltete Funktionen sind oft für viele Programme nützlich. Sobald Sie eine geschrieben und debuggt haben, können Sie sie wiederverwenden.
- In Julia können Funktionen die Leistung erheblich verbessern.
+- In Julia können Funktionen die Schnelligkeit erheblich verbessern.

 %% Cell type:markdown id:7780ae66-db68-48c1-ba62-a883406f1f1c tags:

 More details: [https://docs.julialang.org/en/v1/manual/methods/](https://docs.julialang.org/en/v1/manual/methods/)

 %% Cell type:markdown id:dfa722c2-bd4c-4162-b10d-24c0f8e990e0 tags:

 Weitere Details finden Sie unter: [https://docs.julialang.org/en/v1/manual/methods/](https://docs.julialang.org/en/v1/manual/methods/)

 %% Cell type:markdown id:d914b36b-8b05-4c68-bf57-1fc74aeb26df tags:

 ### Exercises

 %% Cell type:markdown id:a4eafce6-b493-470f-86a3-93319684ee40 tags:

 ### Übungen

 %% Cell type:markdown id:247215e4-47e1-4eb6-978b-a09f14478bb8 tags:

  - Write a function `printgrid` that draws a grid like the following:

 %% Cell type:markdown id:08fe364b-e611-419b-97f2-e806881d6227 tags:

 - Schreiben Sie eine Funktion `printgrid`, die ein Raster wie folgt zeichnet:

 %% Cell type:markdown id:1704f451-9500-41c5-b74b-4a2b4a7b910f tags:

    + - - - - + - - - - +
    |         |         |
    |         |         |
    |         |         |
    |         |         |
    + - - - - + - - - - +
    |         |         |
    |         |         |
    |         |         |
    |         |         |
    + - - - - + - - - - +

 %% Cell type:code id:58ef3248-f85e-4825-bf10-02cee3e068cb tags:

 ``` julia
 ```

 %% Cell type:markdown id:e6a58742-9d24-47a5-aa68-73d44ca05127 tags:

  - Write a function that draws a similar grid with four rows and four columns.

 %% Cell type:markdown id:41f2bf0f-73f4-4671-b059-1118c35ec76f tags:

 - Schreiben Sie eine Funktion, die ein ähnliches Raster mit vier Zeilen und vier Spalten zeichnet.

 %% Cell type:markdown id:b953857f-e8d7-47aa-bc8d-8e2bd1cd20fd tags:

 Tips:
  - To print more than one value on a line, you can print a comma-separated sequence of values: println("+", "-").
  - The function print does not advance to the next line.

 %% Cell type:markdown id:2e606498-6553-4037-a9f9-3b519ffc64c9 tags:

 Tipps:
 - Um mehr als einen Wert in einer Zeile auszugeben, können Sie eine kommagetrennte Sequenz von Werten ausgeben: println("+", "-").
 - Die Funktion print springt nicht zur nächsten Zeile.

 %% Cell type:code id:1ca1789d-eddb-4f41-9ad9-9259c6f22a14 tags:

 ``` julia
 ```

 %% Cell type:markdown id:2ebc911c-7fe0-4d7f-ab5d-d8084f25a93d tags:

 ### Recursive functions

 It is legal for one function to call another; it is also legal for a function to call itself. It may not be obvious why that is a good thing, but it turns out to be one of the most magical things a program can do. For example, look at the following function:

 %% Cell type:markdown id:53edcb8b-2f37-404f-8df6-d84b2327e96e tags:

 ### Rekursive Funktionen

 Es ist erlaubt, dass eine Funktion eine andere aufruft; es ist auch erlaubt, dass eine Funktion sich selbst aufruft. Es mag nicht offensichtlich sein, warum das eine gute Sache ist, aber es stellt sich heraus, dass es eine der magischsten Dinge ist, die ein Programm tun kann. Schauen Sie sich zum Beispiel die folgende Funktion an:

 %% Cell type:code id:e578011e-d0de-4f86-8c2c-a8408454d3ac tags:

 ``` julia
 function countdown(n)
    if n ≤ 0
        println("Blastoff!")
    else
        print(n, " ")
        countdown(n-1)
    end
 end
 ```

 %% Cell type:code id:3af51513-c92e-4488-b2fe-243e2fef6b95 tags:

 ``` julia
 countdown(10)
 ```

 %% Cell type:markdown id:c59c0f54-d967-4416-b57c-e855dfc2c350 tags:

 If a recursion never reaches a base case, it goes on making recursive calls forever, and the program never terminates. This is known as infinite recursion, and it is generally not a good idea. Here is a minimal program with an infinite recursion:

 %% Cell type:markdown id:73ea203a-3919-4e14-b50f-22c8362eb771 tags:

 Wenn eine Rekursion niemals einen Basisfall erreicht, macht sie unendliche rekursive Aufrufe, und das Programm terminiert nie. Dies wird als unendliche Rekursion bezeichnet und ist im Allgemeinen keine gute Idee. Hier ist ein minimales Programm mit einer unendlichen Rekursion:

 %% Cell type:code id:13a4a762-6584-47ab-9fb5-428557770d15 tags:

 ``` julia
 function recurse()
    recurse()
 end
 ```

 %% Cell type:code id:0dde579f-6b12-4072-aa62-aeee3a970503 tags:

 ``` julia
 recurse()
 ```

 %% Cell type:markdown id:22c8c79d-6d41-4758-9550-aaab4f1dc1b1 tags:

 ### Exercises
  - Write a recursive function to compute the factorial of a number.

 %% Cell type:markdown id:a0402c3d-95fa-44a1-86ab-ca229508f68f tags:

 ### Übungen
  - Schreiben Sie eine rekursive Funktion zur Berechnung der Fakultät einer Zahl.

 %% Cell type:code id:f4102487-011e-474f-ab79-3d7db1d3bbd9 tags:

 ``` julia
 ```

 %% Cell type:markdown id:d9c31712-941c-4611-99e5-b33cdb12e28f tags:

-  - Then write a function that computes bynomial coefficients
+  - Then write a function that computes binomial coefficients
 $$ \left(\begin{array}{c} n \\ k \end{array}\right) = \frac{n!}{k! (n-k)!} $$
 by calling the function of the previous points.

 %% Cell type:markdown id:a24cdaef-98b8-46f5-a809-992547882a4b tags:

  - Schreiben Sie dann eine Funktion, die die Binomialkoeffizienten berechnet
 $$ \left(\begin{array}{c} n \\ k \end{array}\right) = \frac{n!}{k! (n-k)!} $$
 indem sie die Funktion aus den vorherigen Punkten aufruft.

 %% Cell type:code id:b54c877e-5494-4657-ba7f-208bdc301225 tags:

 ``` julia
 ```

 %% Cell type:markdown id:4509db3f-8060-46ca-89ac-824c16f5751c tags:

 - Use the two functions to compute
 $$ 15! \qquad \left(\begin{array}{c} 5 \\ 2 \end{array}\right) \qquad \left(\begin{array}{c} 5 \\ 3 \end{array}\right) $$

 %% Cell type:markdown id:a32900cc-c244-4d63-8ff6-4d11cee83eee tags:

- - Verwenden Sie die beiden Funktionen, um zu berechnen
+ - Verwenden Sie die beiden Funktionen, um folgendes zu berechnen
 $$ 15! \qquad \left(\begin{array}{c} 5 \\ 2 \end{array}\right) \qquad \left(\begin{array}{c} 5 \\ 3 \end{array}\right) $$

 %% Cell type:code id:fb02aad5-d9d4-4f0d-8118-b02b73506b89 tags:

 ``` julia
 ```

 %% Cell type:markdown id:240cc4bd-3e45-45b8-ad98-170dbb68f78d tags:

 ### Keywords argument

 Function arguments can be either position based (like what we saw so far) or keyword based, like in the following example.

 %% Cell type:markdown id:b5944412-0d39-4c0b-a0d5-fbeee22e1432 tags:

 ### Schlüsselwortargumente

 Funktionsargumente können entweder positionsbasiert (wie wir bisher gesehen haben) oder schlüsselwortbasiert sein, wie im folgenden Beispiel.

 %% Cell type:code id:30ddeb3b-be35-40eb-8491-1269a4e19f62 tags:

 ``` julia
 function greet(name; greeting="Hello")
    println("$(greeting), $(name)!")
 end
 ```

 %% Cell type:code id:b39f22b1-4a1b-4afd-b6db-041bd7150b66 tags:

 ``` julia
 greet("Michele")
 greet("Lambert"; greeting="Hallo")
+greet("YingXing"; greeting="你好")
 ```

 %% Cell type:markdown id:52b90aa8-4b19-4371-8fae-2121a78fbb96 tags:

 This is quite convenient in the following cases:
  - to set a default behavior of the function, while retaining the possibility to finely control it.
  - to add at a later point in time new functionality, without breaking retrocompatibility.

 %% Cell type:markdown id:07e76016-d5a9-4616-b0b9-2dc9b6f3c8f6 tags:

 Dies ist in den folgenden Fällen sehr praktisch:
-  - um ein Standardverhalten der Funktion festzulegen, während die Möglichkeit besteht, es fein zu steuern.
+  - um ein Standardverhalten der Funktion festzulegen, während die Möglichkeit besteht, sie fein zu steuern.
  - um zu einem späteren Zeitpunkt neue Funktionalitäten hinzuzufügen, ohne die Abwärtskompatibilität zu brechen.

 %% Cell type:markdown id:c939f951-2aaf-4e39-a60f-df7600af1d8f tags:

 ## Further Exercises

 %% Cell type:markdown id:883b3945-d30a-4f27-928f-458c9ad74e9b tags:

 ## Weitere Übungen

 %% Cell type:markdown id:59e2e997-42f7-426c-bfd0-233724704117 tags:

  - Create a function called `fibonacci_sum` that takes a positive integer n as input. This function should return the sum of the first n terms of the Fibonacci sequence.

 %% Cell type:markdown id:54537041-60eb-4961-9805-1d7d405fde1a tags:

 - Erstellen Sie eine Funktion namens `fibonacci_sum`, die eine positive ganze Zahl n als Eingabe erhält. Diese Funktion sollte die Summe der ersten n Terme der Fibonacci-Folge zurückgeben.

 %% Cell type:code id:7ca7c936-fb80-4aed-9788-75a55bb207ad tags:

 ``` julia
 ```

 %% Cell type:markdown id:49fd546f-009d-46ff-af61-6954000bce5f tags:

  - Write a function that converts a Celsius temperature in Fahrenheit and returns the result. Additionally, if the temperature is below freezing (0°C), the program should print a message indicating that it's below freezing.

 %% Cell type:markdown id:70dacb25-360f-4a7a-8c03-73cd0d75dc3e tags:

 - Schreiben Sie eine Funktion, die eine Celsius-Temperatur in Fahrenheit umrechnet und das Ergebnis zurückgibt. Zusätzlich sollte das Programm, wenn die Temperatur unter dem Gefrierpunkt (0°C) liegt, eine Meldung ausgeben, die anzeigt, dass es unter dem Gefrierpunkt liegt.

 %% Cell type:code id:a30a1812-6116-4441-8786-7450c60ef354 tags:

 ``` julia
 ```

 %% Cell type:markdown id:e2c81cc5-7d0d-4a5a-ba69-81686648df90 tags:

  - Write a function which analyzes a sentence. The function should then count and display the number of vowels (both upper and lower case) in the sentence.

 %% Cell type:markdown id:8cabe824-c7eb-46fc-afb8-e039528d2d2a tags:

 - Schreiben Sie eine Funktion, die einen Satz analysiert. Die Funktion sollte dann die Anzahl der Vokale (sowohl in Groß- als auch in Kleinbuchstaben) im Satz zählen und anzeigen.

 %% Cell type:code id:af0e28bd-2b3f-41af-aa92-456e29d50679 tags:

 ``` julia
 ```

 %% Cell type:markdown id:7aad3586-d57e-4000-8688-aa5b53d48416 tags:

 # Basics

 %% Cell type:markdown id:aff6c2f6-3d10-412e-82aa-c199c98edbd7 tags:

 # Grundlagen

 %% Cell type:markdown id:bf904dbe-3197-4a91-bbb8-05e1c7f7dfee tags:

 ## Variables and elementary types

 Defining variables in Julia works like in most languages:

 %% Cell type:markdown id:3be02b91-9619-4cfd-b463-2add42babbcc tags:

 ## Variablen und elementare Datentypen

 Das Definieren von Variablen in Julia funktioniert wie in den meisten Sprachen:

 %% Cell type:code id:3c44023b-06c9-4420-9af3-da2ec37b02da tags:

 ``` julia
 int = 4      # An integer
 ```

 %% Cell type:code id:b2f9ba27-bf65-40d8-b0ac-e3d86c99dd40 tags:

 ``` julia
 str = "Hi"   # A string
 ```

 %% Cell type:code id:87a83355-5088-47d3-b698-2c6902aaa6a0 tags:

 ``` julia
 float = 1.2  # A floating-point number
 ```

 %% Cell type:code id:597523f1-4041-4fc6-9be2-2c94a93fd633 tags:

 ``` julia
 bool = true  # A boolean (also false)
 ```

 %% Cell type:markdown id:0c538bdb-f995-4589-bee7-0989c922090c tags:

 The type is automatically inferred:

 %% Cell type:markdown id:816bc593-70cc-4e0f-b461-c9022d9587f6 tags:

 Der Typ wird automatisch abgeleitet:

 %% Cell type:code id:b80c6777-3dea-4f45-98b3-0a3eee196183 tags:

 ``` julia
 typeof(int)
 ```

 %% Cell type:code id:1fb6cbd2-871f-40a4-ae84-e7ee46e75a61 tags:

 ``` julia
 typeof(str)
 ```

 %% Cell type:code id:a16a6f08-f19a-42e0-baac-aaa88ebba1af tags:

 ``` julia
 typeof(float)
 ```

 %% Cell type:markdown id:09d035eb-22aa-49f5-9fd1-a5b16973f386 tags:

 Julia supports a large range of integer and floating-point types out of the box, for example:

 %% Cell type:markdown id:d5e586cc-874a-46d5-9c7c-d1136d73492e tags:

 Julia unterstützt von Haus aus eine große Bandbreite von Ganzzahl- und Gleitkommazahlentypen, zum Beispiel:

 %% Cell type:code id:88f24b01-f4a5-4030-af2c-a5d30223d047 tags:

 ``` julia
 x = UInt8(1)              # 8-bit wide unsigned integer
 y = Int32(-1)             # 32-bit wide signed integer
 z = Float32(0.2)          # single precision
 α = Float16(-1.0)         # half precision
 β = ComplexF64(2. + 8im)  # Complex number (composed of two Float64)
 ```

 %% Cell type:markdown id:a615bbc0-732e-461f-8c4c-a972fa2be731 tags:

 If you give a variable an illegal name, you get a syntax error:

 %% Cell type:markdown id:bf9f6efc-6b47-415c-8504-35a2b1a80f18 tags:

 Wenn Sie einer Variable einen ungültigen Namen geben, erhalten Sie einen Syntaxfehler:

 %% Cell type:code id:1ca20515-6d66-40c3-84f1-2e24ece096cd tags:

 ``` julia
 1test = "hello"
 ```

 %% Cell type:code id:2c61f59e-2c2f-4049-8624-35e0712b2cf1 tags:

 ``` julia
 more@ = 1000000
 ```

 %% Cell type:code id:85040b19-b0a9-4baa-8748-5ea62f8b5633 tags:

 ``` julia
 struct = "another illegale variable name"
 ```

 %% Cell type:markdown id:cc36688b-c983-43f8-8bdf-9b82aae59909 tags:

 It turns out that `struct` is one of Julia’s keywords, and they cannot be used as variable names.

 - For more Julia's keywords, see [https://docs.julialang.org/en/v1/base/base/#Keywords](https://docs.julialang.org/en/v1/base/base/#Keywords).
 - For more details on `Variable`, see [https://docs.julialang.org/en/v1/manual/variables/](https://docs.julialang.org/en/v1/manual/variables/).

 %% Cell type:markdown id:2e5659b9-9e66-448a-a768-23d7085d7dac tags:

 Es stellt sich heraus, dass `struct` eines der Schlüsselwörter von Julia ist und nicht als Variablennamen verwendet werden kann.

 - Für weitere Schlüsselwörter von Julia, siehe [https://docs.julialang.org/en/v1/base/base/#Keywords](https://docs.julialang.org/en/v1/base/base/#Keywords).
- Für weitere Details über `Variable`, siehe [https://docs.julialang.org/en/v1/manual/variables/](https://docs.julialang.org/en/v1/manual/variables/).
+- Für weitere Details über `Variabeln`, siehe [https://docs.julialang.org/en/v1/manual/variables/](https://docs.julialang.org/en/v1/manual/variables/).

 %% Cell type:markdown id:de111dbe-f7ed-4e1a-8ec0-c5e65bd63bbf tags:

 ### Strings

 %% Cell type:markdown id:e099c88a-5848-4730-be7d-b7651bc3db29 tags:

 ### Zeichenketten

 %% Cell type:markdown id:1b3531e9-33db-4c51-b394-c1def6621519 tags:

 In general, you can’t perform mathematical operations on strings, even if the strings look like numbers, so the following are illegal:

 %% Cell type:markdown id:925cbca6-cce3-4084-96a2-fe0a5acdb1e9 tags:

 Im Allgemeinen können Sie mathematische Operationen nicht auf Zeichenketten ausführen, auch wenn die Zeichenketten wie Zahlen aussehen. Daher sind die folgenden Operationen nicht erlaubt:

 %% Cell type:code id:246f1db8-d734-413d-9237-b2434e071914 tags:

 ``` julia
 "2" - "1"
 "eggs" / "easy"
 "third" + "a charm"
 ```

 %% Cell type:markdown id:c94f1187-67f8-473e-910c-2eb145ed59dd tags:

 But there are two exceptions, * and ^.

 %% Cell type:markdown id:c2c39aa8-d98b-42dd-8e7c-09463f78d22c tags:

 Es gibt jedoch zwei Ausnahmen, * und ^.

 %% Cell type:code id:b3a0f6e1-e28b-4fb7-baa3-bb003de3dc24 tags:

 ``` julia
 "Hello " * "world"
 ```

 %% Cell type:code id:0c963c3c-47c7-4805-8be6-621b72fdb62e tags:

 ``` julia
 "hello! "^5
 ```

 %% Cell type:markdown id:362f9d04-eff9-4594-aa22-a9c8d601fb1e tags:

 For more details: [https://docs.julialang.org/en/v1/manual/strings/](https://docs.julialang.org/en/v1/manual/strings/).

 %% Cell type:markdown id:7b7ff4e3 tags:

 Für weitere Details: [https://docs.julialang.org/en/v1/manual/strings/](https://docs.julialang.org/en/v1/manual/strings/).

 %% Cell type:markdown id:61ff8194-669c-4ece-ba31-44e88ed808ac tags:

 ### Exercises

 %% Cell type:markdown id:43fe0add-b90d-4ed4-862e-37a4361d2354 tags:

 ### Übungen

 %% Cell type:markdown id:e0aecc9c-e77f-449e-8aff-e1ffcf5d7833 tags:

 Practice using Julia as a calculator:
  - The volume of a sphere with radius r is 4/3πr^3. What is the volume of a sphere with radius 5?

 %% Cell type:markdown id:3e392c67-df83-49fc-831d-12e157e4a85c tags:

 Üben Sie, Julia als Taschenrechner zu verwenden:

  - Die Formel für das Volumen einer Kugel mit Radius r lautet 4/3πr^3. Was ist das Volumen einer Kugel mit Radius 5?

 %% Cell type:code id:fc538246-418c-4ebe-b487-81feba4383c8 tags:

 ``` julia
+
 ```

 %% Cell type:markdown id:10f1604d-8e81-4f96-8b6f-95753f0b5c4f tags:

  - Suppose the cover price of a book is € 24.95, but bookstores get a 40 % discount. Shipping costs € 3 for the first copy and 75 cents for each additional copy. What is the total wholesale cost for 60 copies?

 %% Cell type:markdown id:32f7a6f1-6a19-4ebe-bd1b-846f861dc721 tags:

 - Angenommen, der Listenpreis eines Buches beträgt € 24,95, aber Buchhandlungen erhalten einen Rabatt von 40 %. Der Versand kostet € 3 für das erste Exemplar und 75 Cent für jedes zusätzliche Exemplar. Was sind die gesamten Großhandelskosten für 60 Exemplare?

 %% Cell type:code id:bd4150cf-005a-4087-aa92-5f4b18e4d197 tags:

 ``` julia
 ```

 %% Cell type:markdown id:dc9cddb9-717d-4ba0-b478-beb00afc46c8 tags:

 ## Conditionals and Boolean Expressions

 A boolean expression is an expression that is either true or false. The following examples use the operator ==, which compares two operands and produces true if they are equal and false otherwise:

 %% Cell type:markdown id:53e26ee8-c10d-42e4-bbb9-cb5f696139ba tags:

 ## Bedingungen und boolesche Ausdrücke

 Ein boolescher Ausdruck ist ein Ausdruck, der entweder wahr oder falsch ist. Die folgenden Beispiele verwenden den Operator ==, der zwei Operanden vergleicht und true zurückgibt, wenn sie gleich sind, andernfalls false:

 %% Cell type:code id:7de4ffe9-4730-47dd-b074-1525bf9937b1 tags:

 ``` julia
 5 == 5
 ```

 %% Cell type:code id:c02939dd-6f25-4916-8394-a5f95d0200df tags:

 ``` julia
 5 == 6
 ```

 %% Cell type:markdown id:9a108e63-7d58-489d-b7ef-49629c879d29 tags:

 The == operator is one of the relational operators; the others are:

 %% Cell type:markdown id:4722b7b7-3f80-454f-bd8b-f67912105f79 tags:

 Der == Operator ist einer der relationalen Operatoren; die anderen sind:

 %% Cell type:code id:b59cd314-fd03-4609-ac1b-7329a2c3cc38 tags:

 ``` julia
 x = 3; y = 4
 x != y               # x is not equal to y
 x ≠ y                # (to get the ≠ symbol, type \ne and then press TAB)
 x > y                # x is greater than y
 x < y                # x is less than y
 x >= y               # x is greater than or equal to y
 x ≥ y                # (to get the ≥ symbol, type \ge and then press TAB)
 x <= y               # x is less than or equal to y
 x ≤ y                # (to get the ≤ symbol, type \le and then press TAB)
 ```

 %% Cell type:markdown id:15e20f55-1a43-4d0d-94bc-d2de0ee2fe8c tags:

 There are three logical operators: && (and), || (or), and ! (not). The semantics (meaning) of these operators is similar to their meaning in English. For example, x > 0 && x < 10 is true only if x is greater than 0 and less than 10.

 %% Cell type:markdown id:01c9f186-294f-4659-bc32-cee3b6ff4f40 tags:

 Es gibt drei logische Operatoren: && (und), || (oder) und ! (nicht). Die Bedeutung dieser Operatoren entspricht weitgehend ihrer Bedeutung im Englischen. Zum Beispiel ist x > 0 && x < 10 nur dann wahr, wenn x größer als 0 und kleiner als 10 ist.

 %% Cell type:code id:d1e6e2ce-bb0c-4776-80b6-22ceb9c68397 tags:

 ``` julia
 x = 4
 x > 0 && x < 10
 ```

 %% Cell type:markdown id:da591654-6360-4f56-956b-07493d1d2247 tags:

 It is also worth mentioning that in combined logical expression not all conditions are necessarily executed.

 %% Cell type:markdown id:857cde91-3430-480c-9f24-bb9c465248d9 tags:

 Es ist auch erwähnenswert, dass bei kombinierten logischen Ausdrücken nicht alle Bedingungen notwendigerweise ausgeführt werden.

 %% Cell type:code id:e92abf7b-5414-4aee-abaf-a4e52b1c06d3 tags:

 ``` julia
 true  || println("The RHS of || is only run")
 false || println("if the LHS is false")
 ```

 %% Cell type:code id:c8a9d8ac-5378-4ebb-810b-9ae3194d670c tags:

 ``` julia
 iseven(3) && println("The RHS of || is only run")
 isodd(3)  && println("if the LHS is true")
 ```

 %% Cell type:markdown id:be0c63e0-35a9-43c7-9b30-d04072ee6904 tags:

 Finally, the ! operator negates a boolean expression, so !(x > y) is true if x > y is false, that is, if x is less than or equal to y.

 %% Cell type:markdown id:d8db49a8-6c6c-4abf-9a5b-5d27765ab1c7 tags:

 Schließlich kehrt der ! Operator einen booleschen Ausdruck um, sodass !(x > y) wahr ist, wenn x > y falsch ist, das heißt, wenn x kleiner oder gleich y ist.

 %% Cell type:code id:e43ab736-03e2-4040-a15e-48305037ba23 tags:

 ``` julia
 x = 4
 !(x > 0 && x < 10)
 ```

 %% Cell type:markdown id:7064ae20-6d63-40fc-85c5-080ace54e7b6 tags:

 Unsurprisingly Julia has the standard conditionals.

 %% Cell type:markdown id:fbe0d04d-29c9-4bd0-9cfb-0c57a3b3f877 tags:

 Es überrascht nicht, dass Julia die üblichen Bedingungsanweisungen hat.

 %% Cell type:code id:4f140e2c-a240-496d-904c-c60778397bcf tags:

 ``` julia
-x = 3; y = 5
+x = 3; y = 2

 if x < y
    println("x is less than y")
 elseif x > y
    println("x is greater than y")
 else
    println("x is equal to y")
 end
 ```

 %% Cell type:markdown id:4c57139e-da0c-48ef-a86f-4de80e1d7ca4 tags:

 There is also an inline conditional.

 %% Cell type:markdown id:64a3bf26-156f-40a8-8d8c-d4b2f838ef95 tags:

 Es gibt auch eine bedingte Inline-Anweisung.

 %% Cell type:code id:9d0801fd-b0d3-41e0-8b54-19a6b4539231 tags:

 ``` julia
-x = 3
+x = 6
 x < 5 ? "smaller than 5" : "larger or equal 5"
 ```

 %% Cell type:markdown id:b597c363-8066-470e-b1c8-edd00b114317 tags:

 For more details: [https://docs.julialang.org/en/v1/manual/control-flow/](https://docs.julialang.org/en/v1/manual/control-flow/).

 %% Cell type:markdown id:2539a6ec-e950-4b76-ad13-4ac9bb28ec26 tags:

 Für weitere Details siehe: [https://docs.julialang.org/en/v1/manual/control-flow/](https://docs.julialang.org/en/v1/manual/control-flow/)

 %% Cell type:markdown id:e4510840-0890-4217-8a8c-c24aa5d3405b tags:

 ## Iterations

-Julia implements the standard for and while constructs.
+Julia implements the standard `for` and `while` constructs.

 %% Cell type:markdown id:7c8eb301-3404-4d13-bc5d-f4e2f71cfa12 tags:

 ## Iterationen

-Julia implementiert die üblichen for- und while-Strukturen.
+Julia implementiert die üblichen `for`- und `while`-Befehle.

 %% Cell type:code id:9632f210-c713-4829-8187-cf5554adad87 tags:

 ``` julia
 for i in 1:5
    println("Hello from number $i")
 end
 ```

 %% Cell type:markdown id:f00caf15-4992-4c0a-8324-9d2be966346d tags:

 Where the `1:5` is a `Range`-object, but it could be any iterable. There are a few syntax variations, including:

 %% Cell type:markdown id:d0933cf7-b409-4c40-8184-70d0770a06b1 tags:

 Dabei ist `1:5` ein `Range`-Objekt, aber es könnte jede Art von iterierbarem Objekt sein. Es gibt einige syntaktische Variationen, einschließlich:

 %% Cell type:code id:70a9f620-e4ce-4367-b0f5-de37db3f48b5 tags:

 ``` julia
 result = 0
 # To get ∈ write \in and then press TAB
 for j ∈ 1:0.5:3  # Note the step parameter
    result += j
 end
 println(result)
 ```

 %% Cell type:code id:e83b2d88-b0f2-43f1-9187-65fbc75f0d3b tags:

 ``` julia
 n = 10
 while n > 0
    print(n, " ")
    n = n - 1
 end
 ```

 %% Cell type:markdown id:f19d5051-ce82-49cc-80aa-2434a6adc9d0 tags:

 The loops can be further controlled with the `break` and `continue` keywords.

 %% Cell type:markdown id:76563c39-4e45-4daf-b703-575909f70787 tags:

 Die Schleifen können mit den Schlüsselwörtern `break` und `continue` weiter gesteuert werden.

 %% Cell type:markdown id:d0ebce97-3054-4eba-821d-92f27793d752 tags:

 Sometimes you don’t know it’s time to end a loop until you get half way through the body. In that case you can use the `break` statement to jump out of the loop.

 %% Cell type:markdown id:b38f525d-db83-4fbf-808c-bf39080650f5 tags:

 Manchmal weiß man nicht, wann es an der Zeit ist, eine Schleife zu beenden, bis man sich bereits in der Mitte des Schleifenkörpers befindet. In diesem Fall können Sie das `break`-Statement verwenden, um aus der Schleife auszubrechen.

 %% Cell type:code id:9bb642e3-e3b1-488d-939f-6932feb62479 tags:

 ``` julia
 while true
    print("> ")
    line = readline()
    if line == "done"
        break
    end
    println(line)
 end
 println("Done!")
 ```

 %% Cell type:markdown id:98eee547-21fe-4022-bde5-b02ababa26dd tags:

 The `break` statement exits the loop. When a `continue` statement is encountered inside a loop, control jumps to the beginning of the loop for the next iteration, skipping the execution of statements inside the body of the loop for the current iteration. For example:

 %% Cell type:markdown id:873c3625-3b99-48e5-9821-9b696a8f8a12 tags:

-Das `break`-Statement beendet die Schleife. Wenn ein `continue`-Statement in einer Schleife auftritt, springt die Kontrolle zum Anfang der Schleife für die nächste Iteration, wobei die Ausführung der Anweisungen im Körper der Schleife für die aktuelle Iteration übersprungen wird. Zum Beispiel:
+Das `break`-Statement beendet die Schleife. Wenn ein `continue`-Statement in einer Schleife auftritt, springt die Kontrolle zum Anfang der Schleife für die nächste Iteration, wobei die Ausführung der Anweisungen im Innern der Schleife für die aktuelle Iteration übersprungen wird. Zum Beispiel:

 %% Cell type:code id:7f1c2595-8836-4308-9769-f4140d402582 tags:

 ``` julia
 for i in 1:10
    if i % 3 == 0
        continue
    end
    print(i, " ")
 end
 ```

 %% Cell type:markdown id:b8eac9e9-dff9-4b86-88a7-e14f27b7f677 tags:

 For more detials: [https://docs.julialang.org/en/v1/base/collections/#lib-collections-iteration](https://docs.julialang.org/en/v1/base/collections/#lib-collections-iteration).

 %% Cell type:markdown id:d2e93721 tags:

 Für weitere Details: [https://docs.julialang.org/en/v1/base/collections/#lib-collections-iteration](https://docs.julialang.org/en/v1/base/collections/#lib-collections-iteration).

 %% Cell type:markdown id:990cefae-abfe-4649-8d68-3fac1b1e268b tags:

 ### Exercises

 %% Cell type:markdown id:625f1e1b-ab4d-425d-b848-94385ddcb690 tags:

 ### Übungen

 %% Cell type:markdown id:bdb2eef9-bdee-4cf3-8bab-d6c1d46ecc2f tags:

 The mathematician Srinivasa Ramanujan found an infinite series that can be used to generate a numerical approximation of 1/π

 $$ \frac{1}{\pi} = \frac{2\sqrt{2}}{9801} \sum_{k=0}^\infty \frac{(4k)! (1103 + 26390 k)}{(k!)^4 396^{4 k}}$$

-Use this formula to compute an estimate of π. It should use a while loop ot compute terms of the summation untile the last term is smaller than 1e-15. Afterwards, you can check the result by comparing it to π (to get π in Julia, write \pi and then press TAB).
+Use this formula to compute an estimate of π. It should use a while loop ot compute terms of the summation untile the last term is smaller than 1e-15. Afterwards, you can check the result by comparing it to π (to get π in Julia, write \pi and then press TAB). Hint: use the builtin function `factorial`.

 %% Cell type:markdown id:6a0dcd06-0926-4529-ac33-0aee315f85cf tags:

 Der Mathematiker Srinivasa Ramanujan fand eine unendliche Reihe, die verwendet werden kann, um eine numerische Näherung von 1/π zu generieren:

 $$ \frac{1}{\pi} = \frac{2\sqrt{2}}{9801} \sum_{k=0}^\infty \frac{(4k)! (1103 + 26390 k)}{(k!)^4 396^{4 k}}$$

-Verwenden Sie diese Formel, um eine Schätzung von π zu berechnen. Sie sollte eine While-Schleife verwenden, um die Terme der Summation zu berechnen, bis der letzte Term kleiner als 1e-15 ist. Anschließend können Sie das Ergebnis überprüfen, indem Sie es mit π vergleichen (um π in Julia zu erhalten, schreiben Sie \pi und drücken dann die TAB-Taste).
+Verwenden Sie diese Formel, um eine Schätzung von π zu berechnen. Sie sollte eine While-Schleife verwenden, um die Terme der Summation zu berechnen, bis der letzte Term kleiner als 1e-15 ist. Anschließend können Sie das Ergebnis überprüfen, indem Sie es mit π vergleichen (um π in Julia zu erhalten, schreiben Sie \pi und drücken dann die TAB-Taste). Hinweis: Verwenden Sie die integrierte Funktion `factorial`.

-%% Cell type:code id:9243c8ee-b3b9-4e23-a829-d20fc8bf0b16 tags:
+%% Cell type:code id:dbe40300-8333-4271-aa43-49f973fa03a6 tags:

 ``` julia
 ```

 %% Cell type:markdown id:d4a870c3-7679-4775-94ce-4e7266a2bebe tags:

 ## Functions

 %% Cell type:markdown id:e2072b09-53e0-4354-984b-13813e93fef1 tags:

 ## Funktionen

 %% Cell type:markdown id:682a3feb-0b82-479d-9803-3011a1e6e521 tags:

 We have already seen one example of a function call:

 %% Cell type:markdown id:8fde350c-f73a-44b7-9459-b8f6d79120cf tags:

 Wir haben bereits ein Beispiel für einen Funktionsaufruf gesehen:

 %% Cell type:code id:addaa346-7a88-4c18-9f1e-295665959a9d tags:

 ``` julia
 println("Hello, World!")
 ```

 %% Cell type:markdown id:3434842c-2af0-4f6a-a70b-a59fb8fcc4af tags:

 The name of the function is println. The expression in parentheses is called the argument of the function.
 It is common to say that a function “takes” an argument and “returns” a result. The result is also called the return value.

 %% Cell type:markdown id:ef1e8206-add5-49f9-ab4c-4b730164aee6 tags:

 Der Name der Funktion ist println. Der Ausdruck in Klammern wird als Argument der Funktion bezeichnet.
 Es ist üblich zu sagen, dass eine Funktion ein Argument "nimmt" und ein Ergebnis "zurückgibt". Das Ergebnis wird auch als Rückgabewert bezeichnet.

 %% Cell type:markdown id:f63d270a-7149-4ffd-bc31-f746560a37ac tags:

 Julia provides functions that convert values from one type to another. The parse function takes a string and converts it to any number type, if it can, or complains otherwise:

 %% Cell type:markdown id:bd083417-b51a-4f0e-a150-56a0f9c33569 tags:

 Julia bietet Funktionen, die Werte von einem Typ in einen anderen konvertieren. Die Funktion `parse` nimmt einen String und wandelt ihn in jeden Zahlen-Typ um, wenn es möglich ist, oder gibt andernfalls eine Fehlermeldung aus:

 %% Cell type:code id:1f05465a-4863-4205-9c73-26f0e93f049b tags:

 ``` julia
 parse(Int64, "32")
 ```

 %% Cell type:code id:e6ac9994-9cbb-4004-889d-a657b8396063 tags:

 ``` julia
 parse(Int64, "Hello")
 ```

 %% Cell type:markdown id:793c9620-7b6e-443c-8765-8136fbfcb071 tags:

 Julia provides several mathematical functions.
  - abs, sqrt, cbrt, exp, log, log10, log2
  - sin, cos, tan, asin, acos, atan
  - sinh, cosh, tanh, asinh, acosh, atanh
  - floor: Largest integer not greater than x.
  - ceil: Smallest integer not less than x.
  - round: Nearest integer to x.
  - trunc: Integer part of x.

 For more details: [https://docs.julialang.org/en/v1/base/math/#Mathematical-Functions](https://docs.julialang.org/en/v1/base/math/#Mathematical-Functions).

 %% Cell type:markdown id:9176592b-e9f3-46fd-9909-8b73da750434 tags:

 Julia stellt verschiedene mathematische Funktionen zur Verfügung:
  - abs, sqrt, cbrt, exp, log, log10, log2
  - sin, cos, tan, asin, acos, atan
  - sinh, cosh, tanh, asinh, acosh, atanh
  - floor: Größte ganze Zahl, die nicht größer als x ist.
  - ceil: Kleinste ganze Zahl, die nicht kleiner als x ist.
  - round: Nächstgelegene ganze Zahl zu x.
  - trunc: Ganzzahliger Teil von x.

 Für weitere Details: [https://docs.julialang.org/en/v1/base/math/#Mathematical-Functions](https://docs.julialang.org/en/v1/base/math/#Mathematical-Functions).

 %% Cell type:markdown id:d048851b-8eac-4dc3-81b7-ea1d625a1db2 tags:

 So far, we have only been using the functions that come with Julia, but it is also possible to add new functions.
 Defining functions follows a rather intuitive syntax. The value obtained by evaluating the last expression of a `function` block will be automatically returned:

 %% Cell type:markdown id:f43cb468-832a-4cab-b8a3-15bb9bcbfb0d tags:

 Bisher haben wir nur die Funktionen verwendet, die mit Julia geliefert werden, aber es ist auch möglich, neue Funktionen hinzuzufügen.
 Die Definition von Funktionen folgt einer recht intuitiven Syntax. Der Wert, der durch Auswerten des letzten Ausdrucks eines `function`-Blocks erhalten wird, wird automatisch zurückgegeben:

 %% Cell type:code id:fd2f4828-47f5-4df4-b5bd-a42625487b5a tags:

 ``` julia
 function mymult(x, y)
    x * y
 end
 ```

 %% Cell type:markdown id:08bab11e-df61-4906-a925-b93184e5c600 tags:

 For one-line functions one may also use a convenient short-hand:

 %% Cell type:markdown id:e8dfb238-54be-4a95-9eda-4ce1fa5cfd74 tags:

 Für Einzeiler-Funktionen kann man auch eine praktische Kurzschreibweise verwenden:

 %% Cell type:code id:5ed8292a-96e2-49ad-8f00-3c07b9483637 tags:

 ``` julia
 mysquare(x) = mymult(x, x)
 ```

 %% Cell type:markdown id:13b7892e-df8a-462f-a84c-107276d8e499 tags:

 Both such functions are fully generic in the argument types

 %% Cell type:markdown id:9b688bbf-08b6-4fba-babe-b16b6e1119be tags:

-Für Einzeiler-Funktionen kann man auch eine praktische Kurzschreibweise verwenden:
+Beide Funktionen sind in den Argumenttypen vollständig generisch

 %% Cell type:code id:49ceeeff-5291-460d-800d-5ed11a03b13e tags:

 ``` julia
 @show mysquare(2)           # Use integer arithmetic
 @show mymult(-1, 3. + 2im)  # Use complex arithmetic
 @show mysquare(" abc ");    # Use string concatenation
 ```

 %% Cell type:markdown id:15ece147-0384-4c1b-a8c3-d11a795bd1b7 tags:

 Notice, that for each type combination a separate piece of code will be compiled even though we only *defined* the functionality a single time. This compilation takes place on first use of a particular tuple of types.

 %% Cell type:markdown id:6add8ab6-7f66-431b-9e9e-e52d45379483 tags:

 Beachten Sie, dass für jede Kombination von Typen ein separater Codeabschnitt kompiliert wird, obwohl wir die Funktionalität nur einmal *definiert* haben. Diese Kompilierung findet beim ersten Gebrauch eines bestimmten Tupels von Typen statt.

 %% Cell type:code id:7e5dcfeb-960a-47f3-b2f8-f6f0906d2f24 tags:

 ``` julia
 mymult
 ```

 %% Cell type:markdown id:934dc8e8-564b-4566-9eb0-a96df39f0870 tags:

 and may be passed around to other functions, for example:

 %% Cell type:markdown id:3be89ab5-16f3-4633-bb8d-fd74cf39ddec tags:

 und können an andere Funktionen übergeben werden, zum Beispiel:

 %% Cell type:code id:171b1a83-c076-4ac4-a309-9d607ea0b5a4 tags:

 ``` julia
 """The fold function, applying f from the left and accumulating the results"""
 function myfold(f, x, y, z)
    f(f(x, y), z)
 end
 myfold(mymult, "Hello", " Julia ", "World")
 ```

 %% Cell type:markdown id:f31327e4-5d69-4dfb-a4bf-ed1e419b1be3 tags:

 Julia makes a distinction between **functions** and **methods**. Roughly speaking **function**s specify *what* is done and **methods** specify *how* this is done.

 Methods are concrete implementations in form of a list of Julia expressions to be executed, when the function name is used in the code. Multiple methods may be defined for the same function name. They differ in the number of arguments or in the supported argument types (more on this in the next notebook). When a particular function name is used in the code, Julia looks at the types of the arguments and uses this information to **dispatch** to the best-fitting method.

 For our `myfold` example, one could easily imagine a few more method implementations, for example:

 %% Cell type:markdown id:09a40182-e59f-42e4-b11e-0c3aedd0e7a6 tags:

 Julia unterscheidet zwischen **Funktionen** und **Methoden**. Grob gesagt geben **Funktionen** an, *was* gemacht wird, und **Methoden** geben an, *wie* dies gemacht wird.

 Methoden sind konkrete Implementierungen in Form von einer Liste von Julia-Ausdrücken, die ausgeführt werden, wenn der Funktionsname im Code verwendet wird. Für den gleichen Funktionsnamen können mehrere Methoden definiert werden. Sie unterscheiden sich in der Anzahl der Argumente oder in den unterstützten Argumenttypen (dazu mehr im nächsten Notebook). Wenn ein bestimmter Funktionsname im Code verwendet wird, betrachtet Julia die Typen der Argumente und verwendet diese Informationen, um zur am besten passenden Methode zu **dispatchen**.

 Für unser `myfold`-Beispiel könnte man sich leicht einige weitere Methodenimplementierungen vorstellen, zum Beispiel:

 %% Cell type:code id:c249f818-6544-42fe-b387-34058e5f5890 tags:

 ``` julia
 myfold(f, x) = x
 myfold(f, x, y) = f(x, y)
 ```

 %% Cell type:code id:88f62159-2a1b-4a5a-8434-0e91810f2c69 tags:

 ``` julia
 methods(myfold)
 ```

 %% Cell type:markdown id:879d9441-ece1-4f07-a496-6aef71fd2e91 tags:

 So now `myfold` works transparently with 1, 2 or 3 arguments:

 %% Cell type:markdown id:cc818df4-a037-4ba2-8588-1afe4a6de222 tags:

 Nun funktioniert `myfold` transparent mit 1, 2 oder 3 Argumenten:

 %% Cell type:code id:d67f9c21-2c5c-43fd-a7e4-a4ce74281bf0 tags:

 ``` julia
 @show myfold(mymult, 2., 3.)
 @show myfold(+, 1)
 @show myfold(==, false, false, true)
 ```

 %% Cell type:markdown id:59fa4c2a-a1fa-4a1b-9529-68f821589206 tags:

 We can also check which method is actually employed using the `@which` macro:

 %% Cell type:markdown id:5a9a652b-80c4-482f-80b8-2c5340e61a21 tags:

 Wir können auch überprüfen, welche Methode tatsächlich verwendet wird, indem wir das `@which`-Makro verwenden:

 %% Cell type:code id:0fa105fb-b3ad-405a-85f1-598a12cbc655 tags:

 ``` julia
 @which myfold(*, 1, 2)
 ```

 %% Cell type:markdown id:73fa3be7-67a8-4817-9d94-e04765513dd3 tags:

 Standard functions (like `+` or `*`) are by no means special and behave exactly the same way as custom functions ... including the ability to define new methods for them:

 %% Cell type:markdown id:4046d2e8-2018-4f4f-b816-2a6156301f39 tags:

 Standardfunktionen (wie `+` oder `*`) sind keineswegs speziell und verhalten sich genau wie benutzerdefinierte Funktionen ... einschließlich der Möglichkeit, neue Methoden für sie zu definieren:

 %% Cell type:code id:d771af33-5174-4a95-b8e3-ac1c29eb71e9 tags:

 ``` julia
 import Base: + # we have to import functions to override/extend them
 +(x::String, y::String) = x * " " * y
 ```

 %% Cell type:code id:32429003-4879-4a37-ad3c-153857a360dd tags:

 ``` julia
 "Hello" + "World!"
 ```

 %% Cell type:markdown id:8fdf6362-7ca3-4d32-a542-26df56b83108 tags:

 (**Important note:** Since we neither own the `+` function nor the `String` type, this is known as **type piracy** and should in general be avoided!)

 %% Cell type:markdown id:ee25eff6-f56e-4230-b52d-6020dcc29bb2 tags:

 (**Wichtiger Hinweis:** Da wir weder die `+` Funktion noch den `String` Typ besitzen, handelt es sich hierbei um **Typenpiraterie** und sollte im Allgemeinen vermieden werden!)

 %% Cell type:markdown id:89ffcdef-cf06-438f-8448-4bf6dfd1af7e tags:

 Now standard functions relying on `+` just magically work:

 %% Cell type:markdown id:a2c9d8cf-0462-415c-a466-edb33b3aadec tags:

 Nun funktionieren Standardfunktionen, die auf `+` angewiesen sind, einfach magisch:

 %% Cell type:code id:75b4afeb-a3f4-40d7-8b23-b961b01c41bc tags:

 ``` julia
 sum(["a", "b", "c", "d", "e"])
 ```

 %% Cell type:markdown id:d8edaaf0-3de7-4a63-b0bd-bff53ba060f4 tags:

 Variables and parameters are local, they exist only inside the functions where they are defined:

 %% Cell type:markdown id:013b3faf-5f12-482b-956e-de97a2a4830d tags:

 Variablen und Parameter sind lokal, sie existieren nur innerhalb der Funktionen, in denen sie definiert sind:

 %% Cell type:code id:d02e6bca-6723-4a05-82ee-1f30ba127bd5 tags:

 ``` julia
 function multiply_and_print(a, b)
    product = a * b
    println(product)
 end

 multiply_and_print(2, 3)
 println(product)
 ```

 %% Cell type:markdown id:29968f96-5766-4cb7-8538-3bef9aeb8cc9 tags:

 It may not be clear why it is worth the trouble to divide a program into functions. There are several reasons:
  - Creating a new function gives you an opportunity to name a group of statements, which makes your program easier to read and debug.
  - Functions can make a program smaller by eliminating repetitive code. Later, if you make a change, you only have to make it in one place.
  - Dividing a long program into functions allows you to debug the parts one at a time and then assemble them into a working whole.
  - Well-designed functions are often useful for many programs. Once you write and debug one, you can reuse it.
  - In Julia, functions can improve performance a lot.

 %% Cell type:markdown id:0a398295-22e0-45dc-b43c-5f1915a16364 tags:

 Es mag nicht klar sein, warum es sich lohnt, ein Programm in Funktionen zu unterteilen. Es gibt mehrere Gründe dafür:

- Das Erstellen einer neuen Funktion bietet Ihnen die Möglichkeit, eine Gruppe von Anweisungen zu benennen, was Ihr Programm leichter lesbar und einfacher zu debuggen macht.
+- Das Erstellen einer neuen Funktion bietet die Möglichkeit, eine Gruppe von Anweisungen zu benennen, was das Programm leichter lesbar und einfacher zu debuggen macht.
 - Funktionen können ein Programm kleiner machen, indem sie wiederholten Code eliminieren. Später, wenn Sie eine Änderung vornehmen, müssen Sie sie nur an einer Stelle vornehmen.
 - Das Aufteilen eines langen Programms in Funktionen ermöglicht es Ihnen, die Teile nacheinander zu debuggen und dann zu einem funktionierenden Ganzen zusammenzufügen.
 - Gut gestaltete Funktionen sind oft für viele Programme nützlich. Sobald Sie eine geschrieben und debuggt haben, können Sie sie wiederverwenden.
- In Julia können Funktionen die Leistung erheblich verbessern.
+- In Julia können Funktionen die Schnelligkeit erheblich verbessern.

 %% Cell type:markdown id:7780ae66-db68-48c1-ba62-a883406f1f1c tags:

 More details: [https://docs.julialang.org/en/v1/manual/methods/](https://docs.julialang.org/en/v1/manual/methods/)

 %% Cell type:markdown id:dfa722c2-bd4c-4162-b10d-24c0f8e990e0 tags:

 Weitere Details finden Sie unter: [https://docs.julialang.org/en/v1/manual/methods/](https://docs.julialang.org/en/v1/manual/methods/)

 %% Cell type:markdown id:d914b36b-8b05-4c68-bf57-1fc74aeb26df tags:

 ### Exercises

 %% Cell type:markdown id:a4eafce6-b493-470f-86a3-93319684ee40 tags:

 ### Übungen

 %% Cell type:markdown id:247215e4-47e1-4eb6-978b-a09f14478bb8 tags:

  - Write a function `printgrid` that draws a grid like the following:

 %% Cell type:markdown id:08fe364b-e611-419b-97f2-e806881d6227 tags:

 - Schreiben Sie eine Funktion `printgrid`, die ein Raster wie folgt zeichnet:

 %% Cell type:markdown id:1704f451-9500-41c5-b74b-4a2b4a7b910f tags:

    + - - - - + - - - - +
    |         |         |
    |         |         |
    |         |         |
    |         |         |
    + - - - - + - - - - +
    |         |         |
    |         |         |
    |         |         |
    |         |         |
    + - - - - + - - - - +

 %% Cell type:code id:58ef3248-f85e-4825-bf10-02cee3e068cb tags:

 ``` julia
 ```

 %% Cell type:markdown id:e6a58742-9d24-47a5-aa68-73d44ca05127 tags:

  - Write a function that draws a similar grid with four rows and four columns.

 %% Cell type:markdown id:41f2bf0f-73f4-4671-b059-1118c35ec76f tags:

 - Schreiben Sie eine Funktion, die ein ähnliches Raster mit vier Zeilen und vier Spalten zeichnet.

 %% Cell type:markdown id:b953857f-e8d7-47aa-bc8d-8e2bd1cd20fd tags:

 Tips:
  - To print more than one value on a line, you can print a comma-separated sequence of values: println("+", "-").
  - The function print does not advance to the next line.

 %% Cell type:markdown id:2e606498-6553-4037-a9f9-3b519ffc64c9 tags:

 Tipps:
 - Um mehr als einen Wert in einer Zeile auszugeben, können Sie eine kommagetrennte Sequenz von Werten ausgeben: println("+", "-").
 - Die Funktion print springt nicht zur nächsten Zeile.

 %% Cell type:code id:1ca1789d-eddb-4f41-9ad9-9259c6f22a14 tags:

 ``` julia
 ```

 %% Cell type:markdown id:2ebc911c-7fe0-4d7f-ab5d-d8084f25a93d tags:

 ### Recursive functions

 It is legal for one function to call another; it is also legal for a function to call itself. It may not be obvious why that is a good thing, but it turns out to be one of the most magical things a program can do. For example, look at the following function:

 %% Cell type:markdown id:53edcb8b-2f37-404f-8df6-d84b2327e96e tags:

 ### Rekursive Funktionen

 Es ist erlaubt, dass eine Funktion eine andere aufruft; es ist auch erlaubt, dass eine Funktion sich selbst aufruft. Es mag nicht offensichtlich sein, warum das eine gute Sache ist, aber es stellt sich heraus, dass es eine der magischsten Dinge ist, die ein Programm tun kann. Schauen Sie sich zum Beispiel die folgende Funktion an:

 %% Cell type:code id:e578011e-d0de-4f86-8c2c-a8408454d3ac tags:

 ``` julia
 function countdown(n)
    if n ≤ 0
        println("Blastoff!")
    else
        print(n, " ")
        countdown(n-1)
    end
 end
 ```

 %% Cell type:code id:3af51513-c92e-4488-b2fe-243e2fef6b95 tags:

 ``` julia
 countdown(10)
 ```

 %% Cell type:markdown id:c59c0f54-d967-4416-b57c-e855dfc2c350 tags:

 If a recursion never reaches a base case, it goes on making recursive calls forever, and the program never terminates. This is known as infinite recursion, and it is generally not a good idea. Here is a minimal program with an infinite recursion:

 %% Cell type:markdown id:73ea203a-3919-4e14-b50f-22c8362eb771 tags:

 Wenn eine Rekursion niemals einen Basisfall erreicht, macht sie unendliche rekursive Aufrufe, und das Programm terminiert nie. Dies wird als unendliche Rekursion bezeichnet und ist im Allgemeinen keine gute Idee. Hier ist ein minimales Programm mit einer unendlichen Rekursion:

 %% Cell type:code id:13a4a762-6584-47ab-9fb5-428557770d15 tags:

 ``` julia
 function recurse()
    recurse()
 end
 ```

 %% Cell type:code id:0dde579f-6b12-4072-aa62-aeee3a970503 tags:

 ``` julia
 recurse()
 ```

 %% Cell type:markdown id:22c8c79d-6d41-4758-9550-aaab4f1dc1b1 tags:

 ### Exercises
  - Write a recursive function to compute the factorial of a number.

 %% Cell type:markdown id:a0402c3d-95fa-44a1-86ab-ca229508f68f tags:

 ### Übungen
  - Schreiben Sie eine rekursive Funktion zur Berechnung der Fakultät einer Zahl.

 %% Cell type:code id:f4102487-011e-474f-ab79-3d7db1d3bbd9 tags:

 ``` julia
 ```

 %% Cell type:markdown id:d9c31712-941c-4611-99e5-b33cdb12e28f tags:

-  - Then write a function that computes bynomial coefficients
+  - Then write a function that computes binomial coefficients
 $$ \left(\begin{array}{c} n \\ k \end{array}\right) = \frac{n!}{k! (n-k)!} $$
 by calling the function of the previous points.

 %% Cell type:markdown id:a24cdaef-98b8-46f5-a809-992547882a4b tags:

  - Schreiben Sie dann eine Funktion, die die Binomialkoeffizienten berechnet
 $$ \left(\begin{array}{c} n \\ k \end{array}\right) = \frac{n!}{k! (n-k)!} $$
 indem sie die Funktion aus den vorherigen Punkten aufruft.

 %% Cell type:code id:b54c877e-5494-4657-ba7f-208bdc301225 tags:

 ``` julia
 ```

 %% Cell type:markdown id:4509db3f-8060-46ca-89ac-824c16f5751c tags:

 - Use the two functions to compute
 $$ 15! \qquad \left(\begin{array}{c} 5 \\ 2 \end{array}\right) \qquad \left(\begin{array}{c} 5 \\ 3 \end{array}\right) $$

 %% Cell type:markdown id:a32900cc-c244-4d63-8ff6-4d11cee83eee tags:

- - Verwenden Sie die beiden Funktionen, um zu berechnen
+ - Verwenden Sie die beiden Funktionen, um folgendes zu berechnen
 $$ 15! \qquad \left(\begin{array}{c} 5 \\ 2 \end{array}\right) \qquad \left(\begin{array}{c} 5 \\ 3 \end{array}\right) $$

 %% Cell type:code id:fb02aad5-d9d4-4f0d-8118-b02b73506b89 tags:

 ``` julia
 ```

 %% Cell type:markdown id:240cc4bd-3e45-45b8-ad98-170dbb68f78d tags:

 ### Keywords argument

 Function arguments can be either position based (like what we saw so far) or keyword based, like in the following example.

 %% Cell type:markdown id:b5944412-0d39-4c0b-a0d5-fbeee22e1432 tags:

 ### Schlüsselwortargumente

 Funktionsargumente können entweder positionsbasiert (wie wir bisher gesehen haben) oder schlüsselwortbasiert sein, wie im folgenden Beispiel.

 %% Cell type:code id:30ddeb3b-be35-40eb-8491-1269a4e19f62 tags:

 ``` julia
 function greet(name; greeting="Hello")
    println("$(greeting), $(name)!")
 end
 ```

 %% Cell type:code id:b39f22b1-4a1b-4afd-b6db-041bd7150b66 tags:

 ``` julia
 greet("Michele")
 greet("Lambert"; greeting="Hallo")
+greet("YingXing"; greeting="你好")
 ```

 %% Cell type:markdown id:52b90aa8-4b19-4371-8fae-2121a78fbb96 tags:

 This is quite convenient in the following cases:
  - to set a default behavior of the function, while retaining the possibility to finely control it.
  - to add at a later point in time new functionality, without breaking retrocompatibility.

 %% Cell type:markdown id:07e76016-d5a9-4616-b0b9-2dc9b6f3c8f6 tags:

 Dies ist in den folgenden Fällen sehr praktisch:
-  - um ein Standardverhalten der Funktion festzulegen, während die Möglichkeit besteht, es fein zu steuern.
+  - um ein Standardverhalten der Funktion festzulegen, während die Möglichkeit besteht, sie fein zu steuern.
  - um zu einem späteren Zeitpunkt neue Funktionalitäten hinzuzufügen, ohne die Abwärtskompatibilität zu brechen.

 %% Cell type:markdown id:c939f951-2aaf-4e39-a60f-df7600af1d8f tags:

 ## Further Exercises

 %% Cell type:markdown id:883b3945-d30a-4f27-928f-458c9ad74e9b tags:

 ## Weitere Übungen

 %% Cell type:markdown id:59e2e997-42f7-426c-bfd0-233724704117 tags:

  - Create a function called `fibonacci_sum` that takes a positive integer n as input. This function should return the sum of the first n terms of the Fibonacci sequence.

 %% Cell type:markdown id:54537041-60eb-4961-9805-1d7d405fde1a tags:

 - Erstellen Sie eine Funktion namens `fibonacci_sum`, die eine positive ganze Zahl n als Eingabe erhält. Diese Funktion sollte die Summe der ersten n Terme der Fibonacci-Folge zurückgeben.

 %% Cell type:code id:7ca7c936-fb80-4aed-9788-75a55bb207ad tags:

 ``` julia
 ```

 %% Cell type:markdown id:49fd546f-009d-46ff-af61-6954000bce5f tags:

  - Write a function that converts a Celsius temperature in Fahrenheit and returns the result. Additionally, if the temperature is below freezing (0°C), the program should print a message indicating that it's below freezing.

 %% Cell type:markdown id:70dacb25-360f-4a7a-8c03-73cd0d75dc3e tags:

 - Schreiben Sie eine Funktion, die eine Celsius-Temperatur in Fahrenheit umrechnet und das Ergebnis zurückgibt. Zusätzlich sollte das Programm, wenn die Temperatur unter dem Gefrierpunkt (0°C) liegt, eine Meldung ausgeben, die anzeigt, dass es unter dem Gefrierpunkt liegt.

 %% Cell type:code id:a30a1812-6116-4441-8786-7450c60ef354 tags:

 ``` julia
 ```

 %% Cell type:markdown id:e2c81cc5-7d0d-4a5a-ba69-81686648df90 tags:

  - Write a function which analyzes a sentence. The function should then count and display the number of vowels (both upper and lower case) in the sentence.

 %% Cell type:markdown id:8cabe824-c7eb-46fc-afb8-e039528d2d2a tags:

 - Schreiben Sie eine Funktion, die einen Satz analysiert. Die Funktion sollte dann die Anzahl der Vokale (sowohl in Groß- als auch in Kleinbuchstaben) im Satz zählen und anzeigen.

 %% Cell type:code id:af0e28bd-2b3f-41af-aa92-456e29d50679 tags:

 ``` julia
 ```

--- a/2_Advanced_Data_Types.ipynb
+++ b/2_Advanced_Data_Types.ipynb
 %% Cell type:markdown id:4fe99eff-729a-4d93-ab82-487e5143bae5 tags:

 # Advanced Data Types

 %% Cell type:markdown id:5de78ecc-bbde-49ff-b618-b8c8c440ce47 tags:

 # Fortgeschrittene Datentypen

 %% Cell type:markdown id:7969b8f9-335a-4bd2-82f7-1d9795234ed5 tags:

 ## Dictionaries

 %% Cell type:markdown id:8ffb53e2-1813-4fdf-962e-e066bc9b737c tags:

-## Wörterbücher
+## Zuordnungstabellen (assoziative Listen)

 %% Cell type:markdown id:ea8518c1-8e1d-4532-8055-e04c3aa3e7c4 tags:

 A dictionary contains a collection of indices, which are called keys, and a collection of values. Each key is associated with a single value. The association of a key and a value is called a key-value pair or sometimes an item.

-The function `Dict` creates a new dictionary with no items. Because Dict is the name of a built-in function, you should avoid using it as a variable name.
+The function `Dict` creates a new dictionary with no items. Because `Dict` is the name of a built-in function, you should avoid using it as a variable name.

 %% Cell type:markdown id:548487ed-dc9d-4404-a2ab-451c0ea742e4 tags:

-Ein Wörterbuch enthält eine Sammlung von Indizes, die als Schlüssel bezeichnet werden, und eine Sammlung von Werten. Jeder Schlüssel ist mit einem einzigen Wert verbunden. Die Zuordnung eines Schlüssels und eines Wertes wird als Schlüssel-Wert-Paar oder manchmal als Element bezeichnet.
+Eine Zuordnungstabelle enthält eine Sammlung von Indizes, die als Schlüssel bezeichnet werden, und eine Sammlung von Werten. Jeder Schlüssel ist mit einem einzigen Wert verbunden. Die Zuordnung eines Schlüssels und eines Wertes wird als Schlüssel-Wert-Paar oder manchmal als Element bezeichnet.

-Die Funktion `Dict` erstellt ein neues Wörterbuch ohne Elemente. Da Dict der Name einer integrierten Funktion ist, sollte man ihn vermeiden, als Variablenname zu verwenden.
+Die Funktion `Dict` erstellt ein neues Wörterbuch ohne Elemente. Da `Dict` der Name einer integrierten Funktion ist, sollte man vermeiden ihn als Variablenname zu verwenden.

 %% Cell type:code id:59ae8d17-a6f6-4210-95bc-0e7492bc8a7a tags:

 ``` julia
 eng2de = Dict()
 ```

 %% Cell type:code id:28490ea3-c4d3-4e4d-915f-612ad36c9472 tags:

 ``` julia
 eng2de["one"] = "ein";
 ```

 %% Cell type:markdown id:f2aff40c-6dcb-421a-b67f-1662c5bf4702 tags:

 You can also initialize a dictionary with items as:

 %% Cell type:markdown id:09b62b4d-748b-4e1d-91f2-7db610ad02ac tags:

-Du kannst auch ein Wörterbuch mit Elementen initialisieren, wie folgt:
+Du kannst auch eine Zuordnungstabelle mit Elementen wie folgt initialisieren:

 %% Cell type:code id:92fc203b-4ba8-432a-a541-c4ccf3292195 tags:

 ``` julia
 eng2de = Dict("one" => "ein", "two" => "zwei", "three" => "drei")
 ```

 %% Cell type:markdown id:c52d24af-ec90-4b8c-bdd9-988129a7fa81 tags:

 Dictionaries are mutable, meaning that it is always possible to modify their elements, add new key-value pairs or removing existing ones.

 %% Cell type:markdown id:809e7c99-22f0-4440-921d-e5904cadc8a4 tags:

 Wörterbücher sind veränderbar, was bedeutet, dass es immer möglich ist, ihre Elemente zu ändern, neue Schlüssel-Wert-Paare hinzuzufügen oder bestehende zu entfernen.

 %% Cell type:code id:22b295dc-994e-4bbc-ac8d-da5ab9e73493 tags:

 ``` julia
 eng2de["four"] = "VIER"
 @show eng2de
 eng2de["four"] = "vier"
 @show eng2de
 delete!(eng2de, "four")
 @show eng2de;
 ```

 %% Cell type:markdown id:01513ad2-3083-4c89-adca-ccc8a88d93d4 tags:

 In general, the order of the key-value pairs is unpredictable. However this is not important, as the values are always accessed using the keys.

 %% Cell type:markdown id:d8b4ee03-5592-4567-883b-e0842fefeff4 tags:

 Im Allgemeinen ist die Reihenfolge der Schlüssel-Wert-Paare unvorhersehbar. Dies ist jedoch nicht wichtig, da die Werte immer mithilfe der Schlüssel abgerufen werden.

 %% Cell type:code id:e9e4c5b9-9539-4294-a6ec-0a29fb76bf7b tags:

 ``` julia
 eng2de["two"]
 ```

 %% Cell type:markdown id:9944dbbd-478b-4ae1-ac89-e16be08a0868 tags:

 If the key isn’t in the dictionary, you get an exception:

 %% Cell type:markdown id:84cf8b52-f061-4b28-a327-bc527820517c tags:

-Wenn der Schlüssel nicht im Wörterbuch vorhanden ist, tritt eine Ausnahme auf:
+Wenn der Schlüssel nicht im Wörterbuch vorhanden ist, tritt eine Fehlermeldung auf:

 %% Cell type:code id:8221269b-7a8f-4cfd-ab8e-0aa4fd6c962d tags:

 ``` julia
 eng2de["four"]
 ```

 %% Cell type:markdown id:a545abaa-78dc-4625-84e9-03b1c8beaaf8 tags:

 The `length` function works on dictionaries; it returns the number of key-value pairs:

 %% Cell type:markdown id:f83d51c5-2c1d-4449-8cd5-e80f224b9a76 tags:

-Die Funktion `length` funktioniert auch bei Wörterbüchern; sie gibt die Anzahl der Schlüssel-Wert-Paare zurück:
+Die Funktion `length` funktioniert auch bei Zuordnungstabellen; sie gibt die Anzahl der Schlüssel-Wert-Paare zurück:

 %% Cell type:code id:0e242667-b921-4242-bdcc-cbcac14909b2 tags:

 ``` julia
 length(eng2de)
 ```

 %% Cell type:markdown id:8e42655b-f2a0-41f0-be90-015ebfeafdb9 tags:

 The function `keys` returns a collection with the keys of the dictionary:

 %% Cell type:markdown id:b4ac7b46-9fc0-47fd-b6c0-c97791517b51 tags:

 Die Funktion `keys` gibt eine Sammlung mit den Schlüsseln des Wörterbuchs zurück:

 %% Cell type:code id:3236f973-d3fa-42ba-a1c0-41e0002446cb tags:

 ``` julia
 keys(eng2de)
 ```

 %% Cell type:markdown id:acfa7044-5695-4af8-b4bc-320c8a48a220 tags:

 Now you can use the `∈` operator to see whether something appears as a key in the dictionary:

 %% Cell type:markdown id:f9bc6fe5-3f7a-458e-942a-11bd3e83dcc6 tags:

 Nun kannst du den Operator `∈` verwenden, um zu sehen, ob etwas als Schlüssel im Wörterbuch vorhanden ist:

 %% Cell type:code id:1fdeb10c-0d84-4c22-b734-d68e2eafe375 tags:

 ``` julia
 @show "one" ∈ keys(eng2de)
 @show "four" ∈ keys(eng2de);
 ```

 %% Cell type:markdown id:986919d6-4f27-4fad-b222-20697bf6af40 tags:

 To see whether something appears as a value in a dictionary, you can use the function `values`, which returns a collection of values, and then use the `∈` operator:

 %% Cell type:markdown id:864d141e-6cd2-45e6-95fe-e84cca35cf70 tags:

 Um zu überprüfen, ob etwas als Wert in einem Wörterbuch vorhanden ist, kannst du die Funktion `values` verwenden, die eine Sammlung von Werten zurückgibt, und dann den Operator `∈` verwenden:

 %% Cell type:code id:ab90dad1-61d0-4dbd-b829-a354c13fcb71 tags:

 ``` julia
 @show "ein" ∈ values(eng2de)
 @show "vier" ∈ values(eng2de);
 ```

 %% Cell type:markdown id:049c9dfd-1e51-4898-98e5-a4b812d0bba2 tags:

 ### Loops over dictionaries

 You can traverse the keys of the dictionary in a `for` statement.

 %% Cell type:markdown id:5b255b31-8aca-49b4-a95f-302c59baa975 tags:

-### Schleifen über Wörterbücher
+### Schleifen über Zuordnungstabellen

-Du kannst die Schlüssel des Wörterbuchs in einer `for`-Schleife durchlaufen.
+Du kannst die Schlüssel der Zuordnungstabelle in einer `for`-Schleife durchlaufen.

 %% Cell type:code id:e7062d3f-2125-4ecd-ab13-d04944a71fe1 tags:

 ``` julia
 function print_dictionary(dic)
    for key in keys(dic)
        println(key, " ", dic[key])
    end
 end

 print_dictionary(eng2de)
 ```

 %% Cell type:markdown id:cf27195c-e601-49ca-b03d-63162bf59bce tags:

 Again, the keys are in no particular order. To traverse the keys in alphabetically sorted order, you can combine `sort` and `collect`:

 %% Cell type:markdown id:a6b3285a-58f6-41b6-8755-2732a367424e tags:

 Auch hier sind die Schlüssel in keiner bestimmten Reihenfolge. Um die Schlüssel in alphabetisch sortierter Reihenfolge zu durchlaufen, kannst du `sort` und `collect` kombinieren:

 %% Cell type:code id:6d52aeba-3c7e-405c-bcfe-d76e37e94f51 tags:

 ``` julia
 function print_dictionary_sorted(dic)
    for key in sort(collect(keys(dic)))
        println(key, " ", dic[key])
    end
 end

 print_dictionary_sorted(eng2de)
 ```

 %% Cell type:markdown id:8daa9d3e-19de-4415-ba6c-6aeb174b38fa tags:

-### Exercises
+### Exercise
  - Write a function that given a string as input counts how many times each letter appears. Use a dictionary.

 %% Cell type:markdown id:964165ee-4d0d-4122-b6b2-d3926101cab2 tags:

-### Übungen
+### Übung
  - Schreibe eine Funktion, die bei Eingabe eines Strings zählt, wie oft jeder Buchstabe vorkommt. Verwende ein Wörterbuch.

 %% Cell type:code id:aba1978b-e675-48a7-89aa-75553db70537 tags:

 ``` julia
 ```

 %% Cell type:markdown id:3a9b281f-6cc0-4d39-b9e2-d816823f9873 tags:

 ## Tuples and named tuples

 %% Cell type:markdown id:0acaa2f9-372c-4a3e-be01-27cfe2853fdb tags:

 ## Tupel und benannte Tupel

 %% Cell type:markdown id:a722109e-86cc-44e3-9256-a3e93a1668f5 tags:

 A tuple is a sequence of values. The values can be of any type, and they are indexed by integers. The tuples are immutable and each element can have its own type.

 %% Cell type:markdown id:68ea4303-ce3c-4647-8e9f-89afd0a6a670 tags:

 Ein Tupel ist eine Sequenz von Werten. Die Werte können beliebigen Typs sein und sie werden durch Ganzzahlen indexiert. Die Tupel sind unveränderlich und jedes Element kann seinen eigenen Typ haben.

 %% Cell type:code id:8502cf2e-8bea-4707-811c-f4e6e1de3c8f tags:

 ``` julia
 t = 'a', 'b', 'c', 'd', 'e'
 ```

 %% Cell type:markdown id:d01f5647-a240-4620-9a3a-782835aca39c tags:

 Although it is not necessary, it is common to enclose tuples in parentheses:

 %% Cell type:markdown id:2632b11b-de4b-4f21-bcc6-06a32517c121 tags:

 Obwohl es nicht notwendig ist, ist es üblich, Tupel in Klammern zu setzen:

 %% Cell type:code id:bfa31b99-bf9d-49bb-babc-fe8a65248429 tags:

 ``` julia
 t = ('a', 'b', 'c', 'd', 'e')
 ```

 %% Cell type:markdown id:3fa935e0-0611-4b8a-982c-329c33a74f99 tags:

 To create a tuple with a single element, you have to include a final comma:

 %% Cell type:markdown id:86fa8b6b-bbbf-4c9c-a5c0-63b00b2c59cb tags:

 Um ein Tupel mit einem einzigen Element zu erstellen, musst du ein abschließendes Komma setzen:

 %% Cell type:code id:cb1bea15-2b80-43b2-be8e-27507d550fca tags:

 ``` julia
 t1 = ('a',)
 @show typeof(t1)

 t2 = ('a')
 @show typeof(t2);
 ```

 %% Cell type:markdown id:193457ac-4e4b-4e58-8c28-6d8b4331d532 tags:

 Another way to create a tuple is the built-in function tuple. With no argument, it creates an empty tuple:

 %% Cell type:markdown id:d6f34b5b-2aaa-49db-b2a8-d5891fe33ee1 tags:

 Eine andere Möglichkeit, ein Tupel zu erstellen, ist die integrierte Funktion `tuple`. Ohne Argument erstellt sie ein leeres Tupel:

 %% Cell type:code id:952acafe-ca5d-4b58-8969-224b0fe3a28f tags:

 ``` julia
 t3 = tuple()
 @show typeof(t3)

 t4 = tuple(1, 'a', π, 12.0)
 @show typeof(t4);
 ```

 %% Cell type:markdown id:729c3597-1a35-4a26-ae7a-6dadee31daeb tags:

 Using the bracket operator it is possible to access an element. Note, differently from other programming languages (for example C, C++, Python) in Julia the first element is 1.

 %% Cell type:markdown id:efc3d061-7e93-4863-a802-a7cdb869af7e tags:

 Mit dem eckigen Klammern-Operator ist es möglich, auf ein Element zuzugreifen. Beachte, dass in Julia das erste Element, anders als in anderen Programmiersprachen (zum Beispiel C, C++, Python), mit 1 indexiert wird.

 %% Cell type:code id:9817c28f-428d-4d5b-8384-608f9b4d763d tags:

 ``` julia
 t4[2]
 ```

 %% Cell type:markdown id:2519be57-8c10-4878-a772-017b099f6a4c tags:

 It is also possible to get multiple elements by using slices.

 %% Cell type:markdown id:17a0f0ee-e03f-4669-a5f1-889d875577d9 tags:

 Es ist auch möglich, mehrere Elemente mithilfe von Slices zu erhalten.

 %% Cell type:code id:c48ac07f-3a4e-4bb8-9551-2973ea8d2f9c tags:

 ``` julia
 @show t4[1:3];
 ```

 %% Cell type:markdown id:aeda8602-f9da-4173-a692-54e2e9a0e178 tags:

 But if you try to modify one of the elements of the tuple, you get an error:

 %% Cell type:markdown id:d0f25a1f-0a4c-4ab4-a339-f5ba64806681 tags:

 Aber wenn du versuchst, eines der Elemente des Tupels zu ändern, tritt ein Fehler auf:

 %% Cell type:code id:cfc94cc9-832c-45d2-85b8-aaf789f33f6a tags:

 ``` julia
 t4[2] = 'b'
 ```

 %% Cell type:markdown id:b9f13b5c-9e61-46b9-a47d-f90199bd7bd2 tags:

 Because tuples are immutable, you can’t modify the elements.

 %% Cell type:markdown id:d956168e-36e4-4abb-a3d6-3c53a857e78d tags:

 Da Tupel unveränderlich sind, kannst du die Elemente nicht ändern.

 %% Cell type:markdown id:a10cb9a7-8f44-44f8-831f-178b780e4ac9 tags:

 Strictly speaking, a function can only return one value, but if the value is a tuple, the effect is the same as returning multiple values. For example, if you want to divide two integers and compute the quotient and remainder, it is inefficient to compute x ÷ y and then x % y. It is better to compute them both at the same time.

 The built-in function `divrem` takes two arguments and returns a tuple of two values, the quotient and remainder. You can store the result as a tuple:

 %% Cell type:markdown id:6a115819-54fd-4550-b097-59fea3ecb523 tags:

 Genau genommen kann eine Funktion nur einen Wert zurückgeben, aber wenn der Wert ein Tupel ist, hat dies den gleichen Effekt wie das Zurückgeben mehrerer Werte. Zum Beispiel, wenn du zwei Ganzzahlen teilen und den Quotienten und den Rest berechnen möchtest, ist es ineffizient, zuerst x ÷ y und dann x % y zu berechnen. Es ist besser, beides gleichzeitig zu berechnen.

 Die integrierte Funktion `divrem` nimmt zwei Argumente entgegen und gibt ein Tupel aus zwei Werten zurück, dem Quotienten und dem Rest. Du kannst das Ergebnis als Tupel speichern:

 %% Cell type:code id:d1dde137-036f-4b93-8010-13b3e835ebd8 tags:

 ``` julia
 t = divrem(7, 3)
 ```

 %% Cell type:markdown id:ea615dbd-effb-4442-b160-20e7c9b6c22e tags:

 Alternatively, we can use tuple assignment to store the elements separately:

 %% Cell type:markdown id:9cd48d9c-cf1d-4546-a2c0-4bb54a42e1e8 tags:

 Alternativ können wir die Zuweisung als Tupel verwenden, um die Elemente getrennt zu speichern:

 %% Cell type:code id:c4969556-7945-43c9-8b96-1ea1032cbb3c tags:

 ``` julia
 q, r = divrem(7, 3)

 @show q r;
 ```

 %% Cell type:markdown id:4574e191-aaa8-4834-8837-54947d6ddf30 tags:

 ### Gather and scatter

 Functions can take a variable number of arguments. A parameter name that ends with `...` gathers arguments into a tuple. For example, `printall` takes any number of arguments and prints them one by line:

 %% Cell type:markdown id:e4177fab-a386-4274-8657-bbc6698ec1e5 tags:

 ### Sammeln und verteilen

 Funktionen können eine variable Anzahl von Argumenten entgegennehmen. Ein Parametername, der mit `...` endet, sammelt die Argumente in ein Tupel. Zum Beispiel nimmt `printall` eine beliebige Anzahl von Argumenten entgegen und gibt sie nacheinander aus:

 %% Cell type:code id:43f8c7ad-5ac2-425e-a50f-c45624bb3d8a tags:

 ``` julia
 function printall(args...)
    for arg in args
        println(arg)
    end
 end

 printall(1)
 printall(1, 2.0, '3')
 ```

 %% Cell type:markdown id:eb662374-fe83-49d7-a5be-d9582d037ad1 tags:

 The complement of gather is scatter. If you have a sequence of values and you want to pass it to a function as multiple arguments, you can use the `...` operator. For example, `divrem` takes exactly two arguments; it doesn’t work with a tuple:

 %% Cell type:markdown id:28b3cd91-bf05-43bc-a253-2bee077a1df1 tags:

 Das Gegenstück zu "sammeln" ist "verteilen". Wenn du eine Sequenz von Werten hast und sie als mehrere Argumente an eine Funktion übergeben möchtest, kannst du den Operator `...` verwenden. Zum Beispiel nimmt `divrem` genau zwei Argumente an; es funktioniert nicht mit einem Tupel:

 %% Cell type:code id:bf55fc10-8432-41e3-bd6c-2244c8c96513 tags:

 ``` julia
 t = (7, 3)
 divrem(t)
 ```

 %% Cell type:markdown id:d05def39-3244-4acd-a082-a7ee532f8f1d tags:

 But if you scatter the tuple, it works:

 %% Cell type:markdown id:db3cd00d-d41c-4f68-95d4-c4e5b283734a tags:

-Aber wenn du das Tupel verteilst, funktioniert es:
+Wenn du aber das Tupel verteilst, funktioniert es:

 %% Cell type:code id:e7df53bc-6b2d-4501-9ca8-61e3cb79eb1a tags:

 ``` julia
 t = (7, 3)
 divrem(t...)
 ```

 %% Cell type:markdown id:2cf01c32-9d1b-4e83-9375-f737e51c58ed tags:

 ### Dictionaries and Tuples

 %% Cell type:markdown id:dad5d7bf-0dd5-450b-90f3-7768f2d91c18 tags:

-### Wörterbücher und Tupel
+### Zuordnungstabellen und Tupel

 %% Cell type:markdown id:00e97ccc-8e64-4eef-84be-85a266eb3490 tags:

 Dictionaries can be used as iterators that iterate the key-value pairs. You can use it in a `for` loop like this:

 %% Cell type:markdown id:3a38cabd-b056-4140-a75c-e0fa383a2a74 tags:

-Wörterbücher können als Iteratoren verwendet werden, um die Schlüssel-Wert-Paare zu durchlaufen. Du kannst es in einer `for`-Schleife wie folgt verwenden:
+Zuordnungstabellen können als Iteratoren verwendet werden, um die Schlüssel-Wert-Paare zu durchlaufen. Du kannst es in einer `for`-Schleife wie folgt verwenden:

 %% Cell type:code id:ed483334-36d0-4700-b178-cd9dc5f12189 tags:

 ``` julia
 d = Dict('a'=>1, 'b'=>2, 'c'=>3);
 for (key, value) in d
    println(key, " ", value)
 end
 ```

 %% Cell type:markdown id:dcb05236-810a-410b-aaa0-0cb431e3e64f tags:

 It is common to use tuples as keys in dictionaries. For example, a telephone directory might map from last-name, first-name pairs to telephone numbers. Assuming that we have defined last, first and number, we could write:

 %% Cell type:markdown id:5a012731-cf42-487b-9d02-4a4b1d0475c0 tags:

-Es ist üblich, Tupel als Schlüssel in Wörterbüchern zu verwenden. Zum Beispiel könnte ein Telefonverzeichnis Nachname-Vorname-Paare auf Telefonnummern abbilden. Angenommen, wir haben last, first und number definiert, könnten wir schreiben:
+Es ist üblich, Tupel als Schlüssel in Zuordnungstabellen zu verwenden. Zum Beispiel könnte ein Telefonverzeichnis Nachname-Vorname-Paare auf Telefonnummern abbilden. Angenommen, wir haben last, first und number definiert, könnten wir schreiben:

 %% Cell type:markdown id:e5462d35-fa68-42d8-ba00-c5dd1747c557 tags:

 `directory[last, first] = number`

 %% Cell type:markdown id:9980d710-392b-4716-b44d-98e6c5c8b838 tags:

 ### Named tuples

 %% Cell type:markdown id:7bd0a942-de38-4c9e-96df-a786fa814254 tags:

 ### Benannte Tupel

 %% Cell type:markdown id:e514c4bd-c17c-44f4-a89f-88154cc1bf6c tags:

 Named tuples are a special type of tuple in Julia where each element has a specific name associated with it. This allows you to access elements by their names, making the code more readable and self-explanatory.

 %% Cell type:markdown id:2284786f-cb8b-4173-944a-e50d79ceca2d tags:

 Benannte Tupel sind ein besonderer Tupeltyp in Julia, bei dem jedem Element ein spezifischer Name zugeordnet ist. Dies ermöglicht es dir, auf Elemente anhand ihrer Namen zuzugreifen, was den Code lesbarer und selbsterklärender macht.

 %% Cell type:code id:78fb5959-407a-4128-9287-bb9d455f22dc tags:

 ``` julia
 person = (name = "Michele", age = 28, city = "Stuttgart")
 ```

 %% Cell type:markdown id:63075b2d-ef86-48e4-8f84-981f81fdece0 tags:

 Named tuples are immutable, however it is possible to update the content, or to add new elements, by creating a new version. For example:

 %% Cell type:markdown id:01e99a5c-f331-4ad6-95e0-e403b8ad327b tags:

 Benannte Tupel sind unveränderlich, aber es ist möglich, den Inhalt zu aktualisieren oder neue Elemente hinzuzufügen, indem eine neue Version erstellt wird. Zum Beispiel:

 %% Cell type:code id:ecd22e07-5ba3-4f11-bc77-d967a6fc3fe8 tags:

 ``` julia
 updated_person = (person..., age = 29)
 updated_person = (person..., number = "0711 ...")
 ```

 %% Cell type:markdown id:347fe4ea-5b63-4fb8-91bc-2b7b8a0c6a30 tags:

-### Exercises
+### Exercise
  - Write a function `swap_first_last` that takes a tuple and returns a new tuple with the first and last elements swapped. Tip: use a combination of the `...` operator and of this slice `[2:end-1]`.

 %% Cell type:markdown id:70061322-9435-496a-ac0d-c026f41e5936 tags:

-### Exercises
-  - Write a function `swap_first_last` that takes a tuple and returns a new tuple with the first and last elements swapped. Tip: use a combination of the `...` operator and of this slice `[2:end-1]`.
+### Übung
+  - Schreibe eine Funktion `swap_first_last`, die ein Tupel entgegennimmt und ein neues Tupel zurückgibt, bei dem das erste und das letzte Element vertauscht sind. Tipp: Verwende eine Kombination des `...`-Operators und des Slices `[2:end-1]`.

 %% Cell type:code id:3721b654-b182-426d-b799-a69e0b53a550 tags:

 ``` julia
 ```

 %% Cell type:markdown id:647530cd-480a-414f-a8ec-1375e05a9e1b tags:

 ## Objects and structs

 %% Cell type:markdown id:5629a477-5d19-43a2-8bb4-e10b10f2ffde tags:

 ## Objekte und Strukturen

 %% Cell type:markdown id:00b9bdb1-86ad-47f6-b8c3-88e85878eaff tags:

 At this point you know how to use functions to organize code and built-in types to organize data. The next step is to learn how to build your own types to organize both code and data.

 We have used many of Julia’s built-in types; now we are going to define a new type. As an example, we will create a type called Point that represents a point in two-dimensional space.

 There are several ways we might represent points in Julia:
  - We could store the coordinates separately in two variables, x and y.
  - We could store the coordinates as elements in an tuple.
  - We could create a new type to represent points as objects.

 Here we will investigate the third option.

 %% Cell type:markdown id:18412e4f-e5fb-4a92-a083-ac2e5b58cde3 tags:

 Zu diesem Zeitpunkt weißt du bereits, wie man Funktionen verwendet, um Code zu organisieren, und integrierte Typen, um Daten zu organisieren. Der nächste Schritt ist zu lernen, wie man eigene Typen erstellt, um sowohl Code als auch Daten zu organisieren.

 Wir haben viele der integrierten Typen von Julia verwendet; jetzt werden wir einen neuen Typ definieren. Als Beispiel werden wir einen Typ namens Punkt erstellen, der einen Punkt im zweidimensionalen Raum repräsentiert.

 Es gibt verschiedene Möglichkeiten, wie wir Punkte in Julia darstellen könnten:
  - Wir könnten die Koordinaten separat in zwei Variablen, x und y, speichern.
  - Wir könnten die Koordinaten als Elemente in einem Tupel speichern.
  - Wir könnten einen neuen Typ erstellen, um Punkte als Objekte darzustellen.

 Hier werden wir die dritte Option untersuchen.

 %% Cell type:markdown id:9aa53d46-033b-4559-a5d8-e95357a257a5 tags:

 A programmer-defined composite type is also called a struct. The struct definition for a point looks like this:

 %% Cell type:markdown id:270c430a-4157-4e54-bb27-660c4028e5c6 tags:

 Ein vom Programmierer definierter zusammengesetzter Typ wird auch als Struktur (engl. struct) bezeichnet. Die Strukturdefinition für einen Punkt sieht so aus:

 %% Cell type:code id:c2e3f646-2d82-46a4-a265-01b919412c6d tags:

 ``` julia
 struct Point
    x::Real
    y::Real
 end
 ```

 %% Cell type:markdown id:fb9be134-9730-4dbd-9e05-51dd94e9d8e0 tags:

 The header indicates that the new struct is called Point. The body defines the attributes or fields of the struct. The Point struct has two fields: x and y.

 A struct is like a factory for creating objects. To create a point, you call Point as if it were a function having as arguments the values of the fields. When Point is used as a function, it is called a constructor. The constructor returns an instance of the object.

 %% Cell type:markdown id:6b99219f-70ba-41a7-8c52-e3803a360087 tags:

 Die Kopfzeile zeigt an, dass die neue Struktur Point genannt wird. Der Körper definiert die Attribute oder Felder der Struktur. Die Point-Struktur hat zwei Felder: x und y.

 Eine Struktur ist wie eine Fabrik zur Erzeugung von Objekten. Um einen Punkt zu erstellen, rufst du Point auf, als wäre es eine Funktion, und übergibst die Werte der Felder als Argumente. Wenn Point als Funktion verwendet wird, wird dies Konstruktor genannt. Der Konstruktor gibt eine Instanz des Objekts zurück.

 %% Cell type:code id:197339a2-0d8b-4882-bab2-80ba56410f21 tags:

 ``` julia
 p = Point(3.0, 4.0)
 @show p;
 ```

 %% Cell type:markdown id:b0134aa7-f356-4d71-9d46-959bd3cfe89a tags:

 The type speficication (`::Real`) is optional, but can be helpful to enforce correct usage of the struct.

 %% Cell type:markdown id:e35cbbf5-491e-44ff-b2c0-0cf6a8853083 tags:

 Die Typangabe (`::Real`) ist optional, kann aber hilfreich sein, um die korrekte Verwendung der Struktur zu erzwingen.

 %% Cell type:code id:849f1460-d228-4b22-a797-1077d75d1a2d tags:

 ``` julia
 p = Point("a", 4.0)
 ```

 %% Cell type:markdown id:e3011b23-816d-4aa2-be61-7eb8f4aee9d1 tags:

 The values of the fields can be accessed using the `.` operator.

 %% Cell type:markdown id:b86615f4-592f-41f7-b9d1-f5d1573cfd86 tags:

 Die Werte der Felder können mithilfe des `.` Operators abgerufen werden.

 %% Cell type:code id:00d090e4-d74d-4fad-ae8b-369c1046e48b tags:

 ``` julia
 @show p.x p.y;
 @show distance = sqrt(p.x^2 + p.y^2);
 ```

 %% Cell type:markdown id:08748a8c-f76c-4f14-b3d2-9db99fb28e87 tags:

 Structs are however by default immutable, after construction the fields can not change value:

 %% Cell type:markdown id:7c6baa9c-56e2-4595-9e6b-c798d9cea002 tags:

 Die Werte der Felder können mithilfe des `.` Operators abgerufen werden.

 %% Cell type:code id:91bd6248-a358-43e3-90cc-6b8398445aaf tags:

 ``` julia
 p.x = 2
 ```

 %% Cell type:markdown id:629c1004-5d0f-4093-b546-473c94c91b44 tags:

 Where required, mutable composite types can be declared with the keyword mutable struct. Here is the definition of a mutable point:

 %% Cell type:markdown id:48b46edb-b8fd-46ca-a2ec-4aa0acbf6c01 tags:

 Wenn erforderlich, können veränderbare zusammengesetzte Typen mit dem Schlüsselwort `mutable struct` deklariert werden. Hier ist die Definition eines veränderbaren Punkts:

 %% Cell type:code id:804c2c32-7a84-4261-88d8-1bad6ba5e18c tags:

 ``` julia
 mutable struct MPoint
    x::Real
    y::Real
 end
 p = MPoint(3.0, 4.0)
 p.x = 2.0
 @show p;
 ```

 %% Cell type:markdown id:1bd558dd-e6c3-4dc0-9476-768c59178708 tags:

 A third option is to let some fields of an unmutable struct to be mutable. For example a dictionary inside an unmutable struct can be modified.

 %% Cell type:markdown id:06f44f63-bf8e-45f5-9495-006e21fc7560 tags:

-Eine dritte Option ist es, einige Felder einer unveränderlichen Struktur als veränderbar zu definieren. Zum Beispiel kann ein Wörterbuch innerhalb einer unveränderlichen Struktur geändert werden.
+Eine dritte Option ist es, einige Felder einer unveränderlichen Struktur als veränderbar zu definieren. Zum Beispiel kann eine Zuordnungstabellen innerhalb einer unveränderlichen Struktur geändert werden.

 %% Cell type:code id:62cab9ae-5e58-401c-bc93-17720914e530 tags:

 ``` julia
 struct Book
    title::String
    author::String
    properties::Dict{String, Any}
 end

 book = Book("Der Hobbit", "J.R.R. Tolkien", Dict("available" => false))
 @show book
 book.properties["available"] = true
 @show book;
 ```

 %% Cell type:markdown id:31e2098b-5079-4cb5-bf64-a7a78754af32 tags:

 You can pass an instance as an argument in the usual way. For example:

 %% Cell type:markdown id:53aa5851-35c2-4dd0-a1e0-b5bc8e21b9f6 tags:

 Du kannst eine Instanz auf die übliche Weise als Argument übergeben. Zum Beispiel:

 %% Cell type:code id:e6113221-0c03-484a-99e0-f7d4fab70f03 tags:

 ``` julia
 function print_point(p)
    println("($(p.x), $(p.y))")
 end
 print_point(p)
 ```

 %% Cell type:code id:d5c6fa9e-c31d-4aff-a3fd-db3449904519 tags:

 ``` julia
 function print_book(book)
    println("Title: $(book.title)")
    println("Author: $(book.author)")
    available = book.properties["available"]
    println("Available: $(available)")
 end
 print_book(book)
 ```

 %% Cell type:markdown id:3b12a004-81d9-4bbc-9e2e-d2c281dcbe18 tags:

 Functions can return instances as return values.

 %% Cell type:markdown id:916562a2-3402-41bb-b15d-01333915df99 tags:

 Funktionen können Instanzen als Rückgabewerte zurückgeben.

 %% Cell type:code id:9c57c9f7-c4fd-4263-a55f-62f123aaaa8a tags:

 ``` julia
 function find_center(point1, point2)
    x = (point1.x + point2.x)/2.0
    y = (point1.y + point2.y)/2.0
    return Point(x, y)
 end

 point1 = Point(0.0, 0.0)
 point2 = Point(10.0, 10.0)

 @show find_center(point1, point2);
 ```

 %% Cell type:markdown id:078b31ab-11e1-4596-8271-f0d33418eab8 tags:

 ### Exercise

  - Write a function called `point_distance` which takes two points as arguments and returns the Euclidean distance between them.

 %% Cell type:markdown id:4afa9ca0-e6cd-4713-8caa-689c9dfdee42 tags:

 ### Übung

  - Schreibe eine Funktion namens `point_distance`, die zwei Punkte als Argumente entgegennimmt und die euklidische Distanz zwischen ihnen zurückgibt.

 %% Cell type:code id:b5957a05-e396-41c3-9b8f-f14f089115ab tags:

 ``` julia
 ```

 %% Cell type:markdown id:0fb1f6bc-e6e5-4897-bbb6-880e40e3bf20 tags:

 ### References and values

 Each object (instance of a struct) is stored at some memory address. The operator `===` checks if two variables point to the same memory address of the object. For example

 %% Cell type:markdown id:eecb6161-768e-4ae6-a600-d892894f8824 tags:

 ### Referenzen und Werte

 Jedes Objekt (Instanz einer Struktur) wird an einer bestimmten Speicheradresse gespeichert. Der Operator `===` überprüft, ob zwei Variablen auf die gleiche Speicheradresse des Objekts zeigen. Zum Beispiel

 %% Cell type:code id:ed713d91-17f4-4010-a7d3-d39826cffc97 tags:

 ``` julia
 book_copy = book
 @show book_copy === book;
 ```

 %% Cell type:markdown id:636b6713-f4ed-4220-a159-2918bd44f78e tags:

 This means that any change made to `book_copy` will also modify `book`.

 %% Cell type:markdown id:582e0ac0-2304-429e-a678-c37ab157d5d6 tags:

 Das bedeutet, dass jede Änderung, die an `book_copy` vorgenommen wird, auch `book` modifiziert.

 %% Cell type:code id:a9c46bac-d234-4616-a604-63bdf03b1393 tags:

 ``` julia
 book.properties["available"] = true
 book_copy.properties["available"] = false

 @show book;
 ```

 %% Cell type:markdown id:6bcbf983-40fa-4fc8-8eca-7cd7c45778dc tags:

 If a new, distinct, object is needed (in other words, a copy by value), we can use the function `deepcopy`.

 %% Cell type:markdown id:79339467-8994-4a5c-8987-3420d14cb290 tags:

-If a new, distinct, object is needed (in other words, a copy by value), we can use the function `deepcopy`.
+Wenn ein neues, eindeutiges Objekt benötigt wird (mit anderen Worten, eine Kopie nach Wert), können wir die Funktion `deepcopy` verwenden.

 %% Cell type:code id:c36d23c8-2292-4568-aef4-7416c6f3e538 tags:

 ``` julia
 book_copy = deepcopy(book)
 @show book_copy === book;
 ```

 %% Cell type:markdown id:02cc3ec7-e712-4c4b-abf5-9bfc98e68a91 tags:

 Finally, the `==` operator between structs defaults to the `===` operator as Julia has no way of knowing how to compare custom structs. However, it is always possible to reimplement the `==` operator for our custom types.

 %% Cell type:markdown id:4cc4c096-d856-4d43-8808-94edcd3ad906 tags:

 Schließlich entspricht der `==` Operator zwischen Strukturen standardmäßig dem `===` Operator, da Julia nicht weiß, wie benutzerdefinierte Strukturen verglichen werden sollen. Es ist jedoch immer möglich, den `==` Operator für unsere benutzerdefinierten Typen neu zu implementieren.

 %% Cell type:code id:3372eb89-cde6-4040-aa51-b4e76af97851 tags:

 ``` julia
 import Base: ==

 function ==(book1::Book, book2::Book)
    return book1.title == book2.title && book1.author == book2.author
 end

 @show book_copy == book;
 @show book_copy === book;
 ```

 %% Cell type:markdown id:87c1e4fb-d4e2-4ada-a97f-61273012146c tags:

 With this we can compare if two books are the same, even if they are two distinct instances of the same struct.

 %% Cell type:markdown id:02b533ba-2325-488a-838b-94cdf5ca25bb tags:

 Damit können wir vergleichen, ob zwei Bücher gleich sind, auch wenn es sich um zwei unterschiedliche Instanzen desselben Typs handelt.

 %% Cell type:markdown id:9263a1ae-52ee-4afc-9d9f-0f1341b64bc0 tags:

 ## Pure and impure functions

 %% Cell type:markdown id:4e457ee2-813a-42a8-8ee0-600bb4b50812 tags:

 ## Reine und unreine Funktionen

 %% Cell type:markdown id:f638e9b3-9926-46fc-81e0-d49c877a3bbb tags:

 We have seen that it is quite convenient to pass objects to functions. So far we have seen functions that print the content or that create a new object. None of these functions are modifying the content of the input objects.
  - A function that does not modify the input it is also said **pure**.
  - A function which modifies the input it is said **impure**. In Julia impure functions are highlighted by adding a `!` as the last character of the name.

 Let's consider a modified version of the book for an example.

 %% Cell type:markdown id:fb008ae0-a457-45db-8f77-425d56e95b30 tags:

 Wir haben gesehen, dass es ziemlich praktisch ist, Objekte an Funktionen zu übergeben. Bisher haben wir Funktionen gesehen, die den Inhalt ausgeben oder ein neues Objekt erstellen. Keine dieser Funktionen ändert den Inhalt der Eingabeobjekte.
  - Eine Funktion, die die Eingabe nicht ändert, wird auch als **rein** bezeichnet.
  - Eine Funktion, die die Eingabe ändert, wird als **unrein** bezeichnet. In Julia werden unreine Funktionen durch Hinzufügen eines `!` als letztem Zeichen des Namens hervorgehoben.

 Betrachten wir eine modifizierte Version des Buchs als Beispiel.

 %% Cell type:code id:7f892e07-a601-4cba-b58d-40be9c8e93ab tags:

 ``` julia
 book = Book("Der Hobbit", "J.R.R. Tolkien", Dict("available" => true, "copies_in_stock" => 10))
 @show book;
 ```

 %% Cell type:markdown id:99f4d6c9-2633-4394-b6a0-e0ce0c05e0db tags:

 Then we could think of a function which updates the database whenever we order new copies.

 %% Cell type:markdown id:7dac83b5-1086-4ca9-9b36-827497825be6 tags:

 Dann könnten wir über eine Funktion nachdenken, die die Datenbank aktualisiert, wenn wir neue Exemplare bestellen.

 %% Cell type:code id:04937488-a556-44ad-97be-98b017f293fd tags:

 ``` julia
 function order_book!(book, number_of_copies)
    if number_of_copies <= 0
        return
    end
    book.properties["copies_in_stock"] += number_of_copies
    book.properties["available"] = true
 end

 order_book!(book, 5)
 @show book;
 ```

 %% Cell type:markdown id:b30bd560-5ff3-4706-9f53-e6a5158651e9 tags:

 ### Exercise
  - Write an inpure function `sell_book!` for updating the book object whenever we sell a single copy. The function should complain if there are no copies available.

 %% Cell type:markdown id:93bc2e46-8530-4d1e-b7fa-55a74d1831c8 tags:

 ### Übung
  - Schreibe eine unreine Funktion `sell_book!`, um das Buchobjekt zu aktualisieren, wenn wir ein Exemplar verkaufen. Die Funktion sollte eine Meldung ausgeben, wenn keine Exemplare verfügbar sind.

 %% Cell type:code id:6e79fe95-767d-4b3e-af58-623db6dc0712 tags:

 ``` julia
 ```

 %% Cell type:markdown id:5ed4d4e0-0454-4298-9a56-8fb32634aa24 tags:

 ## Further exercises

 %% Cell type:markdown id:d5bb0b58-e85e-4edb-80b6-19d2c7d49ac3 tags:

 ## Weitere Übungen

 %% Cell type:markdown id:8446f1db-d40f-4311-9597-3b3b4d913151 tags:

 - Create a time struct which stores the time of the day (hour, minute and second). Write a function which takes as input the time object and prints it. Then write a function which sums together two time objects and returns a new time object. If the total is more than 24 hours, it should reset as if it was the next day.

 %% Cell type:markdown id:15fd6da2-f862-40ef-a58d-5e7be488565f tags:

 - Erstelle eine Zeitstruktur, die die Uhrzeit des Tages (Stunde, Minute und Sekunde) speichert. Schreibe eine Funktion, die als Eingabe das Zeitobjekt nimmt und es ausgibt. Schreibe dann eine Funktion, die zwei Zeitobjekte zusammenzählt und ein neues Zeitobjekt zurückgibt. Wenn die Summe mehr als 24 Stunden beträgt, sollte sie wie am nächsten Tag zurückgesetzt werden.

 %% Cell type:code id:5335e035-62ee-4d0f-acfc-a9e24ac26d99 tags:

 ``` julia
 ```

 %% Cell type:markdown id:32844b6f-518a-4174-83c6-0d7ebeabe4e4 tags:

  - Create a custom version of the `==` function which checks if two time objects are the same.

 %% Cell type:markdown id:2e0fde12-1214-4709-a7cb-5ebfaa0af17a tags:

 - Erstelle eine benutzerdefinierte Version der `==` Funktion, die überprüft, ob zwei Zeitobjekte identisch sind.

 %% Cell type:code id:966d4db1-c95a-4531-8209-a869519599ea tags:

 ``` julia
 ```

 %% Cell type:markdown id:baa7e06f-e183-4ee7-912a-e22255e18e21 tags:

  - Create a custom version of the `<` and `<=` functions for time objects.

 %% Cell type:markdown id:4e8c3c1e-14fb-439f-97c7-076196f7e5b4 tags:

 - Erstelle eine benutzerdefinierte Version der `<` und `<=` Funktionen für Zeitobjekte.

 %% Cell type:code id:c9b76667-731b-4ec2-aaf4-e94496f65b1a tags:

 ``` julia
 ```

 %% Cell type:markdown id:1bdbd748-7482-4f54-99a7-3d6e74b65575 tags:

  - Create a custom version of the `>` and `>=` functions for time objects.

 %% Cell type:markdown id:b79aad8c-647e-46d0-9b04-6a77cd219953 tags:

 - Erstelle eine benutzerdefinierte Version der `>` und `>=` Funktionen für Zeitobjekte.

 %% Cell type:code id:7df56050-686e-4a87-aa86-9b7f61315aa2 tags:

 ``` julia
 ```

 %% Cell type:markdown id:4fe99eff-729a-4d93-ab82-487e5143bae5 tags:

 # Advanced Data Types

 %% Cell type:markdown id:5de78ecc-bbde-49ff-b618-b8c8c440ce47 tags:

 # Fortgeschrittene Datentypen

 %% Cell type:markdown id:7969b8f9-335a-4bd2-82f7-1d9795234ed5 tags:

 ## Dictionaries

 %% Cell type:markdown id:8ffb53e2-1813-4fdf-962e-e066bc9b737c tags:

-## Wörterbücher
+## Zuordnungstabellen (assoziative Listen)

 %% Cell type:markdown id:ea8518c1-8e1d-4532-8055-e04c3aa3e7c4 tags:

 A dictionary contains a collection of indices, which are called keys, and a collection of values. Each key is associated with a single value. The association of a key and a value is called a key-value pair or sometimes an item.

-The function `Dict` creates a new dictionary with no items. Because Dict is the name of a built-in function, you should avoid using it as a variable name.
+The function `Dict` creates a new dictionary with no items. Because `Dict` is the name of a built-in function, you should avoid using it as a variable name.

 %% Cell type:markdown id:548487ed-dc9d-4404-a2ab-451c0ea742e4 tags:

-Ein Wörterbuch enthält eine Sammlung von Indizes, die als Schlüssel bezeichnet werden, und eine Sammlung von Werten. Jeder Schlüssel ist mit einem einzigen Wert verbunden. Die Zuordnung eines Schlüssels und eines Wertes wird als Schlüssel-Wert-Paar oder manchmal als Element bezeichnet.
+Eine Zuordnungstabelle enthält eine Sammlung von Indizes, die als Schlüssel bezeichnet werden, und eine Sammlung von Werten. Jeder Schlüssel ist mit einem einzigen Wert verbunden. Die Zuordnung eines Schlüssels und eines Wertes wird als Schlüssel-Wert-Paar oder manchmal als Element bezeichnet.

-Die Funktion `Dict` erstellt ein neues Wörterbuch ohne Elemente. Da Dict der Name einer integrierten Funktion ist, sollte man ihn vermeiden, als Variablenname zu verwenden.
+Die Funktion `Dict` erstellt ein neues Wörterbuch ohne Elemente. Da `Dict` der Name einer integrierten Funktion ist, sollte man vermeiden ihn als Variablenname zu verwenden.

 %% Cell type:code id:59ae8d17-a6f6-4210-95bc-0e7492bc8a7a tags:

 ``` julia
 eng2de = Dict()
 ```

 %% Cell type:code id:28490ea3-c4d3-4e4d-915f-612ad36c9472 tags:

 ``` julia
 eng2de["one"] = "ein";
 ```

 %% Cell type:markdown id:f2aff40c-6dcb-421a-b67f-1662c5bf4702 tags:

 You can also initialize a dictionary with items as:

 %% Cell type:markdown id:09b62b4d-748b-4e1d-91f2-7db610ad02ac tags:

-Du kannst auch ein Wörterbuch mit Elementen initialisieren, wie folgt:
+Du kannst auch eine Zuordnungstabelle mit Elementen wie folgt initialisieren:

 %% Cell type:code id:92fc203b-4ba8-432a-a541-c4ccf3292195 tags:

 ``` julia
 eng2de = Dict("one" => "ein", "two" => "zwei", "three" => "drei")
 ```

 %% Cell type:markdown id:c52d24af-ec90-4b8c-bdd9-988129a7fa81 tags:

 Dictionaries are mutable, meaning that it is always possible to modify their elements, add new key-value pairs or removing existing ones.

 %% Cell type:markdown id:809e7c99-22f0-4440-921d-e5904cadc8a4 tags:

 Wörterbücher sind veränderbar, was bedeutet, dass es immer möglich ist, ihre Elemente zu ändern, neue Schlüssel-Wert-Paare hinzuzufügen oder bestehende zu entfernen.

 %% Cell type:code id:22b295dc-994e-4bbc-ac8d-da5ab9e73493 tags:

 ``` julia
 eng2de["four"] = "VIER"
 @show eng2de
 eng2de["four"] = "vier"
 @show eng2de
 delete!(eng2de, "four")
 @show eng2de;
 ```

 %% Cell type:markdown id:01513ad2-3083-4c89-adca-ccc8a88d93d4 tags:

 In general, the order of the key-value pairs is unpredictable. However this is not important, as the values are always accessed using the keys.

 %% Cell type:markdown id:d8b4ee03-5592-4567-883b-e0842fefeff4 tags:

 Im Allgemeinen ist die Reihenfolge der Schlüssel-Wert-Paare unvorhersehbar. Dies ist jedoch nicht wichtig, da die Werte immer mithilfe der Schlüssel abgerufen werden.

 %% Cell type:code id:e9e4c5b9-9539-4294-a6ec-0a29fb76bf7b tags:

 ``` julia
 eng2de["two"]
 ```

 %% Cell type:markdown id:9944dbbd-478b-4ae1-ac89-e16be08a0868 tags:

 If the key isn’t in the dictionary, you get an exception:

 %% Cell type:markdown id:84cf8b52-f061-4b28-a327-bc527820517c tags:

-Wenn der Schlüssel nicht im Wörterbuch vorhanden ist, tritt eine Ausnahme auf:
+Wenn der Schlüssel nicht im Wörterbuch vorhanden ist, tritt eine Fehlermeldung auf:

 %% Cell type:code id:8221269b-7a8f-4cfd-ab8e-0aa4fd6c962d tags:

 ``` julia
 eng2de["four"]
 ```

 %% Cell type:markdown id:a545abaa-78dc-4625-84e9-03b1c8beaaf8 tags:

 The `length` function works on dictionaries; it returns the number of key-value pairs:

 %% Cell type:markdown id:f83d51c5-2c1d-4449-8cd5-e80f224b9a76 tags:

-Die Funktion `length` funktioniert auch bei Wörterbüchern; sie gibt die Anzahl der Schlüssel-Wert-Paare zurück:
+Die Funktion `length` funktioniert auch bei Zuordnungstabellen; sie gibt die Anzahl der Schlüssel-Wert-Paare zurück:

 %% Cell type:code id:0e242667-b921-4242-bdcc-cbcac14909b2 tags:

 ``` julia
 length(eng2de)
 ```

 %% Cell type:markdown id:8e42655b-f2a0-41f0-be90-015ebfeafdb9 tags:

 The function `keys` returns a collection with the keys of the dictionary:

 %% Cell type:markdown id:b4ac7b46-9fc0-47fd-b6c0-c97791517b51 tags:

 Die Funktion `keys` gibt eine Sammlung mit den Schlüsseln des Wörterbuchs zurück:

 %% Cell type:code id:3236f973-d3fa-42ba-a1c0-41e0002446cb tags:

 ``` julia
 keys(eng2de)
 ```

 %% Cell type:markdown id:acfa7044-5695-4af8-b4bc-320c8a48a220 tags:

 Now you can use the `∈` operator to see whether something appears as a key in the dictionary:

 %% Cell type:markdown id:f9bc6fe5-3f7a-458e-942a-11bd3e83dcc6 tags:

 Nun kannst du den Operator `∈` verwenden, um zu sehen, ob etwas als Schlüssel im Wörterbuch vorhanden ist:

 %% Cell type:code id:1fdeb10c-0d84-4c22-b734-d68e2eafe375 tags:

 ``` julia
 @show "one" ∈ keys(eng2de)
 @show "four" ∈ keys(eng2de);
 ```

 %% Cell type:markdown id:986919d6-4f27-4fad-b222-20697bf6af40 tags:

 To see whether something appears as a value in a dictionary, you can use the function `values`, which returns a collection of values, and then use the `∈` operator:

 %% Cell type:markdown id:864d141e-6cd2-45e6-95fe-e84cca35cf70 tags:

 Um zu überprüfen, ob etwas als Wert in einem Wörterbuch vorhanden ist, kannst du die Funktion `values` verwenden, die eine Sammlung von Werten zurückgibt, und dann den Operator `∈` verwenden:

 %% Cell type:code id:ab90dad1-61d0-4dbd-b829-a354c13fcb71 tags:

 ``` julia
 @show "ein" ∈ values(eng2de)
 @show "vier" ∈ values(eng2de);
 ```

 %% Cell type:markdown id:049c9dfd-1e51-4898-98e5-a4b812d0bba2 tags:

 ### Loops over dictionaries

 You can traverse the keys of the dictionary in a `for` statement.

 %% Cell type:markdown id:5b255b31-8aca-49b4-a95f-302c59baa975 tags:

-### Schleifen über Wörterbücher
+### Schleifen über Zuordnungstabellen

-Du kannst die Schlüssel des Wörterbuchs in einer `for`-Schleife durchlaufen.
+Du kannst die Schlüssel der Zuordnungstabelle in einer `for`-Schleife durchlaufen.

 %% Cell type:code id:e7062d3f-2125-4ecd-ab13-d04944a71fe1 tags:

 ``` julia
 function print_dictionary(dic)
    for key in keys(dic)
        println(key, " ", dic[key])
    end
 end

 print_dictionary(eng2de)
 ```

 %% Cell type:markdown id:cf27195c-e601-49ca-b03d-63162bf59bce tags:

 Again, the keys are in no particular order. To traverse the keys in alphabetically sorted order, you can combine `sort` and `collect`:

 %% Cell type:markdown id:a6b3285a-58f6-41b6-8755-2732a367424e tags:

 Auch hier sind die Schlüssel in keiner bestimmten Reihenfolge. Um die Schlüssel in alphabetisch sortierter Reihenfolge zu durchlaufen, kannst du `sort` und `collect` kombinieren:

 %% Cell type:code id:6d52aeba-3c7e-405c-bcfe-d76e37e94f51 tags:

 ``` julia
 function print_dictionary_sorted(dic)
    for key in sort(collect(keys(dic)))
        println(key, " ", dic[key])
    end
 end

 print_dictionary_sorted(eng2de)
 ```

 %% Cell type:markdown id:8daa9d3e-19de-4415-ba6c-6aeb174b38fa tags:

-### Exercises
+### Exercise
  - Write a function that given a string as input counts how many times each letter appears. Use a dictionary.

 %% Cell type:markdown id:964165ee-4d0d-4122-b6b2-d3926101cab2 tags:

-### Übungen
+### Übung
  - Schreibe eine Funktion, die bei Eingabe eines Strings zählt, wie oft jeder Buchstabe vorkommt. Verwende ein Wörterbuch.

 %% Cell type:code id:aba1978b-e675-48a7-89aa-75553db70537 tags:

 ``` julia
 ```

 %% Cell type:markdown id:3a9b281f-6cc0-4d39-b9e2-d816823f9873 tags:

 ## Tuples and named tuples

 %% Cell type:markdown id:0acaa2f9-372c-4a3e-be01-27cfe2853fdb tags:

 ## Tupel und benannte Tupel

 %% Cell type:markdown id:a722109e-86cc-44e3-9256-a3e93a1668f5 tags:

 A tuple is a sequence of values. The values can be of any type, and they are indexed by integers. The tuples are immutable and each element can have its own type.

 %% Cell type:markdown id:68ea4303-ce3c-4647-8e9f-89afd0a6a670 tags:

 Ein Tupel ist eine Sequenz von Werten. Die Werte können beliebigen Typs sein und sie werden durch Ganzzahlen indexiert. Die Tupel sind unveränderlich und jedes Element kann seinen eigenen Typ haben.

 %% Cell type:code id:8502cf2e-8bea-4707-811c-f4e6e1de3c8f tags:

 ``` julia
 t = 'a', 'b', 'c', 'd', 'e'
 ```

 %% Cell type:markdown id:d01f5647-a240-4620-9a3a-782835aca39c tags:

 Although it is not necessary, it is common to enclose tuples in parentheses:

 %% Cell type:markdown id:2632b11b-de4b-4f21-bcc6-06a32517c121 tags:

 Obwohl es nicht notwendig ist, ist es üblich, Tupel in Klammern zu setzen:

 %% Cell type:code id:bfa31b99-bf9d-49bb-babc-fe8a65248429 tags:

 ``` julia
 t = ('a', 'b', 'c', 'd', 'e')
 ```

 %% Cell type:markdown id:3fa935e0-0611-4b8a-982c-329c33a74f99 tags:

 To create a tuple with a single element, you have to include a final comma:

 %% Cell type:markdown id:86fa8b6b-bbbf-4c9c-a5c0-63b00b2c59cb tags:

 Um ein Tupel mit einem einzigen Element zu erstellen, musst du ein abschließendes Komma setzen:

 %% Cell type:code id:cb1bea15-2b80-43b2-be8e-27507d550fca tags:

 ``` julia
 t1 = ('a',)
 @show typeof(t1)

 t2 = ('a')
 @show typeof(t2);
 ```

 %% Cell type:markdown id:193457ac-4e4b-4e58-8c28-6d8b4331d532 tags:

 Another way to create a tuple is the built-in function tuple. With no argument, it creates an empty tuple:

 %% Cell type:markdown id:d6f34b5b-2aaa-49db-b2a8-d5891fe33ee1 tags:

 Eine andere Möglichkeit, ein Tupel zu erstellen, ist die integrierte Funktion `tuple`. Ohne Argument erstellt sie ein leeres Tupel:

 %% Cell type:code id:952acafe-ca5d-4b58-8969-224b0fe3a28f tags:

 ``` julia
 t3 = tuple()
 @show typeof(t3)

 t4 = tuple(1, 'a', π, 12.0)
 @show typeof(t4);
 ```

 %% Cell type:markdown id:729c3597-1a35-4a26-ae7a-6dadee31daeb tags:

 Using the bracket operator it is possible to access an element. Note, differently from other programming languages (for example C, C++, Python) in Julia the first element is 1.

 %% Cell type:markdown id:efc3d061-7e93-4863-a802-a7cdb869af7e tags:

 Mit dem eckigen Klammern-Operator ist es möglich, auf ein Element zuzugreifen. Beachte, dass in Julia das erste Element, anders als in anderen Programmiersprachen (zum Beispiel C, C++, Python), mit 1 indexiert wird.

 %% Cell type:code id:9817c28f-428d-4d5b-8384-608f9b4d763d tags:

 ``` julia
 t4[2]
 ```

 %% Cell type:markdown id:2519be57-8c10-4878-a772-017b099f6a4c tags:

 It is also possible to get multiple elements by using slices.

 %% Cell type:markdown id:17a0f0ee-e03f-4669-a5f1-889d875577d9 tags:

 Es ist auch möglich, mehrere Elemente mithilfe von Slices zu erhalten.

 %% Cell type:code id:c48ac07f-3a4e-4bb8-9551-2973ea8d2f9c tags:

 ``` julia
 @show t4[1:3];
 ```

 %% Cell type:markdown id:aeda8602-f9da-4173-a692-54e2e9a0e178 tags:

 But if you try to modify one of the elements of the tuple, you get an error:

 %% Cell type:markdown id:d0f25a1f-0a4c-4ab4-a339-f5ba64806681 tags:

 Aber wenn du versuchst, eines der Elemente des Tupels zu ändern, tritt ein Fehler auf:

 %% Cell type:code id:cfc94cc9-832c-45d2-85b8-aaf789f33f6a tags:

 ``` julia
 t4[2] = 'b'
 ```

 %% Cell type:markdown id:b9f13b5c-9e61-46b9-a47d-f90199bd7bd2 tags:

 Because tuples are immutable, you can’t modify the elements.

 %% Cell type:markdown id:d956168e-36e4-4abb-a3d6-3c53a857e78d tags:

 Da Tupel unveränderlich sind, kannst du die Elemente nicht ändern.

 %% Cell type:markdown id:a10cb9a7-8f44-44f8-831f-178b780e4ac9 tags:

 Strictly speaking, a function can only return one value, but if the value is a tuple, the effect is the same as returning multiple values. For example, if you want to divide two integers and compute the quotient and remainder, it is inefficient to compute x ÷ y and then x % y. It is better to compute them both at the same time.

 The built-in function `divrem` takes two arguments and returns a tuple of two values, the quotient and remainder. You can store the result as a tuple:

 %% Cell type:markdown id:6a115819-54fd-4550-b097-59fea3ecb523 tags:

 Genau genommen kann eine Funktion nur einen Wert zurückgeben, aber wenn der Wert ein Tupel ist, hat dies den gleichen Effekt wie das Zurückgeben mehrerer Werte. Zum Beispiel, wenn du zwei Ganzzahlen teilen und den Quotienten und den Rest berechnen möchtest, ist es ineffizient, zuerst x ÷ y und dann x % y zu berechnen. Es ist besser, beides gleichzeitig zu berechnen.

 Die integrierte Funktion `divrem` nimmt zwei Argumente entgegen und gibt ein Tupel aus zwei Werten zurück, dem Quotienten und dem Rest. Du kannst das Ergebnis als Tupel speichern:

 %% Cell type:code id:d1dde137-036f-4b93-8010-13b3e835ebd8 tags:

 ``` julia
 t = divrem(7, 3)
 ```

 %% Cell type:markdown id:ea615dbd-effb-4442-b160-20e7c9b6c22e tags:

 Alternatively, we can use tuple assignment to store the elements separately:

 %% Cell type:markdown id:9cd48d9c-cf1d-4546-a2c0-4bb54a42e1e8 tags:

 Alternativ können wir die Zuweisung als Tupel verwenden, um die Elemente getrennt zu speichern:

 %% Cell type:code id:c4969556-7945-43c9-8b96-1ea1032cbb3c tags:

 ``` julia
 q, r = divrem(7, 3)

 @show q r;
 ```

 %% Cell type:markdown id:4574e191-aaa8-4834-8837-54947d6ddf30 tags:

 ### Gather and scatter

 Functions can take a variable number of arguments. A parameter name that ends with `...` gathers arguments into a tuple. For example, `printall` takes any number of arguments and prints them one by line:

 %% Cell type:markdown id:e4177fab-a386-4274-8657-bbc6698ec1e5 tags:

 ### Sammeln und verteilen

 Funktionen können eine variable Anzahl von Argumenten entgegennehmen. Ein Parametername, der mit `...` endet, sammelt die Argumente in ein Tupel. Zum Beispiel nimmt `printall` eine beliebige Anzahl von Argumenten entgegen und gibt sie nacheinander aus:

 %% Cell type:code id:43f8c7ad-5ac2-425e-a50f-c45624bb3d8a tags:

 ``` julia
 function printall(args...)
    for arg in args
        println(arg)
    end
 end

 printall(1)
 printall(1, 2.0, '3')
 ```

 %% Cell type:markdown id:eb662374-fe83-49d7-a5be-d9582d037ad1 tags:

 The complement of gather is scatter. If you have a sequence of values and you want to pass it to a function as multiple arguments, you can use the `...` operator. For example, `divrem` takes exactly two arguments; it doesn’t work with a tuple:

 %% Cell type:markdown id:28b3cd91-bf05-43bc-a253-2bee077a1df1 tags:

 Das Gegenstück zu "sammeln" ist "verteilen". Wenn du eine Sequenz von Werten hast und sie als mehrere Argumente an eine Funktion übergeben möchtest, kannst du den Operator `...` verwenden. Zum Beispiel nimmt `divrem` genau zwei Argumente an; es funktioniert nicht mit einem Tupel:

 %% Cell type:code id:bf55fc10-8432-41e3-bd6c-2244c8c96513 tags:

 ``` julia
 t = (7, 3)
 divrem(t)
 ```

 %% Cell type:markdown id:d05def39-3244-4acd-a082-a7ee532f8f1d tags:

 But if you scatter the tuple, it works:

 %% Cell type:markdown id:db3cd00d-d41c-4f68-95d4-c4e5b283734a tags:

-Aber wenn du das Tupel verteilst, funktioniert es:
+Wenn du aber das Tupel verteilst, funktioniert es:

 %% Cell type:code id:e7df53bc-6b2d-4501-9ca8-61e3cb79eb1a tags:

 ``` julia
 t = (7, 3)
 divrem(t...)
 ```

 %% Cell type:markdown id:2cf01c32-9d1b-4e83-9375-f737e51c58ed tags:

 ### Dictionaries and Tuples

 %% Cell type:markdown id:dad5d7bf-0dd5-450b-90f3-7768f2d91c18 tags:

-### Wörterbücher und Tupel
+### Zuordnungstabellen und Tupel

 %% Cell type:markdown id:00e97ccc-8e64-4eef-84be-85a266eb3490 tags:

 Dictionaries can be used as iterators that iterate the key-value pairs. You can use it in a `for` loop like this:

 %% Cell type:markdown id:3a38cabd-b056-4140-a75c-e0fa383a2a74 tags:

-Wörterbücher können als Iteratoren verwendet werden, um die Schlüssel-Wert-Paare zu durchlaufen. Du kannst es in einer `for`-Schleife wie folgt verwenden:
+Zuordnungstabellen können als Iteratoren verwendet werden, um die Schlüssel-Wert-Paare zu durchlaufen. Du kannst es in einer `for`-Schleife wie folgt verwenden:

 %% Cell type:code id:ed483334-36d0-4700-b178-cd9dc5f12189 tags:

 ``` julia
 d = Dict('a'=>1, 'b'=>2, 'c'=>3);
 for (key, value) in d
    println(key, " ", value)
 end
 ```

 %% Cell type:markdown id:dcb05236-810a-410b-aaa0-0cb431e3e64f tags:

 It is common to use tuples as keys in dictionaries. For example, a telephone directory might map from last-name, first-name pairs to telephone numbers. Assuming that we have defined last, first and number, we could write:

 %% Cell type:markdown id:5a012731-cf42-487b-9d02-4a4b1d0475c0 tags:

-Es ist üblich, Tupel als Schlüssel in Wörterbüchern zu verwenden. Zum Beispiel könnte ein Telefonverzeichnis Nachname-Vorname-Paare auf Telefonnummern abbilden. Angenommen, wir haben last, first und number definiert, könnten wir schreiben:
+Es ist üblich, Tupel als Schlüssel in Zuordnungstabellen zu verwenden. Zum Beispiel könnte ein Telefonverzeichnis Nachname-Vorname-Paare auf Telefonnummern abbilden. Angenommen, wir haben last, first und number definiert, könnten wir schreiben:

 %% Cell type:markdown id:e5462d35-fa68-42d8-ba00-c5dd1747c557 tags:

 `directory[last, first] = number`

 %% Cell type:markdown id:9980d710-392b-4716-b44d-98e6c5c8b838 tags:

 ### Named tuples

 %% Cell type:markdown id:7bd0a942-de38-4c9e-96df-a786fa814254 tags:

 ### Benannte Tupel

 %% Cell type:markdown id:e514c4bd-c17c-44f4-a89f-88154cc1bf6c tags:

 Named tuples are a special type of tuple in Julia where each element has a specific name associated with it. This allows you to access elements by their names, making the code more readable and self-explanatory.

 %% Cell type:markdown id:2284786f-cb8b-4173-944a-e50d79ceca2d tags:

 Benannte Tupel sind ein besonderer Tupeltyp in Julia, bei dem jedem Element ein spezifischer Name zugeordnet ist. Dies ermöglicht es dir, auf Elemente anhand ihrer Namen zuzugreifen, was den Code lesbarer und selbsterklärender macht.

 %% Cell type:code id:78fb5959-407a-4128-9287-bb9d455f22dc tags:

 ``` julia
 person = (name = "Michele", age = 28, city = "Stuttgart")
 ```

 %% Cell type:markdown id:63075b2d-ef86-48e4-8f84-981f81fdece0 tags:

 Named tuples are immutable, however it is possible to update the content, or to add new elements, by creating a new version. For example:

 %% Cell type:markdown id:01e99a5c-f331-4ad6-95e0-e403b8ad327b tags:

 Benannte Tupel sind unveränderlich, aber es ist möglich, den Inhalt zu aktualisieren oder neue Elemente hinzuzufügen, indem eine neue Version erstellt wird. Zum Beispiel:

 %% Cell type:code id:ecd22e07-5ba3-4f11-bc77-d967a6fc3fe8 tags:

 ``` julia
 updated_person = (person..., age = 29)
 updated_person = (person..., number = "0711 ...")
 ```

 %% Cell type:markdown id:347fe4ea-5b63-4fb8-91bc-2b7b8a0c6a30 tags:

-### Exercises
+### Exercise
  - Write a function `swap_first_last` that takes a tuple and returns a new tuple with the first and last elements swapped. Tip: use a combination of the `...` operator and of this slice `[2:end-1]`.

 %% Cell type:markdown id:70061322-9435-496a-ac0d-c026f41e5936 tags:

-### Exercises
-  - Write a function `swap_first_last` that takes a tuple and returns a new tuple with the first and last elements swapped. Tip: use a combination of the `...` operator and of this slice `[2:end-1]`.
+### Übung
+  - Schreibe eine Funktion `swap_first_last`, die ein Tupel entgegennimmt und ein neues Tupel zurückgibt, bei dem das erste und das letzte Element vertauscht sind. Tipp: Verwende eine Kombination des `...`-Operators und des Slices `[2:end-1]`.

 %% Cell type:code id:3721b654-b182-426d-b799-a69e0b53a550 tags:

 ``` julia
 ```

 %% Cell type:markdown id:647530cd-480a-414f-a8ec-1375e05a9e1b tags:

 ## Objects and structs

 %% Cell type:markdown id:5629a477-5d19-43a2-8bb4-e10b10f2ffde tags:

 ## Objekte und Strukturen

 %% Cell type:markdown id:00b9bdb1-86ad-47f6-b8c3-88e85878eaff tags:

 At this point you know how to use functions to organize code and built-in types to organize data. The next step is to learn how to build your own types to organize both code and data.

 We have used many of Julia’s built-in types; now we are going to define a new type. As an example, we will create a type called Point that represents a point in two-dimensional space.

 There are several ways we might represent points in Julia:
  - We could store the coordinates separately in two variables, x and y.
  - We could store the coordinates as elements in an tuple.
  - We could create a new type to represent points as objects.

 Here we will investigate the third option.

 %% Cell type:markdown id:18412e4f-e5fb-4a92-a083-ac2e5b58cde3 tags:

 Zu diesem Zeitpunkt weißt du bereits, wie man Funktionen verwendet, um Code zu organisieren, und integrierte Typen, um Daten zu organisieren. Der nächste Schritt ist zu lernen, wie man eigene Typen erstellt, um sowohl Code als auch Daten zu organisieren.

 Wir haben viele der integrierten Typen von Julia verwendet; jetzt werden wir einen neuen Typ definieren. Als Beispiel werden wir einen Typ namens Punkt erstellen, der einen Punkt im zweidimensionalen Raum repräsentiert.

 Es gibt verschiedene Möglichkeiten, wie wir Punkte in Julia darstellen könnten:
  - Wir könnten die Koordinaten separat in zwei Variablen, x und y, speichern.
  - Wir könnten die Koordinaten als Elemente in einem Tupel speichern.
  - Wir könnten einen neuen Typ erstellen, um Punkte als Objekte darzustellen.

 Hier werden wir die dritte Option untersuchen.

 %% Cell type:markdown id:9aa53d46-033b-4559-a5d8-e95357a257a5 tags:

 A programmer-defined composite type is also called a struct. The struct definition for a point looks like this:

 %% Cell type:markdown id:270c430a-4157-4e54-bb27-660c4028e5c6 tags:

 Ein vom Programmierer definierter zusammengesetzter Typ wird auch als Struktur (engl. struct) bezeichnet. Die Strukturdefinition für einen Punkt sieht so aus:

 %% Cell type:code id:c2e3f646-2d82-46a4-a265-01b919412c6d tags:

 ``` julia
 struct Point
    x::Real
    y::Real
 end
 ```

 %% Cell type:markdown id:fb9be134-9730-4dbd-9e05-51dd94e9d8e0 tags:

 The header indicates that the new struct is called Point. The body defines the attributes or fields of the struct. The Point struct has two fields: x and y.

 A struct is like a factory for creating objects. To create a point, you call Point as if it were a function having as arguments the values of the fields. When Point is used as a function, it is called a constructor. The constructor returns an instance of the object.

 %% Cell type:markdown id:6b99219f-70ba-41a7-8c52-e3803a360087 tags:

 Die Kopfzeile zeigt an, dass die neue Struktur Point genannt wird. Der Körper definiert die Attribute oder Felder der Struktur. Die Point-Struktur hat zwei Felder: x und y.

 Eine Struktur ist wie eine Fabrik zur Erzeugung von Objekten. Um einen Punkt zu erstellen, rufst du Point auf, als wäre es eine Funktion, und übergibst die Werte der Felder als Argumente. Wenn Point als Funktion verwendet wird, wird dies Konstruktor genannt. Der Konstruktor gibt eine Instanz des Objekts zurück.

 %% Cell type:code id:197339a2-0d8b-4882-bab2-80ba56410f21 tags:

 ``` julia
 p = Point(3.0, 4.0)
 @show p;
 ```

 %% Cell type:markdown id:b0134aa7-f356-4d71-9d46-959bd3cfe89a tags:

 The type speficication (`::Real`) is optional, but can be helpful to enforce correct usage of the struct.

 %% Cell type:markdown id:e35cbbf5-491e-44ff-b2c0-0cf6a8853083 tags:

 Die Typangabe (`::Real`) ist optional, kann aber hilfreich sein, um die korrekte Verwendung der Struktur zu erzwingen.

 %% Cell type:code id:849f1460-d228-4b22-a797-1077d75d1a2d tags:

 ``` julia
 p = Point("a", 4.0)
 ```

 %% Cell type:markdown id:e3011b23-816d-4aa2-be61-7eb8f4aee9d1 tags:

 The values of the fields can be accessed using the `.` operator.

 %% Cell type:markdown id:b86615f4-592f-41f7-b9d1-f5d1573cfd86 tags:

 Die Werte der Felder können mithilfe des `.` Operators abgerufen werden.

 %% Cell type:code id:00d090e4-d74d-4fad-ae8b-369c1046e48b tags:

 ``` julia
 @show p.x p.y;
 @show distance = sqrt(p.x^2 + p.y^2);
 ```

 %% Cell type:markdown id:08748a8c-f76c-4f14-b3d2-9db99fb28e87 tags:

 Structs are however by default immutable, after construction the fields can not change value:

 %% Cell type:markdown id:7c6baa9c-56e2-4595-9e6b-c798d9cea002 tags:

 Die Werte der Felder können mithilfe des `.` Operators abgerufen werden.

 %% Cell type:code id:91bd6248-a358-43e3-90cc-6b8398445aaf tags:

 ``` julia
 p.x = 2
 ```

 %% Cell type:markdown id:629c1004-5d0f-4093-b546-473c94c91b44 tags:

 Where required, mutable composite types can be declared with the keyword mutable struct. Here is the definition of a mutable point:

 %% Cell type:markdown id:48b46edb-b8fd-46ca-a2ec-4aa0acbf6c01 tags:

 Wenn erforderlich, können veränderbare zusammengesetzte Typen mit dem Schlüsselwort `mutable struct` deklariert werden. Hier ist die Definition eines veränderbaren Punkts:

 %% Cell type:code id:804c2c32-7a84-4261-88d8-1bad6ba5e18c tags:

 ``` julia
 mutable struct MPoint
    x::Real
    y::Real
 end
 p = MPoint(3.0, 4.0)
 p.x = 2.0
 @show p;
 ```

 %% Cell type:markdown id:1bd558dd-e6c3-4dc0-9476-768c59178708 tags:

 A third option is to let some fields of an unmutable struct to be mutable. For example a dictionary inside an unmutable struct can be modified.

 %% Cell type:markdown id:06f44f63-bf8e-45f5-9495-006e21fc7560 tags:

-Eine dritte Option ist es, einige Felder einer unveränderlichen Struktur als veränderbar zu definieren. Zum Beispiel kann ein Wörterbuch innerhalb einer unveränderlichen Struktur geändert werden.
+Eine dritte Option ist es, einige Felder einer unveränderlichen Struktur als veränderbar zu definieren. Zum Beispiel kann eine Zuordnungstabellen innerhalb einer unveränderlichen Struktur geändert werden.

 %% Cell type:code id:62cab9ae-5e58-401c-bc93-17720914e530 tags:

 ``` julia
 struct Book
    title::String
    author::String
    properties::Dict{String, Any}
 end

 book = Book("Der Hobbit", "J.R.R. Tolkien", Dict("available" => false))
 @show book
 book.properties["available"] = true
 @show book;
 ```

 %% Cell type:markdown id:31e2098b-5079-4cb5-bf64-a7a78754af32 tags:

 You can pass an instance as an argument in the usual way. For example:

 %% Cell type:markdown id:53aa5851-35c2-4dd0-a1e0-b5bc8e21b9f6 tags:

 Du kannst eine Instanz auf die übliche Weise als Argument übergeben. Zum Beispiel:

 %% Cell type:code id:e6113221-0c03-484a-99e0-f7d4fab70f03 tags:

 ``` julia
 function print_point(p)
    println("($(p.x), $(p.y))")
 end
 print_point(p)
 ```

 %% Cell type:code id:d5c6fa9e-c31d-4aff-a3fd-db3449904519 tags:

 ``` julia
 function print_book(book)
    println("Title: $(book.title)")
    println("Author: $(book.author)")
    available = book.properties["available"]
    println("Available: $(available)")
 end
 print_book(book)
 ```

 %% Cell type:markdown id:3b12a004-81d9-4bbc-9e2e-d2c281dcbe18 tags:

 Functions can return instances as return values.

 %% Cell type:markdown id:916562a2-3402-41bb-b15d-01333915df99 tags:

 Funktionen können Instanzen als Rückgabewerte zurückgeben.

 %% Cell type:code id:9c57c9f7-c4fd-4263-a55f-62f123aaaa8a tags:

 ``` julia
 function find_center(point1, point2)
    x = (point1.x + point2.x)/2.0
    y = (point1.y + point2.y)/2.0
    return Point(x, y)
 end

 point1 = Point(0.0, 0.0)
 point2 = Point(10.0, 10.0)

 @show find_center(point1, point2);
 ```

 %% Cell type:markdown id:078b31ab-11e1-4596-8271-f0d33418eab8 tags:

 ### Exercise

  - Write a function called `point_distance` which takes two points as arguments and returns the Euclidean distance between them.

 %% Cell type:markdown id:4afa9ca0-e6cd-4713-8caa-689c9dfdee42 tags:

 ### Übung

  - Schreibe eine Funktion namens `point_distance`, die zwei Punkte als Argumente entgegennimmt und die euklidische Distanz zwischen ihnen zurückgibt.

 %% Cell type:code id:b5957a05-e396-41c3-9b8f-f14f089115ab tags:

 ``` julia
 ```

 %% Cell type:markdown id:0fb1f6bc-e6e5-4897-bbb6-880e40e3bf20 tags:

 ### References and values

 Each object (instance of a struct) is stored at some memory address. The operator `===` checks if two variables point to the same memory address of the object. For example

 %% Cell type:markdown id:eecb6161-768e-4ae6-a600-d892894f8824 tags:

 ### Referenzen und Werte

 Jedes Objekt (Instanz einer Struktur) wird an einer bestimmten Speicheradresse gespeichert. Der Operator `===` überprüft, ob zwei Variablen auf die gleiche Speicheradresse des Objekts zeigen. Zum Beispiel

 %% Cell type:code id:ed713d91-17f4-4010-a7d3-d39826cffc97 tags:

 ``` julia
 book_copy = book
 @show book_copy === book;
 ```

 %% Cell type:markdown id:636b6713-f4ed-4220-a159-2918bd44f78e tags:

 This means that any change made to `book_copy` will also modify `book`.

 %% Cell type:markdown id:582e0ac0-2304-429e-a678-c37ab157d5d6 tags:

 Das bedeutet, dass jede Änderung, die an `book_copy` vorgenommen wird, auch `book` modifiziert.

 %% Cell type:code id:a9c46bac-d234-4616-a604-63bdf03b1393 tags:

 ``` julia
 book.properties["available"] = true
 book_copy.properties["available"] = false

 @show book;
 ```

 %% Cell type:markdown id:6bcbf983-40fa-4fc8-8eca-7cd7c45778dc tags:

 If a new, distinct, object is needed (in other words, a copy by value), we can use the function `deepcopy`.

 %% Cell type:markdown id:79339467-8994-4a5c-8987-3420d14cb290 tags:

-If a new, distinct, object is needed (in other words, a copy by value), we can use the function `deepcopy`.
+Wenn ein neues, eindeutiges Objekt benötigt wird (mit anderen Worten, eine Kopie nach Wert), können wir die Funktion `deepcopy` verwenden.

 %% Cell type:code id:c36d23c8-2292-4568-aef4-7416c6f3e538 tags:

 ``` julia
 book_copy = deepcopy(book)
 @show book_copy === book;
 ```

 %% Cell type:markdown id:02cc3ec7-e712-4c4b-abf5-9bfc98e68a91 tags:

 Finally, the `==` operator between structs defaults to the `===` operator as Julia has no way of knowing how to compare custom structs. However, it is always possible to reimplement the `==` operator for our custom types.

 %% Cell type:markdown id:4cc4c096-d856-4d43-8808-94edcd3ad906 tags:

 Schließlich entspricht der `==` Operator zwischen Strukturen standardmäßig dem `===` Operator, da Julia nicht weiß, wie benutzerdefinierte Strukturen verglichen werden sollen. Es ist jedoch immer möglich, den `==` Operator für unsere benutzerdefinierten Typen neu zu implementieren.

 %% Cell type:code id:3372eb89-cde6-4040-aa51-b4e76af97851 tags:

 ``` julia
 import Base: ==

 function ==(book1::Book, book2::Book)
    return book1.title == book2.title && book1.author == book2.author
 end

 @show book_copy == book;
 @show book_copy === book;
 ```

 %% Cell type:markdown id:87c1e4fb-d4e2-4ada-a97f-61273012146c tags:

 With this we can compare if two books are the same, even if they are two distinct instances of the same struct.

 %% Cell type:markdown id:02b533ba-2325-488a-838b-94cdf5ca25bb tags:

 Damit können wir vergleichen, ob zwei Bücher gleich sind, auch wenn es sich um zwei unterschiedliche Instanzen desselben Typs handelt.

 %% Cell type:markdown id:9263a1ae-52ee-4afc-9d9f-0f1341b64bc0 tags:

 ## Pure and impure functions

 %% Cell type:markdown id:4e457ee2-813a-42a8-8ee0-600bb4b50812 tags:

 ## Reine und unreine Funktionen

 %% Cell type:markdown id:f638e9b3-9926-46fc-81e0-d49c877a3bbb tags:

 We have seen that it is quite convenient to pass objects to functions. So far we have seen functions that print the content or that create a new object. None of these functions are modifying the content of the input objects.
  - A function that does not modify the input it is also said **pure**.
  - A function which modifies the input it is said **impure**. In Julia impure functions are highlighted by adding a `!` as the last character of the name.

 Let's consider a modified version of the book for an example.

 %% Cell type:markdown id:fb008ae0-a457-45db-8f77-425d56e95b30 tags:

 Wir haben gesehen, dass es ziemlich praktisch ist, Objekte an Funktionen zu übergeben. Bisher haben wir Funktionen gesehen, die den Inhalt ausgeben oder ein neues Objekt erstellen. Keine dieser Funktionen ändert den Inhalt der Eingabeobjekte.
  - Eine Funktion, die die Eingabe nicht ändert, wird auch als **rein** bezeichnet.
  - Eine Funktion, die die Eingabe ändert, wird als **unrein** bezeichnet. In Julia werden unreine Funktionen durch Hinzufügen eines `!` als letztem Zeichen des Namens hervorgehoben.

 Betrachten wir eine modifizierte Version des Buchs als Beispiel.

 %% Cell type:code id:7f892e07-a601-4cba-b58d-40be9c8e93ab tags:

 ``` julia
 book = Book("Der Hobbit", "J.R.R. Tolkien", Dict("available" => true, "copies_in_stock" => 10))
 @show book;
 ```

 %% Cell type:markdown id:99f4d6c9-2633-4394-b6a0-e0ce0c05e0db tags:

 Then we could think of a function which updates the database whenever we order new copies.

 %% Cell type:markdown id:7dac83b5-1086-4ca9-9b36-827497825be6 tags:

 Dann könnten wir über eine Funktion nachdenken, die die Datenbank aktualisiert, wenn wir neue Exemplare bestellen.

 %% Cell type:code id:04937488-a556-44ad-97be-98b017f293fd tags:

 ``` julia
 function order_book!(book, number_of_copies)
    if number_of_copies <= 0
        return
    end
    book.properties["copies_in_stock"] += number_of_copies
    book.properties["available"] = true
 end

 order_book!(book, 5)
 @show book;
 ```

 %% Cell type:markdown id:b30bd560-5ff3-4706-9f53-e6a5158651e9 tags:

 ### Exercise
  - Write an inpure function `sell_book!` for updating the book object whenever we sell a single copy. The function should complain if there are no copies available.

 %% Cell type:markdown id:93bc2e46-8530-4d1e-b7fa-55a74d1831c8 tags:

 ### Übung
  - Schreibe eine unreine Funktion `sell_book!`, um das Buchobjekt zu aktualisieren, wenn wir ein Exemplar verkaufen. Die Funktion sollte eine Meldung ausgeben, wenn keine Exemplare verfügbar sind.

 %% Cell type:code id:6e79fe95-767d-4b3e-af58-623db6dc0712 tags:

 ``` julia
 ```

 %% Cell type:markdown id:5ed4d4e0-0454-4298-9a56-8fb32634aa24 tags:

 ## Further exercises

 %% Cell type:markdown id:d5bb0b58-e85e-4edb-80b6-19d2c7d49ac3 tags:

 ## Weitere Übungen

 %% Cell type:markdown id:8446f1db-d40f-4311-9597-3b3b4d913151 tags:

 - Create a time struct which stores the time of the day (hour, minute and second). Write a function which takes as input the time object and prints it. Then write a function which sums together two time objects and returns a new time object. If the total is more than 24 hours, it should reset as if it was the next day.

 %% Cell type:markdown id:15fd6da2-f862-40ef-a58d-5e7be488565f tags:

 - Erstelle eine Zeitstruktur, die die Uhrzeit des Tages (Stunde, Minute und Sekunde) speichert. Schreibe eine Funktion, die als Eingabe das Zeitobjekt nimmt und es ausgibt. Schreibe dann eine Funktion, die zwei Zeitobjekte zusammenzählt und ein neues Zeitobjekt zurückgibt. Wenn die Summe mehr als 24 Stunden beträgt, sollte sie wie am nächsten Tag zurückgesetzt werden.

 %% Cell type:code id:5335e035-62ee-4d0f-acfc-a9e24ac26d99 tags:

 ``` julia
 ```

 %% Cell type:markdown id:32844b6f-518a-4174-83c6-0d7ebeabe4e4 tags:

  - Create a custom version of the `==` function which checks if two time objects are the same.

 %% Cell type:markdown id:2e0fde12-1214-4709-a7cb-5ebfaa0af17a tags:

 - Erstelle eine benutzerdefinierte Version der `==` Funktion, die überprüft, ob zwei Zeitobjekte identisch sind.

 %% Cell type:code id:966d4db1-c95a-4531-8209-a869519599ea tags:

 ``` julia
 ```

 %% Cell type:markdown id:baa7e06f-e183-4ee7-912a-e22255e18e21 tags:

  - Create a custom version of the `<` and `<=` functions for time objects.

 %% Cell type:markdown id:4e8c3c1e-14fb-439f-97c7-076196f7e5b4 tags:

 - Erstelle eine benutzerdefinierte Version der `<` und `<=` Funktionen für Zeitobjekte.

 %% Cell type:code id:c9b76667-731b-4ec2-aaf4-e94496f65b1a tags:

 ``` julia
 ```

 %% Cell type:markdown id:1bdbd748-7482-4f54-99a7-3d6e74b65575 tags:

  - Create a custom version of the `>` and `>=` functions for time objects.

 %% Cell type:markdown id:b79aad8c-647e-46d0-9b04-6a77cd219953 tags:

 - Erstelle eine benutzerdefinierte Version der `>` und `>=` Funktionen für Zeitobjekte.

 %% Cell type:code id:7df56050-686e-4a87-aa86-9b7f61315aa2 tags:

 ``` julia
 ```

--- a/src/README.md
+++ b/src/README.md
+# For developers
+
+## Setting up `pre-commit`
+
+[`pre-commit`](https://pre-commit.com/) is a framework that helps to manage and maintain pre-commit hooks to ensure that your code adheres to a consistent style, prevents errors, and adheres to other quality assurance checks.
+
+1. **Install `pre-commit`:**
+   To ensure smooth development, install `pre-commit` using pip by running the following command:
+
+   ```bash
+   pip install pre-commit
+   ```
+
+   For more information and installation options, visit the [`pre-commit`](https://pre-commit.com/) website.
+
+2. **Navigate to the project directory:**
+    Change into the project directory, i.e., `julia-seminar` by running:
+
+    ```bash
+    cd julia-seminar
+    ```
+
+3. **Install hooks:**
+    Install the git hooks by executing:
+
+    ```bash
+    pre-commit install
+    ```
+
+    This command installs the pre-commit script alongside existing git hooks.
+
+Once the pre-commit hook is installed, it will automatically check your code for any issues before each commit. If the checks do not pass, you will be prompted to fix them before proceeding.
+
+## Localizing the notebooks
+
+1. Make sure the bilingual version of the notebook is in the folder `src/`. This is for clarity reasons.
+
+2. Run `./localize.py bilingual_notebook.ipynb`. The script will ask for your help whenever it is unclear.
+You should help it to set the language of the cell to one among `en`, `de` and `eq`.
+The kind `eq` is for everything that is not a spoken language (figures, schemes, equations and similar).
+
+3. You will get two versions in the `src/` folder. Move them to the root directory, add them to git and commit.
--- a/src/localize.py
+++ b/src/localize.py
+#!/usr/bin/python3
+
+import copy
+import json
+import os
+import sys
+
+import langid
+
+
+def detect_language(text):
+    return langid.classify(text)
+
+
+def load(path):
+    with open(path, encoding="utf-8") as file:
+        notebook = json.load(file)
+    return notebook
+
+
+def human_intervention(language, probability, text):
+    print(
+        f"I classified this text:\n`{text}`\nas {language} with a non normalized probability of {probability}.\n"
+    )
+    while True:
+        print(
+            "Can you help me identifying it? write one among 'en', 'de', 'eq' (for equations), then press enter"
+        )
+        language = input()
+        if language in ["en", "de", "eq"]:
+            print("\n\n")
+            return language
+
+
+def write(path, notebook):
+    with open(path, "w", encoding="utf-8") as file:
+        json.dump(notebook, file, indent=4)
+
+
+def assign_languages(notebook):
+    cells = notebook["cells"]
+
+    for i, cell in enumerate(cells):
+        if cell["cell_type"] == "markdown":
+            text = str(cell["source"]).strip("\n# []'")
+            language, probability = detect_language(text)
+
+            if probability >= -10 or language not in ["en", "de"]:
+                # langid is doing something strange, we need to intervene
+                language = human_intervention(language, probability, text)
+
+            notebook["cells"][i]["metadata"]["natural_language"] = language
+
+
+def select_language(notebook, language):
+    cells = notebook["cells"]
+
+    selected_cells = []
+    for cell in cells:
+        if cell["cell_type"] == "markdown":
+            if cell["metadata"]["natural_language"] == language:
+                selected_cells.append(cell)
+            elif cell["metadata"]["natural_language"] == "eq":
+                selected_cells.append(cell)
+        else:
+            selected_cells.append(cell)
+
+    new_notebook = copy.deepcopy(notebook)
+    new_notebook["cells"] = selected_cells
+
+    return new_notebook
+
+
+if __name__ == "__main__":
+    PATH = sys.argv[1]
+    BASENAME = os.path.splitext(os.path.basename(PATH))[0]
+
+    NOTEBOOK = load(PATH)
+    assign_languages(NOTEBOOK)
+
+    NOTEBOOK_EN = select_language(NOTEBOOK, "en")
+    NOTEBOOK_DE = select_language(NOTEBOOK, "de")
+
+    write(f"{BASENAME}_en.ipynb", NOTEBOOK_EN)
+    write(f"{BASENAME}_de.ipynb", NOTEBOOK_DE)
No results found