diff --git a/0_Installation_de.ipynb b/0_Installation_de.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..9ed0a9cd5a5545b74dedfa612ad3325033252dda
--- /dev/null
+++ b/0_Installation_de.ipynb
@@ -0,0 +1,127 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "31ac33c0-18a9-4cfa-8e04-3ee1a0c909eb",
+ "metadata": {},
+ "source": [
+ "# Installation und Einrichtung\n",
+ "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",
+ "metadata": {},
+ "source": [
+ "## Informationen zu Notebooks\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "Wenn jedoch der Browser geschlossen wird, läuft das Backend weiter. Du kannst darauf zugreifen, indem Du die Adresse öffnest:\n",
+ "[http://localhost:8888](http://localhost:8888)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c974b7c0-119c-4223-ad80-dce5a3ceead3",
+ "metadata": {},
+ "source": [
+ "### Notebooks\n",
+ "\n",
+ "Notebooks sind Dateien, die durch die Erweiterung `.ipynb` gekennzeichnet sind. Mit dem interaktiven Datei-Explorer kannst Du sie öffnen.\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "Die Notebooks werden automatisch alle paar Minuten gespeichert, um jedoch sicherzustellen, dass sie gespeichert sind, kannst Du \"Strg + S\" drücken.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8c98e5f5-5a92-415a-b9ec-865972d45b6f",
+ "metadata": {},
+ "source": [
+ "### Zellen\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "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",
+ "execution_count": null,
+ "id": "8074a659-e100-49db-b83c-f0738b25cf28",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "println(\"Hello World!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "192dac00-072c-4699-bd06-9af6ae4e3055",
+ "metadata": {},
+ "source": [
+ "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).\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "Schließlich können neue Zellen hinzugefügt werden, indem Du das `+`-Symbol im oberen Menü verwendest.\n",
+ "\n",
+ "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",
+ "metadata": {},
+ "source": [
+ "## Überprüfen, ob alles funktioniert\n",
+ "\n",
+ "Um zu überprüfen, ob die Installation erfolgreich war, führe die folgende Zelle aus."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7bb04662",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "using Plots\n",
+ "\n",
+ "p = plot(1, xlim=(0, 3π), ylim=(-1.5, 1.5), title=\"Sine\", marker=2)\n",
+ "N = 100\n",
+ "@gif for i=1:N\n",
+ " x = (i-1) * 3π / N\n",
+ " push!(p, x, sin(x))\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c7d2870e",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "julia 1.9.3",
+ "language": "julia",
+ "name": "julia-1.9"
+ },
+ "language_info": {
+ "file_extension": ".jl",
+ "mimetype": "application/julia",
+ "name": "julia"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/0_Installation_en.ipynb b/0_Installation_en.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..7c460e566d63df5a88c224748cd0069e0b51fa85
--- /dev/null
+++ b/0_Installation_en.ipynb
@@ -0,0 +1,128 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "16b28ead",
+ "metadata": {},
+ "source": [
+ "# Installation and Setup\n",
+ "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",
+ "metadata": {},
+ "source": [
+ "## Information about notebooks\n",
+ "\n",
+ "Notebooks are tools to interactively run code and display output. They are quite convenient for experimenting with code.\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "However, if the browser is closed, the backend will keep running. You can get back to it by opening the address:\n",
+ "[http://localhost:8888](http://localhost:8888)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a915cd2f-dc38-4679-8d79-c2204e2073cf",
+ "metadata": {},
+ "source": [
+ "### Notebooks\n",
+ "\n",
+ "Notebooks are files characterized by the extension `.ipynb`. Using the interactive file explorer you can open them.\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "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",
+ "metadata": {},
+ "source": [
+ "### Cells\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "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",
+ "execution_count": null,
+ "id": "8074a659-e100-49db-b83c-f0738b25cf28",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "println(\"Hello World!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5fc38ba1-65d0-490f-8c06-4136a7ff1372",
+ "metadata": {},
+ "source": [
+ "When you click on a code cell, you can also modify its content.\n",
+ "To modify a markdown cell, you need to double click on it (however this is not required by this course).\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "Finally, new cells can be added by using the `+` symbol in the top menu.\n",
+ "\n",
+ "Every time there is an exercise left to the reader, we added an empty code cell."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d3d75953",
+ "metadata": {},
+ "source": [
+ "## Verifying that everything works\n",
+ "\n",
+ "To check if the installation was successfull, run the following cell."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7bb04662",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "using Plots\n",
+ "\n",
+ "p = plot(1, xlim=(0, 3π), ylim=(-1.5, 1.5), title=\"Sine\", marker=2)\n",
+ "N = 100\n",
+ "@gif for i=1:N\n",
+ " x = (i-1) * 3π / N\n",
+ " push!(p, x, sin(x))\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c7d2870e",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "julia 1.9.3",
+ "language": "julia",
+ "name": "julia-1.9"
+ },
+ "language_info": {
+ "file_extension": ".jl",
+ "mimetype": "application/julia",
+ "name": "julia"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/1_Basics_de.ipynb b/1_Basics_de.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..46032fe756b3936ab958bb3a1131c714ba8bf78f
--- /dev/null
+++ b/1_Basics_de.ipynb
@@ -0,0 +1,1258 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "aff6c2f6-3d10-412e-82aa-c199c98edbd7",
+ "metadata": {},
+ "source": [
+ "# Grundlagen"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3be02b91-9619-4cfd-b463-2add42babbcc",
+ "metadata": {},
+ "source": [
+ "## Variablen und elementare Datentypen\n",
+ "\n",
+ "Das Definieren von Variablen in Julia funktioniert wie in den meisten Sprachen:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3c44023b-06c9-4420-9af3-da2ec37b02da",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "int = 4 # An integer"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b2f9ba27-bf65-40d8-b0ac-e3d86c99dd40",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "str = \"Hi\" # A string"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "87a83355-5088-47d3-b698-2c6902aaa6a0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "float = 1.2 # A floating-point number"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "597523f1-4041-4fc6-9be2-2c94a93fd633",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "bool = true # A boolean (also false)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "816bc593-70cc-4e0f-b461-c9022d9587f6",
+ "metadata": {},
+ "source": [
+ "Der Typ wird automatisch abgeleitet:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b80c6777-3dea-4f45-98b3-0a3eee196183",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "typeof(int)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1fb6cbd2-871f-40a4-ae84-e7ee46e75a61",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "typeof(str)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a16a6f08-f19a-42e0-baac-aaa88ebba1af",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "typeof(float)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d5e586cc-874a-46d5-9c7c-d1136d73492e",
+ "metadata": {},
+ "source": [
+ "Julia unterstützt von Haus aus eine große Bandbreite von Ganzzahl- und Gleitkommazahlentypen, zum Beispiel:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "88f24b01-f4a5-4030-af2c-a5d30223d047",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = UInt8(1) # 8-bit wide unsigned integer\n",
+ "y = Int32(-1) # 32-bit wide signed integer\n",
+ "z = Float32(0.2) # single precision\n",
+ "α = Float16(-1.0) # half precision\n",
+ "β = ComplexF64(2. + 8im) # Complex number (composed of two Float64)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bf9f6efc-6b47-415c-8504-35a2b1a80f18",
+ "metadata": {},
+ "source": [
+ "Wenn Sie einer Variable einen ungültigen Namen geben, erhalten Sie einen Syntaxfehler:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1ca20515-6d66-40c3-84f1-2e24ece096cd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "1test = \"hello\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2c61f59e-2c2f-4049-8624-35e0712b2cf1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "more@ = 1000000"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "85040b19-b0a9-4baa-8748-5ea62f8b5633",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "struct = \"another illegale variable name\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2e5659b9-9e66-448a-a768-23d7085d7dac",
+ "metadata": {},
+ "source": [
+ "Es stellt sich heraus, dass `struct` eines der Schlüsselwörter von Julia ist und nicht als Variablennamen verwendet werden kann.\n",
+ "\n",
+ "- 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).\n",
+ "- 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": "e099c88a-5848-4730-be7d-b7651bc3db29",
+ "metadata": {},
+ "source": [
+ "### Zeichenketten"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "925cbca6-cce3-4084-96a2-fe0a5acdb1e9",
+ "metadata": {},
+ "source": [
+ "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",
+ "execution_count": null,
+ "id": "246f1db8-d734-413d-9237-b2434e071914",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\"2\" - \"1\"\n",
+ "\"eggs\" / \"easy\"\n",
+ "\"third\" + \"a charm\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c2c39aa8-d98b-42dd-8e7c-09463f78d22c",
+ "metadata": {},
+ "source": [
+ "Es gibt jedoch zwei Ausnahmen, * und ^."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b3a0f6e1-e28b-4fb7-baa3-bb003de3dc24",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\"Hello \" * \"world\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0c963c3c-47c7-4805-8be6-621b72fdb62e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\"hello! \"^5"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7b7ff4e3",
+ "metadata": {},
+ "source": [
+ "Für weitere Details: [https://docs.julialang.org/en/v1/manual/strings/](https://docs.julialang.org/en/v1/manual/strings/)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "43fe0add-b90d-4ed4-862e-37a4361d2354",
+ "metadata": {},
+ "source": [
+ "### Übungen"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3e392c67-df83-49fc-831d-12e157e4a85c",
+ "metadata": {},
+ "source": [
+ "Üben Sie, Julia als Taschenrechner zu verwenden:\n",
+ "\n",
+ " - 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",
+ "execution_count": null,
+ "id": "fc538246-418c-4ebe-b487-81feba4383c8",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "32f7a6f1-6a19-4ebe-bd1b-846f861dc721",
+ "metadata": {},
+ "source": [
+ "- 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?\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bd4150cf-005a-4087-aa92-5f4b18e4d197",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "53e26ee8-c10d-42e4-bbb9-cb5f696139ba",
+ "metadata": {},
+ "source": [
+ "## Bedingungen und boolesche Ausdrücke\n",
+ "\n",
+ "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",
+ "execution_count": null,
+ "id": "7de4ffe9-4730-47dd-b074-1525bf9937b1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "5 == 5"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c02939dd-6f25-4916-8394-a5f95d0200df",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "5 == 6"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4722b7b7-3f80-454f-bd8b-f67912105f79",
+ "metadata": {},
+ "source": [
+ "Der == Operator ist einer der relationalen Operatoren; die anderen sind:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b59cd314-fd03-4609-ac1b-7329a2c3cc38",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = 3; y = 4\n",
+ "x != y # x is not equal to y\n",
+ "x ≠ y # (to get the ≠ symbol, type \\ne and then press TAB)\n",
+ "x > y # x is greater than y\n",
+ "x < y # x is less than y\n",
+ "x >= y # x is greater than or equal to y\n",
+ "x ≥ y # (to get the ≥ symbol, type \\ge and then press TAB)\n",
+ "x <= y # x is less than or equal to y\n",
+ "x ≤ y # (to get the ≤ symbol, type \\le and then press TAB)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "01c9f186-294f-4659-bc32-cee3b6ff4f40",
+ "metadata": {},
+ "source": [
+ "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",
+ "execution_count": null,
+ "id": "d1e6e2ce-bb0c-4776-80b6-22ceb9c68397",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = 4\n",
+ "x > 0 && x < 10"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "857cde91-3430-480c-9f24-bb9c465248d9",
+ "metadata": {},
+ "source": [
+ "Es ist auch erwähnenswert, dass bei kombinierten logischen Ausdrücken nicht alle Bedingungen notwendigerweise ausgeführt werden."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e92abf7b-5414-4aee-abaf-a4e52b1c06d3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "true || println(\"The RHS of || is only run\")\n",
+ "false || println(\"if the LHS is false\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c8a9d8ac-5378-4ebb-810b-9ae3194d670c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "iseven(3) && println(\"The RHS of || is only run\")\n",
+ "isodd(3) && println(\"if the LHS is true\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d8db49a8-6c6c-4abf-9a5b-5d27765ab1c7",
+ "metadata": {},
+ "source": [
+ "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",
+ "execution_count": null,
+ "id": "e43ab736-03e2-4040-a15e-48305037ba23",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = 4\n",
+ "!(x > 0 && x < 10)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fbe0d04d-29c9-4bd0-9cfb-0c57a3b3f877",
+ "metadata": {},
+ "source": [
+ "Es überrascht nicht, dass Julia die üblichen Bedingungsanweisungen hat."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4f140e2c-a240-496d-904c-c60778397bcf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = 3; y = 2\n",
+ "\n",
+ "if x < y\n",
+ " println(\"x is less than y\")\n",
+ "elseif x > y\n",
+ " println(\"x is greater than y\")\n",
+ "else\n",
+ " println(\"x is equal to y\")\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "64a3bf26-156f-40a8-8d8c-d4b2f838ef95",
+ "metadata": {},
+ "source": [
+ "Es gibt auch eine bedingte Inline-Anweisung."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9d0801fd-b0d3-41e0-8b54-19a6b4539231",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = 6\n",
+ "x < 5 ? \"smaller than 5\" : \"larger or equal 5\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2539a6ec-e950-4b76-ad13-4ac9bb28ec26",
+ "metadata": {},
+ "source": [
+ "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": "7c8eb301-3404-4d13-bc5d-f4e2f71cfa12",
+ "metadata": {},
+ "source": [
+ "## Iterationen\n",
+ "\n",
+ "Julia implementiert die üblichen `for`- und `while`-Befehle."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9632f210-c713-4829-8187-cf5554adad87",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for i in 1:5\n",
+ " println(\"Hello from number $i\")\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d0933cf7-b409-4c40-8184-70d0770a06b1",
+ "metadata": {},
+ "source": [
+ "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",
+ "execution_count": null,
+ "id": "70a9f620-e4ce-4367-b0f5-de37db3f48b5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "result = 0\n",
+ "# To get ∈ write \\in and then press TAB\n",
+ "for j ∈ 1:0.5:3 # Note the step parameter\n",
+ " result += j\n",
+ "end\n",
+ "println(result)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e83b2d88-b0f2-43f1-9187-65fbc75f0d3b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "n = 10\n",
+ "while n > 0\n",
+ " print(n, \" \")\n",
+ " n = n - 1\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "76563c39-4e45-4daf-b703-575909f70787",
+ "metadata": {},
+ "source": [
+ "Die Schleifen können mit den Schlüsselwörtern `break` und `continue` weiter gesteuert werden."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b38f525d-db83-4fbf-808c-bf39080650f5",
+ "metadata": {},
+ "source": [
+ "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",
+ "execution_count": null,
+ "id": "9bb642e3-e3b1-488d-939f-6932feb62479",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "while true\n",
+ " print(\"> \")\n",
+ " line = readline()\n",
+ " if line == \"done\"\n",
+ " break\n",
+ " end\n",
+ " println(line)\n",
+ "end\n",
+ "println(\"Done!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "873c3625-3b99-48e5-9821-9b696a8f8a12",
+ "metadata": {},
+ "source": [
+ "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",
+ "execution_count": null,
+ "id": "7f1c2595-8836-4308-9769-f4140d402582",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for i in 1:10\n",
+ " if i % 3 == 0\n",
+ " continue\n",
+ " end\n",
+ " print(i, \" \")\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d2e93721",
+ "metadata": {},
+ "source": [
+ "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": "625f1e1b-ab4d-425d-b848-94385ddcb690",
+ "metadata": {},
+ "source": [
+ "### Übungen"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6a0dcd06-0926-4529-ac33-0aee315f85cf",
+ "metadata": {},
+ "source": [
+ "Der Mathematiker Srinivasa Ramanujan fand eine unendliche Reihe, die verwendet werden kann, um eine numerische Näherung von 1/π zu generieren:\n",
+ "\n",
+ "$$ \\frac{1}{\\pi} = \\frac{2\\sqrt{2}}{9801} \\sum_{k=0}^\\infty \\frac{(4k)! (1103 + 26390 k)}{(k!)^4 396^{4 k}}$$\n",
+ "\n",
+ "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",
+ "execution_count": null,
+ "id": "dbe40300-8333-4271-aa43-49f973fa03a6",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e2072b09-53e0-4354-984b-13813e93fef1",
+ "metadata": {},
+ "source": [
+ "## Funktionen"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8fde350c-f73a-44b7-9459-b8f6d79120cf",
+ "metadata": {},
+ "source": [
+ "Wir haben bereits ein Beispiel für einen Funktionsaufruf gesehen:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "addaa346-7a88-4c18-9f1e-295665959a9d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "println(\"Hello, World!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ef1e8206-add5-49f9-ab4c-4b730164aee6",
+ "metadata": {},
+ "source": [
+ "Der Name der Funktion ist println. Der Ausdruck in Klammern wird als Argument der Funktion bezeichnet.\n",
+ "Es ist üblich zu sagen, dass eine Funktion ein Argument \"nimmt\" und ein Ergebnis \"zurückgibt\". Das Ergebnis wird auch als Rückgabewert bezeichnet.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd083417-b51a-4f0e-a150-56a0f9c33569",
+ "metadata": {},
+ "source": [
+ "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:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1f05465a-4863-4205-9c73-26f0e93f049b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "parse(Int64, \"32\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e6ac9994-9cbb-4004-889d-a657b8396063",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "parse(Int64, \"Hello\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9176592b-e9f3-46fd-9909-8b73da750434",
+ "metadata": {},
+ "source": [
+ "Julia stellt verschiedene mathematische Funktionen zur Verfügung:\n",
+ " - abs, sqrt, cbrt, exp, log, log10, log2\n",
+ " - sin, cos, tan, asin, acos, atan\n",
+ " - sinh, cosh, tanh, asinh, acosh, atanh\n",
+ " - floor: Größte ganze Zahl, die nicht größer als x ist.\n",
+ " - ceil: Kleinste ganze Zahl, die nicht kleiner als x ist.\n",
+ " - round: Nächstgelegene ganze Zahl zu x.\n",
+ " - trunc: Ganzzahliger Teil von x.\n",
+ "\n",
+ "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": "f43cb468-832a-4cab-b8a3-15bb9bcbfb0d",
+ "metadata": {},
+ "source": [
+ "Bisher haben wir nur die Funktionen verwendet, die mit Julia geliefert werden, aber es ist auch möglich, neue Funktionen hinzuzufügen.\n",
+ "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",
+ "execution_count": null,
+ "id": "fd2f4828-47f5-4df4-b5bd-a42625487b5a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "function mymult(x, y)\n",
+ " x * y\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e8dfb238-54be-4a95-9eda-4ce1fa5cfd74",
+ "metadata": {},
+ "source": [
+ "Für Einzeiler-Funktionen kann man auch eine praktische Kurzschreibweise verwenden:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5ed8292a-96e2-49ad-8f00-3c07b9483637",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mysquare(x) = mymult(x, x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9b688bbf-08b6-4fba-babe-b16b6e1119be",
+ "metadata": {},
+ "source": [
+ "Beide Funktionen sind in den Argumenttypen vollständig generisch"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "49ceeeff-5291-460d-800d-5ed11a03b13e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "@show mysquare(2) # Use integer arithmetic\n",
+ "@show mymult(-1, 3. + 2im) # Use complex arithmetic\n",
+ "@show mysquare(\" abc \"); # Use string concatenation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6add8ab6-7f66-431b-9e9e-e52d45379483",
+ "metadata": {},
+ "source": [
+ "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",
+ "execution_count": null,
+ "id": "7e5dcfeb-960a-47f3-b2f8-f6f0906d2f24",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mymult"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3be89ab5-16f3-4633-bb8d-fd74cf39ddec",
+ "metadata": {},
+ "source": [
+ "und können an andere Funktionen übergeben werden, zum Beispiel:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "171b1a83-c076-4ac4-a309-9d607ea0b5a4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\"\"\"The fold function, applying f from the left and accumulating the results\"\"\"\n",
+ "function myfold(f, x, y, z)\n",
+ " f(f(x, y), z)\n",
+ "end\n",
+ "myfold(mymult, \"Hello\", \" Julia \", \"World\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "09a40182-e59f-42e4-b11e-0c3aedd0e7a6",
+ "metadata": {},
+ "source": [
+ "Julia unterscheidet zwischen **Funktionen** und **Methoden**. Grob gesagt geben **Funktionen** an, *was* gemacht wird, und **Methoden** geben an, *wie* dies gemacht wird.\n",
+ "\n",
+ "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**.\n",
+ "\n",
+ "Für unser `myfold`-Beispiel könnte man sich leicht einige weitere Methodenimplementierungen vorstellen, zum Beispiel:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c249f818-6544-42fe-b387-34058e5f5890",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "myfold(f, x) = x\n",
+ "myfold(f, x, y) = f(x, y)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "88f62159-2a1b-4a5a-8434-0e91810f2c69",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "methods(myfold)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cc818df4-a037-4ba2-8588-1afe4a6de222",
+ "metadata": {},
+ "source": [
+ "Nun funktioniert `myfold` transparent mit 1, 2 oder 3 Argumenten:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d67f9c21-2c5c-43fd-a7e4-a4ce74281bf0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "@show myfold(mymult, 2., 3.)\n",
+ "@show myfold(+, 1)\n",
+ "@show myfold(==, false, false, true)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5a9a652b-80c4-482f-80b8-2c5340e61a21",
+ "metadata": {},
+ "source": [
+ "Wir können auch überprüfen, welche Methode tatsächlich verwendet wird, indem wir das `@which`-Makro verwenden:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0fa105fb-b3ad-405a-85f1-598a12cbc655",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "@which myfold(*, 1, 2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4046d2e8-2018-4f4f-b816-2a6156301f39",
+ "metadata": {},
+ "source": [
+ "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",
+ "execution_count": null,
+ "id": "d771af33-5174-4a95-b8e3-ac1c29eb71e9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import Base: + # we have to import functions to override/extend them\n",
+ "+(x::String, y::String) = x * \" \" * y"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "32429003-4879-4a37-ad3c-153857a360dd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\"Hello\" + \"World!\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ee25eff6-f56e-4230-b52d-6020dcc29bb2",
+ "metadata": {},
+ "source": [
+ "(**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": "a2c9d8cf-0462-415c-a466-edb33b3aadec",
+ "metadata": {},
+ "source": [
+ "Nun funktionieren Standardfunktionen, die auf `+` angewiesen sind, einfach magisch:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "75b4afeb-a3f4-40d7-8b23-b961b01c41bc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sum([\"a\", \"b\", \"c\", \"d\", \"e\"])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "013b3faf-5f12-482b-956e-de97a2a4830d",
+ "metadata": {},
+ "source": [
+ "Variablen und Parameter sind lokal, sie existieren nur innerhalb der Funktionen, in denen sie definiert sind:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d02e6bca-6723-4a05-82ee-1f30ba127bd5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "function multiply_and_print(a, b)\n",
+ " product = a * b\n",
+ " println(product)\n",
+ "end\n",
+ "\n",
+ "multiply_and_print(2, 3)\n",
+ "println(product)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0a398295-22e0-45dc-b43c-5f1915a16364",
+ "metadata": {},
+ "source": [
+ "Es mag nicht klar sein, warum es sich lohnt, ein Programm in Funktionen zu unterteilen. Es gibt mehrere Gründe dafür:\n",
+ "\n",
+ "- 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.\n",
+ "- 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.\n",
+ "- Das Aufteilen eines langen Programms in Funktionen ermöglicht es Ihnen, die Teile nacheinander zu debuggen und dann zu einem funktionierenden Ganzen zusammenzufügen.\n",
+ "- Gut gestaltete Funktionen sind oft für viele Programme nützlich. Sobald Sie eine geschrieben und debuggt haben, können Sie sie wiederverwenden.\n",
+ "- In Julia können Funktionen die Schnelligkeit erheblich verbessern.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dfa722c2-bd4c-4162-b10d-24c0f8e990e0",
+ "metadata": {},
+ "source": [
+ "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": "a4eafce6-b493-470f-86a3-93319684ee40",
+ "metadata": {},
+ "source": [
+ "### Übungen"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "08fe364b-e611-419b-97f2-e806881d6227",
+ "metadata": {},
+ "source": [
+ "- Schreiben Sie eine Funktion `printgrid`, die ein Raster wie folgt zeichnet:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1704f451-9500-41c5-b74b-4a2b4a7b910f",
+ "metadata": {},
+ "source": [
+ " + - - - - + - - - - +\n",
+ " | | |\n",
+ " | | |\n",
+ " | | |\n",
+ " | | |\n",
+ " + - - - - + - - - - +\n",
+ " | | |\n",
+ " | | |\n",
+ " | | |\n",
+ " | | |\n",
+ " + - - - - + - - - - +"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "58ef3248-f85e-4825-bf10-02cee3e068cb",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "41f2bf0f-73f4-4671-b059-1118c35ec76f",
+ "metadata": {},
+ "source": [
+ "- Schreiben Sie eine Funktion, die ein ähnliches Raster mit vier Zeilen und vier Spalten zeichnet."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2e606498-6553-4037-a9f9-3b519ffc64c9",
+ "metadata": {},
+ "source": [
+ "Tipps:\n",
+ "- Um mehr als einen Wert in einer Zeile auszugeben, können Sie eine kommagetrennte Sequenz von Werten ausgeben: println(\"+\", \"-\").\n",
+ "- Die Funktion print springt nicht zur nächsten Zeile."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1ca1789d-eddb-4f41-9ad9-9259c6f22a14",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "53edcb8b-2f37-404f-8df6-d84b2327e96e",
+ "metadata": {},
+ "source": [
+ "### Rekursive Funktionen\n",
+ "\n",
+ "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",
+ "execution_count": null,
+ "id": "e578011e-d0de-4f86-8c2c-a8408454d3ac",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "function countdown(n)\n",
+ " if n ≤ 0\n",
+ " println(\"Blastoff!\")\n",
+ " else\n",
+ " print(n, \" \")\n",
+ " countdown(n-1)\n",
+ " end\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3af51513-c92e-4488-b2fe-243e2fef6b95",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "countdown(10)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "73ea203a-3919-4e14-b50f-22c8362eb771",
+ "metadata": {},
+ "source": [
+ "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",
+ "execution_count": null,
+ "id": "13a4a762-6584-47ab-9fb5-428557770d15",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "function recurse()\n",
+ " recurse()\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0dde579f-6b12-4072-aa62-aeee3a970503",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "recurse()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a0402c3d-95fa-44a1-86ab-ca229508f68f",
+ "metadata": {},
+ "source": [
+ "### Übungen\n",
+ " - Schreiben Sie eine rekursive Funktion zur Berechnung der Fakultät einer Zahl."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f4102487-011e-474f-ab79-3d7db1d3bbd9",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a24cdaef-98b8-46f5-a809-992547882a4b",
+ "metadata": {},
+ "source": [
+ " - Schreiben Sie dann eine Funktion, die die Binomialkoeffizienten berechnet\n",
+ "$$ \\left(\\begin{array}{c} n \\\\ k \\end{array}\\right) = \\frac{n!}{k! (n-k)!} $$\n",
+ "indem sie die Funktion aus den vorherigen Punkten aufruft."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b54c877e-5494-4657-ba7f-208bdc301225",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a32900cc-c244-4d63-8ff6-4d11cee83eee",
+ "metadata": {},
+ "source": [
+ " - Verwenden Sie die beiden Funktionen, um folgendes zu berechnen\n",
+ "$$ 15! \\qquad \\left(\\begin{array}{c} 5 \\\\ 2 \\end{array}\\right) \\qquad \\left(\\begin{array}{c} 5 \\\\ 3 \\end{array}\\right) $$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fb02aad5-d9d4-4f0d-8118-b02b73506b89",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b5944412-0d39-4c0b-a0d5-fbeee22e1432",
+ "metadata": {},
+ "source": [
+ "### Schlüsselwortargumente\n",
+ "\n",
+ "Funktionsargumente können entweder positionsbasiert (wie wir bisher gesehen haben) oder schlüsselwortbasiert sein, wie im folgenden Beispiel."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "30ddeb3b-be35-40eb-8491-1269a4e19f62",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "function greet(name; greeting=\"Hello\")\n",
+ " println(\"$(greeting), $(name)!\")\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b39f22b1-4a1b-4afd-b6db-041bd7150b66",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "greet(\"Michele\")\n",
+ "greet(\"Lambert\"; greeting=\"Hallo\")\n",
+ "greet(\"YingXing\"; greeting=\"你好\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "07e76016-d5a9-4616-b0b9-2dc9b6f3c8f6",
+ "metadata": {},
+ "source": [
+ "Dies ist in den folgenden Fällen sehr praktisch:\n",
+ " - um ein Standardverhalten der Funktion festzulegen, während die Möglichkeit besteht, sie fein zu steuern.\n",
+ " - um zu einem späteren Zeitpunkt neue Funktionalitäten hinzuzufügen, ohne die Abwärtskompatibilität zu brechen."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "883b3945-d30a-4f27-928f-458c9ad74e9b",
+ "metadata": {},
+ "source": [
+ "## Weitere Übungen"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "54537041-60eb-4961-9805-1d7d405fde1a",
+ "metadata": {},
+ "source": [
+ "- 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",
+ "execution_count": null,
+ "id": "7ca7c936-fb80-4aed-9788-75a55bb207ad",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "70dacb25-360f-4a7a-8c03-73cd0d75dc3e",
+ "metadata": {},
+ "source": [
+ "- 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",
+ "execution_count": null,
+ "id": "a30a1812-6116-4441-8786-7450c60ef354",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cabe824-c7eb-46fc-afb8-e039528d2d2a",
+ "metadata": {},
+ "source": [
+ "- 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",
+ "execution_count": null,
+ "id": "af0e28bd-2b3f-41af-aa92-456e29d50679",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Julia 1.9.3",
+ "language": "julia",
+ "name": "julia-1.9"
+ },
+ "language_info": {
+ "file_extension": ".jl",
+ "mimetype": "application/julia",
+ "name": "julia"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/1_Basics_en.ipynb b/1_Basics_en.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..d7838a5cebe9a921aeec8e4d056d58d8e7905ace
--- /dev/null
+++ b/1_Basics_en.ipynb
@@ -0,0 +1,1256 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "7aad3586-d57e-4000-8688-aa5b53d48416",
+ "metadata": {},
+ "source": [
+ "# Basics"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bf904dbe-3197-4a91-bbb8-05e1c7f7dfee",
+ "metadata": {},
+ "source": [
+ "## Variables and elementary types\n",
+ "\n",
+ "Defining variables in Julia works like in most languages:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3c44023b-06c9-4420-9af3-da2ec37b02da",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "int = 4 # An integer"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b2f9ba27-bf65-40d8-b0ac-e3d86c99dd40",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "str = \"Hi\" # A string"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "87a83355-5088-47d3-b698-2c6902aaa6a0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "float = 1.2 # A floating-point number"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "597523f1-4041-4fc6-9be2-2c94a93fd633",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "bool = true # A boolean (also false)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0c538bdb-f995-4589-bee7-0989c922090c",
+ "metadata": {},
+ "source": [
+ "The type is automatically inferred:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b80c6777-3dea-4f45-98b3-0a3eee196183",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "typeof(int)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1fb6cbd2-871f-40a4-ae84-e7ee46e75a61",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "typeof(str)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a16a6f08-f19a-42e0-baac-aaa88ebba1af",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "typeof(float)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "09d035eb-22aa-49f5-9fd1-a5b16973f386",
+ "metadata": {},
+ "source": [
+ "Julia supports a large range of integer and floating-point types out of the box, for example:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "88f24b01-f4a5-4030-af2c-a5d30223d047",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = UInt8(1) # 8-bit wide unsigned integer\n",
+ "y = Int32(-1) # 32-bit wide signed integer\n",
+ "z = Float32(0.2) # single precision\n",
+ "α = Float16(-1.0) # half precision\n",
+ "β = ComplexF64(2. + 8im) # Complex number (composed of two Float64)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a615bbc0-732e-461f-8c4c-a972fa2be731",
+ "metadata": {},
+ "source": [
+ "If you give a variable an illegal name, you get a syntax error:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1ca20515-6d66-40c3-84f1-2e24ece096cd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "1test = \"hello\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2c61f59e-2c2f-4049-8624-35e0712b2cf1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "more@ = 1000000"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "85040b19-b0a9-4baa-8748-5ea62f8b5633",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "struct = \"another illegale variable name\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cc36688b-c983-43f8-8bdf-9b82aae59909",
+ "metadata": {},
+ "source": [
+ "It turns out that `struct` is one of Julia’s keywords, and they cannot be used as variable names. \n",
+ "\n",
+ "- For more Julia's keywords, see [https://docs.julialang.org/en/v1/base/base/#Keywords](https://docs.julialang.org/en/v1/base/base/#Keywords). \n",
+ "- 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": "de111dbe-f7ed-4e1a-8ec0-c5e65bd63bbf",
+ "metadata": {},
+ "source": [
+ "### Strings"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1b3531e9-33db-4c51-b394-c1def6621519",
+ "metadata": {},
+ "source": [
+ "In general, you can’t perform mathematical operations on strings, even if the strings look like numbers, so the following are illegal:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "246f1db8-d734-413d-9237-b2434e071914",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\"2\" - \"1\"\n",
+ "\"eggs\" / \"easy\"\n",
+ "\"third\" + \"a charm\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c94f1187-67f8-473e-910c-2eb145ed59dd",
+ "metadata": {},
+ "source": [
+ "But there are two exceptions, * and ^."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b3a0f6e1-e28b-4fb7-baa3-bb003de3dc24",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\"Hello \" * \"world\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0c963c3c-47c7-4805-8be6-621b72fdb62e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\"hello! \"^5"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "362f9d04-eff9-4594-aa22-a9c8d601fb1e",
+ "metadata": {},
+ "source": [
+ "For more 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",
+ "metadata": {},
+ "source": [
+ "### Exercises"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e0aecc9c-e77f-449e-8aff-e1ffcf5d7833",
+ "metadata": {},
+ "source": [
+ "Practice using Julia as a calculator:\n",
+ " - 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": "code",
+ "execution_count": null,
+ "id": "fc538246-418c-4ebe-b487-81feba4383c8",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "10f1604d-8e81-4f96-8b6f-95753f0b5c4f",
+ "metadata": {},
+ "source": [
+ " - 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": "code",
+ "execution_count": null,
+ "id": "bd4150cf-005a-4087-aa92-5f4b18e4d197",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dc9cddb9-717d-4ba0-b478-beb00afc46c8",
+ "metadata": {},
+ "source": [
+ "## Conditionals and Boolean Expressions\n",
+ "\n",
+ "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": "code",
+ "execution_count": null,
+ "id": "7de4ffe9-4730-47dd-b074-1525bf9937b1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "5 == 5"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c02939dd-6f25-4916-8394-a5f95d0200df",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "5 == 6"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9a108e63-7d58-489d-b7ef-49629c879d29",
+ "metadata": {},
+ "source": [
+ "The == operator is one of the relational operators; the others are:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b59cd314-fd03-4609-ac1b-7329a2c3cc38",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = 3; y = 4\n",
+ "x != y # x is not equal to y\n",
+ "x ≠ y # (to get the ≠ symbol, type \\ne and then press TAB)\n",
+ "x > y # x is greater than y\n",
+ "x < y # x is less than y\n",
+ "x >= y # x is greater than or equal to y\n",
+ "x ≥ y # (to get the ≥ symbol, type \\ge and then press TAB)\n",
+ "x <= y # x is less than or equal to y\n",
+ "x ≤ y # (to get the ≤ symbol, type \\le and then press TAB)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "15e20f55-1a43-4d0d-94bc-d2de0ee2fe8c",
+ "metadata": {},
+ "source": [
+ "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": "code",
+ "execution_count": null,
+ "id": "d1e6e2ce-bb0c-4776-80b6-22ceb9c68397",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = 4\n",
+ "x > 0 && x < 10"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "da591654-6360-4f56-956b-07493d1d2247",
+ "metadata": {},
+ "source": [
+ "It is also worth mentioning that in combined logical expression not all conditions are necessarily executed."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e92abf7b-5414-4aee-abaf-a4e52b1c06d3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "true || println(\"The RHS of || is only run\")\n",
+ "false || println(\"if the LHS is false\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c8a9d8ac-5378-4ebb-810b-9ae3194d670c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "iseven(3) && println(\"The RHS of || is only run\")\n",
+ "isodd(3) && println(\"if the LHS is true\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "be0c63e0-35a9-43c7-9b30-d04072ee6904",
+ "metadata": {},
+ "source": [
+ "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": "code",
+ "execution_count": null,
+ "id": "e43ab736-03e2-4040-a15e-48305037ba23",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = 4\n",
+ "!(x > 0 && x < 10)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7064ae20-6d63-40fc-85c5-080ace54e7b6",
+ "metadata": {},
+ "source": [
+ "Unsurprisingly Julia has the standard conditionals."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4f140e2c-a240-496d-904c-c60778397bcf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = 3; y = 2\n",
+ "\n",
+ "if x < y\n",
+ " println(\"x is less than y\")\n",
+ "elseif x > y\n",
+ " println(\"x is greater than y\")\n",
+ "else\n",
+ " println(\"x is equal to y\")\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4c57139e-da0c-48ef-a86f-4de80e1d7ca4",
+ "metadata": {},
+ "source": [
+ "There is also an inline conditional."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9d0801fd-b0d3-41e0-8b54-19a6b4539231",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = 6\n",
+ "x < 5 ? \"smaller than 5\" : \"larger or equal 5\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b597c363-8066-470e-b1c8-edd00b114317",
+ "metadata": {},
+ "source": [
+ "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": "e4510840-0890-4217-8a8c-c24aa5d3405b",
+ "metadata": {},
+ "source": [
+ "## Iterations\n",
+ "\n",
+ "Julia implements the standard `for` and `while` constructs."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9632f210-c713-4829-8187-cf5554adad87",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for i in 1:5\n",
+ " println(\"Hello from number $i\")\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f00caf15-4992-4c0a-8324-9d2be966346d",
+ "metadata": {},
+ "source": [
+ "Where the `1:5` is a `Range`-object, but it could be any iterable. There are a few syntax variations, including:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "70a9f620-e4ce-4367-b0f5-de37db3f48b5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "result = 0\n",
+ "# To get ∈ write \\in and then press TAB\n",
+ "for j ∈ 1:0.5:3 # Note the step parameter\n",
+ " result += j\n",
+ "end\n",
+ "println(result)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e83b2d88-b0f2-43f1-9187-65fbc75f0d3b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "n = 10\n",
+ "while n > 0\n",
+ " print(n, \" \")\n",
+ " n = n - 1\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f19d5051-ce82-49cc-80aa-2434a6adc9d0",
+ "metadata": {},
+ "source": [
+ "The loops can be further controlled with the `break` and `continue` keywords."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d0ebce97-3054-4eba-821d-92f27793d752",
+ "metadata": {},
+ "source": [
+ "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": "code",
+ "execution_count": null,
+ "id": "9bb642e3-e3b1-488d-939f-6932feb62479",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "while true\n",
+ " print(\"> \")\n",
+ " line = readline()\n",
+ " if line == \"done\"\n",
+ " break\n",
+ " end\n",
+ " println(line)\n",
+ "end\n",
+ "println(\"Done!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "98eee547-21fe-4022-bde5-b02ababa26dd",
+ "metadata": {},
+ "source": [
+ "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": "code",
+ "execution_count": null,
+ "id": "7f1c2595-8836-4308-9769-f4140d402582",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for i in 1:10\n",
+ " if i % 3 == 0\n",
+ " continue\n",
+ " end\n",
+ " print(i, \" \")\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b8eac9e9-dff9-4b86-88a7-e14f27b7f677",
+ "metadata": {},
+ "source": [
+ "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": "990cefae-abfe-4649-8d68-3fac1b1e268b",
+ "metadata": {},
+ "source": [
+ "### Exercises"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bdb2eef9-bdee-4cf3-8bab-d6c1d46ecc2f",
+ "metadata": {},
+ "source": [
+ "The mathematician Srinivasa Ramanujan found an infinite series that can be used to generate a numerical approximation of 1/π\n",
+ "\n",
+ "$$ \\frac{1}{\\pi} = \\frac{2\\sqrt{2}}{9801} \\sum_{k=0}^\\infty \\frac{(4k)! (1103 + 26390 k)}{(k!)^4 396^{4 k}}$$\n",
+ "\n",
+ "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": "code",
+ "execution_count": null,
+ "id": "dbe40300-8333-4271-aa43-49f973fa03a6",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d4a870c3-7679-4775-94ce-4e7266a2bebe",
+ "metadata": {},
+ "source": [
+ "## Functions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "682a3feb-0b82-479d-9803-3011a1e6e521",
+ "metadata": {},
+ "source": [
+ "We have already seen one example of a function call:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "addaa346-7a88-4c18-9f1e-295665959a9d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "println(\"Hello, World!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3434842c-2af0-4f6a-a70b-a59fb8fcc4af",
+ "metadata": {},
+ "source": [
+ "The name of the function is println. The expression in parentheses is called the argument of the function.\n",
+ "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": "f63d270a-7149-4ffd-bc31-f746560a37ac",
+ "metadata": {},
+ "source": [
+ "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": "code",
+ "execution_count": null,
+ "id": "1f05465a-4863-4205-9c73-26f0e93f049b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "parse(Int64, \"32\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e6ac9994-9cbb-4004-889d-a657b8396063",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "parse(Int64, \"Hello\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "793c9620-7b6e-443c-8765-8136fbfcb071",
+ "metadata": {},
+ "source": [
+ "Julia provides several mathematical functions.\n",
+ " - abs, sqrt, cbrt, exp, log, log10, log2\n",
+ " - sin, cos, tan, asin, acos, atan\n",
+ " - sinh, cosh, tanh, asinh, acosh, atanh\n",
+ " - floor: Largest integer not greater than x.\n",
+ " - ceil: Smallest integer not less than x.\n",
+ " - round: Nearest integer to x.\n",
+ " - trunc: Integer part of x.\n",
+ "\n",
+ "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": "d048851b-8eac-4dc3-81b7-ea1d625a1db2",
+ "metadata": {},
+ "source": [
+ "So far, we have only been using the functions that come with Julia, but it is also possible to add new functions. \n",
+ "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": "code",
+ "execution_count": null,
+ "id": "fd2f4828-47f5-4df4-b5bd-a42625487b5a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "function mymult(x, y)\n",
+ " x * y\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "08bab11e-df61-4906-a925-b93184e5c600",
+ "metadata": {},
+ "source": [
+ "For one-line functions one may also use a convenient short-hand:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5ed8292a-96e2-49ad-8f00-3c07b9483637",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mysquare(x) = mymult(x, x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "13b7892e-df8a-462f-a84c-107276d8e499",
+ "metadata": {},
+ "source": [
+ "Both such functions are fully generic in the argument types"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "49ceeeff-5291-460d-800d-5ed11a03b13e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "@show mysquare(2) # Use integer arithmetic\n",
+ "@show mymult(-1, 3. + 2im) # Use complex arithmetic\n",
+ "@show mysquare(\" abc \"); # Use string concatenation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "15ece147-0384-4c1b-a8c3-d11a795bd1b7",
+ "metadata": {},
+ "source": [
+ "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": "code",
+ "execution_count": null,
+ "id": "7e5dcfeb-960a-47f3-b2f8-f6f0906d2f24",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mymult"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "934dc8e8-564b-4566-9eb0-a96df39f0870",
+ "metadata": {},
+ "source": [
+ "and may be passed around to other functions, for example:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "171b1a83-c076-4ac4-a309-9d607ea0b5a4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\"\"\"The fold function, applying f from the left and accumulating the results\"\"\"\n",
+ "function myfold(f, x, y, z)\n",
+ " f(f(x, y), z)\n",
+ "end\n",
+ "myfold(mymult, \"Hello\", \" Julia \", \"World\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f31327e4-5d69-4dfb-a4bf-ed1e419b1be3",
+ "metadata": {},
+ "source": [
+ "Julia makes a distinction between **functions** and **methods**. Roughly speaking **function**s specify *what* is done and **methods** specify *how* this is done.\n",
+ "\n",
+ "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. \n",
+ "\n",
+ "For our `myfold` example, one could easily imagine a few more method implementations, for example:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c249f818-6544-42fe-b387-34058e5f5890",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "myfold(f, x) = x\n",
+ "myfold(f, x, y) = f(x, y)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "88f62159-2a1b-4a5a-8434-0e91810f2c69",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "methods(myfold)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "879d9441-ece1-4f07-a496-6aef71fd2e91",
+ "metadata": {},
+ "source": [
+ "So now `myfold` works transparently with 1, 2 or 3 arguments:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d67f9c21-2c5c-43fd-a7e4-a4ce74281bf0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "@show myfold(mymult, 2., 3.)\n",
+ "@show myfold(+, 1)\n",
+ "@show myfold(==, false, false, true)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "59fa4c2a-a1fa-4a1b-9529-68f821589206",
+ "metadata": {},
+ "source": [
+ "We can also check which method is actually employed using the `@which` macro:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0fa105fb-b3ad-405a-85f1-598a12cbc655",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "@which myfold(*, 1, 2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "73fa3be7-67a8-4817-9d94-e04765513dd3",
+ "metadata": {},
+ "source": [
+ "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": "code",
+ "execution_count": null,
+ "id": "d771af33-5174-4a95-b8e3-ac1c29eb71e9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import Base: + # we have to import functions to override/extend them\n",
+ "+(x::String, y::String) = x * \" \" * y"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "32429003-4879-4a37-ad3c-153857a360dd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\"Hello\" + \"World!\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8fdf6362-7ca3-4d32-a542-26df56b83108",
+ "metadata": {},
+ "source": [
+ "(**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": "89ffcdef-cf06-438f-8448-4bf6dfd1af7e",
+ "metadata": {},
+ "source": [
+ "Now standard functions relying on `+` just magically work:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "75b4afeb-a3f4-40d7-8b23-b961b01c41bc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sum([\"a\", \"b\", \"c\", \"d\", \"e\"])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d8edaaf0-3de7-4a63-b0bd-bff53ba060f4",
+ "metadata": {},
+ "source": [
+ "Variables and parameters are local, they exist only inside the functions where they are defined:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d02e6bca-6723-4a05-82ee-1f30ba127bd5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "function multiply_and_print(a, b)\n",
+ " product = a * b\n",
+ " println(product)\n",
+ "end\n",
+ "\n",
+ "multiply_and_print(2, 3)\n",
+ "println(product)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "29968f96-5766-4cb7-8538-3bef9aeb8cc9",
+ "metadata": {},
+ "source": [
+ "It may not be clear why it is worth the trouble to divide a program into functions. There are several reasons:\n",
+ " - Creating a new function gives you an opportunity to name a group of statements, which makes your program easier to read and debug.\n",
+ " - 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.\n",
+ " - Dividing a long program into functions allows you to debug the parts one at a time and then assemble them into a working whole.\n",
+ " - Well-designed functions are often useful for many programs. Once you write and debug one, you can reuse it.\n",
+ " - In Julia, functions can improve performance a lot."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7780ae66-db68-48c1-ba62-a883406f1f1c",
+ "metadata": {},
+ "source": [
+ "More details: [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",
+ "metadata": {},
+ "source": [
+ "### Exercises"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "247215e4-47e1-4eb6-978b-a09f14478bb8",
+ "metadata": {},
+ "source": [
+ " - Write a function `printgrid` that draws a grid like the following:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1704f451-9500-41c5-b74b-4a2b4a7b910f",
+ "metadata": {},
+ "source": [
+ " + - - - - + - - - - +\n",
+ " | | |\n",
+ " | | |\n",
+ " | | |\n",
+ " | | |\n",
+ " + - - - - + - - - - +\n",
+ " | | |\n",
+ " | | |\n",
+ " | | |\n",
+ " | | |\n",
+ " + - - - - + - - - - +"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "58ef3248-f85e-4825-bf10-02cee3e068cb",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e6a58742-9d24-47a5-aa68-73d44ca05127",
+ "metadata": {},
+ "source": [
+ " - Write a function that draws a similar grid with four rows and four columns."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b953857f-e8d7-47aa-bc8d-8e2bd1cd20fd",
+ "metadata": {},
+ "source": [
+ "Tips:\n",
+ " - To print more than one value on a line, you can print a comma-separated sequence of values: println(\"+\", \"-\").\n",
+ " - The function print does not advance to the next line."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1ca1789d-eddb-4f41-9ad9-9259c6f22a14",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2ebc911c-7fe0-4d7f-ab5d-d8084f25a93d",
+ "metadata": {},
+ "source": [
+ "### Recursive functions\n",
+ "\n",
+ "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": "code",
+ "execution_count": null,
+ "id": "e578011e-d0de-4f86-8c2c-a8408454d3ac",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "function countdown(n)\n",
+ " if n ≤ 0\n",
+ " println(\"Blastoff!\")\n",
+ " else\n",
+ " print(n, \" \")\n",
+ " countdown(n-1)\n",
+ " end\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3af51513-c92e-4488-b2fe-243e2fef6b95",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "countdown(10)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c59c0f54-d967-4416-b57c-e855dfc2c350",
+ "metadata": {},
+ "source": [
+ "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": "code",
+ "execution_count": null,
+ "id": "13a4a762-6584-47ab-9fb5-428557770d15",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "function recurse()\n",
+ " recurse()\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0dde579f-6b12-4072-aa62-aeee3a970503",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "recurse()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "22c8c79d-6d41-4758-9550-aaab4f1dc1b1",
+ "metadata": {},
+ "source": [
+ "### Exercises\n",
+ " - Write a recursive function to compute the factorial of a number."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f4102487-011e-474f-ab79-3d7db1d3bbd9",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d9c31712-941c-4611-99e5-b33cdb12e28f",
+ "metadata": {},
+ "source": [
+ " - Then write a function that computes binomial coefficients\n",
+ "$$ \\left(\\begin{array}{c} n \\\\ k \\end{array}\\right) = \\frac{n!}{k! (n-k)!} $$\n",
+ " by calling the function of the previous points."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b54c877e-5494-4657-ba7f-208bdc301225",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4509db3f-8060-46ca-89ac-824c16f5751c",
+ "metadata": {},
+ "source": [
+ "- Use the two functions to compute\n",
+ "$$ 15! \\qquad \\left(\\begin{array}{c} 5 \\\\ 2 \\end{array}\\right) \\qquad \\left(\\begin{array}{c} 5 \\\\ 3 \\end{array}\\right) $$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fb02aad5-d9d4-4f0d-8118-b02b73506b89",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "240cc4bd-3e45-45b8-ad98-170dbb68f78d",
+ "metadata": {},
+ "source": [
+ "### Keywords argument\n",
+ "\n",
+ "Function arguments can be either position based (like what we saw so far) or keyword based, like in the following example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "30ddeb3b-be35-40eb-8491-1269a4e19f62",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "function greet(name; greeting=\"Hello\")\n",
+ " println(\"$(greeting), $(name)!\")\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b39f22b1-4a1b-4afd-b6db-041bd7150b66",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "greet(\"Michele\")\n",
+ "greet(\"Lambert\"; greeting=\"Hallo\")\n",
+ "greet(\"YingXing\"; greeting=\"你好\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "52b90aa8-4b19-4371-8fae-2121a78fbb96",
+ "metadata": {},
+ "source": [
+ "This is quite convenient in the following cases:\n",
+ " - to set a default behavior of the function, while retaining the possibility to finely control it.\n",
+ " - to add at a later point in time new functionality, without breaking retrocompatibility."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c939f951-2aaf-4e39-a60f-df7600af1d8f",
+ "metadata": {},
+ "source": [
+ "## Further Exercises"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "59e2e997-42f7-426c-bfd0-233724704117",
+ "metadata": {},
+ "source": [
+ " - 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": "code",
+ "execution_count": null,
+ "id": "7ca7c936-fb80-4aed-9788-75a55bb207ad",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "49fd546f-009d-46ff-af61-6954000bce5f",
+ "metadata": {},
+ "source": [
+ " - 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": "code",
+ "execution_count": null,
+ "id": "a30a1812-6116-4441-8786-7450c60ef354",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e2c81cc5-7d0d-4a5a-ba69-81686648df90",
+ "metadata": {},
+ "source": [
+ " - 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": "code",
+ "execution_count": null,
+ "id": "af0e28bd-2b3f-41af-aa92-456e29d50679",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Julia 1.9.3",
+ "language": "julia",
+ "name": "julia-1.9"
+ },
+ "language_info": {
+ "file_extension": ".jl",
+ "mimetype": "application/julia",
+ "name": "julia"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}