master > master: handschrift - woche 15 aktualisiert

- 2 Beweise für Sem 9.2a)
- Lsg für Sem 9.2b)+c)

.gitignore

@@ -28,6 +28,10 @@
 !/templates
 !/templates/template*
 
+!/notes/
+!/notes/week*.pdf
+!/notes/README.md
+
 !/src
 !/src/**/
 !/src/**/*.py

README.md

@@ -1,6 +1,7 @@
 # Mathematik für Physiker I, WiSe 2022-23 #
 
-Der Inhalt dieses Repository ist keineswegs verpflichtend, sondern dient dem Zweck, „Handnotizen“ anzubieten.
+Der Inhalt dieses Repository ist keineswegs verpflichtend,
+sondern dient dem Zweck, „Handnotizen“ anzubieten (siehe insbesondere den [./notes/](notes/) Ordner).
 Es besteht hier kein Anspruch auf Vollständigkeit.
 Es werden hier keine offiziellen Lösungen für die Übungsblätter gespeichert.
 
@@ -11,6 +12,7 @@ findet man ausschließlich auf der **Moodle**-Seite.
 
 ```text
 .
+├── ./notes     # Handschrift aus ÜG
 ├── ./notebooks # Python/Jupyter Notebooks
 │   ├── ...
 │   └── ... *.ipynb Dateien

justfile

@@ -104,6 +104,7 @@ build-misc:
     @just _copy-file-if-not-exists "templates/template.env" ".env"
 build-requirements:
     @{{PYTHON}} -m pip install --disable-pip-version-check -r requirements.txt
+    @{{PYTHON}} -m jupyter nbextension enable --py widgetsnbextension
 build-models:
     @echo "Generate data models from schemata."
     @just _delete-if-folder-exists "models/generated"
@@ -120,6 +121,17 @@ dist:
     @just build
     @just build-documentation
 
+# exports notebook to format: html, markdown, pdf, latex.
+export name format="pdf" theme="light":
+    @{{PYTHON}} -m jupyter nbconvert \
+        --allow-chromium-download \
+        --HTMLExporter.theme={{theme}} \
+        --TemplateExporter.exclude_input=false \
+        --to {{format}} \
+        --output-dir notes \
+        --ouput "notebook-{{name}}.{{format}}" \
+        notebooks/{{name}}.ipynb
+
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # TARGETS: run
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -223,6 +235,9 @@ _display-logs:
     @- cat logs/debug.log
     @echo ""
     @echo "----------------"
+logs:
+    @just _create-logs
+    @tail -f logs/debug.log &
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # TARGETS: processes

main.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 import os;
 import sys;
@@ -11,17 +11,17 @@ import sys;
 os.chdir(os.path.dirname(__file__));
 sys.path.insert(0, os.getcwd());
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # MAIN
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 def enter():
     print('Not yet implemented.');
     return;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXECUTION
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 if __name__ == '__main__':
     # sys.tracebacklimit = 0;

notebooks/week-10.ipynb

@@ -0,0 +1,265 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Woche 10 #\n",
+    "\n",
+    "Diese Wochen beschäftigen wir uns mit Matrizen und Vektoren.\n",
+    "In diesem Notebook rechnen wir ein paar (Teil)aufgaben aus dem ÜB."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "'''IMPORTS'''\n",
+    "import os;\n",
+    "import sys; \n",
+    "\n",
+    "# NOTE: need this to force jupyter to reload imports:\n",
+    "for key in list(sys.modules.keys()):\n",
+    "    if key.startswith('src.'):\n",
+    "        del sys.modules[key];\n",
+    "\n",
+    "os.chdir(os.path.dirname(_dh[0]));\n",
+    "sys.path.insert(0, os.getcwd());\n",
+    "\n",
+    "from src.thirdparty.maths import *;\n",
+    "from src.thirdparty.misc import *;\n",
+    "from src.thirdparty.render import *;\n",
+    "from src.maths.diagrams import *;\n",
+    "\n",
+    "np.random.seed(8007253); # zur Wiederholbarkeit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "'''BEISPIEL-SIGNAL'''\n",
+    "n = 100;\n",
+    "u = np.zeros((n,), dtype=complex);\n",
+    "u[8] = -0.7\n",
+    "u[58] = 1j * sqrt(2);\n",
+    "\n",
+    "display_signal(u, 'Beispiel eines Vektors in $\\mathbb{C}^{100}$ als Signal über $\\{0,1,2,\\ldots,99\\}$ dargestellt');"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "'''SEMINARAUFGABE 10.4 a)'''\n",
+    "n = 3;\n",
+    "t = linspace(0, n-1, n);\n",
+    "i, j = np.meshgrid(t, t);\n",
+    "theta = 2*pi * i * j / n;\n",
+    "\n",
+    "# definiere die Matrix F_n + die Vektoren u_nk\n",
+    "F_n = (1/sqrt(n)) * exp(-1j * theta);\n",
+    "u_n = [ (1/sqrt(n)) * exp(1j * theta[:, k]) for k in range(n) ];\n",
+    "\n",
+    "print(dedent(\n",
+    "    f'''\n",
+    "    Matrix:\n",
+    "\n",
+    "    F_{n} = \\n{np.round(F_n, 3)}\n",
+    "    '''\n",
+    "));\n",
+    "print('');\n",
+    "\n",
+    "# NOTE: Programmiersprachen können nicht exakt berechnen.\n",
+    "# Darum entstehen winzige Fehler, die sich durch Runden entfernen lassen.\n",
+    "print('Matrix-Vektor-Produkte:');\n",
+    "for k in range(n):\n",
+    "    result = F_n @ u_n[k];\n",
+    "    print(dedent(\n",
+    "        f'''\n",
+    "\n",
+    "              u_{{n {k}}} = {np.round(u_n[k], 3)}\n",
+    "        F_n · u_{{n {k}}} = {np.round(result, 3)}\n",
+    "        '''\n",
+    "    ));"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Seminaraufgabe 10.4 b) ##\n",
+    "\n",
+    "Für $i\\in\\{0,1,\\ldots,n-1\\}$ ist die $i$-te von $\\mathcal{F}_{n}\\,u_{n,k}$\n",
+    "\n",
+    "$$\n",
+    "    \\begin{array}{rcl}\n",
+    "    (\\mathcal{F}_{n}\\,u_{n,k})_{i}\n",
+    "    &= &\\displaystyle\\sum_{j=0}^{n-1}\n",
+    "        (\\mathcal{F}_{n})_{ij}\\,(u_{n,k})_{j}\\\\\n",
+    "    &= &\\displaystyle\\sum_{j=0}^{n-1}\n",
+    "        \\tfrac{1}{\\sqrt{n}}\n",
+    "        \\exp(-\\imath\\tfrac{2\\pi\\,ij}{n})\n",
+    "        \\cdot\n",
+    "        \\tfrac{1}{\\sqrt{n}}\n",
+    "        \\exp(\\imath\\tfrac{2\\pi\\,kj}{n})\\\\\n",
+    "    &= &\\frac{1}{n}\\displaystyle\\sum_{j=0}^{n-1}\n",
+    "        \\underbrace{\n",
+    "            \\exp(\\imath\\tfrac{2\\pi\\,(k-i)j}{n})\n",
+    "        }_{= r^{j}}\\\\\n",
+    "    \\end{array}\n",
+    "$$\n",
+    "\n",
+    "wobei $r := \\exp(\\imath\\tfrac{2\\pi\\,(k-i)}{n})$.\n",
+    "Wir haben, dass\n",
+    "    $r = 1$\n",
+    "    $\\Leftrightarrow$\n",
+    "        $\\tfrac{k-i}{n} \\in \\mathbb{Z}$\n",
+    "    $\\Leftrightarrow$\n",
+    "        $i = k$,\n",
+    "da $0\\leq i,k \\leq n-1$.\n",
+    "<br>\n",
+    "Es gilt außerdem $r^{n} = \\exp(\\imath 2\\pi\\,(k-i)) = 1$.\n",
+    "<br>\n",
+    "Aus der o.s. Berechnung erhält man also\n",
+    "\n",
+    "$$\n",
+    "    \\begin{array}{rcl}\n",
+    "    (\\mathcal{F}_{n}\\,u_{n,k})_{i}\n",
+    "    &= &\\tfrac{1}{n}\\displaystyle\\sum_{j=0}^{n-1}r^{j}\\\\\n",
+    "    &= &\\tfrac{1}{n}\n",
+    "        \\left\\{\n",
+    "        \\begin{array}{lcl}\n",
+    "            \\displaystyle\\sum_{j=0}^{n-1}1 &: &i = k\\\\\n",
+    "            \\dfrac{1 - r^{n}}{1 - r} &: &\\text{sonst}\\\\\n",
+    "        \\end{array}\n",
+    "        \\right.\\\\\n",
+    "    &= &\\tfrac{1}{n}\n",
+    "        \\left\\{\n",
+    "        \\begin{array}{lcl}\n",
+    "            n &: &i = k\\\\\n",
+    "            \\dfrac{1 - 1}{1 - r} &: &\\text{sonst}\\\\\n",
+    "        \\end{array}\n",
+    "        \\right.\\\\\n",
+    "    &= &\\left\\{\n",
+    "        \\begin{array}{lcl}\n",
+    "            1 &: &i = k\\\\\n",
+    "            0 &: &\\text{sonst}\\\\\n",
+    "        \\end{array}\n",
+    "        \\right.\\\\\n",
+    "    &= &\\delta_{ik}.\\\\\n",
+    "    \\end{array}\n",
+    "$$\n",
+    "\n",
+    "Darum $\\mathcal{F}_{n}\\,u_{n,k}\n",
+    "    = \\left(\\begin{matrix}\n",
+    "        0\\\\\n",
+    "        0\\\\\n",
+    "        \\vdots\\\\\n",
+    "        1\\\\\n",
+    "        \\vdots\\\\\n",
+    "        0\\\\\n",
+    "    \\end{matrix}\\right)\n",
+    "    \\begin{matrix}\n",
+    "        \\\\\n",
+    "        \\\\\n",
+    "        \\\\\n",
+    "        \\leftarrow k\\\\\n",
+    "        \\\\\n",
+    "        \\\\\n",
+    "    \\end{matrix}\n",
+    "    = \\mathbf{e}_{k}$.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "'''SEMINARAUFGABE 10.4 d)'''\n",
+    "n = 4;\n",
+    "t = linspace(0, n-1, n);\n",
+    "i, j = np.meshgrid(t, t);\n",
+    "theta = 2*pi * i * j / n;\n",
+    "\n",
+    "# definiere die Matrix F_n + die Vektoren u_nk\n",
+    "F_n = (1/sqrt(n)) * exp(-1j * theta);\n",
+    "u_n = [ (1/sqrt(n)) * exp(1j * theta[:, k]) for k in range(n) ];\n",
+    "\n",
+    "# Eingabe des Vektors:\n",
+    "F_mal_u = np.asarray([100, -3, 0, -3]); # = F_n @ u\n",
+    "\n",
+    "'''\n",
+    "NOTE: Folgende Koeffizienten wurden falsch erraten.\n",
+    "TODO: Wie lauten die richtigen Werte? -> Aufgabe!\n",
+    "'''\n",
+    "c = [10,10,40,50];\n",
+    "\n",
+    "# Aufschreibung des Signals »bzgl. der harmonischen Basis«:\n",
+    "# u = c[0]u_n[0] + c[1]u_n[1] + c[2]u_n[2] + c[3]u_n[3]\n",
+    "u_guess = sum([ c[k] * u_n[k] for k in range(n) ]);\n",
+    "\n",
+    "# Anzeige der Lösung:\n",
+    "display_signal(u_guess, 'Geschätztes Signal');\n",
+    "\n",
+    "# Verifizierung der Lösung:\n",
+    "display_latex(\n",
+    "    f'''\n",
+    "    $$\n",
+    "    \\\\begin{{array}}{{rcl}}\n",
+    "        \\\\%\\\\text{{error}}\n",
+    "            &\\colonequals\n",
+    "                &\\\\dfrac{{\\\\|u_{{\\\\text{{guess}}}} - u\\\\|}}{{\\\\|u\\\\|}}\\\\\\\\\n",
+    "            &=\n",
+    "                &\\\\dfrac{{\n",
+    "                    \\\\|\\\\mathcal{{F}}_{{n}}\\\\,(u_{{\\\\text{{guess}}}} - u)\\\\|\n",
+    "                }}{{\n",
+    "                    \\\\|\\\\mathcal{{F}}_{{n}}\\\\,u\\\\|\n",
+    "                }}\n",
+    "            \\\\quad\\\\text{{\\\\ldots wieso?? [Stichwort: unitär!]}}\\\\\\\\\n",
+    "            &= &\\\\dfrac{{\n",
+    "                    \\\\|\\\\mathcal{{F}}_{{n}}\\\\,u_{{\\\\text{{guess}}}} - \\\\mathcal{{F}}_{{n}}\\\\,u\\\\|\n",
+    "                }}{{\n",
+    "                    \\\\|\\\\mathcal{{F}}_{{n}}\\\\,u\\\\|\n",
+    "                }}\\\\\\\\\n",
+    "            &= &{linalg.norm(F_n @ u_guess - F_mal_u)/linalg.norm(F_mal_u):.2%}\n",
+    "            \\\\%\n",
+    "            \\\\\\\\\n",
+    "    \\\\end{{array}}\n",
+    "    $$\n",
+    "    '''\n",
+    ");\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notebooks/week-2.ipynb

@@ -13,7 +13,7 @@
     "- [x] Struktur\n",
     "- [x] Aufwärme\n",
     "- [x] Seminaraufgaben 2.x\n",
-    "- [ ] Besprechung von HA 1.x\n"
+    "- ~~[ ] Besprechung von HA 1.x~~\n"
    ]
   },
   {
@@ -22,6 +22,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "# imports\n",
     "import os;\n",
     "import sys; \n",
     "\n",
@@ -38,6 +39,7 @@
     "\n",
     "from src.maths.diagrams import *;\n",
     "from src.maths.sets import *;\n",
+    "from src.widgets import *;\n",
     "\n",
     "np.random.seed(8007253); # zur Wiederholbarkeit"
    ]
@@ -48,6 +50,30 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "# Userinput - Anzahl der Funktionen\n",
+    "fnames   = ['f', 'g', 'h', 'i', 'j'];\n",
+    "setnames = ['X', 'Y', 'Z', 'U', 'V', 'W'];\n",
+    "ctrl = widgets.IntSlider(value=1, description=f'# Funktionen', min=1, max=len(fnames));\n",
+    "display(ctrl);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Widget - Mengen und Funktionen\n",
+    "FunctionDiagramWidget(N=ctrl.value, fnames=fnames, setnames=setnames).run();"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ohne Zufallserzeugung:\n",
     "X = ['a', 'b', 'c', 'd', 'e'];\n",
     "Y = [2, 3, 5, 7, 11, 13, 17];\n",
     "Z = ['α', 'β', 'γ', 'δ'];\n",
@@ -59,24 +85,6 @@
     ");\n",
     "comp.draw(show_labels=True);"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "X = randomset_alphabet(N=3);\n",
-    "Y = randomset_integers(N=5);\n",
-    "Z = randomset_greek(N=7);\n",
-    "f = random_function(X, Y, injective=True);\n",
-    "g = random_function(Y, Z, injective=True);\n",
-    "comp = Functions(\n",
-    "    Function(name=('f', 'X', 'Y'), domain=X, codomain=Y, fct=f),\n",
-    "    Function(name=('g', 'Y', 'Z'), domain=Y, codomain=Z, fct=g),\n",
-    ");\n",
-    "comp.draw(show_labels=False);"
-   ]
   }
  ],
  "metadata": {
@@ -96,6 +104,11 @@
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.10.8"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "98590ff4fe04c8543246b2a01debd3de3c5ca9b666f43f1fa87d5110c692004c"
+   }
   }
  },
  "nbformat": 4,

notebooks/week-3.ipynb

@@ -0,0 +1,36 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Woche 3 - 24.-30. Oktober 2022 #\n",
+    "\n",
+    "Herzlich willkommen zur 3. Woche!\n",
+    "\n",
+    "## Agenda ##\n",
+    "\n",
+    "- [x] Besprechung von HA 2.x\n",
+    "- [x] Seminaraufgaben 3.x"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.10.8 64-bit",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.10.8"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "98590ff4fe04c8543246b2a01debd3de3c5ca9b666f43f1fa87d5110c692004c"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notes/README.md

@@ -0,0 +1,9 @@
+# Handnotizen #
+
+Diese Notizen sollen _nicht_ als Musterlösungen verstanden werden.
+
+Während der ÜG interagieren wir mit dem Stoff + den Aufgaben.
+Wir besprechen **Konzepte** und **Ansätze**.
+Diese Schrift ist also eine Abbildung dieser Diskussionen und Präsentationen.
+Teilweise werden sie nur für die Leute Sinn ergeben, die daran teilgenommen haben und eigene Notizen machen.
+Die Dokumente sind nicht vollständig, da einiges während der Stunden im Raum und an der Tafel erörtert wird.

requirements.txt

@@ -1,16 +1,22 @@
-pip>=22.2.2
+pip>=22.3.1
 wheel>=0.37.1
 
 # jupyter
 ipython>=8.3.0
 jupyter>=1.0.0
+widgetsnbextension>=3.6.1
+# FIXME
+# according to https://github.com/microsoft/vscode-jupyter/issues/8552
+# need to use v 7.7.2 for now
+# ipywidgets>=8.0.2
+ipywidgets==7.7.2
 
 # running
 codetiming>=1.3.0
 
 # testing + dev
 coverage[toml]>=6.4
-pytest>=7.1.1
+pytest>=7.2.0
 pytest-asyncio>=0.18.3
 pytest-cov>=3.0.0
 pytest-lazy-fixture>=0.6.3
@@ -27,13 +33,12 @@ lorem>=0.1.1
 safetywrap>=1.5.0
 typing>=3.7.4.3
 nptyping>=2.1.1
-typing-extensions>=3.10.0.2
 
 # config
 python-dotenv>=0.20.0
 jsonschema>=4.4.0
 lazy-load>=0.8.2
-pyyaml>=5.4.1
+pyyaml>=6.0
 pydantic>=1.9.1
 datamodel-code-generator>=0.12.0
 

src/core/calls.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 from __future__ import annotations;
 
@@ -13,32 +13,30 @@ from src.thirdparty.types import *;
 
 from src.core.utils import *;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
     'CallState',
     'GetState',
     'CallValue',
     'CallError',
-    'keep_calm_and_carry_on',
     'run_safely',
-    'to_async',
 ];
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # CONSTANTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 # local usage only
 T = TypeVar('T');
 V = TypeVar('V');
 ARGS = ParamSpec('ARGS');
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # Class State for keeping track of results in the course of a computation
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 @dataclass
 class CallState(Generic[V]):
@@ -153,9 +151,9 @@ def CallError(
         x = list(map(str, x));
     return CallState(tag=tag, errors=x, has_action=has_action, has_error=True);
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # DECORATOR - forces methods to run safely
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 def run_safely(tag: str | None = None, error_message: str | None = None):
     '''

src/core/env.py

@@ -1,18 +1,18 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 from src.thirdparty.code import *;
 from src.thirdparty.config import *;
 from src.thirdparty.system import *;
 from src.thirdparty.types import *;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
     'get_env_string',
@@ -23,9 +23,9 @@ __all__ = [
     'get_env_optional_float',
 ];
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # AUXILIARY METHODS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 def get_env_value(env: dict, key: str, default: Any = None) -> Any: # pragma: no cover
     return env[key] if key in env else default;

src/core/log.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 from src.thirdparty.code import *;
 from src.thirdparty.io import *;
@@ -13,9 +13,9 @@ from src.thirdparty.types import *;
 
 from src.core.calls import *;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
     'LOG_LEVELS',
@@ -33,9 +33,9 @@ __all__ = [
     'prompt_confirmation',
 ];
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # CONSTANTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 class LOG_LEVELS(Enum): # pragma: no cover
     INFO  = logging.INFO;
@@ -45,9 +45,9 @@ class LOG_LEVELS(Enum): # pragma: no cover
 _LOGGING_DEBUG_FILE: str = 'logs/debug.log';
 T = TypeVar('T');
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # METHODS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 def configure_logging(level: LOG_LEVELS): # pragma: no cover
     logging.basicConfig(
@@ -73,9 +73,9 @@ def log_fatal(*messages: Any):
     logging.fatal(*messages);
     exit(1);
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # Special Methods
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 # Intercept fatal errors
 def catch_fatal(method: Callable[[], T]) -> T:
@@ -105,9 +105,9 @@ def log_result(result: Result[CallState, CallState], debug: bool = False):
             log_error(e);
     return;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # DEBUG LOGGING FOR DEVELOPMENT
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 def log_dev(*messages: Any): # pragma: no cover
     with open(_LOGGING_DEBUG_FILE, 'a') as fp:

src/core/utils.py

@@ -1,26 +1,26 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 from src.thirdparty.code import *;
 from src.thirdparty.misc import *;
 from src.thirdparty.types import *;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
     'flatten',
     'get_timestamp_string',
 ];
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # METHODS - date, time
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 def get_timestamp() -> datetime: # pragma: no cover
     return datetime.now();
@@ -28,9 +28,9 @@ def get_timestamp() -> datetime: # pragma: no cover
 def get_timestamp_string() -> str: # pragma: no cover
     return str(get_timestamp());
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # METHODS arrays
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 def flatten(X: list[list[Any]]) -> list[Any]:
     return list(itertools_chain.from_iterable(X));

src/maths/diagrams/__init__.py

@@ -6,6 +6,7 @@
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 from src.maths.diagrams.sets import *;
+from src.maths.diagrams.signal import *;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
@@ -14,4 +15,5 @@ from src.maths.diagrams.sets import *;
 __all__ = [
     'Function',
     'Functions',
+    'display_signal',
 ];

src/maths/diagrams/sets.py

@@ -28,7 +28,7 @@ __all__ = [
 T1 = TypeVar('T1');
 T2 = TypeVar('T2');
 
-SCALE  = (1., 4.);
+SCALE  = (1., 1.5);
 OFFSET = (3., 0.);
 HMARGIN = 0.1;
 VMARGIN = 0.2;
@@ -63,7 +63,7 @@ class Function(Generic[T1,T2]):
             ];
         return getattr(self, '_indexes');
 
-    def draw(self) -> Figure:
+    def draw(self) -> tuple[Figure, Axes]:
         return Functions(self).draw();
 
 class Functions:
@@ -74,7 +74,7 @@ class Functions:
         self.fcts = list(f);
         self.name = r' \circ '.join([ fct.name[0] for fct in self.fcts ][::-1]);
 
-    def draw(self, show_labels: bool = True) -> Figure:
+    def draw(self, show_labels: bool = True) -> tuple[Figure, Axes]:
         N = len(self.fcts);
         obj = mplot.subplots(1, 1, constrained_layout=True);
         fig: Figure = obj[0];
@@ -119,15 +119,15 @@ class Functions:
         for k, f in enumerate(self.fcts):
             if k == 0:
                 comp_range = f.domain;
-                p_domain = random_points(nr_points=len(f.domain), scale=SCALE, centre=origin + k*offset);
+                p_domain = random_points(nr_points=len(f.domain), scale=SCALE, centre=origin + k*offset, tol=0.5);
             else:
                 p_domain = p_codomain;
-            p_codomain = random_points(nr_points=len(f.codomain), scale=SCALE, centre=origin + (k+1)*offset);
+            p_codomain = random_points(nr_points=len(f.codomain), scale=SCALE, centre=origin + (k+1)*offset, tol=0.5);
             # range of composition so far:
             comp_range_next = [y for x, y in f.fct if x in comp_range];
 
             if k == 0:
-                axs.scatter(p_domain[:, 0], p_domain[:, 1], label='', color='black', marker='o');
+                axs.scatter(p_domain[:, 0], p_domain[:, 1], label='', color='blue', marker='o');
                 if show_labels:
                     for i, p in enumerate(p_domain):
                         x_name = f.domain[i];
@@ -136,7 +136,7 @@ class Functions:
             for j, p in enumerate(p_codomain):
                 y = f.codomain[j];
                 marker = 'o' if (y in comp_range_next) else '.';
-                axs.scatter([p[0]], [p[1]], label='', color='black', marker=marker);
+                axs.scatter([p[0]], [p[1]], label='', color='blue', marker=marker);
                 y_name = f.codomain[j];
                 if show_labels:
                     axs.annotate(text=f'{y_name}', xy=p, textcoords='offset points', xytext=ANNOTATE_OFFSET, ha='center', size=FONTSIZE_PTS);
@@ -146,7 +146,7 @@ class Functions:
                 q = p_codomain[j];
                 x = f.domain[i];
                 if k == 0 or (x in comp_range):
-                    axs.plot([p[0], q[0]], [p[1], q[1]], label='', color='black', linewidth=1);
+                    axs.plot([p[0], q[0]], [p[1], q[1]], label='', color='blue', linewidth=1);
                 else:
                     axs.plot([p[0], q[0]], [p[1], q[1]], label='', color='red', linestyle='--', linewidth=1);
 
@@ -165,8 +165,8 @@ class Functions:
 
             # update range of composition:
             comp_range = comp_range_next;
-
-        return fig;
+        axs.set_aspect('equal')
+        return fig, axs;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # AUXILIARY
@@ -189,7 +189,7 @@ def random_points(
     scale:     tuple[float, float] = (1., 1.),
     centre:    tuple[float, float] = (0., 0.),
     force:     bool = False,
-    tol:       float = 0.2,
+    tol:       float = 0.1,
 ) -> NDArray[Shape['*, 2'], Float]:
     theta = np.linspace(start=0, stop=2*np.pi, num=nr_points, endpoint=False);
     r_min = 0.25;

src/maths/diagrams/signal.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from __future__ import annotations;
+
+from src.thirdparty.code import *;
+from src.thirdparty.types import *;
+from src.thirdparty.maths import *;
+from src.thirdparty.plots import *;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# EXPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+__all__ = [
+    'display_signal',
+];
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# CONSTANTS / VARIABLES
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def display_signal(
+    u: np.ndarray,
+    title: str,
+    max_labels = 10,
+):
+    n = len(u);
+    if n <= max_labels:
+        x_axis = list(range(n));
+    else:
+        skip = int(n/max_labels);
+        x_axis = [ k*skip for k in range(max_labels) ];
+
+    fig, axs = mplot.subplots(1, 1, constrained_layout=True);
+    mplot.title(title);
+    mplot.xlabel('»Zeit« [=Indizes]');
+    mplot.ylabel('Werte [=Einträge]');
+    axs.stem(linspace(0,n-1,n), np.real(u), label='reeller Teil', linefmt='red');
+    axs.stem(linspace(0,n-1,n) + 0.05, np.imag(u), label='imaginärer Teil', linefmt='lime');
+    mplot.legend();
+    axs.set_xticks(x_axis, labels=[ str(index) for index in x_axis]);
+    mplot.show();
+    return;

src/maths/sets/__init__.py

@@ -12,8 +12,8 @@ from src.maths.sets.random import *;
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
+    'Letters',
     'random_function',
     'randomset_alphabet',
-    'randomset_greek',
     'randomset_integers',
 ];

src/maths/sets/random.py

@@ -15,9 +15,9 @@ from src.thirdparty.maths import *;
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
+    'Letters',
     'randomset_integers',
     'randomset_alphabet',
-    'randomset_greek',
     'random_function',
 ];
 
@@ -25,35 +25,75 @@ __all__ = [
 # CONSTANTS / VARIABLES
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-ALPHA = 'abcdefghijklmnopqrstuvwxyz';
-GREEK = 'αβγδεζηθικλμνξοπρςτυφχψω';
+# local usage only
 T1 = TypeVar('T1');
 T2 = TypeVar('T2');
 
+class Letters(Enum):
+    # 'abcdefghijklmnopqrstuvwxyz'
+    ROMAN = [chr(97 + n) for n in range(26)];
+    # 'αβγδεζηθικλμνξοπρςτυφχψω'
+    GREEK = [chr(945 + n) for n in range(25)]
+    # 'אבגדהוזחטיךכלםמןנסעףפץצקרשת' (but <—)
+    HEBREW = [chr(1488 + n) for n in range(27)];
+    SYMBOLS = [
+        r'$|0\rangle$',
+        r'$|\uparrow\rangle$',
+        r'$|\downarrow\rangle$',
+        r'$\sqrt{2}$',
+        r'$\pi$',
+        r'$e$',
+        r'$\frac{1}{137}$',
+        r'$\infty$',
+        # r'$-\infty$',
+        r'$\clubsuit$',
+        # r'$\diamondsuit$',
+        r'$\heartsuit$',
+        # r'$\spadesuit$',
+        r'$\hbar$',
+    ];
+
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # METHODS
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-def randomset_integers(N: int = -1, low: int = 1, high: int = 1) -> list[int]:
+def randomset_integers(
+    N:       int  = -1,
+    low:     int  = 1,
+    high:    int  = 1,
+    shuffle: bool = False,
+) -> list[int]:
     if N == -1:
         N = random.randint(low, high);
-    return list(range(1, N+1));
+    values = list(range(1, N+1));
+    if shuffle:
+        return sample(values, size=N, replace=False);
+    return values;
 
-def randomset_alphabet(N: int = -1, low: int = 1, high: int = 1) -> list[int]:
-    if N == -1:
+def randomset_alphabet(
+    mode: Letters,
+    N:       int  = -1,
+    low:     int  = 1,
+    high:    int  = 1,
+    shuffle: bool = False,
+    full:    bool = False,
+) -> list[str]:
+    letters: list[str] = mode.value;
+    if full:
+        N = len(letters);
+    elif N == -1:
+        high = min(low+1, high)
         N = random.randint(low, high);
-    return list([a for k, a in enumerate(ALPHA) if k < N]);
-
-def randomset_greek(N: int = -1, low: int = 1, high: int = 1) -> list[int]:
-    if N == -1:
-        N = random.randint(low, high);
-    return list([a for k, a in enumerate(GREEK) if k < N]);
+    if shuffle:
+        return sample(letters, size=N, replace=False);
+    return letters[:N];
 
 def random_function(
     X: list[T1],
     Y: list[T2],
     injective: Optional[bool] = None,
     surjective: Optional[bool] = None,
+    force: bool = False,
 ) -> list[tuple[T1, T2]]:
     m = len(X);
     n = len(Y);
@@ -61,6 +101,15 @@ def random_function(
         return [];
     if n == 0:
         raise Exception(f'Impossible to create a function with {m} elements in the domain and {n} in the codomain.');
+    if not force:
+        if injective and m > n:
+            injective = None;
+        if surjective and m < n:
+            surjective = None;
+        if not injective and m == 1:
+            injective = None;
+        if not surjective and n == 1:
+            surjective = None;
     match (injective, surjective):
         case (True, _):
             assert m <= n, f'Impossible to create an injective function with {m} elements in the domain and {n} in the codomain.';

src/thirdparty/code.py

@@ -25,9 +25,9 @@ from safetywrap import Result;
 from safetywrap import Option;
 from safetywrap import Some;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
     'partial',

src/thirdparty/config.py

@@ -15,9 +15,9 @@ from yaml import load as yaml_load;
 from yaml import FullLoader as yaml_FullLoader;
 from yaml import add_path_resolver as yaml_add_path_resolver;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
     'load_dotenv',

src/thirdparty/io.py

@@ -7,9 +7,9 @@
 
 from getpass import getpass;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
     'getpass',

src/thirdparty/log.py

@@ -8,9 +8,9 @@
 import logging;
 from logging import LogRecord;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
     'logging',

src/thirdparty/maths.py

@@ -6,17 +6,55 @@
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 from fractions import Fraction;
+from numpy import cos;
+from numpy import exp;
+from numpy import linalg;
+from numpy import linspace;
+from numpy import pi;
+from numpy import sin;
+from numpy import sqrt;
+from typing import TypeVar;
 import math;
 import numpy as np;
 import random;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# MODIFICATIONS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+# local usage only
+T = TypeVar('T');
+
+def sample(
+    X: list[T],
+    size: int = 1,
+    replace: bool = True,
+) -> list[T]:
+    '''
+    @inputs
+    - `X` - a list
+    - `size` <int> - desired sample size
+    - `replace` <bool> - optional replacement
+
+    @returns a sample from an uniformly distributed set.
+    '''
+    return np.random.choice(X, size=size, replace=replace).tolist();
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
     'Fraction',
+    'cos',
+    'exp',
+    'linalg',
+    'linspace',
     'math',
     'np',
+    'pi',
     'random',
+    'sample',
+    'sin',
+    'sqrt',
 ];

src/thirdparty/misc.py

@@ -64,9 +64,9 @@ def dedent(text: str) -> str:
     '''
     return textwrap_dedent(text);
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
     'lorem',

src/thirdparty/plots.py

@@ -11,9 +11,9 @@ from matplotlib.figure import Figure;
 from matplotlib.axes import Axes;
 from matplotlib.patches import FancyArrowPatch;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
     'mplot',

src/thirdparty/render.py

@@ -6,22 +6,57 @@
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 from IPython.display import Latex;
-from IPython.display import display_latex;
-from IPython.display import display_png;
-from IPython.display import display_markdown;
 from IPython.display import display;
+from IPython.display import display_png;
+from IPython.display import display as display_text_ipython;
+from IPython.display import display_latex as display_latex_ipython;
+from IPython.display import display_markdown as display_md_ipython;
+import ipywidgets as widgets;
 # from array_to_latex import to_ltx as array_to_latex; # <- has issues
 from qiskit.visualization import array_to_latex;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+from functools import wraps;
+from typing import Callable;
+from typing import TypeVar;
+
+from src.thirdparty.misc import dedent;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# MODIFICATIONS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+T1 = TypeVar('T1');
+T2 = TypeVar('T2');
+
+def display_with_dedent(pre_process: Callable[[str], T1] = lambda x: x):
+    '''
+    Returns a decorator that modifies string -> string methods
+    '''
+    def dec(method: Callable[[T1], T2]) -> Callable[[str], T2]:
+        '''
+        Performs method but dedents first.
+        '''
+        @wraps(method)
+        def wrapped_method(text: str) -> T2:
+            return method(pre_process(dedent(text)));
+        return wrapped_method;
+
+    return dec;
+
+display_latex = display_with_dedent(Latex)(display_latex_ipython);
+display_text = display_with_dedent()(display_text_ipython);
+display_markdown = display_with_dedent()(display_md_ipython);
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
     'Latex',
+    'array_to_latex',
     'display',
     'display_latex',
-    'display_png',
     'display_markdown',
-    'array_to_latex',
+    'display_png',
+    'widgets',
 ];

src/thirdparty/run.py

@@ -7,9 +7,9 @@
 
 from codetiming import Timer;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
     'Timer',

src/thirdparty/system.py

@@ -9,9 +9,9 @@ import os;
 from pathlib import Path;
 import sys;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
     'os',

src/thirdparty/types.py

@@ -38,12 +38,12 @@ from typing import Generic;
 from typing import Optional;
 from typing import Type;
 from typing import TypeVar;
-from typing_extensions import Concatenate;
-from typing_extensions import ParamSpec;
+from typing import Concatenate;
+from typing import ParamSpec;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
     'Enum',

src/widgets/__init__.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from src.widgets.function_diagrams import *;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# EXPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+__all__ = [
+    'FunctionDiagramWidget',
+];

src/widgets/function_diagrams.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from __future__ import annotations;
+
+from src.thirdparty.code import *;
+from src.thirdparty.types import *;
+from src.thirdparty.plots import *;
+from src.thirdparty.maths import *;
+from src.thirdparty.render import *;
+
+from src.maths.diagrams import *;
+from src.maths.sets import *;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# EXPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+__all__ = [
+    'FunctionDiagramWidget',
+];
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# EXPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class FunctionProperty(Enum):
+    NOTHING = '—';
+    INJECTIVE = 'injektiv';
+    NOT_INJECTIVE = '¬ injektiv';
+    SURJECTIVE = 'surjektiv';
+    NOT_SURJECTIVE = '¬ surjektiv';
+    BOTH = 'injektiv + surjektiv';
+    INJECTIVE_NOT_SURJECTIVE = 'injektiv + ¬ surjektiv';
+    NOT_INJECTIVE_SURJECTIVE = '¬ injektiv + surjektiv';
+    NEITHER = '¬ injektiv + ¬ surjektiv';
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Class
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class FunctionDiagramWidget():
+    state: Optional[widgets.Output];
+    N: Optional[int];
+    N_max: int;
+    fnames: list[str];
+    setnames: list[str];
+    setsfrom: list[list[Any]];
+    card: list[int];
+
+    ctrl_nr: widgets.IntSlider;
+    btn_refresh: widgets.ToggleButton;
+    ctrls_card: list[widgets.IntSlider];
+    ctrls_property: list[widgets.IntSlider];
+    fcts: Functions;
+
+    def __init__(
+        self,
+        fnames: list[str],
+        setnames: list[str],
+        setsfrom: dict[str, list[Any]] | list[list[Any]] = [],
+        N: Optional[int] = None,
+    ):
+        self.state = None;
+        self.N = N or 1;
+        self.N_max = len(fnames);
+        assert len(setnames) == len(fnames) + 1, f'The number of sets must be {self.N_max+1}.';
+        self.fnames = fnames;
+        self.setnames = setnames;
+        # fix set contents:
+        if isinstance(setsfrom, dict):
+            default = randomset_alphabet(mode=Letters.ROMAN, shuffle=True, full=True);
+            setsfrom = [ setsfrom.get(name, default) for name in setnames ];
+        if len(setsfrom) == 0:
+            setsfrom = [
+                randomset_alphabet(mode=Letters.SYMBOLS, shuffle=True, full=True),
+                randomset_alphabet(mode=Letters.ROMAN, shuffle=True, full=True),
+                randomset_alphabet(mode=Letters.HEBREW, shuffle=True, full=True),
+                randomset_alphabet(mode=Letters.GREEK, shuffle=True, full=True),
+            ];
+        n = len(setsfrom);
+        self.setsfrom = [ setsfrom[k % n] for k, name in enumerate(setnames) ];
+        self.card = [ min(3, len(XX)) for XX in self.setsfrom ];
+
+    def run(self):
+        '''
+        Runs the widget.
+        '''
+        self.create_widgets();
+        display(widgets.interactive_output(
+            f = self.handler_main,
+            controls = {'N': self.ctrl_nr},
+        ));
+        return;
+
+    def create_widgets(self):
+        '''
+        Initialises the widgets.
+        '''
+        N = self.N_max;
+        self.btn_refresh = widgets.ToggleButton(description='Neu laden');
+        self.btn_show_labels = widgets.Checkbox(
+            description = 'Labels anzeigen?',
+            value = True,
+            style       = {
+                'description_width': 'initial',
+            },
+            visible     = True
+        );
+        self.ctrl_nr = widgets.IntSlider(value=self.N, description=f'# Funktionen', min=1, max=self.N_max);
+        cards_max = [ len(XX) for XX in self.setsfrom ];
+        card_max_max = max(cards_max);
+        self.ctrls_card = [
+            widgets.IntSlider(
+                value       = card,
+                description = f'|{setname}|',
+                min         = 1,
+                max         = card_max,
+                layout = {
+                    'width': 'initial',
+                    # FIXME: scales wrong:
+                    # 'width': f'{100*cards_max/card_max_max}%',
+                },
+            )
+            for setname, XX, card, card_max in zip(
+                self.setnames[:(N+1)],
+                self.setsfrom[:(N+1)],
+                self.card[:(N+1)],
+                cards_max[:(N+1)],
+            )
+        ];
+        self.ctrls_property = [
+            widgets.RadioButtons(
+                options     = [ e.value for e in possible_properties(self.card[k], self.card[k+1]) ],
+                value       = FunctionProperty.NOTHING.value,
+                layout      = {
+                    'description_width': 'initial',
+                    'width': 'initial',
+                },
+                disabled    = False,
+            )
+            for k in range(N)
+        ];
+        for k, ctrl_card in enumerate(self.ctrls_card):
+            ctrl_card.observe(partial(self.handler_upd_card, k=k), names='value');
+        # FIXME: this does not behave correctly:
+        self.btn_show_labels.observe(partial(self.handler_plot, create=False));
+        return;
+
+    def handler_main(self, *_, **__):
+        '''
+        Main handler for updating widgets.
+        '''
+        N = self.N = self.ctrl_nr.value;
+        ui = widgets.VBox([] \
+            + [ self.btn_refresh ] \
+            + [ self.btn_show_labels ] \
+            + [ widgets.Text(f'Größen den Mengen:') ] \
+            + self.ctrls_card[:(N+1)] \
+            + [widgets.HBox(
+                [
+                    widgets.VBox(
+                        [
+                            widgets.Text(f'Eigenschaften von {fname}'),
+                            ctrl_property
+                        ],
+                        layout = {
+                            'description_width': 'initial',
+                            'width': 'initial',
+                            'display': 'flex',
+                            'align_items': 'stretch',
+                            'overflow': 'hidden',
+                        }
+                    )
+                    for fname, ctrl_property in zip(self.fnames[:N], self.ctrls_property[:N])
+                ],
+            )],
+        );
+        display(ui);
+        display(widgets.interactive_output(
+            f = self.handler_plot,
+            controls = dict(
+                N           = self.ctrl_nr,
+                refresh     = self.btn_refresh,
+                # FIXME: shoud not have to rely on this:
+                show_labels = self.btn_show_labels,
+                **{
+                    f'card[{k}]': ctrl_card
+                    for k, ctrl_card in enumerate(self.ctrls_card)
+                },
+                **{
+                    f'property[{k}]': ctrl_property
+                    for k, ctrl_property in enumerate(self.ctrls_property)
+                },
+            ),
+        ));
+        return;
+
+    def handler_plot(self, *_, create: bool = True, **__):
+        '''
+        Method to create sets, functions, and plot.
+        '''
+        self.card = [ ctrl_card.value for ctrl_card in self.ctrls_card ];
+        if create:
+            N = self.N;
+            options = list(map(lambda ctrl: ctrl.value, self.ctrls_property[:N]));
+            properties = list(map(option_to_property, options));
+            injective = list(map(is_injective, properties));
+            surjective = list(map(is_surjective, properties));
+            sets = [ XX[:card] for XX, card in zip(self.setsfrom[:(N+1)], self.card[:(N+1)]) ];
+            self.fcts = Functions(*[
+                Function(
+                    name     = (fname, nameX, nameY),
+                    domain   = X,
+                    codomain = Y,
+                    fct      = random_function(X, Y, injective=inj, surjective=surj, force=False),
+                )
+                for fname, nameX, nameY, X, Y, inj, surj in zip(
+                    self.fnames,
+                    self.setnames,
+                    self.setnames[1:],
+                    sets,
+                    sets[1:],
+                    injective,
+                    surjective,
+                )
+            ]);
+        # FIXME:
+        # upon toggling show labels button, this even triggers multiple times,
+        # and only the old value registers.
+        show_labels = self.btn_show_labels.value;
+        fig, axs = self.fcts.draw(show_labels=show_labels);
+        return;
+
+    def handler_upd_card(self, change, k: int):
+        '''
+        Handler for altering function property options
+        upon change of set cardinality.
+        '''
+        self.card[k] = change['new'];
+
+        def upd(j: int):
+            m = self.card[j];
+            n = self.card[j+1];
+            value = self.ctrls_property[j].value;
+            options = [ e.value for e in possible_properties(m, n) ];
+            if value not in options:
+                value = FunctionProperty.NOTHING.value;
+            self.ctrls_property[j].options = options;
+            self.ctrls_property[j].value = value;
+            return;
+
+        if k > 0:
+            upd(k-1);
+        if k < self.N:
+            upd(k);
+        return;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# AUXILIARY METHODS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def option_to_property(option: str) -> Optional[FunctionProperty]:
+    try:
+        return FunctionProperty(option);
+    except:
+        return None;
+
+def possible_properties(m: int = 1, n: int = 1) -> list[FunctionProperty]:
+    if m == n:
+        if m == 1:
+            return [
+                e for e in FunctionProperty
+                if (is_injective(e) not in [False])
+                and (is_surjective(e) not in [False])
+            ];
+        else:
+            return [
+                e for e in FunctionProperty
+                if not (is_surjective(e) in [True] and is_injective(e) in [False])
+                and not (is_surjective(e) in [False] and is_injective(e) in [True])
+            ];
+    elif m == 1 and n > 1:
+        return [
+            e for e in FunctionProperty
+            if (is_injective(e) not in [False])
+            and (is_surjective(e) not in [True])
+        ];
+    elif n == 1 and m > 1:
+        return [
+            e for e in FunctionProperty
+            if (is_surjective(e) not in [False])
+            and (is_injective(e) not in [True])
+        ];
+    elif m > n:
+        return [
+            e for e in FunctionProperty
+            if (is_injective(e) not in [True])
+        ];
+    elif n > m:
+        return [
+            e for e in FunctionProperty
+            if (is_surjective(e) not in [True])
+        ];
+    return [ e for e in FunctionProperty ];
+
+def is_injective(property: Optional[FunctionProperty]) -> Optional[bool]:
+    match property:
+        case FunctionProperty.INJECTIVE | FunctionProperty.INJECTIVE_NOT_SURJECTIVE | FunctionProperty.BOTH:
+            return True;
+        case FunctionProperty.NOT_INJECTIVE | FunctionProperty.NOT_INJECTIVE_SURJECTIVE | FunctionProperty.NEITHER:
+            return False;
+    return None;
+
+def is_surjective(property: Optional[FunctionProperty]) -> Optional[bool]:
+    match property:
+        case FunctionProperty.SURJECTIVE | FunctionProperty.NOT_INJECTIVE_SURJECTIVE | FunctionProperty.BOTH:
+            return True;
+        case FunctionProperty.NOT_SURJECTIVE | FunctionProperty.INJECTIVE_NOT_SURJECTIVE | FunctionProperty.NEITHER:
+            return False;
+    return None;