From c4d1e2e8a858fd6daf77712472b133eafae68e8a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lukas=20M=C3=BCller?= <muellerl@mv.uni-kl.de>
Date: Mon, 3 May 2021 14:58:46 +0200
Subject: [PATCH] changed to map(function, values) and translated to english
---
"\303\234bung 1.ipynb" | 1357 +++++++++++++++++++++++++++++++++++-----
1 file changed, 1214 insertions(+), 143 deletions(-)
diff --git "a/\303\234bung 1.ipynb" "b/\303\234bung 1.ipynb"
index 853d1c1..811e462 100644
--- "a/\303\234bung 1.ipynb"
+++ "b/\303\234bung 1.ipynb"
@@ -4,124 +4,141 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "# Übung 1\n",
+ "# Übungsblatt 1\n",
"\n",
- "Im Vergleich zu Matlab müssen Pakete in Python importiert werden. Wir importieren daher hier zunächst die Bibliotheken NumPy\n",
- "und Matplotlib.\n",
+ "## Darstellung der Funktionen\n",
"\n",
- "NumPy bietet viele mathematische Operationen wie Sinus und Cosinus, aber vor allem auch Matrixoperationen. Matplotlib ermöglicht\n",
- "es uns unsere Berechungen zu visualisieren."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "import numpy\n",
- "from matplotlib import pyplot\n",
- "# Ein Notebook spezifischer Befehl zur Darstellung der Grafiken im Notebook\n",
- "%matplotlib inline"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Wir füllen zunächst einen Vektor mit Werten, die unsere abgetastete Zeit repräsentieren."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "dt = 0.01 # (Abtast-)Schrittweite festlegen\n",
- "t_start = -5\n",
- "t_end = 5\n",
- "t_array = numpy.arange(t_start, t_end, dt) # numpy.arange \"tastet\" den Bereich zwischen t_start und t_end mit dt ab\n",
- "print(t_array)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Wir definieren nun unsere Funktionen $x(t),\\:g(t)$ und $f(t)$"
+ "Wir definieren unsere Funktionen $x(t),\\:g(t)$ und $f(t)$:\n",
+ "\n",
+ "$$\n",
+ " x(t)=\n",
+ " \\begin{cases}\n",
+ " 2, & 0\\leq t<1\\\\\n",
+ " 0, & \\text{sonst}\n",
+ " \\end{cases},\\quad\n",
+ " f(t)=\n",
+ " \\begin{cases}\n",
+ " 1, & 0\\leq t<2\\\\\n",
+ " 0, & \\text{sonst}\n",
+ " \\end{cases},\\quad\n",
+ " g(t)=\n",
+ " \\begin{cases}\n",
+ " e^{-t},& t \\geq0\\\\\n",
+ " 0,& \\text{sonst}\n",
+ " \\end{cases}\n",
+ "$$"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
- "def x(t_array):\n",
- " ergebnis = []\n",
- " for t in t_array:\n",
- " if 0 <= t < 1:\n",
- " ergebnis.append(2)\n",
- " else:\n",
- " ergebnis.append(0)\n",
- " return ergebnis\n",
+ "import numpy # math operations\n",
+ "from numpy import exp # for direct usage\n",
+ "from matplotlib import pyplot # plotting\n",
+ "pyplot.rcParams[\"figure.figsize\"] = (9.5, 5) # standard figure size\n",
+ "%matplotlib inline\n",
"\n",
- "def f(t_array):\n",
- " ergebnis = []\n",
- " for t in t_array:\n",
- " if 0 <= t < 2:\n",
- " ergebnis.append(1)\n",
- " else:\n",
- " ergebnis.append(0)\n",
- " return ergebnis\n",
+ "# creating a time \"scale\" to plug into the functions\n",
+ "dt = 0.01 # sampling rate\n",
+ "t0 = -5\n",
+ "t1 = 5\n",
+ "t = numpy.arange(t0, t1, dt) # numpy.arange samples values between t0 and t1 with sampling rate dt\n",
"\n",
- "def g(t_array):\n",
- " ergebnis = []\n",
- " for t in t_array:\n",
- " if t >= 0:\n",
- " ergebnis.append(numpy.exp(-t))\n",
- " else:\n",
- " ergebnis.append(0)\n",
- " return ergebnis"
+ "def x(t):\n",
+ " if 0 <= t < 1:\n",
+ " return 2\n",
+ " else:\n",
+ " return 0\n",
+ " \n",
+ "def f(t):\n",
+ " if 0 <= t < 2:\n",
+ " return 1\n",
+ " else:\n",
+ " return 0\n",
+ " \n",
+ "def g(t):\n",
+ " if t >= 0:\n",
+ " return exp(-t)\n",
+ " else:\n",
+ " return 0"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "Wir stellen nun unsere Funktionen in Grafiken dar."
+ "Wir stellen nun unsere Funktionen in Grafiken dar.\n",
+ "## $x(t)$"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 2,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 684x360 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# plotting\n",
+ "pyplot.plot(t, numpy.array(list(map(x, t))), 'b')\n",
+ "# some formatting\n",
+ "pyplot.xlabel('t') # label for the x-axis\n",
+ "pyplot.ylabel('x') # label for the y-axis\n",
+ "pyplot.ylim(-1, 3) # setting limits for the y-axis\n",
+ "pyplot.title('Eingangsfunktion') # titel of the plot\n",
+ "pyplot.show() # showing the plot"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
"source": [
- "pyplot.plot(t_array, x(t_array), 'b')\n",
- "pyplot.xlabel('t') # Beschriftung der x-Achse\n",
- "pyplot.ylabel('x') # Beschriftung der y-Achse\n",
- "pyplot.ylim(-1, 3) # Achsenbereiche festlegen\n",
- "pyplot.title('Eingangsfunktion') # Titel der Abbildung\n",
- "pyplot.show() # Der Plot muss eingeblendet werden"
+ "## $g(t)$"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 3,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 684x360 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
"source": [
- "pyplot.plot(t_array, g(t_array), 'g')\n",
+ "# plotting\n",
+ "pyplot.plot(t, numpy.array(list(map(g, t))), 'g')\n",
"pyplot.xlabel('t')\n",
"pyplot.ylabel('g')\n",
"pyplot.ylim(-1, 3)\n",
@@ -129,17 +146,37 @@
"pyplot.show()"
]
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## $f(t)$"
+ ]
+ },
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 4,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAFNCAYAAAAdElvFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAV80lEQVR4nO3de6xlZ3kf4N/rGQMVpnYaj4Jje7Bp3BDCzWFqQEiFcklt18W0hWLaEshFUxGsgASKuEjQ8kdEggQtMoozAhRDSXDELRM6iDrgFNIIl7E7NtgOZEra2q4TjA3GVgjU8ds/zjY9HJ8ZL4zP/maf9TzS1qy91ue9X+2NPn7nXd/aq7o7AAAc3XGjCwAAWAVCEwDABEITAMAEQhMAwARCEwDABEITAMAEQhOw7VTVT1bVoaq6q6p+par+UVV9/Cjjn1RVf7LEEoEVtHN0AQBb4FeTXNndT0mSqjqY5OL7DlZVJzmruw8nSXdfV1XfrKp/0t1/MKJg4Nin0wRsR49Jcn2SVNXfT3Jid3/+Af6bDyb5N1tdGLC6hCZgW6mqzyT5h0kuqaq7k5yX5L+sO/7Zxea1VXV3Vb1k8fyPkjy3qh6+zHqB1SE0AdtKdz8nyeeSXNzdJyR5YpIvrzv+DxabT+7uE7r78sX+W5L83yQ/ueSSgRUhNAHb3UlJ7po49q7FeID7EZqA7e4bSR41ceyjknxz60oBVpnQBGx31yX5ew80qKpOTfKwrDuVB7Ce0ARsdweSPGvDvr9M8tgN+56V5DPd/Z2lVAWsHKEJ2Na6+5okd1bV09bt/rdJLlv8NtO/WOz7V0kuXXZ9wOqo7h5dA8CWqqqfTfLL3f3CIxx/UpLf6u5nLLUwYKUITQAAEww7PVdVj6iq/1ZV11bV9VX17zYZ8/CquryqDlfVVVV1xoBSAQCGrmn6TpLndPeTkzwlyblV9fQNY34xyTe6+yeSvDPJry+3RACANcNCU6+5e/H0+MVj47nCC5Ncttj+cNZucVBLKhEA4HuGXj1XVTuq6lCSryW5oruv2jDk1CQ3JUl335PkziQ/utQiAQCS7Bz55t39N0meUlUnJflYVT2hu7/0g75OVe1NsjdJHvnIRz71cY973ENbKAAwG1dfffXXu3vXxv1DQ9N9uvubVXVlknOTrA9NtyQ5PcnNVbUzyYlJbt/kv9+XZF+S7Nmzpw8ePLj1RQMA21JV/a/N9o+8em7XosOUqvpbSZ6f5E83DNuf5OWL7Rdl7dd6/UYCALB0IztNp2TtF3l3ZC28/V53f6Kq3prkYHfvT/LeJB+oqsNJ7khy0bhyAYA5Gxaauvu6JGdvsv/N67b/OsmLl1kXAMBm3HsOAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGCCYaGpqk6vqiur6oaqur6qXr3JmGdX1Z1VdWjxePOIWgEAdg5873uSvLa7r6mqRyW5uqqu6O4bNoz7XHdfMKA+AIDvGdZp6u5bu/uaxfZdSW5McuqoegAAjuaYWNNUVWckOTvJVZscfkZVXVtVn6yqn15uZQAAa0aenkuSVNUJST6S5DXd/a0Nh69J8pjuvruqzk/y8SRnbfIae5PsTZLdu3dvbcEAwCwN7TRV1fFZC0wf7O6Pbjze3d/q7rsX2weSHF9VJ28ybl937+nuPbt27dryugGA+Rl59VwleW+SG7v7HUcY8+jFuFTVOVmr9/blVQkAsGbk6blnJnlZki9W1aHFvjcm2Z0k3X1pkhcleWVV3ZPk20ku6u4eUCsAMHPDQlN3/3GSeoAxlyS5ZDkVAQAc2TFx9RwAwLFOaAIAmEBoAgCYQGgCAJhAaAIAmEBoAgCYQGgCAJhAaAIAmEBoAgCYQGgCAJhAaAIAmEBoAgCYQGgCAJhAaAIAmEBoAgCYQGgCAJhAaAIAmEBoAgCYQGgCAJhAaAIAmEBoAgCYQGgCAJhAaAIAmEBoAgCYQGgCAJhgWGiqqtOr6sqquqGqrq+qV28ypqrqXVV1uKquq6qfGVErAMDOge99T5LXdvc1VfWoJFdX1RXdfcO6MeclOWvxeFqS31z8CwCwVMM6Td19a3dfs9i+K8mNSU7dMOzCJO/vNZ9PclJVnbLkUgEAjo01TVV1RpKzk1y14dCpSW5a9/zm3D9YAQBsueGhqapOSPKRJK/p7m89yNfYW1UHq+rgbbfd9tAWCACQwaGpqo7PWmD6YHd/dJMhtyQ5fd3z0xb7vk937+vuPd29Z9euXVtTLAAwayOvnqsk701yY3e/4wjD9if5ucVVdE9Pcmd337q0IgEAFkZePffMJC9L8sWqOrTY98Yku5Okuy9NciDJ+UkOJ/mrJD+//DIBAAaGpu7+4yT1AGM6yauWUxEAwJENXwgOALAKhCYAgAmEJgCACYQmAIAJhCYAgAmEJgCACYQmAIAJhCYAgAmEJgCACYQmAIAJhCYAgAmEJgCACYQmAIAJhCYAgAmEJgCACYQmAIAJhCYAgAmEJgCACYQmAIAJhCYAgAmEJgCACYQmAIAJhCYAgAmEJgCACYQmAIAJhoamqnpfVX2tqr50hOPPrqo7q+rQ4vHmZdcIAJAkOwe//28nuSTJ+48y5nPdfcFyygEA2NzQTlN3fzbJHSNrAACYYhXWND2jqq6tqk9W1U+PLgYAmKfRp+ceyDVJHtPdd1fV+Uk+nuSsjYOqam+SvUmye/fupRYIAMzDMd1p6u5vdffdi+0DSY6vqpM3Gbevu/d0955du3YtvU4AYPs7pkNTVT26qmqxfU7W6r19bFUAwBwNPT1XVb+b5NlJTq6qm5O8JcnxSdLdlyZ5UZJXVtU9Sb6d5KLu7kHlAgAzNjQ0dfdLH+D4JVn7SQIAgKGO6dNzAADHCqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBggqGhqareV1Vfq6ovHeF4VdW7qupwVV1XVT+z7BoBAJLxnabfTnLuUY6fl+SsxWNvkt9cQk0AAPczNDR192eT3HGUIRcmeX+v+XySk6rqlOVUBwDw/+080oGq+kB3v6yqXt3d/2GZRa1zapKb1j2/ebHv1jHlACvvE59IXve65N57R1cyX2efnVx++egq4Ad2xNCU5KlV9eNJfqGq3p+k1h/s7qN1iJaqqvZm7fRddu/ePbga4Jj2uc8lX/lKctFFoyuZp0OHko9/fHQV8KAcLTRdmuTTSR6b5Op8f2jqxf6tdkuS09c9P22x7/t0974k+5Jkz549vYS6gFV1773JIx6R/M7vjK5knt70puQ3fmN0FfCgHHFNU3e/q7t/Ksn7uvux3X3muscyAlOS7E/yc4ur6J6e5M7udmoOePC6k+NGXwMzY8cdt/YdwAo6WqcpSdLdr9yqN6+q303y7CQnV9XNSd6S5PjF+16a5ECS85McTvJXSX5+q2oBZuLee4WmkY47znoyVtYDhqat1N0vfYDjneRVSyoHmIN7702qHngcW6NqrdPU7Xtg5fhzC5gXnaax7vvsnaJjBZk5gHkRmsa677N3io4VZOYA5sVC8LF0mlhhZg5gXnSaxtJpYoWZOYB5sRB8rPs+e6GJFSQ0AfOi0zSWThMrzMwBzIvQNJbQxAozcwDzYiH4WBaCs8LMHMC86DSNpdPECjNzAPMiNI0lNLHCzBzAvLh6bixXz7HChCZgXnSaxtJpYoWZOYB5EZrGEppYYWYOYF5cPTeWq+dYYWYOYF50msbSaWKFmTmAebEQfCwLwVlhQhMwLzpNY+k0scLMHMC8CE1jCU2sMDMHMC8Wgo9lITgrzMwBzItO01g6TawwMwcwL0LTWEITK8zMAcyLq+fGcvUcK0xoAuZFp2ksnSZWmJkDmBehaSyhiRVm5gDmxdVzY7l6jhU2dOaoqnOr6stVdbiqXr/J8VdU1W1VdWjx+KURdQLbiE7TWDpNrLCdo964qnYkeXeS5ye5OckXqmp/d9+wYejl3X3x0gsEticLwceyEJwVNvLPrXOSHO7ur3b3d5N8KMmFA+sB5kCnaSydJlbYyJnj1CQ3rXt+82LfRv+8qq6rqg9X1enLKQ3YtoSmsYQmVtixPnP8QZIzuvtJSa5Ictlmg6pqb1UdrKqDt91221ILBFaMheBjWQjOChs5c9ySZH3n6LTFvu/p7tu7+zuLp+9J8tTNXqi793X3nu7es2vXri0pFtgmdJrG0mlihY2cOb6Q5KyqOrOqHpbkoiT71w+oqlPWPX1BkhuXWB+wHVkIPpaF4KywYVfPdfc9VXVxkk8l2ZHkfd19fVW9NcnB7t6f5Feq6gVJ7klyR5JXjKoX2CZ0msbSaWKFDQtNSdLdB5Ic2LDvzeu235DkDcuuC9jGhKaxhCZWmJkDmBcLwceyEJwVZuYA5kWnaSydJlaYmQOYF6FpLKGJFWbmAObF1XNjuXqOFSY0AfOi0zSWThMrzMwBzIvQNJbQxAozcwDz4uq5sVw9xwozcwDzotM0lk4TK8zMAcyLheBjWQjOChOagHnRaRpLp4kVZuYA5kVoGktoYoWZOYB5sRB8LAvBWWFmDmBedJrG0mlihZk5gHkRmsYSmlhhZg5gXlw9N5ar51hhQhMwLzpNY+k0scLMHMC8CE1jCU2sMDMHMC+unhvL1XOsMDMHMC86TWPpNLHCzBzAvFgIPpaF4KwwoQmYF52msXSaWGFmDmBehKaxhCZWmJkDmBcLwceyEJwVZuYA5kWnaSydJlaYmQOYF6FpLKGJFTZ05qiqc6vqy1V1uKpev8nxh1fV5YvjV1XVGQPKBLYTV8+N5eo5Vtiw0FRVO5K8O8l5SR6f5KVV9fgNw34xyTe6+yeSvDPJry+3SmDb0WkaS6eJFTZy5jgnyeHu/mp3fzfJh5JcuGHMhUkuW2x/OMlzq/yJCDxI9y0+FprGEZpYYTsHvvepSW5a9/zmJE870pjuvqeq7kzyo0m+vpQKN7r22uS884a8NfAQEJrG27Fj7d+3vCV5+9vH1sLq+uQnkyc/eelvOzI0PWSqam+SvUmye/furXujE09MLrhg614f2Ho7diQvecnoKubrhBOSX/u15M//fHQlrLITTxzytiND0y1JTl/3/LTFvs3G3FxVO5OcmOT2jS/U3fuS7EuSPXv2bN2Pf5xxRrJv35a9PMAsvOENoyuAB2Vkj/oLSc6qqjOr6mFJLkqyf8OY/Ulevth+UZLPdPtFNABg+YZ1mhZrlC5O8qkkO5K8r7uvr6q3JjnY3fuTvDfJB6rqcJI7shasAACWbuiapu4+kOTAhn1vXrf910levOy6AAA2cgkJAMAEQhMAwARCEwDABEITAMAEQhMAwARCEwDABEITAMAEQhMAwARCEwDABEITAMAEQhMAwARCEwDABEITAMAEQhMAwARCEwDABEITAMAEQhMAwARCEwDABEITAMAEQhMAwARCEwDABEITAMAEQhMAwARCEwDABEITAMAEQ0JTVf2dqrqiqv5s8e+PHGHc31TVocVj/7LrBAC4z6hO0+uTfLq7z0ry6cXzzXy7u5+yeLxgeeUBAHy/UaHpwiSXLbYvS/LCQXUAAEwyKjT9WHffutj+iyQ/doRxj6iqg1X1+ap64XJKAwC4v51b9cJV9YdJHr3JoTetf9LdXVV9hJd5THffUlWPTfKZqvpid/+PTd5rb5K9SbJ79+4fsnIAgPvbstDU3c870rGq+suqOqW7b62qU5J87Qivccvi369W1R8lOTvJ/UJTd+9Lsi9J9uzZc6QABgDwoI06Pbc/ycsX2y9P8vsbB1TVj1TVwxfbJyd5ZpIbllYhAMA6o0LT25I8v6r+LMnzFs9TVXuq6j2LMT+V5GBVXZvkyiRv626hCQAYYstOzx1Nd9+e5Lmb7D+Y5JcW23+S5IlLLg0AYFN+ERwAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYAKhCQBgAqEJAGACoQkAYIIhoamqXlxV11fVvVW15yjjzq2qL1fV4ap6/TJrBABYb1Sn6UtJ/lmSzx5pQFXtSPLuJOcleXySl1bV45dTHgDA99s54k27+8YkqaqjDTsnyeHu/upi7IeSXJjkhi0vEABgg2N5TdOpSW5a9/zmxT4AgKXbsk5TVf1hkkdvcuhN3f37D/F77U2yd/H07qr68kP5+tvQyUm+PrqIGfP5j+c7GMvnP57v4Oges9nOLQtN3f28H/Ilbkly+rrnpy32bfZe+5Ls+yHfbzaq6mB3H3EBPlvL5z+e72Asn/94voMH51g+PfeFJGdV1ZlV9bAkFyXZP7gmAGCmRv3kwD+tqpuTPCPJf6qqTy32/3hVHUiS7r4nycVJPpXkxiS/193Xj6gXAGDU1XMfS/KxTfb/nyTnr3t+IMmBJZY2F05ljuXzH893MJbPfzzfwYNQ3T26BgCAY96xvKYJAOCYITTNXFW9tqq6qk4eXcucVNXbq+pPq+q6qvpYVZ00uqY5cGumsarq9Kq6sqpuWNxK69Wja5qjqtpRVf+9qj4xupZVIzTNWFWdnuRnk/zv0bXM0BVJntDdT0rylSRvGFzPtufWTMeEe5K8trsfn+TpSV7lOxji1Vm7wIofkNA0b+9M8qtJLGxbsu7+z4srRJPk81n7HTK21vduzdTd301y362ZWJLuvrW7r1ls35W1/+N2p4clqqrTkvzjJO8ZXcsqEppmqqouTHJLd187uhbyC0k+ObqIGXBrpmNIVZ2R5OwkVw0uZW7+fdb+WL53cB0rachPDrAcR7uVTZI3Zu3UHFtkyq2EqupNWTtl8cFl1gYjVdUJST6S5DXd/a3R9cxFVV2Q5GvdfXVVPXtwOStJaNrGjnQrm6p6YpIzk1xbVcnaqaFrquqc7v6LJZa4rT3QrYSq6hVJLkjy3PbbH8sw+dZMbJ2qOj5rgemD3f3R0fXMzDOTvKCqzk/yiCR/u6r+Y3f/68F1rQy/00Sq6n8m2dPdbt64JFV1bpJ3JHlWd982up45qKqdWVt0/9yshaUvJPmX7jSwPLX2V9plSe7o7tcMLmfWFp2m13X3BYNLWSnWNMEYlyR5VJIrqupQVV06uqDtzq2ZjgnPTPKyJM9Z/O/+0KLrAStBpwkAYAKdJgCACYQmAIAJhCYAgAmEJgCACYQmAIAJhCZgNqrqpKr65dF1AKtJaALm5KQkQhPwoAhNwJy8LcnfXfyo4ttHFwOsFj9uCcxGVZ2R5BPd/YTRtQCrR6cJAGACoQkAYAKhCZiTu7J2o2SAH5jQBMxGd9+e5L9W1ZcsBAd+UBaCAwBMoNMEADCB0AQAMIHQBAAwgdAEADCB0AQAMIHQBAAwgdAEADCB0AQAMMH/AxYdndpg3pwbAAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ "<Figure size 684x360 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
"source": [
- "pyplot.plot(t_array, f(t_array), 'r')\n",
+ "pyplot.plot(t, numpy.array(list(map(f, t))), 'r')\n",
"pyplot.xlabel('t')\n",
"pyplot.ylabel('f')\n",
"pyplot.ylim(-1, 3)\n",
@@ -151,7 +188,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### Faltung\n",
+ "## Faltung der Funktionen\n",
"\n",
"Wir definieren die Faltung als Funktion, wobei wir als Eingabeparameter das Zeitarray sowie die beiden zu faltenden Funktionen benötigen.\n",
"\n",
@@ -163,69 +200,1081 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 5,
"metadata": {
"pycharm": {
"name": "#%%\n"
},
"scrolled": false
},
- "outputs": [],
- "source": [
- "# Vorbereitung für die Plots\n",
- "import ipywidgets # Benötigt für den Schieberegler\n",
- "\n",
- "def faltung(t_array, x, f):\n",
- " ergebnis = []\n",
- " x_ergebnis = x(t_array)\n",
- " for t in t_array:\n",
- " f_ergebnis = f(t-t_array)\n",
- " sum = 0\n",
- " for i in range(0,len(t_array)):\n",
- " sum += x_ergebnis[i]*f_ergebnis[i]*dt\n",
- " ergebnis.append(sum)\n",
- " # tau_array = t_array.copy()\n",
- " # for i in range(0,len(t_array)):\n",
- " # t = t_array[i]\n",
- " # sum = 0\n",
- " # for tau in tau_array:\n",
- " # sum += x([tau])[0]*f([t-tau])[0]\n",
- " # ergebnis.append(sum)\n",
- " return ergebnis"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "pycharm": {
- "name": "#%%\n"
+ "outputs": [
+ {
+ "data": {
+ "application/javascript": [
+ "/* Put everything inside the global mpl namespace */\n",
+ "/* global mpl */\n",
+ "window.mpl = {};\n",
+ "\n",
+ "mpl.get_websocket_type = function () {\n",
+ " if (typeof WebSocket !== 'undefined') {\n",
+ " return WebSocket;\n",
+ " } else if (typeof MozWebSocket !== 'undefined') {\n",
+ " return MozWebSocket;\n",
+ " } else {\n",
+ " alert(\n",
+ " 'Your browser does not have WebSocket support. ' +\n",
+ " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+ " 'Firefox 4 and 5 are also supported but you ' +\n",
+ " 'have to enable WebSockets in about:config.'\n",
+ " );\n",
+ " }\n",
+ "};\n",
+ "\n",
+ "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n",
+ " this.id = figure_id;\n",
+ "\n",
+ " this.ws = websocket;\n",
+ "\n",
+ " this.supports_binary = this.ws.binaryType !== undefined;\n",
+ "\n",
+ " if (!this.supports_binary) {\n",
+ " var warnings = document.getElementById('mpl-warnings');\n",
+ " if (warnings) {\n",
+ " warnings.style.display = 'block';\n",
+ " warnings.textContent =\n",
+ " 'This browser does not support binary websocket messages. ' +\n",
+ " 'Performance may be slow.';\n",
+ " }\n",
+ " }\n",
+ "\n",
+ " this.imageObj = new Image();\n",
+ "\n",
+ " this.context = undefined;\n",
+ " this.message = undefined;\n",
+ " this.canvas = undefined;\n",
+ " this.rubberband_canvas = undefined;\n",
+ " this.rubberband_context = undefined;\n",
+ " this.format_dropdown = undefined;\n",
+ "\n",
+ " this.image_mode = 'full';\n",
+ "\n",
+ " this.root = document.createElement('div');\n",
+ " this.root.setAttribute('style', 'display: inline-block');\n",
+ " this._root_extra_style(this.root);\n",
+ "\n",
+ " parent_element.appendChild(this.root);\n",
+ "\n",
+ " this._init_header(this);\n",
+ " this._init_canvas(this);\n",
+ " this._init_toolbar(this);\n",
+ "\n",
+ " var fig = this;\n",
+ "\n",
+ " this.waiting = false;\n",
+ "\n",
+ " this.ws.onopen = function () {\n",
+ " fig.send_message('supports_binary', { value: fig.supports_binary });\n",
+ " fig.send_message('send_image_mode', {});\n",
+ " if (fig.ratio !== 1) {\n",
+ " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n",
+ " }\n",
+ " fig.send_message('refresh', {});\n",
+ " };\n",
+ "\n",
+ " this.imageObj.onload = function () {\n",
+ " if (fig.image_mode === 'full') {\n",
+ " // Full images could contain transparency (where diff images\n",
+ " // almost always do), so we need to clear the canvas so that\n",
+ " // there is no ghosting.\n",
+ " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+ " }\n",
+ " fig.context.drawImage(fig.imageObj, 0, 0);\n",
+ " };\n",
+ "\n",
+ " this.imageObj.onunload = function () {\n",
+ " fig.ws.close();\n",
+ " };\n",
+ "\n",
+ " this.ws.onmessage = this._make_on_message_function(this);\n",
+ "\n",
+ " this.ondownload = ondownload;\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype._init_header = function () {\n",
+ " var titlebar = document.createElement('div');\n",
+ " titlebar.classList =\n",
+ " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
+ " var titletext = document.createElement('div');\n",
+ " titletext.classList = 'ui-dialog-title';\n",
+ " titletext.setAttribute(\n",
+ " 'style',\n",
+ " 'width: 100%; text-align: center; padding: 3px;'\n",
+ " );\n",
+ " titlebar.appendChild(titletext);\n",
+ " this.root.appendChild(titlebar);\n",
+ " this.header = titletext;\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
+ "\n",
+ "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
+ "\n",
+ "mpl.figure.prototype._init_canvas = function () {\n",
+ " var fig = this;\n",
+ "\n",
+ " var canvas_div = (this.canvas_div = document.createElement('div'));\n",
+ " canvas_div.setAttribute(\n",
+ " 'style',\n",
+ " 'border: 1px solid #ddd;' +\n",
+ " 'box-sizing: content-box;' +\n",
+ " 'clear: both;' +\n",
+ " 'min-height: 1px;' +\n",
+ " 'min-width: 1px;' +\n",
+ " 'outline: 0;' +\n",
+ " 'overflow: hidden;' +\n",
+ " 'position: relative;' +\n",
+ " 'resize: both;'\n",
+ " );\n",
+ "\n",
+ " function on_keyboard_event_closure(name) {\n",
+ " return function (event) {\n",
+ " return fig.key_event(event, name);\n",
+ " };\n",
+ " }\n",
+ "\n",
+ " canvas_div.addEventListener(\n",
+ " 'keydown',\n",
+ " on_keyboard_event_closure('key_press')\n",
+ " );\n",
+ " canvas_div.addEventListener(\n",
+ " 'keyup',\n",
+ " on_keyboard_event_closure('key_release')\n",
+ " );\n",
+ "\n",
+ " this._canvas_extra_style(canvas_div);\n",
+ " this.root.appendChild(canvas_div);\n",
+ "\n",
+ " var canvas = (this.canvas = document.createElement('canvas'));\n",
+ " canvas.classList.add('mpl-canvas');\n",
+ " canvas.setAttribute('style', 'box-sizing: content-box;');\n",
+ "\n",
+ " this.context = canvas.getContext('2d');\n",
+ "\n",
+ " var backingStore =\n",
+ " this.context.backingStorePixelRatio ||\n",
+ " this.context.webkitBackingStorePixelRatio ||\n",
+ " this.context.mozBackingStorePixelRatio ||\n",
+ " this.context.msBackingStorePixelRatio ||\n",
+ " this.context.oBackingStorePixelRatio ||\n",
+ " this.context.backingStorePixelRatio ||\n",
+ " 1;\n",
+ "\n",
+ " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+ "\n",
+ " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
+ " 'canvas'\n",
+ " ));\n",
+ " rubberband_canvas.setAttribute(\n",
+ " 'style',\n",
+ " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
+ " );\n",
+ "\n",
+ " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
+ " if (this.ResizeObserver === undefined) {\n",
+ " if (window.ResizeObserver !== undefined) {\n",
+ " this.ResizeObserver = window.ResizeObserver;\n",
+ " } else {\n",
+ " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
+ " this.ResizeObserver = obs.ResizeObserver;\n",
+ " }\n",
+ " }\n",
+ "\n",
+ " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
+ " var nentries = entries.length;\n",
+ " for (var i = 0; i < nentries; i++) {\n",
+ " var entry = entries[i];\n",
+ " var width, height;\n",
+ " if (entry.contentBoxSize) {\n",
+ " if (entry.contentBoxSize instanceof Array) {\n",
+ " // Chrome 84 implements new version of spec.\n",
+ " width = entry.contentBoxSize[0].inlineSize;\n",
+ " height = entry.contentBoxSize[0].blockSize;\n",
+ " } else {\n",
+ " // Firefox implements old version of spec.\n",
+ " width = entry.contentBoxSize.inlineSize;\n",
+ " height = entry.contentBoxSize.blockSize;\n",
+ " }\n",
+ " } else {\n",
+ " // Chrome <84 implements even older version of spec.\n",
+ " width = entry.contentRect.width;\n",
+ " height = entry.contentRect.height;\n",
+ " }\n",
+ "\n",
+ " // Keep the size of the canvas and rubber band canvas in sync with\n",
+ " // the canvas container.\n",
+ " if (entry.devicePixelContentBoxSize) {\n",
+ " // Chrome 84 implements new version of spec.\n",
+ " canvas.setAttribute(\n",
+ " 'width',\n",
+ " entry.devicePixelContentBoxSize[0].inlineSize\n",
+ " );\n",
+ " canvas.setAttribute(\n",
+ " 'height',\n",
+ " entry.devicePixelContentBoxSize[0].blockSize\n",
+ " );\n",
+ " } else {\n",
+ " canvas.setAttribute('width', width * fig.ratio);\n",
+ " canvas.setAttribute('height', height * fig.ratio);\n",
+ " }\n",
+ " canvas.setAttribute(\n",
+ " 'style',\n",
+ " 'width: ' + width + 'px; height: ' + height + 'px;'\n",
+ " );\n",
+ "\n",
+ " rubberband_canvas.setAttribute('width', width);\n",
+ " rubberband_canvas.setAttribute('height', height);\n",
+ "\n",
+ " // And update the size in Python. We ignore the initial 0/0 size\n",
+ " // that occurs as the element is placed into the DOM, which should\n",
+ " // otherwise not happen due to the minimum size styling.\n",
+ " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
+ " fig.request_resize(width, height);\n",
+ " }\n",
+ " }\n",
+ " });\n",
+ " this.resizeObserverInstance.observe(canvas_div);\n",
+ "\n",
+ " function on_mouse_event_closure(name) {\n",
+ " return function (event) {\n",
+ " return fig.mouse_event(event, name);\n",
+ " };\n",
+ " }\n",
+ "\n",
+ " rubberband_canvas.addEventListener(\n",
+ " 'mousedown',\n",
+ " on_mouse_event_closure('button_press')\n",
+ " );\n",
+ " rubberband_canvas.addEventListener(\n",
+ " 'mouseup',\n",
+ " on_mouse_event_closure('button_release')\n",
+ " );\n",
+ " rubberband_canvas.addEventListener(\n",
+ " 'dblclick',\n",
+ " on_mouse_event_closure('dblclick')\n",
+ " );\n",
+ " // Throttle sequential mouse events to 1 every 20ms.\n",
+ " rubberband_canvas.addEventListener(\n",
+ " 'mousemove',\n",
+ " on_mouse_event_closure('motion_notify')\n",
+ " );\n",
+ "\n",
+ " rubberband_canvas.addEventListener(\n",
+ " 'mouseenter',\n",
+ " on_mouse_event_closure('figure_enter')\n",
+ " );\n",
+ " rubberband_canvas.addEventListener(\n",
+ " 'mouseleave',\n",
+ " on_mouse_event_closure('figure_leave')\n",
+ " );\n",
+ "\n",
+ " canvas_div.addEventListener('wheel', function (event) {\n",
+ " if (event.deltaY < 0) {\n",
+ " event.step = 1;\n",
+ " } else {\n",
+ " event.step = -1;\n",
+ " }\n",
+ " on_mouse_event_closure('scroll')(event);\n",
+ " });\n",
+ "\n",
+ " canvas_div.appendChild(canvas);\n",
+ " canvas_div.appendChild(rubberband_canvas);\n",
+ "\n",
+ " this.rubberband_context = rubberband_canvas.getContext('2d');\n",
+ " this.rubberband_context.strokeStyle = '#000000';\n",
+ "\n",
+ " this._resize_canvas = function (width, height, forward) {\n",
+ " if (forward) {\n",
+ " canvas_div.style.width = width + 'px';\n",
+ " canvas_div.style.height = height + 'px';\n",
+ " }\n",
+ " };\n",
+ "\n",
+ " // Disable right mouse context menu.\n",
+ " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
+ " event.preventDefault();\n",
+ " return false;\n",
+ " });\n",
+ "\n",
+ " function set_focus() {\n",
+ " canvas.focus();\n",
+ " canvas_div.focus();\n",
+ " }\n",
+ "\n",
+ " window.setTimeout(set_focus, 100);\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype._init_toolbar = function () {\n",
+ " var fig = this;\n",
+ "\n",
+ " var toolbar = document.createElement('div');\n",
+ " toolbar.classList = 'mpl-toolbar';\n",
+ " this.root.appendChild(toolbar);\n",
+ "\n",
+ " function on_click_closure(name) {\n",
+ " return function (_event) {\n",
+ " return fig.toolbar_button_onclick(name);\n",
+ " };\n",
+ " }\n",
+ "\n",
+ " function on_mouseover_closure(tooltip) {\n",
+ " return function (event) {\n",
+ " if (!event.currentTarget.disabled) {\n",
+ " return fig.toolbar_button_onmouseover(tooltip);\n",
+ " }\n",
+ " };\n",
+ " }\n",
+ "\n",
+ " fig.buttons = {};\n",
+ " var buttonGroup = document.createElement('div');\n",
+ " buttonGroup.classList = 'mpl-button-group';\n",
+ " for (var toolbar_ind in mpl.toolbar_items) {\n",
+ " var name = mpl.toolbar_items[toolbar_ind][0];\n",
+ " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+ " var image = mpl.toolbar_items[toolbar_ind][2];\n",
+ " var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+ "\n",
+ " if (!name) {\n",
+ " /* Instead of a spacer, we start a new button group. */\n",
+ " if (buttonGroup.hasChildNodes()) {\n",
+ " toolbar.appendChild(buttonGroup);\n",
+ " }\n",
+ " buttonGroup = document.createElement('div');\n",
+ " buttonGroup.classList = 'mpl-button-group';\n",
+ " continue;\n",
+ " }\n",
+ "\n",
+ " var button = (fig.buttons[name] = document.createElement('button'));\n",
+ " button.classList = 'mpl-widget';\n",
+ " button.setAttribute('role', 'button');\n",
+ " button.setAttribute('aria-disabled', 'false');\n",
+ " button.addEventListener('click', on_click_closure(method_name));\n",
+ " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+ "\n",
+ " var icon_img = document.createElement('img');\n",
+ " icon_img.src = '_images/' + image + '.png';\n",
+ " icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
+ " icon_img.alt = tooltip;\n",
+ " button.appendChild(icon_img);\n",
+ "\n",
+ " buttonGroup.appendChild(button);\n",
+ " }\n",
+ "\n",
+ " if (buttonGroup.hasChildNodes()) {\n",
+ " toolbar.appendChild(buttonGroup);\n",
+ " }\n",
+ "\n",
+ " var fmt_picker = document.createElement('select');\n",
+ " fmt_picker.classList = 'mpl-widget';\n",
+ " toolbar.appendChild(fmt_picker);\n",
+ " this.format_dropdown = fmt_picker;\n",
+ "\n",
+ " for (var ind in mpl.extensions) {\n",
+ " var fmt = mpl.extensions[ind];\n",
+ " var option = document.createElement('option');\n",
+ " option.selected = fmt === mpl.default_extension;\n",
+ " option.innerHTML = fmt;\n",
+ " fmt_picker.appendChild(option);\n",
+ " }\n",
+ "\n",
+ " var status_bar = document.createElement('span');\n",
+ " status_bar.classList = 'mpl-message';\n",
+ " toolbar.appendChild(status_bar);\n",
+ " this.message = status_bar;\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n",
+ " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+ " // which will in turn request a refresh of the image.\n",
+ " this.send_message('resize', { width: x_pixels, height: y_pixels });\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.send_message = function (type, properties) {\n",
+ " properties['type'] = type;\n",
+ " properties['figure_id'] = this.id;\n",
+ " this.ws.send(JSON.stringify(properties));\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.send_draw_message = function () {\n",
+ " if (!this.waiting) {\n",
+ " this.waiting = true;\n",
+ " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n",
+ " }\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+ " var format_dropdown = fig.format_dropdown;\n",
+ " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+ " fig.ondownload(fig, format);\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.handle_resize = function (fig, msg) {\n",
+ " var size = msg['size'];\n",
+ " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n",
+ " fig._resize_canvas(size[0], size[1], msg['forward']);\n",
+ " fig.send_message('refresh', {});\n",
+ " }\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
+ " var x0 = msg['x0'] / fig.ratio;\n",
+ " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
+ " var x1 = msg['x1'] / fig.ratio;\n",
+ " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n",
+ " x0 = Math.floor(x0) + 0.5;\n",
+ " y0 = Math.floor(y0) + 0.5;\n",
+ " x1 = Math.floor(x1) + 0.5;\n",
+ " y1 = Math.floor(y1) + 0.5;\n",
+ " var min_x = Math.min(x0, x1);\n",
+ " var min_y = Math.min(y0, y1);\n",
+ " var width = Math.abs(x1 - x0);\n",
+ " var height = Math.abs(y1 - y0);\n",
+ "\n",
+ " fig.rubberband_context.clearRect(\n",
+ " 0,\n",
+ " 0,\n",
+ " fig.canvas.width / fig.ratio,\n",
+ " fig.canvas.height / fig.ratio\n",
+ " );\n",
+ "\n",
+ " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n",
+ " // Updates the figure title.\n",
+ " fig.header.textContent = msg['label'];\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n",
+ " var cursor = msg['cursor'];\n",
+ " switch (cursor) {\n",
+ " case 0:\n",
+ " cursor = 'pointer';\n",
+ " break;\n",
+ " case 1:\n",
+ " cursor = 'default';\n",
+ " break;\n",
+ " case 2:\n",
+ " cursor = 'crosshair';\n",
+ " break;\n",
+ " case 3:\n",
+ " cursor = 'move';\n",
+ " break;\n",
+ " }\n",
+ " fig.rubberband_canvas.style.cursor = cursor;\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.handle_message = function (fig, msg) {\n",
+ " fig.message.textContent = msg['message'];\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n",
+ " // Request the server to send over a new figure.\n",
+ " fig.send_draw_message();\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n",
+ " fig.image_mode = msg['mode'];\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n",
+ " for (var key in msg) {\n",
+ " if (!(key in fig.buttons)) {\n",
+ " continue;\n",
+ " }\n",
+ " fig.buttons[key].disabled = !msg[key];\n",
+ " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
+ " }\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
+ " if (msg['mode'] === 'PAN') {\n",
+ " fig.buttons['Pan'].classList.add('active');\n",
+ " fig.buttons['Zoom'].classList.remove('active');\n",
+ " } else if (msg['mode'] === 'ZOOM') {\n",
+ " fig.buttons['Pan'].classList.remove('active');\n",
+ " fig.buttons['Zoom'].classList.add('active');\n",
+ " } else {\n",
+ " fig.buttons['Pan'].classList.remove('active');\n",
+ " fig.buttons['Zoom'].classList.remove('active');\n",
+ " }\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.updated_canvas_event = function () {\n",
+ " // Called whenever the canvas gets updated.\n",
+ " this.send_message('ack', {});\n",
+ "};\n",
+ "\n",
+ "// A function to construct a web socket function for onmessage handling.\n",
+ "// Called in the figure constructor.\n",
+ "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
+ " return function socket_on_message(evt) {\n",
+ " if (evt.data instanceof Blob) {\n",
+ " var img = evt.data;\n",
+ " if (img.type !== 'image/png') {\n",
+ " /* FIXME: We get \"Resource interpreted as Image but\n",
+ " * transferred with MIME type text/plain:\" errors on\n",
+ " * Chrome. But how to set the MIME type? It doesn't seem\n",
+ " * to be part of the websocket stream */\n",
+ " img.type = 'image/png';\n",
+ " }\n",
+ "\n",
+ " /* Free the memory for the previous frames */\n",
+ " if (fig.imageObj.src) {\n",
+ " (window.URL || window.webkitURL).revokeObjectURL(\n",
+ " fig.imageObj.src\n",
+ " );\n",
+ " }\n",
+ "\n",
+ " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+ " img\n",
+ " );\n",
+ " fig.updated_canvas_event();\n",
+ " fig.waiting = false;\n",
+ " return;\n",
+ " } else if (\n",
+ " typeof evt.data === 'string' &&\n",
+ " evt.data.slice(0, 21) === 'data:image/png;base64'\n",
+ " ) {\n",
+ " fig.imageObj.src = evt.data;\n",
+ " fig.updated_canvas_event();\n",
+ " fig.waiting = false;\n",
+ " return;\n",
+ " }\n",
+ "\n",
+ " var msg = JSON.parse(evt.data);\n",
+ " var msg_type = msg['type'];\n",
+ "\n",
+ " // Call the \"handle_{type}\" callback, which takes\n",
+ " // the figure and JSON message as its only arguments.\n",
+ " try {\n",
+ " var callback = fig['handle_' + msg_type];\n",
+ " } catch (e) {\n",
+ " console.log(\n",
+ " \"No handler for the '\" + msg_type + \"' message type: \",\n",
+ " msg\n",
+ " );\n",
+ " return;\n",
+ " }\n",
+ "\n",
+ " if (callback) {\n",
+ " try {\n",
+ " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+ " callback(fig, msg);\n",
+ " } catch (e) {\n",
+ " console.log(\n",
+ " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
+ " e,\n",
+ " e.stack,\n",
+ " msg\n",
+ " );\n",
+ " }\n",
+ " }\n",
+ " };\n",
+ "};\n",
+ "\n",
+ "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+ "mpl.findpos = function (e) {\n",
+ " //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+ " var targ;\n",
+ " if (!e) {\n",
+ " e = window.event;\n",
+ " }\n",
+ " if (e.target) {\n",
+ " targ = e.target;\n",
+ " } else if (e.srcElement) {\n",
+ " targ = e.srcElement;\n",
+ " }\n",
+ " if (targ.nodeType === 3) {\n",
+ " // defeat Safari bug\n",
+ " targ = targ.parentNode;\n",
+ " }\n",
+ "\n",
+ " // pageX,Y are the mouse positions relative to the document\n",
+ " var boundingRect = targ.getBoundingClientRect();\n",
+ " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
+ " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
+ "\n",
+ " return { x: x, y: y };\n",
+ "};\n",
+ "\n",
+ "/*\n",
+ " * return a copy of an object with only non-object keys\n",
+ " * we need this to avoid circular references\n",
+ " * http://stackoverflow.com/a/24161582/3208463\n",
+ " */\n",
+ "function simpleKeys(original) {\n",
+ " return Object.keys(original).reduce(function (obj, key) {\n",
+ " if (typeof original[key] !== 'object') {\n",
+ " obj[key] = original[key];\n",
+ " }\n",
+ " return obj;\n",
+ " }, {});\n",
+ "}\n",
+ "\n",
+ "mpl.figure.prototype.mouse_event = function (event, name) {\n",
+ " var canvas_pos = mpl.findpos(event);\n",
+ "\n",
+ " if (name === 'button_press') {\n",
+ " this.canvas.focus();\n",
+ " this.canvas_div.focus();\n",
+ " }\n",
+ "\n",
+ " var x = canvas_pos.x * this.ratio;\n",
+ " var y = canvas_pos.y * this.ratio;\n",
+ "\n",
+ " this.send_message(name, {\n",
+ " x: x,\n",
+ " y: y,\n",
+ " button: event.button,\n",
+ " step: event.step,\n",
+ " guiEvent: simpleKeys(event),\n",
+ " });\n",
+ "\n",
+ " /* This prevents the web browser from automatically changing to\n",
+ " * the text insertion cursor when the button is pressed. We want\n",
+ " * to control all of the cursor setting manually through the\n",
+ " * 'cursor' event from matplotlib */\n",
+ " event.preventDefault();\n",
+ " return false;\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
+ " // Handle any extra behaviour associated with a key event\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.key_event = function (event, name) {\n",
+ " // Prevent repeat events\n",
+ " if (name === 'key_press') {\n",
+ " if (event.key === this._key) {\n",
+ " return;\n",
+ " } else {\n",
+ " this._key = event.key;\n",
+ " }\n",
+ " }\n",
+ " if (name === 'key_release') {\n",
+ " this._key = null;\n",
+ " }\n",
+ "\n",
+ " var value = '';\n",
+ " if (event.ctrlKey && event.key !== 'Control') {\n",
+ " value += 'ctrl+';\n",
+ " }\n",
+ " else if (event.altKey && event.key !== 'Alt') {\n",
+ " value += 'alt+';\n",
+ " }\n",
+ " else if (event.shiftKey && event.key !== 'Shift') {\n",
+ " value += 'shift+';\n",
+ " }\n",
+ "\n",
+ " value += 'k' + event.key;\n",
+ "\n",
+ " this._key_event_extra(event, name);\n",
+ "\n",
+ " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
+ " return false;\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
+ " if (name === 'download') {\n",
+ " this.handle_save(this, null);\n",
+ " } else {\n",
+ " this.send_message('toolbar_button', { name: name });\n",
+ " }\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
+ " this.message.textContent = tooltip;\n",
+ "};\n",
+ "\n",
+ "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
+ "// prettier-ignore\n",
+ "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n",
+ "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+ "\n",
+ "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+ "\n",
+ "mpl.default_extension = \"png\";/* global mpl */\n",
+ "\n",
+ "var comm_websocket_adapter = function (comm) {\n",
+ " // Create a \"websocket\"-like object which calls the given IPython comm\n",
+ " // object with the appropriate methods. Currently this is a non binary\n",
+ " // socket, so there is still some room for performance tuning.\n",
+ " var ws = {};\n",
+ "\n",
+ " ws.binaryType = comm.kernel.ws.binaryType;\n",
+ " ws.readyState = comm.kernel.ws.readyState;\n",
+ " function updateReadyState(_event) {\n",
+ " if (comm.kernel.ws) {\n",
+ " ws.readyState = comm.kernel.ws.readyState;\n",
+ " } else {\n",
+ " ws.readyState = 3; // Closed state.\n",
+ " }\n",
+ " }\n",
+ " comm.kernel.ws.addEventListener('open', updateReadyState);\n",
+ " comm.kernel.ws.addEventListener('close', updateReadyState);\n",
+ " comm.kernel.ws.addEventListener('error', updateReadyState);\n",
+ "\n",
+ " ws.close = function () {\n",
+ " comm.close();\n",
+ " };\n",
+ " ws.send = function (m) {\n",
+ " //console.log('sending', m);\n",
+ " comm.send(m);\n",
+ " };\n",
+ " // Register the callback with on_msg.\n",
+ " comm.on_msg(function (msg) {\n",
+ " //console.log('receiving', msg['content']['data'], msg);\n",
+ " var data = msg['content']['data'];\n",
+ " if (data['blob'] !== undefined) {\n",
+ " data = {\n",
+ " data: new Blob(msg['buffers'], { type: data['blob'] }),\n",
+ " };\n",
+ " }\n",
+ " // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+ " ws.onmessage(data);\n",
+ " });\n",
+ " return ws;\n",
+ "};\n",
+ "\n",
+ "mpl.mpl_figure_comm = function (comm, msg) {\n",
+ " // This is the function which gets called when the mpl process\n",
+ " // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+ "\n",
+ " var id = msg.content.data.id;\n",
+ " // Get hold of the div created by the display call when the Comm\n",
+ " // socket was opened in Python.\n",
+ " var element = document.getElementById(id);\n",
+ " var ws_proxy = comm_websocket_adapter(comm);\n",
+ "\n",
+ " function ondownload(figure, _format) {\n",
+ " window.open(figure.canvas.toDataURL());\n",
+ " }\n",
+ "\n",
+ " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
+ "\n",
+ " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+ " // web socket which is closed, not our websocket->open comm proxy.\n",
+ " ws_proxy.onopen();\n",
+ "\n",
+ " fig.parent_element = element;\n",
+ " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+ " if (!fig.cell_info) {\n",
+ " console.error('Failed to find cell for figure', id, fig);\n",
+ " return;\n",
+ " }\n",
+ " fig.cell_info[0].output_area.element.on(\n",
+ " 'cleared',\n",
+ " { fig: fig },\n",
+ " fig._remove_fig_handler\n",
+ " );\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
+ " var width = fig.canvas.width / fig.ratio;\n",
+ " fig.cell_info[0].output_area.element.off(\n",
+ " 'cleared',\n",
+ " fig._remove_fig_handler\n",
+ " );\n",
+ " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n",
+ "\n",
+ " // Update the output cell to use the data from the current canvas.\n",
+ " fig.push_to_output();\n",
+ " var dataURL = fig.canvas.toDataURL();\n",
+ " // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+ " // the notebook keyboard shortcuts fail.\n",
+ " IPython.keyboard_manager.enable();\n",
+ " fig.parent_element.innerHTML =\n",
+ " '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+ " fig.close_ws(fig, msg);\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
+ " fig.send_message('closing', msg);\n",
+ " // fig.ws.close()\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
+ " // Turn the data on the canvas into data in the output cell.\n",
+ " var width = this.canvas.width / this.ratio;\n",
+ " var dataURL = this.canvas.toDataURL();\n",
+ " this.cell_info[1]['text/html'] =\n",
+ " '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.updated_canvas_event = function () {\n",
+ " // Tell IPython that the notebook contents must change.\n",
+ " IPython.notebook.set_dirty(true);\n",
+ " this.send_message('ack', {});\n",
+ " var fig = this;\n",
+ " // Wait a second, then push the new image to the DOM so\n",
+ " // that it is saved nicely (might be nice to debounce this).\n",
+ " setTimeout(function () {\n",
+ " fig.push_to_output();\n",
+ " }, 1000);\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype._init_toolbar = function () {\n",
+ " var fig = this;\n",
+ "\n",
+ " var toolbar = document.createElement('div');\n",
+ " toolbar.classList = 'btn-toolbar';\n",
+ " this.root.appendChild(toolbar);\n",
+ "\n",
+ " function on_click_closure(name) {\n",
+ " return function (_event) {\n",
+ " return fig.toolbar_button_onclick(name);\n",
+ " };\n",
+ " }\n",
+ "\n",
+ " function on_mouseover_closure(tooltip) {\n",
+ " return function (event) {\n",
+ " if (!event.currentTarget.disabled) {\n",
+ " return fig.toolbar_button_onmouseover(tooltip);\n",
+ " }\n",
+ " };\n",
+ " }\n",
+ "\n",
+ " fig.buttons = {};\n",
+ " var buttonGroup = document.createElement('div');\n",
+ " buttonGroup.classList = 'btn-group';\n",
+ " var button;\n",
+ " for (var toolbar_ind in mpl.toolbar_items) {\n",
+ " var name = mpl.toolbar_items[toolbar_ind][0];\n",
+ " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+ " var image = mpl.toolbar_items[toolbar_ind][2];\n",
+ " var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+ "\n",
+ " if (!name) {\n",
+ " /* Instead of a spacer, we start a new button group. */\n",
+ " if (buttonGroup.hasChildNodes()) {\n",
+ " toolbar.appendChild(buttonGroup);\n",
+ " }\n",
+ " buttonGroup = document.createElement('div');\n",
+ " buttonGroup.classList = 'btn-group';\n",
+ " continue;\n",
+ " }\n",
+ "\n",
+ " button = fig.buttons[name] = document.createElement('button');\n",
+ " button.classList = 'btn btn-default';\n",
+ " button.href = '#';\n",
+ " button.title = name;\n",
+ " button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
+ " button.addEventListener('click', on_click_closure(method_name));\n",
+ " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+ " buttonGroup.appendChild(button);\n",
+ " }\n",
+ "\n",
+ " if (buttonGroup.hasChildNodes()) {\n",
+ " toolbar.appendChild(buttonGroup);\n",
+ " }\n",
+ "\n",
+ " // Add the status bar.\n",
+ " var status_bar = document.createElement('span');\n",
+ " status_bar.classList = 'mpl-message pull-right';\n",
+ " toolbar.appendChild(status_bar);\n",
+ " this.message = status_bar;\n",
+ "\n",
+ " // Add the close button to the window.\n",
+ " var buttongrp = document.createElement('div');\n",
+ " buttongrp.classList = 'btn-group inline pull-right';\n",
+ " button = document.createElement('button');\n",
+ " button.classList = 'btn btn-mini btn-primary';\n",
+ " button.href = '#';\n",
+ " button.title = 'Stop Interaction';\n",
+ " button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
+ " button.addEventListener('click', function (_evt) {\n",
+ " fig.handle_close(fig, {});\n",
+ " });\n",
+ " button.addEventListener(\n",
+ " 'mouseover',\n",
+ " on_mouseover_closure('Stop Interaction')\n",
+ " );\n",
+ " buttongrp.appendChild(button);\n",
+ " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
+ " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
+ " var fig = event.data.fig;\n",
+ " if (event.target !== this) {\n",
+ " // Ignore bubbled events from children.\n",
+ " return;\n",
+ " }\n",
+ " fig.close_ws(fig, {});\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype._root_extra_style = function (el) {\n",
+ " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
+ " // this is important to make the div 'focusable\n",
+ " el.setAttribute('tabindex', 0);\n",
+ " // reach out to IPython and tell the keyboard manager to turn it's self\n",
+ " // off when our div gets focus\n",
+ "\n",
+ " // location in version 3\n",
+ " if (IPython.notebook.keyboard_manager) {\n",
+ " IPython.notebook.keyboard_manager.register_events(el);\n",
+ " } else {\n",
+ " // location in version 2\n",
+ " IPython.keyboard_manager.register_events(el);\n",
+ " }\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
+ " var manager = IPython.notebook.keyboard_manager;\n",
+ " if (!manager) {\n",
+ " manager = IPython.keyboard_manager;\n",
+ " }\n",
+ "\n",
+ " // Check for shift+enter\n",
+ " if (event.shiftKey && event.which === 13) {\n",
+ " this.canvas_div.blur();\n",
+ " // select the cell after this one\n",
+ " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
+ " IPython.notebook.select(index + 1);\n",
+ " }\n",
+ "};\n",
+ "\n",
+ "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+ " fig.ondownload(fig, null);\n",
+ "};\n",
+ "\n",
+ "mpl.find_output_cell = function (html_output) {\n",
+ " // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+ " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+ " // IPython event is triggered only after the cells have been serialised, which for\n",
+ " // our purposes (turning an active figure into a static one), is too late.\n",
+ " var cells = IPython.notebook.get_cells();\n",
+ " var ncells = cells.length;\n",
+ " for (var i = 0; i < ncells; i++) {\n",
+ " var cell = cells[i];\n",
+ " if (cell.cell_type === 'code') {\n",
+ " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
+ " var data = cell.output_area.outputs[j];\n",
+ " if (data.data) {\n",
+ " // IPython >= 3 moved mimebundle to data attribute of output\n",
+ " data = data.data;\n",
+ " }\n",
+ " if (data['text/html'] === html_output) {\n",
+ " return [cell, data, j];\n",
+ " }\n",
+ " }\n",
+ " }\n",
+ " }\n",
+ "};\n",
+ "\n",
+ "// Register the function which deals with the matplotlib target/channel.\n",
+ "// The kernel may be null if the page has been refreshed.\n",
+ "if (IPython.notebook.kernel !== null) {\n",
+ " IPython.notebook.kernel.comm_manager.register_target(\n",
+ " 'matplotlib',\n",
+ " mpl.mpl_figure_comm\n",
+ " );\n",
+ "}\n"
+ ],
+ "text/plain": [
+ "<IPython.core.display.Javascript object>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "<img src=\"data:image/png;base64,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\" width=\"684\">"
+ ],
+ "text/plain": [
+ "<IPython.core.display.HTML object>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "0f602df2683d4d3aac489d1fdabea2d8",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "interactive(children=(IntSlider(value=0, description='i', layout=Layout(width='99%'), max=999), Output()), _do…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "<function __main__.slider_return(i)>"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
}
- },
- "outputs": [],
+ ],
"source": [
+ "import ipywidgets # needed for the interactive slider\n",
"%matplotlib notebook\n",
- "# Wir führen die Faltung einmalig aus, um Rechenleistung zu sparen\n",
- "faltung_ergebnis = faltung(t_array, x, f)\n",
"\n",
- "# Definieren einen Schieberegler\n",
- "slider = ipywidgets.IntSlider(min=0, max=len(t_array)-1, step=1)\n",
"\n",
- "# Wir initiieren den Plot mit 2 Reihen und einer Spalte und bekommen für jeden Subplot ein Achsen-Objekt\n",
+ "def convolution(t_array, x, f):\n",
+ " result = []\n",
+ " # compute x once\n",
+ " x_result = numpy.array(list(map(x, t_array)))\n",
+ " # the function f needs to be shifted by t\n",
+ " # t is continuous, we therefore do this for every value t, but we assume\n",
+ " # that it will be sufficient to do this from t0 to t1\n",
+ " for t in t_array:\n",
+ " # compute f for with the shift t\n",
+ " f_result = numpy.array(list(map(f, t-t_array)))\n",
+ " # now compute the integral for the shift t\n",
+ " integral = 0\n",
+ " for ii in range(0,len(t_array)):\n",
+ " integral += x_result[ii]*f_result[ii]*dt\n",
+ " result.append(integral)\n",
+ " return result\n",
+ "\n",
+ "\n",
+ "# we compute the convolution once to save computation effort\n",
+ "x_result = numpy.array(list(map(x, t)))\n",
+ "convolution_result = convolution(t, x, f)\n",
+ "\n",
+ "# define the interactive slider\n",
+ "slider = ipywidgets.IntSlider(min=0, max=len(t)-1, step=1, layout={'width':'99%'})\n",
+ "\n",
+ "# initiate a plot with two rwos and one column\n",
"figure, (axis1, axis2) = pyplot.subplots(2, 1)\n",
"\n",
- "# Wir definieren hier die Funktion die nach einer Änderung am Slider ausgeführt werden soll\n",
+ "# this function will be run every time the slider is dragged\n",
"def slider_return(i):\n",
- " axis1.cla() # Wir löschen den vorherigen Inhalt\n",
+ " # clear previous plot\n",
+ " axis1.cla() \n",
" axis2.cla()\n",
- " axis2.set_xlim(t_array[0],t_array[-1]) # Setzen ein Achsenlimit in x und y Richtung\n",
- " axis2.set_ylim(numpy.min(faltung_ergebnis)-0.1,numpy.max(faltung_ergebnis)+0.1)\n",
- " axis2.plot(t_array[0:i], faltung_ergebnis[0:i]) # Und stellen die Ergebnisse dar\n",
- " axis1.plot(t_array, x(t_array))\n",
- " axis1.plot(t_array, f(-t_array+t_array[i]))\n",
- " figure.show()\n",
+ " # some formatting\n",
+ " axis2.set_xlim(t[0],t[-1]) # set axis limits\n",
+ " axis2.set_ylim(numpy.min(convolution_result)-0.1,numpy.max(convolution_result)+0.1)\n",
+ " # plotting\n",
+ " axis2.plot(t[0:i], convolution_result[0:i])\n",
+ " axis1.plot(t, x_result)\n",
+ " axis1.plot(t, numpy.array(list(map(f, (-t+t[i])))))\n",
"\n",
- "ipywidgets.interact(slider_return, i=slider) # Trägt die Informationen zusammen und erstellt den Schieberegler"
+ "ipywidgets.interact(slider_return, i=slider) # creates and displays the slider, plugs in the slider_return function"
]
},
{
@@ -236,30 +1285,52 @@
}
},
"source": [
- "Nun betrachten wir uns die Funktion `scipy.signal.convolve`."
+ "## Vergleich mit vordefinierter Faltung von SciPy\n",
+ "\n",
+ "Zum Vergleich möchten wir unsere Faltung noch mit einer natürlich bereits vorhandenen Funktion für die Faltung betrachten. Diese ist implementiert in `scipy.signal.convolve` von [SciPy](https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.convolve.html)"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 6,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 684x360 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
"source": [
"%matplotlib inline\n",
- "from scipy.signal import convolve # Wir importieren die Funktion 'convolve' aus dem Submodul 'signal' aus dem Paket 'scipy'\n",
- "# Mehr Infos zum Paket scipy unter https://www.scipy.org/\n",
+ "from scipy.signal import convolve # we import the convolve function from the scipy.signal module\n",
+ "# for more information see https://www.scipy.org/\n",
"\n",
- "x_ergebnis = x(t_array)\n",
- "f_ergebnis = f(t_array)\n",
- "g_ergebnis = g(t_array)\n",
+ "x_result = numpy.array(list(map(x, t)))\n",
+ "f_result = numpy.array(list(map(f, t)))\n",
+ "g_result = numpy.array(list(map(g, t)))\n",
"\n",
- "pyplot.plot(t_array, convolve(x_ergebnis, f_ergebnis, mode='same')*dt)\n",
- "pyplot.show()\n"
+ "pyplot.plot(t, convolve(x_result, f_result, mode='same')*dt)\n",
+ "pyplot.show()"
]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
}
],
"metadata": {
@@ -278,7 +1349,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.7.4"
+ "version": "3.9.4"
},
"latex_envs": {
"LaTeX_envs_menu_present": true,
--
GitLab