diff --git a/_quarto.yml b/_quarto.yml index 66bd639..955ffae 100644 --- a/_quarto.yml +++ b/_quarto.yml @@ -72,7 +72,7 @@ format: highlight-style: github # arrow ????? mainfont: "Roboto Condensed" # Ubuntu # "Atkinson Hyperlegible" # Verdana #Quicksand - toc: true # change for Vorlesung + toc: false # change for Vorlesung toc-depth: 3 number-depth: 3 email-obfuscation: javascript diff --git a/nb/10_Strings.ipynb b/nb/10_Strings.ipynb index fe7bdab..b850542 100644 --- a/nb/10_Strings.ipynb +++ b/nb/10_Strings.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "29fd19a8", + "id": "7c21d452", "metadata": {}, "source": [ "# Zeichen, Strings und Unicode\n", @@ -64,7 +64,7 @@ "- davon entfallen über 90 000 Zeichen auf die CJK-Schriften (Chinesisch/Japanisch/Koreanisch) \n", " \n", " \n", - "### technische Details\n", + "### Technische Details\n", "\n", "- Jedem Zeichen wird ein `codepoint` zugeordnet. Das ist einfach eine fortlaufende Nummer.\n", "- Diese Nummer wird hexadezimal notiert\n", @@ -93,7 +93,7 @@ " - Laufrichtung der Schrift \n", " - Kategorie: Großbuchstabe, Kleinbuchstabe, modifizierender Buchstabe, Ziffer, Satzzeichen, Symbol, Seperator,....\n", "\n", - "Im Unicode-Standard sieht das dann so aus: (zur Vereinfachung nur Codepoint und Name)\n", + "Im Unicode-Standard sieht das dann so aus (zur Vereinfachung nur Codepoint und Name):\n", "```\n", "...\n", "U+0041 LATIN CAPITAL LETTER A\n", @@ -117,7 +117,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8eaf4a41", + "id": "48697b80", "metadata": {}, "outputs": [], "source": [ @@ -126,7 +126,7 @@ }, { "cell_type": "markdown", - "id": "1c1f742a", + "id": "568c932d", "metadata": {}, "source": [ "### Eine Auswahl an Schriften \n", @@ -148,7 +148,7 @@ { "cell_type": "code", "execution_count": null, - "id": "823bfab7", + "id": "44eecb07", "metadata": {}, "outputs": [], "source": [ @@ -165,7 +165,7 @@ }, { "cell_type": "markdown", - "id": "50893728", + "id": "9857ec8a", "metadata": {}, "source": [ "__Kyrillisch__\n" @@ -174,7 +174,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8caca4e0", + "id": "d1827fb6", "metadata": {}, "outputs": [], "source": [ @@ -183,7 +183,7 @@ }, { "cell_type": "markdown", - "id": "4400710f", + "id": "1975b4c8", "metadata": {}, "source": [ "__Tamilisch__\n", @@ -194,7 +194,7 @@ { "cell_type": "code", "execution_count": null, - "id": "85bb89e4", + "id": "0ac169a1", "metadata": {}, "outputs": [], "source": [ @@ -205,7 +205,7 @@ }, { "cell_type": "markdown", - "id": "3904378b", + "id": "cf47c3ec", "metadata": {}, "source": [ "\\begingroup\\setmonofont{Noto Sans Tamil}\n" @@ -214,7 +214,7 @@ { "cell_type": "code", "execution_count": null, - "id": "13461be4", + "id": "4c539418", "metadata": {}, "outputs": [], "source": [ @@ -225,7 +225,7 @@ }, { "cell_type": "markdown", - "id": "e8ed18a7", + "id": "57b1dd19", "metadata": {}, "source": [ "\\endgroup\n", @@ -238,7 +238,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8f6b4cee", + "id": "6d474a65", "metadata": {}, "outputs": [], "source": [ @@ -247,7 +247,7 @@ }, { "cell_type": "markdown", - "id": "f9ca81ef", + "id": "9c31ea8a", "metadata": {}, "source": [ "__Mathematische Operatoren__\n" @@ -256,7 +256,7 @@ { "cell_type": "code", "execution_count": null, - "id": "60c00c29", + "id": "58aaf4c5", "metadata": {}, "outputs": [], "source": [ @@ -265,7 +265,7 @@ }, { "cell_type": "markdown", - "id": "1e023c33", + "id": "9b6c63b0", "metadata": {}, "source": [ "__Runen__\n" @@ -274,7 +274,7 @@ { "cell_type": "code", "execution_count": null, - "id": "361517d3", + "id": "88859f95", "metadata": {}, "outputs": [], "source": [ @@ -283,7 +283,7 @@ }, { "cell_type": "markdown", - "id": "067f18ed", + "id": "08203fd6", "metadata": {}, "source": [ ":::{.cellmerge}\n", @@ -298,7 +298,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9ac8d6c5", + "id": "640c2422", "metadata": {}, "outputs": [], "source": [ @@ -309,7 +309,7 @@ }, { "cell_type": "markdown", - "id": "ab85dc8a", + "id": "ee56718c", "metadata": {}, "source": [ "\\begingroup\\setmonofont{Phaistos.otf}\n" @@ -318,7 +318,7 @@ { "cell_type": "code", "execution_count": null, - "id": "599a342d", + "id": "0a728045", "metadata": {}, "outputs": [], "source": [ @@ -329,7 +329,7 @@ }, { "cell_type": "markdown", - "id": "c5ccd262", + "id": "cfcb78f6", "metadata": {}, "source": [ "\\endgroup\n", @@ -376,7 +376,7 @@ "\n", "Der Datentyp `Char` kodiert ein einzelnes Unicode-Zeichen. \n", "\n", - "- Julia verwendet dafür einfachen Anführungszeichen: `'a'`. \n", + "- Julia verwendet dafür einfache Anführungszeichen: `'a'`. \n", "- Ein `Char` belegt 4 Bytes Speicher und \n", "- repräsentiert einen Unicode-Codepoint.\n", "- `Char`s können von/zu `UInt`s umgewandelt werden und \n", @@ -392,7 +392,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a8ea6e75", + "id": "707c245e", "metadata": {}, "outputs": [], "source": [ @@ -401,7 +401,7 @@ }, { "cell_type": "markdown", - "id": "ab924ce4", + "id": "ce463383", "metadata": {}, "source": [ "- `Char`s können von/zu `UInt`s umgewandelt werden.\n" @@ -410,7 +410,7 @@ { "cell_type": "code", "execution_count": null, - "id": "dac49645", + "id": "6488fdf6", "metadata": {}, "outputs": [], "source": [ @@ -420,7 +420,7 @@ { "cell_type": "code", "execution_count": null, - "id": "98bd57af", + "id": "2637de2b", "metadata": {}, "outputs": [], "source": [ @@ -429,7 +429,7 @@ }, { "cell_type": "markdown", - "id": "74470851", + "id": "985adab7", "metadata": {}, "source": [ "__Bei einem Nicht-ASCII-String unterscheiden sich Anzahl der Bytes und Anzahl der Zeichen:__\n" @@ -438,7 +438,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0edfc402", + "id": "53c741c8", "metadata": {}, "outputs": [], "source": [ @@ -448,7 +448,7 @@ }, { "cell_type": "markdown", - "id": "2c2ce448", + "id": "bf536c2d", "metadata": {}, "source": [ "(Das Leerzeichen zählt natürlich auch.)\n" @@ -457,7 +457,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c171aa8d", + "id": "37e36e85", "metadata": {}, "outputs": [], "source": [ @@ -467,7 +467,7 @@ }, { "cell_type": "markdown", - "id": "e0467145", + "id": "b9caf74d", "metadata": {}, "source": [ "__Iteration über einen String iteriert über die Zeichen:__\n" @@ -476,7 +476,7 @@ { "cell_type": "code", "execution_count": null, - "id": "802e421f", + "id": "0e8e04e3", "metadata": {}, "outputs": [], "source": [ @@ -487,7 +487,7 @@ }, { "cell_type": "markdown", - "id": "b434c61b", + "id": "ce0cfd1b", "metadata": {}, "source": [ "### Verkettung von Strings\n", @@ -500,7 +500,7 @@ { "cell_type": "code", "execution_count": null, - "id": "dba97090", + "id": "6f35d90f", "metadata": {}, "outputs": [], "source": [ @@ -509,7 +509,7 @@ }, { "cell_type": "markdown", - "id": "c2f3a520", + "id": "898a6ea1", "metadata": {}, "source": [ "Damit sind auch Potenzen mit natürlichem Exponenten definiert.\n" @@ -518,7 +518,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e8804720", + "id": "cb9d7217", "metadata": {}, "outputs": [], "source": [ @@ -527,7 +527,7 @@ }, { "cell_type": "markdown", - "id": "ffd0fd4c", + "id": "cc89a9ca", "metadata": {}, "source": [ "### Stringinterpolation\n", @@ -539,7 +539,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b8248a55", + "id": "16b8af0a", "metadata": {}, "outputs": [], "source": [ @@ -551,7 +551,7 @@ }, { "cell_type": "markdown", - "id": "b2039521", + "id": "1ddcc1ad", "metadata": {}, "source": [ "### Backslash escape sequences \n", @@ -563,7 +563,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f896516b", + "id": "64a50bab", "metadata": {}, "outputs": [], "source": [ @@ -573,7 +573,7 @@ }, { "cell_type": "markdown", - "id": "6258cdb2", + "id": "f8a758f6", "metadata": {}, "source": [ "### Triple-Quotes\n", @@ -585,7 +585,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e7913161", + "id": "a042c5ed", "metadata": {}, "outputs": [], "source": [ @@ -600,7 +600,7 @@ }, { "cell_type": "markdown", - "id": "15de1886", + "id": "7ff4c2dd", "metadata": {}, "source": [ "### Raw strings\n", @@ -611,7 +611,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a040859a", + "id": "929529cf", "metadata": {}, "outputs": [], "source": [ @@ -621,7 +621,7 @@ }, { "cell_type": "markdown", - "id": "6e24746e", + "id": "0040e4d6", "metadata": {}, "source": [ "## Weitere Funktionen für Zeichen und Strings (Auswahl)\n", @@ -632,7 +632,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f79e914f", + "id": "195a2a3e", "metadata": {}, "outputs": [], "source": [ @@ -642,7 +642,7 @@ }, { "cell_type": "markdown", - "id": "d39076f7", + "id": "2e50dae6", "metadata": {}, "source": [ "### Anwendung auf Strings\n", @@ -653,7 +653,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b6055040", + "id": "c778a4ad", "metadata": {}, "outputs": [], "source": [ @@ -663,7 +663,7 @@ { "cell_type": "code", "execution_count": null, - "id": "29fd91ef", + "id": "6a162d83", "metadata": {}, "outputs": [], "source": [ @@ -673,7 +673,7 @@ { "cell_type": "code", "execution_count": null, - "id": "73a589b9", + "id": "c2d57533", "metadata": {}, "outputs": [], "source": [ @@ -682,7 +682,7 @@ }, { "cell_type": "markdown", - "id": "5bdff431", + "id": "f6562800", "metadata": {}, "source": [ "### Weitere String-Funktionen\n" @@ -691,7 +691,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a24b1569", + "id": "495799ef", "metadata": {}, "outputs": [], "source": [ @@ -702,7 +702,7 @@ { "cell_type": "code", "execution_count": null, - "id": "89003024", + "id": "13e4d303", "metadata": {}, "outputs": [], "source": [ @@ -712,7 +712,7 @@ { "cell_type": "code", "execution_count": null, - "id": "01910748", + "id": "36451c74", "metadata": {}, "outputs": [], "source": [ @@ -724,7 +724,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d618c466", + "id": "a665d380", "metadata": {}, "outputs": [], "source": [ @@ -734,7 +734,7 @@ { "cell_type": "code", "execution_count": null, - "id": "da05d6b9", + "id": "64967f02", "metadata": {}, "outputs": [], "source": [ @@ -743,7 +743,7 @@ }, { "cell_type": "markdown", - "id": "4e198e74", + "id": "663832cf", "metadata": {}, "source": [ "## Indizierung von Strings\n", @@ -760,7 +760,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4686b303", + "id": "23d51f20", "metadata": {}, "outputs": [], "source": [ @@ -769,7 +769,7 @@ }, { "cell_type": "markdown", - "id": "6c1a2fe1", + "id": "639c88fa", "metadata": {}, "source": [ "Das erste Zeichen\n" @@ -778,7 +778,7 @@ { "cell_type": "code", "execution_count": null, - "id": "eb0e9898", + "id": "68ba5cb6", "metadata": {}, "outputs": [], "source": [ @@ -787,7 +787,7 @@ }, { "cell_type": "markdown", - "id": "50049fee", + "id": "44617a04", "metadata": {}, "source": [ "Dieses Zeichen ist in UTF8-Kodierung 4 Bytes lang. Damit sind 2,3 und 4 ungültige Indizes. \n" @@ -796,7 +796,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a6a3005a", + "id": "c4575cca", "metadata": {}, "outputs": [], "source": [ @@ -805,7 +805,7 @@ }, { "cell_type": "markdown", - "id": "5c428767", + "id": "e558202c", "metadata": {}, "source": [ "Erst das 5. Byte ist ein neues Zeichen:\n" @@ -814,7 +814,7 @@ { "cell_type": "code", "execution_count": null, - "id": "29febb49", + "id": "3813bbdf", "metadata": {}, "outputs": [], "source": [ @@ -823,7 +823,7 @@ }, { "cell_type": "markdown", - "id": "0daa1973", + "id": "48f4cca9", "metadata": {}, "source": [ "Auch bei der Adressierung von Substrings müssen Anfang und Ende jeweils gültige Indizes sein, d.h., der Endindex muss ebenfalls das erste Byte eines Zeichens indizieren und dieses Zeichen ist das letzte des Teilstrings. \n" @@ -832,7 +832,7 @@ { "cell_type": "code", "execution_count": null, - "id": "dbbc0c47", + "id": "546d4ed2", "metadata": {}, "outputs": [], "source": [ @@ -841,7 +841,7 @@ }, { "cell_type": "markdown", - "id": "b7fd7042", + "id": "1007a717", "metadata": {}, "source": [ "Die Funktion `eachindex()` liefert einen Iterator über die gültigen Indizes:\n" @@ -850,7 +850,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6e2b8427", + "id": "d01e440e", "metadata": {}, "outputs": [], "source": [ @@ -862,7 +862,7 @@ }, { "cell_type": "markdown", - "id": "f651e9bf", + "id": "2f35e6bf", "metadata": {}, "source": [ "Wie üblich macht collect() aus einem Iterator einen Vektor.\n" @@ -871,7 +871,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a591c148", + "id": "b1644ea5", "metadata": {}, "outputs": [], "source": [ @@ -880,7 +880,7 @@ }, { "cell_type": "markdown", - "id": "a7f9cb60", + "id": "dc77d9e5", "metadata": {}, "source": [ "Die Funktion `nextind()` liefert den nächsten gültigen Index.\n" @@ -889,7 +889,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d568dd47", + "id": "5c9f35e7", "metadata": {}, "outputs": [], "source": [ @@ -898,7 +898,7 @@ }, { "cell_type": "markdown", - "id": "91af5e34", + "id": "6d1e346b", "metadata": {}, "source": [ "Warum verwendet Julia einen Byte-Index und keinen Zeichenindex? Der Hauptgrund dürfte die Effizienz der Indizierung sein.\n", @@ -913,7 +913,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b62bbd82", + "id": "e1ec4807", "metadata": {}, "outputs": [], "source": [ @@ -923,7 +923,7 @@ { "cell_type": "code", "execution_count": null, - "id": "93def2b5", + "id": "2f8520fd", "metadata": {}, "outputs": [], "source": [ @@ -933,7 +933,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e96565a7", + "id": "0f07cff3", "metadata": {}, "outputs": [], "source": [ @@ -943,7 +943,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e251544c", + "id": "19e5bcc4", "metadata": {}, "outputs": [], "source": [ @@ -952,7 +952,7 @@ }, { "cell_type": "markdown", - "id": "be81789e", + "id": "f614e688", "metadata": {}, "source": [ "So kann man ab dem nächsten nach `n=5` gültigen Index weitersuchen:\n" @@ -961,7 +961,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ad89b2c9", + "id": "3f3b90b4", "metadata": {}, "outputs": [], "source": [ @@ -971,15 +971,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.8.5", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.8" - }, - "language_info": { - "file_extension": ".jl", - "mimetype": "application/julia", - "name": "julia", - "version": "1.8.5" + "name": "julia-1.10" } }, "nbformat": 4, diff --git a/nb/5_TricksHelp.ipynb b/nb/5_TricksHelp.ipynb index 2a2e751..bbbbd7b 100644 --- a/nb/5_TricksHelp.ipynb +++ b/nb/5_TricksHelp.ipynb @@ -2,35 +2,29 @@ "cells": [ { "cell_type": "markdown", - "id": "2ffe347c", + "id": "32301000", "metadata": {}, "source": [ - "# Julia Dokumentation\n", + "# Arbeit mit Julia: REPL, Pakete, Introspection\n", "\n", - "[https://docs.julialang.org/](https://docs.julialang.org/) die offizielle Dokumentation\n", "\n", - "Einige Seiten mit Übersichten:\n", + "\n", + "## Dokumentation\n", + "\n", + "Die offizielle Julia-Dokumentation [https://docs.julialang.org/](https://docs.julialang.org/) enthält zahlreiche Übersichten, darunter:\n", "\n", " - [https://docs.julialang.org/en/v1/base/punctuation/](https://docs.julialang.org/en/v1/base/punctuation/) Verzeichnis der Symbole\n", " - [https://docs.julialang.org/en/v1/manual/unicode-input/](https://docs.julialang.org/en/v1/manual/unicode-input/) Verzeichnis spezieller Unicode-Symbole und deren Eingabe in Julia via Tab-Vervollständigung\n", " - [https://docs.julialang.org/en/v1/manual/mathematical-operations/#Rounding-functions](https://docs.julialang.org/en/v1/manual/mathematical-operations/#Rounding-functions) Liste mathematischer Funktionen \n", "\n", - "---------\n", "\n", "\n", "\n", - "# Hilfe und praktische Tipps\n", - "\n", - "----\n", - "\n", - "\n", "## Julia REPL (Read - Eval - Print - Loop)\n", "\n", - "Start von Julia in einem Terminal:\n", - "```\n", - "julia>\n", - "```\n", + "Nach dem Start von Julia in einem Terminal kann man neben Julia-Code auch verschiedene Kommandos eingeben \n", "\n", + ":::{.narrow}\n", "| Kommando | Wirkung |\n", "| :----------------------------| :------------------------ |\n", "| `exit()` oder `Ctrl-d` | exit Julia |\n", @@ -40,28 +34,23 @@ "| `include(\"filename.jl\")` | Datei mit Julia-Code einlesen und ausführen |\n", "\n", "\n", - "-----\n", "\n", "Der REPL hat verschiedene Modi: \n", "\n", "| Modus | Prompt | Modus starten | Modus verlassen |\n", "| :- | :- | :- | :- |\n", - "|||||\n", - "| default| `julia>` | | |\n", - "|||||\n", + "| default| `julia>` | | `Ctrl-d`|\n", "| Package manager | `pkg>` | `]` | `backspace` |\n", - "|||||\n", "| Help | `help?>` | `?`| `backspace `|\n", - "|||||\n", "|Shell | `shell>` | `;` | `backspace`|\n", - "|||||\n", "\n", - "--------\n", + ":::\n", "\n", "\n", - "## Jupyter notebooks (IJulia)\n", + "## Jupyter-Notebooks (IJulia)\n", "\n", - "Die Modi sind als Einzeiler in einer eigenen Input-Zelle nutzbar: \n", + "\n", + "In einem Jupyter-Notebook sind die Modi sind als Einzeiler in einer eigenen Input-Zelle nutzbar: \n", "\n", "(i) ein Kommando des Paket-Managers:\n" ] @@ -69,16 +58,17 @@ { "cell_type": "code", "execution_count": null, - "id": "d6c200e5", + "id": "efacde4f", "metadata": {}, "outputs": [], "source": [ + "#| eval: false\n", "] status " ] }, { "cell_type": "markdown", - "id": "9caf3630", + "id": "85fec425", "metadata": {}, "source": [ "(ii) eine Help-Abfrage:\n" @@ -87,16 +77,17 @@ { "cell_type": "code", "execution_count": null, - "id": "c923aa16", + "id": "80535b76", "metadata": {}, "outputs": [], "source": [ + "#| eval: false\n", "?sin" ] }, { "cell_type": "markdown", - "id": "bfc75d15", + "id": "581aae68", "metadata": {}, "source": [ "(iii) Ein Shell-Kommando:\n" @@ -105,44 +96,53 @@ { "cell_type": "code", "execution_count": null, - "id": "3617aff8", + "id": "c2438155", "metadata": {}, "outputs": [], "source": [ - ";ls .." + "#| eval: false\n", + ";ls " ] }, { "cell_type": "markdown", - "id": "bdce3ab2", + "id": "bd2c64b7", "metadata": {}, "source": [ - "## Der Paket-Manager\n", + "## Der Paketmanager\n", "\n", - "- Über 7000 Pakete, siehe [https://julialang.org/packages/](https://julialang.org/packages/)\n", - "- Bevor sie mit `using Module` verwendet werden können, müssen sie heruntergeladen und installiert werden.\n", - "- Dazu dient der `package manager`\n", - "- 2 Betriebsarten: \n", - " - als normale Julia-Anweisungen, die auch in einer `.jl`-Programmdatei stehen können:\n", + "Wichtiger Teil des _Julia Ecosystems_ sind die zahlreichen Pakete, die Julia erweitern.\n", + "\n", + "- Einige Pakete sind Teil jeder Julia-Installation und müssen nur mit einer `using Paketname`-Anweisung aktiviert werden. \n", + " - Sie bilden die sogenannte _Standard Library_ und dazu gehören \n", + " - `LinearAlgebra`, `Statistics`, `SparseArrays`, `Printf`, `Pkg` und andere.\n", + "- Über 9000 Pakete sind offiziell registriert, siehe [https://julialang.org/packages/](https://julialang.org/packages/). \n", + " - Diese können mit wenigen Tastendrücken heruntergeladen und installiert werden.\n", + " - Dazu dient der _package manager_ `Pkg`.\n", + " - Man kann ihn auf zwei Arten verwenden: \n", + " - als normale Julia-Anweisungen, die auch in einer `.jl`-Programmdatei stehen können:\n", " ```\n", " using Pkg\n", - " Pkg.add(\"TollesPaket\")\n", + " Pkg.add(\"PaketXY\")\n", " ```\n", - " - im speziellen pkg-Modus des Julia-REPLs:\n", + " - im speziellen pkg-Modus des Julia-REPLs:\n", " ```\n", - " ] add TollesPaket\n", + " ] add PaketXY\n", " ```\n", - "----- \n", + " - Anschließend kann das Paket mit `using PaketXY` verwendet werden.\n", + "- Man kann auch Pakete aus anderen Quellen und selbstgeschriebene Pakete installieren.\n", "\n", - "### Einige Funktionen\n", + " \n", + "### Einige Funktionen des Paketmanagers\n", "\n", "| Funktion | `pkg` - Mode | Erklärung |\n", - "|:------------------------|:----------------------|:----------------------------------------------------------|\n", + "|:------------------------|:--------------------------| :-------------------------------------------------------|\n", "| `Pkg.add(\"MyPack\")` | `pkg> add MyPack` | add `MyPack.jl` to current environment |\n", "| `Pkg.rm(\"MyPack\")` | `pkg> remove MyPack` | remove `MyPack.jl` from current environment |\n", "| `Pkg.update()` | `pkg> update` | update packages in current environment |\n", "| `Pkg.activate(\"mydir\")` | `pkg> activate mydir` | activate directory as current environment |\n", "| `Pkg.status()` | `pkg> status` | list packages |\n", + "| `Pkg.instantiate()` | `pg> instantiate` | install all packages according to `Project.toml` |\n", "\n", "\n", "### Installierte Pakete und Environments \n", @@ -152,308 +152,95 @@ " 2. eine Liste aller dabei auch als implizite Abhängigkeiten installierten Pakete in der Datei `Manifest.toml`. \n", "- Das Verzeichnis, in dem diese Dateien stehen, ist das `environment` und wird mit `Pkg.status()` bzw. `]status` angezeigt. \n", "- Im Normalfall sieht das so aus: \n", + "\n", "```\n", - "(@v1.7) pkg> status\n", - " Status `~/.julia/environments/v1.7/Project.toml`\n", + "(@v1.8) pkg> status\n", + " Status `~/.julia/environments/v1.8/Project.toml`\n", " [1dea7af3] OrdinaryDiffEq v6.7.1\n", " [91a5bcdd] Plots v1.27.1\n", " [438e738f] PyCall v1.93.1\n", "```\n", + "\n", "- Man kann für verschiedene Projekte eigene `environments` benutzen. Dazu kann man entweder Julia mit \n", - "```\n", + "```shell\n", "julia --project=path/to/myproject\n", "```\n", "starten oder in Julia das environment mit `Pkg.activate(\"path/to/myproject\")` aktivieren. Dann werden `Project.toml, Manifest.toml` dort angelegt und verwaltet. (Die Installation der Paketdateien erfolgt weiterhin irgendwo unter `$HOME/.julia`) \n", "\n", "\n", "### Zum Installieren von Paketen auf unserem Jupyter-Server `misun103`:\n", - "- Es gibt ein zentrales Repository, in dem alle von mir erwähnten Pakete bereits installiert sind. \n", + "\n", + "- Es gibt ein zentrales Repository, in dem alle in diesem Kurs erwähnten Pakete bereits installiert sind. \n", "- Dort haben Sie keine Schreibrechte.\n", - "- Sie können aber zusätzliche Pakete in Ihrem `Home` installieren. Dazu ist als erster Befehl nötig, das aktuelle Verzeichnis zu aktivieren: \n" + "- Sie können aber zusätzliche Pakete in Ihrem `HOME` installieren. Dazu ist als erster Befehl nötig, das aktuelle Verzeichnis zu aktivieren: \n" ] }, { "cell_type": "code", "execution_count": null, - "id": "103bd8a1", + "id": "87138f78", "metadata": {}, "outputs": [], "source": [ + "#| eval: false\n", "] activate ." ] }, { "cell_type": "markdown", - "id": "077e93f2", + "id": "da9c6bb6", "metadata": {}, "source": [ "(Man beachte den Punkt!)\n", "\n", - "----\n", "\n", - "Danach können Sie mit `add` im Pkg-Modus auch Pakete installieren:\n", - "\n", - "```\n", - "] add TollesPaket\n", - "```\n", - "\n", - "\n", - "Achtung! Das kann dauern! Viele Pakete haben komplexe Abhängigkeiten und lösen die Installation von weiteren Paketen aus. Viele Pakete werden beim Installieren vorkompiliert. Im REPL sieht man den Installationsfortschritt, im Jupyter-Notebook nicht.\n", - "\n", - "\n", - "## Eingebaute Hilfe und Informationen\n", - "Mit `?` und der `Tab`-Taste kommt man oft weiter. \n", - "\n", - "\n", - "\n", - "### weitere Hilfe: `@which`, `fieldnames()`, `methods()`, `names()`, `pwd()`\n" + "Danach können Sie mit `add` im Pkg-Modus auch Pakete installieren:\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "4f099673", + "id": "7a9e6ab0", "metadata": {}, "outputs": [], "source": [ - "# Die Zuordnung zu einem Modul zeigt @which an:\n", - "\n", - "@which(sqrt)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "44276c0d", - "metadata": {}, - "outputs": [], - "source": [ - "# Die Komponenten einer struct oder eines anderen zusammengesetzten Typs:\n", - "\n", - "fieldnames(Rational)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a200a34f", - "metadata": {}, - "outputs": [], - "source": [ - "fieldnames(Complex)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d99bfda9", - "metadata": {}, - "outputs": [], - "source": [ - "# alle Methoden einer Funktion\n", - "\n", - "methods(sqrt)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b3e6f127", - "metadata": {}, - "outputs": [], - "source": [ - "# alle Methoden einer Funktion bei bestimmten Argumenttypen. Die Argumenttypen müssen als Tupel angegeben werden\n", - "\n", - "methods(sqrt, (Number,)) # Komma nötig für 1-elementiges Tupel " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e74572ad", - "metadata": {}, - "outputs": [], - "source": [ - "# für einen Typ gibt methods() alle Konstruktoren aus\n", - "\n", - "methods(Int64)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e4de6078", - "metadata": {}, - "outputs": [], - "source": [ - "# names(Module) gibt alle von einem Modul exportierte Namen aus. \n", - "# genau wie auch\n", - "#\n", - "# ?Module \n", - "#\n", - "# funktioniert es erst, wenn das Modul mit 'using Module' geladen ist.\n", - "# Oft ist es besser, wenn die using-Anweisung in einer eigenen Zelle steht.\n", - "\n", - "using Plots" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f1df8377", - "metadata": {}, - "outputs": [], - "source": [ - "names(Plots)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3654fab2", - "metadata": {}, - "outputs": [], - "source": [ - "# Julia kürzt den interaktiven Output. \n", - "# ein explizites print() zeigt alles:\n", - "\n", - "print(names(Plots))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "dc9ca3b6", - "metadata": {}, - "outputs": [], - "source": [ - "# eine andere Möglichkeit der Ausgabe mit Überlänge in Jupyter\n", - "\n", - "show(stdout, MIME(\"text/plain\"), names(Plots))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9fa0f216", - "metadata": {}, - "outputs": [], - "source": [ - "# pwd() \"print working directory\" zeigt, in welchem Verzeichnis Julia gerade operiert. \n", - "#\n", - "# Wichtig für die Ein/Ausgabe mit Dateien, z.B. include()\n", - "\n", - "pwd()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "99c19918", - "metadata": {}, - "outputs": [], - "source": [ - "include(\"Jupyter.jl\") # Datei mit Julia-Code einlesen und abarbeiten" + "#| eval: false\n", + "] add PaketXY" ] }, { "cell_type": "markdown", - "id": "1464d951", + "id": "d5fc8aef", "metadata": {}, "source": [ - "## Informationen zu Typen\n", + "Achtung! Das kann dauern! Viele Pakete haben komplexe Abhängigkeiten und lösen die Installation von weiteren Paketen aus. Viele Pakete werden beim Installieren vorkompiliert. Im REPL sieht man den Installationsfortschritt, im Jupyter-Notebook leider nicht.\n", "\n", - "### `subtypes()`, `supertypes()`, `typemax()`, `typemin()`, `fieldnames()`, `Base.return_types()`, `dump()`\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1358c363", - "metadata": {}, - "outputs": [], - "source": [ - "subtypes(Real) # die letzten zwei sind durch das 'using Plots' dazugekommen" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e35fb7da", - "metadata": {}, - "outputs": [], - "source": [ - "supertypes(Real)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "53be4687", - "metadata": {}, - "outputs": [], - "source": [ - "typemax(Int64), typemin(Int64), fieldnames(Complex)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3a9ed940", - "metadata": {}, - "outputs": [], - "source": [ - "Base.return_types(sqrt, (Float64,))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "207af4bd", - "metadata": {}, - "outputs": [], - "source": [ - "Base.return_types(sqrt, (Complex{Int64},))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "66b42304", - "metadata": {}, - "outputs": [], - "source": [ - "# dump() zeigt alle Teile eines zusammengesetzten Objekts\n", "\n", - "x = 3//4 + 75im\n", - "dump(x)" - ] - }, - { - "cell_type": "markdown", - "id": "9c6edfea", - "metadata": {}, - "source": [ - "## Der Julia JIT _(just in time)_ Compiler\n", + "\n", + "\n", + "\n", + "## Der Julia JIT _(just in time)_ Compiler: Introspection\n", "\n", "Julia baut auf die Werkzeuge des _LLVM Compiler Infrastructure Projects_ auf.\n", "\n", - "\n", + ":::{.narrow}\n", "Stages of Compilation \n", "\n", "| stage & result | introspection command |\n", "| :--- | :--- |\n", - "|Parse ==> Abstract Syntax Tree (AST) | `Meta.parse()` |\n", - "| Lowering: transform AST ==> Static Single Assignment (SSA) form | `@code_lowered`|\n", + "|Parse $\\Longrightarrow$ Abstract Syntax Tree (AST) | `Meta.parse()` |\n", + "| Lowering: transform AST $\\Longrightarrow$ Static Single Assignment (SSA) form | `@code_lowered`|\n", "| Type Inference | `@code_warntype`, `@code_typed` |\n", "| Generate LLVM intermediate representation | `@code_llvm`|\n", - "| Generate native machine code | `@code_native` |\n" + "| Generate native machine code | `@code_native` |\n", + "\n", + ":::\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "4d433ab8", + "id": "bc5fdcec", "metadata": {}, "outputs": [], "source": [ @@ -466,7 +253,7 @@ { "cell_type": "code", "execution_count": null, - "id": "de444d8a", + "id": "bb56b5a6", "metadata": {}, "outputs": [], "source": [ @@ -476,27 +263,19 @@ { "cell_type": "code", "execution_count": null, - "id": "1ddf17aa", - "metadata": {}, - "outputs": [], - "source": [ - "using TreeView" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "70d267d7", + "id": "9a8825dd", "metadata": {}, "outputs": [], "source": [ + "using TreeView\n", + "\n", "walk_tree(p)" ] }, { "cell_type": "code", "execution_count": null, - "id": "b19b64ec", + "id": "aa2d2ada", "metadata": {}, "outputs": [], "source": [ @@ -506,7 +285,7 @@ { "cell_type": "code", "execution_count": null, - "id": "57eb03f9", + "id": "e6303b02", "metadata": {}, "outputs": [], "source": [ @@ -516,7 +295,7 @@ { "cell_type": "code", "execution_count": null, - "id": "cf273a25", + "id": "05f5a0cd", "metadata": {}, "outputs": [], "source": [ @@ -526,7 +305,7 @@ { "cell_type": "code", "execution_count": null, - "id": "28779f6b", + "id": "523e86a5", "metadata": {}, "outputs": [], "source": [ @@ -536,7 +315,7 @@ { "cell_type": "code", "execution_count": null, - "id": "02711d1f", + "id": "953d5e83", "metadata": {}, "outputs": [], "source": [ @@ -546,15 +325,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.8.5", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.8" - }, - "language_info": { - "file_extension": ".jl", - "mimetype": "application/julia", - "name": "julia", - "version": "1.8.5" + "name": "julia-1.10" } }, "nbformat": 4, diff --git a/nb/6_ArraysEtcP1.ipynb b/nb/6_ArraysEtcP1.ipynb index 408b0c7..6d27411 100644 --- a/nb/6_ArraysEtcP1.ipynb +++ b/nb/6_ArraysEtcP1.ipynb @@ -2,14 +2,14 @@ "cells": [ { "cell_type": "markdown", - "id": "fcc03529", + "id": "81cc02aa", "metadata": {}, "source": [ "# Container\n", "\n", "\n", "Julia bietet eine große Auswahl von Containertypen mit weitgehend ähnlichem Interface an. \n", - "Wir stellen hier `Tuple`, `Range`, `Array`, `Vector` und `Matrix` vor. \n", + "Wir stellen hier `Tuple`, `Range` und `Dict` vor, im nächsten Kapitel dann `Array`, `Vector` und `Matrix`. \n", "\n", "Diese Container sind: \n", "\n", @@ -21,9 +21,9 @@ "```julia\n", "x = container[i]\n", "``` \n", - "und einige sind \n", + "und einige sind auch \n", "\n", - "- **mutierbar** (nur `Array`, `Vector` und `Matrix`): Man kann Elemente hinzufügen, entfernen und ändern.\n", + "- **mutierbar**: Man kann Elemente hinzufügen, entfernen und ändern.\n", "\n", "Weiterhin gibt es eine Reihe gemeinsamer Funktionen, z.B.\n", "\n", @@ -41,7 +41,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3b33212e", + "id": "ec893f0b", "metadata": {}, "outputs": [], "source": [ @@ -54,7 +54,7 @@ }, { "cell_type": "markdown", - "id": "e65e4da8", + "id": "21549769", "metadata": {}, "source": [ "Ein Tupel ist ein **inhomogener** Typ. Jedes Element hat seinen eigenen Typ und das zeigt sich auch im Typ des Tupels:\n" @@ -63,7 +63,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3d21cc5b", + "id": "5add8abb", "metadata": {}, "outputs": [], "source": [ @@ -72,7 +72,7 @@ }, { "cell_type": "markdown", - "id": "74fcc47e", + "id": "e8bc972e", "metadata": {}, "source": [ "Man verwendet Tupel gerne als Rückgabewerte von Funktionen, um mehr als ein Objekt zurückzulieferen.\n" @@ -81,7 +81,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6ffc0cdc", + "id": "85b3f1fd", "metadata": {}, "outputs": [], "source": [ @@ -94,7 +94,7 @@ }, { "cell_type": "markdown", - "id": "e7a04cdd", + "id": "d144679d", "metadata": {}, "source": [ "Wie man hier sieht, kann man in bestimmten Konstrukten die Klammern auch weglassen.\n", @@ -104,7 +104,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2a260b6e", + "id": "2ef18811", "metadata": {}, "outputs": [], "source": [ @@ -114,7 +114,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3447dffb", + "id": "759e8783", "metadata": {}, "outputs": [], "source": [ @@ -123,7 +123,7 @@ }, { "cell_type": "markdown", - "id": "8694ec4a", + "id": "2bed8606", "metadata": {}, "source": [ "Manche Funktionen bestehen auf Tupeln als Argument oder geben immer Tupeln zurück. Dann braucht man manchmal ein Tupel aus einem Element. \n", @@ -134,7 +134,7 @@ { "cell_type": "code", "execution_count": null, - "id": "24856f9b", + "id": "e985c23d", "metadata": {}, "outputs": [], "source": [ @@ -143,7 +143,7 @@ }, { "cell_type": "markdown", - "id": "11ac465d", + "id": "174aed3a", "metadata": {}, "source": [ "Das Komma - und nicht die Klammern -- macht das Tupel. \n" @@ -152,7 +152,7 @@ { "cell_type": "code", "execution_count": null, - "id": "87474e9d", + "id": "8359e689", "metadata": {}, "outputs": [], "source": [ @@ -161,7 +161,7 @@ }, { "cell_type": "markdown", - "id": "da35087d", + "id": "a5fb2b62", "metadata": {}, "source": [ "## Ranges\n", @@ -172,7 +172,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3bfc9415", + "id": "ba823baf", "metadata": {}, "outputs": [], "source": [ @@ -182,7 +182,7 @@ }, { "cell_type": "markdown", - "id": "7d2c6838", + "id": "6dd2ebf4", "metadata": {}, "source": [ "Es gibt verschiedene *range*-Typen. Wie man sieht, sind es über den Zahlentyp parametrisierte Typen und `UnitRange` ist z.B. ein *range* mit der Schrittweite 1. Ihre Konstruktoren heißen in der Regel `range()`. \n", @@ -199,7 +199,7 @@ { "cell_type": "code", "execution_count": null, - "id": "28aecb9e", + "id": "5ee0a9ef", "metadata": {}, "outputs": [], "source": [ @@ -208,7 +208,7 @@ }, { "cell_type": "markdown", - "id": "350affb7", + "id": "f4524b63", "metadata": {}, "source": [ "Wir erinnern an die Semantik der `for`-Schleife: `for i in 1:1000` heißt **nicht**:\n", @@ -228,7 +228,7 @@ { "cell_type": "code", "execution_count": null, - "id": "14ea84bd", + "id": "7049d454", "metadata": {}, "outputs": [], "source": [ @@ -238,7 +238,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c900fd32", + "id": "dbc66a57", "metadata": {}, "outputs": [], "source": [ @@ -247,7 +247,7 @@ }, { "cell_type": "markdown", - "id": "0a763f8b", + "id": "3d98f5f4", "metadata": {}, "source": [ "Zum Umwandeln in einen 'richtigen' Vektor dient die Funktion `collect()`.\n" @@ -256,7 +256,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0e0be9dd", + "id": "fe033c47", "metadata": {}, "outputs": [], "source": [ @@ -265,7 +265,7 @@ }, { "cell_type": "markdown", - "id": "568f2f9f", + "id": "a94e5258", "metadata": {}, "source": [ "Recht nützlich, z.B. beim Vorbereiten von Daten zum Plotten, ist der *range*-Typ `LinRange`.\n" @@ -274,7 +274,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8596862b", + "id": "e4b40085", "metadata": {}, "outputs": [], "source": [ @@ -283,19 +283,471 @@ }, { "cell_type": "markdown", - "id": "f148954b", + "id": "bde8b38f", "metadata": {}, "source": [ "`LinRange(start, stop, n)` erzeugt eine äquidistante Liste von `n` Werten von denen der erste und der letzte die vorgegebenen Grenzen sind. \n", - "Mit `collect()` kann man bei Bedarf auch daraus den entsprechenden Vektor gewinnen.\n" + "Mit `collect()` kann man bei Bedarf auch daraus den entsprechenden Vektor gewinnen.\n", + "\n", + "\n", + "## Dictionaries \n", + "\n", + "- _Dictionaries_ (deutsch: \"assoziative Liste\" oder \"Zuordnungstabelle\" oder ...) sind spezielle Container. \n", + "- Einträge in einem Vektor `v` sind durch einen Index 1,2,3.... addressierbar: `v[i]`\n", + "- Einträge in einem _dictionary_ sind durch allgemeinere _keys_ addressierbar. \n", + "- Ein _dictionary_ ist eine Ansammlung von _key-value_-Paaren.\n", + "- Damit haben _dictionaries_ in Julia den parametrisierten Typ `Dict{S,T}`, wobei `S` der Typ der _keys_ und `T` der Typ der _values_ ist\n", + "\n", + "\n", + "Man kann sie explizit anlegen:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "25c7aefc", + "metadata": {}, + "outputs": [], + "source": [ + "# Einwohner 2020 in Millionen, Quelle: wikipedia\n", + "\n", + "EW = Dict(\"Berlin\" => 3.66, \"Hamburg\" => 1.85, \n", + " \"München\" => 1.49, \"Köln\" => 1.08)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9620f365", + "metadata": {}, + "outputs": [], + "source": [ + "typeof(EW)" + ] + }, + { + "cell_type": "markdown", + "id": "d3b4d2af", + "metadata": {}, + "source": [ + "und mit den _keys_ indizieren:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "62938a1b", + "metadata": {}, + "outputs": [], + "source": [ + "EW[\"Berlin\"]" + ] + }, + { + "cell_type": "markdown", + "id": "73ddf61d", + "metadata": {}, + "source": [ + "Das Abfragen eines nicht existierenden _keys_ ist natürlich ein Fehler.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6e16eb41", + "metadata": {}, + "outputs": [], + "source": [ + "EW[\"Leipzig\"]" + ] + }, + { + "cell_type": "markdown", + "id": "49a6d001", + "metadata": {}, + "source": [ + "Man kann ja auch vorher mal anfragen...\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e43aec5d", + "metadata": {}, + "outputs": [], + "source": [ + "haskey(EW, \"Leipzig\")" + ] + }, + { + "cell_type": "markdown", + "id": "a1cefaa1", + "metadata": {}, + "source": [ + "... oder die Funktion `get(dict, key, default)` benutzen, die bei nicht existierendem Key keinen Fehler wirft sondern das 3. Argument zurückgibt. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e31c792c", + "metadata": {}, + "outputs": [], + "source": [ + "@show get(EW, \"Leipzig\", -1) get(EW, \"Berlin\", -1);" + ] + }, + { + "cell_type": "markdown", + "id": "f625eaaa", + "metadata": {}, + "source": [ + "Man kann sich auch alle `keys` und `values` als spezielle Container geben lassen.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "21460e3a", + "metadata": {}, + "outputs": [], + "source": [ + "keys(EW)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a87d9788", + "metadata": {}, + "outputs": [], + "source": [ + "values(EW)" + ] + }, + { + "cell_type": "markdown", + "id": "97b96369", + "metadata": {}, + "source": [ + "Man kann über die `keys` iterieren...\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "41e9189f", + "metadata": {}, + "outputs": [], + "source": [ + "for i in keys(EW)\n", + " n = EW[i]\n", + " println(\"Die Stadt $i hat $n Millionen Einwohner.\")\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "b2fe653a", + "metadata": {}, + "source": [ + "odere gleich über `key-value`-Paare.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b445207", + "metadata": {}, + "outputs": [], + "source": [ + "for (stadt, ew) ∈ EW\n", + " println(\"$stadt : $ew Mill.\")\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "6fcd4019", + "metadata": {}, + "source": [ + "### Erweitern und Modifizieren\n", + "\n", + "Man kann in ein `Dict` zusätzliche `key-value`-Paare eintragen...\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "94c4f076", + "metadata": {}, + "outputs": [], + "source": [ + "EW[\"Leipzig\"] = 0.52\n", + "EW[\"Dresden\"] = 0.52 \n", + "EW" + ] + }, + { + "cell_type": "markdown", + "id": "ed90d684", + "metadata": {}, + "source": [ + "und einen `value` ändern.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c57e8dd2", + "metadata": {}, + "outputs": [], + "source": [ + "# Oh, das war bei Leipzig die Zahl von 2010, nicht 2020\n", + "\n", + "EW[\"Leipzig\"] = 0.597\n", + "EW" + ] + }, + { + "cell_type": "markdown", + "id": "3d0eadd7", + "metadata": {}, + "source": [ + "Ein Paar kann über seinen `key` auch gelöscht werden.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0dfd9f2d", + "metadata": {}, + "outputs": [], + "source": [ + "delete!(EW, \"Dresden\")" + ] + }, + { + "cell_type": "markdown", + "id": "3db2aa1f", + "metadata": {}, + "source": [ + "Zahlreiche Funktionen können mit `Dicts` wie mit anderen Containern arbeiten.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1204aaab", + "metadata": {}, + "outputs": [], + "source": [ + "maximum(values(EW))" + ] + }, + { + "cell_type": "markdown", + "id": "6a4946b4", + "metadata": {}, + "source": [ + "### Anlegen eines leeren Dictionaries\n", + "\n", + "Ohne Typspezifikation ...\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1f82ac79", + "metadata": {}, + "outputs": [], + "source": [ + "d1 = Dict()" + ] + }, + { + "cell_type": "markdown", + "id": "27c98eaf", + "metadata": {}, + "source": [ + "und mit Typspezifikation:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1b8f201e", + "metadata": {}, + "outputs": [], + "source": [ + "d2 = Dict{String, Int}()" + ] + }, + { + "cell_type": "markdown", + "id": "7fe71a3b", + "metadata": {}, + "source": [ + "### Umwandlung in Vektoren: `collect()`\n", + "\n", + "- `keys(dict)` und `values(dict)` sind spezielle Datentypen. \n", + "- Die Funktion `collect()` macht daraus eine Liste vom Typ `Vector`. \n", + "- `collect(dict)` liefert eine Liste vom Typ `Vector{Pair{S,T}}` \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2dc85bdd", + "metadata": {}, + "outputs": [], + "source": [ + "collect(EW)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "100dbbf1", + "metadata": {}, + "outputs": [], + "source": [ + "collect(keys(EW)), collect(values(EW))" + ] + }, + { + "cell_type": "markdown", + "id": "f9703f73", + "metadata": {}, + "source": [ + "### Geordnetes Iterieren über ein Dictionary\n", + "\n", + "Wir sortieren die Keys. Als Strings werden sie alphabetisch sortiert. Mit dem `rev`-Parameter wird rückwärts sortiert.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c02f0ca", + "metadata": {}, + "outputs": [], + "source": [ + "for k in sort(collect(keys(EW)), rev = true)\n", + " n = EW[k]\n", + " println(\"$k hat $n Millionen Einw. \")\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "c20f0654", + "metadata": {}, + "source": [ + "Wir sortieren `collect(dict)`. Das ist ein Vektor von Paaren. Mit `by` definieren wir, wonach zu sortieren ist: nach dem 2. Element des Paares. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "89ee04e9", + "metadata": {}, + "outputs": [], + "source": [ + "for (k,v) in sort(collect(EW), by = pair -> last(pair), rev=false)\n", + " println(\"$k hat $v Mill. EW\")\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "94ba9752", + "metadata": {}, + "source": [ + "### Eine Anwendung von Dictionaries: Zählen von Häufigkeiten\n", + "\n", + "Wir machen 'experimentelle Stochastik' mit 2 Würfeln: \n", + "\n", + "Gegeben sei `l`, eine Liste mit den Ergebnissen von 100 000 Pasch-Würfen, also 100 000 Zahlen zwischen 2 und 12.\n", + "\n", + "Wie häufig sind die Zahlen 2 bis 12?\n", + "\n", + "\n", + "Wir (lassen) würfeln:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7ff829d", + "metadata": {}, + "outputs": [], + "source": [ + "l = rand(1:6, 100_000) .+ rand(1:6, 100_000)" + ] + }, + { + "cell_type": "markdown", + "id": "48a58503", + "metadata": {}, + "source": [ + "Wir zählen mit Hilfe eines Dictionaries die Häufigkeiten der Ereignisse. Dazu nehmen wir das Ereignis als `key` und seine Häufigkeit als `value`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dd2bcd79", + "metadata": {}, + "outputs": [], + "source": [ + "# In diesem Fall könnte man das auch mit einem einfachen Vektor\n", + "# lösen. Eine bessere Illustration wäre z.B. Worthäufigkeit in\n", + "# einem Text. Dann ist i keine ganze Zahl sondern ein Wort=String\n", + "\n", + "d = Dict{Int,Int}() # das Dict zum 'reinzählen'\n", + "\n", + "for i in l # für jedes i wird d[i] erhöht. \n", + " d[i] = get(d, i, 0) + 1 \n", + "end\n", + "d" + ] + }, + { + "cell_type": "markdown", + "id": "62fe53b9", + "metadata": {}, + "source": [ + "Das Ergebnis:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "154252d3", + "metadata": {}, + "outputs": [], + "source": [ + "using Plots\n", + "\n", + "plot(collect(keys(d)), collect(values(d)), seriestype=:scatter)" + ] + }, + { + "cell_type": "markdown", + "id": "dd482553", + "metadata": {}, + "source": [ + "##### Das Erklär-Bild dazu:\n", + "\n", + "[https://math.stackexchange.com/questions/1204396/why-is-the-sum-of-the-rolls-of-two-dices-a-binomial-distribution-what-is-define](https://math.stackexchange.com/questions/1204396/why-is-the-sum-of-the-rolls-of-two-dices-a-binomial-distribution-what-is-define)\n" ] } ], "metadata": { "kernelspec": { - "display_name": "Julia 1.8.5", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.8" + "name": "julia-1.10" } }, "nbformat": 4, diff --git a/nb/7_ArraysP2.ipynb b/nb/7_ArraysP2.ipynb index 02bab53..71e376c 100644 --- a/nb/7_ArraysP2.ipynb +++ b/nb/7_ArraysP2.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "5c227958", + "id": "e43a03dc", "metadata": {}, "source": [ "# Vektoren, Matrizen, Arrays\n", @@ -21,7 +21,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ee55f3c2", + "id": "4b125a0a", "metadata": {}, "outputs": [], "source": [ @@ -30,7 +30,7 @@ }, { "cell_type": "markdown", - "id": "bc271209", + "id": "78eba0dc", "metadata": {}, "source": [ "Beim Anlegen durch eine explizite Elementliste wird der 'kleinste gemeinsame Typ' für den Typparameter `T` ermittelt.\n" @@ -39,7 +39,7 @@ { "cell_type": "code", "execution_count": null, - "id": "93a9f521", + "id": "6205881e", "metadata": {}, "outputs": [], "source": [ @@ -48,7 +48,7 @@ }, { "cell_type": "markdown", - "id": "3d2a9699", + "id": "f720c669", "metadata": {}, "source": [ "Falls `T` ein numerischer Typ ist, werden die Elemente in diesen Typ umgewandelt.\n" @@ -57,7 +57,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6810b420", + "id": "b0e9d4a3", "metadata": {}, "outputs": [], "source": [ @@ -66,7 +66,7 @@ }, { "cell_type": "markdown", - "id": "cff4245f", + "id": "d0cbc3d0", "metadata": {}, "source": [ "Informationen über einen Array liefern die Funktionen:\n", @@ -80,7 +80,7 @@ { "cell_type": "code", "execution_count": null, - "id": "79c5010b", + "id": "333529d4", "metadata": {}, "outputs": [], "source": [ @@ -96,7 +96,7 @@ }, { "cell_type": "markdown", - "id": "dd306f62", + "id": "b21923e2", "metadata": {}, "source": [ "- Die Stärke des 'klassischen' Arrays für das wissenschaftliche Rechnen besteht darin, dass es einfach nur ein zusammenhängendes Speichersegment ist, in dem die Komponenten gleicher Länge (z.B. 64 Bit) geordnet hintereinander abgespeichert sind. Damit ist der Speicherbedarf minimal und die Zugriffsgeschwindigkeit auf eine Komponente, sowohl beim Lesen als auch beim Modifizieren, maximal. Der Platz der Komponente `v[i]` ist sofort aus `i` berechenbar. \n", @@ -107,7 +107,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3227cda0", + "id": "50682513", "metadata": {}, "outputs": [], "source": [ @@ -118,7 +118,7 @@ }, { "cell_type": "markdown", - "id": "dd9c87cf", + "id": "fc6ba262", "metadata": {}, "source": [ "## Vektoren\n", @@ -134,7 +134,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f49c51ee", + "id": "6a668c97", "metadata": {}, "outputs": [], "source": [ @@ -151,7 +151,7 @@ }, { "cell_type": "markdown", - "id": "d0bae695", + "id": "15639f3a", "metadata": {}, "source": [ "Ein `push!()` kann sehr aufwändig sein, da eventuell neuer Speicher alloziert und dann der ganze bestehende Vektor umkopiert werden muss. Julia optimiert das Speichermanagement. Es wird in einem solchen Fall Speicher auf Vorrat alloziert, so dass weitere `push!`s sehr schnell sind und man 'fast O(1)-Geschwindigkeit' erreicht. \n", @@ -160,13 +160,13 @@ "\n", "### Weitere Konstruktoren\n", "\n", - "Man kann Vektoren mit vorgegebener Länge und Typ uninitialisiert anlegen. Das geht am Schnellsten, die Elemente sind zufállige Bitmuster.\n" + "Man kann Vektoren mit vorgegebener Länge und Typ uninitialisiert anlegen. Das geht am Schnellsten, die Elemente sind zufällige Bitmuster.\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "5dd7319a", + "id": "50f6c3b9", "metadata": {}, "outputs": [], "source": [ @@ -178,7 +178,7 @@ }, { "cell_type": "markdown", - "id": "d154d1d5", + "id": "5076f499", "metadata": {}, "source": [ "- `zeros(n)` legt einen `Vector{Float64}` der Länge `n` an und initialisiert mit Null. \n" @@ -187,7 +187,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a4a098b6", + "id": "8207df1d", "metadata": {}, "outputs": [], "source": [ @@ -196,7 +196,7 @@ }, { "cell_type": "markdown", - "id": "20e95a21", + "id": "7696ccaa", "metadata": {}, "source": [ "- `zeros(T,n)` legt einen Nullvektor vom Typ `T` an.\n" @@ -205,7 +205,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3914deb9", + "id": "6e578ab8", "metadata": {}, "outputs": [], "source": [ @@ -214,16 +214,16 @@ }, { "cell_type": "markdown", - "id": "6ea61c0a", + "id": "6c9dc7a8", "metadata": {}, "source": [ - "- `fill(x, n)` legt `Vector{typeof(x)}` der Länfe `n` an und füllt mit `x`.\n" + "- `fill(x, n)` legt `Vector{typeof(x)}` der Länge `n` an und füllt mit `x`.\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "92180908", + "id": "d9cba335", "metadata": {}, "outputs": [], "source": [ @@ -232,7 +232,7 @@ }, { "cell_type": "markdown", - "id": "177266ed", + "id": "2868cf5c", "metadata": {}, "source": [ "- `similar(v)` legt einen uninitialisierten Vektor von gleichem Typ und Größe wie `v` an.\n" @@ -241,7 +241,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b5479424", + "id": "62eca8f9", "metadata": {}, "outputs": [], "source": [ @@ -250,7 +250,7 @@ }, { "cell_type": "markdown", - "id": "4ad4add1", + "id": "7cbf3df1", "metadata": {}, "source": [ "### Konstruktion durch implizite Schleife _(list comprehension)_\n", @@ -261,7 +261,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2a281cdf", + "id": "e07eaf25", "metadata": {}, "outputs": [], "source": [ @@ -271,7 +271,7 @@ { "cell_type": "code", "execution_count": null, - "id": "afb33a9c", + "id": "2fce397a", "metadata": {}, "outputs": [], "source": [ @@ -280,7 +280,7 @@ }, { "cell_type": "markdown", - "id": "cde23de5", + "id": "d3432e22", "metadata": {}, "source": [ "Man kann sogar noch ein `if` unterbringen.\n" @@ -289,7 +289,7 @@ { "cell_type": "code", "execution_count": null, - "id": "88638841", + "id": "c61e9e2c", "metadata": {}, "outputs": [], "source": [ @@ -298,7 +298,7 @@ }, { "cell_type": "markdown", - "id": "1ee31e25", + "id": "7606acd1", "metadata": {}, "source": [ "### Bitvektoren {#sec-bitvec}\n", @@ -314,7 +314,7 @@ { "cell_type": "code", "execution_count": null, - "id": "115aa38e", + "id": "0d5b1e39", "metadata": {}, "outputs": [], "source": [ @@ -323,7 +323,7 @@ }, { "cell_type": "markdown", - "id": "dd064777", + "id": "426cefd2", "metadata": {}, "source": [ "Für die Gegenrichtung gibt es `collect()`.\n" @@ -332,7 +332,7 @@ { "cell_type": "code", "execution_count": null, - "id": "035f3ce7", + "id": "65291775", "metadata": {}, "outputs": [], "source": [ @@ -341,7 +341,7 @@ }, { "cell_type": "markdown", - "id": "b40e16c8", + "id": "3f56c7c8", "metadata": {}, "source": [ "BitVectoren entstehen z.B. als Ergebnis von elementweisen Vergleichen (s. @sec-broadcast).\n" @@ -350,7 +350,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6b67988d", + "id": "2584c04e", "metadata": {}, "outputs": [], "source": [ @@ -359,12 +359,12 @@ }, { "cell_type": "markdown", - "id": "6095e15c", + "id": "6a0f2b5e", "metadata": {}, "source": [ "### Indizierung\n", "\n", - "Für den Mathematiker sind Indizes Ordinalzahlen. Also __startet die Indexzählung mit 1.__\n", + "Indizes sind Ordinalzahlen. Also __startet die Indexzählung mit 1.__\n", "\n", "Als Index kann man verwenden:\n", "\n", @@ -380,7 +380,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1e8f2011", + "id": "9180ff62", "metadata": {}, "outputs": [], "source": [ @@ -390,7 +390,7 @@ { "cell_type": "code", "execution_count": null, - "id": "61efc9b0", + "id": "cb5a9547", "metadata": {}, "outputs": [], "source": [ @@ -399,7 +399,7 @@ }, { "cell_type": "markdown", - "id": "005efaab", + "id": "e58751f6", "metadata": {}, "source": [ "Bei Zuweisungen wird die rechte Seite wenn nötig mit `convert(T,x)` in den Vektorelementetyp umgewandelt.\n" @@ -408,7 +408,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d29b8ddb", + "id": "d029af20", "metadata": {}, "outputs": [], "source": [ @@ -418,7 +418,7 @@ }, { "cell_type": "markdown", - "id": "4c1b08f5", + "id": "2561448e", "metadata": {}, "source": [ "Überschreiten der Indexgrenzen führt zu einem `BoundsError`. \n" @@ -427,7 +427,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d8e26873", + "id": "06224d52", "metadata": {}, "outputs": [], "source": [ @@ -436,7 +436,7 @@ }, { "cell_type": "markdown", - "id": "43567db7", + "id": "deb2c6b3", "metadata": {}, "source": [ "Mit einem `range`-Objekt kann man einen Teilvektor adressieren.\n" @@ -445,7 +445,7 @@ { "cell_type": "code", "execution_count": null, - "id": "15f45e9d", + "id": "322752f1", "metadata": {}, "outputs": [], "source": [ @@ -456,7 +456,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c52da06e", + "id": "a24080ff", "metadata": {}, "outputs": [], "source": [ @@ -466,17 +466,17 @@ }, { "cell_type": "markdown", - "id": "d6e45504", + "id": "9a7afae9", "metadata": {}, "source": [ "- Bei der Verwendung als Index kann in einem Range der Spezialwert `end` verwendet werden.\n", - "- Bei der Verwendung als Index kann der \"leere\" Range `:` als Abkürzung von `1:end` verwendet werden. Das ist nützlich bei Matrizen: `A[:, 3]` addresiert die gesamte 3. Spalte von `A`. \n" + "- Bei der Verwendung als Index kann der \"leere\" Range `:` als Abkürzung von `1:end` verwendet werden. Das ist nützlich bei Matrizen: `A[:, 3]` adressiert die gesamte 3. Spalte von `A`. \n" ] }, { "cell_type": "code", "execution_count": null, - "id": "6f73e624", + "id": "e7bfe889", "metadata": {}, "outputs": [], "source": [ @@ -486,7 +486,7 @@ }, { "cell_type": "markdown", - "id": "ff325674", + "id": "178a0bd2", "metadata": {}, "source": [ "#### Indirekte Indizierung\n", @@ -500,7 +500,7 @@ { "cell_type": "code", "execution_count": null, - "id": "bf53ca2b", + "id": "f72a76df", "metadata": {}, "outputs": [], "source": [ @@ -509,7 +509,7 @@ }, { "cell_type": "markdown", - "id": "7b2f2bc8", + "id": "f2d76c2c", "metadata": {}, "source": [ "ist also gleich\n" @@ -518,7 +518,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4f5fec9d", + "id": "5c9556da", "metadata": {}, "outputs": [], "source": [ @@ -527,7 +527,7 @@ }, { "cell_type": "markdown", - "id": "d24e3956", + "id": "3d7b83ee", "metadata": {}, "source": [ "#### Indizierung mit einem Vektor von Wahrheitswerten\n", @@ -538,7 +538,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9af04e7e", + "id": "0995d191", "metadata": {}, "outputs": [], "source": [ @@ -547,7 +547,7 @@ }, { "cell_type": "markdown", - "id": "7d64ac85", + "id": "f7ef567d", "metadata": {}, "source": [ "Das ist nützlich, da man z.B.\n", @@ -560,7 +560,7 @@ { "cell_type": "code", "execution_count": null, - "id": "670b80ea", + "id": "eda29b0d", "metadata": {}, "outputs": [], "source": [ @@ -569,7 +569,7 @@ }, { "cell_type": "markdown", - "id": "7bc7e5fb", + "id": "3f46137f", "metadata": {}, "source": [ "## Matrizen und Arrays\n", @@ -582,7 +582,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f4c8b14c", + "id": "a8bf798b", "metadata": {}, "outputs": [], "source": [ @@ -591,7 +591,7 @@ }, { "cell_type": "markdown", - "id": "b692ddb4", + "id": "60e20aae", "metadata": {}, "source": [ "In den meisten Funktionen kann man die Dimensionen auch als Tupel übergeben. Die obige Anweisung lässt sich auch so schreiben:\n", @@ -606,7 +606,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c7b17431", + "id": "50627ef8", "metadata": {}, "outputs": [], "source": [ @@ -616,7 +616,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f361ecf8", + "id": "fa2da287", "metadata": {}, "outputs": [], "source": [ @@ -625,7 +625,7 @@ }, { "cell_type": "markdown", - "id": "68ac511a", + "id": "79c237c5", "metadata": {}, "source": [ "Die Funktion `similar()`, die einen Array gleicher Größe uninitialisiert erzeugt, kann auch einen Typ als weiteres Argument bekommen.\n" @@ -634,7 +634,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3a0958e2", + "id": "967c0a3e", "metadata": {}, "outputs": [], "source": [ @@ -643,7 +643,7 @@ }, { "cell_type": "markdown", - "id": "027fb6d6", + "id": "381254e3", "metadata": {}, "source": [ "### Konstruktion durch explizite Elementliste\n", @@ -656,7 +656,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ba838fe7", + "id": "7100bcaf", "metadata": {}, "outputs": [], "source": [ @@ -666,7 +666,7 @@ }, { "cell_type": "markdown", - "id": "5254a785", + "id": "45bef96a", "metadata": {}, "source": [ "- dieselbe Matrix:\n" @@ -675,7 +675,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4878b4e0", + "id": "7e6caf84", "metadata": {}, "outputs": [], "source": [ @@ -684,7 +684,7 @@ }, { "cell_type": "markdown", - "id": "48b415e9", + "id": "be6fedc8", "metadata": {}, "source": [ "- Ein Array mit 3 Indizes:\n" @@ -693,7 +693,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c0e45334", + "id": "3f2233ce", "metadata": {}, "outputs": [], "source": [ @@ -705,7 +705,7 @@ }, { "cell_type": "markdown", - "id": "aedabca8", + "id": "e3bee379", "metadata": {}, "source": [ "- und nochmal die Matrix `M2`:\n" @@ -714,7 +714,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3537604f", + "id": "efa9ecd7", "metadata": {}, "outputs": [], "source": [ @@ -723,7 +723,7 @@ }, { "cell_type": "markdown", - "id": "8b21f42d", + "id": "fa6e923a", "metadata": {}, "source": [ "Im letzten Beispiel kommen diese Regeln zur Anwendung:\n", @@ -741,14 +741,14 @@ "\n", ":::{.callout-important}\n", "\n", - "- Vektorschreibweise mit Komma als Trenner geht nur bei Vektoren, nicht mit \"Semikolon, Leerzeichen, Newline' mischen! \n", - "- Vektoren mit einem Index; $1\\!\\times\\!n$-Matrizen und $n\\!\\times\\!1$-Matrizen sind drei verschiedene Dinge!\n" + "- Vektorschreibweise mit Komma als Trenner geht nur bei Vektoren, nicht mit \"Semikolon, Leerzeichen, Newline\" mischen! \n", + "- Vektoren, $1\\!\\times\\!n$-Matrizen und $n\\!\\times\\!1$-Matrizen sind drei verschiedene Dinge!\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "5068d43b", + "id": "20499e99", "metadata": {}, "outputs": [], "source": [ @@ -758,7 +758,7 @@ { "cell_type": "code", "execution_count": null, - "id": "251a03fc", + "id": "e8554e3f", "metadata": {}, "outputs": [], "source": [ @@ -768,7 +768,7 @@ { "cell_type": "code", "execution_count": null, - "id": "12be7f1d", + "id": "d42f242f", "metadata": {}, "outputs": [], "source": [ @@ -778,7 +778,7 @@ { "cell_type": "code", "execution_count": null, - "id": "41a648f3", + "id": "f76b20d5", "metadata": {}, "outputs": [], "source": [ @@ -787,7 +787,7 @@ }, { "cell_type": "markdown", - "id": "e16508b2", + "id": "a049e8a8", "metadata": {}, "source": [ ":::\n", @@ -799,7 +799,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8d20c99f", + "id": "73cfb832", "metadata": {}, "outputs": [], "source": [ @@ -809,7 +809,7 @@ { "cell_type": "code", "execution_count": null, - "id": "7acc9cd7", + "id": "55f2f419", "metadata": {}, "outputs": [], "source": [ @@ -818,7 +818,7 @@ }, { "cell_type": "markdown", - "id": "36081804", + "id": "69072c6f", "metadata": {}, "source": [ "Das sollte man nur in Spezialfällen tun. Die Array-Sprache von Julia ist in der Regel bequemer und schneller.\n", @@ -829,7 +829,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8dbddd28", + "id": "f8d1140f", "metadata": {}, "outputs": [], "source": [ @@ -839,7 +839,7 @@ }, { "cell_type": "markdown", - "id": "86dcdd80", + "id": "7ca06ccd", "metadata": {}, "source": [ "Die übliche Indexnotation:\n" @@ -848,7 +848,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6457e824", + "id": "117b78c9", "metadata": {}, "outputs": [], "source": [ @@ -858,7 +858,7 @@ }, { "cell_type": "markdown", - "id": "ed38064b", + "id": "6a1d738b", "metadata": {}, "source": [ "Man kann mit Ranges Teilfelder adressieren:\n" @@ -867,7 +867,7 @@ { "cell_type": "code", "execution_count": null, - "id": "865b7b29", + "id": "733f15a6", "metadata": {}, "outputs": [], "source": [ @@ -876,7 +876,7 @@ }, { "cell_type": "markdown", - "id": "eafd8cc8", + "id": "212c6e6d", "metadata": {}, "source": [ "Das Adressieren von Teilen mit geringerer Dimension wird auch *slicing* genannt.\n" @@ -885,7 +885,7 @@ { "cell_type": "code", "execution_count": null, - "id": "aba3e4ef", + "id": "2190a0d6", "metadata": {}, "outputs": [], "source": [ @@ -897,7 +897,7 @@ { "cell_type": "code", "execution_count": null, - "id": "14259946", + "id": "94e3dc5b", "metadata": {}, "outputs": [], "source": [ @@ -908,7 +908,7 @@ }, { "cell_type": "markdown", - "id": "bec96c71", + "id": "45c89587", "metadata": {}, "source": [ "Natürlich sind damit auch Zuweisungen möglich:\n" @@ -917,7 +917,7 @@ { "cell_type": "code", "execution_count": null, - "id": "82f68a6e", + "id": "beca175d", "metadata": {}, "outputs": [], "source": [ @@ -929,7 +929,7 @@ }, { "cell_type": "markdown", - "id": "23dd1440", + "id": "9dd8da68", "metadata": {}, "source": [ "## Verhalten bei Zuweisungen, `copy()` und `deepcopy()`, Views\n", @@ -943,7 +943,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2499e260", + "id": "e7ece88d", "metadata": {}, "outputs": [], "source": [ @@ -953,7 +953,7 @@ }, { "cell_type": "markdown", - "id": "4c9e3a04", + "id": "390e8338", "metadata": {}, "source": [ "`A` und `B` sind jetzt Namen desselben Objekts.\n" @@ -962,7 +962,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9fdad306", + "id": "ad71682b", "metadata": {}, "outputs": [], "source": [ @@ -973,7 +973,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c51812e7", + "id": "9422450b", "metadata": {}, "outputs": [], "source": [ @@ -983,7 +983,7 @@ }, { "cell_type": "markdown", - "id": "00fe556c", + "id": "ce960e49", "metadata": {}, "source": [ "Dieses Verhalten spart viel Zeit und Speicher, ist aber nicht immer gewünscht. \n", @@ -993,7 +993,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b71aff22", + "id": "61fd903e", "metadata": {}, "outputs": [], "source": [ @@ -1005,7 +1005,7 @@ }, { "cell_type": "markdown", - "id": "03f55f43", + "id": "cf24b145", "metadata": {}, "source": [ "Die Funktion \n", @@ -1019,7 +1019,7 @@ { "cell_type": "code", "execution_count": null, - "id": "75c537cc", + "id": "174a9513", "metadata": {}, "outputs": [], "source": [ @@ -1037,7 +1037,7 @@ { "cell_type": "code", "execution_count": null, - "id": "5721ca90", + "id": "79dac2ba", "metadata": {}, "outputs": [], "source": [ @@ -1049,7 +1049,7 @@ }, { "cell_type": "markdown", - "id": "f9ebeba5", + "id": "8adee725", "metadata": {}, "source": [ "### Views\n", @@ -1061,7 +1061,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d17cb1dd", + "id": "0aeffcf9", "metadata": {}, "outputs": [], "source": [ @@ -1077,7 +1077,7 @@ }, { "cell_type": "markdown", - "id": "3b5120b7", + "id": "1e2f7d51", "metadata": {}, "source": [ "Manchmal möchte man aber gerade hier eine Referenz-Semantik haben im Sinne von: \"Vektor `v` soll der 2. Spaltenvektor von `A` sein und auch bleiben (d.h., sich mitändern, wenn sich `A` ändert).\"\n", @@ -1090,7 +1090,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c86c7a1f", + "id": "1ea24972", "metadata": {}, "outputs": [], "source": [ @@ -1106,7 +1106,7 @@ }, { "cell_type": "markdown", - "id": "d076c1a5", + "id": "929d0c0c", "metadata": {}, "source": [ "Diese Technik wird von Julia aus Effizienzgründen auch bei einigen Funktionen der linearen Algebra verwendet. \n", @@ -1123,7 +1123,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f3bae50e", + "id": "4eab95b5", "metadata": {}, "outputs": [], "source": [ @@ -1134,7 +1134,7 @@ }, { "cell_type": "markdown", - "id": "67138cff", + "id": "05788cae", "metadata": {}, "source": [ "Die Matrix `B` ist nur ein modifizierter 'View' auf `A`:\n" @@ -1143,7 +1143,7 @@ { "cell_type": "code", "execution_count": null, - "id": "829acf4c", + "id": "8cbbd3b6", "metadata": {}, "outputs": [], "source": [ @@ -1153,7 +1153,7 @@ }, { "cell_type": "markdown", - "id": "e3c2a66c", + "id": "67cfc86f", "metadata": {}, "source": [ "Aus Vektoren macht `adjoint()` eine $1\\!\\times\\!n$-Matrix (einen Zeilenvektor).\n" @@ -1162,7 +1162,7 @@ { "cell_type": "code", "execution_count": null, - "id": "78065100", + "id": "5bbd675d", "metadata": {}, "outputs": [], "source": [ @@ -1172,7 +1172,7 @@ }, { "cell_type": "markdown", - "id": "a5d85afa", + "id": "c6a6095a", "metadata": {}, "source": [ "Eine weitere solche Funktion, die einen alternativen 'View', eine andere Indizierung, derselben Daten \n", @@ -1184,7 +1184,7 @@ { "cell_type": "code", "execution_count": null, - "id": "7c31328d", + "id": "6f9b3031", "metadata": {}, "outputs": [], "source": [ @@ -1195,7 +1195,7 @@ }, { "cell_type": "markdown", - "id": "ab0bb6f9", + "id": "a113beb5", "metadata": {}, "source": [ "## Speicherung eines Arrays\n", @@ -1210,7 +1210,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e6b341f8", + "id": "d465b690", "metadata": {}, "outputs": [], "source": [ @@ -1236,7 +1236,7 @@ { "cell_type": "code", "execution_count": null, - "id": "02e841a6", + "id": "eba4dc73", "metadata": {}, "outputs": [], "source": [ @@ -1247,7 +1247,7 @@ { "cell_type": "code", "execution_count": null, - "id": "977e691b", + "id": "ae245931", "metadata": {}, "outputs": [], "source": [ @@ -1259,7 +1259,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1e5df44b", + "id": "604ed987", "metadata": {}, "outputs": [], "source": [ @@ -1268,7 +1268,7 @@ }, { "cell_type": "markdown", - "id": "c75b3f1d", + "id": "18adb785", "metadata": {}, "source": [ "### Lokalität von Speicherzugriffen und _Caching_\n", @@ -1303,7 +1303,7 @@ { "cell_type": "code", "execution_count": null, - "id": "af7e8988", + "id": "dfb3003d", "metadata": {}, "outputs": [], "source": [ @@ -1313,7 +1313,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b37890ac", + "id": "48d71570", "metadata": {}, "outputs": [], "source": [ @@ -1323,7 +1323,7 @@ }, { "cell_type": "markdown", - "id": "62d17bc4", + "id": "6c87a401", "metadata": {}, "source": [ "### Matrixprodukt\n", @@ -1348,7 +1348,7 @@ { "cell_type": "code", "execution_count": null, - "id": "bfd0201f", + "id": "05935615", "metadata": {}, "outputs": [], "source": [ @@ -1360,7 +1360,7 @@ }, { "cell_type": "markdown", - "id": "78eb3a67", + "id": "dce2784e", "metadata": {}, "source": [ "- (2,3)-Matrix `*` (3,2)-Matrix\n" @@ -1369,7 +1369,7 @@ { "cell_type": "code", "execution_count": null, - "id": "5012734f", + "id": "7598bc25", "metadata": {}, "outputs": [], "source": [ @@ -1378,7 +1378,7 @@ }, { "cell_type": "markdown", - "id": "6853f87e", + "id": "55f9d6b9", "metadata": {}, "source": [ "- (3,2)-Matrix `*` (2,3)-Matrix\n" @@ -1387,7 +1387,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0043d2e3", + "id": "564ad780", "metadata": {}, "outputs": [], "source": [ @@ -1396,7 +1396,7 @@ }, { "cell_type": "markdown", - "id": "2f8fef4c", + "id": "40ac054a", "metadata": {}, "source": [ "- (2,3)-Matrix `*` 3-Vektor\n" @@ -1405,7 +1405,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b12cbb35", + "id": "b786671d", "metadata": {}, "outputs": [], "source": [ @@ -1414,7 +1414,7 @@ }, { "cell_type": "markdown", - "id": "80ba832f", + "id": "2e1d3ac5", "metadata": {}, "source": [ "- (1,2)-Vektore `*` (2,3)-Matrix\n" @@ -1423,7 +1423,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f832930e", + "id": "0ffa79ec", "metadata": {}, "outputs": [], "source": [ @@ -1432,7 +1432,7 @@ }, { "cell_type": "markdown", - "id": "30ccb92a", + "id": "63ef7bb9", "metadata": {}, "source": [ "- (3,2)-Matrix `*` 2-Vektor\n" @@ -1441,7 +1441,7 @@ { "cell_type": "code", "execution_count": null, - "id": "20668407", + "id": "b0f948d5", "metadata": {}, "outputs": [], "source": [ @@ -1450,7 +1450,7 @@ }, { "cell_type": "markdown", - "id": "11148039", + "id": "fd1bc853", "metadata": {}, "source": [ "- (1,2)-Vektor `*` 2-Vektor (Skalarprodukt)\n" @@ -1459,7 +1459,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b7f89eac", + "id": "5dab68d0", "metadata": {}, "outputs": [], "source": [ @@ -1468,7 +1468,7 @@ }, { "cell_type": "markdown", - "id": "a6c08a07", + "id": "f968aace", "metadata": {}, "source": [ "2-Vektor `*` (1,3)-Vektor (äußeres Produkt) \n" @@ -1477,7 +1477,7 @@ { "cell_type": "code", "execution_count": null, - "id": "71f47541", + "id": "1e9d367d", "metadata": {}, "outputs": [], "source": [ @@ -1486,7 +1486,7 @@ }, { "cell_type": "markdown", - "id": "7d1fe459", + "id": "5550f800", "metadata": {}, "source": [ "## Broadcasting {#sec-broadcast}\n", @@ -1506,7 +1506,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3b2f54bd", + "id": "cf644168", "metadata": {}, "outputs": [], "source": [ @@ -1515,7 +1515,7 @@ }, { "cell_type": "markdown", - "id": "9e2b6b10", + "id": "ad8b4971", "metadata": {}, "source": [ "- Das Folgende liefert nicht die algebraische [Wurzel aus einer Matrix](https://de.wikipedia.org/wiki/Quadratwurzel_einer_Matrix), sondern die elementweise Wurzel aus jedem Eintrag. \n" @@ -1524,7 +1524,7 @@ { "cell_type": "code", "execution_count": null, - "id": "eed676ee", + "id": "b4538387", "metadata": {}, "outputs": [], "source": [ @@ -1536,7 +1536,7 @@ }, { "cell_type": "markdown", - "id": "ae8a2b5e", + "id": "3707abc5", "metadata": {}, "source": [ "- Das Folgende liefert nicht $A^2$, sondern die Einträge werden quadriert.\n" @@ -1545,7 +1545,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0cc93370", + "id": "5f37e6fb", "metadata": {}, "outputs": [], "source": [ @@ -1554,16 +1554,16 @@ }, { "cell_type": "markdown", - "id": "3f8e55c6", + "id": "e29962a4", "metadata": {}, "source": [ - "- Zum Vergleich das Ergenmis der algebraischen Operationen:\n" + "- Zum Vergleich das Ergebnis der algebraischen Operationen:\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "f1b97fa1", + "id": "1b596daf", "metadata": {}, "outputs": [], "source": [ @@ -1572,7 +1572,7 @@ }, { "cell_type": "markdown", - "id": "6e3c2f80", + "id": "8f03b0b1", "metadata": {}, "source": [ "- Broadcasting geht auch mit Funktionen mehrerer Variablen.\n" @@ -1581,7 +1581,7 @@ { "cell_type": "code", "execution_count": null, - "id": "14763047", + "id": "e6b8bee2", "metadata": {}, "outputs": [], "source": [ @@ -1595,7 +1595,7 @@ }, { "cell_type": "markdown", - "id": "7c23f048", + "id": "1b26105a", "metadata": {}, "source": [ "Bei Operanden verschiedener Dimension wird der Operand mit fehlenden Dimensionen in diesen durch Vervielfältigung virtuell \n", @@ -1607,7 +1607,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d1186a3d", + "id": "e93a5c94", "metadata": {}, "outputs": [], "source": [ @@ -1618,7 +1618,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ca261d61", + "id": "1ffed9b6", "metadata": {}, "outputs": [], "source": [ @@ -1627,7 +1627,7 @@ }, { "cell_type": "markdown", - "id": "88d70780", + "id": "20ad8893", "metadata": {}, "source": [ "Der Skalar wurde durch Replikation auf dieselbe Dimension wie die Matrix gebracht. Wir lassen uns von `broadcast()` die Form des 2. Operanden nach dem *broadcasting* anzeigen: \n" @@ -1636,7 +1636,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c48e84e2", + "id": "f1cb0ee6", "metadata": {}, "outputs": [], "source": [ @@ -1645,7 +1645,7 @@ }, { "cell_type": "markdown", - "id": "021a47a6", + "id": "241dbfa0", "metadata": {}, "source": [ "(Natürlich findet diese Replikation nur virtuell statt. Dieses Objekt wird bei anderen Operationen nicht wirklich erzeugt.)\n", @@ -1656,7 +1656,7 @@ { "cell_type": "code", "execution_count": null, - "id": "769ea0eb", + "id": "429dabe1", "metadata": {}, "outputs": [], "source": [ @@ -1665,7 +1665,7 @@ }, { "cell_type": "markdown", - "id": "458cdda2", + "id": "de953456", "metadata": {}, "source": [ "Der Vektor wird durch Wiederholung der Spalten aufgeblasen:\n" @@ -1674,7 +1674,7 @@ { "cell_type": "code", "execution_count": null, - "id": "fa093187", + "id": "9f5535f6", "metadata": {}, "outputs": [], "source": [ @@ -1683,7 +1683,7 @@ }, { "cell_type": "markdown", - "id": "a5fa929f", + "id": "2627365f", "metadata": {}, "source": [ "Matrix und Zeilenvektor: Der Zeilenvektor wird zeilenweise vervielfältigt:\n" @@ -1692,7 +1692,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c3d35884", + "id": "962474ab", "metadata": {}, "outputs": [], "source": [ @@ -1701,7 +1701,7 @@ }, { "cell_type": "markdown", - "id": "01cd8879", + "id": "ac7a3201", "metadata": {}, "source": [ "Der 2. Operand wird von `broadcast()` durch Vervielfältigung der Zeilen 'aufgeblasen'.\n" @@ -1710,7 +1710,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2e90d0b0", + "id": "d83acb56", "metadata": {}, "outputs": [], "source": [ @@ -1719,7 +1719,7 @@ }, { "cell_type": "markdown", - "id": "6d5febb2", + "id": "80457191", "metadata": {}, "source": [ "#### _Broadcasting_ bei Zuweisungen\n", @@ -1734,7 +1734,7 @@ { "cell_type": "code", "execution_count": null, - "id": "14dece22", + "id": "bee75c40", "metadata": {}, "outputs": [], "source": [ @@ -1744,7 +1744,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3b73a744", + "id": "bf5e8b92", "metadata": {}, "outputs": [], "source": [ @@ -1753,7 +1753,7 @@ }, { "cell_type": "markdown", - "id": "33ad4d5e", + "id": "98dd945c", "metadata": {}, "source": [ "## Weitere Array-Funktionen - eine Auswahl\n", @@ -1764,7 +1764,7 @@ { "cell_type": "code", "execution_count": null, - "id": "04f8dc09", + "id": "519a4401", "metadata": {}, "outputs": [], "source": [ @@ -1773,7 +1773,7 @@ }, { "cell_type": "markdown", - "id": "58ce80a0", + "id": "439eed6b", "metadata": {}, "source": [ "- Finde das Maximum\n" @@ -1782,7 +1782,7 @@ { "cell_type": "code", "execution_count": null, - "id": "34487039", + "id": "ec143467", "metadata": {}, "outputs": [], "source": [ @@ -1791,7 +1791,7 @@ }, { "cell_type": "markdown", - "id": "d17e1a0d", + "id": "d15dfe99", "metadata": {}, "source": [ "- Finde das Maximum jeder Spalte\n" @@ -1800,7 +1800,7 @@ { "cell_type": "code", "execution_count": null, - "id": "801f2031", + "id": "533c06d7", "metadata": {}, "outputs": [], "source": [ @@ -1809,7 +1809,7 @@ }, { "cell_type": "markdown", - "id": "2478bd06", + "id": "5f1a1b2a", "metadata": {}, "source": [ "- Finde das Maximum jeder Zeile\n" @@ -1818,7 +1818,7 @@ { "cell_type": "code", "execution_count": null, - "id": "85671a6a", + "id": "c34651ef", "metadata": {}, "outputs": [], "source": [ @@ -1827,7 +1827,7 @@ }, { "cell_type": "markdown", - "id": "acb7426d", + "id": "f3fdef0e", "metadata": {}, "source": [ "- Finde das Minimum und seine Position\n" @@ -1836,7 +1836,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e6dd832a", + "id": "98e5091d", "metadata": {}, "outputs": [], "source": [ @@ -1845,16 +1845,16 @@ }, { "cell_type": "markdown", - "id": "42cca03b", + "id": "2e7763ec", "metadata": {}, "source": [ - "- Was ist ein `CatesianIndex`?\n" + "- Was ist ein `CartesianIndex`?\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "f07d0f44", + "id": "af1ba0fd", "metadata": {}, "outputs": [], "source": [ @@ -1863,7 +1863,7 @@ }, { "cell_type": "markdown", - "id": "ad46031d", + "id": "6ab6f7d3", "metadata": {}, "source": [ "- Extrahiere die Indizes des Minimum als Tupel\n" @@ -1872,7 +1872,7 @@ { "cell_type": "code", "execution_count": null, - "id": "73fee196", + "id": "d05a38b9", "metadata": {}, "outputs": [], "source": [ @@ -1881,7 +1881,7 @@ }, { "cell_type": "markdown", - "id": "eb657bc1", + "id": "086a84fa", "metadata": {}, "source": [ "- Summe und Produkt aller Einträge\n" @@ -1890,7 +1890,7 @@ { "cell_type": "code", "execution_count": null, - "id": "56363941", + "id": "da8c7d9d", "metadata": {}, "outputs": [], "source": [ @@ -1899,7 +1899,7 @@ }, { "cell_type": "markdown", - "id": "c7cf919e", + "id": "00dafdb6", "metadata": {}, "source": [ "- Spaltensumme (1. Index wird reduziert)\n" @@ -1908,7 +1908,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c6fecc3b", + "id": "5396cf9f", "metadata": {}, "outputs": [], "source": [ @@ -1917,7 +1917,7 @@ }, { "cell_type": "markdown", - "id": "5081b4da", + "id": "22bb7bc0", "metadata": {}, "source": [ "- Zeilensummen (2. Index wird reduziert)\n" @@ -1926,7 +1926,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a1099f5a", + "id": "d4b2df7a", "metadata": {}, "outputs": [], "source": [ @@ -1935,7 +1935,7 @@ }, { "cell_type": "markdown", - "id": "05404237", + "id": "8034a3be", "metadata": {}, "source": [ "- Summiere nach elementweiser Anwendung einer Funktion\n" @@ -1944,7 +1944,7 @@ { "cell_type": "code", "execution_count": null, - "id": "fcd3a0a8", + "id": "7ba1e90d", "metadata": {}, "outputs": [], "source": [ @@ -1953,7 +1953,7 @@ }, { "cell_type": "markdown", - "id": "59f9b755", + "id": "3e5683c0", "metadata": {}, "source": [ "- Reduziere (falte) den Array mit einer Funktion\n" @@ -1962,7 +1962,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a7ecdced", + "id": "159aaf26", "metadata": {}, "outputs": [], "source": [ @@ -1971,7 +1971,7 @@ }, { "cell_type": "markdown", - "id": "c72dff31", + "id": "88a48c23", "metadata": {}, "source": [ "- `mapreduce(f, op, array)`: Wende `f` auf alle Einträge an, dann reduziere mit `op`\n" @@ -1980,7 +1980,7 @@ { "cell_type": "code", "execution_count": null, - "id": "99dc2a14", + "id": "4ea5e808", "metadata": {}, "outputs": [], "source": [ @@ -1989,7 +1989,7 @@ }, { "cell_type": "markdown", - "id": "de530920", + "id": "f6373c3d", "metadata": {}, "source": [ "- Gibt es Elemente in A, die > 5 sind? \n" @@ -1998,7 +1998,7 @@ { "cell_type": "code", "execution_count": null, - "id": "53d33e6c", + "id": "f3aac8eb", "metadata": {}, "outputs": [], "source": [ @@ -2007,7 +2007,7 @@ }, { "cell_type": "markdown", - "id": "9dea54d7", + "id": "9e9df67c", "metadata": {}, "source": [ "- Wieviele Elemente in A sind > 5?\n" @@ -2016,7 +2016,7 @@ { "cell_type": "code", "execution_count": null, - "id": "7dbdc21b", + "id": "8377529f", "metadata": {}, "outputs": [], "source": [ @@ -2025,7 +2025,7 @@ }, { "cell_type": "markdown", - "id": "6c57c62e", + "id": "b3038478", "metadata": {}, "source": [ "- sind alle Einträge positiv?\n" @@ -2034,7 +2034,7 @@ { "cell_type": "code", "execution_count": null, - "id": "394308c2", + "id": "911556d1", "metadata": {}, "outputs": [], "source": [ @@ -2044,9 +2044,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.8.5", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.8" + "name": "julia-1.10" } }, "nbformat": 4, diff --git a/nb/9_functs.ipynb b/nb/9_functs.ipynb index fada2fe..b078712 100644 --- a/nb/9_functs.ipynb +++ b/nb/9_functs.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "87512b9c", + "id": "c68c2670", "metadata": {}, "source": [ "# Funktionen und Operatoren\n", @@ -19,7 +19,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2cdf33d6", + "id": "9443ccb7", "metadata": {}, "outputs": [], "source": [ @@ -30,7 +30,7 @@ }, { "cell_type": "markdown", - "id": "d22901e3", + "id": "50291f2a", "metadata": {}, "source": [ "II. Als \"Einzeiler\" \n" @@ -39,7 +39,7 @@ { "cell_type": "code", "execution_count": null, - "id": "338f000a", + "id": "4657e421", "metadata": {}, "outputs": [], "source": [ @@ -48,7 +48,7 @@ }, { "cell_type": "markdown", - "id": "f14a745f", + "id": "d36c44e2", "metadata": {}, "source": [ "III. Als anonyme Funktionen\n" @@ -57,7 +57,7 @@ { "cell_type": "code", "execution_count": null, - "id": "44319487", + "id": "02e66f6e", "metadata": {}, "outputs": [], "source": [ @@ -66,7 +66,7 @@ }, { "cell_type": "markdown", - "id": "d8f8978c", + "id": "f3c09c53", "metadata": {}, "source": [ "### Block-Form und `return`\n", @@ -106,7 +106,7 @@ { "cell_type": "code", "execution_count": null, - "id": "721d72e8", + "id": "6694b46d", "metadata": {}, "outputs": [], "source": [ @@ -121,7 +121,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f6847d6a", + "id": "ee012edc", "metadata": {}, "outputs": [], "source": [ @@ -131,7 +131,7 @@ { "cell_type": "code", "execution_count": null, - "id": "483d2b6b", + "id": "fca80289", "metadata": {}, "outputs": [], "source": [ @@ -140,7 +140,7 @@ }, { "cell_type": "markdown", - "id": "66a0d115", + "id": "39cf5d56", "metadata": {}, "source": [ "### Einzeiler-Form\n", @@ -186,7 +186,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e07295eb", + "id": "35a8bd70", "metadata": {}, "outputs": [], "source": [ @@ -196,7 +196,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b8ca9baf", + "id": "f8cec9b2", "metadata": {}, "outputs": [], "source": [ @@ -205,7 +205,7 @@ }, { "cell_type": "markdown", - "id": "9ba0e8db", + "id": "71388002", "metadata": {}, "source": [ "Ein weiteres Beispiel ist `filter(test, collection)`, wobei ein Test eine Funktion ist, die ein `Bool` zurückgibt.\n" @@ -214,7 +214,7 @@ { "cell_type": "code", "execution_count": null, - "id": "12731194", + "id": "11d55610", "metadata": {}, "outputs": [], "source": [ @@ -223,7 +223,7 @@ }, { "cell_type": "markdown", - "id": "f4af9755", + "id": "36b2a20b", "metadata": {}, "source": [ "## Argumentübergabe\n", @@ -237,7 +237,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d34f0256", + "id": "650adea1", "metadata": {}, "outputs": [], "source": [ @@ -251,7 +251,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f83f5e37", + "id": "49a771b3", "metadata": {}, "outputs": [], "source": [ @@ -267,7 +267,7 @@ }, { "cell_type": "markdown", - "id": "7476eab9", + "id": "d0d2e303", "metadata": {}, "source": [ "## Varianten von Funktionsargumenten\n", @@ -285,7 +285,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e67e1006", + "id": "5ec6f56a", "metadata": {}, "outputs": [], "source": [ @@ -298,7 +298,7 @@ }, { "cell_type": "markdown", - "id": "1d889283", + "id": "4389ea71", "metadata": {}, "source": [ "Eine Funktion nur mit _keyword_-Argumenten wird so deklariert:\n" @@ -307,7 +307,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e79269ee", + "id": "0fc2aeac", "metadata": {}, "outputs": [], "source": [ @@ -318,7 +318,7 @@ }, { "cell_type": "markdown", - "id": "14d197af", + "id": "26e02ff2", "metadata": {}, "source": [ "## Funktionen sind ganz normale Objekte\n", @@ -329,7 +329,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2e0a4b89", + "id": "17b38616", "metadata": {}, "outputs": [], "source": [ @@ -339,7 +339,7 @@ }, { "cell_type": "markdown", - "id": "6f0fef37", + "id": "325c567b", "metadata": {}, "source": [ "- Sie können als Argumente an Funktionen übergeben werden.\n" @@ -348,7 +348,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c6db6121", + "id": "4d5be6cf", "metadata": {}, "outputs": [], "source": [ @@ -369,7 +369,7 @@ }, { "cell_type": "markdown", - "id": "b8eb1978", + "id": "43f02a36", "metadata": {}, "source": [ "- Sie können von Funktionen erzeugt und als Ergebnis `return`t werden.\n" @@ -378,7 +378,7 @@ { "cell_type": "code", "execution_count": null, - "id": "67e640ce", + "id": "81e0ad89", "metadata": {}, "outputs": [], "source": [ @@ -393,7 +393,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a78dd669", + "id": "5491730c", "metadata": {}, "outputs": [], "source": [ @@ -403,7 +403,7 @@ { "cell_type": "code", "execution_count": null, - "id": "23b557af", + "id": "f39aa8b1", "metadata": {}, "outputs": [], "source": [ @@ -413,7 +413,7 @@ { "cell_type": "code", "execution_count": null, - "id": "440b7568", + "id": "4b708a03", "metadata": {}, "outputs": [], "source": [ @@ -422,7 +422,7 @@ }, { "cell_type": "markdown", - "id": "ab655f0f", + "id": "5c0d6771", "metadata": {}, "source": [ "Die obige Funktion `generate_add_func()` lässt sich auch kürzer definieren. Der innere Funktionsname `addx()` ist sowieso lokal und außerhalb nicht verfügbar. Also kann man eine anonyme Funktion verwenden.\n" @@ -431,7 +431,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d0b76e9c", + "id": "7817f2ff", "metadata": {}, "outputs": [], "source": [ @@ -440,7 +440,7 @@ }, { "cell_type": "markdown", - "id": "9dcb1129", + "id": "0cf5d3c0", "metadata": {}, "source": [ "## Zusammensetzung von Funktionen: die Operatoren $\\circ$ und `|>`\n", @@ -453,7 +453,7 @@ { "cell_type": "code", "execution_count": null, - "id": "fcaf335f", + "id": "cae2ce88", "metadata": {}, "outputs": [], "source": [ @@ -463,7 +463,7 @@ { "cell_type": "code", "execution_count": null, - "id": "48dd034e", + "id": "a16fb3c6", "metadata": {}, "outputs": [], "source": [ @@ -474,7 +474,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2ecd0bb3", + "id": "ed8ec445", "metadata": {}, "outputs": [], "source": [ @@ -483,7 +483,7 @@ }, { "cell_type": "markdown", - "id": "64c2f8ca", + "id": "6c6d5a5a", "metadata": {}, "source": [ "- Es gibt auch einen Operator, mit dem Funktionen \"von rechts\" wirken und zusammengesetzt werden können _(piping)_\n" @@ -492,7 +492,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8cdef694", + "id": "d32aaa8f", "metadata": {}, "outputs": [], "source": [ @@ -502,7 +502,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4fd01026", + "id": "c5b9236a", "metadata": {}, "outputs": [], "source": [ @@ -511,7 +511,7 @@ }, { "cell_type": "markdown", - "id": "d8c6e6f3", + "id": "2af53243", "metadata": {}, "source": [ "- Natürlich kann man auch diese Operatoren 'broadcasten' (s. @sec-broadcast). Hier wirkt ein Vektor von Funktionen elementweise auf einen Vektor von Argumenten:\n" @@ -520,7 +520,7 @@ { "cell_type": "code", "execution_count": null, - "id": "94691aad", + "id": "4ea2ad9f", "metadata": {}, "outputs": [], "source": [ @@ -529,7 +529,7 @@ }, { "cell_type": "markdown", - "id": "f4b75c54", + "id": "f941ceb5", "metadata": {}, "source": [ "## Die `do`-Notation\n", @@ -552,7 +552,7 @@ { "cell_type": "code", "execution_count": null, - "id": "76c02df9", + "id": "a6620e38", "metadata": {}, "outputs": [], "source": [ @@ -563,7 +563,7 @@ }, { "cell_type": "markdown", - "id": "a708ad3e", + "id": "26486b16", "metadata": {}, "source": [ "Der Sinn besteht natürlich in der Anwendung mit komplexeren Funktionen, wie diesem aus zwei Teilstücken zusammengesetzten Integranden:\n" @@ -572,7 +572,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e3012c9b", + "id": "53714315", "metadata": {}, "outputs": [], "source": [ @@ -589,7 +589,7 @@ }, { "cell_type": "markdown", - "id": "c38a800c", + "id": "c973f2c1", "metadata": {}, "source": [ "## Funktionsartige Objekte\n", @@ -600,7 +600,7 @@ { "cell_type": "code", "execution_count": null, - "id": "5de4f59a", + "id": "73cc94fd", "metadata": {}, "outputs": [], "source": [ @@ -617,7 +617,7 @@ }, { "cell_type": "markdown", - "id": "8b0b62a3", + "id": "99427b65", "metadata": {}, "source": [ "Die folgende Methode macht diese Struktur `callable`.\n" @@ -626,7 +626,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0a5cb287", + "id": "94bbfd15", "metadata": {}, "outputs": [], "source": [ @@ -637,7 +637,7 @@ }, { "cell_type": "markdown", - "id": "a5149012", + "id": "b13ba4a8", "metadata": {}, "source": [ "Jetzt kann man die Objekte, wenn gewünscht, auch wie Funktionen verwenden.\n" @@ -646,7 +646,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b271dbf1", + "id": "9b490828", "metadata": {}, "outputs": [], "source": [ @@ -655,7 +655,7 @@ }, { "cell_type": "markdown", - "id": "b355c1b0", + "id": "bff0bff7", "metadata": {}, "source": [ "## Operatoren und spezielle Formen\n", @@ -666,7 +666,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4f71f917", + "id": "da10ff9f", "metadata": {}, "outputs": [], "source": [ @@ -676,7 +676,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b19e79cf", + "id": "177a174d", "metadata": {}, "outputs": [], "source": [ @@ -686,7 +686,7 @@ { "cell_type": "code", "execution_count": null, - "id": "869917d4", + "id": "f0f52152", "metadata": {}, "outputs": [], "source": [ @@ -695,7 +695,7 @@ }, { "cell_type": "markdown", - "id": "490bceac", + "id": "39178d6d", "metadata": {}, "source": [ "- Auch Konstruktionen wie `x[i]`, `a.x`, `[x; y]` werden vom Parser zu Funktionsaufrufen umgewandelt.\n", @@ -755,7 +755,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4d92cc97", + "id": "419bcd07", "metadata": {}, "outputs": [], "source": [ @@ -764,7 +764,7 @@ }, { "cell_type": "markdown", - "id": "ec6b89f6", + "id": "3b37d178", "metadata": {}, "source": [ "werden vom Parser in eine Baumstruktur überführt.\n" @@ -773,7 +773,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9f607850", + "id": "7e5bd52c", "metadata": {}, "outputs": [], "source": [ @@ -784,7 +784,7 @@ }, { "cell_type": "markdown", - "id": "68328dda", + "id": "d26e9cbc", "metadata": {}, "source": [ "- Die Auswertung solcher Ausdrücke wird durch \n", @@ -802,7 +802,7 @@ { "cell_type": "code", "execution_count": null, - "id": "71fdbe34", + "id": "3faed089", "metadata": {}, "outputs": [], "source": [ @@ -812,7 +812,7 @@ { "cell_type": "code", "execution_count": null, - "id": "fc26727a", + "id": "559f6beb", "metadata": {}, "outputs": [], "source": [ @@ -821,7 +821,7 @@ }, { "cell_type": "markdown", - "id": "0253c57a", + "id": "115f7493", "metadata": {}, "source": [ "Zuweisungen wie `=`, `+=`, `*=`,... sind gleichrangig und rechtsassoziativ.\n" @@ -830,7 +830,7 @@ { "cell_type": "code", "execution_count": null, - "id": "7f9891ea", + "id": "72456757", "metadata": {}, "outputs": [], "source": [ @@ -846,16 +846,16 @@ }, { "cell_type": "markdown", - "id": "9eeccc4c", + "id": "a716bc08", "metadata": {}, "source": [ - "Natürlich kann man die Assoziativität in Julia auch abfragen. Die entsprechenden Funktionen werden nicht expizit aus dem `Base`-Modul exportiert, deshalb muss man den Modulnamen beim Aufruf angeben. \n" + "Natürlich kann man die Assoziativität in Julia auch abfragen. Die entsprechenden Funktionen werden nicht explizit aus dem `Base`-Modul exportiert, deshalb muss man den Modulnamen beim Aufruf angeben. \n" ] }, { "cell_type": "code", "execution_count": null, - "id": "23fe3c28", + "id": "f2317e6a", "metadata": {}, "outputs": [], "source": [ @@ -867,7 +867,7 @@ }, { "cell_type": "markdown", - "id": "148b459a", + "id": "3a7e3a79", "metadata": {}, "source": [ "Also ist der Potenzoperator rechtsassoziativ.\n" @@ -876,7 +876,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d1ad2685", + "id": "21fe9789", "metadata": {}, "outputs": [], "source": [ @@ -885,7 +885,7 @@ }, { "cell_type": "markdown", - "id": "86c59c17", + "id": "0d333e68", "metadata": {}, "source": [ "### Vorrang\n", @@ -896,7 +896,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9c97eee7", + "id": "e5ad39a5", "metadata": {}, "outputs": [], "source": [ @@ -908,7 +908,7 @@ }, { "cell_type": "markdown", - "id": "177ecf6d", + "id": "4decdf33", "metadata": {}, "source": [ "- 11 ist kleiner als 12, also geht 'Punktrechnung vor Strichrechnung'\n", @@ -919,7 +919,7 @@ { "cell_type": "code", "execution_count": null, - "id": "30c88bf2", + "id": "9450f974", "metadata": {}, "outputs": [], "source": [ @@ -932,7 +932,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b4a0a3ee", + "id": "d631e121", "metadata": {}, "outputs": [], "source": [ @@ -942,7 +942,7 @@ }, { "cell_type": "markdown", - "id": "0384575c", + "id": "0969d330", "metadata": {}, "source": [ "Nochmal zum Beispiel vom Anfang von @sec-vorrang:\n" @@ -951,7 +951,7 @@ { "cell_type": "code", "execution_count": null, - "id": "56488075", + "id": "107124d7", "metadata": {}, "outputs": [], "source": [ @@ -961,7 +961,7 @@ { "cell_type": "code", "execution_count": null, - "id": "543e7874", + "id": "420964a2", "metadata": {}, "outputs": [], "source": [ @@ -973,7 +973,7 @@ }, { "cell_type": "markdown", - "id": "bcb7fc77", + "id": "9c17c3e7", "metadata": {}, "source": [ "Nach diesen Vorrangregeln wird der Beispielausdruck also wie folgt ausgewertet:\n" @@ -982,7 +982,7 @@ { "cell_type": "code", "execution_count": null, - "id": "89af1388", + "id": "43b21b33", "metadata": {}, "outputs": [], "source": [ @@ -991,7 +991,7 @@ }, { "cell_type": "markdown", - "id": "509a3955", + "id": "2d52102a", "metadata": {}, "source": [ "(Das entspricht natürlich dem oben gezeigten *parse-tree*)\n", @@ -1021,7 +1021,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c134b798", + "id": "a4465163", "metadata": {}, "outputs": [], "source": [ @@ -1030,7 +1030,7 @@ }, { "cell_type": "markdown", - "id": "aafaa2d1", + "id": "1529af73", "metadata": {}, "source": [ "::: \n", @@ -1045,7 +1045,7 @@ { "cell_type": "code", "execution_count": null, - "id": "61fc5df5", + "id": "8dbccf82", "metadata": {}, "outputs": [], "source": [ @@ -1055,7 +1055,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8c609c3b", + "id": "26415d53", "metadata": {}, "outputs": [], "source": [ @@ -1066,7 +1066,7 @@ { "cell_type": "code", "execution_count": null, - "id": "44a6345d", + "id": "b07aabae", "metadata": {}, "outputs": [], "source": [ @@ -1076,7 +1076,7 @@ { "cell_type": "code", "execution_count": null, - "id": "660dfb1f", + "id": "09f3ecc4", "metadata": {}, "outputs": [], "source": [ @@ -1085,7 +1085,7 @@ }, { "cell_type": "markdown", - "id": "0fecdb42", + "id": "d1e4bc70", "metadata": {}, "source": [ "- Funktionsanwendung `f(...)` hat Vorrang vor allen Operatoren\n" @@ -1094,7 +1094,7 @@ { "cell_type": "code", "execution_count": null, - "id": "198bb0f8", + "id": "a9c32959", "metadata": {}, "outputs": [], "source": [ @@ -1103,7 +1103,7 @@ }, { "cell_type": "markdown", - "id": "f153e028", + "id": "e9915990", "metadata": {}, "source": [ "### Zusätzliche Operatoren\n", @@ -1126,15 +1126,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.8.5", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.8" - }, - "language_info": { - "file_extension": ".jl", - "mimetype": "application/julia", - "name": "julia", - "version": "1.8.5" + "name": "julia-1.10" } }, "nbformat": 4, diff --git a/nb/Erste_Bsp.ipynb b/nb/Erste_Bsp.ipynb index 44381b0..83ce8e0 100644 --- a/nb/Erste_Bsp.ipynb +++ b/nb/Erste_Bsp.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "9bb241ad", + "id": "f21dc71b", "metadata": {}, "source": [ "# Erste Miniprogramme\n", @@ -72,7 +72,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b5ec6b90", + "id": "44d0f59e", "metadata": {}, "outputs": [], "source": [ @@ -87,7 +87,7 @@ }, { "cell_type": "markdown", - "id": "e4de7d69", + "id": "4d9f5b4f", "metadata": {}, "source": [ ":::\n", @@ -102,7 +102,7 @@ { "cell_type": "code", "execution_count": null, - "id": "772bbe68", + "id": "9d36a90d", "metadata": {}, "outputs": [], "source": [ @@ -111,7 +111,7 @@ }, { "cell_type": "markdown", - "id": "b9b95d73", + "id": "71a52de7", "metadata": {}, "source": [ ":::\n", @@ -151,7 +151,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c0730a2a", + "id": "15983324", "metadata": {}, "outputs": [], "source": [ @@ -170,7 +170,7 @@ }, { "cell_type": "markdown", - "id": "1caa208b", + "id": "7cafe59e", "metadata": {}, "source": [ ":::\n", @@ -180,7 +180,7 @@ { "cell_type": "code", "execution_count": null, - "id": "72341556", + "id": "82139e32", "metadata": {}, "outputs": [], "source": [ @@ -192,7 +192,7 @@ }, { "cell_type": "markdown", - "id": "5eeb2626", + "id": "1467ade0", "metadata": {}, "source": [ "Im Sinne der Aufgabe wenden wir die Funktion wiederholt an:\n" @@ -201,7 +201,7 @@ { "cell_type": "code", "execution_count": null, - "id": "da47c136", + "id": "2a91c9da", "metadata": {}, "outputs": [], "source": [ @@ -214,7 +214,7 @@ }, { "cell_type": "markdown", - "id": "e67b1670", + "id": "1399219b", "metadata": {}, "source": [ "... und haben hier einen der '89er Zyklen' getroffen.\n", @@ -232,7 +232,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3868d34e", + "id": "8b76324d", "metadata": {}, "outputs": [], "source": [ @@ -248,7 +248,7 @@ }, { "cell_type": "markdown", - "id": "10ce44d1", + "id": "06d73770", "metadata": {}, "source": [ ":::\n", @@ -259,7 +259,7 @@ { "cell_type": "code", "execution_count": null, - "id": "54521e6a", + "id": "7a0051f2", "metadata": {}, "outputs": [], "source": [ @@ -274,7 +274,7 @@ }, { "cell_type": "markdown", - "id": "4a545b8c", + "id": "000b5826", "metadata": {}, "source": [ "Zahlen, bei denen die iterierte Quadratquersummenbildung bei 1 endet, heißen übrigens [fröhliche Zahlen](https://de.wikipedia.org/wiki/Fr%C3%B6hliche_Zahl) und wir haben gerade die Anzahl der traurigen Zahlen kleiner als 10.000.000 berechnet.\n", @@ -288,7 +288,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a7253bc1", + "id": "db3ef4ef", "metadata": {}, "outputs": [], "source": [ @@ -322,7 +322,7 @@ }, { "cell_type": "markdown", - "id": "772bec11", + "id": "8d2084be", "metadata": {}, "source": [ ":::" @@ -331,9 +331,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.8.5", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.8" + "name": "julia-1.10" } }, "nbformat": 4, diff --git a/nb/Pi2.ipynb b/nb/Pi2.ipynb index 89f002c..5f89df1 100644 --- a/nb/Pi2.ipynb +++ b/nb/Pi2.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "raw", - "id": "9d63401b", + "id": "9e1ef849", "metadata": {}, "source": [ "---\n", @@ -18,7 +18,7 @@ }, { "cell_type": "markdown", - "id": "405d242e", + "id": "beff12c8", "metadata": {}, "source": [ "# Ein Beispiel zur Stabilität von Gleitkommaarithmetik\n", @@ -29,7 +29,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f17a5fcb", + "id": "a7810264", "metadata": {}, "outputs": [], "source": [ @@ -84,7 +84,7 @@ }, { "cell_type": "markdown", - "id": "7745166c", + "id": "8d4bd1ab", "metadata": {}, "source": [ "Eine untere Schranke für $2\\pi$, den Umfang des Einheitskreises, erhält man durch die\n", @@ -151,7 +151,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d83237c5", + "id": "3f238690", "metadata": {}, "outputs": [], "source": [ @@ -186,7 +186,7 @@ }, { "cell_type": "markdown", - "id": "dcdecd41", + "id": "0c0178f5", "metadata": {}, "source": [ "Während Iteration B sich stabilisiert bei einem innerhalb der Maschinengenauigkeit korrekten Wert für π, wird Iteration A schnell instabil. Ein Plot der relativen Fehler $\\epsilon_i$ bestätigt das:\n" @@ -195,7 +195,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4404adb1", + "id": "f415aab0", "metadata": {}, "outputs": [], "source": [ @@ -212,7 +212,7 @@ }, { "cell_type": "markdown", - "id": "ac5d56d5", + "id": "02116ab2", "metadata": {}, "source": [ "## Stabilität und Auslöschung\n", @@ -223,7 +223,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e807fa2b", + "id": "3d50cba2", "metadata": {}, "outputs": [], "source": [ @@ -232,7 +232,7 @@ }, { "cell_type": "markdown", - "id": "68979310", + "id": "5ba088ba", "metadata": {}, "source": [ "Weitere Iterationen verbessern das Ergebnis nicht mehr. Sie stabilisieren sich bei einem relativen Fehler von etwa 2.5 Maschinenepsilon:\n" @@ -241,7 +241,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6a9f7b29", + "id": "2bcae61d", "metadata": {}, "outputs": [], "source": [ @@ -250,7 +250,7 @@ }, { "cell_type": "markdown", - "id": "09be0e03", + "id": "0bfd8235", "metadata": {}, "source": [ "Die Form Iteration A ist instabil. Bereits bei $i=16$ beginnt der relative Fehler wieder zu wachsen.\n", @@ -262,7 +262,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2ccb85ad", + "id": "365d4c27", "metadata": {}, "outputs": [], "source": [ @@ -283,7 +283,7 @@ }, { "cell_type": "markdown", - "id": "27616d4d", + "id": "04736a02", "metadata": {}, "source": [ "Man sieht die Abnahme der Zahl der signifikanten Ziffern. Man sieht auch, dass eine Verwendung von `BigFloat` mit einer Mantissenlänge von hier 80 Bit das Einsetzen des Auslöschungseffekts nur etwas hinaussschieben kann. \n", @@ -303,9 +303,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.8.5", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.8" + "name": "julia-1.10" } }, "nbformat": 4, diff --git a/nb/first_contact.ipynb b/nb/first_contact.ipynb index d59d129..10d6885 100644 --- a/nb/first_contact.ipynb +++ b/nb/first_contact.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "e009ef80", + "id": "65cc0031", "metadata": {}, "source": [ "# First Contact\n", @@ -16,7 +16,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b488cb23", + "id": "f9151e6d", "metadata": {}, "outputs": [], "source": [ @@ -45,7 +45,7 @@ }, { "cell_type": "markdown", - "id": "76000398", + "id": "3c611742", "metadata": {}, "source": [ "Berechne $\\qquad 12^{1/3} + \\frac{3\\sqrt{2}}{\\sin(0.5)-\\cos(\\frac{\\pi}{4})\\log(3)}+ e^5$\n" @@ -54,7 +54,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0f9feb86", + "id": "fd02456e", "metadata": {}, "outputs": [], "source": [ @@ -63,7 +63,7 @@ }, { "cell_type": "markdown", - "id": "3e9fad84", + "id": "9ce12c0f", "metadata": {}, "source": [ "Man beachte:\n", @@ -74,7 +74,7 @@ "- Das Multiplikationszeichen `a*b` kann nach einer Zahl weggelassen werden, wenn eine Variable, Funktion oder Klammer folgt.\n", "\n", "\n", - "## Die wichtigsten Tasten: `Tab` und `?`\n", + "## Die wichtigsten Tasten: `Tab` und `?` {#sec-tab}\n", "\n", "Man drücke beim Programmieren immer wieder die Tabulatortaste, sobald 2...3 Buchstaben eines Wortes getippt sind. Es werden dann mögliche Ergänzungen angezeigt bzw. ergänzt, wenn die Ergänzung eindeutig ist. Das spart Zeit und bildet ungemein:\n" ] @@ -82,7 +82,7 @@ { "cell_type": "code", "execution_count": null, - "id": "734300ba", + "id": "e2ca6f27", "metadata": {}, "outputs": [], "source": [ @@ -93,7 +93,7 @@ { "cell_type": "code", "execution_count": null, - "id": "155bc575", + "id": "9fdfabe6", "metadata": {}, "outputs": [], "source": [ @@ -103,7 +103,7 @@ }, { "cell_type": "markdown", - "id": "ba74dc32", + "id": "d8ecd73b", "metadata": {}, "source": [ "Die eingebaute Julia-Hilfe `?name` zu allen Funktionen und Konstrukten ist sehr umfassend. Hier ein eher kurzes Beispiel: \n" @@ -112,7 +112,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1b941a97", + "id": "9ba34e9d", "metadata": {}, "outputs": [], "source": [ @@ -121,7 +121,7 @@ }, { "cell_type": "markdown", - "id": "c8f7da7b", + "id": "c798d174", "metadata": {}, "source": [ ":::{.content-hidden unless-format=\"xxx\"}\n", @@ -160,7 +160,7 @@ { "cell_type": "code", "execution_count": null, - "id": "da1dc7ec", + "id": "2f60e4e5", "metadata": {}, "outputs": [], "source": [ @@ -170,7 +170,7 @@ }, { "cell_type": "markdown", - "id": "37b29541", + "id": "20819c0a", "metadata": {}, "source": [ "Im interaktiven Betrieb zeigt Julia das Ergebnis der letzten Operation an.\n", @@ -201,7 +201,7 @@ { "cell_type": "code", "execution_count": null, - "id": "173f7324", + "id": "2874204c", "metadata": {}, "outputs": [], "source": [ @@ -214,7 +214,7 @@ }, { "cell_type": "markdown", - "id": "13a8984f", + "id": "d5343251", "metadata": {}, "source": [ "Die Standard-Gleitkommazahl hat eine Länge von 64 Bit, entspricht also einer `double` in C/C++/Java.\n", @@ -227,7 +227,7 @@ { "cell_type": "code", "execution_count": null, - "id": "cd3b3e96", + "id": "544f8fe6", "metadata": {}, "outputs": [], "source": [ @@ -242,7 +242,7 @@ }, { "cell_type": "markdown", - "id": "eae463bf", + "id": "b1734df1", "metadata": {}, "source": [ "## Druckanweisungen\n", @@ -252,7 +252,7 @@ { "cell_type": "code", "execution_count": null, - "id": "df98312b", + "id": "b44d0f53", "metadata": {}, "outputs": [], "source": [ @@ -266,7 +266,7 @@ }, { "cell_type": "markdown", - "id": "b74dcb3f", + "id": "3baa2a89", "metadata": {}, "source": [ "Beide Funkionen können als Argument eine Liste von *strings* und Variablen bekommen. Man kann Variablen auch in *strings* einbetten, indem man dem Variablennamen ein Dollarzeichen voranstellt *(string interpolation)*.\n" @@ -275,7 +275,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3b76d855", + "id": "fa3b2601", "metadata": {}, "outputs": [], "source": [ @@ -288,7 +288,7 @@ }, { "cell_type": "markdown", - "id": "c06fc5da", + "id": "fe3b44d2", "metadata": {}, "source": [ ":::{.callout-note .titlenormal collapse=true icon=false }\n", @@ -300,7 +300,7 @@ { "cell_type": "code", "execution_count": null, - "id": "00a46544", + "id": "198c1231", "metadata": {}, "outputs": [], "source": [ @@ -309,7 +309,7 @@ }, { "cell_type": "markdown", - "id": "3ba46a2c", + "id": "847182e6", "metadata": {}, "source": [ ":::\n", @@ -321,7 +321,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6e83b8e2", + "id": "8c4c8af3", "metadata": {}, "outputs": [], "source": [ @@ -334,7 +334,7 @@ }, { "cell_type": "markdown", - "id": "6ae72d3a", + "id": "270a968d", "metadata": {}, "source": [ "Nach ihrer Definition kann die Funktion benutzt (aufgerufen) werden. Die in der Definition verwendeten Variablen `a,b,c,c2` sind lokale Variablen und stehen außerhalb der Funktionsdefinition nicht zur Verfügung. \n" @@ -343,7 +343,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2b68ec32", + "id": "aeb1b763", "metadata": {}, "outputs": [], "source": [ @@ -356,7 +356,7 @@ }, { "cell_type": "markdown", - "id": "d62b25c3", + "id": "83623a5d", "metadata": {}, "source": [ "Sehr einfache Funktionen können auch als Einzeiler definiert werden.\n" @@ -365,7 +365,7 @@ { "cell_type": "code", "execution_count": null, - "id": "436bf54a", + "id": "bb93d920", "metadata": {}, "outputs": [], "source": [ @@ -374,7 +374,7 @@ }, { "cell_type": "markdown", - "id": "13485711", + "id": "28cfec18", "metadata": {}, "source": [ "## Tests\n", @@ -384,7 +384,7 @@ { "cell_type": "code", "execution_count": null, - "id": "fbfc37d5", + "id": "a778d1c9", "metadata": {}, "outputs": [], "source": [ @@ -394,7 +394,7 @@ }, { "cell_type": "markdown", - "id": "d43e3179", + "id": "43717a30", "metadata": {}, "source": [ "Neben den üblichen arithmetischen Vergleichen `==, !=, <, <= ,> ,>=` \n", @@ -404,7 +404,7 @@ { "cell_type": "code", "execution_count": null, - "id": "7e289c8e", + "id": "b425b2bf", "metadata": {}, "outputs": [], "source": [ @@ -416,7 +416,7 @@ }, { "cell_type": "markdown", - "id": "0ca8fc84", + "id": "b8b63af7", "metadata": {}, "source": [ "## Verzweigungen\n", @@ -437,7 +437,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6ab36f93", + "id": "759c7b60", "metadata": {}, "outputs": [], "source": [ @@ -453,7 +453,7 @@ }, { "cell_type": "markdown", - "id": "3247aa40", + "id": "92f05a99", "metadata": {}, "source": [ "Einrückungen verbessern die Lesbarkeit, sind aber fakultativ. Zeilenumbrüche trennen Anweisungen. Das ist auch durch Semikolon möglich. Obiger Codeblock ist für Julia identisch zu folgender Zeile:\n" @@ -462,7 +462,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6b6f3846", + "id": "75c38c3c", "metadata": {}, "outputs": [], "source": [ @@ -472,7 +472,7 @@ }, { "cell_type": "markdown", - "id": "4f8718ea", + "id": "6c916fa7", "metadata": {}, "source": [ "Es wird dringend empfohlen, von Anfang an den eigenen Code übersichtlich mit sauberen Einrückungen zu formatieren!\n", @@ -494,7 +494,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e2518e65", + "id": "8f6ff3c3", "metadata": {}, "outputs": [], "source": [ @@ -507,7 +507,7 @@ }, { "cell_type": "markdown", - "id": "3fa36879", + "id": "6ba98544", "metadata": {}, "source": [ "## Arrays\n", @@ -518,7 +518,7 @@ { "cell_type": "code", "execution_count": null, - "id": "cf56b9fc", + "id": "bde3f18d", "metadata": {}, "outputs": [], "source": [ @@ -528,7 +528,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2e6ae1f4", + "id": "ab7ae1b1", "metadata": {}, "outputs": [], "source": [ @@ -538,7 +538,7 @@ { "cell_type": "code", "execution_count": null, - "id": "18a71a80", + "id": "cd6f6101", "metadata": {}, "outputs": [], "source": [ @@ -548,7 +548,7 @@ }, { "cell_type": "markdown", - "id": "6833c60b", + "id": "4cd8e309", "metadata": {}, "source": [ "Man kann leere Vektoren anlegen und sie verlängern.\n" @@ -557,7 +557,7 @@ { "cell_type": "code", "execution_count": null, - "id": "49a0d406", + "id": "4e643897", "metadata": {}, "outputs": [], "source": [ @@ -569,7 +569,7 @@ }, { "cell_type": "markdown", - "id": "ca3e6d8e", + "id": "d3e2209e", "metadata": {}, "source": [ ":::{.callout-note icon=\"false\" .titlenormal collapse=\"true\" font-variant-ligatures=\"no-contextual\" }\n", @@ -580,7 +580,7 @@ { "cell_type": "code", "execution_count": null, - "id": "087b10f7", + "id": "8bb956d4", "metadata": {}, "outputs": [], "source": [ @@ -600,7 +600,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0b8be63e", + "id": "a417e43d", "metadata": {}, "outputs": [], "source": [ @@ -609,7 +609,7 @@ }, { "cell_type": "markdown", - "id": "cd067cf0", + "id": "71efa254", "metadata": {}, "source": [ ":::" @@ -618,9 +618,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.8.5", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.8" + "name": "julia-1.10" } }, "nbformat": 4, diff --git a/nb/numerictypes.ipynb b/nb/numerictypes.ipynb index d407b74..9fd8218 100644 --- a/nb/numerictypes.ipynb +++ b/nb/numerictypes.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "3a993968", + "id": "24a532a6", "metadata": {}, "source": [ "# Maschinenzahlen\n" @@ -11,7 +11,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4f4dbb6a", + "id": "d7654522", "metadata": {}, "outputs": [], "source": [ @@ -23,7 +23,7 @@ }, { "cell_type": "markdown", - "id": "82bbdd01", + "id": "0a0f532c", "metadata": {}, "source": [ "## Ganze Zahlen *(integers)*\n", @@ -41,16 +41,14 @@ { "cell_type": "code", "execution_count": null, - "id": "ab84c4da", + "id": "9d1aa3b9", "metadata": {}, "outputs": [], - "source": [ - "subtypes(Unsigned)" - ] + "source": [] }, { "cell_type": "markdown", - "id": "7f458fcd", + "id": "1668b3fb", "metadata": {}, "source": [ "UInts sind Binärzahlen mit n=8, 16, 32, 64 oder 128 Bits Länge und einem entsprechenden Wertebereich von\n", @@ -63,20 +61,14 @@ { "cell_type": "code", "execution_count": null, - "id": "3b6b30a0", + "id": "7e8f2435", "metadata": {}, "outputs": [], - "source": [ - "x = 0x0033efef\n", - "@show x typeof(x) Int(x)\n", - "\n", - "z = UInt(32)\n", - "@show z typeof(z);" - ] + "source": [] }, { "cell_type": "markdown", - "id": "25774520", + "id": "e472b90c", "metadata": {}, "source": [ "### *Signed Integers* \n" @@ -85,16 +77,14 @@ { "cell_type": "code", "execution_count": null, - "id": "341e9267", + "id": "8f1272d6", "metadata": {}, "outputs": [], - "source": [ - "subtypes(Signed)" - ] + "source": [] }, { "cell_type": "markdown", - "id": "a8ea7009", + "id": "eab3eaca", "metadata": {}, "source": [ "*Integers* haben den Wertebereich\n", @@ -109,17 +99,14 @@ { "cell_type": "code", "execution_count": null, - "id": "79490021", + "id": "af6239db", "metadata": {}, "outputs": [], - "source": [ - "x = 42\n", - "typeof(x)" - ] + "source": [] }, { "cell_type": "markdown", - "id": "295048cd", + "id": "04f5044e", "metadata": {}, "source": [ "Sie haben daher den Wertebereich: \n", @@ -127,6 +114,26 @@ "-9.223.372.036.854.775.808 \\le x \\le 9.223.372.036.854.775.807\n", "$$\n", "\n", + "32-Bit-Integers haben den Wertebereich \n", + "$$\n", + "-2.147.483.648 \\le x \\le 2.147.483.647\n", + "$$\n", + "Der Maximalwert $2^{31}-1$ is zufällig gerade eine Mersenne-Primzahl:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3f219052", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "fde7b29b", + "metadata": {}, + "source": [ "Negative Zahlen werden im Zweierkomplement dargestellt:\n", "\n", "$x \\Rightarrow -x$ entspricht: _flip all bits, then add 1_\n", @@ -150,39 +157,35 @@ { "cell_type": "code", "execution_count": null, - "id": "677353d7", + "id": "7578aa32", "metadata": {}, "outputs": [], - "source": [ - "x = 2^62 - 10 + 2^62" - ] + "source": [] }, { "cell_type": "code", "execution_count": null, - "id": "7da20d70", + "id": "d0ef29dd", "metadata": {}, "outputs": [], - "source": [ - "x + 20" - ] + "source": [] }, { "cell_type": "markdown", - "id": "2cdce6d7", + "id": "e78ca374", "metadata": {}, "source": [ "Keine Fehlermeldung, keine Warnung! Ganzzahlen fester Länge liegen nicht auf einer Geraden, sondern auf einem Kreis!\n", "\n", ":::\n", "\n", - "Schauen wir uns ein paar *Integers* mal an:\n" + "Schauen wir uns ein paar *Integers* an:\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "098d82f4", + "id": "4ee2d6c8", "metadata": {}, "outputs": [], "source": [ @@ -197,36 +200,34 @@ }, { "cell_type": "markdown", - "id": "388bed6e", + "id": "b8640e2b", "metadata": {}, "source": [ - "... und noch etwas mehr *introspection*:\n" + "Julia hat Funktionen, die über die Datentypen informieren (*introspection*):\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "e164bb25", + "id": "1ac371fb", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2dcf1ad6", "metadata": {}, "outputs": [], "source": [ - "typemin(Int64), typemax(Int64)" + "typemin(UInt64), typemax(UInt64), BigInt(typemax(UInt64))" ] }, { "cell_type": "code", "execution_count": null, - "id": "2c94b3df", - "metadata": {}, - "outputs": [], - "source": [ - "typemin(UInt64), typemax(UInt64)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1d2f77c9", + "id": "e56ba2ac", "metadata": {}, "outputs": [], "source": [ @@ -235,7 +236,7 @@ }, { "cell_type": "markdown", - "id": "74d88d56", + "id": "8d38072e", "metadata": {}, "source": [ "## Arithmetik ganzer Zahlen\n", @@ -253,7 +254,7 @@ { "cell_type": "code", "execution_count": null, - "id": "46b5e26a", + "id": "e10e1e7b", "metadata": {}, "outputs": [], "source": [ @@ -262,7 +263,7 @@ }, { "cell_type": "markdown", - "id": "0187fb1e", + "id": "9f170e32", "metadata": {}, "source": [ "- Für natürliche Exponenten wird [*exponentiation by squaring*](https://de.wikipedia.org/wiki/Bin%C3%A4re_Exponentiation) verwendet, so dass z.B. `x^23` nur 7 Multiplikationen benötigt: \n", @@ -278,16 +279,14 @@ { "cell_type": "code", "execution_count": null, - "id": "67cb4661", + "id": "ce734b5f", "metadata": {}, "outputs": [], - "source": [ - "x = 40/5" - ] + "source": [] }, { "cell_type": "markdown", - "id": "94408807", + "id": "bc0af941", "metadata": {}, "source": [ "#### Ganzzahldivision und Rest\n", @@ -300,19 +299,14 @@ { "cell_type": "code", "execution_count": null, - "id": "3ccdabcf", + "id": "8e496544", "metadata": {}, "outputs": [], - "source": [ - "@show divrem( 27, 4)\n", - "@show ( 27 ÷ 4, 27 % 4) \n", - "@show (-27 ÷ 4, -27 % 4 )\n", - "@show ( 27 ÷ -4, 27 % -4);" - ] + "source": [] }, { "cell_type": "markdown", - "id": "5222cddb", + "id": "2efcbcdb", "metadata": {}, "source": [ "- Eine von `RoundToZero` abweichende Rundungsregel kann bei den Funktionen als optionales 3. Argument angegeben werden. \n", @@ -323,7 +317,7 @@ { "cell_type": "code", "execution_count": null, - "id": "be29f9d4", + "id": "1a64561b", "metadata": {}, "outputs": [], "source": [ @@ -334,7 +328,7 @@ }, { "cell_type": "markdown", - "id": "84e604f7", + "id": "f4c504dc", "metadata": {}, "source": [ "Für alle Rundungsregeln gilt:\n", @@ -352,7 +346,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ad97d8a3", + "id": "6e5e2595", "metadata": {}, "outputs": [], "source": [ @@ -368,7 +362,7 @@ }, { "cell_type": "markdown", - "id": "b7da46f1", + "id": "c959faa9", "metadata": {}, "source": [ "Meist wird man allerdings den Datentyp `BigInt` explizit anfordern müssen, damit nicht modulo $2^{64}$ gerechnet wird:\n" @@ -377,16 +371,14 @@ { "cell_type": "code", "execution_count": null, - "id": "89d35c00", + "id": "1118bb76", "metadata": {}, "outputs": [], - "source": [ - "@show 3^300 BigInt(3)^300;" - ] + "source": [] }, { "cell_type": "markdown", - "id": "16d1d9cc", + "id": "0075815b", "metadata": {}, "source": [ "*Arbitrary precision arithmetic* kostet einiges an Speicherplatz und Rechenzeit.\n", @@ -397,7 +389,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d7e4a838", + "id": "5306bf40", "metadata": {}, "outputs": [], "source": [ @@ -410,7 +402,7 @@ }, { "cell_type": "markdown", - "id": "5df8fda6", + "id": "2d052b71", "metadata": {}, "source": [ "Einen ersten Eindruck vom Zeit- und Speicherbedarf gibt das `@time`-Macro:\n" @@ -419,7 +411,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e37fa19f", + "id": "18de4e6a", "metadata": {}, "outputs": [], "source": [ @@ -430,7 +422,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a58adeb1", + "id": "dc805fe6", "metadata": {}, "outputs": [], "source": [ @@ -440,7 +432,7 @@ }, { "cell_type": "markdown", - "id": "17081476", + "id": "0506b2d0", "metadata": {}, "source": [ "Durch die Just-in-Time-Compilation von Julia ist die einmalige Ausführung einer Funktion wenig aussagekräftig. Das Paket `BenchmarkTools` stellt u.a. das Macro `@benchmark` bereit, das eine Funktion mehrfach aufruft und die Ausführungszeiten als Histogramm darstellt.\n", @@ -451,19 +443,15 @@ { "cell_type": "code", "execution_count": null, - "id": "a5944727", + "id": "8235276b", "metadata": {}, "outputs": [], - "source": [ - "using BenchmarkTools\n", - "\n", - "@benchmark sum($vec_int)" - ] + "source": [] }, { "cell_type": "code", "execution_count": null, - "id": "eb32dbfa", + "id": "ee87e4ab", "metadata": {}, "outputs": [], "source": [ @@ -472,107 +460,21 @@ }, { "cell_type": "markdown", - "id": "11e20069", + "id": "a3e7ba45", "metadata": {}, "source": [ ":::\n", "Die `BigInt`-Addition ist mehr als 30 mal langsamer. \n", "\n", "\n", - "\n", - ":::{.content-hidden unless-format=\"xxx\"}\n", - "Die folgende Funktion soll die Summe aller Zahlen von 1 bis n mit der Arithmetik des Datentyps T berechnen.\n", - "Auf Grund der *type promotion rules* reicht es für `T ≥ Int64` dazu aus, die Akkumulatorvariable mit einer Zahl vom Typ T zu initialisieren. \n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ad42844a", - "metadata": {}, - "outputs": [], - "source": [ - "function mysum(n, T)\n", - " s = T(0)\n", - " for i = 1:n\n", - " s += i \n", - " end\n", - " return s\n", - "end" + "\n" ] }, { "cell_type": "markdown", - "id": "184457e8", + "id": "4a985f0b", "metadata": {}, "source": [ - "Einen ersten Eindruck vom Zeit- und Speicherbedarf gibt das `@time`-Macro:\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c92af0db", - "metadata": {}, - "outputs": [], - "source": [ - "@time x = mysum(10_000_000, Int64)\n", - "@show x typeof(x);" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e58be090", - "metadata": {}, - "outputs": [], - "source": [ - "@time x = mysum(10_000_000, BigInt)\n", - "@show x typeof(x);" - ] - }, - { - "cell_type": "markdown", - "id": "bfe545fd", - "metadata": {}, - "source": [ - "Durch die Just-in-Time-Compilation von Julia ist die einmalige Ausführung einer Funktion wenig aussagekräftig. Das Paket `BenchmarkTools` stellt u.a. das Macro `@benchmark` bereit, das eine Funktion mehrfach aufruft und die Ausführungszeiten als Histogramm darstellt.\n", - "\n", - ":::{.ansitight}\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3ae14185", - "metadata": {}, - "outputs": [], - "source": [ - "using BenchmarkTools\n", - "\n", - "@benchmark mysum(10_000_000, Int64)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d7513870", - "metadata": {}, - "outputs": [], - "source": [ - "@benchmark mysum(10_000_000, BigInt)" - ] - }, - { - "cell_type": "markdown", - "id": "4835712f", - "metadata": {}, - "source": [ - "Die Berechnung von $\\sum_{n=1}^{10000000} n$ dauert auf meinem PC mit den Standard-64bit-Integern im Schnitt 2 Nanosekunden, in *arbitrary precision arithmetic* über eine Sekunde, wobei auch noch fast 500MB Speicher allokiert werden. \n", - "\n", - ":::\n", - ":::\n", - "\n", "\n", "## Gleitkommazahlen\n", "\n", @@ -585,11 +487,21 @@ "### Grundidee \n", "\n", "- Eine „feste Anzahl von Vor- und Nachkommastellen“ ist für viele Probleme ungeeignet.\n", - "- Eine Trennung zwischen „gültigen Ziffern“ und Größenordnung wie in der wissenschaftlichen Notation\n", + "- Eine Trennung zwischen „gültigen Ziffern“ und Größenordnung (Mantisse und Exponent) wie in der wissenschaftlichen Notation ist wesentlich flexibler.\n", " $$ 345.2467 \\times 10^3\\qquad 34.52467\\times 10^4\\qquad \\underline{3.452467\\times 10^5}\\qquad 0.3452467\\times 10^6\\qquad 0.03452467\\times 10^7$$ \n", - " ist wesentlich flexibler. \n", - "- Zur Eindeutigkeit legt man fest: Die Darstellung mit genau einer Ziffer vor dem Komma ist die __Normalisierte Darstellung__.\n", - "- Bei Binärzahlen `1.01101`: ist diese Ziffer immer gleich Eins und man kann auf das Abspeichern dieser Ziffer verzichten.\n", + "- Zur Eindeutigkeit muss man eine dieser Formen auswählen. In der mathematischen Analyse von Maschinenzahlen wählt man oft die Form, bei der die erste Nachkommastelle ungleich Null ist. Damit gilt für die Mantisse $m$: \n", + "$$\n", + "1 < m \\le (0.1)_b = b^{-1},\n", + "$$ \n", + "wobei $b$ die gewählte Basis des Zahlensystems bezeichnet.\n", + "- Wir wählen im Folgenden die Form, die der tatsächlichen Implementation auf dem Computer entspricht und legen fest: \n", + "Die Darstellung mit genau einer Ziffer ungleich Null vor dem Komma ist die __Normalisierte Darstellung__. Damit gilt \n", + "$$\n", + " b< m \\le 1.\n", + "$$ \n", + "- Bei Binärzahlen `1.01101`: ist diese Ziffer immer gleich Eins und man kann auf das Abspeichern dieser Ziffer verzichten. Diese tatsächlich abgespeicherte (gekürzte) Mantisse bezeichnen wir mit $M$, so dass \n", + "$$m = 1 + M$$ \n", + "gilt. \n", "\n", "\n", ":::{.callout-note }\n", @@ -627,7 +539,7 @@ "- 11 Bits für den Exponenten, also $0\\le E \\le 2047$\n", "- die Werte $E=0$ und $E=(11111111111)_2=2047$ sind reserviert für die Codierung von Spezialwerten wie\n", "$\\pm0, \\pm\\infty$, NaN _(Not a Number)_ und denormalisierte Zahlen.\n", - "- 52 Bits für die Mantisse $M,\\quad 0\\le M<1$, das entspricht etwa 16 Dezimalstellen\n", + "- 52 Bits für die (gekürzte) Mantisse $M,\\quad 0\\le M<1$, das entspricht etwa 16 Dezimalstellen\n", "- Damit wird folgende Zahl dargestellt:\n", "$$ x=(-1)^S \\cdot(1+M)\\cdot 2^{E-1023}$$\n", "\n", @@ -637,17 +549,16 @@ { "cell_type": "code", "execution_count": null, - "id": "8433da22", + "id": "b353480a", "metadata": {}, "outputs": [], "source": [ - "x = 27.56640625\n", - "bitstring(x)" + "x = 27.56640625\n" ] }, { "cell_type": "markdown", - "id": "7be4f1fc", + "id": "14878920", "metadata": {}, "source": [ "Das geht auch schöner:\n" @@ -656,7 +567,7 @@ { "cell_type": "code", "execution_count": null, - "id": "98311a9b", + "id": "0417cf2a", "metadata": {}, "outputs": [], "source": [ @@ -673,7 +584,7 @@ }, { "cell_type": "markdown", - "id": "728867d2", + "id": "f7e57f81", "metadata": {}, "source": [ "und wir können S (in blau),E (grün) und M (rot) ablesen:\n", @@ -693,16 +604,14 @@ { "cell_type": "code", "execution_count": null, - "id": "f4403c1c", + "id": "1e357fb6", "metadata": {}, "outputs": [], - "source": [ - "x = (1 + 1/2 + 1/8 + 1/16 + 1/32 + 1/256 + 1/4096) * 2^4" - ] + "source": [] }, { "cell_type": "markdown", - "id": "9346d953", + "id": "d9982c45", "metadata": {}, "source": [ "- Die Maschinenzahlen 𝕄 bilden eine endliche, diskrete Untermenge von ℝ. Es gibt eine kleinste und eine größte Maschinenzahl und abgesehen davon haben alle x∈𝕄 einen Vorgänger und Nachfolger in 𝕄.\n", @@ -713,7 +622,7 @@ { "cell_type": "code", "execution_count": null, - "id": "be8c52e0", + "id": "749a668f", "metadata": {}, "outputs": [], "source": [ @@ -723,7 +632,7 @@ }, { "cell_type": "markdown", - "id": "165a8689", + "id": "60852e8d", "metadata": {}, "source": [ "Das kann man in Julia allerdings auch einfacher haben:\n" @@ -732,16 +641,14 @@ { "cell_type": "code", "execution_count": null, - "id": "3901ed32", + "id": "df856949", "metadata": {}, "outputs": [], - "source": [ - "y = nextfloat(x)" - ] + "source": [] }, { "cell_type": "markdown", - "id": "d8b2e005", + "id": "915240b8", "metadata": {}, "source": [ "Der Vorgänger von x ist:\n" @@ -750,7 +657,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ed502537", + "id": "7844705c", "metadata": {}, "outputs": [], "source": [ @@ -761,28 +668,26 @@ }, { "cell_type": "markdown", - "id": "973c7660", + "id": "4e9dcdfe", "metadata": {}, "source": [ "## Maschinenepsilon\n", "\n", "- Den Abstand zwischen `1` und dem Nachfolger `nextfloat(1)` nennt man [**Maschinenepsilon**](https://en.wikipedia.org/wiki/Machine_epsilon). \n", - "- Für `Float64` mit einer Mantissenlänge von 52 Bit, ist $\\epsilon=2^{-52}$.\n" + "- Für `Float64` mit einer Mantissenlänge von 52 Bit ist $\\epsilon=2^{-52}$.\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "53a4703b", + "id": "54f77992", "metadata": {}, "outputs": [], - "source": [ - "@show nextfloat(1.) - 1 2^-52 eps(Float64);" - ] + "source": [] }, { "cell_type": "markdown", - "id": "1b27e5f1", + "id": "efc48d58", "metadata": {}, "source": [ "- Das Maschinenepsilon ist ein Maß für den relativen Abstand zwischen den Maschinenzahlen und quantifiziert die Aussage: „64-Bit-Gleitkommazahlen haben eine Genauigkeit von etwa 16 Dezimalstellen.“\n", @@ -792,16 +697,14 @@ { "cell_type": "code", "execution_count": null, - "id": "6c6247c5", + "id": "bcbd1bcf", "metadata": {}, "outputs": [], - "source": [ - "floatmin(Float64)" - ] + "source": [] }, { "cell_type": "markdown", - "id": "ace02061", + "id": "93097822", "metadata": {}, "source": [ "- Ein Teil der Literatur verwendet eine andere Definition des Maschinenepsilons, die halb so groß ist. \n", @@ -819,21 +722,14 @@ { "cell_type": "code", "execution_count": null, - "id": "94351455", + "id": "5c96f36c", "metadata": {}, "outputs": [], - "source": [ - "Eps = 1\n", - "while(1 != 1 + Eps)\n", - " Eps /= 2\n", - " println(1+Eps)\n", - "end\n", - "Eps" - ] + "source": [] }, { "cell_type": "markdown", - "id": "ce03b152", + "id": "9c2d355d", "metadata": {}, "source": [ "oder als Bitmuster:\n" @@ -842,7 +738,7 @@ { "cell_type": "code", "execution_count": null, - "id": "de6c5e53", + "id": "0897f63f", "metadata": {}, "outputs": [], "source": [ @@ -856,9 +752,22 @@ }, { "cell_type": "markdown", - "id": "23b7914a", + "id": "5a2a1ae0", "metadata": {}, "source": [ + ":::\n", + "\n", + ":::{.callout-note}\n", + "## Die Menge der (normalisierten) Maschinenzahlen\n", + "\n", + "- Im Intervall $[1,2)$ liegen $2^{52}$ äquidistante Maschinenzahlen.\n", + "- Danach erhöht sich der Exponent um 1 und die Mantisse $M$ wird auf 0 zurückgesetzt. Damit enthält das Intervall $[2,4)$ wiederum $2^{52}$ äquidistante Maschinenzahlen, ebenso das Intervall $[4,8)$ bis hin zu $[2^{1023}, 2^{1024})$. \n", + "- Ebenso liegen in den Intervallen $\\ [\\frac{1}{2},1), \\ [\\frac{1}{4},\\frac{1}{2}),...$ je $2^{52}$ äquidistante Maschinenzahlen, bis hinunter zu $[2^{-1022}, 2^{-1021})$. \n", + "- Dies bildet die Menge $𝕄_+$ der positiven Maschinenzahlen und es ist\n", + "$$\n", + "𝕄 = -𝕄_+ \\cup \\{0\\} \\cup 𝕄_+\n", + "$$\n", + "\n", ":::\n", "\n", "Die größte und die kleinste positive normalisiert darstellbare Gleitkommazahl eines Gleitkommatyps kann man abfragen:\n" @@ -867,7 +776,7 @@ { "cell_type": "code", "execution_count": null, - "id": "10296953", + "id": "3c0a75bb", "metadata": {}, "outputs": [], "source": [ @@ -880,7 +789,7 @@ }, { "cell_type": "markdown", - "id": "ac56b395", + "id": "8bde2bbb", "metadata": {}, "source": [ "## Runden auf Maschinenzahlen\n", @@ -889,6 +798,11 @@ "- Standardrundungsregel: _round to nearest, ties to even_ \n", " Wenn man genau die Mitte zwischen zwei Maschinenzahlen trifft *(tie)*, wählt man die, deren letztes Mantissenbit 0 ist. \n", "- Begründung: damit wird statistisch in 50% der Fälle auf- und in 50% der Fälle abgerundet und so ein „statistischer Drift“ bei längeren Rechnungen vermieden. \n", + "- Es gilt:\n", + "$$\n", + "\\frac{|x-\\text{rd}(x)|}{|x|} \\le \\frac{1}{2} \\epsilon\n", + "$$\n", + "\n", "\n", "## Maschinenzahlarithmetik\n", "\n", @@ -912,26 +826,22 @@ { "cell_type": "code", "execution_count": null, - "id": "dbe01c9d", + "id": "24f9a783", "metadata": {}, "outputs": [], - "source": [ - "1 + 10^-16 + 10^-16 " - ] + "source": [] }, { "cell_type": "code", "execution_count": null, - "id": "cd4dea94", + "id": "c04afc52", "metadata": {}, "outputs": [], - "source": [ - "1 + (10^-16 + 10^-16)" - ] + "source": [] }, { "cell_type": "markdown", - "id": "c5f1bc1c", + "id": "0db90e88", "metadata": {}, "source": [ "Im ersten Fall (ohne Klammern) wird von links nach rechts ausgewertet:\n", @@ -969,7 +879,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d3d65d23", + "id": "221ec38c", "metadata": {}, "outputs": [], "source": [ @@ -979,7 +889,7 @@ }, { "cell_type": "markdown", - "id": "4941993c", + "id": "727318a8", "metadata": {}, "source": [ "Folge:\n" @@ -988,36 +898,30 @@ { "cell_type": "code", "execution_count": null, - "id": "c2d4306a", + "id": "37770ed0", "metadata": {}, "outputs": [], - "source": [ - "0.1 + 0.1 == 0.2" - ] + "source": [] }, { "cell_type": "code", "execution_count": null, - "id": "92671384", + "id": "8502b772", "metadata": {}, "outputs": [], - "source": [ - "0.2 + 0.1 == 0.3" - ] + "source": [] }, { "cell_type": "code", "execution_count": null, - "id": "a3ae81f9", + "id": "6b8f708e", "metadata": {}, "outputs": [], - "source": [ - "0.2 + 0.1" - ] + "source": [] }, { "cell_type": "markdown", - "id": "2ea75313", + "id": "2fa26d1a", "metadata": {}, "source": [ "Bei der Ausgabe einer Maschinenzahl muss der Binärbruch in einen Dezimalbruch entwickelt werden. Man kann sich auch mehr Stellen dieser Dezimalbruchentwicklung anzeigen lassen: \n" @@ -1026,7 +930,7 @@ { "cell_type": "code", "execution_count": null, - "id": "17c80acc", + "id": "4163149b", "metadata": {}, "outputs": [], "source": [ @@ -1037,7 +941,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3409a939", + "id": "66a1cbdc", "metadata": {}, "outputs": [], "source": [ @@ -1046,7 +950,7 @@ }, { "cell_type": "markdown", - "id": "51bd9e73", + "id": "de6afd2b", "metadata": {}, "source": [ "Die Binärbruch-Mantisse einer Maschinenzahl kann eine lange oder sogar unendlich-periodische Dezimalbruchentwicklung haben. Dadurch \n", @@ -1067,6 +971,9 @@ "\n", "## Normalisierte und Denormalisierte Maschinenzahlen\n", "\n", + "Die Lücke zwischen Null und der kleinsten normalisierten Maschinenzahl $2^{-1022} \\approx 2.22\\times 10^{-308}$ \n", + "ist mit denormalisierten Maschinenzahlen besiedelt. \n", + "\n", "Zum Verständnis nehmen wir ein einfaches Modell: \n", "\n", "- Sei 𝕄(10,4,±5) die Menge der Maschinenzahlen zur Basis 10 mit 4 Mantissenstellen (eine vor dem Komma, 3 Nachkommastellen) und dem Exponentenbereich -5 ≤ E ≤ 5.\n", @@ -1081,21 +988,9 @@ "Im `Float`-Datentyp werden solche *subnormal values* dargestellt durch ein Exponentenfeld, in dem alle Bits gleich Null sind:\n" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "4cf6ecae", - "metadata": {}, - "outputs": [], - "source": [ - "#| echo: false\n", - "#| output: false\n", - "flush(stdout)" - ] - }, { "cell_type": "markdown", - "id": "baddd014", + "id": "13e1fcdb", "metadata": {}, "source": [ ":::{.ansitight}\n" @@ -1104,7 +999,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1d0377d1", + "id": "bcb17fac", "metadata": {}, "outputs": [], "source": [ @@ -1121,20 +1016,28 @@ }, { "cell_type": "markdown", - "id": "246e9987", + "id": "658f30b8", "metadata": {}, "source": [ ":::\n", "\n", "## Spezielle Werte\n", "\n", - "Die Gleitkommaarithmetik kennt einige spezielle Werte:\n" + "Die Gleitkommaarithmetik kennt einige spezielle Werte, z.B.\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "7a7ad264", + "id": "576a8b00", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13628c87", "metadata": {}, "outputs": [], "source": [ @@ -1146,7 +1049,7 @@ }, { "cell_type": "markdown", - "id": "806100b7", + "id": "f79d32eb", "metadata": {}, "source": [ "- Ein Exponentenüberlauf *(overflow)* führt zum Ergebnis `Inf` oder `-Inf`.\n" @@ -1155,16 +1058,14 @@ { "cell_type": "code", "execution_count": null, - "id": "c4381f5a", + "id": "8b3bf260", "metadata": {}, "outputs": [], - "source": [ - "2/0, -3/0, floatmax(Float64) * 1.01, exp(1300)" - ] + "source": [] }, { "cell_type": "markdown", - "id": "01836c3b", + "id": "9f8ae030", "metadata": {}, "source": [ "- Damit kann weitergerechnet werden:\n" @@ -1173,16 +1074,14 @@ { "cell_type": "code", "execution_count": null, - "id": "f6d21942", + "id": "f0421f6b", "metadata": {}, "outputs": [], - "source": [ - "-Inf + 20, Inf/30, 23/-Inf, sqrt(Inf), Inf * 0, Inf - Inf" - ] + "source": [] }, { "cell_type": "markdown", - "id": "b8dd245d", + "id": "b29f956a", "metadata": {}, "source": [ "- `NaN` *(Not a Number)* steht für das Resultat einer Operation, das undefiniert ist. Alle weiteren Operationen mit `NaN` ergeben ebenfalls `NaN`.\n" @@ -1191,16 +1090,14 @@ { "cell_type": "code", "execution_count": null, - "id": "ed988054", + "id": "28167d92", "metadata": {}, "outputs": [], - "source": [ - "0/0, Inf - Inf, 2.3NaN, sqrt(NaN)" - ] + "source": [] }, { "cell_type": "markdown", - "id": "a5cdc827", + "id": "e33dbf1b", "metadata": {}, "source": [ "- Da `NaN` einen undefinierten Wert repräsentiert, ist es zu nichts gleich, nichtmal zu sich selbst. Das ist sinnvoll, denn wenn zwei Variablen `x` und `y` als `NaN` berechnet wurden, sollte man nicht schlußfolgern, dass sie gleich sind. \n", @@ -1210,7 +1107,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c1fddee9", + "id": "d440a247", "metadata": {}, "outputs": [], "source": [ @@ -1221,7 +1118,7 @@ }, { "cell_type": "markdown", - "id": "7620f690", + "id": "d63d00e9", "metadata": {}, "source": [ "- Es gibt eine „minus Null“. Sie signalisiert einen Exponentenunterlauf *(underflow)* einer betragsmäßig zu klein gewordenen *negativen* Größe. \n" @@ -1230,16 +1127,14 @@ { "cell_type": "code", "execution_count": null, - "id": "448f1740", + "id": "2dc5751c", "metadata": {}, "outputs": [], - "source": [ - "@show 23/-Inf -2/exp(1200) -0.0==0.0;" - ] + "source": [] }, { "cell_type": "markdown", - "id": "fc1c8f29", + "id": "68605845", "metadata": {}, "source": [ "## Mathematische Funktionen\n", @@ -1256,7 +1151,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a22d5739", + "id": "32b65c0a", "metadata": {}, "outputs": [], "source": [ @@ -1266,7 +1161,7 @@ { "cell_type": "code", "execution_count": null, - "id": "175b33d1", + "id": "c9dbc9e5", "metadata": {}, "outputs": [], "source": [ @@ -1275,7 +1170,7 @@ }, { "cell_type": "markdown", - "id": "40ce370d", + "id": "6eba24bc", "metadata": {}, "source": [ "Es sei noch hingewiesen auf `atan(y, x)`, den [Arkustangens mit 2 Argumenten](https://de.wikipedia.org/wiki/Arctan2), Er ist in anderen Programmiersprachen oft als Funktion mit eigenem Namen *atan2* implementiert. \n", @@ -1287,7 +1182,7 @@ { "cell_type": "code", "execution_count": null, - "id": "518c24db", + "id": "1b517f6a", "metadata": {}, "outputs": [], "source": [ @@ -1296,7 +1191,7 @@ }, { "cell_type": "markdown", - "id": "f61060f4", + "id": "3f12b1c4", "metadata": {}, "source": [ "## Umwandlung Strings $\\Longleftrightarrow$ Zahlen\n", @@ -1307,46 +1202,38 @@ { "cell_type": "code", "execution_count": null, - "id": "96490c3b", + "id": "30eaa58a", "metadata": {}, "outputs": [], - "source": [ - "parse(Int64, \"1101\", base=2)" - ] + "source": [] }, { "cell_type": "code", "execution_count": null, - "id": "814ac0ed", + "id": "cf1565b4", "metadata": {}, "outputs": [], - "source": [ - "string(13, base=2)" - ] + "source": [] }, { "cell_type": "code", "execution_count": null, - "id": "90b64397", + "id": "4c9faf39", "metadata": {}, "outputs": [], - "source": [ - "string(1/7)" - ] + "source": [] }, { "cell_type": "code", "execution_count": null, - "id": "fb1ebb4d", + "id": "fa1f5299", "metadata": {}, "outputs": [], - "source": [ - "string(77, base=16)" - ] + "source": [] }, { "cell_type": "markdown", - "id": "029d437e", + "id": "4bd183df", "metadata": {}, "source": [ "Zur Umwandlung der numerischen Typen ineinander kann man die Typnamen verwenden. Typenamen sind auch Konstruktoren:\n" @@ -1355,7 +1242,7 @@ { "cell_type": "code", "execution_count": null, - "id": "df5b20f2", + "id": "2022c8ea", "metadata": {}, "outputs": [], "source": [ @@ -1366,26 +1253,22 @@ { "cell_type": "code", "execution_count": null, - "id": "27314b21", + "id": "3a8885ab", "metadata": {}, "outputs": [], - "source": [ - "z = UInt64(3459)" - ] + "source": [] }, { "cell_type": "code", "execution_count": null, - "id": "5687c82a", + "id": "875c77bc", "metadata": {}, "outputs": [], - "source": [ - "y = Float64(z)" - ] + "source": [] }, { "cell_type": "markdown", - "id": "075b91d7", + "id": "b9d2cb4b", "metadata": {}, "source": [ "## Literatur\n", @@ -1397,9 +1280,15 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.8.5", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.8" + "name": "julia-1.10" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.10.2" } }, "nbformat": 4, diff --git a/nb/pcomplex.ipynb b/nb/pcomplex.ipynb index 1d2c72c..edc33ee 100644 --- a/nb/pcomplex.ipynb +++ b/nb/pcomplex.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "3b9e97dc", + "id": "69149570", "metadata": {}, "source": [ "# Ein Fallbeispiel: Der parametrisierte Datentyp PComplex\n", @@ -20,7 +20,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b00fa817", + "id": "3ee9c4ae", "metadata": {}, "outputs": [], "source": [ @@ -36,7 +36,7 @@ }, { "cell_type": "markdown", - "id": "00603f51", + "id": "729a1d8e", "metadata": {}, "source": [ "Julia stellt automatisch *default constructors* zur Verfügung:\n", @@ -60,7 +60,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d583f845", + "id": "214480f6", "metadata": {}, "outputs": [], "source": [ @@ -84,7 +84,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e3d6ada4", + "id": "873d5dc6", "metadata": {}, "outputs": [], "source": [ @@ -103,7 +103,7 @@ { "cell_type": "code", "execution_count": null, - "id": "55f6b7dc", + "id": "95c7386c", "metadata": {}, "outputs": [], "source": [ @@ -112,7 +112,7 @@ }, { "cell_type": "markdown", - "id": "99f6d6e1", + "id": "eb213995", "metadata": {}, "source": [ "Für die explizite Angabe eines *inner constructors* müssen wir allerdings einen Preis zahlen: Die sonst von Julia bereitgestellten *default constructors* fehlen. \n", @@ -123,7 +123,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e6c36f18", + "id": "e87d3a42", "metadata": {}, "outputs": [], "source": [ @@ -134,7 +134,7 @@ }, { "cell_type": "markdown", - "id": "5d77812c", + "id": "0512b019", "metadata": {}, "source": [ "## Eine neue Schreibweise\n", @@ -165,7 +165,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a4fc6d3c", + "id": "81818d42", "metadata": {}, "outputs": [], "source": [ @@ -176,7 +176,7 @@ }, { "cell_type": "markdown", - "id": "c19f6e25", + "id": "bf0863e9", "metadata": {}, "source": [ "(Die Typ-Annotation -- `Real` statt `AbstractFloat` -- ist ein Vorgriff auf kommende weitere Konstruktoren. Im Moment funktioniert der Operator `⋖` erstmal nur mit `Float`s.)\n", @@ -188,7 +188,7 @@ { "cell_type": "code", "execution_count": null, - "id": "13e750ef", + "id": "4cf73e28", "metadata": {}, "outputs": [], "source": [ @@ -206,7 +206,7 @@ }, { "cell_type": "markdown", - "id": "e1c7d6fa", + "id": "0dae2fef", "metadata": {}, "source": [ "## Methoden für `PComplex`\n", @@ -230,7 +230,7 @@ { "cell_type": "code", "execution_count": null, - "id": "373829e0", + "id": "042418fd", "metadata": {}, "outputs": [], "source": [ @@ -241,7 +241,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a4490292", + "id": "c20d10e5", "metadata": {}, "outputs": [], "source": [ @@ -252,7 +252,7 @@ }, { "cell_type": "markdown", - "id": "d49ec514", + "id": "82fe20b4", "metadata": {}, "source": [ ":::\n" @@ -261,7 +261,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d2186aeb", + "id": "a53f0e79", "metadata": {}, "outputs": [], "source": [ @@ -271,7 +271,7 @@ { "cell_type": "code", "execution_count": null, - "id": "5d93d3ca", + "id": "d6987594", "metadata": {}, "outputs": [], "source": [ @@ -289,7 +289,7 @@ }, { "cell_type": "markdown", - "id": "07ed8595", + "id": "53f4bb77", "metadata": {}, "source": [ "Die Funktion `sqrt()` hat schon einige Methoden:\n" @@ -298,7 +298,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1ecfd1ac", + "id": "f93f63c6", "metadata": {}, "outputs": [], "source": [ @@ -307,7 +307,7 @@ }, { "cell_type": "markdown", - "id": "f619c771", + "id": "7b4f323a", "metadata": {}, "source": [ "Jetzt wird es eine Methode mehr:\n" @@ -316,7 +316,7 @@ { "cell_type": "code", "execution_count": null, - "id": "56a4ce0f", + "id": "b88cd74b", "metadata": {}, "outputs": [], "source": [ @@ -328,7 +328,7 @@ { "cell_type": "code", "execution_count": null, - "id": "195204e7", + "id": "e077b8bf", "metadata": {}, "outputs": [], "source": [ @@ -337,7 +337,7 @@ }, { "cell_type": "markdown", - "id": "c912bcd2", + "id": "e223fdd1", "metadata": {}, "source": [ "und nun zur Multiplikation:\n" @@ -346,7 +346,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8c648a2d", + "id": "5537f7ec", "metadata": {}, "outputs": [], "source": [ @@ -357,7 +357,7 @@ }, { "cell_type": "markdown", - "id": "79074b01", + "id": "7189f0c6", "metadata": {}, "source": [ "(Da das Operatorsymbol kein normaler Name ist, muss der Doppelpunkt bei der Zusammensetzung mit `Base.` sein.)\n", @@ -373,7 +373,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ff3ee027", + "id": "610a38fe", "metadata": {}, "outputs": [], "source": [ @@ -382,7 +382,7 @@ }, { "cell_type": "markdown", - "id": "f43ef8c6", + "id": "bc39d089", "metadata": {}, "source": [ "Wenn man in die zahlreichen Methoden schaut, die z.B. für `+` und `*` definiert sind, findet man u.a. eine Art 'catch-all-Definition'\n", @@ -408,7 +408,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8f1d4d57", + "id": "48cae0ae", "metadata": {}, "outputs": [], "source": [ @@ -418,7 +418,7 @@ { "cell_type": "code", "execution_count": null, - "id": "27c2724e", + "id": "768934ac", "metadata": {}, "outputs": [], "source": [ @@ -428,7 +428,7 @@ }, { "cell_type": "markdown", - "id": "8347acad", + "id": "df2672c5", "metadata": {}, "source": [ "Die Funktion `promote()` verwendet dazu zwei Helfer, die Funktionen\n", @@ -445,7 +445,7 @@ { "cell_type": "code", "execution_count": null, - "id": "fe551c95", + "id": "70306adc", "metadata": {}, "outputs": [], "source": [ @@ -454,7 +454,7 @@ }, { "cell_type": "markdown", - "id": "e4c08732", + "id": "ec999b3a", "metadata": {}, "source": [ "### Die Funktion `convert(T,x)`\n", @@ -466,7 +466,7 @@ { "cell_type": "code", "execution_count": null, - "id": "5d6aabe4", + "id": "b326a121", "metadata": {}, "outputs": [], "source": [ @@ -476,7 +476,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8b5205d2", + "id": "57606643", "metadata": {}, "outputs": [], "source": [ @@ -486,7 +486,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0d4b80ce", + "id": "a3b39504", "metadata": {}, "outputs": [], "source": [ @@ -495,7 +495,7 @@ }, { "cell_type": "markdown", - "id": "3e3d953b", + "id": "06251c1d", "metadata": {}, "source": [ "Die spezielle Rolle von `convert()` liegt darin, dass es an verschiedenen Stellen _implizit_ und automatisch eingesetzt wird: \n", @@ -526,7 +526,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2f9e1ebe", + "id": "e258330e", "metadata": {}, "outputs": [], "source": [ @@ -558,7 +558,7 @@ }, { "cell_type": "markdown", - "id": "c831e4c3", + "id": "ccb96089", "metadata": {}, "source": [ "Ein Test der neuen Konstruktoren:\n" @@ -567,7 +567,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8103dc03", + "id": "ec747779", "metadata": {}, "outputs": [], "source": [ @@ -576,7 +576,7 @@ }, { "cell_type": "markdown", - "id": "c85b8d7a", + "id": "fd8541cf", "metadata": {}, "source": [ "Wir brauchen nun noch *promotion rules*, die festlegen, welcher Typ bei `promote(x::T1, y::T2)` herauskommen soll. Damit wird `promote_type()` intern um die nötigen weiteren Methoden erweitert. \n", @@ -587,7 +587,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8e6a1e94", + "id": "806fff6a", "metadata": {}, "outputs": [], "source": [ @@ -600,7 +600,7 @@ }, { "cell_type": "markdown", - "id": "4ad30167", + "id": "97c7de69", "metadata": {}, "source": [ "1. Regel:\n", @@ -617,7 +617,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9e72f683", + "id": "cc47939d", "metadata": {}, "outputs": [], "source": [ @@ -627,7 +627,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f0aec53e", + "id": "63c20bc7", "metadata": {}, "outputs": [], "source": [ @@ -636,7 +636,7 @@ }, { "cell_type": "markdown", - "id": "0d881cc4", + "id": "e94c6b15", "metadata": {}, "source": [ ":::{.callout-caution icon=\"false\" collapse=\"true\" .titlenormal}\n", @@ -730,15 +730,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.8.5", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.8" - }, - "language_info": { - "file_extension": ".jl", - "mimetype": "application/julia", - "name": "julia", - "version": "1.8.5" + "name": "julia-1.10" } }, "nbformat": 4, diff --git a/nb/script1.sh b/nb/script1.sh index 801804c..30e4c43 100755 --- a/nb/script1.sh +++ b/nb/script1.sh @@ -1,7 +1,8 @@ #!/bin/bash -cp ../chapters/*.ipynb . -for i in *.ipynb +cp ../chapters/*.quarto_ipynb . +for i in *.quarto_ipynb do - echo $i - jupyter nbconvert --inplace --clear-output --to notebook $i + echo $i + mv $i "${i%.quarto_ipynb}.ipynb" + jupyter nbconvert --inplace --clear-output --to notebook "${i%.quarto_ipynb}.ipynb" done diff --git a/nb/syntax.ipynb b/nb/syntax.ipynb index 074b2a9..a02a69f 100644 --- a/nb/syntax.ipynb +++ b/nb/syntax.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "d56a820e", + "id": "5060b5d0", "metadata": {}, "source": [ "# Grundlagen der Syntax\n", @@ -36,7 +36,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ff07d3b4", + "id": "109cbcf5", "metadata": {}, "outputs": [], "source": [ @@ -47,7 +47,7 @@ }, { "cell_type": "markdown", - "id": "da69601f", + "id": "267dcd3c", "metadata": {}, "source": [ "Jetzt ist natürlich der Logarithmus kaputt:\n" @@ -56,7 +56,7 @@ { "cell_type": "code", "execution_count": null, - "id": "88275d81", + "id": "c8432843", "metadata": {}, "outputs": [], "source": [ @@ -66,7 +66,7 @@ }, { "cell_type": "markdown", - "id": "5ecfdec6", + "id": "cf194eb9", "metadata": {}, "source": [ "(siehe auch )\n", @@ -92,7 +92,7 @@ { "cell_type": "code", "execution_count": null, - "id": "dc76d67e", + "id": "8fa53675", "metadata": {}, "outputs": [], "source": [ @@ -102,7 +102,7 @@ }, { "cell_type": "markdown", - "id": "6b068f1c", + "id": "07d1a5e6", "metadata": {}, "source": [ "Das Semikolon unterdrückt das:\n" @@ -111,7 +111,7 @@ { "cell_type": "code", "execution_count": null, - "id": "efd01a2c", + "id": "4b79202b", "metadata": {}, "outputs": [], "source": [ @@ -121,7 +121,7 @@ }, { "cell_type": "markdown", - "id": "18387226", + "id": "76937fcb", "metadata": {}, "source": [ ":::\n", @@ -137,7 +137,7 @@ { "cell_type": "code", "execution_count": null, - "id": "41df7f55", + "id": "4af8b031", "metadata": {}, "outputs": [], "source": [ @@ -147,7 +147,7 @@ }, { "cell_type": "markdown", - "id": "61e668f9", + "id": "b81c022a", "metadata": {}, "source": [ "Also geht das Folgende schief, aber leider **ohne eine Fehlermeldung**!\n" @@ -156,7 +156,7 @@ { "cell_type": "code", "execution_count": null, - "id": "694793eb", + "id": "74162af6", "metadata": {}, "outputs": [], "source": [ @@ -169,7 +169,7 @@ }, { "cell_type": "markdown", - "id": "88c64cd2", + "id": "fdaa2eed", "metadata": {}, "source": [ "Hier wird das `+` in der zweiten Zeile als Präfix-Operator (Vorzeichen) interpretiert. Damit sind 1. und 2. Zeile jeweils für sich vollständige, korrekte Ausdrücke (auch wenn die 2. Zeile natürlich völlig nutzlos ist) und werden auch so abgearbeitet. \n", @@ -180,7 +180,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8ec8508d", + "id": "e865958c", "metadata": {}, "outputs": [], "source": [ @@ -191,7 +191,7 @@ }, { "cell_type": "markdown", - "id": "1b323891", + "id": "ddd2ae7d", "metadata": {}, "source": [ ":::\n", @@ -205,7 +205,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d733f6a2", + "id": "a628a28a", "metadata": {}, "outputs": [], "source": [ @@ -217,7 +217,7 @@ { "cell_type": "code", "execution_count": null, - "id": "cf4ef498", + "id": "39f0f1fd", "metadata": {}, "outputs": [], "source": [ @@ -238,7 +238,7 @@ }, { "cell_type": "markdown", - "id": "e0fc09d1", + "id": "44aa6359", "metadata": {}, "source": [ "## Datentypen Teil I \n", @@ -260,7 +260,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0ba7db71", + "id": "f5fcc67a", "metadata": {}, "outputs": [], "source": [ @@ -271,7 +271,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ad90519a", + "id": "0f4c6d58", "metadata": {}, "outputs": [], "source": [ @@ -282,7 +282,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e36334d2", + "id": "ef084989", "metadata": {}, "outputs": [], "source": [ @@ -293,7 +293,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f48d35a6", + "id": "1f1df8fc", "metadata": {}, "outputs": [], "source": [ @@ -304,7 +304,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0eb5282b", + "id": "b833e181", "metadata": {}, "outputs": [], "source": [ @@ -314,7 +314,7 @@ }, { "cell_type": "markdown", - "id": "6407ce53", + "id": "610935f8", "metadata": {}, "source": [ "- `sizeof()` liefert die Größe eines Objekts oder Typs in Bytes (1 Byte = 8 Bit)\n", @@ -332,7 +332,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d2c3f6c8", + "id": "1b399845", "metadata": {}, "outputs": [], "source": [ @@ -355,7 +355,7 @@ }, { "cell_type": "markdown", - "id": "868ae573", + "id": "73a859d9", "metadata": {}, "source": [ "Kurze Blöcke kann man in eine Zeile schreiben:\n" @@ -364,7 +364,7 @@ { "cell_type": "code", "execution_count": null, - "id": "76f17f5f", + "id": "ad94abc7", "metadata": {}, "outputs": [], "source": [ @@ -373,7 +373,7 @@ }, { "cell_type": "markdown", - "id": "ef1e84b5", + "id": "34c18e6c", "metadata": {}, "source": [ "Der Wert eines `if`-Blocks kann natürlich zugewiesen werden:\n" @@ -382,7 +382,7 @@ { "cell_type": "code", "execution_count": null, - "id": "318501e9", + "id": "27eef305", "metadata": {}, "outputs": [], "source": [ @@ -396,7 +396,7 @@ }, { "cell_type": "markdown", - "id": "0c05b161", + "id": "0ac5ece1", "metadata": {}, "source": [ "### Auswahloperator (ternary operator) `test ? exp1 : exp2`\n" @@ -405,7 +405,7 @@ { "cell_type": "code", "execution_count": null, - "id": "40e9db00", + "id": "dbe58322", "metadata": {}, "outputs": [], "source": [ @@ -416,7 +416,7 @@ }, { "cell_type": "markdown", - "id": "48705675", + "id": "d7e0a7f9", "metadata": {}, "source": [ "ist äquivalent zu\n" @@ -425,7 +425,7 @@ { "cell_type": "code", "execution_count": null, - "id": "dadac914", + "id": "e1929004", "metadata": {}, "outputs": [], "source": [ @@ -438,7 +438,7 @@ }, { "cell_type": "markdown", - "id": "8d122010", + "id": "406f03e8", "metadata": {}, "source": [ "## Vergleiche, Tests, Logische Operationen\n", @@ -458,7 +458,7 @@ { "cell_type": "code", "execution_count": null, - "id": "13005342", + "id": "5409328f", "metadata": {}, "outputs": [], "source": [ @@ -467,7 +467,7 @@ }, { "cell_type": "markdown", - "id": "dd31f487", + "id": "9b27b690", "metadata": {}, "source": [ "Nun ja, fast alles:\n" @@ -476,7 +476,7 @@ { "cell_type": "code", "execution_count": null, - "id": "7491b44b", + "id": "5e6b4540", "metadata": {}, "outputs": [], "source": [ @@ -485,7 +485,7 @@ }, { "cell_type": "markdown", - "id": "d5eace21", + "id": "df810fec", "metadata": {}, "source": [ "Die Fehlermeldung zeigt ein paar Grundprinzipien von Julia:\n", @@ -500,7 +500,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6538caaf", + "id": "aa2d90be", "metadata": {}, "outputs": [], "source": [ @@ -509,7 +509,7 @@ }, { "cell_type": "markdown", - "id": "297ce845", + "id": "7d79d348", "metadata": {}, "source": [ "Zuletzt noch: Vergleiche können gekettet werden.\n" @@ -518,7 +518,7 @@ { "cell_type": "code", "execution_count": null, - "id": "449eba70", + "id": "3de7f381", "metadata": {}, "outputs": [], "source": [ @@ -528,7 +528,7 @@ }, { "cell_type": "markdown", - "id": "9f4b1c41", + "id": "e5535e05", "metadata": {}, "source": [ "### Tests \n", @@ -538,7 +538,7 @@ { "cell_type": "code", "execution_count": null, - "id": "18d77ec1", + "id": "1fa42721", "metadata": {}, "outputs": [], "source": [ @@ -547,7 +547,7 @@ }, { "cell_type": "markdown", - "id": "2dc1c0aa", + "id": "9e3772fc", "metadata": {}, "source": [ "und vom Typ `f(s1::String, s2::String) -> Bool`\n" @@ -556,7 +556,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ea9be46e", + "id": "a462d33f", "metadata": {}, "outputs": [], "source": [ @@ -565,7 +565,7 @@ }, { "cell_type": "markdown", - "id": "af8b3ce6", + "id": "ee1487a3", "metadata": {}, "source": [ "- Die Funktion `in(item, collection) -> Bool` testet, ob `item` in `collection` ist. \n", @@ -576,7 +576,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e811c4d8", + "id": "71790111", "metadata": {}, "outputs": [], "source": [ @@ -587,7 +587,7 @@ { "cell_type": "code", "execution_count": null, - "id": "15f8ba27", + "id": "f9b92ce4", "metadata": {}, "outputs": [], "source": [ @@ -596,7 +596,7 @@ }, { "cell_type": "markdown", - "id": "6b811515", + "id": "93782274", "metadata": {}, "source": [ "### Logische Operationen: `&&`, `||`, `!`\n" @@ -605,7 +605,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ea9ad7fb", + "id": "8e907712", "metadata": {}, "outputs": [], "source": [ @@ -614,7 +614,7 @@ }, { "cell_type": "markdown", - "id": "a1886e91", + "id": "efb19c75", "metadata": {}, "source": [ "#### Bedingte Auswertung (_short circuit evaluation_)\n", @@ -632,7 +632,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a5ef06bf", + "id": "e5cae687", "metadata": {}, "outputs": [], "source": [ @@ -647,7 +647,7 @@ }, { "cell_type": "markdown", - "id": "bb950743", + "id": "444d49b9", "metadata": {}, "source": [ "Natürlich kann man alle diese Tests auch Variablen vom Typ `Bool` zuordnen und\n", @@ -657,7 +657,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8c44f3bc", + "id": "68a69b63", "metadata": {}, "outputs": [], "source": [ @@ -671,7 +671,7 @@ }, { "cell_type": "markdown", - "id": "b7d1e766", + "id": "e42d40c8", "metadata": {}, "source": [ "- In Julia müssen alle Tests in einem logischen Ausdruck vom Typ `Bool` sein.\n", @@ -684,7 +684,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0a46fa2b", + "id": "9fb43a4a", "metadata": {}, "outputs": [], "source": [ @@ -695,7 +695,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f56bbc75", + "id": "58faddd6", "metadata": {}, "outputs": [], "source": [ @@ -705,7 +705,7 @@ }, { "cell_type": "markdown", - "id": "508cebd9", + "id": "295ec49e", "metadata": {}, "source": [ "## Schleifen *(loops)*\n", @@ -725,7 +725,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d91b98b6", + "id": "9bd613c4", "metadata": {}, "outputs": [], "source": [ @@ -739,7 +739,7 @@ }, { "cell_type": "markdown", - "id": "f7edea21", + "id": "33b95f6d", "metadata": {}, "source": [ "Der Körper einer `while`- und `for`-Schleife kann die Anweisungen `break` und `continue` enthalten. `break` stoppt die Schleife, `continue` überspringt den Rest des Schleifenkörpers und beginnt sofort mit dem nächsten Schleifendurchlauf.\n" @@ -748,7 +748,7 @@ { "cell_type": "code", "execution_count": null, - "id": "149c79ac", + "id": "8ef0e09b", "metadata": {}, "outputs": [], "source": [ @@ -773,7 +773,7 @@ }, { "cell_type": "markdown", - "id": "2e91f7a3", + "id": "ab77d5c1", "metadata": {}, "source": [ "Mit `break` kann man auch Endlosschleifen verlassen:\n" @@ -782,7 +782,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0b1b1ab2", + "id": "72307342", "metadata": {}, "outputs": [], "source": [ @@ -797,7 +797,7 @@ }, { "cell_type": "markdown", - "id": "d9bc10da", + "id": "f3032c94", "metadata": {}, "source": [ "### `for`-Schleifen\n", @@ -818,7 +818,7 @@ { "cell_type": "code", "execution_count": null, - "id": "99cd73cb", + "id": "1e45bf78", "metadata": {}, "outputs": [], "source": [ @@ -829,7 +829,7 @@ }, { "cell_type": "markdown", - "id": "1a17064c", + "id": "e723c97a", "metadata": {}, "source": [ "Oft benötigt man einen numerischen Schleifenzähler. Dafür gibt es das *range*-Konstrukt. Die einfachsten Formen sind \n", @@ -839,7 +839,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3177977b", + "id": "b3a01bd4", "metadata": {}, "outputs": [], "source": [ @@ -853,7 +853,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0c859acc", + "id": "8427a301", "metadata": {}, "outputs": [], "source": [ @@ -863,7 +863,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c31d91f6", + "id": "f973a1cb", "metadata": {}, "outputs": [], "source": [ @@ -873,7 +873,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c35be84d", + "id": "63290cd9", "metadata": {}, "outputs": [], "source": [ @@ -882,7 +882,7 @@ }, { "cell_type": "markdown", - "id": "19034238", + "id": "419963f0", "metadata": {}, "source": [ "#### Geschachtelte Schleifen _(nested loops)_\n", @@ -893,7 +893,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9be68ac5", + "id": "06ab8236", "metadata": {}, "outputs": [], "source": [ @@ -909,7 +909,7 @@ }, { "cell_type": "markdown", - "id": "99328006", + "id": "19464d7e", "metadata": {}, "source": [ "Man kann *nested loops* auch in einer `for`-Anweisung zusammenfassen. Dann beendet ein `break` die Gesamtschleife.\n" @@ -918,7 +918,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e437369c", + "id": "e208b54c", "metadata": {}, "outputs": [], "source": [ @@ -932,7 +932,7 @@ }, { "cell_type": "markdown", - "id": "e995a233", + "id": "e5f41344", "metadata": {}, "source": [ ":::{.callout-important .titlenormalxx}\n", @@ -944,7 +944,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2d2e2164", + "id": "c903a887", "metadata": {}, "outputs": [], "source": [ @@ -957,7 +957,7 @@ }, { "cell_type": "markdown", - "id": "6c940891", + "id": "68db2918", "metadata": {}, "source": [ "-------\n", @@ -1004,7 +1004,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9d8ee587", + "id": "6b3cf482", "metadata": {}, "outputs": [], "source": [ @@ -1014,7 +1014,7 @@ }, { "cell_type": "markdown", - "id": "4a3975ec", + "id": "2009bbff", "metadata": {}, "source": [ "Hier wird die Eingabe als Gleitkommazahl interpretiert -- und `3E+2` oder `3f+2` (Float32) ebenso. \n" @@ -1023,7 +1023,7 @@ { "cell_type": "code", "execution_count": null, - "id": "fa68ebcd", + "id": "d1812cfd", "metadata": {}, "outputs": [], "source": [ @@ -1032,7 +1032,7 @@ }, { "cell_type": "markdown", - "id": "d3b54ba7", + "id": "6cf09a01", "metadata": {}, "source": [ "Ein Leerzeichen schafft Eindeutigkeit:\n" @@ -1041,7 +1041,7 @@ { "cell_type": "code", "execution_count": null, - "id": "378e3e06", + "id": "e6104540", "metadata": {}, "outputs": [], "source": [ @@ -1050,7 +1050,7 @@ }, { "cell_type": "markdown", - "id": "d23bc72e", + "id": "5215cde4", "metadata": {}, "source": [ "Das funktioniert:\n" @@ -1059,7 +1059,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ab2811f6", + "id": "6828cede", "metadata": {}, "outputs": [], "source": [ @@ -1069,7 +1069,7 @@ }, { "cell_type": "markdown", - "id": "c81689d3", + "id": "5316e342", "metadata": {}, "source": [ "...und das nicht. `0x`, `0o`, `0b` wird als Anfang einer Hexadezimal-, Oktal- bzw. Binärkonstanten interpretiert.\n" @@ -1078,7 +1078,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a5eff7fc", + "id": "d8ff4514", "metadata": {}, "outputs": [], "source": [ @@ -1087,7 +1087,7 @@ }, { "cell_type": "markdown", - "id": "ac739eda", + "id": "d2df69d1", "metadata": {}, "source": [ "- Es gibt noch ein paar andere Fälle, bei denen die sehr kulante Syntax zu Überraschungen führt.\n" @@ -1096,7 +1096,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a69f9e83", + "id": "02e802cf", "metadata": {}, "outputs": [], "source": [ @@ -1108,7 +1108,7 @@ { "cell_type": "code", "execution_count": null, - "id": "3d9dc81e", + "id": "227c2b1d", "metadata": {}, "outputs": [], "source": [ @@ -1117,7 +1117,7 @@ }, { "cell_type": "markdown", - "id": "89722987", + "id": "b14d28e3", "metadata": {}, "source": [ "Julia interpretiert das als Vergleich `Wichtig != 88`.\n", @@ -1128,7 +1128,7 @@ { "cell_type": "code", "execution_count": null, - "id": "87a6cfd7", + "id": "41460c8d", "metadata": {}, "outputs": [], "source": [ @@ -1138,7 +1138,7 @@ }, { "cell_type": "markdown", - "id": "90ae7dac", + "id": "8c7a3ede", "metadata": {}, "source": [ "- Operatoren der Form `.*`, `.+`,... haben in Julia eine spezielle Bedeutung (*broadcasting*, d.h., vektorisierte Operationen). \n" @@ -1147,7 +1147,7 @@ { "cell_type": "code", "execution_count": null, - "id": "538cd36e", + "id": "1d6f31aa", "metadata": {}, "outputs": [], "source": [ @@ -1156,7 +1156,7 @@ }, { "cell_type": "markdown", - "id": "7f39acd9", + "id": "1ffdeba1", "metadata": {}, "source": [ "Wieder gilt: Leerzeichen schaffen Klarheit!\n" @@ -1165,7 +1165,7 @@ { "cell_type": "code", "execution_count": null, - "id": "45ceb4be", + "id": "350fe2e3", "metadata": {}, "outputs": [], "source": [ @@ -1175,9 +1175,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.8.5", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.8" + "name": "julia-1.10" } }, "nbformat": 4, diff --git a/nb/types.ipynb b/nb/types.ipynb index 946ff36..7044cc2 100644 --- a/nb/types.ipynb +++ b/nb/types.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "raw", - "id": "f1724c85", + "id": "782b49af", "metadata": {}, "source": [ "---\n", @@ -12,7 +12,7 @@ }, { "cell_type": "markdown", - "id": "75a11f86", + "id": "8a4cf30f", "metadata": {}, "source": [ "# Das Typsystem von Julia\n", @@ -21,7 +21,7 @@ "\n", "Wir blicken jetzt trotzdem mal unter die Motorhaube.\n", "\n", - "## Die Typhierarchie\n", + "## Die Typhierarchie am Beispiel der numerischen Typen\n", "\n", "Das Typsystem hat die Struktur eines Baums, dessen Wurzel der Typ `Any` ist. Mit den Funktionen `subtypes()` und `supertype()` kann man den Baum erforschen. Sie zeigen alle Kinder bzw. die Mutter eines Knotens an.\n" ] @@ -29,7 +29,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f3f47e9d", + "id": "c657afef", "metadata": {}, "outputs": [], "source": [ @@ -38,7 +38,7 @@ }, { "cell_type": "markdown", - "id": "3cb68ade", + "id": "34cfce26", "metadata": {}, "source": [ "Das Ergebnis ist eine leere Liste von Typen. `Int64` ist ein sogenannter **konkreter Typ** und hat keine Untertypen.\n", @@ -49,7 +49,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c7c10d75", + "id": "a45cb2eb", "metadata": {}, "outputs": [], "source": [ @@ -59,7 +59,7 @@ { "cell_type": "code", "execution_count": null, - "id": "15b4e8d6", + "id": "3ccc88af", "metadata": {}, "outputs": [], "source": [ @@ -69,7 +69,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2c62f342", + "id": "c368a69d", "metadata": {}, "outputs": [], "source": [ @@ -79,7 +79,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ee7eb511", + "id": "31ff03ae", "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9ab37b54", + "id": "96315571", "metadata": {}, "outputs": [], "source": [ @@ -98,7 +98,7 @@ }, { "cell_type": "markdown", - "id": "d5fe3447", + "id": "86acca0c", "metadata": {}, "source": [ "Das wäre übrigens auch schneller gegangen: Die Funktion `supertypes()` (mit Plural-s) zeigt alle Vorfahren an.\n" @@ -107,7 +107,7 @@ { "cell_type": "code", "execution_count": null, - "id": "895d4570", + "id": "550adea0", "metadata": {}, "outputs": [], "source": [ @@ -116,61 +116,1380 @@ }, { "cell_type": "markdown", - "id": "79a45ce0", + "id": "8ba10cd3", "metadata": {}, "source": [ "Nun kann man sich die Knoten angucken:\n", "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "{{< embed ../notebooks/nb-types.ipynb#nb3 >}}\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", "Mit einer kleinen rekursiven Funktion kann man schnell einen ganzen (Unter-)Baum ausdrucken: \n", "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "{{< embed ../notebooks/nb-types.ipynb#nb1 >}}\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", "::::{.content-hidden unless-format=\"xxx\"}\n", "\n", "...und natürlich gibt es da auch ein Julia-Paket:\n", "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "{{< embed ../notebooks/nb-types.ipynb#nb2 >}}\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", ":::\n", "\n", "\n", + "Hier das Ganze nochmal als Bild (gemacht mit LaTeX/[TikZ](https://tikz.dev/tikz-trees))\n", + "\n", "::: {.content-visible when-format=\"html\"}\n", - "![](../images/TypeTree2.png)\n", + "![](../images/TypeTree2.png){width=80%}\n", ":::\n", "\n", "::: {.content-visible when-format=\"pdf\"}\n", - "![The type tree of numbers](../images/TypeTree2.png) {width=50%}\n", + "![Die Hierarchie der numerischen Typen](../images/TypeTree2.png){width=60%}\n", ":::\n", "\n", - "### Abstrakte und Konkrete Typen\n", "\n", - "- Ein Objekt hat immer einen **konkreten** Typ. \n", - "- Komkrete Typen haben keine Untertypen mehr, sie sind immer „Blätter“ des Baumes.\n", - "- Abstrakte Typen können in der Definition von Funktionstypen, Argumenttypen, Elementtypen von zusammengesetzten Typen,... verwendet werden\n", - "\n", - "https://github.com/carstenbauer/JuliaCologne21/blob/master/Day1/1_types_and_dispatch.ipynb\n", - "\n", - "Zum Deklarieren und Testen der \"Abstammung\" gibt es einen eigenen Operator:\n" + "Natürlich hat Julia nicht nur numerische Typen. Die Anzahl der direkten Abkömmlinge (Kinder) von `Any` ist\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "e300c9a9", + "id": "1bd31bf7", + "metadata": {}, + "outputs": [], + "source": [ + "length(subtypes(Any))" + ] + }, + { + "cell_type": "markdown", + "id": "46ea6703", + "metadata": {}, + "source": [ + "und mit (fast) jedem Paket, das man mit `using ...` lädt, werden es mehr.\n", + "\n", + "\n", + "## Abstrakte und Konkrete Typen\n", + "\n", + "- Ein Objekt hat immer einen **konkreten** Typ. \n", + "- Konkrete Typen haben keine Untertypen mehr, sie sind immer „Blätter“ des Baumes.\n", + "- Konkrete Typen spezifizieren eine konkrete Datenstruktur.\n", + "\n", + ":::{.xxx}\n", + "\n", + ":::\n", + "\n", + "- Abstrakte Typen können nicht instanziiert werden, d.h., es gibt keine Objekte mit diesem Typ. \n", + "- Sie definieren eine Menge von konkreten Typen und gemeinsame Methoden für diese Typen.\n", + "- Sie können daher in der Definition von Funktionstypen, Argumenttypen, Elementtypen von zusammengesetzten Typen u.ä. verwendet werden.\n", + "\n", + "\n", + "\n", + "Zum **Deklarieren** *und* **Testen** der \"Abstammung\" innerhalb der Typhierarchie gibt es einen eigenen Operator:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8b10ed6", "metadata": {}, "outputs": [], "source": [ "Int64 <: Number " ] + }, + { + "cell_type": "markdown", + "id": "9c8bd208", + "metadata": {}, + "source": [ + "Zum Testen, ob ein Objekt einen bestimmten Typ (oder einen abstrakten Supertyp davon) hat, dient `isa(object, typ)`. Es wird meist in der Infix-Form verwendet und sollte als Frage `x is a T?` gelesen werden.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "87663e4e", + "metadata": {}, + "outputs": [], + "source": [ + "x = 17.2\n", + "\n", + "42 isa Int64, 42 isa Real, x isa Real, x isa Float64, x isa Integer " + ] + }, + { + "cell_type": "markdown", + "id": "2f627b1b", + "metadata": {}, + "source": [ + "Da abstrakte Typen keine Datenstrukturen definieren, ist ihre Definition recht schlicht. Entweder sie stammen direkt von `Any` ab:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0419b2c6", + "metadata": {}, + "outputs": [], + "source": [ + "abstract type MySuperType end\n", + "\n", + "supertype(MySuperType)" + ] + }, + { + "cell_type": "markdown", + "id": "68448b69", + "metadata": {}, + "source": [ + "oder von einem anderen abstrakten Typ:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6ab6c2a6", + "metadata": {}, + "outputs": [], + "source": [ + "abstract type MySpecialNumber <: Integer end\n", + "\n", + "supertypes(MySpecialNumber)" + ] + }, + { + "cell_type": "markdown", + "id": "a1b16c28", + "metadata": {}, + "source": [ + "## Die numerischen Typen `Bool` und `Irrational` \n", + "\n", + "Da sie im Baum der numerischen Typen zu sehen sind, seien sie kurz erklärt: \n", + "\n", + "`Bool` ist numerisch im Sinne von `true=1, false=0`: \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c991dbbe", + "metadata": {}, + "outputs": [], + "source": [ + "true + true + true, false - true, sqrt(true), true/4" + ] + }, + { + "cell_type": "markdown", + "id": "9cc6bf10", + "metadata": {}, + "source": [ + "`Irrational` ist der Typ einiger vordefinierter Konstanten wie `π` und `ℯ`. \n", + "Laut [Dokumentation](https://docs.julialang.org/en/v1/base/numbers/#Base.AbstractIrrational) ist `Irrational` ein *\"Number type representing an exact irrational value, which is automatically rounded to the correct precision in arithmetic operations with other numeric quantities\".*\n", + "\n", + "## Union-Typen\n", + "\n", + "Falls die Baum-Hierarchie nicht ausreicht, kann man auch abstrakte Typen als Vereinigung beliebiger (abstrakter und konkreter) Typen definieren.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b3af8cf9", + "metadata": {}, + "outputs": [], + "source": [ + "IntOrString = Union{Int64,String}" + ] + }, + { + "cell_type": "markdown", + "id": "6b304c6b", + "metadata": {}, + "source": [ + ":::{.callout-note .titlenormal}\n", + "\n", + "## Beispiel\n", + "Das Kommando `methods(<)` zeigt, dass unter den über 70 Methoden, die für den Vergleichsoperator definiert sind, einige auch *union types* verwenden, z.B. ist\n", + "```julia\n", + " <(x::Union{Float16, Float32, Float64}, y::BigFloat)\n", + "```\n", + "eine Methode für den Vergleich einer Maschinenzahl fester Länge mit einer Maschinenzahl beliebiger Länge. \n", + ":::\n", + "\n", + "## Zusammengesetzte (_composite_) Typen: `struct`\n", + "\n", + "Eine `struct` ist eine Zusammenstellung von mehreren benannten Feldern und definiert einen konkreten Typ.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "38f2a5ab", + "metadata": {}, + "outputs": [], + "source": [ + "abstract type Point end\n", + "\n", + "mutable struct Point2D <: Point\n", + " x :: Float64\n", + " y :: Float64\n", + "end\n", + "\n", + "mutable struct Point3D <: Point\n", + " x :: Float64\n", + " y :: Float64\n", + " z :: Float64\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "0a7b8685", + "metadata": {}, + "source": [ + "Wie wir schon bei Ausdrücken der Form `x = Int8(33)` gesehen haben, kann man Typnamen direkt als Konstruktoren einsetzen:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cfd64912", + "metadata": {}, + "outputs": [], + "source": [ + "p1 = Point2D(1.4, 3.5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "107ba10e", + "metadata": {}, + "outputs": [], + "source": [ + "p1 isa Point3D, p1 isa Point2D, p1 isa Point" + ] + }, + { + "cell_type": "markdown", + "id": "e96471e5", + "metadata": {}, + "source": [ + "Die Felder einer `struct` können über ihren Namen mit dem `.`-Operator adressiert werden. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e672e78", + "metadata": {}, + "outputs": [], + "source": [ + "p1.y" + ] + }, + { + "cell_type": "markdown", + "id": "5614cb89", + "metadata": {}, + "source": [ + "Da wir unsere `struct` als `mutable` deklariert haben, können wir das Objekt `p1` modifizieren, indem wir den Feldern neue Werte zuweisen.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cd6e9ae8", + "metadata": {}, + "outputs": [], + "source": [ + "p1.x = 3333.4\n", + "p1" + ] + }, + { + "cell_type": "markdown", + "id": "1686641e", + "metadata": {}, + "source": [ + "Informationen über den Aufbau eines Typs oder eines Objekts von diesem Typ liefert `dump()`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "29deb4f7", + "metadata": {}, + "outputs": [], + "source": [ + "dump(Point3D) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d07356bc", + "metadata": {}, + "outputs": [], + "source": [ + " dump(p1)" + ] + }, + { + "cell_type": "markdown", + "id": "e02a2f66", + "metadata": {}, + "source": [ + "## Funktionen und *Multiple dispatch*\n", + "\n", + ":::{.callout-note .titlenormal}\n", + "\n", + "## Objekte, Funktionen, Methoden\n", + "\n", + "In klassischen objektorientierten Sprachen wie C++/Java haben Objekte üblicherweise mit ihnen assoziierte Funktionen, die Methoden des Objekts. \n", + "\n", + "In Julia gehören Methoden zu einer Funktion und nicht zu einem Objekt. \n", + "(Eine Ausnahme sind die Konstruktoren, also Funktionen, die genauso heißen wie ein Typ und ein Objekt dieses Typs erzeugen.) \n", + "\n", + "Sobald man einen neuen Typ definiert hat, kann man sowohl neue als auch bestehende Funktionen um neue Methoden für diesen Typ ergänzen.\n", + "\n", + " - Eine Funktion kann mehrfach für verschiedene Argumentlisten (Typ und Anzahl) definiert werden.\n", + " - Die Funktion hat dann mehrere Methoden.\n", + " - Beim Aufruf wird an Hand der konkreten Argumente entschieden, welche Methode genutzt wird *(multiple dispatch)*.\n", + " - Es ist typisch für Julia, dass für Standardfunktionen viele Methoden definiert sind. Diese können problemlos um weitere Methoden für eigene Typen erweitert werden. \n", + "\n", + ":::\n", + "\n", + "\n", + "Den Abstand zwischen zwei Punkten implementieren wir als Funktion mit zwei Methoden:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2fcc529b", + "metadata": {}, + "outputs": [], + "source": [ + "function distance(p1::Point2D, p2::Point2D)\n", + " sqrt((p1.x-p2.x)^2 + (p1.y-p2.y)^2)\n", + "end\n", + "\n", + "function distance(p1::Point3D, p2::Point3D)\n", + " sqrt((p1.x-p2.x)^2 + (p1.y-p2.y)^2 + (p1.z-p2.z)^2)\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aed12cee", + "metadata": {}, + "outputs": [], + "source": [ + "distance(p1, Point2D(2200, -300))" + ] + }, + { + "cell_type": "markdown", + "id": "796596b1", + "metadata": {}, + "source": [ + "Wie schon erwähnt, zeigt `methods()` die Methodentabelle einer Funktion an:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e7472228", + "metadata": {}, + "outputs": [], + "source": [ + "methods(distance)" + ] + }, + { + "cell_type": "markdown", + "id": "e3d29877", + "metadata": {}, + "source": [ + "Das Macro `@which`, angewendet auf einen vollen Funktionsaufruf mmit konkreter Argumentliste, zeigt an, welche Methode zu diesen konkreten Argumenten ausgewählt wird:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "06ffd7b0", + "metadata": {}, + "outputs": [], + "source": [ + "@which sqrt(3.3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8019fcb5", + "metadata": {}, + "outputs": [], + "source": [ + "z = \"Hallo\" * '!'\n", + "println(z)\n", + "\n", + "@which \"Hallo\" * '!'" + ] + }, + { + "cell_type": "markdown", + "id": "f21cad4e", + "metadata": {}, + "source": [ + "Methoden können auch abstrakte Typen als Argument haben: \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4cf39de0", + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + " Berechnet den Winkel ϕ (in Grad) der Polarkoordinaten (2D) bzw.\n", + " Kugelkoordinaten (3D) eines Punktes\n", + "\"\"\"\n", + "function phi_winkel(p::Point)\n", + " atand(p.y, p.x)\n", + "end\n", + "\n", + "phi_winkel(p1)" + ] + }, + { + "cell_type": "markdown", + "id": "c46f8247", + "metadata": {}, + "source": [ + ":::{.callout-tip collapse=\"true\"}\n", + "Ein in *triple quotes* eingeschlossene Text unmittelbat vor der Funktionsdefinition \n", + "wird automatisch in die Hilfe-Datenbank von Julia integriert:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "997f3797", + "metadata": {}, + "outputs": [], + "source": [ + "?phi_winkel" + ] + }, + { + "cell_type": "markdown", + "id": "f64e264a", + "metadata": {}, + "source": [ + ":::\n", + "\n", + "\n", + "\n", + "Beim *multiple dispatch* wird die Methode angewendet, die unter allen passenden die spezifischste ist. Hier eine Funktion mit mehreren Methoden \n", + "(alle bis auf die letzte in der kurzen [*assignment form*](https://docs.julialang.org/en/v1/manual/functions/#man-functions) geschrieben):\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c0f3b3ee", + "metadata": {}, + "outputs": [], + "source": [ + "f(x::String, y::Number) = \"Args: String + Zahl\"\n", + "f(x::String, y::Int64) = \"Args: String + Int64\"\n", + "f(x::Number, y::Int64) = \"Args: Zahl + Int64\"\n", + "f(x::Int64, y:: Number) = \"Args: Int64 + Zahl\"\n", + "f(x::Number) = \"Arg: eine Zahl\"\n", + "\n", + "function f(x::Number, y::Number, z::String) \n", + " return \"Arg: 2 x Zahl + String\"\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "7c188a97", + "metadata": {}, + "source": [ + "Hier passen die ersten beiden Methoden. Gewählt wird die zweite, da sie spezifischer ist, `Int64 <: Number`. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8f62a9c1", + "metadata": {}, + "outputs": [], + "source": [ + "f(\"Hallo\", 42)" + ] + }, + { + "cell_type": "markdown", + "id": "f15f9c8a", + "metadata": {}, + "source": [ + "Es kann sein, dass diese Vorschrift zu keinem eindeutigen Ergebnis führt, wenn man seine Methoden schlecht gewählt hat. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b8c7b8d", + "metadata": {}, + "outputs": [], + "source": [ + "f(42, 42)" + ] + }, + { + "cell_type": "markdown", + "id": "81e6a8d2", + "metadata": {}, + "source": [ + "## Parametrisierte numerische Typen: `Rational` und `Complex`\n", + "\n", + "\n", + "- Für rationale Zahlen (Brüche) verwendet Julia `//` als Infix-Konstruktor:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "285efd4d", + "metadata": {}, + "outputs": [], + "source": [ + "@show Rational(23, 17) 4//16 + 1//3;" + ] + }, + { + "cell_type": "markdown", + "id": "fd1a9e04", + "metadata": {}, + "source": [ + "- Die imaginäre Einheit $\\sqrt{-1}$ heißt `im`\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "92f7c509", + "metadata": {}, + "outputs": [], + "source": [ + "@show Complex(0.4) 23 + 0.5im/(1-2im);" + ] + }, + { + "cell_type": "markdown", + "id": "12bd71e6", + "metadata": {}, + "source": [ + "`Rational` und `Complex` bestehen, ähnlich wie unser `Point2D`, aus 2 Feldern: Zähler und Nenner bzw. Real- und Imaginärteil.\n", + "\n", + "Der Typ dieser Felder ist allerdings nicht vollständig festgelegt. `Rational` und `Complex` sind _parametrisierte_ Typen.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "caa005d9", + "metadata": {}, + "outputs": [], + "source": [ + "x = 2//7 \n", + "@show typeof(x);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d153b0e2", + "metadata": {}, + "outputs": [], + "source": [ + "y = BigInt(2)//7 \n", + "@show typeof(y) y^48;" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ebcef28d", + "metadata": {}, + "outputs": [], + "source": [ + "x = 1 + 2im\n", + "typeof(x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "512dfe32", + "metadata": {}, + "outputs": [], + "source": [ + "y = 1.0 + 2.0im\n", + "typeof(y)" + ] + }, + { + "cell_type": "markdown", + "id": "a5c41a3b", + "metadata": {}, + "source": [ + "Die konkreten Typen `Rational{Int64}`, `Rational{BigInt}`,..., `Complex{Int64}`, `Complex{Float64}}`, ... sind Subtypen von `Rational` bzw. `Complex`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "366b3941", + "metadata": {}, + "outputs": [], + "source": [ + "Rational{BigInt} <: Rational" + ] + }, + { + "cell_type": "markdown", + "id": "3bf8a72a", + "metadata": {}, + "source": [ + "Die Definitionen [sehen etwa so aus](https://github.com/JuliaLang/julia/blob/master/base/rational.jl#L6-L15):\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "15f36e48", + "metadata": {}, + "outputs": [], + "source": [ + "struct MyComplex{T<:Real} <: Number\n", + " re::T\n", + " im::T\n", + "end\n", + "\n", + "struct MyRational{T<:Integer} <: Real\n", + " num::T\n", + " den::T\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "e72521d9", + "metadata": {}, + "source": [ + "Die erste Definition besagt:\n", + "\n", + "- `MyComplex` hat zwei Felder `re` und `im`, beide vom gleichen Typ `T`. \n", + "- Dieser Typ `T` muss ein Untertyp von `Real` sein. \n", + "- `MyComplex` und alle seine Varianten wie `MyComplex{Float64}` sind Untertypen von `Number`. \n", + "\n", + "und die zweite besagt analog:\n", + "\n", + "- `MyRational` hat zwei Felder `num` und `den`, beide vom gleichen Typ `T`.\n", + "- Dieser Typ `T` muss ein Untertyp von `Integer` sein.\n", + "- `MyRational` und seine Varianten sind Untertypen von `Real`.\n", + "\n", + "Nun ist ℚ$\\subset$ ℝ, oder auf julianisch `Rational <: Real`. Also können die Komponenten einer komplexen Zahl auch rational sein: \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "16d94216", + "metadata": {}, + "outputs": [], + "source": [ + "z = 3//4 + 5im\n", + "dump(z)" + ] + }, + { + "cell_type": "markdown", + "id": "716bc312", + "metadata": {}, + "source": [ + "Diese Strukturen sind ohne das `mutable`-Attribut definiert, also *immutable*:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f9601b06", + "metadata": {}, + "outputs": [], + "source": [ + "x = 2.2 + 3.3im\n", + "println(\"Der Realteil ist: $(x.re)\")\n", + "\n", + "x.re = 4.4 " + ] + }, + { + "cell_type": "markdown", + "id": "5b0fe9d4", + "metadata": {}, + "source": [ + "Das ist so üblich. Wir betrachten das Objekt `9` vom Typ `Int64` ja auch als unveränderlich. \n", + "Das Folgende geht natürlich trotzdem:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d8d626b1", + "metadata": {}, + "outputs": [], + "source": [ + "x += 2.2" + ] + }, + { + "cell_type": "markdown", + "id": "49215683", + "metadata": {}, + "source": [ + "Hier wird ein neues Objekt vom Typ `Complex{Float64}` erzeugt und `x` zur Referenz auf dieses neue Objekt gemacht.\n", + "\n", + "Die Möglichkeiten des Typsystems verleiten leicht zum Spielen. Hier definieren wir eine `struct`, die wahlweise eine Maschinenzahl oder ein Paar von Ganzzahlen enthalten kann: \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "99563913", + "metadata": {}, + "outputs": [], + "source": [ + "struct MyParms{T <: Union{Float64, Tuple{Int64, Int64}}}\n", + " param::T\n", + "end\n", + "\n", + "p1 = MyParms(33.3)\n", + "p2 = MyParms( (2, 4) )\n", + "\n", + "@show p1.param p2.param;" + ] + }, + { + "cell_type": "markdown", + "id": "32e74121", + "metadata": {}, + "source": [ + "## Typen als Objekte\n", + "\n", + "(1) Typen sind ebenfalls Objekte. Sie sind Objekte einer der drei \"Meta-Typen\" \n", + "\n", + " - `Union` (Union-Typen)\n", + " - `UnionAll` (parametrisierte Typen)\n", + " - `DataType` (alle konkreten und sonstige abstrakte Typen)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de573ecf", + "metadata": {}, + "outputs": [], + "source": [ + "@show 23779 isa Int64 Int64 isa DataType; " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4123890d", + "metadata": {}, + "outputs": [], + "source": [ + "@show 2im isa Complex Complex isa UnionAll;" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "05a0390a", + "metadata": {}, + "outputs": [], + "source": [ + "@show 2im isa Complex{Int64} Complex{Int64} isa DataType;" + ] + }, + { + "cell_type": "markdown", + "id": "6537065b", + "metadata": {}, + "source": [ + "Diese 3 konkreten \"Meta-Typen\" sind übrigens Subtypen des abstrakten \"Meta-Typen\" `Type`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "15a5484c", + "metadata": {}, + "outputs": [], + "source": [ + "subtypes(Type)" + ] + }, + { + "cell_type": "markdown", + "id": "6caefeac", + "metadata": {}, + "source": [ + "-----------------\n", + "\n", + "(2) Damit können Typen auch einfach Variablen zugewiesen werden: \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "82d0e5fe", + "metadata": {}, + "outputs": [], + "source": [ + "x3 = Float64\n", + "@show x3(4) x3 <: Real x3==Float64 ; " + ] + }, + { + "cell_type": "markdown", + "id": "e2b3f283", + "metadata": {}, + "source": [ + ":::{.callout-note collapse=\"true\"}\n", + "\n", + "Dies zeigt auch, dass die [Style-Vorgaben in Julia](https://docs.julialang.org/en/v1/manual/style-guide/#Use-naming-conventions-consistent-with-Julia-base/) wie „Typen und Typvariablen starten mit Großbuchstaben, sonstige Variablen und Funktionen werden klein geschrieben.“ nur Konventionen sind und von der Sprache nicht erzwungen werden. \n", + "\n", + "Man sollte sie trotzdem einhalten, um den Code lesbar zu halten. \n", + "\n", + ":::\n", + "\n", + "\n", + "Wenn man solche Zuweisungen mit `const` für dauerhaft erklärt, entsteht ein \n", + " *type alias*.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9138ee10", + "metadata": {}, + "outputs": [], + "source": [ + "const MyCmplxF64 = MyComplex{Float64}\n", + "\n", + "z = MyComplex(1.1, 2.2)\n", + "typeof(z)" + ] + }, + { + "cell_type": "markdown", + "id": "4510cfbf", + "metadata": {}, + "source": [ + "--------\n", + "\n", + "(3) Typen können Argumente von Funktionen sein.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1a0d9a2", + "metadata": {}, + "outputs": [], + "source": [ + "function myf(x, S, T)\n", + " if S <: T\n", + " println(\"$S is subtype of $T\")\n", + " end\n", + " return S(x)\n", + "end\n", + "\n", + "z = myf(43, UInt16, Real)\n", + "\n", + "@show z typeof(z);" + ] + }, + { + "cell_type": "markdown", + "id": "88fff457", + "metadata": {}, + "source": [ + "Wenn man diese Funktion mit Typsignaturen definieren möchte, kann man natürlich\n", + "```julia\n", + "function myf(x, S::Type, T::Type) ... end\n", + "```\n", + "schreiben. Üblicher ist hier die (dazu äquivalente) spezielle Syntax \n", + "```julia\n", + "function myf(x, ::Type{S}, ::Type{T}) where {S,T} ... end\n", + "```\n", + "bei der man in der `where`-Klausel auch noch Einschränkungen an die zulässigen Werte der Typvariablen `S` und `T` stellen kann.\n", + "\n", + "Wie definiere ich eine spezielle Methode von `myf`, die nur aufgerufen werden soll, wenn `S` und `T` gleich `Int64` sind? Das ist folgendermaßen möglich:\n", + "\n", + "```julia\n", + "function myf(x, ::Type{Int64}, ::Type{Int64}) ... end\n", + "```\n", + "`Type{Int64}` wirkt wie ein \"Meta-Typ\", dessen einzige Instanz der Typ `Int64` ist.\n", + "\n", + "\n", + "-----------------\n", + "\n", + "(4) Es gibt zahlreiche Operationen mit Typen als Argumenten. Wir haben schon `<:(T1, T2)`, `supertype(T)`, `supertypes(T)`, `subtypes(T)` gesehen. Erwähnt seien noch `typejoin(T1,T2)` (nächster gemeinsamer Vorfahre im Typbaum) und Tests wie `isconcretetype(T)`, `isabstracttype(T)`, `isstructtype(T)`. \n", + "\n", + "\n", + "\n", + "\n", + "## Invarianz parametrisierter Typen {#sec-invariance}\n", + "\n", + "Kann man in parametrisierten Typen auch nicht-konkrete Typen einsetzen? Gibt es `Complex{AbstractFloat}` oder `Complex{Union{Float32, Int16}}`? \n", + "\n", + "Ja, die gibt es; und es sind konkrete Typen, man kann also Objekte von diesem Typ erzeugen. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "96ebad91", + "metadata": {}, + "outputs": [], + "source": [ + "z5 = Complex{Integer}(2, 0x33)\n", + "dump(z5)" + ] + }, + { + "cell_type": "markdown", + "id": "9ad1639f", + "metadata": {}, + "source": [ + "Das ist eine heterogene Struktur. Jede Komponente hat einen individuellen Typ `T`, für den `T<:Integer` gilt. \n", + "\n", + "Nun gilt zwar\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88a54bfb", + "metadata": {}, + "outputs": [], + "source": [ + "Int64 <: Integer" + ] + }, + { + "cell_type": "markdown", + "id": "1ba2b7d8", + "metadata": {}, + "source": [ + "aber es gilt nicht, dass \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c9b40433", + "metadata": {}, + "outputs": [], + "source": [ + "Complex{Int64} <: Complex{Integer}" + ] + }, + { + "cell_type": "markdown", + "id": "180d71a9", + "metadata": {}, + "source": [ + "Diese Typen sind beide konkret. Damit können sie in der Typhierarchie von Julia nicht in einer Sub/Supertype-Relation zueinander stehen. Julias parametrisierte Typen sind [in der Sprache der theoretischen Informatik](https://de.wikipedia.org/wiki/Kovarianz_und_Kontravarianz) **invariant**. \n", + "(Wenn aus `S<:T` folgen würde, dass auch `ParamType{S} <: ParamType{T}` gilt, würde man von **Kovarianz** sprechen.) \n", + "\n", + "\n", + "\n", + "## Generische Funktionen\n", + "\n", + "Der übliche (und in vielen Fällen empfohlene!) Programmierstil in Julia ist das Schreiben generischer Funktionen:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "81b5863d", + "metadata": {}, + "outputs": [], + "source": [ + "function fsinnfrei1(x, y)\n", + " return x * x * y\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "6c4c8113", + "metadata": {}, + "source": [ + "Diese Funktion funktioniert sofort mit allen Typen, für die die verwendeten Operationen definiert sind.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a29cc84e", + "metadata": {}, + "outputs": [], + "source": [ + "fsinnfrei1( Complex(2,3), 10), fsinnfrei1(\"Hallo\", '!')" + ] + }, + { + "cell_type": "markdown", + "id": "3351849c", + "metadata": {}, + "source": [ + "Man kann natürlich Typ-Annotationen benutzen, um die Verwendbarkeit einzuschränken oder um unterschiedliche Methoden für unterschiedliche Typen zu implementieren: \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "04a3d099", + "metadata": {}, + "outputs": [], + "source": [ + "function fsinnfrei2(x::Number, y::AbstractFloat)\n", + " return x * x * y\n", + "end\n", + "\n", + "function fsinnfrei2(x::String, y::String)\n", + " println(\"Sorry, I don't take strings!\")\n", + "end\n", + "\n", + "\n", + "@show fsinnfrei2(18, 2.0) fsinnfrei2(18, 2);" + ] + }, + { + "cell_type": "markdown", + "id": "178c8f0a", + "metadata": {}, + "source": [ + ":::{.callout-important}\n", + "\n", + "**Explizite Typannotationen sind fast immer irrelevent für die Geschwindigkeit des Codes!**\n", + "\n", + "Dies ist einer der wichtigsten *selling points* von Julia. \n", + "\n", + "Sobald eine Funktion zum ersten Mal mit bestimmten Typen aufgerufen wird, wird eine auf diese Argumenttypen spezialisierte Form der Funktion generiert und compiliert. Damit sind generische Funktionen in der Regel genauso schnell, wie die spezialisierten Funktionen, die man in anderen Sprachen schreibt. \n", + "\n", + "Generische Funktionen erlauben die Zusammenarbeit unterschiedlichster Pakete und eine hohe Abstraktion. \n", + "\n", + "Ein einfaches Beispiel: Das Paket `Measurements.jl` definiert einen neuen Datentyp `Measurement`, einen Wert mit Fehler, und die Arithmetik dieses Typs. Damit funktionieren generische Funktionen automatisch:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "95086dd4", + "metadata": {}, + "outputs": [], + "source": [ + "#| echo: false\n", + "#| output: false\n", + "\n", + "#= \n", + " -Measurements.jl/show.jl adds a method \n", + " Base.show(io::IO, ::MIME\"text/latex\", measure::Measurement)\n", + " - IJulia sends out a text/latex-cell in addition to the text/plain-cell \n", + " \n", + " \"outputs\": [\n", + " {\n", + " \"data\": {\n", + " \"text/latex\": [\n", + " \"$2590.0 \\\\pm 52.0$\"\n", + " ],\n", + " \"text/plain\": [\n", + " \"2590.0 ± 52.0\"\n", + " ]\n", + " },\n", + " whenever it finds this method, see\n", + " https://github.com/JuliaLang/IJulia.jl/commit/7311e517194ddba07af64952b0f9413401213050\n", + "\n", + " - Quarto takes this latex-cell in its qmd -> ipynb->exec->ipynb -> md pipeline, generating a :::{=tex} -div\n", + "\n", + " - so we delete the method\n", + "\n", + "=#\n", + "using Measurements\n", + "zz= @which Base.show(stdout, MIME\"text/latex\"(), 3±2)\n", + "Base.delete_method(zz)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10bd90b2", + "metadata": {}, + "outputs": [], + "source": [ + "using Measurements\n", + "\n", + "x = 33.56±0.3\n", + "y = 2.3±0.02\n", + "\n", + "fsinnfrei1(x, y)" + ] + }, + { + "cell_type": "markdown", + "id": "1a1ebeb6", + "metadata": {}, + "source": [ + ":::\n", + "\n", + "## Typ-Parameter in Funktionsdefinitionen: die `where`-Klausel\n", + "\n", + "Wir wollen eine Funktion schreiben, die für **alle komplexen Integer** (und nur diese) funktioniert, z.B. eine [in ℤ[i] mögliche Primfaktorzerlegung](https://de.wikipedia.org/wiki/Gau%C3%9Fsche_Zahl). Die Definition\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c6c4920a", + "metadata": {}, + "outputs": [], + "source": [ + "#| eval: false\n", + "function isprime(x::Complex{Integer}) ... end" + ] + }, + { + "cell_type": "markdown", + "id": "ff815b70", + "metadata": {}, + "source": [ + "liefert nun nicht das Gewünschte, wie wir in @sec-invariance gesehen haben. Die Funktion würde für ein Argument vom Typ `Complex{Int64}` nicht funktionieren, da letzteres kein Subtyp von `Complex{Integer}` ist.\n", + "\n", + "Wir müssen eine Typ-Variable einführen. Dazu dient die `where`-Klausel.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c7d8952", + "metadata": {}, + "outputs": [], + "source": [ + "#| eval: false\n", + "function isprime(x::Complex{T}) where {T<:Integer}\n", + " ... \n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "324c1a8e", + "metadata": {}, + "source": [ + "Das ist zu lesen als: \n", + "\n", + "> „Das Argument x soll von einem der Typen `Complex{T}` sein, wobei die Typvariable `T` irgendein Untertyp von `Integer` sein kann.“ \n", + "\n", + "Noch ein Beispiel:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "24e71b8d", + "metadata": {}, + "outputs": [], + "source": [ + "#| eval: false\n", + "function kgV(x::Complex{T}, y::Complex{S}) where {T<:Integer, S<:Integer}\n", + " ... \n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "0b0e28c8", + "metadata": {}, + "source": [ + "> Die Argumente x und y können verschiedene Typen haben und beide müssen Subtypen von `Integer` sein.\n", + "\n", + "\n", + "Wenn es nur eine `where`-Klausel wie im vorletzten Beispiel gibt, kann man die geschweiften Klammern weglassen und \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9886c460", + "metadata": {}, + "outputs": [], + "source": [ + "#| eval: false\n", + "function isprime(x::Complex{T}) where T<:Integer\n", + " ... \n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "3e2c6355", + "metadata": {}, + "source": [ + "schreiben. Das lässt sich noch weiter kürzen zu\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0d1e79dd", + "metadata": {}, + "outputs": [], + "source": [ + "#| eval: false\n", + "function isprime(x::Complex{<:Integer}) \n", + " ... \n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "d2b1739e", + "metadata": {}, + "source": [ + "Diese verschiedenen Varianten können verwirrend sein, aber das ist nur Syntax.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "86265284", + "metadata": {}, + "outputs": [], + "source": [ + "C1 = Complex{T} where {T<:Integer} \n", + "C2 = Complex{T} where T<:Integer\n", + "C3 = Complex{<:Integer}\n", + "\n", + "C1 == C2 == C3" + ] + }, + { + "cell_type": "markdown", + "id": "e0eaebf1", + "metadata": {}, + "source": [ + "Kurze Syntax für einfache Fälle, ausführliche Syntax für komplexe Varianten.\n", + "\n", + "Als letztes sein bemerkt, dass `where T` die Kurzform von `where T<:Any` ist, also eine völlig unbeschränkte Typvariable einführt. Damit ist sowas möglich:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d5f32649", + "metadata": {}, + "outputs": [], + "source": [ + "function fgl(x::T, y::T) where T\n", + " println(\"Glückwunsch! x und y sind vom gleichen Typ!\")\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "6b6732ba", + "metadata": {}, + "source": [ + "Diese Methode erfordert, dass die Argumente genau den gleichen, aber ansonsten beliebigen Typ haben. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "81785182", + "metadata": {}, + "outputs": [], + "source": [ + "fgl(33, 44)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7688296", + "metadata": {}, + "outputs": [], + "source": [ + "fgl(33, 44.0)" + ] } ], "metadata": { "kernelspec": { - "display_name": "Julia 1.8.5", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.8" + "name": "julia-1.10" } }, "nbformat": 4,