From 8242e4062e0a4096a5cee0355d784c164f026eb5 Mon Sep 17 00:00:00 2001 From: Jakob Lemvig <jakle@dtu.dk> Date: Thu, 20 Apr 2023 15:00:36 +0200 Subject: [PATCH] hard linked to Demos --- Demos | 1 - Demos/Arbejde_videre_med_Output.ipynb | 743 ++++++++++++ Demos/Demo-E-Uge-10-LilleDag.ipynb | 877 ++++++++++++++ Demos/Demo-E-Uge-10-StoreDag.ipynb | 660 +++++++++++ Demos/Demo-E-Uge-11-LilleDag.ipynb | 354 ++++++ ...ear-Transformation-Symmetrisk-Matrix.ipynb | 317 ++++++ Demos/Demo-E-Uge-11-StoreDag.ipynb | 571 ++++++++++ Demos/Demo-E-Uge-12-StoreDag.ipynb | 331 ++++++ Demos/Demo-E-Uge-13-Hookes-lov.ipynb | 325 ++++++ Demos/Demo-E-Uge-13-StoreDag.ipynb | 238 ++++ Demos/Demo-E-Uge-4-StoreDag.ipynb | 710 ++++++++++++ Demos/Demo-E-Uge-5-LilleDag.ipynb | 850 ++++++++++++++ Demos/Demo-E-Uge-5-StoreDag.ipynb | 930 +++++++++++++++ Demos/Demo-E-Uge-6-LilleDag.ipynb | 286 +++++ Demos/Demo-E-Uge-6-StoreDag.ipynb | 748 ++++++++++++ Demos/Demo-E-Uge-7-StoreDag.ipynb | 341 ++++++ Demos/Demo-E-Uge-8-LilleDag.ipynb | 383 +++++++ Demos/Demo-E-Uge-8-StoreDag.ipynb | 625 ++++++++++ Demos/Demo-E-Uge-9-StoreDag.ipynb | 226 ++++ Demos/Demo-F-Uge-1-LilleDag.ipynb | 719 ++++++++++++ Demos/Demo-F-Uge-1-StoreDag.ipynb | 545 +++++++++ Demos/Demo-F-Uge-1-StoreDag_minversion.ipynb | 1010 +++++++++++++++++ Demos/Demo-F-Uge-2-LilleDag.ipynb | 308 +++++ Demos/Demo-F-Uge-2-StoreDag.ipynb | 293 +++++ Demos/Demo-F-Uge-3-StoreDag.ipynb | 592 ++++++++++ Demos/Demo-F-Uge-4-StoreDag.ipynb | 422 +++++++ Demos/Demo-F-Uge-5-LilleDag.ipynb | 666 +++++++++++ Demos/Demo-F-Uge-5-StoreDag.ipynb | 505 +++++++++ Demos/Demo-F-Uge-6-StoreDag.ipynb | 386 +++++++ Demos/Demo-F-Uge-7-LilleDag.ipynb | 292 +++++ Demos/Demo-F-Uge-7-StoreDag.ipynb | 377 ++++++ Demos/Demo-F-Uge-8-StoreDag.ipynb | 668 +++++++++++ Demos/Demo-F-Uge-9-StoreDag.ipynb | 430 +++++++ Demos/Intro-SymPy.ipynb | 489 ++++++++ Demos/mit_plot.png | Bin 0 -> 12741 bytes Demos/test.ipynb | 96 ++ Demos/vogn_fig1.png | Bin 0 -> 8149 bytes Demos/vogn_fig2.png | Bin 0 -> 11413 bytes 38 files changed, 17313 insertions(+), 1 deletion(-) delete mode 120000 Demos create mode 100644 Demos/Arbejde_videre_med_Output.ipynb create mode 100644 Demos/Demo-E-Uge-10-LilleDag.ipynb create mode 100644 Demos/Demo-E-Uge-10-StoreDag.ipynb create mode 100644 Demos/Demo-E-Uge-11-LilleDag.ipynb create mode 100644 Demos/Demo-E-Uge-11-Linear-Transformation-Symmetrisk-Matrix.ipynb create mode 100644 Demos/Demo-E-Uge-11-StoreDag.ipynb create mode 100644 Demos/Demo-E-Uge-12-StoreDag.ipynb create mode 100644 Demos/Demo-E-Uge-13-Hookes-lov.ipynb create mode 100644 Demos/Demo-E-Uge-13-StoreDag.ipynb create mode 100644 Demos/Demo-E-Uge-4-StoreDag.ipynb create mode 100644 Demos/Demo-E-Uge-5-LilleDag.ipynb create mode 100644 Demos/Demo-E-Uge-5-StoreDag.ipynb create mode 100644 Demos/Demo-E-Uge-6-LilleDag.ipynb create mode 100644 Demos/Demo-E-Uge-6-StoreDag.ipynb create mode 100644 Demos/Demo-E-Uge-7-StoreDag.ipynb create mode 100644 Demos/Demo-E-Uge-8-LilleDag.ipynb create mode 100644 Demos/Demo-E-Uge-8-StoreDag.ipynb create mode 100644 Demos/Demo-E-Uge-9-StoreDag.ipynb create mode 100644 Demos/Demo-F-Uge-1-LilleDag.ipynb create mode 100644 Demos/Demo-F-Uge-1-StoreDag.ipynb create mode 100644 Demos/Demo-F-Uge-1-StoreDag_minversion.ipynb create mode 100644 Demos/Demo-F-Uge-2-LilleDag.ipynb create mode 100644 Demos/Demo-F-Uge-2-StoreDag.ipynb create mode 100644 Demos/Demo-F-Uge-3-StoreDag.ipynb create mode 100644 Demos/Demo-F-Uge-4-StoreDag.ipynb create mode 100644 Demos/Demo-F-Uge-5-LilleDag.ipynb create mode 100644 Demos/Demo-F-Uge-5-StoreDag.ipynb create mode 100644 Demos/Demo-F-Uge-6-StoreDag.ipynb create mode 100644 Demos/Demo-F-Uge-7-LilleDag.ipynb create mode 100644 Demos/Demo-F-Uge-7-StoreDag.ipynb create mode 100644 Demos/Demo-F-Uge-8-StoreDag.ipynb create mode 100644 Demos/Demo-F-Uge-9-StoreDag.ipynb create mode 100644 Demos/Intro-SymPy.ipynb create mode 100644 Demos/mit_plot.png create mode 100644 Demos/test.ipynb create mode 100644 Demos/vogn_fig1.png create mode 100644 Demos/vogn_fig2.png diff --git a/Demos b/Demos deleted file mode 120000 index e4da998..0000000 --- a/Demos +++ /dev/null @@ -1 +0,0 @@ -/home/jakle/Python/pilot-project-for-01005/Demos \ No newline at end of file diff --git a/Demos/Arbejde_videre_med_Output.ipynb b/Demos/Arbejde_videre_med_Output.ipynb new file mode 100644 index 0000000..8b5179a --- /dev/null +++ b/Demos/Arbejde_videre_med_Output.ipynb @@ -0,0 +1,743 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<font size=\"5\"><center>\n", + "Kursus: 01005 Matematik 1 \\\n", + "Forfatter: Jakob Lemvig \\\n", + "Email: jakle@dtu.dk\n", + "</font></center>" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "IPython console for SymPy 1.11.1 (Python 3.10.6-64-bit) (ground types: python)\n", + "\n", + "These commands were executed:\n", + ">>> from sympy import *\n", + ">>> x, y, z, t = symbols('x y z t')\n", + ">>> k, m, n = symbols('k m n', integer=True)\n", + ">>> f, g, h = symbols('f g h', cls=Function)\n", + ">>> init_printing()\n", + "\n", + "Documentation can be found at https://docs.sympy.org/1.11.1/\n", + "\n" + ] + } + ], + "source": [ + "from sympy import *\n", + "init_session()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Hvordan arbejder man videre med output/løsninger i SymPy?\n", + "\n", + "Man kommer tit ud for at skulle arbejde videre med output eller en løsning i SymPy. Fx hvis man bliver bedt om at angive en løsning ud af uendeligt mange løsninger. Lad os kigge på nogle typiske eksempler." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Egenvektorer\n", + "\n", + "Vi ønsker ofte at arbejde videre med egenvektorer af en matrix, men det kan hurtigt blive besværligt at skrive alle (lin. uafh.) egenvektorerne ind manuelt. Hvis man bruger `eigenvects`-metoden gemmer SymPy al information i en liste:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c43ae7ec", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left[ \\left( 1, \\ 1, \\ \\left[ \\left[\\begin{matrix}-1\\\\\\frac{1}{2}\\\\1\\end{matrix}\\right]\\right]\\right), \\ \\left( 10, \\ 2, \\ \\left[ \\left[\\begin{matrix}\\frac{1}{2}\\\\1\\\\0\\end{matrix}\\right], \\ \\left[\\begin{matrix}1\\\\0\\\\1\\end{matrix}\\right]\\right]\\right)\\right]$" + ], + "text/plain": [ + "⎡⎛ ⎡⎡-1 ⎤⎤⎞ ⎛ ⎡⎡1/2⎤ ⎡1⎤⎤⎞⎤\n", + "⎢⎜ ⎢⎢ ⎥⎥⎟ ⎜ ⎢⎢ ⎥ ⎢ ⎥⎥⎟⎥\n", + "⎢⎜1, 1, ⎢⎢1/2⎥⎥⎟, ⎜10, 2, ⎢⎢ 1 ⎥, ⎢0⎥⎥⎟⎥\n", + "⎢⎜ ⎢⎢ ⎥⎥⎟ ⎜ ⎢⎢ ⎥ ⎢ ⎥⎥⎟⎥\n", + "⎣⎝ ⎣⎣ 1 ⎦⎦⎠ ⎝ ⎣⎣ 0 ⎦ ⎣1⎦⎦⎠⎦" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "list" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "A = Matrix([[6,2,4],[2,9,-2],[4,-2,6]])\n", + "ev = A.eigenvects()\n", + "display(ev, type(ev))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`eigenvects()` giver altså en liste af tuples, hvor egenvektorerne gemmes på plads 2 i hver tuple. Vi kan derfor gemme alle egenvektorerne i en liste af vektorer på følgende måde:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left[ \\left[\\begin{matrix}-1\\\\\\frac{1}{2}\\\\1\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{1}{2}\\\\1\\\\0\\end{matrix}\\right], \\ \\left[\\begin{matrix}1\\\\0\\\\1\\end{matrix}\\right]\\right]$" + ], + "text/plain": [ + "⎡⎡-1 ⎤ ⎡1/2⎤ ⎡1⎤⎤\n", + "⎢⎢ ⎥ ⎢ ⎥ ⎢ ⎥⎥\n", + "⎢⎢1/2⎥, ⎢ 1 ⎥, ⎢0⎥⎥\n", + "⎢⎢ ⎥ ⎢ ⎥ ⎢ ⎥⎥\n", + "⎣⎣ 1 ⎦ ⎣ 0 ⎦ ⎣1⎦⎦" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_of_ev = []\n", + "[list_of_ev.extend(ev[k][2]) for k in range(0,len(ev))]\n", + "list_of_ev" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Eller som matrix:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}-1 & \\frac{1}{2} & 1\\\\\\frac{1}{2} & 1 & 0\\\\1 & 0 & 1\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡-1 1/2 1⎤\n", + "⎢ ⎥\n", + "⎢1/2 1 0⎥\n", + "⎢ ⎥\n", + "⎣ 1 0 1⎦" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Matrix(A.shape[0],len(list_of_ev),Matrix((list_of_ev))).T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hvis vi gerne vil arbejde videre med egenvektorerne som søjler i en matrix, er det meget nemmere at bruge `diagonalize` metoden:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "789ade26", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}-2 & 1 & 1\\\\1 & 2 & 0\\\\2 & 0 & 1\\end{matrix}\\right], \\ \\left[\\begin{matrix}1 & 0 & 0\\\\0 & 10 & 0\\\\0 & 0 & 10\\end{matrix}\\right]\\right)$" + ], + "text/plain": [ + "⎛⎡-2 1 1⎤ ⎡1 0 0 ⎤⎞\n", + "⎜⎢ ⎥ ⎢ ⎥⎟\n", + "⎜⎢1 2 0⎥, ⎢0 10 0 ⎥⎟\n", + "⎜⎢ ⎥ ⎢ ⎥⎟\n", + "⎝⎣2 0 1⎦ ⎣0 0 10⎦⎠" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "V, Lamda = A.diagonalize()\n", + "V, Lamda" + ] + }, + { + "cell_type": "markdown", + "id": "9f7a8935", + "metadata": {}, + "source": [ + "## Et lineært ligningssystem med flere løsninger\n", + "\n", + "Vi ønsker at løse det inhomogene ligningssystem: " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHkAAAAUCAYAAACpkJLNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAABJ0AAASdAHeZh94AAADq0lEQVR4nO3ae4hVVRTH8c+kRH8YBf0zEJRBEESCUFFQhBIWJZSWUkjmgEX0IKYgzEhWqwcpRSpR2AMcqf6xBoQwsocYQi8RTO2dIRRSGUogPayc/th34HZ1HvfOmbkjzvefc89+rR97n73WXufcjr6+PhMcf2TmGZiL2ZiGM3EYu7AWayPiCJzULpETjJj5eAmX4BOsQi8uwMtYn5kdMLlNAislM7uUp3dmRGxpr5ox4xtch439OxYy8yF8ihtxA3orXeTMfAezMC8ieuvKO5RFWIQVEfFglXZHyvGoOyI2D1D+U2auwROYgd6q3fUDOILHMnNSXfnTykS9OJ4mqo7jVfdA/F27/kPF7joiPsvMV5SJWYiemvu4H+txZ5X2qmIsdGdmN05vosuOiNjQgp3JuLV2+zajE5OX4SZEZk5R3MYmLKyPHeOQ0dbdjbObaL8OG1qws1w5fL0VEZugoz6Fysy9TQp5LSJuaSzMzCfR794+xKyI+L2hzVLlYHAe/sLHWBoRuwcz2ILGdRHRNZyGw9R9N+7A1FrR53g8IjY2oWlUyMx7sRpf4bKIOMDRO3kP/mxi3H0DlO+v+724caJqzMDz2IYOPIr3MvP8fnEDsMrRbm86rlee/r0NdTsGGauR4ej+EUvwrZKCLsKGzLwwInY2YatSMvMeZYG/wJX1c9hR9cuQzFyAV/EzOrEmIoaMaTUX+RvmRMSbTdrsMsIUqlXdtb4HFC/0wiBtuo1STK6NvRK7lQX+pb6+6hTqWvT0G8NW3JaZqyLi6yG6n6rsjINVahoOrequncTnY4ri3gej2yjE5MxcosThHUp4+bWxTWWLnJmX4w3FnV0dEfsz82G8jhWYM8QQq2tCP6pK03BoRXdmTqvpPAWHMDcidg1mJyKmVquczFymhLntuGqgMFeJu87M6diCP3B5ROypq9uGi3BFRGwdoP8zuLnW9/sW7HdpwV23qjszT8ZZOA3zcDtmDHVorJLMXKR4n3/xrBLqGtkbET0j3smZea6Sj/UpO2FPQ5OleBdP4dJj9F+pLPDMVha4VUaiOyIO47va7fbMvBj3YfGoiv4/59Suk5RQcCw+QE/lB69myMzVSm46MyK+bJuQEZKZm7HvWOnkeKBtHygy8znl7dIcHMzMzlrVoYg41C5dQ5GZy7ERPyiHxQVKOji7jbIGpZ1foe6qXd9vKE88MrZSmqJTSbU6lTi4E9f0v10aj7TVXU8wNkz8aeAEYGKRTwD+Axz4oiassDLEAAAAAElFTkSuQmCC", + "text/latex": [ + "$\\displaystyle - x_{2} + x_{3} = 2$" + ], + "text/plain": [ + "-x₂ + x₃ = 2" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAL4AAAAUCAYAAAAz84cVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAABJ0AAASdAHeZh94AAAE/0lEQVR4nO2aa6gVVRiGn6MSBUZCf6SoDIQoFDQVg0S8YFFCaSmFaBoqUYmcojIle32tSCnUQxesDE9af+yCFFZ2EUvTSqRT2sXKEAu7WCcCybTy9GPNiXE7e++Zs6/n8sCwZ2Zd5nvXt2Zdvj0NbW1tANg+G5gMTAQGA+cCx4E9wFpgraQTdEFsTwfWR5dzJa2ppT3lorv4tCM6e8XOpwLPACOBj4BVwMvAIGANsMF2Q2UlVB/b5wGPA0dqbUsF6C4+zayzT+z8a+AaYFP87bC9CPgYuB64LqqwptieRXiTx0raWkI9DVE9vwGvAHeVw746otP4tEQy6/y/40vaklSjpJ9srwYeAsbEC9t+C5gATJEUv9/eoWYCyyXdWwZxlWA+MI6ga1yhjJ1Ra3fxaUd09koqkMDf0e8/OffvBk4AD9juHbv/KKGBnq6nBopj+2JgGdAk6f0URTqt1jx0OZ/mIVFnn4SMJ2G7D3BTdPlmPE3Sp7bXExpkBtAcTS93AhuAW0s0uiJEmtYDB4FFacp0Vq1J1INPbTcC/TIUaZG0MeMz8uos2vEJo+Ig4HVJmxPSFwM3ALLdlzCtbAZm1HHE4H5gKDBK0tEM5Tqj1iTqwaeNwAUZ8j8HbMz4jLw6G9rDmUnYng80AV8Bl0tqzZPvYaB9+tsBTJD0Z06e0YTN4zDgHOBmSc3FLLd9gIwNJGlWgfpGAh8AKyTdE7u/BBBFwpkptS4kbKYuAo4BHwILJe0tZHgHtL4gaXqG/OX26e3ALcCA6NbnwIOSNmWxqRIU05l3xLc9Lyr4BTA+XwNFHI6dz85toIi+wF5gXXSkZRWnTolDgGsJo8CBnLSWfBVFU986QhRgcQYb4qTROgZ4EtgFNABLgXdsX1KkHfcDf2Ww5VCGvJXw6Q/AAuAbwn5xJrDR9jBJn2WxrZyk0Zk44kfrr5WEjjpe0i8FHjINeB74GegPrJZUcB1o+wgwL82In6f8LDoQzrTdD/g9ZfYmSY055TNrjcr1Bf4AJkl6La295aTSPo2VbSXMbk+lsKdfmjojUq3x0+o8ZcS3vYCwNmohTG+/FnjI1UBz+0OAbcAc26sk7StmZA04BjybJ+1Swrp/O7AP2BlPLFHrmYQRMe1LV1aq4dMoAjSVMLPvSGFWI2Ve42fReVLHt72YMC3vBq4oNBXaHgW8RJjurpR02PZ9wIvAcmBScS3VJdrIzklKi9b4Qwl7hDU5aaVqbSI4Y2eRfGWn0j61PZig63TCv9+TJe0pZpekAZnFFCCLTogtdWzPJLzp/wKPEabmXA5IarY9BNgKHCVERvbHDNgFDAdGS9qWx8iaLHWK1LmEhM1tGbSuAG6Myn5XDlvTUg2f2j4NOB84C5gCzAXGFNvIl5MsOtsv4iP+hdFvb8I0lMR7trcTYqJthFFhf06ehcDbwCPAZZkU1Bm2B1KCVtsrCZ1+bLU7fUTFfSrpOPBtdLnb9gjgDmB2ydanJ5VOwssBFAlnVopSR/zOgO0mQix8rKQva21PtbC9BTiUNcxabarW8aPIxsDocgdhE/Iq0CrpYFWMqBK2nyD86zmJEFJr54ikLvMVqO1lwCbge8IGfhohvDlR0hu1tK0Yab/VKQfDgU+i4wzA0fnSKtpQLW4jdIR3gR9jR1f7+rM/Iey5j6B1BHBVvXd6qNFSp4ceak01R/weeqgbejp+D92S/wB9U/pYy1V1tAAAAABJRU5ErkJggg==", + "text/latex": [ + "$\\displaystyle 2 x_{1} + 4 x_{2} - 2 x_{3} = 2$" + ], + "text/plain": [ + "2⋅x₁ + 4⋅x₂ - 2⋅x₃ = 2" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x1,x2,x3 = symbols('x1:4')\n", + "eq1 = Eq(-x2 + x3, 2)\n", + "eq2 = Eq(2*x1 + 4*x2 - 2*x3, 2)\n", + "display(eq1, eq2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "hvis totalmatrix er givet ved " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "57c54709", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}0 & -1 & 1 & 2\\\\2 & 4 & -2 & 2\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡0 -1 1 2⎤\n", + "⎢ ⎥\n", + "⎣2 4 -2 2⎦" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "A, b = linear_eq_to_matrix([eq1, eq2], [x1, x2, x3])\n", + "T = A.row_join(b)\n", + "display(T)" + ] + }, + { + "cell_type": "markdown", + "id": "34345904", + "metadata": {}, + "source": [ + "Det kan løses direkte ved brug af SymPy på flere forskellige måder:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6b058e32", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}5 - \\tau_{0}\\\\\\tau_{0} - 2\\\\\\tau_{0}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\tau_{0}\\end{matrix}\\right]\\right)$" + ], + "text/plain": [ + "⎛⎡5 - τ₀⎤ ⎞\n", + "⎜⎢ ⎥ ⎟\n", + "⎜⎢τ₀ - 2⎥, [τ₀]⎟\n", + "⎜⎢ ⎥ ⎟\n", + "⎝⎣ τ₀ ⎦ ⎠" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left\\{\\left( 5 - \\tau_{0}, \\ \\tau_{0} - 2, \\ \\tau_{0}\\right)\\right\\}$" + ], + "text/plain": [ + "{(5 - τ₀, τ₀ - 2, τ₀)}" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left\\{ x_{1} : 5 - x_{3}, \\ x_{2} : x_{3} - 2\\right\\}$" + ], + "text/plain": [ + "{x₁: 5 - x₃, x₂: x₃ - 2}" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sols1 = A.gauss_jordan_solve(b)\n", + "sols2 = linsolve(T)\n", + "sols3 = solve([eq1,eq2])\n", + "display(sols1,sols2,sols3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Vi forestiller os at vi gerne vil angive den løsning, hvor den frie parameter er lig med $4$.** Vi bemærker først at løsningerne gemmes i forskellige data-typer, så det er svært at lave en generel metode:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tuple, sympy.sets.sets.FiniteSet, dict)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(sols1), type(sols2), type(sols3)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SetKind(TupleKind(NumberKind, NumberKind, NumberKind))" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sols2.kind" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi prøver:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}5 - \\tau_{0}\\\\\\tau_{0} - 2\\\\\\tau_{0}\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡5 - τ₀⎤\n", + "⎢ ⎥\n", + "⎢τ₀ - 2⎥\n", + "⎢ ⎥\n", + "⎣ τ₀ ⎦" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "display(sols1[0])\n", + "# sols1[0].subs(tau0,4) # Fejlmeddelelse: NameError: name 'tau0' is not defined" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "men 'tau0' er ikke defineret. Vi kan undersøge sagen nærmere med:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"MutableDenseMatrix([[Add(Integer(5), Mul(Integer(-1), Symbol('tau0')))], [Add(Symbol('tau0'), Integer(-2))], [Symbol('tau0')]])\"" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "srepr(sols1[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi ser at 'tau0' faktisk hedder `Symbol('tau0')`, så en mulighed er:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}1\\\\2\\\\4\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡1⎤\n", + "⎢ ⎥\n", + "⎢2⎥\n", + "⎢ ⎥\n", + "⎣4⎦" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sols1[0].subs(Symbol('tau0'),4) " + ] + }, + { + "cell_type": "markdown", + "id": "2c05071d", + "metadata": {}, + "source": [ + "### Brug af `free_symbol`-metoden:\n", + "\n", + "Vi kan mere generelt få fat i de frie variable ved `free_symbols`-metoden:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}5 - \\tau_{0}\\\\\\tau_{0} - 2\\\\\\tau_{0}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\tau_{0}\\end{matrix}\\right]\\right)$" + ], + "text/plain": [ + "⎛⎡5 - τ₀⎤ ⎞\n", + "⎜⎢ ⎥ ⎟\n", + "⎜⎢τ₀ - 2⎥, [τ₀]⎟\n", + "⎜⎢ ⎥ ⎟\n", + "⎝⎣ τ₀ ⎦ ⎠" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAADAAAAAVCAYAAAAAY20CAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAABJ0AAASdAHeZh94AAAC3UlEQVR4nNXXTYhWZRQH8N9MEVmhggOTBZJQWYtKsSKChCD7WATtpI1FVJhQTJ8QBKcTWBuZapWQC6ONLYYIjMhNYB/0ZRgYRpuEINOJIisS+3hb3Hvrzn3ve993RAfmvzncc85znv/h3Oec5xnr9XoWM85uU2bma7gDqyPi94Wl1MpnPT7HAxGxs24ba1YgM6/DJ3giIqYXjOUQZOabuAGXRcRvlX68xXcbjuOVBeI2Kl7AhXikrpxTgcy8HF9jZ0Q8uKD0RkBmHsJ5il/7H/rPwH0YwxuNhRM4Vtq6cBLLIuLEaWHcj914FhvxLv0J3IK/8XFDfwGeq31fgnuwH3tq+tkzSB4+LGV/Apl5PtbiULPzRMRhReaV7/2KBHZHxPYzSLiJz0q5oVLUD/HFOAtHRgi0tpQHTgerURERv+AEVlW6+i+0opQ/jxDrmlJ+OcghM7fiSazEV5iKiPfnQ3gAfsJk9VGvwB+lPLdrdWaO4Wp8HxGzA3w24WU8j3X4CO9k5qo2/3liSY3rnAocK+UK3ViNpf4/UG14DLsi4tXy++HMvB0P4el50a0hM8exHN9WunoFjmAWa4bEuaKUBwdscg7WY2/DtBc3jk63FWsUrfxApfgvgYjoYR8mMvPSjiBLS3l8gH1C0QyONvRHFZN0DjJzV2b2MvPeIeQprhLwXqVoXiVmSnlbR5BvSjmVmdOZefcIG3eh4vDXCL63KubUW83FFWYUZ2HzoAgR8QWewZ+YwrUNlx/LTSYb+kn80BLyKvyKt7uYZ+Yy3IU9EfFdawIRcRIv4frMXNeRxLaIWBkR4xHxeEuM/YppWcdGRTeqk1qu6Gg7ImJY+96s6JBzBmfbe+BFbFFcHe4cEnQQpvF6Zn6q6FZbcBF2NPxuUlSy89qemUsU3WsmIj6o2/reA+WCDbgZ20/1QVMOsqcUg+wgHo2IfacY60psUrTmw3VbawKLCW0PmkWFfwH4Hdu5138UYAAAAABJRU5ErkJggg==", + "text/latex": [ + "$\\displaystyle \\left( \\tau_{0},\\right)$" + ], + "text/plain": [ + "(τ₀,)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# sols1\n", + "sols1_as_tuple = Tuple(*sols1)\n", + "var1_as_tuple = Tuple(*sols1_as_tuple.free_symbols)\n", + "display(sols1_as_tuple, var1_as_tuple)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left( \\left( 5 - \\tau_{0}, \\ \\tau_{0} - 2, \\ \\tau_{0}\\right),\\right)$" + ], + "text/plain": [ + "((5 - τ₀, τ₀ - 2, τ₀),)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAADAAAAAVCAYAAAAAY20CAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAABJ0AAASdAHeZh94AAAC3UlEQVR4nNXXTYhWZRQH8N9MEVmhggOTBZJQWYtKsSKChCD7WATtpI1FVJhQTJ8QBKcTWBuZapWQC6ONLYYIjMhNYB/0ZRgYRpuEINOJIisS+3hb3Hvrzn3ve993RAfmvzncc85znv/h3Oec5xnr9XoWM85uU2bma7gDqyPi94Wl1MpnPT7HAxGxs24ba1YgM6/DJ3giIqYXjOUQZOabuAGXRcRvlX68xXcbjuOVBeI2Kl7AhXikrpxTgcy8HF9jZ0Q8uKD0RkBmHsJ5il/7H/rPwH0YwxuNhRM4Vtq6cBLLIuLEaWHcj914FhvxLv0J3IK/8XFDfwGeq31fgnuwH3tq+tkzSB4+LGV/Apl5PtbiULPzRMRhReaV7/2KBHZHxPYzSLiJz0q5oVLUD/HFOAtHRgi0tpQHTgerURERv+AEVlW6+i+0opQ/jxDrmlJ+OcghM7fiSazEV5iKiPfnQ3gAfsJk9VGvwB+lPLdrdWaO4Wp8HxGzA3w24WU8j3X4CO9k5qo2/3liSY3rnAocK+UK3ViNpf4/UG14DLsi4tXy++HMvB0P4el50a0hM8exHN9WunoFjmAWa4bEuaKUBwdscg7WY2/DtBc3jk63FWsUrfxApfgvgYjoYR8mMvPSjiBLS3l8gH1C0QyONvRHFZN0DjJzV2b2MvPeIeQprhLwXqVoXiVmSnlbR5BvSjmVmdOZefcIG3eh4vDXCL63KubUW83FFWYUZ2HzoAgR8QWewZ+YwrUNlx/LTSYb+kn80BLyKvyKt7uYZ+Yy3IU9EfFdawIRcRIv4frMXNeRxLaIWBkR4xHxeEuM/YppWcdGRTeqk1qu6Gg7ImJY+96s6JBzBmfbe+BFbFFcHe4cEnQQpvF6Zn6q6FZbcBF2NPxuUlSy89qemUsU3WsmIj6o2/reA+WCDbgZ20/1QVMOsqcUg+wgHo2IfacY60psUrTmw3VbawKLCW0PmkWFfwH4Hdu5138UYAAAAABJRU5ErkJggg==", + "text/latex": [ + "$\\displaystyle \\left( \\tau_{0},\\right)$" + ], + "text/plain": [ + "(τ₀,)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# sols2\n", + "sols2_as_tuple = Tuple(*sols2)\n", + "var2_as_tuple = Tuple(*sols2_as_tuple.free_symbols)\n", + "display(sols2_as_tuple, var2_as_tuple)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEsAAAAUCAYAAADFlsDIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAABJ0AAASdAHeZh94AAADc0lEQVR4nO3YX4hVVRTH8c9oD1pGkkFSIAXW0EMhWSClUtIkBZFYEAX2v6iwhJjCiWK1jAqpNIsKRGiilwolQpOMIoj+kmCBYD1UkMFIkmJNZaVOD+fcuHM9d7wzt7n54A8O+7DPWut8zz7rrL3P7hoaGnJMrem4qs7MfAVX4MyI+K2zSP+/MnM2tuKOiFhX6+9qzKzMvBCfozciVnWU8ihSZr6JOTgrIgZhQoXd4/gFL3WQ7WjUk5iO+2odwzIrM8/G11gXEXd2HO8oU2buwPGKcnSosWbdii68XuH4LnpwbURsqOvvwsu4CSsjYvl4wVdpnLlew6Nl/C2Nn+FlOIjPKhwfwCE8lpkT6/qfLoHWdnqgOsD1cdn2UFezMvMEzMKOqhkwIr7CqzgHS0qfh3A/3sDdYwRqS+PM9UXZzmd4gT8dEzEwgvMj2I/IzKWKyWALlkTEoTag2tW4cEXEvjLuDIavs6aV7d4RnHdm5rNYjufxCRZHxF/1dpk5H72YjdNwS0T0jxX6SBoFVx8Woxt/KspNX0RsHyH8HpzK8Mz6o2wnHYFtd935bRHxe4XNFGzHsrq4461WuC7Bi7gIC3AA72XmySPEnax8hvrM+qlspx1mXiozb1AUzl2KNcgyFTUhIjZjc+nTPwLIf6JRcC1s8FuCfbgYGyviTsBUfM/wzBpQvJ3uJkBXol+RMefhG9yemZX2nVKbXCcqxqBZ6elWLKW+pG6wImIIH+KUzJzZADQX6/EjFkbEbjysyMyVLT5XpTKzPzOHMvPmMfi2y7VGMRCfNrk+p2w/4PDfndqi7t90zcxZ2KRI156IGICIWK/42bw6M+e1ANZMNYYDo3FqlyszV2EuromIg03MLlesO9+qB61pg6J23VgGnIl3MKR4c9822PeV7VMtPF8znYtf8XarDu1yZeZqXI8FEfFdE5uTsAibImIn1bsOfXgC50fEtlYfoJkycxBLq5YOmTkVP+OZiHiw3Xu1yLMG1+HSiNgxgt29eA7zIuIjqvezVuMurMBVYwSaglrdm4AZ5WezJyJ+qDOdh7/Rka2gzHxBscpfhL2ZOb28NFjbhintJiuyc0NtoKjYoomI/WXAreUv0Fh0AbaVx2Rkeb6i4V4bI2JSROwa431Gq3sUM+D7itm/dvQ22J2BtY39h32Gx9Rc/wByJHWldifP3wAAAABJRU5ErkJggg==", + "text/latex": [ + "$\\displaystyle \\left( x_{1}, \\ x_{2}\\right)$" + ], + "text/plain": [ + "(x₁, x₂)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJYAAAAVCAYAAACkJReUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAABJ0AAASdAHeZh94AAAFFUlEQVR4nO2af6xPZRzHXxdbdGts2rqbpWv9MFsk1aYVkWSyVsRqRlr6wSopFSp79+4nq9CvpWbD1FaNpYWojYVaPyihsFJKQ5RSlBS3P57zvY7jfO91ru/3uur72u6e+/2c5znn/ZzzOZ/P8+OUVVVVUaJEoWmSZrQ9A+gNtJG0u34llThWsH0usBy4SdLU+LGyZMSyfT7wEXC3pIkx+0bg1DzX+FFSRSFFl6hfbLcE+gJ9gPZAK2AvsBqYBkyTtD+l3RtAZ+AMSbty9rSI9SjwG/BCyrGdwOQU+64UW4ljiwGEZ74FWAx8D5wM9AOmAr1tD5CUHDs9TghEI4DHcsaDIpbtM4F1wFRJN8dbRxELSZUF7U6JBoHtS4ByYF48MtmuAD4GTgH6S5qd0nYtcDxh6LQfDo1YNwBlwGvFkV94bL8D9CTRadtlhBA+BJggaUxJV34kLcpj32p7CiGTdQMOcSzgVeBBQn8XwqGOdSmwD/gwz/WPsz0IaA3sBlYBSyTty9SLwnIP8CnwsO05MS1PEh7eS0fp4TVUXXXh76j8J8/x96Oy2rEa5Y7YLgc6AmtrmAlWADMJ3jsZWAR8ZfviI1F9JEj6PNLUDhgMYPs+4C7gdWB4SVfdsd0EuC76uSBPtU+ismvO0Ch2sBXQmDB4S2Ma0IPgXOWEmcOLQCXwtu2z6yK8QIwD9gCyfRvB8RcCg9NmMiVdmRgPnAXMl7QwrYKknYR+ts7Z4qmwZVT+kqexE6Y1wDDbu4BRhBzbtyaFtSxZpPGKpEG1VZK0yfZkYAzwLPAB0E/S3ti1bwVuIbwIAF8Aj0ial0FPJoqtq1j3M3b+EYRnu44o6tbADsIsEjg4Yv0ZlU0P98IRU6Kya421AhuA9Rn+NmfQsT32/1BJfySO/wCMBjoB5xHS+BzbHTJcoy4UU1fR7mcUYZ8GvgS6S9pRS5NmHPChgyLWtqhsSTZyN668toqSemQ892FheyBhULyVkKrvIDGGkfRmotn9tocDFxAmIcecriLez5HAJEJW6iFpWy31GwEtgG9ztnjE2kJwkrYZdXSOym8ytisIti8HphNuQgfCm3mj7bz9sN3Y9rXACYT09L/RVRu2RxOcaiUhUtXoVBFtCctUK3OGaseKVlSXACfZPj1xsXbRrDEpohJ4Lvr5cqYeFADbFwGzCOmkl6TtwAOESDwhpX77aEz4FyGF95W0OqXedNtVtq9vSLqKje1xhMH6CkKk+ukwm+aCy+KcIbmONRu4GugFfB2zXwOMsr0E+A74HTiNsK/UFJhPCPn1hu2OwFzCNlNPSVsAJM2yvRy40nYXSUtjzdYTllSaA/2BGba7SVqTOH3uhcu3bnO0dBUN20OAhwjrmEuBEXZyvsZGSdNTml8WtatO62mOtY2wbvF8zL6YEO7OAS4kjKd+BZYR1mpmpuwhFY0ooi4AqggRYUOiyljgXeAJDrxNRLOx3AuzItpwvxMYmmjfnvDyZJox1oOuYtImKhsDI/PUeY+Q3qux3Ry4CpgraVPOnvZ1w1jCZmInSZ8VQnFDxfYiYHN8Cm67BfAz8JSkexuKroaK7duBZ4Aukpbl7GlfN0wChhHC4hX1I6/42B5PiECbgBOBgYS9rz6Jql0IWxgTqQcy6Gpw2G5GiMKz404FKY4laY/twUB32+X/oQ/9KggTjArC+GcV0Du5mizpLbKv5RVdVwOlEniJRHqElFRYokQhaFR7lRIlsvMvQVhcWbYw8twAAAAASUVORK5CYII=", + "text/latex": [ + "$\\displaystyle \\left( 5 - x_{3}, \\ x_{3} - 2\\right)$" + ], + "text/plain": [ + "(5 - x₃, x₃ - 2)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# sols3 er en dictionary, så den skal tilgås ved:\n", + "display(tuple(sols3.keys()),tuple(sols3.values()))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJYAAAAVCAYAAACkJReUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAABJ0AAASdAHeZh94AAAFFUlEQVR4nO2af6xPZRzHXxdbdGts2rqbpWv9MFsk1aYVkWSyVsRqRlr6wSopFSp79+4nq9CvpWbD1FaNpYWojYVaPyihsFJKQ5RSlBS3P57zvY7jfO91ru/3uur72u6e+/2c5znn/ZzzOZ/P8+OUVVVVUaJEoWmSZrQ9A+gNtJG0u34llThWsH0usBy4SdLU+LGyZMSyfT7wEXC3pIkx+0bg1DzX+FFSRSFFl6hfbLcE+gJ9gPZAK2AvsBqYBkyTtD+l3RtAZ+AMSbty9rSI9SjwG/BCyrGdwOQU+64UW4ljiwGEZ74FWAx8D5wM9AOmAr1tD5CUHDs9TghEI4DHcsaDIpbtM4F1wFRJN8dbRxELSZUF7U6JBoHtS4ByYF48MtmuAD4GTgH6S5qd0nYtcDxh6LQfDo1YNwBlwGvFkV94bL8D9CTRadtlhBA+BJggaUxJV34kLcpj32p7CiGTdQMOcSzgVeBBQn8XwqGOdSmwD/gwz/WPsz0IaA3sBlYBSyTty9SLwnIP8CnwsO05MS1PEh7eS0fp4TVUXXXh76j8J8/x96Oy2rEa5Y7YLgc6AmtrmAlWADMJ3jsZWAR8ZfviI1F9JEj6PNLUDhgMYPs+4C7gdWB4SVfdsd0EuC76uSBPtU+ismvO0Ch2sBXQmDB4S2Ma0IPgXOWEmcOLQCXwtu2z6yK8QIwD9gCyfRvB8RcCg9NmMiVdmRgPnAXMl7QwrYKknYR+ts7Z4qmwZVT+kqexE6Y1wDDbu4BRhBzbtyaFtSxZpPGKpEG1VZK0yfZkYAzwLPAB0E/S3ti1bwVuIbwIAF8Aj0ial0FPJoqtq1j3M3b+EYRnu44o6tbADsIsEjg4Yv0ZlU0P98IRU6Kya421AhuA9Rn+NmfQsT32/1BJfySO/wCMBjoB5xHS+BzbHTJcoy4UU1fR7mcUYZ8GvgS6S9pRS5NmHPChgyLWtqhsSTZyN668toqSemQ892FheyBhULyVkKrvIDGGkfRmotn9tocDFxAmIcecriLez5HAJEJW6iFpWy31GwEtgG9ztnjE2kJwkrYZdXSOym8ytisIti8HphNuQgfCm3mj7bz9sN3Y9rXACYT09L/RVRu2RxOcaiUhUtXoVBFtCctUK3OGaseKVlSXACfZPj1xsXbRrDEpohJ4Lvr5cqYeFADbFwGzCOmkl6TtwAOESDwhpX77aEz4FyGF95W0OqXedNtVtq9vSLqKje1xhMH6CkKk+ukwm+aCy+KcIbmONRu4GugFfB2zXwOMsr0E+A74HTiNsK/UFJhPCPn1hu2OwFzCNlNPSVsAJM2yvRy40nYXSUtjzdYTllSaA/2BGba7SVqTOH3uhcu3bnO0dBUN20OAhwjrmEuBEXZyvsZGSdNTml8WtatO62mOtY2wbvF8zL6YEO7OAS4kjKd+BZYR1mpmpuwhFY0ooi4AqggRYUOiyljgXeAJDrxNRLOx3AuzItpwvxMYmmjfnvDyZJox1oOuYtImKhsDI/PUeY+Q3qux3Ry4CpgraVPOnvZ1w1jCZmInSZ8VQnFDxfYiYHN8Cm67BfAz8JSkexuKroaK7duBZ4Aukpbl7GlfN0wChhHC4hX1I6/42B5PiECbgBOBgYS9rz6Jql0IWxgTqQcy6Gpw2G5GiMKz404FKY4laY/twUB32+X/oQ/9KggTjArC+GcV0Du5mizpLbKv5RVdVwOlEniJRHqElFRYokQhaFR7lRIlsvMvQVhcWbYw8twAAAAASUVORK5CYII=", + "text/latex": [ + "$\\displaystyle \\left( 5 - x_{3}, \\ x_{3} - 2\\right)$" + ], + "text/plain": [ + "(5 - x₃, x₃ - 2)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAADAAAAAVCAYAAAAAY20CAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAABJ0AAASdAHeZh94AAADKUlEQVR4nNXXbajfYxgH8M85RzEjqykrJQpL2ZqnTJkoxxrJQ15odUbmaRERmacul+dlHkqitbLFC7QTMuUgSoiQ52ZFXhx1ZEWHYYYdL+7f/+x3/ud3HmydU+f75vr/rv913/f3uq+H+747hoaGzGTs06TMzI1YhiMi4vfppdTI5wR8jCsiYn39v472CGTmSfgQN0XEI9PGcgJk5otYjKMiYntL39lgex9+xZPTxG2yeADzcF1dOSICmXk0vsH6iLhyWulNApm5Bfsrqb2L0TVwGTrwfMPg19GNiyKit6bvwNO4BGsiYvXU0AfP4a6KRx+jU+hM/IsPGgbfjF24JzO7avq1Cvl1U0we3qtkd0sx7EBmzsYibGnqPBHxOZ7BMeipxtyGG/ECVk0V6xo+quRpLUU9AoeiCwPjTHAndiAy81ql4PvQ08rJqUREDFbrH9bS1WtgbiV/GWeC/sx8DKvxON7HhRGxs26XmdfgKhxeqb7GvRHx6t65AH7GIa2PegT+rOR+E0ywrfZ7ZUT80WDzA27B8TgRb+GlzFz4v+mOxiy7uY6IwE+VnGsMZOZypWh/VHry9RpyPyJeblPdnpmrcAq+2CPaZf1OzMH3LV09AgPK7s4fY/DZ2ICvsBBbcXlmNtrXxnVl5sU4QEm5vcF8pc1/1lIMOxARQ3gHB2fmkW0kTsUmJTWWRsQ23KFEcM0YxBdk5nb8hadwQUR82WC3ITOHMvPSSTiwuJJvj3KgQuuAWlpbYBE2YxDdETFQObxJuWCdl5lLGhbbqrTlk5VrycbMPLbBrsXhn0k4cJZyTg2naPtJ3KvUwgo8UUXiNQwpO/9dm/2teAMP2b07oOpM31afn1SXxBuwsm2OBfgN43aozDwI52NzRPQ3OhARO6s2eX9mHhcRnyrF2oiIeFPJycmgE/u2kZqj1NPDETFm+66wQumQa+vKpvfAo7gad+PcSZIbgcx8UNnRfhyI5Tgd57SZLsHfGPfanpmzlGj3RsS79f9GORAROzKzB2dk5uw9fNDMw7OVHFRa57KI6Gtb6xUTnzuUA3Gd0gVHYNSDZqah6UEzo/AfJu4K5UKWGpoAAAAASUVORK5CYII=", + "text/latex": [ + "$\\displaystyle \\left( x_{3},\\right)$" + ], + "text/plain": [ + "(x₃,)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# sols3\n", + "sols3_as_tuple = Tuple(*sols3.values()) # bemærk `values`-metoden bruges\n", + "var3_as_tuple = Tuple(*sols3_as_tuple.free_symbols)\n", + "display(sols3_as_tuple, var3_as_tuple)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Lad os samle det i én kommando:**" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAALwAAAAVCAYAAAD8WoSNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAABJ0AAASdAHeZh94AAAFC0lEQVR4nO2bbYgVVRjHf6tSmqGRgpZkipUJbVlWSKBlZikVZCVCWFpUWKRsmYZQ/PsHvXwwrQgyFNyoqD4sEaihH5JWi7TMtSxNerECX1azNCWxdPtw5up1vHfd2Z2596r3B5eHeeacmf8899xnznlmbk1LSwtVqpwudCnktP0WMA4YKGl/aSVVqdJxbA8DvgIekrQw56+JZ3jb1wCrgSclzc3zbwEuLHL8HZL6pi26Smmx3QsYD9wK1AL9gIPAt8AiYJGkw+VTmAzbHwLDgYsl7YPCGf55YC/wRoF9e4BXCvj3paSxSnmZQPjetwErgN+APsCdwEJgnO0Jkk6WefCLhOQ9HXgBYhne9iXAJmChpIfze0YZHkkDSqO1SqmxfSPQHViSn8lt9wXWABcAd0tqKJPExNjeCJxFmJ4fjmf4B4Aa4IOSK2sHtnsDzQTNrXEQ6CnpQPaqKlfXiZD0SRH/dtvzCXf/G4DUBnwJYvU+8CwwBlgWH/A3AYeAL4p0PtP2JKA/sB/4BmiUdCihiLQ4G3gub3sAMBlYCyzO8+8s8aCqVF0d4d/I/pfycbOO1WeRHQMsOzKlsd2dMEffKKk23quVResvwP2SPm2HmFSx/SCwAJgpaU659eSoVF1txXYXYB1wGTBW0rIMz5VqrGz3BP4CvpR0bae8ff2AzoQFSyEWAaOBvoR5Xi3wJuEX+bHtKzoqLgWGRrapjBoKMTSyTWXU0BFeIgz2pVkO9oihkW1K42CS9gAHCLOSY6o0vSL7Z5GOjrk2AFNt7wNmEOZJ41s7+QlKm4V4V9KkBO1zP7r1rWh4FJgJnAd8B9RJWpngHO0hE10liCe2pxO+303AvUn6tpMsYrWbUG0iP8P/E9muCQXOj+zINrT9CfghwWdrW0XYrgEuB7ZK2lmkzUTgVUKJ6krgc8LdqX9bz5OUjHVlFs9I12ORru+BUZJ2J+mflAxj1Y1ofOdn+ObI9jqueevkhHU/UUNJoxMeOwkDgR4cXaQU4gmgXtKCaHua7bHAI8Dsk01XlvG0XQfMI9zJR0tqbr1HKqQeK9udgHMIa81jMvw2wuAdnFDk8Mj+nLBf2lwa2Q2Fdto+AxgGLI/tWg5cdxrqKortpwiDvYmQ2Usx2CGbWA0mlDybIG/AR0/PGoHeti+KnWhIVMWJCxgAvB5tvlP8OkpCj8juLbK/N2FRviPm30FYiB/Bdr3tFttTKklXKbD9DGGRupaQ2Xe1oU9a8coiVrmEvAKOf7WgAbgLuAX4Mc8/EZhhuxH4FfgbGER456IrsBQod7ltc2TrbJ9LKEO9185j5RJBGjXnNHVliu3JhJr4IWAlMN2O1yrYIqk+5ksrXlnE6mbC9XwEx05pIAz4ZuC+mH8F4SHAIOAewjzqemAV4SHBbZIOdlBYh5D0NfA04QFJHXB1rMkuwoX3ifn7ANtjvlrCj3pJhenKmoGR7UzQqgKfKQX6pRKvtGMV1eDvABZL+h0Kvy05m7ACvkrSuo5cQKVhezWwPv89IdubgQZJs6Ptc4A/gJclzaoUXZVKqeOVJFa2pwGvASMkrYLCb0vOA6YSbm23ZyW8TMwF3ra9hlAJmAqcz9HSKsAIQoaZe3z3suqqVEodrzbFynY3QtWmITfYoUCGjxqPBEYBc061P4BEDy1mER5abAAel9RYXlWVq6sSaUusbA8hrD3rJW3J+QsO+CpVTlXii9YqVU5p/geojlcEm2u1/AAAAABJRU5ErkJggg==", + "text/latex": [ + "$\\displaystyle \\left( 5 - \\tau_{0}, \\ \\tau_{0} - 2, \\ \\tau_{0}\\right)$" + ], + "text/plain": [ + "(5 - τ₀, τ₀ - 2, τ₀)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFgAAAAUCAYAAAAJD/ojAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAABJ0AAASdAHeZh94AAADkklEQVR4nO3YW6hVVRQG4O+oD0k3wR4EKzBKC5LMCO1BS1MjgrAsesiypIjADkZSGNlwCJUPqRlFgobHJChBIqjIlyIzupNQdCPIkjDMjMrILnZ6WGufttt9vOy9l56iHzaTOeacY/z7X3ONOebq6u3t9T+qw6BjTeC/jiHNjJm5DpdjVET8cnQp/fuQmRfgPdwaEWvqx7oaU0RmXoi3sSAiltfZr8HFGIfzcCKejojZFRIfjqtwBcZiJH7Hh1iLtRHxV1Xx63jMxvqye4CI5ZznMBFnRcSemr1ZingAP+GJBvt9mKcQ+Jv2aR8WrsVqTFA89EewEediDTZkZleVBDLzNDyGPYeY+hBGoLveuJ/AmTka07AhIn5tcHAnRuMk3N4G5yPB57gSp0bE9RGxMCLm4mxsxyxcXVXw8uGtxfdYdbC5EfEOPsVtmdmna2MOnosuPNvEwat1gVtnfQSIiFf6sX+bmasUb9slil1dBboxtYwx9TDmP4PFmI5NHJgipmEf3uoUwwrxR9n+WYXzzDwHS7EyIjYf5rI3ynZ6zdAncGYer8ivnwz0yiEzh+DGsvtyRf7X42vcewRL3y3byTVD/Q4eicHY0S7Bo4ClioPupYjYVIH/+3E+bmpyFvWLiPgRe3F6zVYv8PCy/aETDKtCZnbjLsWBckMF/icodu2yiHizBRe7cUqtUy9w7Ukd1zq9apGZ87ASH2NKROzusP8heEpRvSxq0c1Q/2i5XxWxs2yHG4DIzPlYgY9waUTsPPiKlnCCohSFvf1US6szc7Xi8JvfwHEQhuHLmq1e4B34DmM6x7czyMx7FHl3K6ZHxK6KQv2GJ/sZG6/Iy1vwGZqljzGKMndrzdAncET0ZuZmzMrMMyPii3bZZmYP5uDmiOhp0cciLMH7mHGotNBOzPJAu6Ufv4sVAq9rdlUuMbFs++4MjReNjYrb0WXYT+DMnImZZXdE2V5U/iHYFRELGvzVcnxLtWpmzlGIuw+vo7vJa7utQci2YraJGQquz9cMzQTeqagxH28YG6fYGfU4o/zBV2gUeCx+xostEh5VtoMxv585r6GngzFbQmaerNiAL0TE9pq92de0hXgQ4yPigzYCDlPc4ZdFxN2t+hnoMeti34FHMSkittTszb6mrVDcYJa0GXOS4jq7/FATO4hjEVNmDsVCbKwXlyY7uFwwGVPw8EC/Ng8ElN8trkNPRGyrH/sbGUIvLKnRTFUAAAAASUVORK5CYII=", + "text/latex": [ + "$\\displaystyle \\left( 1, \\ 2, \\ 4\\right)$" + ], + "text/plain": [ + "(1, 2, 4)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# virker både for sols1 og sols2, mens sols3 kræver sols3.values()\n", + "sols = linsolve((A,b)) # or sols = A.gauss_jordan_solve(b)\n", + "var = Tuple(*Tuple(*sols).free_symbols)\n", + "display(Tuple(*sols)[0])\n", + "Tuple(*sols)[0].subs(var[0],4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Det er lige til at generalisere dette til tilfælde med flere frie variable. Prøv." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 ('mat1-pilot': venv)", + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-E-Uge-10-LilleDag.ipynb b/Demos/Demo-E-Uge-10-LilleDag.ipynb new file mode 100644 index 0000000..59434ba --- /dev/null +++ b/Demos/Demo-E-Uge-10-LilleDag.ipynb @@ -0,0 +1,877 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "14b14fd2", + "metadata": {}, + "source": [ + "# Diagonalisering ved similartransformation\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aad4b143", + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "cell_type": "markdown", + "id": "9169d043", + "metadata": {}, + "source": [ + "I denne SymPy demo vil der blive gennemgået fem eksempler på mulig diagonalisering. Til sidst præsenteres en metode til undersøgelse om matricer er similære." + ] + }, + { + "cell_type": "markdown", + "id": "df2c8fb7", + "metadata": {}, + "source": [ + "### Eksempel 1\n", + "\n", + "Vi betragter matricen:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d854a3a7", + "metadata": {}, + "outputs": [], + "source": [ + "A = Matrix([[1,1,0],[2,1,-1],[0,2,1]])\n", + "A" + ] + }, + { + "cell_type": "markdown", + "id": "24c7c5c9", + "metadata": {}, + "source": [ + "Som vi finder egenværdierne af, ved \"simuleret håndregning\"," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f4f95cd1", + "metadata": {}, + "outputs": [], + "source": [ + "def K(l):\n", + " return A - l*eye(3)\n", + "\n", + "lamda = symbols('lambda')\n", + "K(lamda)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "05b970e0", + "metadata": {}, + "outputs": [], + "source": [ + "karakpol = K(lamda).det()\n", + "roots(karakpol)" + ] + }, + { + "cell_type": "markdown", + "id": "9e503221", + "metadata": {}, + "source": [ + "Vi kan altså se, at der kun er én egenværdi, og at den har algebraisk multiplicitet tre! Dette eftertjekkes ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cf76869f", + "metadata": {}, + "outputs": [], + "source": [ + "factor(karakpol)" + ] + }, + { + "cell_type": "markdown", + "id": "d4aaa240", + "metadata": {}, + "source": [ + "Egenvektorene hørende til egenværdien $1$ findes som løsningerne til den homogene matrixligning $K(1)\\,x=\\mathbf{0}$, altså ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fd404051", + "metadata": {}, + "outputs": [], + "source": [ + "K(1).nullspace()" + ] + }, + { + "cell_type": "markdown", + "id": "25056f19", + "metadata": {}, + "source": [ + "Vi har altså at\n", + "\n", + "\\begin{equation}\n", + "E_1=\\text{span}\\{(1/2,0,1)\\}\n", + "\\end{equation}\n", + "\n", + "og dermed at summen af de geometriske multipliciteter kun er 1! Da $1<n=3$ kan $A$ *ikke* diagonaliseres!" + ] + }, + { + "cell_type": "markdown", + "id": "3b268d27", + "metadata": {}, + "source": [ + "### Eksempel 2\n", + "\n", + "Vi betragter nu matricen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2405412f", + "metadata": {}, + "outputs": [], + "source": [ + "B = Matrix([[2,1,0],[0,1,-1],[0,2,4]])\n", + "B" + ] + }, + { + "cell_type": "markdown", + "id": "6e6cea3c", + "metadata": {}, + "source": [ + "Vi benytter nu en stærkere kommando til at finde egenværdierne" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6c05b0d3", + "metadata": {}, + "outputs": [], + "source": [ + "B.eigenvals()" + ] + }, + { + "cell_type": "markdown", + "id": "b868632e", + "metadata": {}, + "source": [ + "Hvor vi altså kan se, at egenværdien $2$ har algebraisk multiplicitet to, og at egenværdien $3$ har algebraisk multiplicitet en. \n", + "\n", + "Nu kan vi så finde egenvektorene ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7dc805e4", + "metadata": {}, + "outputs": [], + "source": [ + "B.eigenvects()" + ] + }, + { + "cell_type": "markdown", + "id": "341999c9", + "metadata": {}, + "source": [ + "Altså får vi at\n", + "\n", + "\\begin{equation}\n", + "\\begin{aligned}\n", + "E_2 = & \\text{span}\\,\\{(1,0,0)\\}\\\\\n", + "E_3 = & \\text{span}\\,\\{(-1/2,-1/2,1)\\}.\n", + "\\end{aligned}\n", + "\\end{equation}\n", + "\n", + "Her ser vi, at både egenværdien $2$ og egenværdien $3$ har algebraisk multiplicitet 1. Da bare en af vores egenværdier ikke har $am(\\lambda)=gm(\\lambda)$ kan $B$ altså *ikke* diagonaliseres!\n", + "\n", + "Dette ses også tydeligt, hvis vi benytter den indbyggede funktion:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a8aba5d", + "metadata": {}, + "outputs": [], + "source": [ + "B.is_diagonalizable()" + ] + }, + { + "cell_type": "markdown", + "id": "4c656c5d", + "metadata": {}, + "source": [ + "### Eksempel 3\n", + "\n", + "Vi betragter matricen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "603eaaed", + "metadata": {}, + "outputs": [], + "source": [ + "C = Matrix([[0,1,0],[-2,3,0],[0,0,2]])\n", + "C" + ] + }, + { + "cell_type": "markdown", + "id": "ea3af290", + "metadata": {}, + "source": [ + "Vi finder egenværdierne og egenvektorene direkte ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d1199c56", + "metadata": {}, + "outputs": [], + "source": [ + "C.eigenvects()" + ] + }, + { + "cell_type": "markdown", + "id": "796b39a1", + "metadata": {}, + "source": [ + "Her ses, at egenværdien $1$ har algebraisk multiplicitet en, og en tilhørende egenvektor, samt at egenværdien $2$ har algebraisk multiplicitet på to med to tilhørende egenvektorer. Da summen af geometrisk og algebraisk multiplicitet stemmer overens, kan vi i dette tilfælde godt diagonalisere vores matrix. De egenrum der opstår kan beskrives ved\n", + "\n", + "\\begin{equation}\n", + "\\begin{aligned}\n", + "E_1 = & \\text{span}\\,\\{(1,1,0)\\}\\\\\n", + "E_2 = & \\text{span}\\,\\{(1/2,1,0),(0,0,1)\\}.\n", + "\\end{aligned}\n", + "\\end{equation}\n", + "\n", + "Disse egenrum kan visualiseres ved\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "id": "b9c58551", + "metadata": {}, + "source": [ + "Vi fortsætter med diagonaliseringen. Vi vælger" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a6ae722", + "metadata": {}, + "outputs": [], + "source": [ + "v1 = Matrix([1,1,0])\n", + "v2 = Matrix([S(1)/2,1,0])\n", + "v3 = Matrix([0,0,1])\n", + "Matrix.hstack(v1,v2,v3)" + ] + }, + { + "cell_type": "markdown", + "id": "d9af2c3e", + "metadata": {}, + "source": [ + "Det ses at $v_1$ er en basis for $E_1$, samt at $v_2$ og $v_3$ er en basis for $E_2$. Af sætning 13.11 punkt 1, må $V=(v_1,v_2,v_3)$ altså udgøre et lineært uafhængigt sæt, som kan bruges til en basis bestående af egenvektorer." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "da8f66aa", + "metadata": {}, + "outputs": [], + "source": [ + "V = Matrix.hstack(v1,v2,v3)\n", + "V" + ] + }, + { + "cell_type": "markdown", + "id": "7776386f", + "metadata": {}, + "source": [ + "Og af Hovedsætning 13.14 punkt 2, får vi" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ac99e18e", + "metadata": {}, + "outputs": [], + "source": [ + "Lamda = Matrix.diag([1,2,2])\n", + "Lamda" + ] + }, + { + "cell_type": "markdown", + "id": "d8de5568", + "metadata": {}, + "source": [ + "Dette kan eftertjekkes med sætning 14.7, der siger at $V^{-1}\\,C\\,V=\\Lambda$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "72684605", + "metadata": {}, + "outputs": [], + "source": [ + "V.inv()*C*V" + ] + }, + { + "cell_type": "markdown", + "id": "5e7cf53f", + "metadata": {}, + "source": [ + "Som forventet!" + ] + }, + { + "cell_type": "markdown", + "id": "8b59e217", + "metadata": {}, + "source": [ + "### Eksempel 4\n", + "\n", + "Vi betragter matricen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4de3bf3b", + "metadata": {}, + "outputs": [], + "source": [ + "F = Matrix([[0,-1,0],[4,5,2],[0,0,2]])\n", + "F" + ] + }, + { + "cell_type": "markdown", + "id": "53c6b23d", + "metadata": {}, + "source": [ + "Vi kan direkte se, at denne kan diagonaliseres ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7282d192", + "metadata": {}, + "outputs": [], + "source": [ + "F.is_diagonalizable()" + ] + }, + { + "cell_type": "markdown", + "id": "f4b7df5a", + "metadata": {}, + "source": [ + "Hvorved vi kan benytte den indbyggede funktion til at finde diagonaliseringen," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "72ddff90", + "metadata": {}, + "outputs": [], + "source": [ + "F.diagonalize()" + ] + }, + { + "cell_type": "markdown", + "id": "63cfffcb", + "metadata": {}, + "source": [ + "Vi aflæser at egenværdierne er $1$, $2$ og $4$ med algebraisk multiplicitet (og geometrisk), samt at de tilhørende egenrum kan beskrives ved\n", + "\n", + "\\begin{equation}\n", + "\\begin{aligned}\n", + "E_1 = & \\text{span}\\{(-1,1,0)\\}\\\\\n", + "E_2 = & \\text{span}\\{(1,-2,1)\\}\\\\\n", + "E_4 = & \\text{span}\\{(-1,4,0)\\}.\n", + "\\end{aligned}\n", + "\\end{equation}\n", + "\n", + "Disse egenrum kan visualiseres ved\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "id": "d3fa61c2", + "metadata": {}, + "source": [ + "Dette eftertjekkes med sætning 14.7" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e3c6136a", + "metadata": {}, + "outputs": [], + "source": [ + "V = F.diagonalize()[0]\n", + "V.inv()*F*V" + ] + }, + { + "cell_type": "markdown", + "id": "040bed79", + "metadata": {}, + "source": [ + "Som forventet!" + ] + }, + { + "cell_type": "markdown", + "id": "d84216f2", + "metadata": {}, + "source": [ + "### Eksempel 5\n", + "\n", + "Vi betragter den sidste matrix" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6a6ec755", + "metadata": {}, + "outputs": [], + "source": [ + "G = Matrix([[2,0,-4],[0,1,1],[0,-1,1]])\n", + "G" + ] + }, + { + "cell_type": "markdown", + "id": "37dc7767", + "metadata": {}, + "source": [ + "Som er speciel ved, at egenværdierne ikke er reelle (den kan altså ikke diagonaliseres reelt), men stadig at den (i følge SymPy) godt kan diagonaliseres: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c29647bc", + "metadata": {}, + "outputs": [], + "source": [ + "display(G.eigenvals(), G.is_diagonalizable())" + ] + }, + { + "cell_type": "markdown", + "id": "248e91cf", + "metadata": {}, + "source": [ + "Vi finder egenvektorene, og benytter dem til at opskrive en kompleks basis," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "119780da", + "metadata": {}, + "outputs": [], + "source": [ + "G.eigenvects()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4ab7c76c", + "metadata": {}, + "outputs": [], + "source": [ + "v1 = Matrix([1,0,0])\n", + "v2 = Matrix([2-2*I,I,1])\n", + "v3 = Matrix([2+2*I,-I,1])\n", + "V = Matrix.hstack(v1,v2,v3)\n", + "V" + ] + }, + { + "cell_type": "markdown", + "id": "c2661051", + "metadata": {}, + "source": [ + "samt den tilhørende diagonalmatrix:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5a913b0", + "metadata": {}, + "outputs": [], + "source": [ + "Lamb = Matrix.diag([2,1-I,1+I])\n", + "Lamb" + ] + }, + { + "cell_type": "markdown", + "id": "2645d6c7", + "metadata": {}, + "source": [ + "Bemærk at hvis man ikke gider skrive egenvektorerne ind i hånden, som vi lige har gjort, så kan de trækkes ud at `G.eigenvects()` på følgende måde:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "df81f74e", + "metadata": {}, + "outputs": [], + "source": [ + "v1, v2, v3 = tuple([vec[2][0] for vec in G.eigenvects()]) # virker kun når gm=1\n", + "V = Matrix.hstack(v1,v2,v3)\n", + "V" + ] + }, + { + "cell_type": "markdown", + "id": "fff8e36d", + "metadata": {}, + "source": [ + "Vi bemærker at der var altså slet ikke noget farligt ved at det var komplekse egenværdier. Dette ses også tydeligt, da den indbyggede funktion sagtens kan håndtere dette!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ead5ae14", + "metadata": {}, + "outputs": [], + "source": [ + "G.diagonalize()" + ] + }, + { + "cell_type": "markdown", + "id": "3532579a", + "metadata": {}, + "source": [ + "Denne kan også bruges til at opskrive $V$ og $\\Lambda$ direkte: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c744e2f", + "metadata": {}, + "outputs": [], + "source": [ + "V, Lamd = G.diagonalize()\n", + "V, Lamd" + ] + }, + { + "cell_type": "markdown", + "id": "6fea915c", + "metadata": {}, + "source": [ + "## Similære matricer\n", + "\n", + "Til sidst følger et eksempel, hvor vi vil finde om matricerne $A$ og $B$ er similære," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b4c1d040", + "metadata": {}, + "outputs": [], + "source": [ + "A = Matrix([[3,2,1],[1,4,1],[1,2,3]])\n", + "B = Matrix([[6,14,13],[0,2,0],[0,0,2]])\n", + "A, B" + ] + }, + { + "cell_type": "markdown", + "id": "ec6f9ea0", + "metadata": {}, + "source": [ + "Det vides fra sætning 14.5, at de to matricer ikke kan være similære, hvis de ikke har samme karakteristiske polynomium. Dette undersøges hurtigt ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b9b7df7", + "metadata": {}, + "outputs": [], + "source": [ + "A.charpoly() == B.charpoly()" + ] + }, + { + "cell_type": "markdown", + "id": "2007df58", + "metadata": {}, + "source": [ + "De har altså det samme karakteristiske polynomium, så de må altså have samme egenværdier med samme tilhørende algebraiske multiplicitet!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9d567aa1", + "metadata": {}, + "outputs": [], + "source": [ + "A.eigenvals(), B.eigenvals()" + ] + }, + { + "cell_type": "markdown", + "id": "9c6a1ef6", + "metadata": {}, + "source": [ + "Det sidste vi mangler at undersøge er, at de to matricer har samme geometrisk multiplicitet for alle egenværdier (sætning 14.5)," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f8cc2dd5", + "metadata": {}, + "outputs": [], + "source": [ + "A.eigenvects(), B.eigenvects()" + ] + }, + { + "cell_type": "markdown", + "id": "fde2506a", + "metadata": {}, + "source": [ + "Her ses at den geometriske multiplicitet også stemmer overens for alle egenværdierne, hvorved vi kan konkludere at $A$ og $B$ er similære! Hvad vi egentligt har gjort er at vise at både $A$ og $B$ er similære med diagonalmatricen " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c0622b1f", + "metadata": {}, + "outputs": [], + "source": [ + "Lamb = Matrix.diag([2,2,6])\n", + "Lamb" + ] + }, + { + "cell_type": "markdown", + "id": "64e59864", + "metadata": {}, + "source": [ + "Men af sætning 14.3 får vi at $A$ og $B$ dermed også er similære!" + ] + }, + { + "cell_type": "markdown", + "id": "073a2c54", + "metadata": {}, + "source": [ + "Da vi nu ved at de er similære, ved vi fra sætning 14.1, at der findes en regulær matrix $M$ der opfylder $B=M^{-1}\\,A\\,M$. \n", + "\n", + "For at finde $M$ opstiller vi koordinatmatricerne $V$ og $U$ bestående af de lineært uafhængige vektorer for $A$ og $B$ henholdsvist, begge med de to første vektorer tilhørende $E_2$ og den sidste tilhørende $E_6$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c72127b0", + "metadata": {}, + "outputs": [], + "source": [ + "v1 = Matrix([-2,1,0])\n", + "v2 = Matrix([-1,0,1])\n", + "v3 = Matrix([1,1,1])\n", + "V = Matrix.hstack(v1,v2,v3)\n", + "V" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0ab4bd66", + "metadata": {}, + "outputs": [], + "source": [ + "u1 = Matrix([-S(7)/2,1,0])\n", + "u2 = Matrix([-S(13)/4,0,1])\n", + "u3 = Matrix([1,0,0])\n", + "U = Matrix.hstack(u1,u2,u3)\n", + "U" + ] + }, + { + "cell_type": "markdown", + "id": "9ae6a9ce", + "metadata": {}, + "source": [ + "Af sætning 14.7 kan vi altså opskrive\n", + "\n", + "\\begin{equation}\n", + "\\begin{aligned}\n", + "V^{-1}\\,A\\,V= & \\Lambda\\\\\n", + "U^{-1}\\,A\\,U= & \\Lambda,\n", + "\\end{aligned}\n", + "\\end{equation}\n", + "\n", + "hvorved vi kan sætte dem lig hinanden og regne,\n", + "\n", + "\\begin{equation}\n", + "\\begin{aligned}\n", + "V^{-1}\\,A\\,V= & U^{-1}\\,A\\,U\\\\\n", + "\\Leftrightarrow &\\\\\n", + "B = & U\\,V^{-1}\\,A\\,V\\,U^{-1}\\\\\n", + "\\Leftrightarrow &\\\\\n", + "B = & (V\\,U^{-1})^{-1}\\,A\\,(V\\,U^{-1}).\n", + "\\end{aligned}\n", + "\\end{equation}\n", + "\n", + "Matricen vi leder efter opfylder altså netop \n", + "\n", + "\\begin{equation}\n", + "\\begin{aligned}\n", + "M = & V\\,U^{-1}\\\\\n", + "B = & M^{-1}\\,A\\,M\n", + "\\end{aligned}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40e0d8c8", + "metadata": {}, + "outputs": [], + "source": [ + "M=V*U.inv()\n", + "M" + ] + }, + { + "cell_type": "markdown", + "id": "ac2a4579", + "metadata": {}, + "source": [ + "Som eftertjekkes ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0c117da8", + "metadata": {}, + "outputs": [], + "source": [ + "B, M.inv()*A*M" + ] + }, + { + "cell_type": "markdown", + "id": "8258b920", + "metadata": {}, + "source": [ + "Som forventet" + ] + }, + { + "cell_type": "markdown", + "id": "fba9ebef", + "metadata": {}, + "source": [ + "**Fortolkning**: \n", + "\n", + "Hvad betyder det overhovedet at de er similære? Hvis vi opfatter $A$ som en afbildningsmatrix for en lineær afbildning $f:\\mathbb{R}^3\\to \\mathbb{R}^3$ med hensyn til standard basis, kan man forestille sig $M$ som en basisskiftematrix med basisvektorer $(m_1,m_2,m_3)=((1,1,1),(1.5,4.5,3.5),(2.25,3.25,4.25))$. Altså må $B$ være den samme afbildningsmatrice $_mF_m$ for $f$ med den nye $m$-basis!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "81c2fd3b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 ('mat1-pilot': venv)", + "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.6" + }, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Demos/Demo-E-Uge-10-StoreDag.ipynb b/Demos/Demo-E-Uge-10-StoreDag.ipynb new file mode 100644 index 0000000..1d6e779 --- /dev/null +++ b/Demos/Demo-E-Uge-10-StoreDag.ipynb @@ -0,0 +1,660 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "14b14fd2", + "metadata": {}, + "source": [ + "# Egenværdier og egenvektorer\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "aad4b143", + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "3e5bd455", + "metadata": {}, + "source": [ + "I denne SymPy demo undersøger vi en matrix og hvordan vi med SymPy kan lave operationer på den i forbindelse med egenværdier og egenvektorer. Dette foregår først med \"simuleret håndregning\", og viser til sidst de direkte kommandoer. Afbildningsmatricen vi betragter er\n", + "\n", + "\\begin{equation}\n", + "{}_eF_e = \n", + "\\begin{bmatrix}\n", + "6&3&12\\\\4&-5&4\\\\-4&-1&-10\n", + "\\end{bmatrix}\n", + "\\end{equation}\n", + "\n", + "for den lineære funktion $f:\\mathbb{R}^3\\to \\mathbb{R}^3$ med hensyn til standard basis." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d8d9527e", + "metadata": {}, + "outputs": [], + "source": [ + "eFe = Matrix([[6,3,12],[4,-5,4],[-4,-1,-10]])" + ] + }, + { + "cell_type": "markdown", + "id": "7962de0a", + "metadata": {}, + "source": [ + "## At finde egenværdier\n", + "\n", + "Vi opstiller først den karakteristiske matrix $K(\\lambda)$, " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7c9a4a14", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}6 - \\lambda & 3 & 12\\\\4 & - \\lambda - 5 & 4\\\\-4 & -1 & - \\lambda - 10\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡6 - \\lambda 3 12 ⎤\n", + "⎢ ⎥\n", + "⎢ 4 -\\lambda - 5 4 ⎥\n", + "⎢ ⎥\n", + "⎣ -4 -1 -\\lambda - 10⎦" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def K(l):\n", + " return eFe - l * eye(3)\n", + "\n", + "lamb = symbols('\\lambda')\n", + "K(lamb)" + ] + }, + { + "cell_type": "markdown", + "id": "4475587b", + "metadata": {}, + "source": [ + "Det karakteristiske polynomium fåes nu ved" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "493dbbc2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJUAAAAVCAYAAABPEqyXAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAFI0lEQVRoBe2a7VEUQRCGT4sAECMQM/AjAiED0AjQDLT4xz9LM1AiQMgAjMCPDCQDlAzwedbpqd29Oe6427vjVrpqmN7e2Znu3ne6e/a4d3V1NVgkHRwcbLLeFu03Tf457T3yn/S9IGxZx5D9ZIw2SnvIL/+x/f67tgTzPrDmOQ7+7Nr0b+m+0h543RP6gF1vwhb4T/A/aI9D1uf+/hKMe8+aR7V1H8IbtfpErwGS0TjIjbSJ7EkI+twvPFLh2Haa28HBOr1PZJT63ieDbmLLvUXXVKEc4DLtvaIdwX8MeR977HPT7ND/F+mvM1DhMIvTQ0EBv2s/jtIzx4w7hV8asFjbmidoA6ZYVCd9b2qjKU8bn/L8Ugt11h+rC2Mia1ygs5vA+vCcPhPX9YOIcq+PkZ950RmonCwt9gf2I/w7ZeOIcRpqEavT26lx3OMz3U/6uvYn+ArUSR8PDurTcKaLIdOBE9nIWE9+AnYXfimASvq6Eaxbn9H094OSPsj0hSfxE/oBvbYq24bPvoDXX/kgksa6ccw6J50W6kyo41TotQu1ifvrtD80DQsKZ2vwoklnb6BPjpLwAtt6qB69sl7cv9bGGMg4AfWO3hdy6XWSxZCJe57bohV9Om4SnnNtQS0IjkaNT/P7fipAOQ4+bM2+SOMEWpv2EOwr7BRUaRUVUDkL8AYlJd0xGfXwnpJU/gtt0aSOdV1ifYHli1wPQasfaaPjeE5AOcYd/cQGb+TW9mlIPUbpMs18pWcsWbS7Td8Q1H1hStxuD6pfdw4qHGheFSSN8FhbVOX3GffWBq+CC683WDteUulFXyR9i9FzAhvdyW4W+2h+ZtAvt5XUt+SL2HTelwSZhw7r4PChcmsxN9JgzT9zID9sChojVsORXLsbSjtiDmqMnlK9aA7YKIzy25lkxBlF19m4Uh9y8UMdHKPsrfzE2BMbg4zyljJGYKOXIKtSZ+eRismlCrH0U9UB1QyL+aMTSsCJmu86Z6+KjZN4MjZWIwC0Hsy+ADxmm+oXEXojlFEsB4p5gSrC6KgUiA63giwuBzgpQru8gArnRugvKbsqNpZ0n0YW0VsfGaX0kRHKcseN+SvJB2swItAjdEYi/DjyNJGRWR+c5vN4aVj0G4eFanFs/blxfJq3Mz1djzlNgY9gKz3pdZw1Q1U30BdBlXSZh41Gvwxw+KBIPaVN+hN9JvouGJMV+tgghVu5PKjqTNYy+1gDhy6ebgWZ/jiEPxNUIu4pbWZiLhHr5C/SZIZGFw8FkvjmXZd61ldP8zb0Q6be0hCo5mxjQ49/KlTg96X5SSJ/+oh7XfT6gOZUpcASsvCFvnEjZuJZ6yyj1i/aVmfpj0lNG6e06ms014LVmuUlbdVIW86SDVn3ntmY7UpMpLG2vIqSCPWHABs6fPkA9wSd73ujE1AlZ5ua3sDXU53hXCXcabeO1IvmCSZ24yDxpqDGLwLIBdrK2XgDp5thnhXGm8VMsUYzA4W9GalE+vFsZlCxgC/AbzFGKNGeKV2L4GJYzwOXx+icdj2hcxubY8VtrHs3iu2IPvkeNnqa+02fAwC8IDHTVAeaNNj6zd/58kZUzrW1lp8Vzmf+7Y9JTHkuEkdM18iEXCV9UY9dMN+4JQw6Rf0UTso/jIaKjFmqjcmHU9dUPK//JQOAdppNfBeCIL83eO/pj0uahflz2tB/5TLOqL1Pq2/I7LeZQcXEdzRnD/AS3ZhTg2rO6g1NP3P6G5rxTjAPDxg5bCtBfwF09DMDfkJBYAAAAABJRU5ErkJggg==", + "text/latex": [ + "$\\displaystyle - \\lambda^{3} - 9 \\lambda^{2} + 108$" + ], + "text/plain": [ + " 3 2 \n", + "- \\lambda - 9⋅\\lambda + 108" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "karakpol = K(lamb).det()\n", + "karakpol" + ] + }, + { + "cell_type": "markdown", + "id": "7088c9b3", + "metadata": {}, + "source": [ + "Man kan også benytte den indbyggede metode til at komme frem til dette resultat. Her skal det dog noteres at fortegnet er anderledes til forhold af den tidligere præsenterede metode. Dette er dog ikke et problem, da vi alligevel bare er interesserede i rødderne af det karakteristiske polynomium." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "69d19b80", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAAaCAYAAABb/4wHAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAO4ElEQVR4Ae2c/3UUNxDHD54LcJwKAh2AqSCkgxBXYNIBefwF//mFDgIVmNABoQJMOiCpIOY6IN+PTqOn1Wp3tXu75zujeU+nX6PRzGhmpNWufefr16+rCoengZcvX94T14+VrpUoP1K6UPvfym8FSJZjCfLcC4OMwLna15ti/a0aqBoYq4G7YwdU/Hk0oMD1VImgPRV+18D7ovFO6ZXKH5U+TCW2p+N+l2y/+fREPLLBfdpTXitbVQN7pQH5zR85hmrQz2ll4TYtxs+a4qHyv7aY6kJjL6Px36tMULxNkG6MbHT3pLcHt0nIKkvVwEIa4ND0PqVdg36qkYXrWgR3ZaH8122m0vi/SRENNhKC4m0CdHR1mwSqslQN7EoDig//aK4/lT+L57xT7/RjdSxf1gKw87IQr+eYzS/omWhdqsw1z60Fycem9rPy+7dWyCpY1UCiAdk7BzrebfFei0Mj77QI6DzZ0wZQP1XiOrQRW1T/rHZuFty7sCMVGIQz8chsBN6pbMAkwGyBakNu/O/SvIo+OnijhB7+Up175NnA83+q/KcuoupD3/CwUnlwfuG8UmKRWZ8VdcbeBGju+A7xRDxkX7oKb5SMyKIxrI27FqN+k+B5+VM8BEdK+RGOPXX9pz42KR61ccwAqqMHe1FNO3XWcfK1n6dZbD9MOgU0T+wrb1Xf6sl1Cg9Tx4hXTr68DzsUnolHBHjsp/GxhmT4pPRQ7StfbgR82gX4JTbh4kk46WsAi8hLMl4MNoKN6kxK3z8quwlUvjFYmlfRN1kbethWYNFF+Wvlv/XRUj/O/0WJgN6La3SEZ+tHIIqvfQxlsdzzi87+UNltOp4fXizDTyPYwYjaimUULvaH7p6ovGb8rsHzi+PgfJyo0Pd3OX7Uhi5wTnd48mNp+0nloAuV0Vcj8KjOZsJTW3zwUlM5aGyxbsup5jE1F5//sS6T+c1TXq5VvHLyJc4V+dZynJRRFp/Y/kp5aitsXsST10ocMj4qb62D2swenL3ehZiHTmfSIAwVBT3wxG3MTeVL84pjLwFPRfT9EGHpGPlYPPBbwCIqfVEi8BiYTghIo0G0Hitl5ysgRjA80fjwlKEyG8+VkjPYlIb6e2U0fOER8HlkJWBi4LzIpW2n4OcmuOF4l12Tqx8dsj7B+RirNupBFx6PjSCFczU8TxvH1KP5pq5n0XSax74+m/xkUjTRzEjim1P+QQR8L/qJcntydE3i/1gFfIKAT5nYHGzOIfkftWN/+OMvNMVBn3of4MAAj9j7DnvHqxRvAdp4G9IhAYLg0dK3X0Q2pnBqVBkHZHHfKk0BDIc0BeAx5sVoYGhsJl10O2WEgMYR3MHhRIxRo0OcFdn3FXg6RO4U+KQ21gVXPp3XfOngCfVe3U6glxsC/zz9Y3cVltMA16Spf7EJ2MbFocvKXVwQd9zNxZigz24DHMIC7yOvBOViB9Eic3pC141HOtUNWMDnwntGUhkH7LxjtkFz55rbAnouEP/n58s+fRTIyEkYvZFb4jPOfbZB+M3pwpyWfoBNgJfS7yMd0o4zE7C3ggLdbkXfD0aWgzrlzyH0rmmk9q46hx+erPmCj/I15QG+uNJyfng0gBh326nkgkY/GTsMp7Hw0lPtPFISqGjnXtPueDEQDNq1K8cJHinRzmOzcwrl9LNrwSTfnnPa7Qp86s5Cg1fDEB0CFDxAG+C0NfjiTONMJhRMwInl4g7WTrpcQ7xTPQfIOjZY8VKGoI4OGmNVZ5GHFjrHx6xt8KUETdtoY/qsH8CadkGfjN91DdrHdukB+xoCpyfhcqeMrWA7XNVh89gjm0CXDal7FHTqdhQVIYsn1hDfwU/ZzAn2+IOLB8obIHxwwQOwfZ7W3AahHJ9nLO3nSugEHwcf30UHvM8C50wJoMzL8NYmo7aUN6dXaLiR+lGZtcGP0TEvP8MLT5WL+NG4fQF0+8QzE5f7+CNWEEeOj/qw6ANJGcpygU91Z5DKIcLJkgAajF117pi4YuBFZAC1sVjg047iMR5ONJxSUTrjWNgPSuHln9oIeuENtfo6QXhZXhmgPmgToNOXaRgYVwfBQMCPQX0YCPwhK7trwFWZDauEP3i7jukWlE0/6D7MWTBu1yjYBGuYAjoHgn1sqo3fQ5GxwXRH5cS3rzv6aQ668LaD/KyvBVTyuWAW3YpP1hbfif3S3k01grBwCcD0/aqyBXnaPqvOXTp+jw9yQAKPgyMvIN31hHJ8jU0QHfJkbO1sjvDQOAiov4u3x9DydDTMPRUzp+GHoK++En7YpN3BFGI5UD/6zvlBDt3aiCcWwK2tMxcuemAMhy3shvjVZ29Gy2LPvSNriXICYGx47L4ov6HsCL+lCJhQilAaRSZnQdzpHbrgewwWlc+/Ak2V2fHZ4XkUTk9AY3iFdm7hMCqCNk8rbGR9wKLCCzum41k5gS172kkIERCCXElfV9UWCl3tc9DntPavdMG6mqOjF1vXPrkPRcauNRrbbk8/K+kKB0ZHHIIsYBAc5/oaZmvdipdj8YbvEDDjdaTsgo/yGAjk4VRPB+P8WDYC+kkAmwF9sW3bxomPxRsK7fASQP19vEEX3a6UY4sf/UACbJBDfQTpIn78+M5MtFxM60SYp4MrXfuCEn1aeYi604WQTnJBH2W53XWIysR+Jo+VHi8MRvApQ5dgzKNgGvSLeJU8LDq0beFV3ID6MFwqZ0rM0wecDtgQ45P3WaG+jjXOnLBvDtcnmuA7Z1PORsMGN8RfCV0LLimuczbNkTPc3tOIxrDJ/2B8KiewoWsSgS2st8oBNGYpGaHLEyN5KRBot9Vv3/o6/YoZd+WhubAhTs6mb06bdpp9ozKHkHUp8ymexs6lW+ydAByfjJmOYNnwR+FgW3xdFQdxcAHkxwev1I+9wB91k19FB/gqkM5HcEvXp5Q34oSN5QuWCybwUMpP1oaNyC5yycCtiONdZWRvxWn0qpSzm2CbuaC/C/4DA9FkGACAI+AQMWBMV3HDyLLRzinDSJmxWb2Vo0wljPG5Ek8gGK5z4hZyu4G5zfHbvVGL6MIvAf9H38wC4xypg/ju8ky0szTUTsDpctjBCTQe+Rq01QbfQMth1LekjPBSegJyDM7xgw6UIIVdpGBtpgt0w0YZQGN5EuXUzzViK6gGxIGCaMypW4JkfOJeiT6yMIedkI2jFi4dnh/GcI2z9sjIR1+Dtpq40889QUA73Qha84leizebUzk2Tn+gY31q6+LHHQYjPKHuHjQ/fHMwIKF7DoGtoK92DgzpUxkMW+y5PqJ2A2ALH09tzsAdVeMEESNNLBttFNcFhtPVb+0461Px6IKkysGADGGbXHTZfAj4nDydnrw+MPBGUN1mnh2NRZbWifWWyZiqkiCGU6ZgToc+sMPsiUx9nEqxf8NP6fTW59St8akJc8F9pf4QsHtw4dfsNvbrrifr1mYn2rShMw5/zGt+TD7IG2M8cFhjY2VzTvXfxQ9+7vjPjDG6Llc//LnNo9HRX+l9io6GvlHZgrwdAqPuoBeuwXPvCExn60WCvibNGX2DwbSiMba7o/zYOByq+h8rBSNLx/fVI9qcIhq0oevHEmgHQfg4JXxgQK2A1kOATcUUn0UTXYIk1xLpVQPGxGLm3mtkae2yEb40H0b5g8pr5laOrOi2ceJW+0HKiEyFgB3ZE048xF1PRPoh8PBklTtsoLtg68JJA1RMN5SFN0q3pXQ1QcqjO40zsWiw9vgufkGTW38KEbjrUHCiNmyjcWBSP3ITO9JATtC1Oehn7FslIKZJvYs3aKMfC5z4r5VVdDRTfpANsLnSMZte/yv+bXNrtG9bEV34vlaODpCdcio30+CDuXb6TvgRXN/d5O4XpQDWuakN/7JALEQMMMbifx83+jLz2FxpN9cZBHfGB1AdJ4qFsfFjeIX2L6KFAmOANlc1wcnizo4yQRg6lx39ueaPajzNddCm+ZGZ9xnnKS++jvyLGJXobgusf3plR/DjRZPdpa5UPmQZYx2ZXbfsTzISOHBKCxjIjb3ypHYeEeE0xufCZsuuS3UCJE+7zt59P1+z5N51BXLqH6XbErrCWWsC/CL4t9qQC9u/UgK4bjDfRHaCbgD1ER/eKg8BVmXoIXfqP+hopf7UF8G1NmzKvsoZw5uTAdpKlLlCc+DrOX7AI9CyQbMuKb8bAsv/EqNMf3HZzQz/SugZ/mwtXF/0gyzIsb7z4sULKhAit4DIaZid2yZStRuERxAEUCSGws74rxLAixIMA6MkaGE04LBgl2pPT97wYfNCDwfjawD42YpXPx7azA9AL3xpoH7kZzeHVwAec/djK+HimA0DdyM6foQLTRYm/lopYENPFYJA47RhCGpHbwRS++zNumbJPf1t7vSxIQDnAZDFHNU1qH6jMjomtvgR/+gfYC2Rkw0NJ8MWwrqpTB/6wM5458NHCBdqDxug6ivVzd7iDTOnNwtQvO+CZgvUPlq3GlNCF1neKHFowRcJLPCAfLQRRINcKpsdIDfvJ3LyoD/8jv4Aqj9TpfWP0NQOPpsk/HI9E2+IY3hj/dDTSjTi9erix2RnDBt5I1ZBZ2nQnPAG32yyJ0rELMoGpyrAJ2tCO5uUxU9VN6A2YvSJ8ifhH65ZZ82HNSDF4awEyFFGIHz+RoGrm0YwHJ5xeQzxxKYyOegvz+G3PYNfnzHXiUUKW4pu0eQVaWca0DrzpMhG+/ruzmY94ImkKN6U29MMkvCZ5qiA78XnCaj46cCP2VXGSYFUYT818Eg2t8T6LEV3P7X4DXIluzmW2BxU3buJo29QB1NEPtMg9/WMFIjyeKydAmwcH5Raj19TiM05RnLt3dPHnPIdMi3vtFyXzApL0Z2VyUpsDg0Qu9xXSxCrJ/0ylV4IjZdR3DmeKp9yyl9pHHefPKJzlVKhaqBUA09lM69KkUfgLUV3BAsVdQca4JAZDpr1Tn8HGo+nkPPyqPVB+cO4vZarBqoGqgbm1oDiDF8d8clvODTUoD+3lgvoaQE46XOXGnbfgmEVpWqgaqBqoFgDii/2dWLjPWK93ilW4XyIWgyuh/jHWnyOVaFqoGqgamAJDXCobP117v/vDPenb/OLwwAAAABJRU5ErkJggg==", + "text/latex": [ + "$\\displaystyle \\operatorname{PurePoly}{\\left( \\lambda^{3} + 9 \\lambda^{2} - 108, \\lambda, domain=\\mathbb{Z} \\right)}$" + ], + "text/plain": [ + "PurePoly(lambda**3 + 9*lambda**2 - 108, lambda, domain='ZZ')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eFe.charpoly()" + ] + }, + { + "cell_type": "markdown", + "id": "f1080c15", + "metadata": {}, + "source": [ + "Hvormed egenværdierne kan findes ved" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e17ad7aa", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAH4AAAAVCAYAAACAEFoRAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEm0lEQVRoBe2Z61UUMRSABw4FLNqBdgBYgdoBaAVgB3r8xz+PdoBWoNgB2AHSAXQg2AF+35iM2ezOi51ZV+Sek00mubk3ua/cZNdubm6KHA4PDyf07dhP+zQfv/9efQmgt0escotyTvsyX/F63gHSa/q+hf6zfPz++9+QQFC2Cn9P+4SiM1ewlno8g7uMHFM2af+ssAZuQPt9RvIzfedZ38Kf0NTq3wRCRrArv0fk9SrwUsjyVuijRUxo69Hqa5t2rb4YOwHnJ/UedQkbsRHqJ9SXTUQy/F6f0FUYLlThlwKh9tvymDIYBF5H1M8jUdoa3Hf7KIMpBFoq2j1FxRe0dSI9bY/yNa5h0Rpa8vpE0Yg1ZmXaBjqV66lgvWotp6GC9e5U6G5k5gwaYDkquVKE9OCr9+sZrmNIOIDYAfRT4cY9vh2SETxKz6V2b59vS3tpig9CMTR9TBdLv95XeWU6tmD7GfMvoK1hpaBCJvR38ZR0XlNbj9KgLCVAv2rHvlWq81A/5tq0UK11WQJRwVsN/CZDbRYe8tpM6dEXvf8o7V+V9jIV73lk/qDXv6T8oHiuHwfB0WwHcC/AOqWeCuP5TMarRCYbk3/BuF46CkDbaFMeNbSnIlwdQ/A67atuft/+XPF6wVgeGT1sh03GTLugfU3Zp7QmQOBIwxCtEfUG5qt051f8exNpmBDoq3STZA2r03V40X01LCkO6WQP4od1dcbDXIG8oAwemsLG5GfozT3gC/2fEhzx5gI4GqVXze25CO2dJnVfmf+hHbU/BnR9LPlAMdqYeHmDiCG/liA4i+6rlnYY0KnMa6q1bPChwg1L1l49YjbK5x+gX2/zYce6K0gvDanzsvfvEDMr1ovn8k6ZQU8h9QbmadAeNXVHQG+aTRPgo4G5Vo+y1neRgNtE8tZj0Hbf5iA6mLeMdyreznd8eGZ6Fz2jzAg39N3K05xLgXwxQ9fOABreKABvDesB9Ri3hwK6dXmDod7Qb2k9ysAZE1S4Mi7fUNblxMINUTFZ8nFgDNCbJw2E50WDBvRuQ+zL8PaYuvJ02o8s3Sh0wjJqGdab9teJ0BhIrEsZ+BT/lHYZVUvFJ8wMy6X1Jn1DNQ2184RtFDEitIb5vguBpnt5Qp0ncwriKtJjfFGFGcliaI9krT2+hMH39pts51+Tzamr9EbnqQsiIlwF4zXM9+tSEdQK3IRyvwv5gH8NrhGq8dhhXCMzmZOnRpfCM/rKBI/aNXizaKWZEsjauWEV0NO4pP2KtoZRC4yXawCh7xoeBqJm7I08GK8M3TlLU7zM2KCvdCo+KsIFG37SBFDUuQCeVuuR0OWa5B8TKt/zPYeKX0JzQtvSJsCcVsGcjxSNKe5LHHl3+k+AeX32VYAfn5zNHQQTSOXifwP5ralEyH/yf+fM7neZPOgfJjnTVfxmz3qo0aG34ldxP+ma2NOMXtdThP+8bS5w55Rep9Nc8TMvPHUT71I/Cp+wH/d+V8H9TRl1rviZF567KolsX/6lOsprXsZn6Z/BqGdeZKfOeFcFokmJWaqJl/+d/+2HB5ZxD30lEPTo24z6nNHjL3h/0vhF/xl3AAAAAElFTkSuQmCC", + "text/latex": [ + "$\\displaystyle \\left\\{ -6 : 2, \\ 3 : 1\\right\\}$" + ], + "text/plain": [ + "{-6: 2, 3: 1}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "roots(karakpol)" + ] + }, + { + "cell_type": "markdown", + "id": "152fef45", + "metadata": {}, + "source": [ + "I SymPy bliver vi nødt til at bede om rødderne i stedet for at løse ligningen til 0, da $\\text{solve}$ ikke her fanger, at $-6$ har algebraisk multiplicitet 2! Dette kan også aflæses ved at bede om faktoriseringen," + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "aea185f0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJ4AAAAaCAYAAABGpOW1AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAFb0lEQVR4Ae2b7VHcMBCGD4YCSEqADvioANIBkAqADmDyj7/QAaECAh0QOgh0EDpIch2Q91G0HlnIPvk43cU33hkhWZK1u69Wu5J8rLy+vo4GGhAogcDFxcW6xv3ix97w+bHqx2slGA5jDgh4BC5lZKeGhsrXKj8pba5a5ZAPCBRA4ETGth+Me6nyhuq2BsMLUBmKM0cAb/cjNerKsMdLwTLUlUBAng6Pd6B8PqFWjGxjWUKfuY05Cz1mMcbcFJ7AqIsu6rul4Q6Uthm2eKgVwzPxgekyEPsT9JmKlgwLMMjCQ3rjePB22yqPebFoqBUTLHxX+TnMQlIdR+0b6lQ+DNsWUZYMgGMnMGRzYKn+eyiPnjG8sfKvYf2ksvr3BotQF8mNwYR0q7pnq1C5FQ+1g+O5coetfy5neGLA5D0qd67VBA1z3+eP6q5UfmOcYd+SZS9HfPTHUO6UDtV+H/LXM1cCe8rd6g3bUmU/fi+wMPklMwaD/hiNW3zKed5Svmn9yPWcxEP1jMEVSji3GOD5qv6UIlYKTBtJgjFxTOpJY6f5NMCfoz/GZmSezi5ArZ4cvWJPELbH5bljIV32ld6DK0aGdzMc0Aln8kIhoiY8MEiuU8gtgfO4pOEdiUFOOELodfUNJ11VcyVCB4ug8mCA0ySB1wv9mIgcWgQWyJYrX00HPxfsy2vzp/pPpFpnPaiOfm/wUP0HpZU48X4RwxMjjCi1MuBZI/VlRTHJtr+qtc/jARmUAKla3SrbQmBhpAj9jlINYZ0fpzdYeNmZC/axzEsuZeFhg5X6ZMaqqCbRmLXkrJgzKYrn66Jsy5DTN0kGwgPh8VTl2qoPRkU/9Gxqt659xGJHwr9Id7zeZ6VfSuzr7lTXNK+5eGiYQh5P4yL4TxhkknmV9+xJMlk1dwNoJU5prHjCb/LW3Y+Afhu+3Jb1EQsL0TvCg8MFhz8wwfAsEsQ65+Lh3isSajUygv+OJWt5tr4LC7fIJlCflQCZ651bpSeVm4BG5hzD6xUW0teMjkUYe/Nv0vkm6KPHinLxcC+s+UEe9WQMq5FaClwxPLe0f1TbuKW9avL83bFdlVxpoHDj2L7/rOWt5LGC+NwroQOrnP1frA97mhzMimGBrJKLaBF+iKcagi/tqcXMApt0d5ral3IyJSrhxeOQm4uHXh2NMDwAbbxro1MpEm88Bka353m4fZXKKbBclxLyakz2MiPlscETaplUUu0uT8/ZBqW+E0m8O2PBoHoviZXq8dR8WbiayDzooP4cKqiJF1rQK+npO+FRKtTidlu9gZRjsh+U3A8DUVhlJnfiSVF9Zk3ujkkytMocMaUvek6ivmGBPnizNixS3jAXD4dXKcNDMFZwkrzRES45NYZeZlF3emPJYqE1lJmQAsVhhTpWeGoCaAupb1ggO/OQmj8iIx7xPXgwfpl7PI2LMe3CICYJTdjCw+Dpagr4ZyYqGT7isWb4zCcdvG9FkoVQxSpmcWCYMTEJ4aKJ2+25b1iMpC+Rh7tNtj6OVAYLotHxv5o3f3PxcC+W8nicCAmlKWKSmcx4z2R9ad9Xe2rFWZ+Z5uLF6Y17q2tLesb4uamPT3bGmwVUM1ZriPJeYWGyS2/uH0cBHvygg+/TTfOWi4djUezXKRKQe51Jp18nRN/+SDcWxYPy2sfyJj0WgYV4TnW4aNKhrb4rHoxVyuMxtp1QKS8b4ZWrMJSh3CKwYHuQ2iJkiNu5S1c8yv0sCtG1EghFhNWcTXhnbRfxgl/dhGQXinJlWEYs0H1aPEp6POTiktI+h/G8DIQ+0xx+lhEL5nMqPIrt8czC/IrgHzw6XWTa+/9TLh34jsu1y1QefJmwYF7eg8df6UJQbS2Z1f4AAAAASUVORK5CYII=", + "text/latex": [ + "$\\displaystyle - \\left(\\lambda - 3\\right) \\left(\\lambda + 6\\right)^{2}$" + ], + "text/plain": [ + " 2\n", + "-(\\lambda - 3)⋅(\\lambda + 6) " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "factor(karakpol)" + ] + }, + { + "cell_type": "markdown", + "id": "0637fc87", + "metadata": {}, + "source": [ + "## At finde egenvektorene\n", + "\n", + "For at finde egenvektorene tilhørende egenværdien $-6$, skal vi finde samtlige løsninger til $K(-6)\\,x=\\mathbf{0}$, " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7b737023", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}12 & 3 & 12\\\\4 & 1 & 4\\\\-4 & -1 & -4\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡12 3 12⎤\n", + "⎢ ⎥\n", + "⎢4 1 4 ⎥\n", + "⎢ ⎥\n", + "⎣-4 -1 -4⎦" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "K(-6)" + ] + }, + { + "cell_type": "markdown", + "id": "eec926fd", + "metadata": {}, + "source": [ + "Løsningen kan findes ved brug af SymPy ved" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "eecac6d2", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}- \\frac{\\tau_{0}}{4} - \\tau_{1}\\\\\\tau_{0}\\\\\\tau_{1}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\tau_{0}\\\\\\tau_{1}\\end{matrix}\\right]\\right)$" + ], + "text/plain": [ + "⎛⎡ τ₀ ⎤ ⎞\n", + "⎜⎢- ── - τ₁⎥ ⎟\n", + "⎜⎢ 4 ⎥ ⎡τ₀⎤⎟\n", + "⎜⎢ ⎥, ⎢ ⎥⎟\n", + "⎜⎢ τ₀ ⎥ ⎣τ₁⎦⎟\n", + "⎜⎢ ⎥ ⎟\n", + "⎝⎣ τ₁ ⎦ ⎠" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "K(-6).gauss_jordan_solve(Matrix([0,0,0]))" + ] + }, + { + "cell_type": "markdown", + "id": "3447ecf9", + "metadata": {}, + "source": [ + "Vi kan altså aflæse at egenrummet tilhørende egenværdien $-6$ er\n", + "\n", + "\\begin{equation}\n", + "E_{-6}=\\text{span}\\{\\left(-\\frac{1}{4},1,0\\right),(-1,0,1)\\}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "95ac181d", + "metadata": {}, + "source": [ + "Her ser vi også at den geometriske, ligesom den algebraiske, multiplicitet er på to for $-6$." + ] + }, + { + "cell_type": "markdown", + "id": "91125f65", + "metadata": {}, + "source": [ + "Egenvektorene hørende til egenværdien 3 findes igen ved at løse $K(3)\\,x=\\mathbf{0}$, som her bare gøres ved at finde kernen til afbildningen tilsvarende til $K(3)$ (Dette havde også virket for $K(-6)$)." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3d84da31", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEYAAABLCAYAAADNsPFaAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADkElEQVR4Ae2c0W3dIBSGnarPVdNKHeCOkLQb3GyQrJBs0KhP976mGyQdIdkg6QZJN0gH6ENVdYL+vwsIMMfXwcbmSgcJAb85GD4dwFxb92Cz2Rw1TfOEmAp32+32LHUBepZdqq0xGvrxDPtVqg1cO0jp1HbZvfYMvyLPm/jhp18Q8rl2QnMvlq8SFifQThO6L/Xa+WCuQXEICL9x5nPt4nayyujzTWwIjVIvmF12Ppi4/SrKGACnyYXpzFukLF9BfzBakaRqMBg8QVwitWAa5OkJ90jPEO+KUEGjr0o1PFG752jn3MCwTVpP+WKFEmntYH5g0H9MbMcPSCwXD7VPJXrHoU/B855rX586X7vHBOMFlDUEbrMXyHd2o6DyyELVHmPHBgh8mCSUT4icXo+IRcO+gCEMxgaQuCs9IS26KxUFg85zu/2OyHRo4IBbCCkDXOMxhQvwLdJDk09VHaWVBsMBHOf2EIPmFGqQxqA4lTi1GIs8y9S++PJwy2nzEo+DyfhQ1GPGd699hnkAGHqeHz6agn3Y869Nkq8dzGU8SkDi4ksP4pYdA4urZ5erBoOB3yCuEf2HuRVGewKtmLeQZtVg2EEDoCgE3icOtS++cX9nKysYAbWCUTACAUFWj1EwAgFBVo9RMAIBQVaPUTACAUGu/khg+42jAX+buUU8Rr7Y4dHer2owAMBT9DfE34j8qWGFOEuoHQw9o/3aApA+I9/+ojcHGV18BcoKRsEIBARZPUbBCAQEueiuZLbbSV+4CeOYXCaYN6ZVmw69ia1v046deRDLfuHWaXC48GF41aCms+Ma89dcsmlQs6dg69u0p+rsl35l3tHZ6eIrENwnMO/NGN4JY5lULrr4TtFTrFM8ODKs/yftVw787JYfKBb7eGgfwCS/TDeQiiX7NJWKQUg1rGBSVKApGAUjEBBk9RgFIxAQZPUYBSMQEGT1GAUjEBDkao4EOPccoY+zvVATeDh5UTCAsdgLNUdAyCwNZrEXagIPJ+vi61CEGQUT8nAlBeNQhBkFE/JwJQXjUIQZBRPycCUF41CEGQUT8nAlBeNQhJmawMz6Qi3E0C0teiRgd3BeWuSFWhdFqNQAZpEXaiGGbqmmqdTt3YKKghHgKxgFIxAQZPUYAYy/Kz1j64yriX8Q6FXMtfOayM+iz+IfBPa1usuOYPgRjvvXsKixvv/Fy7WLbjG6mPqjvyGN9tr9AzJ+170dIVFEAAAAAElFTkSuQmCC", + "text/latex": [ + "$\\displaystyle \\left[ \\left[\\begin{matrix}-3\\\\-1\\\\1\\end{matrix}\\right]\\right]$" + ], + "text/plain": [ + "⎡⎡-3⎤⎤\n", + "⎢⎢ ⎥⎥\n", + "⎢⎢-1⎥⎥\n", + "⎢⎢ ⎥⎥\n", + "⎣⎣1 ⎦⎦" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "K(3).nullspace()" + ] + }, + { + "cell_type": "markdown", + "id": "15a5515d", + "metadata": {}, + "source": [ + "Altså fåes at $E_3=\\text{span}\\{(-3,-1,1)\\}$, samt at den geometriske multiplicitet er lig med den algebraiske multiplicitet på en.\n", + "\n", + "Hvis den sidste metode stadig ikke var hurtig nok for dig, så frygt ej, for i det følgende kommer de direkte kommandoer!" + ] + }, + { + "cell_type": "markdown", + "id": "abef2d84", + "metadata": {}, + "source": [ + "## Egenværdier og egenvektorer med stærke kommandoer\n", + "\n", + "De følgende er *meget* brugbare!" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c713b553", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAH4AAAAVCAYAAACAEFoRAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEm0lEQVRoBe2Z61UUMRSABw4FLNqBdgBYgdoBaAVgB3r8xz+PdoBWoNgB2AHSAXQg2AF+35iM2ezOi51ZV+Sek00mubk3ua/cZNdubm6KHA4PDyf07dhP+zQfv/9efQmgt0escotyTvsyX/F63gHSa/q+hf6zfPz++9+QQFC2Cn9P+4SiM1ewlno8g7uMHFM2af+ssAZuQPt9RvIzfedZ38Kf0NTq3wRCRrArv0fk9SrwUsjyVuijRUxo69Hqa5t2rb4YOwHnJ/UedQkbsRHqJ9SXTUQy/F6f0FUYLlThlwKh9tvymDIYBF5H1M8jUdoa3Hf7KIMpBFoq2j1FxRe0dSI9bY/yNa5h0Rpa8vpE0Yg1ZmXaBjqV66lgvWotp6GC9e5U6G5k5gwaYDkquVKE9OCr9+sZrmNIOIDYAfRT4cY9vh2SETxKz6V2b59vS3tpig9CMTR9TBdLv95XeWU6tmD7GfMvoK1hpaBCJvR38ZR0XlNbj9KgLCVAv2rHvlWq81A/5tq0UK11WQJRwVsN/CZDbRYe8tpM6dEXvf8o7V+V9jIV73lk/qDXv6T8oHiuHwfB0WwHcC/AOqWeCuP5TMarRCYbk3/BuF46CkDbaFMeNbSnIlwdQ/A67atuft/+XPF6wVgeGT1sh03GTLugfU3Zp7QmQOBIwxCtEfUG5qt051f8exNpmBDoq3STZA2r03V40X01LCkO6WQP4od1dcbDXIG8oAwemsLG5GfozT3gC/2fEhzx5gI4GqVXze25CO2dJnVfmf+hHbU/BnR9LPlAMdqYeHmDiCG/liA4i+6rlnYY0KnMa6q1bPChwg1L1l49YjbK5x+gX2/zYce6K0gvDanzsvfvEDMr1ovn8k6ZQU8h9QbmadAeNXVHQG+aTRPgo4G5Vo+y1neRgNtE8tZj0Hbf5iA6mLeMdyreznd8eGZ6Fz2jzAg39N3K05xLgXwxQ9fOABreKABvDesB9Ri3hwK6dXmDod7Qb2k9ysAZE1S4Mi7fUNblxMINUTFZ8nFgDNCbJw2E50WDBvRuQ+zL8PaYuvJ02o8s3Sh0wjJqGdab9teJ0BhIrEsZ+BT/lHYZVUvFJ8wMy6X1Jn1DNQ2184RtFDEitIb5vguBpnt5Qp0ncwriKtJjfFGFGcliaI9krT2+hMH39pts51+Tzamr9EbnqQsiIlwF4zXM9+tSEdQK3IRyvwv5gH8NrhGq8dhhXCMzmZOnRpfCM/rKBI/aNXizaKWZEsjauWEV0NO4pP2KtoZRC4yXawCh7xoeBqJm7I08GK8M3TlLU7zM2KCvdCo+KsIFG37SBFDUuQCeVuuR0OWa5B8TKt/zPYeKX0JzQtvSJsCcVsGcjxSNKe5LHHl3+k+AeX32VYAfn5zNHQQTSOXifwP5ralEyH/yf+fM7neZPOgfJjnTVfxmz3qo0aG34ldxP+ma2NOMXtdThP+8bS5w55Rep9Nc8TMvPHUT71I/Cp+wH/d+V8H9TRl1rviZF567KolsX/6lOsprXsZn6Z/BqGdeZKfOeFcFokmJWaqJl/+d/+2HB5ZxD30lEPTo24z6nNHjL3h/0vhF/xl3AAAAAElFTkSuQmCC", + "text/latex": [ + "$\\displaystyle \\left\\{ -6 : 2, \\ 3 : 1\\right\\}$" + ], + "text/plain": [ + "{-6: 2, 3: 1}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eFe.eigenvals()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e678613a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdcAAABMCAYAAAA/Uv31AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAUX0lEQVR4Ae1dS7IVNxK9Jhh3YBzR837eAZgVGO/A2Csw7ADCM88I2AF4BXx2AKwA83aAF9ARjYked4T7nHo6Rb376tZHSqlUVamIuqqPpEydTGXqd6u++vvvvw8eHIEYBH777bcbyPcTjgc4vx1ThudxBBwBR2CLCFyHUbyFin04UbnXeH7vxLNJt5GfZT9C/HZSBk90AFZRMonNFwN5oHU35KWT7Q1I9xEPzvoe4tlXffdL3iuJ2VC9YnFKyEeZvMFxG2V8HuJtLc9Qj13aGtS7ensxpEMJOhxlW0DPRPfH+L7eqfRTnJPZbvizezH3HMSfIc+fiN2xzgXvIn2sTGLzTeYSMj1H4nPEP45ketLz/AfcG8vXky3rreyYjXAfi1NUPsiN7fI1ePodR1IHeqReRR6jLm5rDodYHY7NZyXbKB0G8ah8hro/SL/rXJ+RqBVaKIvGk1OG/7Iqc4flxMokNp85xNCD58eF4h5v1eZcF8UsFqfYfBQA8nJG6S8c93FckRPTrCGAd7c1F4KK1eHYfCbq0ad7uMeyB21EbD4WjLzJuj9Gv+tcSdMkgCinCdkjZgU2MeVkAowXsnsE0B44hfcKRy3TsRy1vgFfb3GYda5LCRo8u60pBXYEHciHU7APQlbKitdPqG/h3pJRVt3P4lyBFh0rp51W2xteUuJOe1sIdBzAJ9TsOxw0MFUEGjkcnB7mtCqn69cW3NZUKrGg9xxgybkecM7RKDtz93BQ7xYLoJ9V969Z1wwMs2dOAB9Zl+3lOQJrRABt4jMOGhMamRcV1oFt9S74G5yGq41v8Ou2pjahXObnPi655NDVK41Yf72cdLGrbLpv7lwBEXuS3OgiEBdDzQk7Ao7AOAJoq5wOZnvt26AxXsByKdzWLIf9FMrc9MhlwXZpELrWnk8pIHeanLpv6lzBKHso7E36qDW3Vnj5joAtAmyzZ2jDD22LzVOa25o8uFqWChlx2vVrxio3yI2XXIaoJWTRfVPnCqQ41Pe/3tSiMhn5QCOhIeZIhzJvznG9CsOcEZbVFg3ZcZRBI1jLdN0Ylm5rxhCq7Dl07C5Yos3gS2eq2Y+TS/fNNjSBQY5YfdRamULnYgfy5lSiz1DkAniZcp+BbLP2CvkuutlkqPpua4bQqe9ZkBcd6x0c7MT9UR+XzUjaVPctR67q8VbTI6lQgM6SI1AtAh2HqrZcK6/iz21NrRLq8AW94h6cpzj41xdu6PuA8+4mp07qZU7BjzqT0q1kRkxGrmCM/18iWJxjr2rBOhkhL2D3CAT9fgcgqOdTA3cHs5e+tkAj8yN4v1Uj/0EWbmsKaFXA2lTvUSZfqUsf8Qox12Nr8hemum/iXAEU38TE8Owi8t9aEYAy00EkNRiUMfq1B6RZ/L3BVjIIBmAvHyZgG6bz+hlHjZ0DtzVWij1STqreIz+XCQ+Ij/WI08KcJuahESNOFw+mum/lXDncZ2h3hV1c+m9tCKQ2GNYHZWzGcdYmn6X5gWw5+0Q2+B/FGtfU3dZQOusIzQdhoE+1jVB70bPW/eQ1VzDEkRB7INwlXNMQvxdAv+kIOAKjCLCTfAPtuRl5jKYulMBtTSGg7cjQH2gauFvqd+GixsGYme4nO1eApGmamob3XUH6eQEEYPhOfbawAPVVkfgmcHuzYq7fBN44NVxTcFtTkzTGeeHMh3SpSQ07wSUHDsj4d5waB2PiN1n3LaaF9T5SMdWA6D/7QQCN5CFqW9Uopzb0gRFf1s/AWR4Gbujg35n4ntXadr1qRCFeG4Yr+HFbU4EQprJAvcbBv7d09+KcIf8PuCcdm1pcqXTiK1n3LZxrw0TFYJUSyi7psPGg4qv7mkppYQEnrRWWJj2bHnjlXyeYjzuGOT1cywjDbc1saS6bAbpDZyWHtSwzE6iDXzPdT5oWZsMDvzzcuE4Q3NaSBPlzxLqaxrM1GWSsj3Z4an0sI6nxot3WjGPkKcwQMNH9JOeKqjQ9ScTuXM3kuqqC7sPoPV0Vx87sVAT4dwmGWqb73dZcyMN/8yNgovupzlVrIPL0+avtFKpAAE6VGxN8E1sV0sjChDaoqY1nITKjUPHhtmYGaJ40CgET3U91rpoyeh9VBc+0SgTgWM/A+E3EPmOxSglOYlq9d7XxSZkyJhIfbmsyguxFNwiY6P71RDBpZBncyF7gsJdfrrN/C+eq73/y+hCu3yP2Ee36NUFtupFtBdVxW1OBEHbCgonup45c1fDEzE6w33c14Ty5o+6RDqAhJ/vYHes2dANy/Kya4LyGdVe3NRKIx1kRsNL9aOcKBtSTPHSZyVprL7w6BCB7viZPzvUJrrkW62EbCKjT3Lb1JaoFnWrpu61ZQgK7pJms+ynTwurNioldSmDvlYax4wsQansJwt7FYlV/jV5b52ZV8Mxy3NbMBMyTJyOQrPvXElhQgxMTCUV5VkfAEagQAXWc9crGpVh0W7MU8vulm6z7Kc5VDe7TfvH3mjsCm0ZAbVvObanKuq1ZCvn90k3W/ZRpYTU4H7luWAEx7cspOb4X97avdw0LGvho7fk/SPktDq5Bqwc8nLnOp2rbautLcSn64mcpPpxuJAIrtCPSNene7JqnONcbgZo8/GziKRk6hkzFvMC9c11YxCiPwOqblvyfHevKXbKmdCx4tSwD9aNsf8fB+rLe0QqGvLsIwIx/PG93SwcMPyDmS8rX7GApP7X1pWQp+tTHWQHYU3cfhEwsh9fs9GR5ZSfK9c5oABtYbMGOSPdCraZHKc715nQydilDY+FIik6uaSCIec2DowWTEOg8Q6w3wxxwzpGJDGaWxmnCfGIhqOdnFNG8aB7n/sWbETyBEXdM8wX37f97iWG45hdBWh0aKaq2xxyBMyzS1i9Ix9MH/jSMtBNyrgecczc7v0R0D0crrw6t2acoZwtOZHa9xzIAlzXbkWTdvzYG0MBzKhQDASwZ6EQ5Su06N/JiPTqgI20bJSsImhzFsr7kwYMjIATYEembzXiP+/zkltqK0q8lVttemn/RFz9T8WOnh++/7v49THbj16mFjKVD+exI0VnTXrwYS+/PV4GAdE26N5vpFOdavDcbGgmnXS799QP3OfVmPTq4CzofUe4xuGycHKVwesmDI0AEqCt9U5bq8PG5h3gEYm0NOzw0kjKUB7Tb9jyeHc/pCIwjkDItrNI1fNZ1zpg9Q/YSSzQQOlF+z/IUrRs5K+plrwMB6McUPYh1DkuD0NdhWJKnWbYGsmEb/rrLMO5pFNv9gHc3iZ87AkQgWfctnOsp55NDRNxc8ycaCEevP+NgY+M666vQkHBqE1DeqY9bk/YBz9kr9uAIyHEOtYMpDtiRHEdgCOPR3GiznEFolntwfmn2azSzJ3AEZiKQ4lyXMBii+R0ah3bxHnD+F45fcJhsUDiFIcqnY+V0cEv7VFq/7wh0END/NDu3VnGa5MwMa6h2H1VkaLd0rHdwsFP8R1RBnmlPCCTrfopzFdDJw2cVNBSjgaiBcar2uNf5Enl/x/23OJJBGeCDG5leg4Z/IHwApJ09GtJ/jWpnTWdWhF9bN+g89xnkbFtTqt3yMyWx0oDvc5zzOOCc08Lc8W+2W5jlbjEAI9rcdzhke6dUk7g2WE9JXHGaVteIA47Zuk/n+o9QQcVz6/u/qRmMhKVNIl2yH3DBnYGcNuY6i3kA71yj4ZT0qeliS5qSheKpZSu94qn5Sqf7Z2mCA/SEleKBpFcfsdHh4IM+A6R7fTp7tbCrd2Jxis13zEEUJseFGF5PtjWnaEJW7BzTUHIp6etwfir5Wu5LToqn8q30ii/lC9jcvnSz3EWsDsfmO65ZLybHiXquW/p0rv8NCRT3pB+8NXn0myIs5sVBRoZ6EFl28IIuHTc/Dm69I5n16QuSheK+NH33lF5xX5oa7v27BiYCD8JKcQxr7ND16d7NUFhshy8Wp9h8x3VPweS4LIvrybaGxNBeb4X4/Ig4p4XvhiPrUtIR3VyXkpPiqXSUXvHUfCXSxepwbL7jOsVi0tK/dlxi5dc0UhoN9LEaO0LoK6u5hwbKaSR+GLwdseL8jMfJTP5gbwhwuYCzJseBvX5++3aoQ3icp8rrldaBM1qcAh6yGVXi7UzVg0Cs7qc4VxmMmwVh4NRsn1OjEePIth0hWDQolHEL5d5BfLyBiQ73E44mWNBSWRXG2oxTUs4nYagRa/DEPQCfEFMvmhD4/AkXv4Rba4yiZJ5BRrG2hvk0DdzFXx0hU3vRJXDqPAM2p0jVdr8qOzIBnCjd75ab4ly75RQ5h2JyCoeblridvglBWS8ZsXCPO4jZc40KyEsnzhEJF7P5GsT2wL0HuG4aPOIbuE6ihfzVBdSLa1KsP6fEGZpr3NP1xd2Cv5VjzQ4eX2bC99Y+xDnfzfw9zo+nJAsiVp5UZTJip/hNFwXwxw4Q22yuNnzSiVSGTReWbOeoc3V2JFtljwqetYZxlJcjNypp0QBhyYDpT+DsYVwyYkjDUSyniOkYeTSOcCajbJR0sH3OpDWYRrRmspY/OerVToPnpzaNQs1YBx279LrMabXaVqpMMoqyNeDlOQ6+flK2gmCzTdOGdEetyfYC5bEjysC1XAY6Fdogvse4+XcD4mQ6Tckr+kGdq7MjpeBLca5yWEs42ONp2it4QahcJ22n6a4kGLnB/CNJ2septNqC/GQUAcd6FCLLBGrbauuTys4gI9EXP5P4YCLwQifaOtJTGVN5Rv5JTiSVzin+/b45AtI16d5sAtdm5/iSgb1JBk2DXFzV9cv10mhwZlalJK2ZrG0uuWNdRqRad1Jbn0PVUkain9vWWPI8hFUpOkM8+LNhBFJ0vyk5xbnKacnDD7Na+CmcKvkq8uf9krQKw1gdOce6qEjUttXWJxHPICPRFz+T+JiTKAPPveRL0ekl7jfnICBdk+7NydukTXGu6k3Kw88mnjnDfSjy08w0VHxJWqK519ixLid5jRTV1qdStpaR6Oe0NdY8n8KqFJ1T9P3+NARidb8tPcW5yqPLw7eF1nBS0LEeStKqAdsleXCsi6Kvtj3r/+MZZJTd1mTguVdQpej0EvebcxCI0v0ugRTn+jEUlLM32eXVzx0BR6AsAmeBnNp6WepfqIm+25ovmPhZXgSSdT/Fuao3KybyVtVLdwQcgdIIyJmprZemL3qi77ZGiHicG4Fk3bdwrho+566sl+8IOAJlEZAzk3MrS/0LNdF3W/MFEz/Li0Cy7kc7V6wdSOEPOBcjeavrpTsCjkBJBOTM2rZekrhoua0REh4XRCBZ96Oda6ikGp0714JSd1KOQG4EOh1mvlXoc256E8p3WzMBJE+SjoCV7qe8oYm1OMdBx+rOlWhsLEDJ9A5n/l+Yb6zie3Nl5DZWW5vqAJ9bKImvwruN8xqcUmzF1KZrkbfbmlhJFsi3Ib0nWia6n+pc34MRvmLwNjnysB0E0Fj40YPHiJvvXSLmNAk/38X3stZicKsAPGDDF/Xz/5j84ooaZxX8RTLBTgLD6KsDL5Jl/3Vbkx3ieQQ2qvcEwUT3U50re5MMNCgeNoIAGg0/VsAPHrQfksY5pwd5zZegl/po/CoQJTZgtHm3LM75RRw1zlXwf4LJO+E+nVoNwW1NDVLo8LBRvWcNTXT/WgermNM/QqYtGJOY+m81Dx2FjFm3jjS0/MoIR7Eeto2A2nQtI1e3NdvWt5pqZ6L7Sc419FyaKUKcb2EqrCYBL8nLXRDnFOdx0HQwn3vYKAKh88T2XMtmpoPbmo0qW2XVstT9JOcacNHUoRvcyhQlhp2gXGNZb44l8OerRkBtuZZRq8B0WyMkPM6FgJnuWzhXflScwdfhLnBY+68c59BOV58WXruUh/n/OTx+MZys+FO3NcUh3x1BM91Pdq4Y6bB3S0Mc/WHy3Ylv/RXWFyPWXxOvQR8CTe8dbVsjxb40xe+5rSkO+R4Jmul+snMN6L9kDOXXQvAehbKVOvettapuGtUW+U6uiHpcDoHQhjkzUZVj7SDgtqYDhp/aIWCt+1bO9VWooobUdjX2kooiAAXTdHDf1K/uaWNTUd6cWBEEtOZU25SwKu+2Rkh4bI2Aqe6bOFcYZE0N8/+RHtaPAOV51lMNjVxr2+jSw6rfikSAHWT9pzmyiHzZ3Nbkw9ZLPpjqvolzDUJ5jJgvHpD3d1mtFwGODvpeDMI3cZ13RrfrraFzfgUByJXLOjyeX3lY1w23NXXJY/Xc5NB9M+cK5p4GhB+sHumdVwCypHH9hLjdpIZzTgn/hOOXncMzVn1t9tIofyx9Tc9/DczQeVUb3NZUKZo16z0BNdf968ZiooN9SEOMQ2t3xiS8uEIIcJTKF/XzVWDcwMT4e1z3vbkJj/YdgIvWAjVz8wr3uDb9BnHtI8EDeGTniZ2p1zhfQ9t1W1NBk4OurFrvCWEu3bd2ruzx8t2q7AU8wuFhpQgEA+uzEBPlB7z4ysg1B+2XWEu7dVtTgbZtQO+JYhbdN5sWJofBILNxNqNX3vPgCDgCq0CAHeLnaMOr2AnutmYVOrUWJrPovqlzJZJQek7XsIFqDpu3PTgCjkClCKDNcraJ08JrGbU2SLqtqVShVsRWTt03d64BV41ez1aEs7PqCOwOARgXOtUnOB7gfA1rrccycltzjIhfT0Igt+5nca5gmm934SaOZ5Nq6YkcAUdgKQT4kfe3aLPVb7rqA8htTR8qfm8iAll1P4tzZcWg9NwMc4ZYi8UT6+vJHAFHoAQCaJvc2cxj1Zux3NaU0JZt0Sih+93dwh9B8BhBbstPaXjM+w5lvMSxximnYzxKX8fKJDafef0g948odA3LA4tiFotTbL4gaM4s3dtI23RbczjE6nBsPhN7EavDsfmsdH+MPp0rNx+d+stF0s5BEOfbfKj0/EO9O1eAMDHEyiQ230S2opJxPa/mUAtmsThF5UO75For11k38SrLnduaWB2OzWfdnqN0GExE5TPU/UH6/wf/7s4VFqHLMQAAAABJRU5ErkJggg==", + "text/latex": [ + "$\\displaystyle \\left[ \\left( -6, \\ 2, \\ \\left[ \\left[\\begin{matrix}- \\frac{1}{4}\\\\1\\\\0\\end{matrix}\\right], \\ \\left[\\begin{matrix}-1\\\\0\\\\1\\end{matrix}\\right]\\right]\\right), \\ \\left( 3, \\ 1, \\ \\left[ \\left[\\begin{matrix}-3\\\\-1\\\\1\\end{matrix}\\right]\\right]\\right)\\right]$" + ], + "text/plain": [ + "⎡⎛ ⎡⎡-1/4⎤ ⎡-1⎤⎤⎞ ⎛ ⎡⎡-3⎤⎤⎞⎤\n", + "⎢⎜ ⎢⎢ ⎥ ⎢ ⎥⎥⎟ ⎜ ⎢⎢ ⎥⎥⎟⎥\n", + "⎢⎜-6, 2, ⎢⎢ 1 ⎥, ⎢0 ⎥⎥⎟, ⎜3, 1, ⎢⎢-1⎥⎥⎟⎥\n", + "⎢⎜ ⎢⎢ ⎥ ⎢ ⎥⎥⎟ ⎜ ⎢⎢ ⎥⎥⎟⎥\n", + "⎣⎝ ⎣⎣ 0 ⎦ ⎣1 ⎦⎦⎠ ⎝ ⎣⎣1 ⎦⎦⎠⎦" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eFe.eigenvects()" + ] + }, + { + "cell_type": "markdown", + "id": "45d85953", + "metadata": {}, + "source": [ + "Den sidste af kommandoerne giver altså både egenværdierne, deres tilhørende algebraiske multiplicitet, sammen med hvilke egenvektorer der udspænder egenrummet (og dermed også den geometriske multiplicitet)! \n", + "\n", + "Mega fedt!\n", + "\n", + "*Det kan hænde, at egenvektorene vælges anderledes til forhold af den anden metode, men egenrummet de udspænder vil være det samme!*" + ] + }, + { + "cell_type": "markdown", + "id": "300ee788", + "metadata": {}, + "source": [ + "## Egenbasis og diagonalmatrix\n", + "\n", + "Da $n=3$ og vi i sidste opgave så at summen af de geometriske multipliciteter også er $3$, har vi af sætning 13.11, at der må findes en basis for vektorrummet bestående af egenvektorer for $f$. Vi kan vælge egenbasen\n", + "\n", + "\\begin{equation}\n", + "v=((-1,0,1),(-1/4,1,0),(-3,-1,1))\n", + "\\end{equation}\n", + "\n", + "Ved at bruge Hovedsætning 13.14, ser vi at dette giver afbildningsmatricen\n", + "\n", + "\\begin{equation}\n", + "_vF_v = \\begin{bmatrix}-6&0&0\\\\0&-6&0\\\\0&0&3\\end{bmatrix}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "696c6617", + "metadata": {}, + "source": [ + "Vi får et andet bud på et valg af egenvektorer, men også en mulig diagonalisering ved brug af den indbyggede funktion," + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "10bb7fe0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUYAAABLCAYAAAAMPi6aAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAPvklEQVR4Ae2dUY7cNhKGJ4N5DuwE2PfM3mBsnyDjGzjxCezcwEbe/BbEN4h9Aju+gZMTOPYNnAMssPZgnxfw/p+apaXUVI96WhJJdRFQi2JTZPFn8VcVRUlfffny5WRMePbs2Xvle6r9H6n8Sr9QOnlS4Y3+/yH1h6etBwH18Ue15jzVIv33VSp9yTTX0SXRnr6um+qXzkMn32q7o/jVGMnOxmRSYb8p39/aJ0mxV8ZzHTNA4vB3fODx1SLwa6Jl95X2IJGeM8l1NCf6N6/7Rvol3oK73qjal9pGGWjXEqMKRKl/1PadtjHhNwQZk9HzrAsB9fuLfouURlJpxOg62u+oCo4P0S+di7f7WdvjVDn95u8kRhVwSyfAshQ6ygTtVzDXseTBdf9d22jzeC5Z9i23VtklNy7JT6G96AbHvyp9jCcRTjuOnTDpWzevlPahhNZHsv1b8vxTG31YhDEzs2xYi29Vxx/XtXcnMaoQSBEzdMsSUPriQXIYUX9S5Xe1JeezFhdsRIU1y07zgvxcII0YScMSRNF+0IarcvRBOKCTXLDb+XilccwGCWUNkoX7AL9Yf2nPmHqv/X1tWclR9c8qm8qHENFTpgaZ4hkMp0P/qAAsMhT/6VCepdMl05U2BiGD89XS9R9SX82yh3Y/1h43JHaLzVL8+RBsVnYuBIh1aNjQPMgnK+kghGSiD29p317EFL9SmpEF2bKEBWWDzy5VX6zHW20eJEblxFr8oALiDt4qwBOOBgHcQAYRWxPCoLLDo9+HwYZB0fGwlI41ttNCWQg8XMmUO/9O6ZAFBJ4rLCKb2sgFCk7rT3V02p10pXUybEoHl9CZHYH9IA8C0gmU6XZce9ATknBNPGzmX/Fq2otHYaBcSp4OaQf5zJrl/9aaXFj2JWXDamT64Ik2VihshSQxKheu0djlOVuFesL6EZBCochcdX9SPDXY1g/CdgvvKolxg1HxUJvd3PhdaVk9L9U/xhr8ZrtJ86csLZvqM08YnhtHjDqJTmUrZm5x/q7xGsYiEPQDUrynDbfsr7HnHkE+I5+7wqkdP4qzTOSRtlzWGNAb6e2yZk3+pbsqh2x4Oc1cY6pfUnOMsCjBrYANDv4bISAl4mr7XBtzQtwAwyXZOZEdnb7aqDAwUrlQvD92XqvhL6M8peLwbamCSa5JZVNf2EXK+K7T9I4rHToOJee29q4rS6eQsQeh/D+V35RozKnchU5NGI85d7I8NcsOCHPIrzJ51BM9wVW8HeKTYb50QZIfvTxUP22+LhafZSjcEcbVzuVSf4oF6sXNYsP1zxFyyQY5PlC/czHrcEyHGJWJJ1wImJmThzBw7kxe8AIF1iw78Bwqv85neoVyOgqkJFxpXGs2uworWl84BCPO1UajdxkU57lQieRLGSWWliL12UXOKBs8hyHIfHBHr/uuNO4RIddVbVO7/5aIAFYPbrMNohJlzC0T42YXPlmIJwIF+VLkbBZjznG/uGzSZWsv1nwntMQYFJ6rPnfVrjq5/MAR2FhC5jrHeOAeEkzJNkfH+YsFkiIevCQsytwYsfjc+ivuIeRj7jjnuM8lG33CovfGIzJQWmJUgrnRtbhDNhlrVztrUw37GmXnLuvbGFwpE24IFhJLdnIOqlisbHFhwNhhfr5dPKw4+DC2HmUTLFQsWbgp9El7+q0JpciXUTbTadzpNpy1sf8v5raM0V/lRAUgVxYC1i2BiX9cFJ7Z7d8NbDKU8lO57C8kP8sb4vlnrCOe6shtCZXSxSfCAjx4KYPhxIX7ex135rAyCox1iHwst+JmC/tS5Mshm+mu8YngODmJibH5Q4BZxiZDaT+Sz+ZBSxPtWnlqlp3GBd0oWj+u7YQFMgindg3jAtXtVYVkw7JvXwSy18kzZ84hm+pkCoGWcWcal7rxfBpXmgT9wZZ7chgBPTgCjoAjsCQCZs238682x2hmpBPjkt3hdTkCjkAJCLDkjNDegDFitJdFGHNusvmvI+AIOALrR4ClaATjwRMjRjMhef2QB0fAEXAEjgkBsxiNB1tiPA8ouCt9TOrgbXUEHAEQMN7jPksTzGK0BMtg//veEXAEHIFVI2B3ommk4s0846kiZi2SeLVqBLxxjoAj4AikETCjsOFDLEa7E2N/pE/zVEfAEXAE1ouAGYUtMZrFaH+st+neMkfAEXAE0giYYdg8rovFaM/tfkrn91RHwBFwBFaPgPFfYyjySGDRFmOYDOUlBUU+xtRXF8lpLxDgOdSiPmbel/Wmx6FPeGb9juJH52kcSR+bHpua8EnY2dc5Z8TW9Lglxluh5caYBkQpewbg7B0yRWPVqSwULfJj5oe2T21DT/ikLnrCei+7oCp6PGHNfUwvqn30K2PuqeLNc/Hac8zGhX62oHpKGD8NH56qlbz9o8ggoJ4UKVhCKMla7MfME+LunaT28T5BPjOB5c63Xo4urL2PQ4dCgFiH8ctCIAubg5ul3wvAFg+P0PAhxGgW41WTXMiPgOJuOTIVJdcOeHjrT8qyfaf0S7XHcN5RhP9VOAKr7mPp6APhz7jrvL5P6bxKrX1cbqY+yo2t8UwzTku2GB+qMzodNFOHTFUsL+JITUfYldZe1DFVfV7O8gisvY/xBvAMjCSWRLgobM+ilpspGSXliapjcKHtRZ95hNijVsk7xhosdspij6YebdYj6WPmjvm0CVYjb7SGE5hX5GXQsWutpOlCIdh2jJqYGHNcJbbQFUjnSuSqZZbWVp4CE4z0dmE4hjwLbJqLFBA4hj42Hb2r8de+bFfxz9oeaZvrsyfFYRvPMZYyAliaU5MLPRY3Wy86Nr/nqw+BavtYY85IkTdZ98ffa3XFyyhPjp6ZG9uOURNbjB1TMkfLBTx3dqtxoSOMdmFnV8OsUxVBqQ/9mHzU5KOLHksfpzy19+ptxiau9hwudQnYtjIwVmJi/O+Bqv51ON/2exUnYXCh+eZCqmP2KmvpzJIZ159q7aobi2BpWduFjBLqTizYQvF/LFTPmGpMN20/5pwmz9r7OGpfx3LqAcQYnTxEddtYieuwtKHxM5V+dXQiJsY4Hgs2Nv6fkNH2Y8+zfIB+TyCxjioOFzo4D+lMDLdzH3GmAuJcSVOKYxbjHFfaApp9rQj/ujbHchlMN22/b81r7+Oh9hlOQ+Rk/x+yH6r7uvEzlX51dOJQMjwEiM65IjyAYesEpX9WAt/qLf3rgBB6/zEq2oKVlvtj5sjh4XAE1t7HTGP1DRNQQ4fxirbGJ39OFIrBVu28OlWjzHQ2Zp6onZMVgylt5vRkhU5dkMBkwrrIj5lP3VaVZxPhs+mM8Cyuz9fex2ofd50xQtoLfOiHH5X+aAY9aossANuOLhdjMbYIhYiA4uplrilPjnBFeaf9837ego65spb6MfODYQp9QDmXoTDWt+FevdW+fyczZNl/p7IgRZaIYGmDaUlh7X3MUy7osN0EhTC+py8W6IRisIUYP2kr8epcxdt0YmWR8lzpuDq54zbsiqt9i0xngKM2CJebcWzgWkQIsqy2jwFZbcwyj18StrErXRw5FjESXIgsCGiQ8MRFlgGapcFeaW4EjP+aizDEiMVI+Haz819HoBgEWKVQjLVYDCouyBwI2Bxjw4duMc4BsZd5MAIiRK7gWRfFH9wIL6AmBAYtRmPMmhrjsq4Xgccix5JvtK0X+eNsmXnMbjEeZ//X0WonxTr6aUVSmsXYLGLHlf4YGucW44p62ZviCDgCeyFwHnI3fAgx2mM+9sdepXlmR8ARcARWgIAZhq3FaMRopuQK2uhNcAQcAUdgLwTMMNwQo+ZyjBhPFLc/9yrRMzsCjoAjUDkCZhi2FiPtMXJ0Yqy8d118R8AR2A+ByCDkiasrzrZnpT8oDikWQYwSzh5it29O8OymkTdyFx0k64UE5NnuKj9IX7v8cyvHCvSzyPElXOEfe9wSC45jxv6cb/VBXYz3Wo4xYnynP/l0Ig9xZw0CgbcFV/fReslNR1b7Qfra5V9KaWvVT8OnVPmD/j3V3ojxRHE4iReU8D3zub43AzQYMoSWgE83x+33kHl1ebagxlf70XrJjhle7Qfpa5d/CaWtWT/Bp3D5Gfss6ocMLRhR/WwJM+3vhXIxEJtgxPhXODbmDIeL73J/dHvxBnuFVSFQu36WLD/TeczvNXN8aIVIso1zPGMw3jMiPmmIMQjQ+NeKm789oxyDRfOev+aRnF4O8/3534MjkAuB2vWzWPnFO7wg9zZ761zFzXq0d0PaX5PtVQdTYHBee+OFws1iJG4+fBbyCQIix67wza4//T9HYC4EatfP2uSXvPAQN4nm/pyy8V1LyOjQGT8hvNX+ibb72iZ7G3Moe8zOSG+X+Qy7e3AEciBQu35WIb8I8UKdC1kx74d7bdN8is4SHoZSX8WltxajBIIxISUzX+N8pcTtDRilyONyOAIxArXrZ3b5xUN8zuK5NuZDIav3is/JSY3FqDrMY276syXG0Luv2SsTrL10SM0tmgx2tfP38xkivl8agdr1szr5A1lhrPFtocm9xcBzlNshRRSrT4wsSiaYebk5WuBXQgIAIQWApdlNmE1O/3UEFkKgdv0sXX5Iii3RneZK21xgIsuNk6zMjhtNaR1ilGDmTrOmKEeg/vNExWYxdiZIE/k8yRGYE4Ha9bNk+XmwA7fZjKA5+9HKxgDkbvS1FiMn/KLtljIbm5K2VMBivZuojCdy/KP1CWA8aVEEatfPkuXHY3wj3mEfB+ODSY0i1YN1ypa80dyxGJFGJ9jr5NtHc0hfIqjutXy03iaxzdJdAr4p66hd/imxaMuqXT8Ll58vQrIypg2Sl5suWJAs2ekTZpvvhhF7mgZDcCucbaVsEiDHJxIGy3FqgQaqbJOxDqv8aL2wsjlas7Zn+SB9i9TEkdrlnxiOoeKq1c/QoCLll+690HapLV7MzbTafaVNbS1CtpBuykJtYBoiRliUNY2wKky+WBAIEPHi1uoUDZTsLDGoNtQu/xLA16yf4FOy/JINApyUBAd0wu6hDHLblisdgcdJjdU4ULgnOwKOgCNQIwIYfFiog6tcksRIS3US7jQnmi9OsgdHwBFwBKpFQLyGJ4wrPWgt0rhBYuRPBbMa8fU9OAKOgCNQLQIiRQjRnr9mym4w7CRGFcT6Hu4UxxOig4X5H46AI+AIFIwAL5LmLT7JJTqx3DuJkYwqhBsh59rbhGV8vscdAUfAESgeAfEXK0XYRt0gHbor3W8ohf2pwl9r22mCKt9H5emfz23xUQL1T/TjehBQH/Ox8hqmXVxH61GrVtID9QuvlzfsX8dfTX2jiFGF8dQJxMaC5aGCuVEztMxm8O5PI4X/rAUB5m9KDq6jJffO9bLdSL/EXbdUNIvERy8F+h+zANCqBrdE8QAAAABJRU5ErkJggg==", + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}-1 & -1 & -3\\\\4 & 0 & -1\\\\0 & 1 & 1\\end{matrix}\\right], \\ \\left[\\begin{matrix}-6 & 0 & 0\\\\0 & -6 & 0\\\\0 & 0 & 3\\end{matrix}\\right]\\right)$" + ], + "text/plain": [ + "⎛⎡-1 -1 -3⎤ ⎡-6 0 0⎤⎞\n", + "⎜⎢ ⎥ ⎢ ⎥⎟\n", + "⎜⎢4 0 -1⎥, ⎢0 -6 0⎥⎟\n", + "⎜⎢ ⎥ ⎢ ⎥⎟\n", + "⎝⎣0 1 1 ⎦ ⎣0 0 3⎦⎠" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eFe.diagonalize()" + ] + }, + { + "cell_type": "markdown", + "id": "ac4d3e03", + "metadata": {}, + "source": [ + "Som dog kun virker, hvis vi har mulighed for at diagonalisere matricen," + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "62930fd7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eFe.is_diagonalizable()" + ] + }, + { + "cell_type": "markdown", + "id": "434d2417", + "metadata": {}, + "source": [ + "## Diagonalisering ved basisskift\n", + "\n", + "Vi kan også komme frem til diagonalmatricen ved at benytte basisskiftematricen, der skifter fra $v$-koordinater til standard basis koordinater, som fremkommer af de valgte egenvektorer," + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "7d1283f0", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}-6 & 0 & 0\\\\0 & -6 & 0\\\\0 & 0 & 3\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡-6 0 0⎤\n", + "⎢ ⎥\n", + "⎢0 -6 0⎥\n", + "⎢ ⎥\n", + "⎣0 0 3⎦" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eMv = Matrix([[-1,-S(1)/4,-3],[0,1,-1],[1,0,1]])\n", + "vMe = eMv.inv()\n", + "vFv = vMe*eFe*eMv\n", + "vFv" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "e23edab1", + "metadata": {}, + "source": [ + "Læg mærke til, at der her er indsat $\\frac{1}{4}$ som sympy brøk (med $\\text{S(1)}$). Hvis ikke dette gøres, ender der med at være numerisk meget små værdier i matricen, hvor der nu er $0$ (forsøg meget gerne at ændre og se hvad der sker). Dette kan altså nogle gange hjælpe, hvis I støder ind i dette problem.\n", + "\n", + "Når man skriver ligningerne op, kan det også ses, at man, i stedet for at udregne den inverse, kan løse ligningen ${}_eM_v {}_v X_v = {}_e F_e {}_e M_v$ for $_vX_v$ ved" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "94b1517c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}-6 & 0 & 0\\\\0 & -6 & 0\\\\0 & 0 & 3\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\end{matrix}\\right]\\right)$" + ], + "text/plain": [ + "⎛⎡-6 0 0⎤ ⎞\n", + "⎜⎢ ⎥ ⎟\n", + "⎜⎢0 -6 0⎥, []⎟\n", + "⎜⎢ ⎥ ⎟\n", + "⎝⎣0 0 3⎦ ⎠" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eMv.gauss_jordan_solve(eFe*eMv)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5cf294f0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.9.0 64-bit", + "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.9.0" + }, + "vscode": { + "interpreter": { + "hash": "2c9ac3126509fb7562f80b441cd82ed33aedc8c8ddd6ebd5271e1ee2b7189db1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Demos/Demo-E-Uge-11-LilleDag.ipynb b/Demos/Demo-E-Uge-11-LilleDag.ipynb new file mode 100644 index 0000000..85d2267 --- /dev/null +++ b/Demos/Demo-E-Uge-11-LilleDag.ipynb @@ -0,0 +1,354 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "14b14fd2", + "metadata": {}, + "source": [ + "# Diagonalisering af symmetriske matricer\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aad4b143", + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "cell_type": "markdown", + "id": "9339eb92", + "metadata": {}, + "source": [ + "I den sidste demo diagonaliserede vi en symmetrisk matrix ved at lave alle steps ind imellem. Dog er alle steps præcis de samme, uanset hvilken symmetrisk matrix man får! Det er derfor muligt at lave en funktion (vores, og altså ikke en indbygget) som kan give både $Q$ og $\\Lambda$ som opfylder,\n", + "\n", + "\\begin{equation}\n", + "Q^\\top\\, A\\, Q = \\Lambda.\n", + "\\end{equation}\n", + "\n", + "Der er tilføjet et par ekstra tjek således at den giver en god fejlbesked, hvis den bruges på matricer som den ikke burde bruges på! Dette skal lige så meget bruges som et eksempel på hvordan man sagtens kan bygge sine egne funktioner der regner matematik ved brug af Python og SymPy!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c56aba08", + "metadata": {}, + "outputs": [], + "source": [ + "def orto_diag_symmetrisk(A, numeric=False):\n", + " \"\"\"\n", + " Inputs:\n", + " A: Matrix()\n", + " Symmetrisk matrix af størrelse (n x n)\n", + " numeric: Bool\n", + " True/False, om der skal regnes numerisk (hurtigere)\n", + " \n", + " Output:\n", + " (Q, Lamda)\n", + " Q og Lamda matricer der opfylder Q.T*A*Q = Lamda\n", + " Q er positiv ortogonal og Lamda er diagonal\n", + " \"\"\"\n", + " \n", + " # Finder ud af om korrekt matrix er input\n", + " assert type(A) == type(Matrix([])), \"Fejl: Input var ikke en matrix!\"\n", + " assert A.shape[0] == A.shape[1], \"Fejl: Matricen er ikke kvadratisk!\"\n", + " assert A.T == A, \"Fejl: Matricen givet er ikke symmetrisk!\"\n", + " assert A.rank() == A.shape[0], \"Fejl: Matricen har ikke fuld rank. \\\n", + " Det er derfor ikke muligt at finde nok lineært uafhængige vektorer!\"\n", + " \n", + " # Nu finder vi egenvektorer\n", + " U, Lamda = A.diagonalize()\n", + " u_list = [U.col(k) for k in range(A.shape[0])]\n", + " \n", + " if(numeric):\n", + " # evaluate as floating (evalf)\n", + " u_list = [u.evalf() for u in u_list]\n", + " \n", + " v_list = GramSchmidt(u_list, orthonormal=True)\n", + " Q = Matrix.hstack(*v_list)\n", + " \n", + " # Numeriske problemer for nogle matricer. Tjekker imaginærdelen af tallet\n", + " assert im(det(Q)) < 1e-15, \"Fejl: Determinanten af Q var forventet til \\\n", + " enten 1 eller -1, men imaginær del blev fundet!\"\n", + " \n", + " # Hvis negativ ortogonal\n", + " if(re(det(Q)) < 0):\n", + " v_list[0] = -v_list[0]\n", + " Q = Matrix.hstack(*v_list)\n", + " \n", + " return Q, Lamda" + ] + }, + { + "cell_type": "markdown", + "id": "d5326907", + "metadata": {}, + "source": [ + "Denne funktion burde altså virke på alle matricer! Vi kan jo lige prøve på matricen fra sidste uges demo:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0341ef7", + "metadata": {}, + "outputs": [], + "source": [ + "A = Matrix([[6,2,4],[2,9,-2],[4,-2,6]])\n", + "A\n", + "U, Lamda = A.diagonalize()\n", + "u_list = [U.col(k) for k in range(A.shape[0])]\n", + "u_list" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bfb8aa6c", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "Q, Lambda = orto_diag_symmetrisk(A)\n", + "Q, Lambda" + ] + }, + { + "cell_type": "markdown", + "id": "f5797e92", + "metadata": {}, + "source": [ + "Som eftertjekkes ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6deff32c", + "metadata": {}, + "outputs": [], + "source": [ + "Q.T*A*Q, Q*Q.T" + ] + }, + { + "cell_type": "markdown", + "id": "3654cfbf", + "metadata": {}, + "source": [ + "Dette virker også med større matricer," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6a627132", + "metadata": {}, + "outputs": [], + "source": [ + "B = Matrix([[0,1,1,-1],[1,0,-1,1],[1,-1,0,1],[-1,1,1,0]])\n", + "B" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dfb71f62", + "metadata": {}, + "outputs": [], + "source": [ + "Q, Lambda = orto_diag_symmetrisk(B)\n", + "Q, Lambda" + ] + }, + { + "cell_type": "markdown", + "id": "49733024", + "metadata": {}, + "source": [ + "Som eftertjekkes ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "599c55f0", + "metadata": {}, + "outputs": [], + "source": [ + "Q.T*B*Q" + ] + }, + { + "cell_type": "markdown", + "id": "1e991bc2", + "metadata": {}, + "source": [ + "Denne metode skal dog ikke bruges hovedløst! Den finder ikke frem til et svar inden for tiden af min tålmodighed, hvis man giver den følgende matrix:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e9986b0a", + "metadata": {}, + "outputs": [], + "source": [ + "C = Matrix([[1,1,0],[1,0,1],[0,1,0]])\n", + "C\n", + "# orto_diag_symmetrisk(C)" + ] + }, + { + "cell_type": "markdown", + "id": "6558f125", + "metadata": {}, + "source": [ + "Dog kan man komme i mål med en numerisk løsning ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88d37e19", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "Q, Lamda = orto_diag_symmetrisk(C, numeric=True)\n", + "Q, Lamda" + ] + }, + { + "cell_type": "markdown", + "id": "51159e26", + "metadata": {}, + "source": [ + "Bemærk at $Q$ nu kun er approksimativt ortogonal:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dd9edf28", + "metadata": {}, + "outputs": [], + "source": [ + "N(Q.T * Q)" + ] + }, + { + "cell_type": "markdown", + "id": "67b9ad36", + "metadata": {}, + "source": [ + "Eller vi kan tænke os endnu mere om. Den symmetriske matrix har nemlig 3 forskellige egenværdier:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3ac4efa5", + "metadata": {}, + "outputs": [], + "source": [ + "eigs = C.eigenvals(multiple=True)\n", + "display(eigs) # eksakte egenværdier\n", + "[N(ev) for ev in eigs] # decimaltal approx" + ] + }, + { + "cell_type": "markdown", + "id": "39b1c573", + "metadata": {}, + "source": [ + "De tre egenvektorer hørende til disse tre egenværdier er derfor alle allerede ortogonale, og vi behøver kun normalisere dem:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "896db422", + "metadata": {}, + "outputs": [], + "source": [ + "v1, v2, v3 = tuple([vec[2][0].normalized() for vec in C.eigenvects()]) # virker kun når gm=1\n", + "V = Matrix.hstack(-v1,v2,v3)\n", + "V\n", + "# I en samlet kommando:\n", + "# C.diagonalize(normalize=True)" + ] + }, + { + "cell_type": "markdown", + "id": "81e50cad", + "metadata": {}, + "source": [ + "Kapow, SymPy kastede matematik ud på flere A4-sider! Det er defor dog nok alligevel mere nyttigt med den numeriske approksimation, som vi kan genfinde ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "246abb64", + "metadata": {}, + "outputs": [], + "source": [ + "N(V)" + ] + }, + { + "cell_type": "markdown", + "id": "ed9cdbfa", + "metadata": {}, + "source": [ + "De fundne $Q$ og $V$ stemmer godt overens:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "68c6ef84", + "metadata": {}, + "outputs": [], + "source": [ + "N(V-Q)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 ('mat1-pilot': venv)", + "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.6" + }, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Demos/Demo-E-Uge-11-Linear-Transformation-Symmetrisk-Matrix.ipynb b/Demos/Demo-E-Uge-11-Linear-Transformation-Symmetrisk-Matrix.ipynb new file mode 100644 index 0000000..46f9aa8 --- /dev/null +++ b/Demos/Demo-E-Uge-11-Linear-Transformation-Symmetrisk-Matrix.ipynb @@ -0,0 +1,317 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Illustration af lineære transformationer med symmetriske matricer i $\\mathbb{R}^2$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Nogle plot-funktioner (spring gerne dette over)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Først definerer vi nogle plot-kommandoer vha. Matplotlib. Disse behøver I ikke kunne forstå." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Inspired by https://scipython.com/book2/chapter-6-numpy/examples/visualizing-linear-transformations/\n", + "import matplotlib.pyplot as plt\n", + "\n", + "XMIN, XMAX, YMIN, YMAX = -10, 10, -10, 10\n", + "\n", + "def plot_box(B, color='k'):\n", + " \"\"\"Input: a 2x2 matrix B=[b1|b2]. Plots the convex hull of the column vectors 0,b1,b2,b1+b2.\"\"\"\n", + " ix, iy = B[:,0]\n", + " jx, jy = B[:,1]\n", + " plt.plot([0, ix, ix+jx, jx, 0], [0, iy, iy+jy, jy, 0], color)\n", + " plt.axis('square') # skalerer akserne lige\n", + " plt.xlim(XMIN, XMAX) # bestem x-aksen\n", + " plt.ylim(YMIN, YMAX) # bestem y-aksen\n", + "\n", + "def plot_vector(v, color='k', lw=1):\n", + " \"\"\"Plot vector v as a line with a specified color and linewidth.\"\"\"\n", + " plt.plot([0, v[0]], [0, v[1]], c=color, lw=lw)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi vælger nedenfor to vektorer, $\\pmb{v}_1 = [2,0]^T$ og $\\pmb{v}_1 = [0,3]^T$, og plotter randen af firkanten $F$ givet ved:\n", + "$$\n", + " F = \\Big\\{ c_1 \\pmb{v}_1 + c_2 \\pmb{v}_2 \\; \\Big\\vert \\; 0 \\le c_1,c_2 \\le 1 \\Big\\} \n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "v_1 = Matrix(2,1,[2,0])\n", + "v_2 = Matrix(2,1,[0,3])\n", + "V = v_1.row_join(v_2) # V = [v_1|v_2]\n", + "\n", + "plot_vector(v_1,color='r',lw=2) # plot v_1 med rød\n", + "plot_vector(v_2,color='b',lw=2) # plot v_2 med gul\n", + "plot_box(V,color='y') # plot randen af firkanten F med gul" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi betragter en linear transformation $\\mathbb{R}^2 \\to \\mathbb{R}^2$ givet ved $\\pmb{x} \\mapsto A\\pmb{x}$, hvor $A$ er: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "A = Matrix(2,2,[2,1,1,2])\n", + "A" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi diagonaliserer den symmetriske matrix $A$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Q, Lamda = A.diagonalize(normalize=True)\n", + "Q, Lamda" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi undersøger billedet $A(F)$, der er givet ved:\n", + "$$\n", + " A(F) = \\Big\\{ c_1 A \\pmb{v}_1 + c_2 A \\pmb{v}_2 \\; \\Big\\vert \\; 0 \\le c_1,c_2 \\le 1 \\Big\\} \n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_box(V,color='k') # plot randen af F med sort\n", + "\n", + "plot_box(A*V,color='y') # plot A(F) med gul\n", + "plot_vector(A*v_1,color='r') # plot A(v_1) med rød\n", + "plot_vector(A*v_2,color='b') # plot A(v_2) med blå" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Da $A = Q \\Lambda Q^T$ kan vi undersøge hvad der sker trin for trin. Først $Q^T(F)$, der roterer mod venstre i skiftet fra standard $e$-basis til $q$-basis (husk $Q = {}_eM_q$ og $Q^T = Q^{-1} = {}_qM_e$)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_box(V,color='k')\n", + "\n", + "plot_box(Transpose(Q)*V,color='y')\n", + "plot_vector(Transpose(Q)*v_1,color='r')\n", + "plot_vector(Transpose(Q)*v_2,color='b')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Så $\\Lambda Q^T(F)$. Husk at $\\Lambda$ afbildningsmatricen mht til $q$-basis. Diagonalmatricen $\\Lambda = \\mathrm{diag}(1,3)$ strækker $y$-koordinaten med en faktor $3$, mens den lader $x$-koordinaten være uændret." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_box(V,color='k')\n", + "\n", + "plot_box(Lamda*Transpose(Q)*V,color='y')\n", + "plot_vector(Lamda*Transpose(Q)*v_1,color='r')\n", + "plot_vector(Lamda*Transpose(Q)*v_2,color='b')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Og endelig $Q \\Lambda Q^T(F)$ som jo selvfølgelig er det samme som $A(F)$. Multiplikation med $Q$ roterer mod højre i skiftet fra $q$-basis tilbage til $e$-basis. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_box(V,color='k')\n", + "\n", + "plot_box(Q*Lamda*Transpose(Q)*V,color='y')\n", + "plot_vector(Q*Lamda*Transpose(Q)*v_1,color='r')\n", + "plot_vector(Q*Lamda*Transpose(Q)*v_2,color='b')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mere advancerede matplotlib-kommandoer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I matplotlib-pakken kan kan vælge følgende pre-definerede \"plot styles\": " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(plt.style.available)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi vælger en, tilføjer plottet lidt mere information og gemmer det som en png-fil:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.style.use('ggplot')\n", + "plt.title('Plot af firkanten F og dens billede A(F) under A')\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.xticks(list(range(-10,12,2)))\n", + "plt.yticks(list(range(-10,12,2)))\n", + "plot_box(V,color='k')\n", + "\n", + "plot_box(Q*Lamda*Transpose(Q)*V,color='y')\n", + "plot_vector(Q*Lamda*Transpose(Q)*v_1,color='r')\n", + "plot_vector(Q*Lamda*Transpose(Q)*v_2,color='b')\n", + "\n", + "# Gemmer plot som png-fil:\n", + "plt.savefig('mit_plot.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lidt mindre seriøst, har matplotlib en [xkcd](https://xkcd.com/) sketch-style drawing mode. Det fungerer bedst med Humor fonts installeret. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.xkcd()\n", + "\n", + "plt.style.use('seaborn-v0_8-colorblind')\n", + "plt.title('Plot af firkanten F og dens billede A(F) under A')\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.xticks(list(range(-10,12,2)))\n", + "plt.yticks(list(range(-10,12,2)))\n", + "plt.grid()\n", + "plot_box(V,color='k')\n", + "\n", + "plot_box(Q*Lamda*Transpose(Q)*V,color='y')\n", + "plot_vector(Q*Lamda*Transpose(Q)*v_1,color='r')\n", + "plot_vector(Q*Lamda*Transpose(Q)*v_2,color='b')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 ('mat1-pilot': venv)", + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-E-Uge-11-StoreDag.ipynb b/Demos/Demo-E-Uge-11-StoreDag.ipynb new file mode 100644 index 0000000..aeefe88 --- /dev/null +++ b/Demos/Demo-E-Uge-11-StoreDag.ipynb @@ -0,0 +1,571 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "14b14fd2", + "metadata": {}, + "source": [ + "# Symmetriske matricer\n", + "\n", + "Demo af Christian Mikkelstrup, Hans Henrik Hermansen og Jakob Lemvig" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aad4b143", + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "cell_type": "markdown", + "id": "1a37dcc0", + "metadata": {}, + "source": [ + "I denne demo gennemgåes eksempler der udregner og benytter ortonormale baser, samt diagonalisering af en symmetriske matrix ved ortogonal substitution." + ] + }, + { + "cell_type": "markdown", + "id": "0e7c596c", + "metadata": {}, + "source": [ + "## Ortonormale baser\n", + "\n", + "I de følgende tre eksempler benyttes tre vektorer $u_1,u_2,u_3\\in \\mathbb{R}^4$," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1ec4a432", + "metadata": {}, + "outputs": [], + "source": [ + "u_1 = Matrix([1,1,1,1])\n", + "u_2 = Matrix([1,0,1,0])\n", + "u_3 = Matrix([1,0,0,1])\n", + "u_1, u_2, u_3" + ] + }, + { + "cell_type": "markdown", + "id": "1fd990e7", + "metadata": {}, + "source": [ + "### Eksempel 1\n", + "\n", + "I dette eksempel udregner vi længden af og vinkler mellem vektorer. Først længden af de tre vektorer:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fe38fd6e", + "metadata": {}, + "outputs": [], + "source": [ + "display(u_1.norm(), u_2.norm(), u_3.norm())" + ] + }, + { + "cell_type": "markdown", + "id": "c9e15602", + "metadata": {}, + "source": [ + "Vinkler mellem vektorer blev allerede præsenteret i Demo'en fra lille dag, uge 6. Dog, da vi skal gøre det mange gange, kan vi definere vores egen funktion:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e554dee4", + "metadata": {}, + "outputs": [], + "source": [ + "def angle(u_1, u_2):\n", + " cos_to_v = (u_1.dot(u_2))/(u_1.norm()*u_2.norm())\n", + " return acos(cos_to_v)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4d7fc403", + "metadata": {}, + "outputs": [], + "source": [ + "# vinkel mellem u_1 og u_2\n", + "angle(u_1,u_2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3f22ed99", + "metadata": {}, + "outputs": [], + "source": [ + "# vinkel mellem u_2 og u_3\n", + "angle(u_2,u_3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b19a8657", + "metadata": {}, + "outputs": [], + "source": [ + "# vinkel mellem u_3 og u_1\n", + "angle(u_3,u_1)" + ] + }, + { + "cell_type": "markdown", + "id": "6678b63d", + "metadata": {}, + "source": [ + "### Eksempel 2\n", + "\n", + "I dette eksempel finder vi en ortonormal basis for underrummet udspændt af $u_1, u_2$ og $u_3$, altså for $U=\\text{span}\\{u_1, u_2, u_3\\}$.\n", + "\n", + "Vi kan således beskrive koordinatmatricen for vektorene med hensyn til den sædvanlige basis som," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cd96f608", + "metadata": {}, + "outputs": [], + "source": [ + "eU = Matrix([[1,1,1],[1,0,0],[1,1,0],[1,0,1]])\n", + "eU" + ] + }, + { + "cell_type": "markdown", + "id": "bc6f35f6", + "metadata": {}, + "source": [ + "Hvor rangen af $_eU$ findes til" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "08567dff", + "metadata": {}, + "outputs": [], + "source": [ + "eU.rank()" + ] + }, + { + "cell_type": "markdown", + "id": "a13706c7", + "metadata": {}, + "source": [ + "Vi kan altså sige, at de tre vektorer er lineært uafhængige, og derved kan bruges som basis for $U$. " + ] + }, + { + "cell_type": "markdown", + "id": "0efdfe0c", + "metadata": {}, + "source": [ + "En **ortonormal basis** for underrummet U findes ved brug af **Gram-Schmidt** metoden. Her vises den ved simuleret håndregning," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7a7502ab", + "metadata": {}, + "outputs": [], + "source": [ + "v_1 = u_1/u_1.norm()\n", + "v_1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b96f4a42", + "metadata": {}, + "outputs": [], + "source": [ + "w_2 = u_2 - u_2.dot(v_1)*v_1\n", + "v_2 = w_2/w_2.norm()\n", + "v_2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b7cd2536", + "metadata": {}, + "outputs": [], + "source": [ + "w_3 = u_3 - u_3.dot(v_1)*v_1 - u_3.dot(v_2)*v_2\n", + "v_3 = w_3/w_3.norm()\n", + "v_3" + ] + }, + { + "cell_type": "markdown", + "id": "69e9c289", + "metadata": {}, + "source": [ + "Hvorved vi har vores basis bestående af $v_1$, $v_2$ og $v_3$.\n", + "\n", + "Denne basis kan også fåes direkte med den indbyggede funktion," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ff0308ff", + "metadata": {}, + "outputs": [], + "source": [ + "GramSchmidt([u_1, u_2, u_3], orthonormal=True)" + ] + }, + { + "cell_type": "markdown", + "id": "aee7819a", + "metadata": {}, + "source": [ + "### Eksempel 3\n", + "\n", + "Her følger et eksempel på en ortonormal basis i $\\mathbb{R}^3$. Vi får givet to vektorer, som er ortogonale og som har længden $1$," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9efc8a8f", + "metadata": {}, + "outputs": [], + "source": [ + "v_1 = Matrix([1,2,-2])/S(3)\n", + "v_2 = Matrix([2,1,2])/S(3)\n", + "v_1,v_2" + ] + }, + { + "cell_type": "markdown", + "id": "fb6b41e5", + "metadata": {}, + "source": [ + "Den tredje vektor findes ved krydsproduktet," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dc6d7b21", + "metadata": {}, + "outputs": [], + "source": [ + "v_3 = v_1.cross(v_2)" + ] + }, + { + "cell_type": "markdown", + "id": "a543901b", + "metadata": {}, + "source": [ + "Nu må det altså gælde, at $(v_1, v_2, v_3)$ udgør en en ortonormal basis for $\\mathbb{R}^3$. \n", + "\n", + "Koordinatmatricen $V$ for de tre vektorer er et eksempel på en ortogonal matrix," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9cb9d3a5", + "metadata": {}, + "outputs": [], + "source": [ + "V = Matrix.hstack(v_1, v_2, v_3)\n", + "V" + ] + }, + { + "cell_type": "markdown", + "id": "0899270f", + "metadata": {}, + "source": [ + "Dette kan eftertjekkes ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23601557", + "metadata": {}, + "outputs": [], + "source": [ + "V.T * V" + ] + }, + { + "cell_type": "markdown", + "id": "bc93e74a", + "metadata": {}, + "source": [ + "Når en ortonormal basis i $\\mathbb{R}^3$ er fremskaffet ved krydsproduktet, er koordinatmatricen positiv ortogonal. Altså har den valgte basis den **sædvanlige orientering**. Dette eftertjekkes ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db5e6485", + "metadata": {}, + "outputs": [], + "source": [ + "det(V)" + ] + }, + { + "cell_type": "markdown", + "id": "dd14ae58", + "metadata": {}, + "source": [ + "som forventet." + ] + }, + { + "cell_type": "markdown", + "id": "8a5a6ffb", + "metadata": {}, + "source": [ + "# Diagonalisering af en symmetrisk matrix ved ortogonal substitution\n", + "\n", + "Den symmetriske matrix $A$ er givet ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c43ae7ec", + "metadata": {}, + "outputs": [], + "source": [ + "A = Matrix([[6,2,4],[2,9,-2],[4,-2,6]])\n", + "A" + ] + }, + { + "cell_type": "markdown", + "id": "3235b1b8", + "metadata": {}, + "source": [ + "Vi vil bestemme en positiv ortogonal matrix $Q$ og en diagonalmatrix $\\Lambda$ så $Q^\\top\\, A\\, Q = \\Lambda$.\n", + "\n", + "Vi starter med at finde 3 lineært uafhængige egenvektorer vha. SymPy:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65870bcf", + "metadata": {}, + "outputs": [], + "source": [ + "A.eigenvects()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "31db740e", + "metadata": {}, + "outputs": [], + "source": [ + "u_1 = Matrix([-1,Rational(1,2),1])\n", + "u_2 = Matrix([Rational(1,2),1,0])\n", + "u_3 = Matrix([1,0,1])" + ] + }, + { + "cell_type": "markdown", + "id": "0014f5ec", + "metadata": {}, + "source": [ + "Eller i et \"go\" uden at skulle skrive $u$-vektorerne ind manuelt:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "789ade26", + "metadata": {}, + "outputs": [], + "source": [ + "U, Lamda = A.diagonalize()\n", + "[u_1,u_2,u_3] = [U.col(k) for k in range(3)] # hver søjle i U tilgås og gemmes som vektor\n", + "[u_1,u_2,u_3]" + ] + }, + { + "cell_type": "markdown", + "id": "4231d98d", + "metadata": {}, + "source": [ + "Nu kan vi bruge den indbyggede metode til at (eller håndregning som vist højere oppe) til at finde den ortonormale basis. Vi finder:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b316d2aa", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "v_1 = u_1.normalized()\n", + "v_2, v_3 = GramSchmidt([u_2,u_3], orthonormal=True)\n", + "Q = Matrix.hstack(v_1,v_2,v_3)\n", + "Q" + ] + }, + { + "cell_type": "markdown", + "id": "f9ae3c78", + "metadata": {}, + "source": [ + "Bemærk at vi kører Gram-Schmidt på hhv. den ene vektor $u_1$ og bagefter på de to vektorer $u_2, u_3$. Kommandoen `v_1,v_2, v_3 = GramSchmidt([u_1,u_2,u_3], orthonormal=True)` giver det samme (hvorfor?).\n", + "\n", + "Vi kan undersøge om $Q$ er positiv ortogonal ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a029d44", + "metadata": {}, + "outputs": [], + "source": [ + "det(Q)" + ] + }, + { + "cell_type": "markdown", + "id": "d17febf7", + "metadata": {}, + "source": [ + "Det er den ikke. Dog kan dette fixes ved at skifte fortegn på én af de tre $v$-vektorer," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9c721543", + "metadata": {}, + "outputs": [], + "source": [ + "Q = Matrix.hstack(v_1, v_2, -v_3)\n", + "Q" + ] + }, + { + "cell_type": "markdown", + "id": "011c09f8", + "metadata": {}, + "source": [ + "Vi tjekker at den opdaterede $Q$-matrix er positiv ortogonal: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e134d725", + "metadata": {}, + "outputs": [], + "source": [ + "det(Q)" + ] + }, + { + "cell_type": "markdown", + "id": "8ae5f018", + "metadata": {}, + "source": [ + "Rækkefølgen af egenværdierne i diagonalmatricen $\\Lambda$ er bestemt af rækkefølgen af egenvektorer, som vi valgte. Den er lig $U^T A U$ og givet ved: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a80ad5e1", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "Lamda" + ] + }, + { + "cell_type": "markdown", + "id": "d2f01d15", + "metadata": {}, + "source": [ + "Lad os tjekke at Gram-Schmidt ikke har ændret ved $\\Lambda$. Vi skriver:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "524e7c71", + "metadata": {}, + "outputs": [], + "source": [ + "Lamda == Q.T*A*Q" + ] + }, + { + "cell_type": "markdown", + "id": "695ebb02", + "metadata": {}, + "source": [ + "Som forventet er $\\Lambda = U^T A U = Q^T A Q$. Bemærk at dette \"Gram-Schmidt\"-trick ikke skal bruges for matricer der opfyder $AA^T \\neq A^TA$, da der altid vil gælde $\\Lambda = U^T A U \\neq Q^T A Q$." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "language": "python", + "name": "mat1-pilot" + }, + "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.6" + }, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Demos/Demo-E-Uge-12-StoreDag.ipynb b/Demos/Demo-E-Uge-12-StoreDag.ipynb new file mode 100644 index 0000000..0f448b6 --- /dev/null +++ b/Demos/Demo-E-Uge-12-StoreDag.ipynb @@ -0,0 +1,331 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Differentialligningssystemer\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Homogene systemer af første ordens lineære diff-ligninger\n", + "\n", + "## 1. Systemmatricen har to reelle egenværdier\n", + "Givet differentialligningsystemet\n", + "\n", + "\\begin{gather*}\n", + " \\frac{\\text{d}}{\\text{d}t}x_1(t) = 5x_1(t) - 3x_2(t)\\\\\n", + " \\frac{\\text{d}}{\\text{d}t}x_2(t) = 6x_1(t) - 4x_2(t)\n", + "\\end{gather*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### a. Simuleret håndregning via diagonaliseringsmetoden\n", + "Først løser vi systemet i hånden vha. diagonaliseringsmetoden, dvs. vi opstiller og analyserer systemmatricen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "t,C1,C2 = symbols(\"t C1:3\")\n", + "A = Matrix([[5,-3],[6,-4]])\n", + "ev = A.eigenvects()\n", + "res = C1 * E ** (ev[0][0]*t) * ev[0][2][0] + C2 * E ** (ev[1][0]*t) * ev[1][2][0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Løsningen $[x_1(t), x_2(t)]^T$ er altså givet ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "res" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "hvor $C_1, C_2$ er arbitrære reelle eller komplekse konstanter$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### b. via dsolve\n", + "Vi kan også finde løsningen direkte med dsolve" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x1 = Function(\"x1\")\n", + "x2 = Function(\"x2\")\n", + "eq1 = Eq(diff(x1(t),t),5 * x1(t) - 3 * x2(t))\n", + "eq2 = Eq(diff(x2(t),t),6*x1(t) - 4*x2(t))\n", + "#\n", + "dsolve([eq1, eq2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Systemmatricen har to komplekse egenværdier\n", + "Givet differentialligningssystemet\n", + "\\begin{gather*}\n", + " \\frac{\\text{d}}{\\text{d}t}x_1(t) = 2x_1(t) + 2x_2(t)\\\\\n", + " \\frac{\\text{d}}{\\text{d}t}x_2(t) = -x_1(t) + 4x_2(t)\n", + "\\end{gather*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## a. Simuleret håndregning\n", + "Fremgangsmåden her er den samme." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "A = Matrix([[2,2],[-1,4]])\n", + "ev = A.eigenvects()\n", + "res = C1 * E ** (ev[0][0]*t) * ev[0][2][0] + C2 * E ** (ev[1][0]*t) * ev[1][2][0]\n", + "res" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "hvor $C_1, C_2 \\in \\mathbb{C}$ hvis vi er ude efter den fuldstændige komplekse løsning." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu finder vi også den fuldstændige reelle løsning vha. metode 17.5" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "D1,D2 = symbols(\"D1:3\")\n", + "a = re(ev[0][0])\n", + "b = im(ev[0][0])\n", + "re_ev = re(ev[0][2][0])\n", + "im_ev = im(ev[0][2][0])\n", + "u1 = E ** (a * t) * (cos(b * t) * re_ev - sin(b * t) * im_ev)\n", + "u2 = E ** (a * t) * (sin(b * t) * re_ev + cos(b * t) * im_ev)\n", + "D1 * u1 + D2 * u2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "hvor $D_1, D_2 \\in \\mathbb{R}$. Bemærk at hvis vi i stedet skriver \"hvor $D_1, D_2 \\in \\mathbb{C}$\" fås fuldstændige komplekse løsning. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### b. Med dsovle" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "eq1 = Eq(diff(x1(t),t),2*x1(t) + 2*x2(t))\n", + "eq2 = Eq(diff(x2(t),t),-x1(t) + 4*x2(t))\n", + "\n", + "dsolve([eq1, eq2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Selvom løsningerne er lidt forskellige ud, så giver de anledning til samme fuldstændige løsningsmængde. For at indse dette skal vi blot sætte $D_1 = C_2$ og $D_1 = C_2$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Betinget løsning med plot\n", + "Lad os se på systemet fra eksempel 1 igen.\n", + "\\begin{gather*}\n", + " \\frac{\\text{d}}{\\text{d}t}x_1(t) = 5x_1(t) - 3x_2(t)\\\\\n", + " \\frac{\\text{d}}{\\text{d}t}x_2(t) = 6x_2(t) - 4x_2(t)\n", + "\\end{gather*}\n", + "\n", + "Vi kom frem til den fuldstændige løsning\n", + "\\begin{gather*}\n", + " \\begin{bmatrix} x_1(t) \\\\ x_2(t) \\end{bmatrix} = C_1 e^{-t} \\begin{bmatrix}1 \\\\ 2\\end{bmatrix} + C_2 e^{2t} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix}\n", + "\\end{gather*}\n", + "\n", + "Lad os finde et $C_1$ og $C_2$, der medfører at $x_1(0) = 2$ og $x_2(0) = 3$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### a. Simuleret håndregning\n", + "Først finder vi lige løsningen igen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "t,C1,C2 = symbols(\"t C1:3\")\n", + "A = Matrix([[5,-3],[6,-4]])\n", + "ev = A.eigenvects()\n", + "fuld = C1 * E ** (ev[0][0]*t) * ev[0][2][0] + C2 * E ** (ev[1][0]*t) * ev[1][2][0]\n", + "x1_fuld, x2_fuld = fuld[0],fuld[1]\n", + "x1_fuld, x2_fuld" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi sætter $t=0$ i løsningerne og bruger begyndelsesbetingelsen $x_1(0) = 2$ og $x_2(0) = 3$, hvilket giver ligningerne:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "display(Eq(x1_fuld.subs(t,0),2),Eq(x2_fuld.subs(t,0),3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Dette løses let, fx ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "solve([Eq(x1_fuld.subs(t,0),2),Eq(x2_fuld.subs(t,0),3)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kunne også gøre dette direkte med $\\text{dsolve}$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "eq1 = Eq(diff(x1(t),t),5 * x1(t) - 3 * x2(t))\n", + "eq2 = Eq(diff(x2(t),t),6*x1(t) - 4*x2(t))\n", + "\n", + "dsolve([eq1, eq2],ics={x1(0) : 2, x2(0) : 3})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu, hvor vi har fundet $c_1$ og $c_2$, kan vi plotte vores løsning." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot(x1_fuld.subs([(C1,2),(C2,1)]),x2_fuld.subs([(C1,2),(C2,1)]),xlim=(-1,1),ylim=(0,8),legend=True)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.6" + }, + "vscode": { + "interpreter": { + "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-E-Uge-13-Hookes-lov.ipynb b/Demos/Demo-E-Uge-13-Hookes-lov.ipynb new file mode 100644 index 0000000..0c8c9e9 --- /dev/null +++ b/Demos/Demo-E-Uge-13-Hookes-lov.ipynb @@ -0,0 +1,325 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Andenordens lineære differentialligninger med konstante koefficienter" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()\n", + "t = symbols('t', real=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Figur 1: \n", + "\n", + "Figur 2: \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "En vogn er på fig.1 fastgjort til muren med en fjeder. Fjederen er i sin hvilestilling, så vognen holder stille og roligt ved $x = 0$. Til et bestemt tidspunkt $t$ er vognen bragt ud til positionen $x(t)$ mod højre, se fig.2. Den er da i følge Hooke's lov påvirket af en kraft mod venstre af størrelsen $F = -k x(t)$, hvor $k$ er en (positiv) konstant som angiver fjederens stivhed. Jo længere mod højre vognen er placeret, desto mere trækker fjederen altså i den mod venstre. Og når vi slipper den, begynder den at køre! Vi vil gerne beskrive vognens bevægelse, det vil sige bestemme dens placering $x(t)$ til tiden $t$. Vi er nødt til at gå indirekte frem. Det viser sig at vi kan opstille et udtryk for bevægelsens acceleration - og det kan vi arbejde videre med." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Opgave 1\n", + "## a)\n", + "I følge Newtons anden lov er den kraft der påvirker vognen, lig med vognens masse $M$ gange dens acceleration. Opstil en ligning som kæder accelerationen sammen med stedfunktionen $x(t)$ ved at udfylde `XX` i den følgende kommando:\n", + "\n", + "```\n", + "x = Function(\"x\")\n", + "k, M = symbols('k, M', positive=True)\n", + "diff_lign1 = Eq(diff(x(t),t,t), XX * x(t))\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Løsning a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi har fra Newton og Hooke to forskellige udtryk for den resulterende kraft $F$, nemlig:\n", + "$$ F = M a(t) \\quad \\text{og} \\quad M a(t) = -k x(t)$$\n", + "og da accelerationen er den anden afledede af stedfunktionen, får vi" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = Function(\"x\")\n", + "k, M = symbols('k, M', positive=True)\n", + "diff_lign1 = Eq(diff(x(t),t,t), -(k/M) * x(t))\n", + "diff_lign1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Det er nu lykkedes os at opstille en andenordens differentialligning, hvori stedfunktionen optræder som ukendt funktion. Vi må forvente at vognen vil køre frem og tilbage, henover $x = 0$. Men hvad betyder egentlig fjederens stivhed $k$ for svingningens hastighed? Dette spørgsmål nærmer vi os i det følgende.\n", + "\n", + "I det følgende sætter vi som eksempel vognens masse til $M=1$. \n", + "\n", + "## b) \n", + "Find et foreløbigt udtryk for $x(t)$ vha. `dsolve`. Hvor mange yderligere oplysninger (begyndelsesbetingelser) skal vi bruge for endeligt at fastlægge $x(t)$, når vi forudsætter at $k$ er kendt?\n", + "\n", + "## c) \n", + "Antag at en fotooptagelse viser at vognen til tiden t = 0 var ved stedet $x=1$, og til tiden $t = 1$ ved stedet $x=5$, og plot på den baggrund $x(t)$ for henholdsvis $k=1, 2, 3$. Kommentér plottet." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Løsning b)+c)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fuld_sol1 = dsolve(diff_lign1.subs(M,1))\n", + "fuld_sol1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I den fuldstændige løsning optræder der to ukendte konstanter $C_1$ og $C_2$. Vi har derfor brug for to begyndelsesbetingelser, hvis vi forudsætter $k$ kendt. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "part_sol1 = dsolve(diff_lign1.subs(M,1),ics = {x(0) : 1, x(1) : 5}).rhs\n", + "part_sol1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p1 = plot(part_sol1.subs(k,1),(t,0,10), show=False, xlabel='t', ylabel='x(t)', legend=True)\n", + "p1[0].label = 'k=1'\n", + "p2 = plot(part_sol1.subs(k,2),(t,0,10), show=False)\n", + "p2[0].label = 'k=2'\n", + "p3 = plot(part_sol1.subs(k,3),(t,0,10), show=False)\n", + "p3[0].label = 'k=3'\n", + "p1.append(p2[0])\n", + "p1.append(p3[0])\n", + "p1.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi bemærker at alle tre grafer, som forventet, opfylder begyndelsesbetingelserne idet de passerer $(0,1)$ og $(1, 5)$. Og vi ser at desto *stivere* fjederen er, desto *hurtigere* kører vognen frem og tilbage.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Opgave 2\n", + "Nu gør vi model-situationen lidt mere realistisk. Der er selvfølgelig en vis modstand mod bevægelsen som skyldes vindmodstand, knirken i vognens hjul mv. Det er oplagt at forvente at denne gnidningsmodstand afhænger af hastigheden: desto større hastigheden er, desto større er modstanden imod bevægelsen. Vi antager enkelt at modstandskraften kan skrives som $-n$ ganget med hastigheden, hvor $n$ er et positivt tal der angiver gnidningsbetingelserne. Mon vognen stadig vil køre frem og tilbage, eller vil svingningen ophøre hvis $n$ er tilstrækkelig stor? Dette spørgsmål nærmer vi os i det følgende." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# d)\n", + "Angiv den samlede kraft F der nu virker på vognen i fig.2, og opstil den andenordens differentialligning der sammenfatter situationen." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Løsning d)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n = symbols('n', positive=True)\n", + "diff_lign2 = Eq(diff(x(t),t,t), -k/M*x(t)-n/M*diff(x(t),t))\n", + "diff_lign2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I det følgende sætter vi som eksempel fjederens stivhed til $k=1$ (og stadig $M=1$). Lad os undersøge om vi stadig med to begyndelsesbetingelser kan opnå en endelig løsning på det nye bevægelsesproblem. En videooptagelse viser at vognen til tiden t = 0 var ved stedet $x=0$, og at dens hastighed til tiden $t = 0$ var $1$. Den fuldstændige løsning er:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "diff_lign2 = diff_lign2.subs(M,1).subs(k,1)\n", + "fuld_sol1 = dsolve(diff_lign2)\n", + "fuld_sol1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi bemærker at $\\sqrt{n-2}$ optræder i løsningen. Vi må derfor forvente at løsningsformen ændrer sig ved $n=2$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# e) \n", + "Find den partikulære løsningen $x(t)$ for henholdvis $n=1,2,3$. \n", + "# f)\n", + "Plot de tre løsninger og kommentér plottet.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Løsning e)+f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Da vi i d) så at løsningen ændrer form ved $n=2$, må vi hellere løse differentialligningen for hver af de 3 $n$-værdier. For $n=1$ bliver det til: \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dsolve(diff_lign2.subs(n,1), ics = {x(0) : 0, diff(x(t),t).subs(t,0) : 1})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi bruger en ´for´-løkke for de tre tilfælde; alternativt kan man bare bruge ovenstående `dsolve`-kommando 3 gange. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "part_sol2 = []\n", + "for nn in [1,2,3]:\n", + " part_sol2.append(dsolve(diff_lign2.subs(n,nn), ics = {x(0) : 0, diff(x(t),t).subs(t,0) : 1}).rhs)\n", + " \n", + "print('De tre løsninger:') \n", + "part_sol2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p1 = plot(part_sol2[0],(t,0,10), show=False, xlabel='t', ylabel='x(t)', legend=True)\n", + "p1[0].label = 'n=1'\n", + "p2 = plot(part_sol2[1],(t,0,10), show=False)\n", + "p2[0].label = 'n=2'\n", + "p3 = plot(part_sol2[2],(t,0,10), show=False)\n", + "p3[0].label = 'n=3'\n", + "p1.append(p2[0])\n", + "p1.append(p3[0])\n", + "p1.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Det er kun i tilfældet $n = 1$ at vognen, efter en tur ude på vejens højre side, passerer $x = 0$ og derfor udfører egentlige svingninger pga. $\\sin$ i funktionsudstrykket. Men svingningen dæmpes, og i ingen af de tre tilfælde går der lang tid før at vognen (næsten) står stille ved $x=0$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 ('mat1-pilot': venv)", + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-E-Uge-13-StoreDag.ipynb b/Demos/Demo-E-Uge-13-StoreDag.ipynb new file mode 100644 index 0000000..3353e3d --- /dev/null +++ b/Demos/Demo-E-Uge-13-StoreDag.ipynb @@ -0,0 +1,238 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2. ordens lineære differentialligning med konst. koefficenter \n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi betragter følgende differentialliging\n", + "\\begin{equation*}\n", + " \\frac{\\text{d}^2}{\\text{d}t^2}x(t) - 3\\frac{\\text{d}}{\\text{d}t}x(t) + 2x(t) = \\cos(2t)\n", + "\\end{equation*}\n", + "og ønsker at finde **reelle** løsninger. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Simuleret håndregning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### a. Undersøgelse af den tilsvarende homogene ligning\n", + "Først finder vi løsningen til den homogene ligning. Dette gøres ved at løse karakterligningen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "l, C1, C2 = symbols(\"l C1:3\")\n", + "solve(l ** 2 - 3 * l + 2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Så den homogene del af løsninger er\n", + "\\begin{equation*}\n", + " C_1 e^{2t} + C_2 e^{t}\n", + "\\end{equation*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "hvor $C_1,C_2 \\in \\mathbb{R}$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### b. Undersøgelse af den inhomogene ligning\n", + "Her bruger vi gættemetoden. Vi kan se at højresiden har formen $\\cos(2t)$. Derfor gætter vi på en løsning på formen $a \\sin(2t) + b \\cos(2t)$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a,b,t = symbols(\"a b t\")\n", + "gæt = a * sin(2*t) + b * cos(2*t)\n", + "eq_gæt = Eq(simplify(diff(gæt,t,t) - 3 * diff(gæt,t) + 2 * gæt),cos(2*t))\n", + "eq_gæt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ligningen skal gælde for alle værdier af $t$. Ved at sætte $t=0$ fås $-6a-2b = 1$. Ved at sætte $t=\\pi/4$ fås, da $\\sin(\\pi/2)=1$ og $\\cos(\\pi/2)=0$ fås $-2a+6b = 0$. Det ses let i SymPy:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "eq_gæt.subs(t,0), eq_gæt.subs(t,pi/4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "og løsningen er:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ab_val = solve([eq_gæt.subs(t,0), eq_gæt.subs(t,pi/4)])\n", + "ab_val" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi mangler at tjekke at disse valg af $a$ og $b$ opfylder $−2a \\sin(2t)−6a\\cos(2t)+6b\\sin(2t)−2b\\cos(2t)=cos(2t)$ for alle $t$. Det kan gøres ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "eq_gæt.subs(ab_val)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Deraf ender vi med en fuldstændig løsning\n", + "\\begin{equation*}\n", + " x(t) = C_1 e^{2t} + C_2 e^t - \\frac{3}{20}\\sin(2t) - \\frac{1}{20}\\cos(2t),\n", + "\\end{equation*}\n", + "hvor $C_1,C_2 \\in \\mathbb{R}$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### c. En ønsket partikulær løsning\n", + "Nu er vi interesserede i at finde en løsning med begyndelsesbetingelserne $x(0) = 0$ og $x'(0) = 1$.\n", + "Dette gør vi ved løse to ligninger efter $C_1$ og $C_2$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x_fuld = C1 * E ** (2*t) + C2 * E ** t - 3/20 * sin(2*t) - 1/20 * cos(2*t)\n", + "solve([Eq(x_fuld.subs(t,0),0),Eq(diff(x_fuld,t).subs(t,0),1)]) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot(x_fuld.subs([(C1,1.25),(C2,-1.2)]),xlim = (-1,1), ylim = (-1,2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Med dsolve\n", + "Nu finder vi samme løsning med $\\text{dsolve}$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = Function(\"x\")\n", + "res = dsolve(Eq(diff(x(t),t,t) - 3*diff(x(t),t) + 2 * x(t),cos(2*t)),ics = {x(0) : 0, diff(x(t),t).subs(t,0) : 1})\n", + "res" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot(res.rhs,xlim = (-1,1),ylim = (-1,2))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 ('mat1-pilot': venv)", + "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.6" + }, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-E-Uge-4-StoreDag.ipynb b/Demos/Demo-E-Uge-4-StoreDag.ipynb new file mode 100644 index 0000000..4904188 --- /dev/null +++ b/Demos/Demo-E-Uge-4-StoreDag.ipynb @@ -0,0 +1,710 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Komplekse tal\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Den imaginære enhed\n", + "\n", + "Når den imaginære enhed skal benyttes i SymPy er det vigtigt at huske,at man ikke bare kan bruge \n", + "*i*, men man er nødt til at bruge *I*. Dette skyldes, at vi i python meget gerne vil have adgang til bogstavet *i* til andre ting. F.eks. bruges *i* meget ofte, når der bruges loops i python. Lad os prøve at skrive nedenstående i python\n", + "\n", + "\\begin{gather}\n", + " 3 + 2i\n", + "\\end{gather}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "try:\n", + " 3 + 2*i\n", + "except:\n", + " print(\"i virker ikke\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Man skal skrive:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "3 + 2*I" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lad os se på selve fejlmeddelelsen, når vi skriver `3 + 2*i`. Python giver en NameError, hvilket giver god mening, da `i` ikke er defineret." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "3 + 2*I # Ingen fejl, I er defineret i SymPy\n", + "3 + E # Ingen fejl, E er defineret i SymPy\n", + "3 + 2*i # i er ikke defineret" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Som vi kan se, så får vi det rigtige, når vi bruger *I*, men python giver os en fejl, når vi bruger *i*." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Rektangulær form\n", + "SymPy vil forsimple komplekse udtryk den får en smule." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "(2*I+3)*2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Her ser vi at $(2i + 3)\\,2$ bliver til $6+4i$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "SymPy vil også sørge for at komplekse brøker ikke har nogen imaginær værdi i nævneren." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "(3+2*I)/(5+I)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Kommandoen **simplify** benyttes for at få udtrykket på den klassiske rektangulære form." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "simplify((3+2*I)/(5+I))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "SymPy kan også hjælpe os med at finde de realle og imaginære dele af komlpekse tal." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "z = (3+2*I) / (5+I)\n", + "re(z), im(z)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternativt, kan vi benytte den indbyggede metode:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "z.as_real_imag()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternativt, kan vi benytte den indbyggede metode:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "z.as_real_imag()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Absolutværdi (Længde) og Argument (Vinkel)\n", + "Vi kan også nemt finde absolutværdien og argumentet af et komplekst tal" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "z = 1 - sqrt(3)*I\n", + "abs(z), arg(z)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Eksponential form\n", + "Når vi skriver et komplekst tal på eksponentiel form, så laver SymPy det ikke om til rektangulær from for os" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "z = exp(ln(2) + pi/4 * I)\n", + "z" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Bemærk at den komplekse eksponentialfunktion kan skrives på to måder i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = symbols(\"x\")\n", + "exp(x) == E ** x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan få SymPy til at sætte det på vores velkendte rektangulære form for os ved at bruge argumentet og absolutværdien, eller reeldelen og imaginærdelen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "abs(z) * (cos(arg(z)) + sin(arg(z)) * I), re(z) + im(z)*I\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan også gå fra rektangulær på lignende vis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "z = 3 + 3*I\n", + "z, exp(ln(abs(z))+arg(z)*I), abs(z)*exp(arg(z)*I)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Konjugering\n", + "Vi kan nemt konjegere komplekse tal med SymPy" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "z = 3 + 3*I\n", + "conjugate(z)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ligninger\n", + "Vi vil også meget gerne kunne løse ligninger med komplekse tal. Det kan SymPy heldigvis også." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = symbols(\"x\")\n", + "solveset(x**2 + 1,x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lign1 = Eq(x**2,-1)\n", + "solveset(lign1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting af komplekse punktmængder\n", + "SymPy kan også plotte komplekse punktmængder for os. Vi vil gerne udforske punkterne, der opfylder $|z -5 + 2i| = 3$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "try:\n", + " z = symbols(\"z\")\n", + " lign = Eq(abs(z - 5 + 2*I),3)\n", + " plot_implicit(lign)\n", + "except Exception:\n", + " print(\"Noget gik galt\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Her kan vi se at SymPy ikke lykkedes med at plotte vores punkter. Dette skyldes at SymPy's funktion `plot_implicit()` ikke kan håndtere en kompleks variabel, så vi bliver nødt til at hjælpe den lidt på vej." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x,y = symbols(\"x y\", real = True)\n", + "z = x + I *y\n", + "lign = Eq(abs(z -5 + 2*I),3)\n", + "plot_implicit(lign)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Her gik det noget bedre. Vi opretter to variabler $x$ og $y$, som vi definirer til at være realle, og så konstruerer vi $z$ ud fra $x$ og $y$. Dette er nødvendigt, da Sympy er nødt til at kende forholdet mellem $z$ og vores to akser. Og vores akser er *nødt* til at være realle.\n", + "\n", + "Vores plot er dog endnu ikke helt pænt, så vi tilføjer nogle grænser til vores symboler $x$ og $y$, så vi får et bedre udsnit af cirklen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x,y = symbols(\"x y\", real =True)\n", + "z = x + I*y\n", + "lign1 = Eq(abs(z - 5 + 2*I),3)\n", + "plot_implicit(lign1,(x,0,10),(y,-6,2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sådan! " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Taylor-udvidelser\n", + "\n", + "### Approksimering af funktioner via taylor-udvidelse\n", + "Vi vil gerne prøve at approksimere hhv. $\\ln(x)$ og $\\cos(x)$ via taylor-udvidelser og undersøge, hvordan dette påvirker plottet med approksimeringen og den originale funktion.\n", + "\n", + "Kommandoen for taylor-udvikling i SymPy er $\\text{series}$ og har følgende format: `series(funktion, variabel, x0, n)`\n", + "\n", + "Det er dog vigtigt at huske at antallet af led ($\\text{n}$) er én større end graden som beskrives i eNoterne." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = symbols(\"x\")\n", + "series(ln(x),x,1,7)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hvis vi ønsker et polynomium, vi kan evaluere for en given $x$-værdi, fx $x=2$, bliver vi nødt til at fjerne restleddet først:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "series(ln(x),x,1,7).removeO().subs(x,2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lad os plotte nogle Taylor-polynomier for $\\ln(x)$ med udvikling i $x_0=1$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pl = plot(ln(x),xlim = (0,2), ylim = (-2,1), show = False, legend = True)\n", + "for n in [1,2,5,10]:\n", + " newseries = series(ln(x),x,1,n).removeO()\n", + " newplot = plot(newseries, show = False, label = \"n = {}\".format(n))\n", + " pl.extend(newplot)\n", + "pl.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Her oprettes der først et plot med $\\text{show = False}$, for at vi med $\\text{.extend}$ kan tilføje de andre plots til samme plot.\n", + "Ud fra vores plot er det tydeligt at se, at når vi øger $n$, så bliver vores approksimation også bedre. Vi tjekker kort det samme for $\\cos(x)$, denne gang med $x_0 = 0$ " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pl = plot(cos(x),xlim = (-3,3), ylim = (-3,3), show=False, legend = True)\n", + "for i in [1,2,3,4,7]:\n", + " newseries = series(cos(x),x,0,i).removeO()\n", + " newplot = plot(newseries,label = \"n = {}\".format(i), show=False)\n", + " pl.extend(newplot)\n", + "pl.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Her kan vi se, at kun tre forskellige linjer er synlige. Dette skyldes, at når $n=1$ og $n=2$ har samme taylor udvikling. Det samme gælder for $n=3$ og $n=4$.\n", + "Det er nemmere at forstå, hvorfor dette er tilfældet, hvis man laver taylor udviklingen i hånden.\n", + "\n", + "\\begin{gather*}\n", + " t_{n=1} = \\cos(0) = 1\\\\\n", + " t_{n=2} = \\cos(0) + \\sin(0) = 1 + 0 = 1\n", + "\\end{gather*}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Vurdering af restfunktionen vha. Taylor's formel\n", + "Vi vil gerne forsøge at finde en tilnærmet værdi af $ln(\\frac{5}{4})$ vha. af det approksimerende polynomium $P_3(x)$ udviklet i punket $x_0=1$.\n", + "\n", + "Vi skal først bestemme $P_3(x)$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = symbols(\"x\")\n", + "P3 = series(ln(x),x,1,4).removeO()\n", + "val = P3.subs(x,Rational(5/4))\n", + "val, val.evalf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi ved udfra **Taylors formel** at der findes et $\\xi \\in ]1;\\frac{5}{4}[$ sådan at fejlen $R_3(\\frac{5}{4})$ kan skrives som:\n", + "\n", + "\\begin{equation*}\n", + " R_3(\\frac{5}{4}) = \\frac{D^{(4)}f(\\xi)}{4!}(\\frac{5}{4})\n", + "\\end{equation*}\n", + "\n", + "Her er skal vi først finde ud af hvilket tal i intervallet for $\\xi$ fører til den største fejl. Hvis vi approksimerer vores fejl med dette, kan vi være sikre på, at den reelle fejl er mindre. Vi bestemmer først ledet $D^{(4)}f(\\xi)$, da dette er det eneste led, der er afhængigt af $\\xi$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "xi = symbols(\"xi\")\n", + "diff(ln(x),x,4).subs(x,xi)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Her får vi resultatet $-\\frac{6}{\\xi^4}$. Nu skal vi blot analysere udtrykket for at finde ud af, hvilket $\\xi$ gør udtrykket størst. Vi kan i dette tilfælde se, at $\\xi$ står i nævneren, og derfor bliver udtrykket større, hvis $\\xi$ er mindre. I dette tilfælde betyder det, at vi bare skal vælge den mindste værdi muligt for $\\xi$, hvilket i dette tilfælde er 1. Nu kan foretage vores approksimation af fejlen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "R3 = abs(diff(ln(x),x,4).subs(x,1) * (5/4 - 1) ** 4 /(factorial(4)))\n", + "R3, [val - R3, val + R3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi har nu bestemt fejlen, og vi kan nu garantere, at den rigtige værdi af $\\ln(\\frac{5}{4})$ ligger i intervallet $]0.2229;0.2250[$.\n", + "Lad os sammenligne det med python's værdi (Der stadig er en approksimation)," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ln(5/4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Grænseværdier vha. Taylor's grænseformel\n", + "Vi vil nu benytte Taylor's grænseformel til at bestemme grænseværdien af forskellige udtryk. Dette ses oftest med brøker, hvor tælleren, nævneren eller begge indeholder udtryk, der ikke er nemme at arbejde med.\n", + "Måden vi får adgang til Taylor's grænseformel uden i SymPy er ved hjælp af funktionen $\\text{series}$, hvor vi undlader at bruge $\\text{.removeO()}$ efter. I e-Noterne bruges epsilon-funktioner, men SymPy bruger $O$-symbolet. Sammenhængen mellem disse er:\n", + "\\begin{equation*}\n", + " O(x^{n}) = \\epsilon(x) \\cdot x^n\n", + "\\end{equation*} " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Eksempel 1\n", + "Vi vil først undersøge udtrykket $\\frac{\\sin(x)}{x}$ når $x\\rightarrow 0$," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "series(sin(x),x,0,n=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Dette giver os\n", + "\\begin{gather*}\n", + " \\frac{\\sin(x)}{x} = \\frac{x + \\epsilon (x) \\cdot x^2}{x} = 1 + \\epsilon (x)x \\rightarrow 1, \\text{ når } x \\rightarrow 0\n", + "\\end{gather*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Eksempel 2\n", + "\n", + "Det kan nogle gange være noget gætværk at finde ud af, hvor mange led, man er nødt til at tage med, når man skal finde en grænseværdi med Taylor's grænseformel. Lad os f.eks. prøve $\\frac{e^x - e^{-x} - 2x}{x-\\sin(x)}$, hvor $x \\rightarrow 0$. Lad os evaluere tælleren og nævneren hver for sig, og se hvad der sker, når vi inkluderer flere og flere led." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "T = exp(x) - exp(-x) - 2*x\n", + "N = x - sin(x)\n", + "series(T,x,0,2),series(N,x,0,2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For upræcist, da vi kun får restledet med" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "series(T,x,0,3),series(N,x,0,3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Stadig for upræcist" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "series(T,x,0,4),series(N,x,0,4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Her er noget, hvor begge udtryk har noget brugbart. Her får vi:\n", + "\n", + "\\begin{gather*}\n", + " \\frac{\\frac{x^3}{3}+\\epsilon(x)x^4}{\\frac{x^3}{6}+\\epsilon(x)x^4} = \\\\\n", + " \\frac{\\frac{1}{3} + \\epsilon(x)}{\\frac{1}{6}+\\epsilon(x)} \\rightarrow \\frac{\\frac{1}{3}}{\\frac{1}{6}} = 2, \\text{ når } x \\rightarrow 0\n", + "\\end{gather*}\n", + "\n", + "Som kontrol kan vi bruge $\\text{limit()}$ funktionen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "limit(T/N,x,0)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.6" + }, + "vscode": { + "interpreter": { + "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-E-Uge-5-LilleDag.ipynb b/Demos/Demo-E-Uge-5-LilleDag.ipynb new file mode 100644 index 0000000..17769c3 --- /dev/null +++ b/Demos/Demo-E-Uge-5-LilleDag.ipynb @@ -0,0 +1,850 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6c796744", + "metadata": {}, + "source": [ + "# Kvadratiske matricer\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d2f1a6fe", + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "38832aaa", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}1 & -3\\\\0 & 2\\end{matrix}\\right], \\ \\left[\\begin{matrix}-7 & -4\\\\6 & 2\\end{matrix}\\right]\\right)$" + ], + "text/plain": [ + "⎛⎡1 -3⎤ ⎡-7 -4⎤⎞\n", + "⎜⎢ ⎥, ⎢ ⎥⎟\n", + "⎝⎣0 2 ⎦ ⎣6 2 ⎦⎠" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A = Matrix([[1,-3],[0,2]])\n", + "B = Matrix([[-7,-4],[6,2]])\n", + "A,B" + ] + }, + { + "cell_type": "markdown", + "id": "2ca52a45", + "metadata": {}, + "source": [ + "Først vil vi **finde en matrix $X$, således at $AX=B$**.\n", + "\n", + "Dette kan eksempelvis gøres på følgende måde:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a98c6fe", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHQAAAAzCAYAAABGxyzzAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAG8UlEQVR4Ae2cS3LVOhCGw60MGeRyGTAOOwiwAnJ3QIoVEHYAdWeZpWAHkBXw2AFQxZABZAewAKp4DBgwy/0/x63Ykuzjh4x9ctRVOpblVqvVrW61HsmVs7OzrTFwdHS0E6uv8p+x8stWtrT+b3cRsJh+I7zHep5G8D+pbNcrf673h17ZZX19pY7te517q/d/vbLOr+Ugge6B8r0M48oqCxVBCL/REyUFoPLPKnyoJ53YeJAcDiUEFDFYoQhR9ff0QPa3lO+s1L+o3AQiBMEvekaV2VQvl4+XgGSON3yshAfsDI0uVwQZabt6HnSmFkFUfdwxjAG3lb4rNblvcBYH6sMgaxnbEbX7WumO0iulTnqIKlSVUcITpVtjmCrpPNPTuR/lofuJMqXFumnxRrB3osQAZCD6cYKKpgfxweD/rHSotNJTNrlcgqBjEfgykmWUVwuORBNrZU7AnS8WxOdPJeZC+H8xM6PI7Il4YZC1QqBQVcLVXtPzaWvNbh+J/hhdPiNY5o7KZxn13VhfDpbk9FrcYFwYSCsEChU2lVaadivVi48ojqAKi4yBr+gYTi47lwBWitttNYKaQoX8SJUQ8vE5jXG/oofLuhmhQpCxpW+xdW0EPRdJVhgH8mq10ppChcx8QWTVZFH6PA5EG2UyyizyHUdws2pjaPckw0bP5hRaEXQS62yRM8EQgybFHN3SzKX8ZKsC4pwoVJct/wmDyG4yNyjaz9QGc2qnNVWU446FaoNR/E6pcTRHSDFFTNb/SHu9isQb+kGpeNKoQVQVSkRqI6BXQ12QxYhFz25N2qXeUBw6r7qj1tFD2564Hh6OtT2bPsGysnC5+sC8xkhm/ZkcRP+eiN7U01mm8jDEXJqhnwRelugYYABmofYxuYVKaQwWtq/8IAglp1oeBR1bhwLJhFUF7hPo5O5VB7eL98HTPfdpmEL5CGJgwiofDKKHBeIi3irP/FmFfZVF54Eq0kLy/5R8XNMTYSaBsv9P9WQpAu2u8FGIGAoAb+60yxTKXiVIqQEXjlJjUdligw8TggRt25PmwdgkZ9A3Hida3YmfyM54qjW1LQaZO0lJrZNWRDu2qcCntQDx7+b8hTHMGTTyDZRKUGSBSYG0MMYzO3EJmDc1t+uwqgpNbqGulZxJLQHTVeABUahNxoaUuvFML7EE5GotMDPduRZQKPMnYEjnb/l3HSRgunO8olALyb+70pxZBwlggK0Wug6dyDxeSAADjFpooeWKX76oknNLl0DUQpfOdOavhwSYQ4u5UxYamG8POhl1HgkEcQ8KZXIFAvM9L86/U0pghCGhL9OdY5G93G/l2yQWKoZ3Rd9OFGiDd64kJj/ZKfvR+yFe9lSJfdtef3bQuyGvQqnMHyr+qjTk6DLYO0ChgZa9dge/lgxzUdgUuqU8x2ZsbnNcxPXEWUBtM7hOlHBbHE4w0P4oiAc74bquhq/2bBz+oy7XCqdwuZyycPUQJRqYZXLlZTYohcmgYrC9mIsRtc/23fs+7asOygQCY2QONbOdYoSelo26hhEknGSoSeCG3n7VStpfTFc2XTpsjs9OlShIfv9GdLHGvyFuoDKzVv/A21A26il5YG2/e3baFIox2k5fQQILBfhwu8hN+CPmOb/jdJ4T9o2+flIRM9PSh8p7l6wpFA9YA4IigA8IexKQ8ogioX9HibbsPE/ZzQXJxe4UEb/0iXKR45bqcyWWLLcAeR5s8yuAWHEjWx+Sz3GiiRKL0aQ8Lpc/J5w1yhUPs4NkwJ2qIfeqMI4iuBQNLt+5C3jmcs1iQJwUxABLFQYN93OYPzL0kIBkhrtFblGLLhQqJKwHId9XSgaiu0eKEPxjAyjS9roXmdFhGAGYhfLhpZIhB4gDC/j/ALjXbIkDBRipxpVb5k5bbtZQqgpl62tHiCmVitXH/prNImrbZKgxlV9aJUAM0rjkcwqVIhEuWk95dZHJuubr1Q4MYbEsXVD4EsDWclPsliXrn+Rl95sbl3zbXmusEQmB2X8dLWzR4Kr+vlJ1RO2qjUX8wwzxtdSL1J5a3CsGEvN4DqGm0FIBKJV9VhcKO+wBGdHE8hfpWsVbSm80QDrdq4hXpsLCGNpqOZdbQUKRj0QAt5hhORIw64wGQ8ZmoFApEv/MMgYrzbAACZTWiYU+WMVOoNCyAhUPRQgTzzC/BIhB2FlbGddEFaqKWOixUjWYmb9bG8iBdEFMw4lYdCPBF0lUoSCJAHuMnKhDMMMMEpDscbOsEjoHb7Uo1+cZQkrs9LBx3zZC+PP6WhCl95XuwW9vHd/9fqsPNTkM7ZPosmWKMd3tQ6PRQo2ICHPwzSZAbE/W0HDNXHaytElWzVrW+s1zdN/LQXIiWneV72UY/wMV0jInMy8y0gAAAABJRU5ErkJggg==", + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}2 & -1\\\\3 & 1\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\end{matrix}\\right]\\right)$" + ], + "text/plain": [ + "⎛⎡2 -1⎤ ⎞\n", + "⎜⎢ ⎥, []⎟\n", + "⎝⎣3 1 ⎦ ⎠" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X = A.gauss_jordan_solve(B)\n", + "X" + ] + }, + { + "cell_type": "markdown", + "id": "1fd71928", + "metadata": {}, + "source": [ + "Som kan eftertjekkes ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8e21929e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}-7 & -4\\\\6 & 2\\end{matrix}\\right], \\ \\left[\\begin{matrix}-7 & -4\\\\6 & 2\\end{matrix}\\right]\\right)$" + ], + "text/plain": [ + "⎛⎡-7 -4⎤ ⎡-7 -4⎤⎞\n", + "⎜⎢ ⎥, ⎢ ⎥⎟\n", + "⎝⎣6 2 ⎦ ⎣6 2 ⎦⎠" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X = X[0]\n", + "A*X, B" + ] + }, + { + "cell_type": "markdown", + "id": "63d06013", + "metadata": {}, + "source": [ + "Som forventet" + ] + }, + { + "cell_type": "markdown", + "id": "1db83e5b", + "metadata": {}, + "source": [ + "Nu vil vi prøve at finde en matrix $E$, således at $AE=A$ for en vilkårlig matrix $A$. \n", + "\n", + "Vi prøver altså at finde ud af hvordan en \"**enhedsmatrix**\" skal se ud:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "260be9c2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}a & b & c\\\\d & e & f\\\\g & h & i\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡a b c⎤\n", + "⎢ ⎥\n", + "⎢d e f⎥\n", + "⎢ ⎥\n", + "⎣g h i⎦" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a,b,c,d,e,f,g,h,i = symbols('a:i', complex=True)\n", + "A = Matrix(3,3,[a,b,c,d,e,f,g,h,i])\n", + "A" + ] + }, + { + "cell_type": "markdown", + "id": "a6c78324", + "metadata": {}, + "source": [ + "Så kan vi finde $E$ ved at løse ligningen $AE=A$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "724acab7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\end{matrix}\\right]\\right)$" + ], + "text/plain": [ + "⎛⎡1 0 0⎤ ⎞\n", + "⎜⎢ ⎥ ⎟\n", + "⎜⎢0 1 0⎥, []⎟\n", + "⎜⎢ ⎥ ⎟\n", + "⎝⎣0 0 1⎦ ⎠" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "E = A.gauss_jordan_solve(A)\n", + "E" + ] + }, + { + "cell_type": "markdown", + "id": "8f965d8f", + "metadata": {}, + "source": [ + "Vi har netop én løsning! En matrix med 1-taller langs diagonalen! Vi kontrollerer, at denne matrix har den ønskede egenskab:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "111b6d92", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}a & b & c\\\\d & e & f\\\\g & h & i\\end{matrix}\\right], \\ \\left[\\begin{matrix}a & b & c\\\\d & e & f\\\\g & h & i\\end{matrix}\\right]\\right)$" + ], + "text/plain": [ + "⎛⎡a b c⎤ ⎡a b c⎤⎞\n", + "⎜⎢ ⎥ ⎢ ⎥⎟\n", + "⎜⎢d e f⎥, ⎢d e f⎥⎟\n", + "⎜⎢ ⎥ ⎢ ⎥⎟\n", + "⎝⎣g h i⎦ ⎣g h i⎦⎠" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "E = E[0]\n", + "A*E,A" + ] + }, + { + "cell_type": "markdown", + "id": "dff62272", + "metadata": {}, + "source": [ + "Som forventet!" + ] + }, + { + "cell_type": "markdown", + "id": "9f126cc9", + "metadata": {}, + "source": [ + "Vi har vist, at denne matrix har egenskaben, at $AE=A$. Dog har vi ikke bevist, at denne matrix er den eneste sådan matrix for alle $n\\times n$ matricer for vilkårligt $n>1$!" + ] + }, + { + "cell_type": "markdown", + "id": "720cd1ed", + "metadata": {}, + "source": [ + "Bemærk, at der også gælder $AE=A=EA$, da:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fce88af7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}a & b & c\\\\d & e & f\\\\g & h & i\\end{matrix}\\right], \\ \\left[\\begin{matrix}a & b & c\\\\d & e & f\\\\g & h & i\\end{matrix}\\right]\\right)$" + ], + "text/plain": [ + "⎛⎡a b c⎤ ⎡a b c⎤⎞\n", + "⎜⎢ ⎥ ⎢ ⎥⎟\n", + "⎜⎢d e f⎥, ⎢d e f⎥⎟\n", + "⎜⎢ ⎥ ⎢ ⎥⎟\n", + "⎝⎣g h i⎦ ⎣g h i⎦⎠" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "E*A,A" + ] + }, + { + "cell_type": "markdown", + "id": "32e6242e", + "metadata": {}, + "source": [ + "*Bemærk*: På engelsk betegnes denne matrix ved *the identity matrix*, og denne matrix kan derfor ofte på variabelnavnet $I$." + ] + }, + { + "cell_type": "markdown", + "id": "113739a0", + "metadata": {}, + "source": [ + "**Find matrix $A^{-1}$, så $AA^{-1}=E$**" + ] + }, + { + "cell_type": "markdown", + "id": "d813bd92", + "metadata": {}, + "source": [ + "En $n\\times n$ matrix kaldes **invertibel**, hvis der findes en $n\\times n$ matrix $A^{-1}$ så der gælder at $AA^{-1}=E$. Bemærk: Hvis $AA^{-1}=E$ er opfyldt, så gælder automatisk at $A^{-1}A=E$, og omvendt.\n", + "\n", + "**Eksempel 1:**\n", + "Vi undersøger om følgende $3\\times 3$ matrix er invertibel:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bc96cbb5", + "metadata": {}, + "outputs": [], + "source": [ + "A = Matrix([[1,2,3],[4,5,6],[7,8,9]])" + ] + }, + { + "cell_type": "markdown", + "id": "7c796ed9", + "metadata": {}, + "source": [ + "Vi forsøger at finde den invertible ved at løse ligningen $AX=E$ ved hjælp af totalmatricen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b9492dd5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFgAAABLCAYAAAD010ABAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEkklEQVR4Ae2d/00VQRDHwfi3IZpYAHYAWoHQgdiBWgb8Z7ADtQIDHWgHBjrAAkwkxAr8fuEGj3Xfu+Fm583dczY59vbn7Hxu3+zd7iRsHh4e7mxsbJzhqoXTo6Ojg1pB5t0QAJ8L3G3XeKBs82Gv4APuWbkffvQTeV8lcFzJ3UfeK+b3AX8E8QRaobUsC8w+leXIY9Y/gMt61TQa06Sc4NrF/VW1kkMmZMlM+YXun+E6Rt5KJoRFdn8GL8QCAVso/IzrEtdzXFWbg3yXAPlcI94jPqWAbjxniPdxuUJG/ybZDzREIOQK1wGud6j/RdOmVR3IfIu+thBfw2W/uOcvh+mPTHuFFrJVgL0UUPbLt5jzSt3vyNsDBP66vIJZ9hwA74EeTVMZxDSw3CuYZU8asHJ2Pvag20r2pAEDnMBb9rbiZSKayJ46YM3kfKKp5FRnUPbUAddsr7CSGcb3Yo/QRPakAcMOimmomQHJk8WuKeRWsicNuCP2DfF2hZ7MYJZ7BbPsOQDmZzm/Hsuwi4zz3kwry1ukzbLHABbDLjOohSIL+wBAbqZcIr7ePGFF3NM8vMb1hmmv0EK2ai+CCkAYnyaDvNifII/272s3kOtCpz+crdzceYGYixrjl0jXvvBQ1DSYZN8HMD8bQwJAcrHjPsjKg1X2GBOxciXnLDABOz+9BJyAnQk4d58zOAE7E3DuPmdwAnYm4Nx9zuAE7EzAuXv1pzLHgc/GMOePTv4OYu6JzMbpRQ0YcE0OGAQ0JkAud85m6/SissFQMtL5Y9ZOLyrAmEFmB4wxs3cCbcx6awFzD7h2CCjnYSxfx2DWexBwZwOH4K3kdGNoEC3LW+k9CBiDFnjc9F4UuBCtW2iitwawBpyc02nqrlOdQb01gGu2VyDJU/Zy/hA5EXETvQn4UTd6ie8oA1skpqFmBiRPFrs7beecMOr9VHQn4N9dQmIp68dmB4x+ZzO6H6v3T9FRYyJY1+yAIQJnFpv1VgHGzyXM+aN4ILKoiO0vitsmW+it3ovA0E0OGBbVoehsnV7UgDujH+X8MVunF5WJsMy+/71tAnaeAQk4ATsTcO4+Z3ACdibg3H3O4ATsTMC5+5zBCdiZgHP36k9ljgOfy2GOJ5GyO913EN/b6UUNGAqGOJ50yoXIhs48UDA5vahsMARFOp5EyjY7vagA4ymaHTA4E0eGSNkjh/y3mRbwHprUDgHlLI7lXiFStlmnQcCdHRoS5HLCECl7SGFt+SBgdCTw5HS51recLtfKLHmRsi3jvm2rAXxbecmNnJUtqeJWFCl7UCkN4JrtlY5lhnk5nkTKFh1N8SBg2EExDTUzIHmy2JkGUzaOlF2OZWx6EHDX8VgHjLHj6reLlN0fx6h7LWCzA8ao0d00ipRtGPZNUxVg/FTDHE8iZRd0ZTGVdacorifVexFoHuZ4EikbD9jk9KIG3C04UY4nXGijZJucXlQmoj75M1dDIAFrKBnqJGADPE3TBKyhZKiTgA3wNE37bxEXeFMo2+Q/KimJFGkwW/iPSliVgLmPsOgVyGWPgYLXKMhBcFWlP/gz38bXcncWAAAAAElFTkSuQmCC", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡1 0 0⎤\n", + "⎢ ⎥\n", + "⎢0 1 0⎥\n", + "⎢ ⎥\n", + "⎣0 0 1⎦" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "E = eye(3)\n", + "E" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "212cf749", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}1 & 2 & 3 & 1 & 0 & 0\\\\4 & 5 & 6 & 0 & 1 & 0\\\\7 & 8 & 9 & 0 & 0 & 1\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡1 2 3 1 0 0⎤\n", + "⎢ ⎥\n", + "⎢4 5 6 0 1 0⎥\n", + "⎢ ⎥\n", + "⎣7 8 9 0 0 1⎦" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "T = Matrix.hstack(A,E) \n", + "T" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab3ca284", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}1 & 0 & -1 & 0 & - \\frac{8}{3} & \\frac{5}{3}\\\\0 & 1 & 2 & 0 & \\frac{7}{3} & - \\frac{4}{3}\\\\0 & 0 & 0 & 1 & -2 & 1\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡1 0 -1 0 -8/3 5/3 ⎤\n", + "⎢ ⎥\n", + "⎢0 1 2 0 7/3 -4/3⎥\n", + "⎢ ⎥\n", + "⎣0 0 0 1 -2 1 ⎦" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "T.rref(pivots=False)" + ] + }, + { + "cell_type": "markdown", + "id": "38c5f065", + "metadata": {}, + "source": [ + "Det ser ikke lovende ud. Den nederste række beskriver en umulighed. Dette ses også, da $rang(A) \\neq rang(T)$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d68892a0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAADEAAAAVCAYAAADvoQY8AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAC4UlEQVRYCc2X0XEaMRCGiccFEJdAOiBxBYEObJdgOiCTJ3h1OrA7yNgd2OkgpgPoIIQOyPdppEMcAoI5z7AzYlcr6d9daVcnWsvlspW30WjUyfunJpf8O2tlNB6Ph3S7meoUxU70s/LtgzstMXAFu4R/C4r4Q7+DmHRfkOf20U/ilMZYtDWIgG24tu/Qv+RG6LvZC/iD+hAEHRf8gn9WmYi+IPfwfqa7Qxakj34NPM15CwdLH3Q4BdFCdmMfadfITzku/Vf6X+GLlE46dp9PirL6ClQdizyVBU3wJukWsFvwdTxR2qTvSZFx/dW/VgrihsXhaLJJij3alDF3KSfB2+g9qabI9HRzbIHAr+SkSzz6q9/tc36MfJYGa1xnuzvA2rX5b+5iQ1sfc4Dom6pSlqjX75tzfsz3dGyIKwLketVbk8INxnjjxZ2sgG0WhHRGLmWJU/W7bxDeONsiZWidADQA0yjdWOsTjuxFfAO4pLlJv3dAThnrGYQpMd8xsT5kQT9h7Ed9oIk+uDoeThjZVH+Fb9xO0ZZ+dyzsC9rWAoqTAwPME5sJmuvfS8aO16q+PSKX6s+aaKfbaa8fgHgFXsCrb8beRQdMANcLpPRaSOlkitUpHIBBeCSlKKsFgHusn+DVCSD7+bc2miI/XqbOTl9qxpw7NwiPZKszgLo7G88RdAbmBgQ60HhalvMFHWtNnpMXj1S6QT2JmYVtEXkTbBCABmchvyDXb7AeulDccHfkL3xCW3u6bIBuV2zcdmC5UWIPkOvBiaStiUH8pG17QjwzZiDWQ50MPpAGaKHI4H7JSwbT9CJnzQPNjck3S9u73mjWySD8l+CNPqV1j/3vAMYVrX0szv+sx06HNnXuWdyWjYdecbv2K62dg09hP2xxhum3egB6lCiOum3AMHf/FM01rMSWaaa/4TmSTkIzXp95Pqo7hHxGv8tXvOCEfq7+IuT5F/NsmOtOTcbHoX7mfv0DhYKZTINsMCUAAAAASUVORK5CYII=", + "text/latex": [ + "$\\displaystyle \\left( 2, \\ 3\\right)$" + ], + "text/plain": [ + "(2, 3)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A.rank(),T.rank()" + ] + }, + { + "cell_type": "markdown", + "id": "7845dad8", + "metadata": {}, + "source": [ + "Der findes altså ikke en løsning! En kvadratisk matrix der ikke har fuld rang, kaldes **singulær**. $A$ er altså en singulær matrix!\n", + "\n", + "Det gælder altid at **en *singulær* matrix ikke har en invers matrix**." + ] + }, + { + "cell_type": "markdown", + "id": "651ca2a4", + "metadata": {}, + "source": [ + "**Eksempel 2:**\n", + "\n", + "Nu prøver vi en med **regulær** matrix, altså en matrix med fuld rang:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1689596a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}0 & 2 & 3\\\\4 & 5 & 6\\\\7 & 8 & 9\\end{matrix}\\right], \\ 3\\right)$" + ], + "text/plain": [ + "⎛⎡0 2 3⎤ ⎞\n", + "⎜⎢ ⎥ ⎟\n", + "⎜⎢4 5 6⎥, 3⎟\n", + "⎜⎢ ⎥ ⎟\n", + "⎝⎣7 8 9⎦ ⎠" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A = Matrix([[0,2,3],[4,5,6],[7,8,9]])\n", + "A,A.rank()" + ] + }, + { + "cell_type": "markdown", + "id": "886277a3", + "metadata": {}, + "source": [ + "Med samme fremgangsmåde som i sidste eksempel kommer vi frem til:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "001a5679", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & -1 & 2 & -1\\\\0 & 1 & 0 & 2 & -7 & 4\\\\0 & 0 & 1 & -1 & \\frac{14}{3} & - \\frac{8}{3}\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡1 0 0 -1 2 -1 ⎤\n", + "⎢ ⎥\n", + "⎢0 1 0 2 -7 4 ⎥\n", + "⎢ ⎥\n", + "⎣0 0 1 -1 14/3 -8/3⎦" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "T = Matrix.hstack(A,E)\n", + "T.rref(pivots=False)" + ] + }, + { + "cell_type": "markdown", + "id": "e92a146f", + "metadata": {}, + "source": [ + "Der er præcis én løsning, som kan trækkes ud ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7ae2f1f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}-1 & 2 & -1\\\\2 & -7 & 4\\\\-1 & \\frac{14}{3} & - \\frac{8}{3}\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡-1 2 -1 ⎤\n", + "⎢ ⎥\n", + "⎢2 -7 4 ⎥\n", + "⎢ ⎥\n", + "⎣-1 14/3 -8/3⎦" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "invA = T.rref(pivots=False)[:,3:]\n", + "invA" + ] + }, + { + "cell_type": "markdown", + "id": "f9c1062e", + "metadata": {}, + "source": [ + "Vi kan nu kontrollere, at $AA^{-1}=E=A^{-1}A$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2ef0401d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right], \\ \\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right]\\right)$" + ], + "text/plain": [ + "⎛⎡1 0 0⎤ ⎡1 0 0⎤⎞\n", + "⎜⎢ ⎥ ⎢ ⎥⎟\n", + "⎜⎢0 1 0⎥, ⎢0 1 0⎥⎟\n", + "⎜⎢ ⎥ ⎢ ⎥⎟\n", + "⎝⎣0 0 1⎦ ⎣0 0 1⎦⎠" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A*invA,invA*A" + ] + }, + { + "cell_type": "markdown", + "id": "38c54006", + "metadata": {}, + "source": [ + "Perfekt!\n", + "\n", + "Vi kan også finde direkte frem til den inverse, hvis den findes, ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fb4ee0dc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}-1 & 2 & -1\\\\2 & -7 & 4\\\\-1 & \\frac{14}{3} & - \\frac{8}{3}\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡-1 2 -1 ⎤\n", + "⎢ ⎥\n", + "⎢2 -7 4 ⎥\n", + "⎢ ⎥\n", + "⎣-1 14/3 -8/3⎦" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A.inv()" + ] + }, + { + "cell_type": "markdown", + "id": "18ffdc85", + "metadata": {}, + "source": [ + "**Det gælder altid at en *regulær* matrix har netop én invers matrix!**" + ] + }, + { + "cell_type": "markdown", + "id": "ee92b87e", + "metadata": {}, + "source": [ + "Til sidst vises at vi også kan løse $AX=B$ ved hjælp af $A^{-1}$, hvis den findes:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3b9b37fd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}1 & -3\\\\0 & 2\\end{matrix}\\right], \\ \\left[\\begin{matrix}-7 & -4\\\\6 & 2\\end{matrix}\\right]\\right)$" + ], + "text/plain": [ + "⎛⎡1 -3⎤ ⎡-7 -4⎤⎞\n", + "⎜⎢ ⎥, ⎢ ⎥⎟\n", + "⎝⎣0 2 ⎦ ⎣6 2 ⎦⎠" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A = Matrix([[1,-3],[0,2]])\n", + "B = Matrix([[-7,-4],[6,2]])\n", + "A,B" + ] + }, + { + "cell_type": "markdown", + "id": "d3a91263", + "metadata": {}, + "source": [ + "A har en invers matrix da det kan ses, at den er regulær!\n", + "\n", + "Vi kan derfor løse $AX=B$ ved at gange den inverse matrix på fra venstre på begge sider af lighedstegnet:\n", + "\n", + "$A^{-1}AX=A^{-1}B$\n", + "\n", + "$X=A^{-1}B$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f16b02d7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEYAAAAzCAYAAAAqwX72AAAACXBIWXMAAA7EAAAOxAGVKw4bAAADaklEQVRoBe2b7VEbMRCGTSYFOKQD0wGEDkwHcQtQQia/7L+kA0gFGdMBpIOQDqCEhBLyvM7p5izfSneHb+4stDNC0lofu69293TScbRcLqeTGlqtVi817ORY6Fmr/zs0fST99dJ1cgjYCq093YXF+giLeaJwBXIPdt+38ws4XKLtQhaTqQaB9zW8LRYIzmB8KZifyP+oDv93wRt9hqynCCmXOaPcKHYGgSlAuSG/cNpTVvx5FI80WvdDNgXV7yQtpBZUC9yYYq4kEK6qozGhrEeoawVGS8j5QlqQJP+PtoLGgJkz4BOD+480WcoUfqtVaCvckO1jwAiAZwCw/NIHbEhd9jp3LMYsjNkUzCYAdjAB2NDDZMcsZqcjYAgUuZB7Uu20SYHRGhiUVtC9A6BvKQBg6RB0Jb8TYNzAU8yxXMzv0rnOHIpfP0lt4pieQntx78bAMKG2ysfk5Z6ms9YNOjKPAv5Zg6a9NGnkSgj5mdlPyEtLoTxT6kWqEQwaBQblFWzPyf1gK7C0q0ySgq5UWISC7QNlxZcqzeEdSgD+WAh+TC4XjVIQGHrfk+Quii8+7SXI+YPus87CudeWeTHuGt4z5Xvy29BcQWDofBLqPPbfkL+MiW1ljcaYtgOm0j4DY6xkBiYDYyBgsLPFZGAMBAx2tpgMjIGAwc4Wk4ExEDDYwVcC9WFbPSNzVyg6NFL9Gv5o7pSQRScAei9qfKFG2yAFgWFCAaFbRwfMhLKOG/QSptOyu+DoPf7I3JKt84VaTLRYjNFb9WUBhhvLWcpXxxgiR6ZXXajFZI4Bo6MFnV8obUgCuXLKecyVZB0fqgBUrMc/uKo2O/hyzGK2FASUOYzNfTbl4EHPVscDrAQtxukDCIr6AuWcJPf6RUqamgIjMDZHmYUr6TOQQZ9Kfa9KK1eSMACiR7QCsM5Pp+KlSEFgUPxUqUZx50pyryQpCAwa64tOuU2ylmGtaizGyGV0p6S8Svp0S+Q2e/9rCf2NAePfPk4ASa8EsiB9AusDNhQ0rS/UYoIGgUHxW5JuHKubuRmDjuLDROTqfKH2KmDUmcnlLqN0GWTrfKEWAyYWfGP9k/09A2MsbQYmA2MgYLCzxRjAuMe1PhvT3qQk6mPZo5Qy9VHw9WaODQ7OYrRPqf4zl85c3gppL7Sj+z9JSPxu7r5JSAAAAABJRU5ErkJggg==", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}2 & -1\\\\3 & 1\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡2 -1⎤\n", + "⎢ ⎥\n", + "⎣3 1 ⎦" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X = A.inv()*B\n", + "X" + ] + }, + { + "cell_type": "markdown", + "id": "c728d160", + "metadata": {}, + "source": [ + "Som kontrolleres ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a83de506", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}-7 & -4\\\\6 & 2\\end{matrix}\\right], \\ \\left[\\begin{matrix}-7 & -4\\\\6 & 2\\end{matrix}\\right]\\right)$" + ], + "text/plain": [ + "⎛⎡-7 -4⎤ ⎡-7 -4⎤⎞\n", + "⎜⎢ ⎥, ⎢ ⎥⎟\n", + "⎝⎣6 2 ⎦ ⎣6 2 ⎦⎠" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A*X, B" + ] + }, + { + "cell_type": "markdown", + "id": "5657d881", + "metadata": {}, + "source": [ + "Dette stemmer overens med hvad vi fandt ved brug af den anden metode!" + ] + }, + { + "cell_type": "markdown", + "id": "3cb12328", + "metadata": {}, + "source": [ + "Lad os til sidst bede SymPy om den inverse til en singulær matrix. Den findes ikke så vi håber SymPy giver fejl: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "279e362c", + "metadata": {}, + "outputs": [], + "source": [ + "A = Matrix([[1,2,3],[4,5,6],[7,8,9]])\n", + "A.inv()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "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.4" + }, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Demos/Demo-E-Uge-5-StoreDag.ipynb b/Demos/Demo-E-Uge-5-StoreDag.ipynb new file mode 100644 index 0000000..b8d816f --- /dev/null +++ b/Demos/Demo-E-Uge-5-StoreDag.ipynb @@ -0,0 +1,930 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "14b14fd2", + "metadata": {}, + "source": [ + "# Lineære ligningssystemer\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aad4b143", + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "cell_type": "markdown", + "id": "eadb6193", + "metadata": {}, + "source": [ + "Vi vil gerne løse det lineære ligningssystem\n", + "\n", + "\\begin{aligned}\n", + "-x_2+x_3=2\\\\\n", + "2x_1+4x_2-2x_3=2\\\\\n", + "3x_1+4x_2+x_3=9\\\\\n", + "\\end{aligned}\n" + ] + }, + { + "cell_type": "markdown", + "id": "b1b8cc7e", + "metadata": {}, + "source": [ + "Dette kan skrives på matrixform $Ax=b$ med koefficientmatrix $A$ givet ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b6793e58", + "metadata": {}, + "outputs": [], + "source": [ + "A = Matrix([[0,-1,1],[2,4,-2],[3,4,1]])\n", + "A" + ] + }, + { + "cell_type": "markdown", + "id": "95454f70", + "metadata": {}, + "source": [ + "og højreside givet ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "89a5882e", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "b = Matrix([2,2,9])\n", + "b" + ] + }, + { + "cell_type": "markdown", + "id": "67ec5823", + "metadata": {}, + "source": [ + "Lad os først skrive ligningerne op i SymPy:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "54a59ed6", + "metadata": {}, + "outputs": [], + "source": [ + "x1,x2,x3 = symbols('x1:4')\n", + "eq1 = Eq(-x2 + x3, 2)\n", + "eq2 = Eq(2*x1 + 4*x2 - 2*x3, 2)\n", + "eq3 = Eq(3*x1 + 4*x2 + x3, 9)\n", + "eq1, eq2, eq3" + ] + }, + { + "cell_type": "markdown", + "id": "cb19e726", + "metadata": { + "scrolled": true + }, + "source": [ + "Koefficientmatricen og højresiden for et system af lineære ligninger kan nu findes direkte i SymPy ved kaldet:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23645a7a", + "metadata": {}, + "outputs": [], + "source": [ + "A, b = linear_eq_to_matrix([eq1, eq2, eq3], [x1, x2, x3])\n", + "display(A, b)" + ] + }, + { + "cell_type": "markdown", + "id": "cd9866de", + "metadata": {}, + "source": [ + "Det stemmer med hvad vi påstod tidligere. Lad os nu se hvordan vi kan løse ligningssystemet." + ] + }, + { + "cell_type": "markdown", + "id": "cd437b43", + "metadata": {}, + "source": [ + "**Metode 0:**\n", + "\n", + "Vi har allerede skrevet alle ligningerne op i SymPy, så vi kan bede SymPy om at løse dem:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb19e726", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "linsolve((eq1,eq2,eq3),x1,x2,x3)" + ] + }, + { + "cell_type": "markdown", + "id": "0cd70d7e", + "metadata": {}, + "source": [ + "**Metode 1:**\n", + "\n", + "Direkte løsning med SymPy ved koefficientmatricen. Der findes flere metoder, men her er præsenteret 2:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3b1d3c8b", + "metadata": {}, + "outputs": [], + "source": [ + "A.gauss_jordan_solve(b)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35ec6888", + "metadata": {}, + "outputs": [], + "source": [ + "linsolve((A,b))" + ] + }, + { + "cell_type": "markdown", + "id": "259b64cf", + "metadata": {}, + "source": [ + "Som har netop én løsning:\n", + "\n", + "\\begin{aligned}\n", + "(x_1,x_2,x_3)=(4,-1,1).\n", + "\\end{aligned}" + ] + }, + { + "cell_type": "markdown", + "id": "ade8ff9a", + "metadata": {}, + "source": [ + "**Metode 2:**\n", + "\n", + "Fuldstændig GaussJordan-elimination kan ordnes med 1 kommando, Reduced Row Echelon Form (rref):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0842198f", + "metadata": {}, + "outputs": [], + "source": [ + "T = Matrix.hstack(A,b)\n", + "T" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b7f53e4b", + "metadata": {}, + "outputs": [], + "source": [ + "T.rref(pivots=False)" + ] + }, + { + "cell_type": "markdown", + "id": "5fcafb2b", + "metadata": {}, + "source": [ + "Løsningen kan aflæses til \n", + "\n", + "\\begin{aligned}\n", + "(x_1,x_2,x_3)=(4,-1,1)\n", + "\\end{aligned}\n", + "\n", + "Pivots beskriver hvilke kolonner de ledende 1-taller befinder sig i. Hvis vi bare vil have matricen, kan denne sættes til \"False\". Alternativt kommer outputtet bare ud som:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "547a3d34", + "metadata": {}, + "outputs": [], + "source": [ + "T.rref()" + ] + }, + { + "cell_type": "markdown", + "id": "78445630", + "metadata": {}, + "source": [ + "**Metode 3:**\n", + "\n", + "Løsning ved brug af GaussJordan elimination, men hvor vi selv udfører hver rækkeoperation:" + ] + }, + { + "cell_type": "markdown", + "id": "d01acb7d", + "metadata": {}, + "source": [ + "Første søjle laves ved at bytte række 1 og række 2, hvorefter den nye række 1 ganges med $1/2$. Til sidst lægges $-3$ gange række 1 til række 3:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ed73c3ff", + "metadata": {}, + "outputs": [], + "source": [ + "T1 = T.elementary_row_op('n<->m', 0, 1)\n", + "T2 = T1.elementary_row_op('n->kn', 0, S(1)/2)\n", + "T3 = T2.elementary_row_op('n->n+km',2,-3,0)\n", + "T1,T2,T3" + ] + }, + { + "cell_type": "markdown", + "id": "5cde16d6", + "metadata": {}, + "source": [ + "Så kan vi klare de sidste 2 søjler ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "41b8014c", + "metadata": {}, + "outputs": [], + "source": [ + "T4 = T3.elementary_row_op('n->kn',1,-1)\n", + "T5 = T4.elementary_row_op('n->n+km',2,2,1)\n", + "T6 = T5.elementary_row_op('n->n+km',0,-2,1)\n", + "T4,T5,T6" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "20d55edd", + "metadata": {}, + "outputs": [], + "source": [ + "T7 = T6.elementary_row_op('n->kn',2,0.5)\n", + "T8 = T7.elementary_row_op('n->n+km',0,-1,2)\n", + "T9 = T8.elementary_row_op('n->n+km',1,1,2)\n", + "T7,T8,T9" + ] + }, + { + "cell_type": "markdown", + "id": "08bf6794", + "metadata": {}, + "source": [ + "Hvor vi her ser, at den sidste matrice er den samme løsning som tidligere." + ] + }, + { + "cell_type": "markdown", + "id": "9f7a8935", + "metadata": {}, + "source": [ + "# Et lineært ligningssystem med flere løsninger\n", + "\n", + "Vi ønsker at løse det inhomogene ligningssystem, hvis koefficientmatrix er givet ved " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "57c54709", + "metadata": {}, + "outputs": [], + "source": [ + "A = Matrix([[1,3,2,4,5],[2,6,4,3,5],[3,8,6,7,6],[4,14,8,10,22]])\n", + "A" + ] + }, + { + "cell_type": "markdown", + "id": "1c5250fa", + "metadata": {}, + "source": [ + "Hvor **højresiden** er givet ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "33266dbf", + "metadata": {}, + "outputs": [], + "source": [ + "b = Matrix([9,3,5,32])\n", + "b" + ] + }, + { + "cell_type": "markdown", + "id": "34345904", + "metadata": {}, + "source": [ + "**Metode 1:**\n", + "\n", + "Løses direkte ved brug af SymPy. Igen er der to metoder:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6b058e32", + "metadata": {}, + "outputs": [], + "source": [ + "A.gauss_jordan_solve(b)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c4d70f43", + "metadata": {}, + "outputs": [], + "source": [ + "linsolve((A,b))" + ] + }, + { + "cell_type": "markdown", + "id": "2c05071d", + "metadata": {}, + "source": [ + "Dette læses ved, at $\\tau_0$ og $\\tau_1$ er de to frie parametre, altså $\\tau_0, \\tau_1 \\in \\mathbb{R}$." + ] + }, + { + "cell_type": "markdown", + "id": "06036c6f", + "metadata": {}, + "source": [ + "**Metode 2:**\n", + "\n", + "Løsning ved fuldstændig reduktion:\n", + "\n", + "Først laves **totalmatricen** ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "07d4a21e", + "metadata": {}, + "outputs": [], + "source": [ + "T = Matrix.hstack(A,b)\n", + "T" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d79ab668", + "metadata": {}, + "outputs": [], + "source": [ + "T.rref()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "437a0d2b", + "metadata": {}, + "source": [ + "Nu er vi færdige med eliminationen og løsningen kan nemt udregnes (eller direkte aflæses). \n", + "\n", + "På standard-parameterform er løsningen:\n", + "\n", + "\\begin{equation}\n", + "\\begin{bmatrix}\n", + "x_1\\\\x_2\\\\x_3\\\\x_4\\\\x_5\n", + "\\end{bmatrix} \n", + "=\n", + "\\begin{bmatrix}\n", + "-24\\\\7\\\\0\\\\3\\\\0\n", + "\\end{bmatrix}\n", + "+\n", + "\\tau_0\n", + "\\begin{bmatrix}\n", + "-2\\\\0\\\\1\\\\0\\\\0\n", + "\\end{bmatrix}\n", + "+\n", + "\\tau_1\\begin{bmatrix}\n", + "11\\\\-4\\\\0\\\\-1\\\\1\n", + "\\end{bmatrix}\n", + "\\end{equation}\n", + "\n", + "Her er undladt at sætte \"pivots=False\" for at vise at som standard beskrives kolonnerne som de ledende 1-taller befinder sig i. Der er ingen ledende 1-taller i søjle 3 og 5, så disse variable (dvs. $x_3$ og $x_5$) bliver vores frie variable (hhv. $\\tau_0$ og $\\tau_1$)." + ] + }, + { + "cell_type": "markdown", + "id": "47b9ed09", + "metadata": {}, + "source": [ + "**Kontrol:**\n", + "\n", + "Vi tjekker at antallet af *frie parametre* (de to vi har) er korrekt:\n", + "\n", + "Antallet af ubekendte er $n=5$, så antallet af frie parametre skulle gerne være lig med $n-\\text{A.rank()}$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8281faac", + "metadata": {}, + "outputs": [], + "source": [ + "A.rank()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "61cd60c4", + "metadata": {}, + "outputs": [], + "source": [ + "5-A.rank()" + ] + }, + { + "cell_type": "markdown", + "id": "bdd8e040", + "metadata": {}, + "source": [ + "som forventet." + ] + }, + { + "cell_type": "markdown", + "id": "91d31562", + "metadata": {}, + "source": [ + "# Når systemet indeholder ubekendte koefficienter\n", + "\n", + "Når ligningssystemet indeholder ukendte koefficienter, kræver det nogle gange lidt mere opmærksomhed. Tilsvarende, kræver det lidt mere arbejde i SymPy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4b5ea6b5", + "metadata": {}, + "outputs": [], + "source": [ + "a = symbols('a', real=True)\n", + "T = Matrix([[1,3,-2,0,0],[1,2,3,-a,-1],[3,7,a+3,-2*a,a-3],[0,1,-5,a**2,a],[1,1,8,-2*a,-2]])\n", + "T" + ] + }, + { + "cell_type": "markdown", + "id": "d1f8d705", + "metadata": {}, + "source": [ + "Man kunne fristes til bare at spørge SymPy om løsningen direkte:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2d47dbf", + "metadata": {}, + "outputs": [], + "source": [ + "T.rref()" + ] + }, + { + "cell_type": "markdown", + "id": "92435746", + "metadata": {}, + "source": [ + "Her kan vi se, at vi må kræve at $a\\neq 0$. Dog har vi sprunget mange udregninger over (vi har ladet SymPy lave alle udregningerne for os), så det kan være at nogle at disse udregninger SymPy har lavet, kræver at $a$ undgår andre værdier end nul. Vi forsøger derfor at lave GaussJordan-elimination i \"hånden\" så vi har tjek på alle trin. Vi ordner først den første søjle:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c763a62e", + "metadata": {}, + "outputs": [], + "source": [ + "T1 = T.elementary_row_op('n->n+km',1,-1,0)\n", + "T2 = T1.elementary_row_op('n->n+km',2,-3,0)\n", + "T3 = T2.elementary_row_op('n->n+km',4,-1,0)\n", + "T3" + ] + }, + { + "cell_type": "markdown", + "id": "c725d48e", + "metadata": {}, + "source": [ + "Anden søjle er også ret lige til:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1f6f99f1", + "metadata": {}, + "outputs": [], + "source": [ + "T4 = T3.elementary_row_op('n->kn',1,-1)\n", + "T5 = T4.elementary_row_op('n->n+km',0,-3,1)\n", + "T6 = T5.elementary_row_op('n->n+km',2,2,1)\n", + "T7 = T6.elementary_row_op('n->n+km',3,-1,1)\n", + "T8 = T7.elementary_row_op('n->n+km',4,2,1)\n", + "T8" + ] + }, + { + "cell_type": "markdown", + "id": "19f129ce", + "metadata": {}, + "source": [ + "Inden at vi kan gå videre, er det vigtigt at ligge mærke til, at $a-1$ kan gå hen og blive nul. Da vi gerne vil have et ledende 1-tal i tredje række, skal vi dividere med $a-1$, men hvis det er $0$ har vi divideret med $0$ (no good). Dette sker præcis når $a=1$, så lad os antage at $a\\neq 1$, og gemme dette specialtilfælde til senere.\n", + "\n", + "Vi fortsætter nu Gauss-Jordan eliminationen:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b7c06d06", + "metadata": {}, + "outputs": [], + "source": [ + "T9 = T8.elementary_row_op('n->kn',2,1/(a-1))\n", + "T10 = T9.elementary_row_op('n->n+km',1,5,2)\n", + "T11 = T10.elementary_row_op('n->n+km',0,-13,2)\n", + "T11" + ] + }, + { + "cell_type": "markdown", + "id": "3c2bb1ef", + "metadata": {}, + "source": [ + "Med et ledende 1-tal i fjerde række, kan vi komme til at dividere med $0$ igen. Dette sker præcis når $a^2-a=0$, altså når $a(a-1)=0$. Ved nulreglen må vi kræve at $a$ hverken er nul eller et. Vi tjekker argumentet i SymPy:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c7f6eb46", + "metadata": {}, + "outputs": [], + "source": [ + "roots(a**2-a,multiple=True)" + ] + }, + { + "cell_type": "markdown", + "id": "8b4b5372", + "metadata": {}, + "source": [ + "Da vi allerede har taget højde for det ene special-tilfælde ($a=1$), skal vi bare lave et special-tilfælde for $a=0$. Vi fortsætter altså vores beregninger under antagelsen om at $a\\neq0$ og $a\\neq1$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5fd5781", + "metadata": {}, + "outputs": [], + "source": [ + "T12 = T11.elementary_row_op('n->kn',3,1/(a**2-a))\n", + "T13 = T12.elementary_row_op('n->n+km',0,3*a,3)\n", + "T14 = T13.elementary_row_op('n->n+km',1,-a,3)\n", + "T14.simplify()\n", + "T14" + ] + }, + { + "cell_type": "markdown", + "id": "8f84ec5e", + "metadata": {}, + "source": [ + "Vi har nu en fuldstændig reduktion gennemførst, og vi konkluderer:\n", + "\n", + "For $a\\neq0$ og $a\\neq1$ er der netop én løsning: \n", + "\n", + "\\begin{equation}\n", + "\\begin{bmatrix}x_1\\\\x_2\\\\x_3\\\\x_4\\end{bmatrix}\n", + "=\\begin{bmatrix}-13\\\\5\\\\1\\\\ \\frac{1}{a}\\end{bmatrix}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "63fea249", + "metadata": {}, + "source": [ + "For specialtilfældet hvor $a=0$ får vi:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "09468acb", + "metadata": {}, + "outputs": [], + "source": [ + "T.subs({a:0}).rref(pivots=False)" + ] + }, + { + "cell_type": "markdown", + "id": "672a4147", + "metadata": {}, + "source": [ + "Række 4 svarer til at $0=1$. Da dette er umuligt, kan vi konkludere, at:\n", + "\n", + "For $a=0$ har ligningssystemet ingen løsninger." + ] + }, + { + "cell_type": "markdown", + "id": "7d23976f", + "metadata": {}, + "source": [ + "For specialtilfældet hvor $a=1$ får vi:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f92e21af", + "metadata": {}, + "outputs": [], + "source": [ + "T.subs({a:1}).rref(pivots=False)" + ] + }, + { + "cell_type": "markdown", + "id": "32199c3c", + "metadata": {}, + "source": [ + "Med rank:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e11355b5", + "metadata": {}, + "outputs": [], + "source": [ + "T.subs({a:1}).rank()" + ] + }, + { + "cell_type": "markdown", + "id": "0d1d47e4", + "metadata": {}, + "source": [ + "Vi kan nu aflæse løsningen eller alternativt bruge SymPy:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a5cb1f34", + "metadata": {}, + "outputs": [], + "source": [ + "linsolve(T.subs({a:1}))" + ] + }, + { + "cell_type": "markdown", + "id": "7ea2039e", + "metadata": {}, + "source": [ + "Vi ser at for $a=1$ har systemet den fuldstændige løsning:\n", + "\n", + "\\begin{equation}\n", + "\\begin{bmatrix}\n", + "x_1\\\\x_2\\\\x_3\\\\x_4\n", + "\\end{bmatrix}=\n", + "\\begin{bmatrix}-3\\\\1\\\\0\\\\0\n", + "\\end{bmatrix}+\\tau_0\n", + "\\begin{bmatrix}-13\\\\5\\\\1\\\\0\n", + "\\end{bmatrix}+\\tau_1\n", + "\\begin{bmatrix}3\\\\-1\\\\0\\\\1\n", + "\\end{bmatrix}, \\;\\; \\text{hvor } \\tau_0, \\tau_1 \\in \\mathbb{R}.\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "4b148364", + "metadata": {}, + "source": [ + "Læg mærke til, at den direkte løsning med $\\text{rref()}$ på $T$ i starten af opgaven helt missede at $a=1$ var et specialtilfælde! Man skal altså passe på med bare at springe direkte til løsningen når der er symbolske variable med i matricen!" + ] + }, + { + "cell_type": "markdown", + "id": "458f7d74", + "metadata": {}, + "source": [ + "# MatrixAlgebra" + ] + }, + { + "cell_type": "markdown", + "id": "08986372", + "metadata": {}, + "source": [ + "Vi vil regne på følgende matricer:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3256ce1c", + "metadata": {}, + "outputs": [], + "source": [ + "A = Matrix([[2,1],[3,0],[7,11]])\n", + "B = Matrix([[1,1],[9,3],[-7,-1]])\n", + "C = Matrix([[2,1,3],[-6,5,8]])\n", + "A,B,C" + ] + }, + { + "cell_type": "markdown", + "id": "3c9a9102", + "metadata": {}, + "source": [ + "Vi kan gange matricen $A$ med en konstant ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "21679666", + "metadata": {}, + "outputs": [], + "source": [ + "k = symbols('k',real=True)\n", + "k*A" + ] + }, + { + "cell_type": "markdown", + "id": "661d6095", + "metadata": {}, + "source": [ + "Da $A$ og $B$ er af samme type $\\mathbb{R}^{3\\times 2}$, kan vi bestemme matrixsummen $A+B$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2498d51", + "metadata": {}, + "outputs": [], + "source": [ + "A+B" + ] + }, + { + "cell_type": "markdown", + "id": "5c02c7f8", + "metadata": {}, + "source": [ + "og vi kan udregne linearkombinationer af matricer. Eksempelvis $3A-5B$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2da825ce", + "metadata": {}, + "outputs": [], + "source": [ + "3*A-5*B" + ] + }, + { + "cell_type": "markdown", + "id": "3aa3eba7", + "metadata": {}, + "source": [ + "Da antallet af søjler i $A$ passer med antaller af rækker i $C$, kan vi bestemme matrixproduktet $A \\cdot C$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b9cf7884", + "metadata": {}, + "outputs": [], + "source": [ + "A*C" + ] + }, + { + "cell_type": "markdown", + "id": "5c9dca98", + "metadata": {}, + "source": [ + "Bemærk at for matrixprodukter gælder generelt at $AC \\neq CA$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e40075c1", + "metadata": {}, + "outputs": [], + "source": [ + "display(A*C, C*A)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c3338e5c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "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.4" + }, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Demos/Demo-E-Uge-6-LilleDag.ipynb b/Demos/Demo-E-Uge-6-LilleDag.ipynb new file mode 100644 index 0000000..3f9ccb9 --- /dev/null +++ b/Demos/Demo-E-Uge-6-LilleDag.ipynb @@ -0,0 +1,286 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a16f919a", + "metadata": {}, + "source": [ + "# Prikprodukt og krydsprodukt\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "02fbdd15", + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "cell_type": "markdown", + "id": "3c6bf518", + "metadata": {}, + "source": [ + "Prikprodukter og krydsprodukter bruges meget, især når forårssemesteret nåes. Heldigvis er det gode funktioner for begge dele indbygget i Sympy." + ] + }, + { + "cell_type": "markdown", + "id": "57df8306", + "metadata": {}, + "source": [ + "## Dot og Cross" + ] + }, + { + "cell_type": "markdown", + "id": "21f7179b", + "metadata": {}, + "source": [ + "I planen er giver 2 vektorer, find **prikproduktet** af dem:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23b1fa09", + "metadata": {}, + "outputs": [], + "source": [ + "u = Matrix([-7,9])\n", + "v = Matrix([13,8])\n", + "u.dot(v)" + ] + }, + { + "cell_type": "markdown", + "id": "908f8666", + "metadata": {}, + "source": [ + "Eller generelt:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "af28b92c", + "metadata": {}, + "outputs": [], + "source": [ + "a,b,c,d = symbols(['a', 'b', 'c', 'd'], real = True)\n", + "u = Matrix([a,b])\n", + "v = Matrix([c,d])\n", + "u.dot(v)" + ] + }, + { + "cell_type": "markdown", + "id": "7468adb6", + "metadata": {}, + "source": [ + "Med vektorer i rummet, kan vi også finde deres prikprodukt på samme måde" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "faa6eb05", + "metadata": {}, + "outputs": [], + "source": [ + "u = Matrix([-7,9,2])\n", + "v = Matrix([13,8,-1])\n", + "u.dot(v)" + ] + }, + { + "cell_type": "markdown", + "id": "5d99a5f5", + "metadata": {}, + "source": [ + "Derudover kan vi også finde deres **krydsprodukt** ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e28a9160", + "metadata": {}, + "outputs": [], + "source": [ + "j = u.cross(v)\n", + "j" + ] + }, + { + "cell_type": "markdown", + "id": "301e0d5a", + "metadata": {}, + "source": [ + "*Bemærk*: Prikproduktet er et **tal** (en skalar). Krydsproduktet giver en ny **vektor**, der er vinkelret på de to givne vektorer! Dette eftertjekkes ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "62b183b7", + "metadata": {}, + "outputs": [], + "source": [ + "j.dot(u),j.dot(v)" + ] + }, + { + "cell_type": "markdown", + "id": "33f98d7c", + "metadata": {}, + "source": [ + "Da prikproduktet giver 0, ses det at den nye vektor er vinkelret på begge vektorer i krydsproduktet. Som forventet." + ] + }, + { + "cell_type": "markdown", + "id": "1fd990e7", + "metadata": {}, + "source": [ + "## Længder og vinkler\n", + "\n", + "I dette eksempel udregner vi længden af og vinkler mellem vektorer ved brug af prikproduktet. Længden udregnes ved\n", + "\n", + "\\begin{equation}\n", + "|u|=\\sqrt{u\\cdot u},\n", + "\\end{equation}\n", + "\n", + "Bemærk at længden/normen $|u|$ oftest skrives $||u||_2$ i ingeniørvidenskaben. Længden af vektorene kan udregnes ved én af følgende 3 metoder:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "11f9f90b", + "metadata": {}, + "outputs": [], + "source": [ + "u_1 = Matrix([1,2])\n", + "u_2 = Matrix([3,4])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50b5f60c", + "metadata": {}, + "outputs": [], + "source": [ + "# Gange sammen elementvis, sum sammen bagefter, kvadratroden til sidst\n", + "\n", + "sqrt(sum(u_1.multiply_elementwise(u_1)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "53713bc1", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# Indbyggede funktion for prikproduktet (dot product), og så kvadratroden\n", + "\n", + "sqrt(u_2.dot(u_2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eeecf6a4", + "metadata": {}, + "outputs": [], + "source": [ + "# Indbyggede funktion, så vi kan bede om normen \n", + "# (2-normen er standard for vektorer, Frobenius normen for matricer)\n", + "\n", + "u_2.norm() # er det samme som u_2.norm(2)" + ] + }, + { + "cell_type": "markdown", + "id": "9158d5e7", + "metadata": {}, + "source": [ + "Vinklerne mellem vektorene, $v$, udregnes udelukkende ved brug af ligheden fra *sætning 10.53*,\n", + "\n", + "\\begin{equation}\n", + "\\cos(v)=\\frac{u_1 \\cdot u_2}{|u_1|\\,|u_2|},\n", + "\\end{equation}\n", + "\n", + "hvor $u_1$ og $u_2$ er egentlige vektorer. Vi udregner vinkel mellem $u_1$ og $u_2$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0bf3e613", + "metadata": {}, + "outputs": [], + "source": [ + "# \n", + "cos_to_v = (u_1.dot(u_2))/(u_1.norm()*u_2.norm())\n", + "\n", + "# arccos(x) fåes i python ved acos(x)\n", + "v = acos(cos_to_v)\n", + "v" + ] + }, + { + "cell_type": "markdown", + "id": "2fd74371", + "metadata": {}, + "source": [ + "hvilket cirka har værdien (målt i radianer)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "abd3c7b3", + "metadata": {}, + "outputs": [], + "source": [ + "N(v,5)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "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.4" + }, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Demos/Demo-E-Uge-6-StoreDag.ipynb b/Demos/Demo-E-Uge-6-StoreDag.ipynb new file mode 100644 index 0000000..6a57442 --- /dev/null +++ b/Demos/Demo-E-Uge-6-StoreDag.ipynb @@ -0,0 +1,748 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "955d9e17", + "metadata": {}, + "source": [ + "# Determinanter\n", + "\n", + "Demo af Jakob Lemvig, Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "05c284f6", + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "cell_type": "markdown", + "id": "4de9ea48", + "metadata": {}, + "source": [ + "Vi betragter følgende matrix \n", + "\\begin{equation}\n", + " A = \\begin{bmatrix} 0 & 2 & 3 & 4 \\\\ 2 & 0 & 4 & 3 \\\\ 3 & 4 & 0 & 2 \\\\ 4 & 3 & 2 & 0\\end{bmatrix}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "0cef88be", + "metadata": {}, + "source": [ + "## Derterminant via SymPy\n", + "Til at finde determinanten her, benytter vi blot SymPy's indbyggede metode: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "497e3ec9", + "metadata": {}, + "outputs": [], + "source": [ + "A = Matrix([[0,2,3,4],[2,0,4,3],[3,4,0,2],[4,3,2,0]])\n", + "A.det()" + ] + }, + { + "cell_type": "markdown", + "id": "e3137bff", + "metadata": {}, + "source": [ + "eller den tilsvarende funktion:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7b98e0ec", + "metadata": {}, + "outputs": [], + "source": [ + "det(A)" + ] + }, + { + "cell_type": "markdown", + "id": "f1515e24", + "metadata": {}, + "source": [ + "## Determinant i hånden" + ] + }, + { + "cell_type": "markdown", + "id": "4c41be55", + "metadata": {}, + "source": [ + "Hvordan udregner man determinanten uden brug af den indbyggede `det()`? Vi prøver først at bruge definitionen i eNoterne. \n", + "\n", + "Vi vælger at opløse efter første række og finder derfor følgende snit-matricer:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c0da91c0", + "metadata": {}, + "outputs": [], + "source": [ + "hatA11 = A[1:4,1:4]\n", + "hatA12 = A[1:4,[0,2,3]]\n", + "hatA13 = A[1:4,[0,1,3]]\n", + "hatA14 = A[1:4,[0,1,2]]" + ] + }, + { + "cell_type": "markdown", + "id": "5ce6f49b", + "metadata": {}, + "source": [ + "Husk at fx snit-matricen $\\hat{A}_{1,3}$ fås fra $A$ ved at fjerne første rækker og 3 søjle fra $A$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "43f165d5", + "metadata": {}, + "outputs": [], + "source": [ + "hatA13" + ] + }, + { + "cell_type": "markdown", + "id": "a67d2d16", + "metadata": {}, + "source": [ + "Fra definitionen fås nu at $det(A)$ er:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "32d4e1c7", + "metadata": {}, + "outputs": [], + "source": [ + "A[0,0] * hatA11.det() - A[0,1] * hatA12.det() + A[0,2] * hatA13.det() - A[0,3] * hatA14.det()" + ] + }, + { + "cell_type": "markdown", + "id": "c293dff5", + "metadata": {}, + "source": [ + "Det passer, men bemærk at vi har snydt, da vi alligevel har brug `det()`. Problemet er at definitionen af determinanten er rekursiv. Vi kan \"løse\" dette ved at opløse hver af de fire $3 \\times 3$ matricer efter fx første rækker. Dette giver os $det(A)$ som en sum af determinanten af $4 \\cdot 3$ (dvs tolv) $2\\times 2$ matricer - og determinanten af $2\\times 2$ matricer findes let ved at \"gange over kryds\". " + ] + }, + { + "cell_type": "markdown", + "id": "f17fdad4", + "metadata": {}, + "source": [ + "**Alternativt**\n", + "\n", + "Determinanten af en trekantsmatrix er lig med produktet af diagonalelementerne. Da det således er meget nemt at udregne determinanten af en trekantsmatrix, kan vi ved rækkeoperationer prøve at få en matrix på \"trekantsform\" - vi skal blot huske at nogle rækkeoperationer ændrer på determinanten. Se eksempelvis matricen:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bdaa309e", + "metadata": {}, + "outputs": [], + "source": [ + "d = symbols('detA',real=True)\n", + "A = Matrix([[0, 2, 1],[1,3,2],[0,5,1]])\n", + "A, d" + ] + }, + { + "cell_type": "markdown", + "id": "a601bafc", + "metadata": {}, + "source": [ + "Hvis vi kan lave den om til en øvre (eller nedre) trekantsmatrix, kan vi gange diagonalelementerne sammen for at få determinanten. Dette kræver følgende rækkeoperationer:\n", + "\n", + "**Bytte rundt på rækker**: *Determinanten skifter fortegn*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "547068c3", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "A2 = A.elementary_row_op(\"n<->m\",0,1)\n", + "d2 = d*(-1)\n", + "A2, d2" + ] + }, + { + "cell_type": "markdown", + "id": "aa94d337", + "metadata": {}, + "source": [ + "**Gange række med konstant *k***: *Determinanten ganges med konstant *k**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b4b39a49", + "metadata": {}, + "outputs": [], + "source": [ + "k = S(1)/2\n", + "A3 = A2.elementary_row_op(\"n->kn\", 1, S(1)/2)\n", + "d3 = d2*k\n", + "A3, d3" + ] + }, + { + "cell_type": "markdown", + "id": "461377fb", + "metadata": {}, + "source": [ + "**Rækkeoperation af typen $R_j+k\\cdot R_i$**: *Determinanten ændres ikke*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8a2b1229", + "metadata": {}, + "outputs": [], + "source": [ + "A4 = A3.elementary_row_op(\"n->n+km\", 2, -5, 1)\n", + "d4 = d3\n", + "A4, d4" + ] + }, + { + "cell_type": "markdown", + "id": "92806d08", + "metadata": {}, + "source": [ + "Determinanten af denne trekantmatrix er blot produktet af diagonalelementerne: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0cd482cc", + "metadata": {}, + "outputs": [], + "source": [ + "det_diag = 1*1*(-S(3)/2)\n", + "det_diag" + ] + }, + { + "cell_type": "markdown", + "id": "0902a927", + "metadata": {}, + "source": [ + "Den oprindelige determinant kan nu findes ved at isolere $detA$ i ligningen: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "48e8f8cf", + "metadata": {}, + "outputs": [], + "source": [ + "Eq(det_diag,d4)" + ] + }, + { + "cell_type": "markdown", + "id": "7e5e03ba", + "metadata": {}, + "source": [ + "Der skal blot ganges igennem med $-2$ på begge sider (alternativt brug `solveset`, men det er overkill):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "517c426e", + "metadata": {}, + "outputs": [], + "source": [ + "Eq(-2*det_diag,-2*d4)" + ] + }, + { + "cell_type": "markdown", + "id": "74fbcd7f", + "metadata": {}, + "source": [ + "Som matcher med determinanten hvis vi havde brugt den indbyggede funktion:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "afa9d2e8", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "A, det(A)" + ] + }, + { + "cell_type": "markdown", + "id": "65c6f4bd", + "metadata": {}, + "source": [ + "## En anvendelse af determinanter" + ] + }, + { + "cell_type": "markdown", + "id": "887444b9", + "metadata": {}, + "source": [ + "Vi betragter nu følgende koeffecientmatrix og højreside:\n", + "\\begin{gather}\n", + "A = \\begin{bmatrix} a & 1 & 1 \\\\ 1 & a & 1 \\\\ 1 & 1 & a \\end{bmatrix} \\\\\n", + "b = \\begin{bmatrix} 1 \\\\ 1 \\\\ 1 \\end{bmatrix}\n", + "\\end{gather}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c731b31", + "metadata": {}, + "outputs": [], + "source": [ + "a = symbols(\"a\",real = true)\n", + "A = Matrix([[a,1,1],[1,a,1],[1,1,a]])\n", + "b = Matrix([1,1,1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9413828f", + "metadata": {}, + "outputs": [], + "source": [ + "A.rank()" + ] + }, + { + "cell_type": "markdown", + "id": "9a588e4b", + "metadata": {}, + "source": [ + "Her kan vi se at rangen af matricen har $\\rho(A) = 3$ i følge Sympy for et givet $a$. \n", + "Men er det altid tilfældet at $A$ har rank 3? Det vil gerne undersøge, og fordi \n", + "$A$ er kvadratisk, kan vi gøre det ved hjælp af determinanten." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7633de5b", + "metadata": {}, + "outputs": [], + "source": [ + "detA = A.det()\n", + "detA,linsolve((A,b))" + ] + }, + { + "cell_type": "markdown", + "id": "b9f241e9", + "metadata": {}, + "source": [ + "Her har vi fundet determinanten af $A$ og løsningsvektoren for matrixligningen $Ax = b$.\n", + "Allerede her kan vi se at der kan ske noget farligt. Hvad sker der hvis $a=-2$?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "51c336c5", + "metadata": {}, + "outputs": [], + "source": [ + "roots(detA,multiple=True), detA.factor()" + ] + }, + { + "cell_type": "markdown", + "id": "ed70275f", + "metadata": {}, + "source": [ + "Her kan vi se at $det(A)=a^3-3+2 = 0$ præcis når $a\\in \\{-2,1\\}$.\n", + "Lad os prøve at indsætte disse værdier af $a$ og løse ligningsystemet igen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40d706ac", + "metadata": {}, + "outputs": [], + "source": [ + "Asubs1 = A.subs(a,1)\n", + "display(Asubs1.rank())\n", + "Asubs2 = A.subs(a,-2)\n", + "Asubs2.rank()" + ] + }, + { + "cell_type": "markdown", + "id": "cf1cd7d5", + "metadata": {}, + "source": [ + "Nu er rangen ikke 3 længere, og vi kan derfor ikke forvente ikke at kunne finde løsninger for alle højresider." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b675fcc8", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "linsolve((Asubs1,b))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50a70d54", + "metadata": {}, + "outputs": [], + "source": [ + "try: # denne try-catch block er nødvendig, da SymPy giver en error.\n", + " linsolve(Asubs2,b)\n", + "except:\n", + " print(\"Kunne ikke finde en løsning\")" + ] + }, + { + "cell_type": "markdown", + "id": "99d8d65a", + "metadata": {}, + "source": [ + "Systemet er altså inkonsistent for $a=-2$.\n", + "\n", + "Vi kan tjekke dette udsagn ved at finde trappeformen af totalmatricen. Trappeformen af totalmatricen for hhv $a=1$ og $a=-2$ er: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab917436", + "metadata": {}, + "outputs": [], + "source": [ + "Asubs1.row_join(b).rref(pivots=False), \\\n", + "Asubs2.row_join(b).rref(pivots=False)" + ] + }, + { + "cell_type": "markdown", + "id": "e357c025", + "metadata": {}, + "source": [ + "Her ses at der for $a=1$ er to frie parametre, mens der for $a=-2$ ikke er nogen løsninger." + ] + }, + { + "cell_type": "markdown", + "id": "f8d86e75", + "metadata": {}, + "source": [ + "# Vektorer i $\\mathbb{R}^3$: Lineær (u)afhængighed" + ] + }, + { + "cell_type": "markdown", + "id": "21a0f009", + "metadata": {}, + "source": [ + "Vi betragter tre vektorer i $\\mathbb{R}^3$ i standard basis-koordinater:\n", + "\\begin{gather*} \n", + "\\begin{Bmatrix} \n", + "a_1 = \\begin{bmatrix} 1 \\\\ 1 \\\\ 1 \\end{bmatrix} &\n", + "a_2 = \\begin{bmatrix} 1 \\\\ 0 \\\\ 1 \\end{bmatrix} &\n", + "b = \\begin{bmatrix} 2 \\\\ -2 \\\\ 0 \\end{bmatrix}\n", + "\\end{Bmatrix} \n", + "\\end{gather*}\n", + "Vi vil nu gerne undersøge om $b$, kan skrives som linearkombination af $a_1$ og $a_2$\n", + "Altså vil gerne tjekke om der findes $x_1 \\neq 0,x_2 \\neq 0 $, så følgende ligning er opfyldt:\n", + "\\begin{equation*}\n", + " x_1 \\cdot a_1 + x_2 \\cdot a_2 = b\n", + "\\end{equation*}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4c52f4f7", + "metadata": {}, + "outputs": [], + "source": [ + "a_1 = Matrix([1,1,1])\n", + "a_2 = Matrix([1,0,1])\n", + "b = Matrix([2,-2,0])\n", + "a_1,a_2,b" + ] + }, + { + "cell_type": "markdown", + "id": "2f3ed4a1", + "metadata": {}, + "source": [ + "Dette svarer til at løse lignings systemet $\\begin{bmatrix} a_1 & | & a_2 \\end{bmatrix} = b$\n", + "Herunder ses en løsning til at vektorer om til sympy matrix" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d6699c6f", + "metadata": {}, + "outputs": [], + "source": [ + "Matrix.hstack(a_1,a_2,b).rref()" + ] + }, + { + "cell_type": "markdown", + "id": "0450f35a", + "metadata": {}, + "source": [ + "Heraf kan det ses, at $a_1$ og $a_2$ er lineært uafhængige med $b$ og kan derfor ikke skrives som en linearkombination af dem." + ] + }, + { + "cell_type": "markdown", + "id": "86a203bc", + "metadata": {}, + "source": [ + "## Undersøge om vektorer er lineært uafhængige" + ] + }, + { + "cell_type": "markdown", + "id": "efc863ef", + "metadata": {}, + "source": [ + "Vi betragter igen tre vektorer i $\\mathbb{R}^3$ i standard basis-koordinater:\n", + "\\begin{gather*} \n", + "\\begin{Bmatrix} \n", + "a_1 = \\begin{bmatrix} 2 \\\\ 2 \\\\ 7 \\end{bmatrix} &\n", + "a_2 = \\begin{bmatrix} 3 \\\\ 3 \\\\ 1 \\end{bmatrix} &\n", + "a_3 = \\begin{bmatrix} 12 \\\\ 9 \\\\ 2 \\end{bmatrix}\n", + "\\end{Bmatrix} \n", + "\\end{gather*}\n", + "og vi vil gerne undersøge om de tre vektorer er lineært uafhængige. Altså at ligningen\n", + "\\begin{gather*}\n", + "x_1 \\cdot a_1 + x_2 \\cdot a_2 + x_3 \\cdot a_3 = \\mathbf{0}\n", + "\\end{gather*}\n", + "har $\\{x_1 = 0, x_2 = 0, x_3 = 0\\}$ som eneste løsning." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7b3a1d32", + "metadata": {}, + "outputs": [], + "source": [ + "a_1 = Matrix([2,2,7])\n", + "a_2 = Matrix([3,3,1])\n", + "a_3 = Matrix([12,9,2])" + ] + }, + { + "cell_type": "markdown", + "id": "75fe35ad", + "metadata": {}, + "source": [ + "Vi løser nu matrix ligninen $[a_1 |a_2| a_3 ]x = \\mathbf{0}$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "96945d47", + "metadata": {}, + "outputs": [], + "source": [ + "A = Matrix.hstack(a_1,a_2,a_3)\n", + "linsolve(A)" + ] + }, + { + "cell_type": "markdown", + "id": "e5945314", + "metadata": {}, + "source": [ + "Altså har vi\n", + "\\begin{gather*}\n", + " \\begin{bmatrix} x_1 \\\\ x_2 \\\\ x_3 \\end{bmatrix} = \\begin{bmatrix} 0 \\\\ 0 \\\\ 0 \\end{bmatrix} \n", + "\\end{gather*}\n", + "som den eneste løsning. Dermed er de tre vektorer lineært uafhængige." + ] + }, + { + "cell_type": "markdown", + "id": "a2f5454d", + "metadata": {}, + "source": [ + "Vi gentager nu proceduren for vektorene:\n", + "\\begin{gather} \n", + "\\begin{Bmatrix} \n", + "b_1 = \\begin{bmatrix} 2 \\\\ 2 \\\\ 8 \\end{bmatrix} &\n", + "b_2 = \\begin{bmatrix} 3 \\\\ 3 \\\\ 12 \\end{bmatrix} &\n", + "b_3 = \\begin{bmatrix} 12 \\\\ 9 \\\\ 42 \\end{bmatrix}\n", + "\\end{Bmatrix} \n", + "\\end{gather}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3644ef9c", + "metadata": {}, + "outputs": [], + "source": [ + "b_1 = Matrix([2,2,8])\n", + "b_2 = Matrix([3,3,12])\n", + "b_3 = Matrix([12,9,46])\n", + "B = Matrix.hstack(b_1,b_2,b_3)\n", + "B.nullspace()" + ] + }, + { + "cell_type": "markdown", + "id": "50079866", + "metadata": {}, + "source": [ + "Her ser vi, at der andre løsninger end $\\{x_1 = 0, x_2 = 0, x_3 = 0\\}$, og da er de tre vektorer ikke er lineært uafhængige." + ] + }, + { + "cell_type": "markdown", + "id": "9407b101", + "metadata": {}, + "source": [ + "## Undersøg om tre vektorer er en _basis_ via determinant\n", + "Vi betragter tre vektorer i $\\mathbb{R}^3$ på standard basis-koordinater:\n", + "\\begin{gather} \n", + "\\begin{Bmatrix} \n", + "a_1 = \\begin{bmatrix} 2 \\\\ 2 \\\\ 7 \\end{bmatrix} &\n", + "a_2 = \\begin{bmatrix} 3 \\\\ 3 \\\\ 1 \\end{bmatrix} &\n", + "a_3 = \\begin{bmatrix} 12 \\\\ 9 \\\\ 2 \\end{bmatrix}\n", + "\\end{Bmatrix} \n", + "\\end{gather}\n", + "Og vi vil gerne undersøge om de udgør en basis for $\\mathbb{R}^3$.\n", + "Her skal vi blot tjekke om de er lineært uafhængige. Dette kan vi finde \n", + "ud af ved at tjekke om matricen:\n", + "$\\begin{bmatrix} a_1 & | & a_2 & | & a_3 \\end{bmatrix}$ har en determinant\n", + "forskellig fra 0, da den i det tilfælde vil have fuld rang og opfylde at\n", + "$\\{x_1 = 0, x_2 = 0, x_3 = 0\\}$ er den eneste løsning for ligningen:\n", + "\\begin{gather*}\n", + " x_1 \\cdot a_1 + x_2 \\cdot a_2 + x_3 \\cdot a_3 = \\mathbf{0}\n", + "\\end{gather*}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d0e0b13a", + "metadata": {}, + "outputs": [], + "source": [ + "A = Matrix([[2,2,7],[3,3,1],[12,9,2]]).T\n", + "det(A)" + ] + }, + { + "cell_type": "markdown", + "id": "0c47a5b4", + "metadata": {}, + "source": [ + "Vi ser at $det(A) = -57 \\neq 0$, og vektorerne må derfor være lineært uafhængige\n", + " og dermed udspænde en basis for $\\mathbb{R}^3$" + ] + }, + { + "cell_type": "markdown", + "id": "4c2f59e5", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "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.4" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "vscode": { + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Demos/Demo-E-Uge-7-StoreDag.ipynb b/Demos/Demo-E-Uge-7-StoreDag.ipynb new file mode 100644 index 0000000..8e7d2f7 --- /dev/null +++ b/Demos/Demo-E-Uge-7-StoreDag.ipynb @@ -0,0 +1,341 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Vektorrum\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Undersøg om vektorer er lineært uafhængige" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi betragter tre vektorer i vektorrummet $\\mathbb{R}^4$:\n", + "\n", + "$$\n", + "a_1 = \\begin{bmatrix} 1 \\\\ 2 \\\\ 1 \\\\ 0 \\end{bmatrix},\n", + "a_2 = \\begin{bmatrix} 1 \\\\ 7 \\\\ 3 \\\\ 1 \\end{bmatrix},\n", + "a_3 = \\begin{bmatrix} 3 \\\\ 12 \\\\ 5 \\\\ 2 \\end{bmatrix}\n", + "$$\n", + "\n", + "Vi vil gerne undersøge om de er lineært uafhængige. " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fremgangsmåde 1\n", + "Første metoden er at løse matrixligningen $A x = \\mathbf{0}$, hvor $A$ er givet ved:\n", + "\n", + "\\begin{equation*}\n", + " A = \n", + " \\begin{bmatrix} \n", + " a_1 & | & a_2 & | & a_3 \n", + " \\end{bmatrix}\n", + "\\end{equation*}\n", + "\n", + "Vi skriver $A$ ind i SymPy:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a1 = Matrix([1,2,1,0])\n", + "a2 = Matrix([2,7,3,1])\n", + "a3 = Matrix([3,12,5,2])\n", + "A = Matrix.hstack(a1,a2,a3)\n", + "A" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "og løser ligningssystemet:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "linsolve((A,Matrix.zeros(4,1)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Herfra kan det kan det ses, at det er uendeligt mange løsninger. Vektorerne er altså lineært **afhængige**. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fremgangsmåde 2\n", + "En anden metode er at finde **trap(A)**: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "A.rref()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Heraf kan vi se at vi kan finde $x_1 \\neq 0$ of $x_2 \\neq 0$, der opfylder ligningen:\n", + "\\begin{gather}\n", + "x_1 \\cdot a_1 + x_2 \\cdot a_2 = a_3\n", + "\\end{gather}\n", + "Vi dobbelt tjekker lige:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "A2 = Matrix.hstack(a1,a2)\n", + "linsolve((A2,a3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Derfor gælder at $a_3$ kan skrives som $-1 \\cdot a_1 + 2 \\cdot a_2$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Eq(a1 * (-1) + a2 * 2,a3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Om en delmængde af et vektorrum udgør et *underrum*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi betragter nu den delmængde af alle 3x3 matricer, der er skævsymmetriske, dvs. at vi undersøger matricer på følgende form:\n", + "\n", + "$\\begin{bmatrix} 0 & a & b \\\\ -a & 0 & c \\\\ -b & -c & 0 \\end{bmatrix}$.\n", + "\n", + "For at undersøge om mængden udgør et underrum, skal vi undersøge om den er stabil under addition med et andet element fra samme mængde og multiplikation med en skalar. Det betyder altså, at hvis vi adderer to matricer fra delmængden eller gang en matrice fra delmængden med et tal, så de resulterende matricer også være en del af delmængden.\n", + "\n", + "Til dette formål betragter vi to matricer **A** og **B**\n", + "\\begin{gather*}\n", + " \\textbf{A} = \\begin{bmatrix} 0 & a & b \\\\ -a & 0 & c \\\\ -b & -c & 0 \\end{bmatrix} \\\\\n", + " \\textbf{B} = \\begin{bmatrix} 0 & d & e \\\\ -d & 0 & f \\\\ -e & -f & 0 \\end{bmatrix}\n", + "\\end{gather*}\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a,b,c,d,e,f,k = symbols(\"a b c d e f k\")\n", + "A = Matrix([[0,a,b],[-a,0,c],[-b,-c,0]])\n", + "B = Matrix([[0,d,e],[-d,0,f],[-e,-f,0]])\n", + "A,B, A+B, k * A" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Som vi kan se er både **A** + **B** og *k* $\\cdot$ **A** skævsymmetriske og delmængden er dermed stabil og udgør dermed et underum. En anden måde dette resultat kan forstås på er, at vi ikke kan forlade underrummet via linære operationer." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Find en basis for en udspænding af vektorer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi betragter vektor rummet bestående at 2x2 matricer, altså $\\mathbb{R}^{2 \\times 2}$. I dette rum er givet matricerne **A**, **B**, **C**, og **D**:\n", + "\\begin{gather*}\n", + " \\textbf{A} = \\begin{bmatrix} 1 & -6 \\\\ 2 & 0 \\end{bmatrix},\n", + " \\textbf{B} = \\begin{bmatrix} 1 & 2 \\\\ -2 & 0 \\end{bmatrix} \\\\\n", + " \\textbf{C} = \\begin{bmatrix} -2 & 2 \\\\ 1 & 0 \\end{bmatrix},\n", + " \\textbf{D} = \\begin{bmatrix} 3 & -4 \\\\ -1 & 0 \\end{bmatrix}\n", + "\\end{gather*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi vil gerne finde dimensionen af $\\textbf{span}(\\{\\textbf{A},\\textbf{B},\\textbf{C},\\textbf{D}\\})$ og en basis for samme rum. Først opstiller vi koordinatmatricen **V** for de fire vektorer i den sædvanelige basis for $\\mathbb{R}^{2 \\times 2}$\n", + "\n", + "\\begin{gather*}\n", + " \\textbf{V} = \\begin{bmatrix} 1 & 1 & -2 & 3 \\\\\n", + " -6 & 2 & 2 & -4 \\\\\n", + " 2 & -2 & 1 & -1 \\\\\n", + " 0 & 0 & 0 & 0 \\end{bmatrix}\n", + "\\end{gather*}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "A = Matrix([[1,-6],[2,0]])\n", + "B = Matrix([[1,2],[-2,0]])\n", + "C = Matrix([[-2,2],[1,0]])\n", + "D = Matrix([[3,-4],[-1,0]])\n", + "# V = Matrix([[1,1,-2,3],[-6,2,2,-4],[2,-2,1,-1],[0,0,0,0]])\n", + "# i stedet for at skrive den hele ind ^^\n", + "# kan det også gøres ved\n", + "V = Matrix.hstack(A.reshape(4,1),\n", + " B.reshape(4,1),\n", + " C.reshape(4,1),\n", + " D.reshape(4,1))\n", + "V" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For at finde dimensionen af $\\textbf{span}(\\{\\textbf{A},\\textbf{B},\\textbf{C},\\textbf{D}\\})$ tager vi et kig på **trap(V)** (husk at det i SymPy fåes ved `.rref()`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "V.rref()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Da rangen af **trap(V)** er lig 2, så er dimensionen af $\\textbf{span}(\\{\\textbf{A},\\textbf{B},\\textbf{C},\\textbf{D}\\})$ og så lig 2. Vi kan af **trap(V)** aflæse at **A** og **B** er lineært uafhængige og udgør dermed en basis for $\\textbf{span}(\\{\\textbf{A},\\textbf{B},\\textbf{C},\\textbf{D}\\})$. Vi kan finde de nye koordinater for **C** og **D** ved at løse følgende ligninger:\n", + "\\begin{gather*}\n", + " x_1 \\cdot \\textbf{A} + x_2 \\cdot \\textbf{B} = \\textbf{C}\\\\\n", + " x_1 \\cdot \\textbf{A} + x_2 \\cdot \\textbf{B} = \\textbf{D}\n", + "\\end{gather*}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Koefficientmatrix for venstresiden:\n", + "V_12 = V[:,[0,1]]\n", + "# Højresiden er koordinatvektoren for hhv C og D\n", + "print(\"Koordinater for C:\")\n", + "display(linsolve((V_12, V[:,2])))\n", + "print(\"Koordinater for D:\")\n", + "linsolve((V_12, V[:,3]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Heraf kan vi se at koordinaterne for **C** og **D** i den nye basis er:\n", + "\\begin{gather*}\n", + " \\textbf{C} = -\\frac{3}{4} \\cdot \\textbf{A} -\\frac{5}{4} \\cdot \\textbf{B}\\\\\n", + " \\textbf{D} = \\frac{5}{4} \\cdot \\textbf{A} + \\frac{7}{4} \\cdot \\textbf{B}\n", + "\\end{gather*}\n", + "Vi tjekker lige efter for at være sikre" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Eq(C,-A * Rational(3/4) - Rational(5/4) * B), \\\n", + "Eq(D, Rational(5/4) * A + Rational(7/4) * B)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "language": "python", + "name": "mat1-pilot" + }, + "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.6" + }, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-E-Uge-8-LilleDag.ipynb b/Demos/Demo-E-Uge-8-LilleDag.ipynb new file mode 100644 index 0000000..27eaa4e --- /dev/null +++ b/Demos/Demo-E-Uge-8-LilleDag.ipynb @@ -0,0 +1,383 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "14b14fd2", + "metadata": {}, + "source": [ + "# Afbildningsmatricer og basisskifte\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aad4b143", + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "62d9e2a8", + "metadata": {}, + "source": [ + "I denne SymPy demo følger eksempler på *opstilling, brug og ændring af afbildningsmatricer ved basisskifte*. \n", + "\n", + "Der er givet en basis $a=(a_1,a_2,a_3)\\in \\mathbb{R}^3$ og en basis $c=(c_1,c_2)\\in \\mathbb{R}^2$. Derudover er der givet en lineær afbildning $f:\\mathbb{R}^3\\to \\mathbb{R}^2$ som opfylder\n", + "\n", + "\\begin{equation}\n", + "f(a_1)=c_1-2\\,c_2, \\;\\; f(a_2)=c_1+c_2, \\;\\; f(a_3) = 3\\,c_2\n", + "\\end{equation}\n", + "\n", + "Vi kan altså strakt opskrive afbildningsmatricen for $f$ med hensyn til de to baser:\n", + "\n", + "\\begin{equation}\n", + "{}_cF_a=\n", + "\\begin{bmatrix}\n", + "1&1&0\\\\-2&1&3\n", + "\\end{bmatrix}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "905fc014", + "metadata": {}, + "outputs": [], + "source": [ + "cFa = Matrix([[1,1,0],[-2,1,3]])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "444ceee8", + "metadata": {}, + "source": [ + "### Eksempel 1\n", + "\n", + "Vi får givet en vektor $x=-a_1+2\\,a_2+a_3\\in \\mathbb{R}^3$. Vi skal nu bestemme $f(x)$. Da $x$ er givet i basis $a$ kan vi benytte afbildningsmatricen direkte:\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "{}_ax= & \n", + "\\begin{bmatrix}\n", + "-1\\\\2\\\\1\n", + "\\end{bmatrix}\\\\\n", + "f(_ax) = & {}_cF_a {}_ax,\n", + "\\end{aligned}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b4ef9ef4", + "metadata": {}, + "outputs": [], + "source": [ + "ax = Matrix([-1,2,1])\n", + "cFa*ax" + ] + }, + { + "cell_type": "markdown", + "id": "861cdd64", + "metadata": {}, + "source": [ + "Altså at $f(x) = c_1+7\\,c_2$." + ] + }, + { + "cell_type": "markdown", + "id": "cf6a6847", + "metadata": {}, + "source": [ + "### Eksempel 2\n", + "\n", + "Givet $x=a_1-a_2+a_3\\in \\mathbb{R}^3$, undersøg om $x$ er en del af kernen for $f$. Dette gøres ved at undersøge om afbildningen giver nulvektoren:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5a9af20b", + "metadata": {}, + "outputs": [], + "source": [ + "ax = Matrix([1,-1,1])\n", + "cFa*ax" + ] + }, + { + "cell_type": "markdown", + "id": "9ff844be", + "metadata": {}, + "source": [ + "Da $f(x)=\\mathbf{0}$ er $x$ dermed en del af kernen." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "0aa3ae35", + "metadata": {}, + "source": [ + "### Eksempel 3\n", + "\n", + "Bestem kernen for $f$. \n", + "\n", + "Dette problem tilsvarer at finde alle de $x$ der opfylder $f(x)=\\mathbf{0}$, som på matrixform gøres ved at løse det homogene ligningssystem\n", + "\n", + "\\begin{equation}\n", + "{}_c F_a {}_a x = {}_c\\mathbf{0},\n", + "\\end{equation}\n", + "\n", + "som kan gøres ud fra totalmatricen på trappeform:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a8ec7de7", + "metadata": {}, + "outputs": [], + "source": [ + "T = Matrix.hstack(cFa,Matrix([0,0]))\n", + "T.rref()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "ffaec7eb", + "metadata": {}, + "source": [ + "Her kan vi se, at rangen af $_cF_a$ er 2, hvorved vi af dimensionssætningen ved at der er $3-2=1$ fri parameter, eller at $\\text{dim}(\\text{ker}\\,f)=1$. Vi ved nu fra Eksempel 2 ovenfor, hvordan kernen ser ud (hvorfor?). Alternativt, kan den aflæses af `T.rref()` til at være alle vektorer af formen: \n", + "\n", + "\\begin{equation}\n", + "{}_ax=\n", + "\\begin{bmatrix}\n", + "x_1\\\\x_2\\\\x_3\n", + "\\end{bmatrix} \n", + "= t \\,\n", + "\\begin{bmatrix}\n", + "1\\\\-1\\\\1\n", + "\\end{bmatrix}, \n", + "\\;\\;t\\in \\mathbb{R}.\n", + "\\end{equation}\n", + "\n", + "Skrevet ud fra basisvektorene bliver dette\n", + "\n", + "\\begin{equation}\n", + "ker f = \\{t\\,(a_1 - a_2 + a_3) \\; \\vert \\; t\\in \\mathbb{R} \\}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "2b76c2fe", + "metadata": {}, + "source": [ + "Vi kan bekræfte dette resultat ved de to andre metoder hvorpå SymPy kan finde kernen:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "60b6febc", + "metadata": {}, + "outputs": [], + "source": [ + "cFa.gauss_jordan_solve(Matrix([0,0]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c48679c8", + "metadata": {}, + "outputs": [], + "source": [ + "cFa.nullspace()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "0d0928fc", + "metadata": {}, + "source": [ + "### Eksempel 4" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "eb646c95", + "metadata": {}, + "source": [ + "Givet $b=2\\,c_1-c_2$, løs den lineære ligning $f(x)=b$. Dette tilsvarer på matrixform at løse det inhomogene ligningssystem ${}_cF_a {}_ax=_cb$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0c9ceed4", + "metadata": {}, + "outputs": [], + "source": [ + "cB = Matrix([2,-1])\n", + "cFa.gauss_jordan_solve(cB)" + ] + }, + { + "cell_type": "markdown", + "id": "849aa221", + "metadata": {}, + "source": [ + "Vi kan aflæse løsningen til \n", + "\n", + "\\begin{equation}\n", + "_ax=\\begin{bmatrix}x_1\\\\x_2\\\\x_3\\end{bmatrix}=\\begin{bmatrix}1\\\\1\\\\0\\end{bmatrix}+t\\,\\begin{bmatrix}1\\\\-1\\\\1\\end{bmatrix}, \\;\\; t\\in \\mathbb{R}.\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "1b678c2b", + "metadata": {}, + "source": [ + "Læg her mærke til, at den frie parameter skalerer vektoren vi også fandt for kernen af $f$. Dette stemmer overens med struktursætningen!\n", + "\n", + "Resultatet kan også skrives ud fra basisvektorene som \n", + "\n", + "\\begin{equation}\n", + "x=(1+t)\\,a_1+(1-t)\\,a_2+a_3, \\;\\; t\\in \\mathbb{R}\n", + "\\end{equation}" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "f3b2bb8f", + "metadata": {}, + "source": [ + "### Eksempel 5\n", + "\n", + "Bestem en basis for billedrummet $f(\\mathbb{R}^3)$.\n", + "\n", + "Vi kan finde dimensionen af billedrummet ved brug af dimensionssætningen. Her finder vi, at $\\text{dim}(f(\\mathbb{R}^3))=\\text{dim}(\\mathbb{R}^3)-\\text{dim}(\\text{ker}\\,f)=3-1=2$.\n", + "Da billedrummet også har dimension 2, skal vi altså bare finde 2 lineært uafhængige vektorer i $\\mathbb{R}^2$. Et eksempel på lineært uafhængige vektorer kan findes fra reducering af totalmatricen fra *Eksempel 3*. Her ved vi, at afbildningen af de første 2 basisvektorer, $f(a_1)=c_1-2\\,c_2$ og $f(a_2)=c_1+c_2$ er lineært uafhængige. En mulig basis for billedrummet vil derfor være\n", + "\n", + "\\begin{equation}\n", + "(c_1-2\\,c_2,\\,c_1+c_2)\n", + "\\end{equation}\n", + "\n", + "Dette er også den basis man kommer frem til, hvis man benytter den indbyggede `columnspace()` funktion:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "83e36084", + "metadata": {}, + "outputs": [], + "source": [ + "cFa.columnspace()" + ] + }, + { + "cell_type": "markdown", + "id": "662d27d4", + "metadata": {}, + "source": [ + "Læg mærke til, at vi har lavet de første fem eksempler med arbitrær basis, $a$ og $c$ i de to talrum! Dette gælder altså for alle mulige valg af basis, altså både standardbasis, den basis der introduceres i næste eksempel og hvilken som helst anden basis!" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "ec5e6a5d", + "metadata": {}, + "source": [ + "### Eksempel 6\n", + "\n", + "Vi får nu givet basisvektorene for $a$ og $c$ i standard basis koordinater! De er,\n", + "\n", + "\\begin{equation}\n", + "\\begin{aligned}\n", + "a_1 = & (1,2,0)\\\\\n", + "a_2 = & (1,1,0)\\\\\n", + "a_3 = & (0,0,1)\\\\\n", + "c_1 = & (1,-1)\\\\\n", + "c_2 = & (2,0).\n", + "\\end{aligned}\n", + "\\end{equation}\n", + "\n", + "Vi skal nu bestemme afbildningsmatricen for $f$ i standard basis koordinater, nemlig ${}_eF_e$, hvor vi indtil videre kun kender ${}_cF_a$. For at gøre dette, kan vi udnytte at der gælder at\n", + "\n", + "\\begin{equation}\n", + "{}_eF_e = {}_eM_c {}_cF_a {}_aM_e.\n", + "\\end{equation}\n", + "\n", + "Da vi nu har basisvektorene i standard basis koordinater, kan vi opskrive basisskiftematricerne, og udregne svaret:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4091fc6c", + "metadata": {}, + "outputs": [], + "source": [ + "eMa = Matrix([[1,1,0],[2,1,0],[0,0,1]])\n", + "aMe = eMa.inv()\n", + "eMc = Matrix([[1,2],[-1,0]])\n", + "eFe = eMc*cFa*aMe\n", + "eFe" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8bade218", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 ('mat1-pilot': venv)", + "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.6" + }, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Demos/Demo-E-Uge-8-StoreDag.ipynb b/Demos/Demo-E-Uge-8-StoreDag.ipynb new file mode 100644 index 0000000..9a570cd --- /dev/null +++ b/Demos/Demo-E-Uge-8-StoreDag.ipynb @@ -0,0 +1,625 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "14b14fd2", + "metadata": {}, + "source": [ + "# Lineære afbildninger\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aad4b143", + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "cell_type": "markdown", + "id": "9ac0407d", + "metadata": {}, + "source": [ + "## Eksempel\n", + "\n", + "Vi vil gerne undersøge om en afbildning er lineær. For dette, undersøger vi afbildningen $f:\\mathbb{R}^2 \\to \\mathbb{R}^4$ givet ved\n", + "\n", + "\\begin{equation}\n", + "f(x_1,x_2)=(2\\,x_1+x_2,\\;3\\,x_1+2\\,x_2,\\;x_1+x_2,\\;2\\,x_1+3\\,x_2).\n", + "\\end{equation}\n", + "\n", + "Dette vil vi undersøge ved 2 metoder:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7cfbc08e", + "metadata": {}, + "outputs": [], + "source": [ + "def f(x):\n", + " x1 = x[0]\n", + " x2 = x[1]\n", + " return Matrix([2*x1+x2, 3*x1+2*x2, x1+x2, 2*x1+3*x2])\n", + " \n", + "u1,u2,v1,v2,k = symbols('u_1,u_2,v_1,v_2,k')\n", + "u = Matrix([u1,u2])\n", + "v = Matrix([v1,v2])\n", + "\n", + "display(u, v, f(u))" + ] + }, + { + "cell_type": "markdown", + "id": "ece556b5", + "metadata": {}, + "source": [ + "### Metode 1: Definition 12.5\n", + "\n", + "Vi ved at en afbildning er lineær, hvis den for vilkårlige vektorer $u$ og $v$, samt en vilkårlig skalar $k$ opfylder linearitetsbetingelserne:\n", + "\n", + "\\begin{equation}\n", + "\\begin{aligned}\n", + "L_1: & f(u+v)=f(u)+f(v).\\\\\n", + "L_2: & f(k\\,u)=k\\,f(u).\n", + "\\end{aligned}\n", + "\\end{equation}\n", + "\n", + "Dette kan altså eftertjekkes ved følgende," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4078efd9", + "metadata": {}, + "outputs": [], + "source": [ + "# L1:\n", + "f(u+v) - (f(u)+f(v))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "917a40ea", + "metadata": {}, + "outputs": [], + "source": [ + "# L2:\n", + "simplify(f(k*u)-k*f(u))" + ] + }, + { + "cell_type": "markdown", + "id": "79236966", + "metadata": {}, + "source": [ + "Vi kan altså se, at begge linearitetsbetingelser er opfyldt. Dermed må funktionen være lineær!" + ] + }, + { + "cell_type": "markdown", + "id": "1dc4a473", + "metadata": {}, + "source": [ + "### Metode 2: Hovedsætning 12.18\n", + "\n", + "Vi kan udnytte en af resultaterne fra hovedsætning 12.18. Nemlig hvis vi kan skrive afbildningen $y=f(x)$ på koordinatform ved \n", + "\n", + "\\begin{equation}\n", + "y=G\\,x,\n", + "\\end{equation}\n", + "\n", + "med $G\\in \\mathbb{R}^{m\\times n}$, så er $f$ lineær." + ] + }, + { + "cell_type": "markdown", + "id": "f8b6f1fc", + "metadata": {}, + "source": [ + "Vi kan se, at f har matrixfremstillingen (med hensyn til standardbaserne i $\\mathbb{R}^4$ og $\\mathbb{R}^2$): \n", + "\n", + "\\begin{equation}\n", + "\\begin{aligned}\n", + "y = & F\\,x\\\\\n", + "\\begin{bmatrix}2\\,x_1+x_2\\\\ 3\\,x_1+2\\,x_2\\\\ x_1+x_2\\\\ 2\\,x_1+3\\,x_2\\end{bmatrix} = & \\begin{bmatrix}2&1\\\\3&2\\\\1&1\\\\2&3\\end{bmatrix} \\begin{bmatrix}x_1\\\\x_2\\end{bmatrix}.\n", + "\\end{aligned}\n", + "\\end{equation}" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "a9554387", + "metadata": {}, + "source": [ + "Af hovedsætning 12.18 fåes at matricen $F \\in \\mathbb{R}^{4\\times 2}$ givet ved\n", + "\n", + "\\begin{equation}\n", + "F = \\begin{bmatrix} \n", + "2&1\\\\3&2\\\\1&1\\\\2&3 \n", + "\\end{bmatrix},\n", + "\\end{equation}\n", + "\n", + "er afbildningsmatricen m.h.t. standard e-baserne. Ydermere ser vi, at søjlerne i matricen er billederne af basisvektorene, da:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "31321695", + "metadata": {}, + "outputs": [], + "source": [ + "f([1,0]),f([0,1])" + ] + }, + { + "cell_type": "markdown", + "id": "98381f45", + "metadata": {}, + "source": [ + "Husk at hvis den lineære afbildning er givet, kan man **altid** finde afbildningsmatricen på denne måde. Med standardbasen kan identitetsmatricen `eye` bruges således:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "828915b1", + "metadata": {}, + "outputs": [], + "source": [ + "n = 2\n", + "m = 4\n", + "V = eye(n)\n", + "F = zeros(m,n)\n", + "for k in range(n):\n", + " F[:,k] = f(V[:,k])\n", + "F" + ] + }, + { + "cell_type": "markdown", + "id": "c0160c0c", + "metadata": {}, + "source": [ + "## Typiske løsninger ved brug af afbildningsmatrix\n", + "\n", + "Vi betragter en afbildning $g:\\mathbb{R}^3\\to\\mathbb{R}^4$, som med hensyn til standardbaserne i de to vektorrum er givet ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "73268185", + "metadata": {}, + "outputs": [], + "source": [ + "G = Matrix([[1,3,1],[2,4,0],[1,1,-1],[-3,-1,5]])\n", + "G" + ] + }, + { + "cell_type": "markdown", + "id": "bea01701", + "metadata": {}, + "source": [ + "Her følger fem eksempler på hvordan en opgave kan løses ved brug af denne afbildningsmatrix." + ] + }, + { + "cell_type": "markdown", + "id": "56fb44be", + "metadata": {}, + "source": [ + "### Eksempel 1: Finde billeder af given vektor\n", + "\n", + "Hvis vi vil finde billedet $g(v)$ af en vektor $v$, kan dette gøres let ved " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5ec4655c", + "metadata": {}, + "outputs": [], + "source": [ + "v = Matrix([1,-2,5])\n", + "G*v\n" + ] + }, + { + "cell_type": "markdown", + "id": "8ea7e1e2", + "metadata": {}, + "source": [ + "Det ses altså at $g(v) = (0,-6,-6,24)$" + ] + }, + { + "cell_type": "markdown", + "id": "ae6b00a5", + "metadata": {}, + "source": [ + "### Eksempel 2: Undersøge om given vektor tilhører kernen\n", + "\n", + "Hvis vi vil se om en vektor $v$ tilhører kernen, skal vi se, at $g(v)$ er nul-vektoren. Dette ses gjort her" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1cbe4050", + "metadata": {}, + "outputs": [], + "source": [ + "v = Matrix([-6,3,-3])\n", + "G*v" + ] + }, + { + "cell_type": "markdown", + "id": "37c6f81f", + "metadata": {}, + "source": [ + "### Eksempel 3: Finde kernen for afbildning\n", + "\n", + "Da det vides at $x\\in \\text{ker}(g)$ gælder *hvis og kun hvis* $g(x)=\\mathbf{0}$, kan vi altså finde kernen til afbildningen ved at løse\n", + "\n", + "\\begin{equation}\n", + "G\\,x=\\mathbf{0}.\n", + "\\end{equation}\n", + "\n", + "Dette kan gøres ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "52ba16d8", + "metadata": {}, + "outputs": [], + "source": [ + "G.rref()" + ] + }, + { + "cell_type": "markdown", + "id": "ff27c20a", + "metadata": {}, + "source": [ + "Nu kan vi aflæse kernen til \n", + "\n", + "\\begin{equation}\n", + "\\text{ker}\\,g=\\text{span}\\{(2,-1,1)\\}.\n", + "\\end{equation}\n", + "\n", + "Dette passer med dimensionssætningen, der siger at\n", + "\n", + "\\begin{equation}\n", + "\\begin{aligned}\n", + "\\text{dim}(\\text{ker}\\,g) = & \\text{dim}(\\mathbb{R}^3)-\\rho(G)\\\\\n", + "= & 3-2 \\\\\n", + "= & 1.\n", + "\\end{aligned}\n", + "\\end{equation}\n", + "\n", + "En anden måde at se dette på er ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "26a48541", + "metadata": {}, + "outputs": [], + "source": [ + "G.gauss_jordan_solve(Matrix([0,0,0,0]))" + ] + }, + { + "cell_type": "markdown", + "id": "d8fb2557", + "metadata": {}, + "source": [ + "Kontrol: Dette giver den samme vektor, som hvis man direkte beder om de vektorer der udspænder kernen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d40ffafc", + "metadata": {}, + "outputs": [], + "source": [ + "G.nullspace()" + ] + }, + { + "cell_type": "markdown", + "id": "a65a7761", + "metadata": {}, + "source": [ + "### Eksempel 4: Bestemme billedrummet\n", + "\n", + "Vi ved fra den reducerede matrix ovenfor, at $\\rho(G)=\\text{dim}(g(\\mathbb{R}^3))=2$. Dermed skal en basis for billedrummet bestå af 2 lineært uafhængige vektorer. Husk først at alle søjler af $G$ tilhører billedrummet, da de er billedet af standardbasis-vektorerne $\\pmb{e}_1, \\pmb{e}_2, \\pmb{e}_3$. Vi kan altså nøjes med at finde to lineært uafhængige søjler i $G$. Fra `G.rref()`ovenfor kan vi se at de første 2 søjler i $G$ er lineært uafhængige, da der er ledende et-taller i $trap(G)$. Derfor kan det aflæses at\n", + "\n", + "\\begin{equation}\n", + "g(\\mathbb{R}^3) = \\text{span}\\{(1,2,1,-3),(3,4,1,-1)\\}.\n", + "\\end{equation}\n", + "\n", + "Bemærk at fx søjle 1 og 3 også kunne være brugt her -- generelt kan billedrummet skrives på uendeligt mange måder. \n", + "\n", + "Man kan også benytte den indbyggede funktion til at få billedrummet:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a88dd23", + "metadata": {}, + "outputs": [], + "source": [ + "G.columnspace()" + ] + }, + { + "cell_type": "markdown", + "id": "3032f140", + "metadata": {}, + "source": [ + "I dette tilfælde giver funktionen de samme vektorer. Dette er ikke altid tilfældet, men de skal udspænde det samme rum!" + ] + }, + { + "cell_type": "markdown", + "id": "91c8e526", + "metadata": {}, + "source": [ + "### Eksempel 5: Undersøge om given vektor tilhører billedrummet\n", + "\n", + "Da det gælder at $b \\in g(\\mathbb{R}^3)$ er ensbetydende med, at der findes en vektor $x \\in \\mathbb{R}^3$ således at $g(x)=b$, skal vi altså løse ligningssystemet\n", + "\n", + "\\begin{equation}\n", + "G\\,x=b\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "1b008437", + "metadata": {}, + "source": [ + "Først ser vi hvad der sker hvis det ikke kan lade sig gøre:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "36dc1f2d", + "metadata": {}, + "outputs": [], + "source": [ + "b1 = Matrix([1,2,1,-4])\n", + "T1 = Matrix.hstack(G,b1)\n", + "\n", + "T1.rref()" + ] + }, + { + "cell_type": "markdown", + "id": "428cf8d1", + "metadata": {}, + "source": [ + "Systemet har tydeligvis ingen løsninger. Dette ses også meget tydeligt, hvis vi beder SymPy om at løse ligningssystemet:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46feff5c", + "metadata": {}, + "outputs": [], + "source": [ + "G.gauss_jordan_solve(b1)" + ] + }, + { + "cell_type": "markdown", + "id": "51e0f246", + "metadata": {}, + "source": [ + "Hvis vektoren til gengæld befinder sig i billedrummet ser vi følgende:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2c5334d", + "metadata": {}, + "outputs": [], + "source": [ + "b2 = Matrix([3,0,-3,15])\n", + "T2 = Matrix.hstack(G,b2)\n", + "\n", + "T2.rref()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "057d3d03", + "metadata": {}, + "source": [ + "Som tydeligvis har en løsning. Vi ser at $b_2\\in g(\\mathbb{R}^3)$ har koordinaterne $(-6,3)$ med hensyn til basen $((1,2,1,-3),(3,4,1,-1))$ for $g(\\mathbb{R}^3)$. Samtidigt findes der uendeligt mange vektorer der via $g$ bliver afbildet i $b$, nemlig alle dem der har formen:\n", + "\n", + "\\begin{equation}\n", + "(-6,3,0)+t\\,(2,-1,1), \\;\\;\\;t\\in\\mathbb{R}\n", + "\\end{equation}\n", + "\n", + "Nu virker `gauss_jordan_solve()` også, som bekræfter hvad vi aflæste:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "714efd1d", + "metadata": {}, + "outputs": [], + "source": [ + "G.gauss_jordan_solve(b2)" + ] + }, + { + "cell_type": "markdown", + "id": "d4420b14", + "metadata": {}, + "source": [ + "## Ændring af afbildningsmatrix ved basisskifte\n", + "\n", + "Her følger to eksempler hvor vi ændrer afbildningsmatricen ved brug af basisskifte. I det følgende kommer matricerne altså til at blive beskrevet ved notationen der beskriver hvilken basis de skifter fra og til." + ] + }, + { + "cell_type": "markdown", + "id": "72368aa5", + "metadata": {}, + "source": [ + "#### Eksempel 1\n", + "\n", + "En basis $a=((5,3),(-2,-1))$ er givet. I *denne* basis er den lineære afbildning $h\\mathbb{R}^2\\to \\mathbb{R}^2$ givet ved afbildningsmatricen\n", + "\n", + "\\begin{equation}\n", + "_aH_a=\\begin{bmatrix}1&2\\\\3&4\\end{bmatrix}\n", + "\\end{equation}" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "aa51e2c5", + "metadata": {}, + "source": [ + "#### Hvad er afbildningsmatricen med hensyn til standardbasis?\n", + "\n", + "For at finde $_eH_e$ skal vi benytte basisskiftematricen, som opskrives ud fra basisvektorene,\n", + "\n", + "\\begin{equation}\n", + "{}_eM_a=\n", + "\\begin{bmatrix}\n", + "5&-2\\\\3&-1\n", + "\\end{bmatrix}\n", + "\\end{equation}\n", + "\n", + "og omvendt, skal vi også bruge basisskiftematricen der går fra standardbasis til basis $a$,\n", + "\n", + "\\begin{equation}\n", + "{}_aM_e = {}_eH_a^{-1}=\n", + "\\begin{bmatrix}\n", + "-1&2\\\\-3&5\n", + "\\end{bmatrix}.\n", + "\\end{equation}\n", + "\n", + "Nu findes den ønskede afbildningsmatrix ved \n", + "\n", + "\\begin{equation}\n", + "{}_eH_e = {}_eM_a {}_aH_a {}_aM_e,\n", + "\\end{equation}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7ec3165a", + "metadata": {}, + "outputs": [], + "source": [ + "aHa = Matrix([[1,2],[3,4]])\n", + "eMa = Matrix([[5,-2],[3,-1]])\n", + "aMe = Matrix([[-1,2],[-3,5]])\n", + "eHe = eMa*aHa*aMe\n", + "eHe" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "18855e85", + "metadata": {}, + "source": [ + "#### Eksempel 2\n", + "\n", + "Den samme basis $a$ er givet. I *standard* basis er den lineære afbildning $k:\\mathbb{R}^2\\to \\mathbb{R}^2$ givet ved afbildningsmatricen\n", + "\n", + "\\begin{equation}\n", + "{}_eK_e=\\begin{bmatrix}-2&0\\\\1&3\\end{bmatrix}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "bb33de31", + "metadata": {}, + "source": [ + "#### Hvad er afbildningsmatricen med hensyn til $a$-basis?\n", + "\n", + "Da vi allerede kender basisskiftematricerne for $a$ og $e$-basis, kan vi direkte finde den ønskede afbildningsmatrice," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5fcdcbeb", + "metadata": {}, + "outputs": [], + "source": [ + "eKe = Matrix([[-2,0],[1,3]])\n", + "aKa = aMe*eKe*eMa\n", + "aKa" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a96f5e50", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "language": "python", + "name": "mat1-pilot" + }, + "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.6" + }, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Demos/Demo-E-Uge-9-StoreDag.ipynb b/Demos/Demo-E-Uge-9-StoreDag.ipynb new file mode 100644 index 0000000..41a9922 --- /dev/null +++ b/Demos/Demo-E-Uge-9-StoreDag.ipynb @@ -0,0 +1,226 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Første ordens linære differentialligninger\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi er givet følgende 1. ordens linære inhomogene differentialligning\n", + "\\begin{equation*}\n", + " \\frac{\\text{d}}{\\text{d}t}x(t) + x(t) = e ^ t\n", + "\\end{equation*}\n", + "Vi ønsker at gøre følgende\n", + "1. Bestemme den fuldstændige løsning\n", + "2. Bestemme en løsning, der opfylder $x(0)=2$\n", + "3. Undersøge hvad startbetingelsen har af inflydelse på løsningen." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Metode 1: Simuleret håndregning\n", + "Her vil anvende SymPy til at bruge panser-formlen på vores differntialligning" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "t,C = symbols('t C')\n", + "p = 1\n", + "P = integrate(p,t)\n", + "q = exp(t)\n", + "res = exp(-P) * (integrate(exp(P) * q,t) + C)\n", + "res" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi har nu fundet den fuldstændige løsning. Nu skal vi finde en løsning, hvor $x(0)=2$. Da vi har fundet $x(t)$ kan vi indsætte 0 på $t$'s plads og løse for $C_1$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "solve(Eq(res.subs(t,0), 2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Altså har vi:\n", + "$x(t) = \\frac{3}{2 e ^ t} + \\frac{e ^ t}{2}$\n", + "Da dette er den eneste løsning er vi i overensstemmelse med *eksistens- og entydighedssætningen*.\n", + "Vi plotter løsningen:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "res.subs(C,3/2).expand()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot(res.subs(C,3/2),xlim=(-1,2),ylim=(0,5))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kontrollerer at grafen faktisk går igennem punktet (0,2)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Metode 2: Funktionen dsolve\n", + "\n", + "Den næste metode gør brug af SymPy's indbyggede funktion $\\text{dsolve}$, der løser differentialligninger.\n", + "Lige som vi definerer vores variable via funktionen $\\text{symbols}$, når vi skal løse f.eks. ligninger,\n", + "så skal også definere funktionsvariabler, som repræsenterer ukendte funktioner, når vi løser differentialligninger.\n", + "Dette gøres via funktionen $\\text{Function()}$," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = Function('x')\n", + "dsolve(Eq(diff(x(t),t)+x(t),exp(t)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu har vi den fuldstændige løsning. Vi kan også bruge SymPy til at finde en specifik løsning.\n", + "I det tilfælde skal blot bruge funktionsparameteren $\\text{ics()}$, som er \"initial conditions\"." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "res = dsolve(Eq(diff(x(t),t) + x(t),exp(t)),ics = {x(0) : 2})\n", + "res" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Her kan vi se, at vi får den samme løsning. Mon ikke også den ser ens ud, når vi plotter den." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot(res.rhs,xlim=(-1,2),ylim=(0,5))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Som forventet! \n", + "\n", + "Vi kan også bruge Pythons loops til at vise mange forskellige startbetingelser:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p1 = plot(show=False)\n", + "for x0 in range(11):\n", + " # Ny ligning med nye initial conditions\n", + " neweq = dsolve(Eq(diff(x(t),t) + x(t),exp(t)),ics = {x(0) : x0})\n", + " # Nyt plot, hvor vi plotter for t mellem -1 og 2\n", + " newplot = plot(neweq.rhs, (t, -1, 2), show=False)\n", + " # tilføj til vores plot\n", + " p1.extend(newplot)\n", + "p1.xlim = (-1,2)\n", + "p1.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 ('mat1-pilot': venv)", + "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.6" + }, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-F-Uge-1-LilleDag.ipynb b/Demos/Demo-F-Uge-1-LilleDag.ipynb new file mode 100644 index 0000000..4c15b2a --- /dev/null +++ b/Demos/Demo-F-Uge-1-LilleDag.ipynb @@ -0,0 +1,719 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Grafer og tangentplaner\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "from dtumathtools import *\n", + "init_printing()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## En definitionsmængde\n", + "\n", + "Vi ønsker at finde definitionsmængden for funktionen\n", + "\n", + "\\begin{equation}\n", + "f(x,y)=\\sqrt{1+y^2-y\\,x^2}.\n", + "\\end{equation}\n", + "\n", + "Alt under kvadratroden skrives ind ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x, y = symbols(\"x y\")\n", + "g = y**2 - x**2\n", + "g" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For ikke at få komplekse tal ud, skal vi finde $(x,y)$, hvor \n", + "\n", + "\\begin{equation}\n", + "y^{2} - x^{2} \\geq 0.\n", + "\\end{equation}\n", + "\n", + "Vi finder først der hvor \n", + "\n", + "\\begin{equation}\n", + "y^{2} - x^{2} = 0,\n", + "\\end{equation}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "solveset(Eq(g,0),y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_implicit(Eq(g,0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi har nu delt planen i 4 områder. For at undersøge hvilke der er større eller mindre end 0, undersøger vi et punkt fra hver," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "display(g.subs({x:1,y:0}), g.subs({x:0,y:1}), g.subs({x:-1,y:0}), g.subs({x:0,y:-1}))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Da $g(x,y)$ er kontinuert, kan den ikke skifte fortegn uden først at have været igennem $g(x,y)=0$. Dette må altså betyde, at områderne har samme fortegn inden for linjerne. Vi konkluderer, at det øverste og nederste område er vores definitionsmængde!\n", + "\n", + "Vi kan også tjekke dette efter ved at plotte," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_implicit(g>0)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note: Definitionsmængden for $f$ ($Dm(f)$) er *afsluttet* (indeholder hele sin *rand*) og *ubegrænset* (kan ikke omkrandses af en cirkel)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Approksimerende førstegradspolynomium og tangentplan\n", + "\n", + "Vi definerer en funktion af to variable,\n", + "\n", + "\\begin{equation}\n", + "f(x,y)=4-x^2-y^2,\n", + "\\end{equation}\n", + "\n", + "hvis graf er en parabloide," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f = 4-x**2-y**2\n", + "\n", + "dtuplot.plot3d(f,(x,-2,2), (y,-2,2),use_cm=True, legend=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi vil opstille *det approximerende førstegradspolynomium* for $f$ med udviklingspunktet $a=(1,-1)$.\n", + "\n", + "Vi finder de partielt afledteaf $f$ i $a$ mht. $x$ og $y$, som indgår i det approximerende polynomium," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# skrives \"a\" på denne måde, er det lettere at substituere ind i f\n", + "a = {x:1,y:-1}\n", + "P1 = f.subs(a)+f.diff(x).subs(a)*(x-1)+f.diff(y).subs(a)*(y+1)\n", + "P1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan også bruge ``.series()`` til at få det samme resultat, her skrevet pænt sammen i en funktion," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def poly_approx(f, var, expand_from, degree):\n", + " for i, x in enumerate(var):\n", + " f = f.series(x, expand_from[i], degree+1).removeO()\n", + " return f\n", + "\n", + "poly_approx(f, (x,y), (1,-1), 1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Da vi har udviklet ud fra $(1,-1)$, ved vi at punkterne $(1,-1,f(1,-1))$ og $(1,-1,p_1(1,-1))$ er identiske!\n", + "\n", + "Tangentplanen har derfor ligningen\n", + "\n", + "\\begin{equation}\n", + "z=6-2x+2y,\n", + "\\end{equation}\n", + "\n", + "som også kan skrives som \n", + "\n", + "\\begin{equation}\n", + "2x-2y+z=6.\n", + "\\end{equation}\n", + "\n", + "Af den sidste ligning kan vi aflæse normalvektoren for tangentplanen til\n", + "\n", + "\\begin{equation}\n", + "N=(2,-2,1).\n", + "\\end{equation}\n", + "\n", + "Dette kan plottes sammen med figuren," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "N = Matrix([2,-2,1])\n", + "a0 = Matrix([1,-1,f.subs(a)])\n", + "\n", + "p = dtuplot.plot3d(f,(x,-2,2), (y,-2,2), rendering_kw={\"alpha\":0.3,\"cmap\":\"Blues\"}, xlim=(-2,3), ylim=(-3,2), zlim=(-1,4),camera={\"elev\":10,\"azim\":-110},show=False)\n", + "p.extend(dtuplot.plot3d(P1,(x,0,2), (y,-2,0), rendering_kw={\"color\":\"green\", \"alpha\":0.5}, show=False))\n", + "p.extend(dtuplot.scatter(a0, rendering_kw={\"alpha\":1, \"s\":100, \"color\":\"black\"}, show=False))\n", + "p.extend(dtuplot.quiver(a0, N, {\"color\":\"red\"}, show=False))\n", + "\n", + "p.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "En vigtig detalje ved ovenstående plot er grænserne der er blevet sat (xlim, ylim, zlim). Dette sørger for, at alle 3 dimensioner er lige store. Hvis ikke dette gøres, vil vinkelrette ting ikke ligne, at de er vinkelrette. Dette kan også opnåes ved at indtaste ``aspect=\"equal\"`` som argument i stedet for at give specifikke grænser. Dette er ikke gjort her, da figuren i dette tilfælde blev for lille (man kan så ikke selv styre grænserne)." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## En højdefunktion\n", + "\n", + "Vi har en funktion af to variable," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x,y,u = symbols(\"x y u\")\n", + "f = x**2/10+y**2/10+10\n", + "f" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Og vi har en parametriseret kurve i $(x,y)$-planen," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r = Matrix([u*cos(u), u*sin(u)])\n", + "r\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Højdefunktionen bliver nu," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "h = f.subs({x:r[0],y:r[1]})\n", + "simplify(h)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$h$ måler altså den lodrette afstand fra kurven i $(x,y)$ planen til grafen for $f$. Dette kan vi illustrere i følgende plot for $u=\\pi\\cdot 3/2$ og $u=3\\pi$," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p = dtuplot.plot3d(f,(x,-10,10),(y,-10,10),use_cm=True,camera={\"elev\":20, \"azim\":-125}, rendering_kw={\"alpha\":0.4}, show=False)\n", + "p.extend(dtuplot.plot3d_parametric_line(r[0],r[1],0, (u,0,4*pi), use_cm=False, rendering_kw={\"color\":\"red\"}, show=False))\n", + "r1 = r.subs(u,3*pi)\n", + "p.extend(dtuplot.scatter(r1[0], r1[1], 0, rendering_kw={\"color\":\"black\", \"s\":100}, show=False))\n", + "p.extend(dtuplot.quiver(r1[0], r1[1], 0, 0, 0, f.subs({x:r1[0],y:r1[1]}), rendering_kw={\"color\":\"orange\"}, show=False))\n", + "r2 = r.subs(u,3*pi/2)\n", + "p.extend(dtuplot.scatter(r2[0], r2[1], 0, rendering_kw={\"color\":\"black\", \"s\":100}, show=False))\n", + "p.extend(dtuplot.quiver(r2[0], r2[1], 0, 0, 0, f.subs({x:r2[0],y:r2[1]}), rendering_kw={\"color\":\"orange\"}, show=False))\n", + "\n", + "p.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Den afledede af $h$ angiver væksthastigheden langs den parametriserede kurve. Den kan findes ved *kædereglen langs kurver*, eller direkte (da vi har dens forskrift):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dh = h.diff(u)\n", + "dh" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Eksempelvis i de nævnte punkter," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dh.subs(u,3*pi/2), dh.subs(u,3*pi)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Retningsafledet i sammenligning med de partielt afledte\n", + "\n", + "Vi betragter følgende funktion af to variable," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x, y, z = symbols(\"x y z\")\n", + "\n", + "f = 1-x**2/2-y**2/2\n", + "f\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Grafen for funktionen er en paraboloide, og vi befinder os i punktet $p_0$ givet ved $(1,-1,f(1,-1))=(1,-1,0)$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p0 = Matrix([1,-1,0])\n", + "p_parab = dtuplot.plot3d(f,(x,-2,2),(y,-2,2),use_cm=True,camera={\"elev\":20, \"azim\":-80}, rendering_kw={\"alpha\":0.4}, show=False)\n", + "p_point = dtuplot.scatter(p0, rendering_kw={\"color\":\"black\", \"s\":100}, show=False)\n", + "\n", + "(p_parab + p_point).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hvis vi fra $p_0$ bevæger os i x-aksens retning, er stigningsgraden, $f_x'(1,-1)$, hældningskoefficienten for tangenten til $p_0$ til den tilsvarende løftede x-koordinatkurve," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dfx = f.diff(x)\n", + "t = symbols(\"t\")\n", + "xtan = p0+Matrix([1,0,dfx.subs({x:p0[0],y:p0[1]})])*t\n", + "\n", + "n0 = Matrix([0,1,0])\n", + "p_xplane = dtuplot.plot_geometry(Plane(p0,n0), (x,-2,2),(y,-2,2),(z,-3,1), rendering_kw={\"alpha\":0.3, \"color\":\"blue\"}, show=False)\n", + "p_xtan = dtuplot.plot3d_parametric_line(xtan[0],xtan[1],xtan[2], (t,-1,1), use_cm=False, rendering_kw={\"color\":\"red\"}, show=False)\n", + "\n", + "(p_parab + p_point + p_xplane + p_xtan).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Den nævnte stigningsgrad udregnes til," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dfx.subs({x:p0[0],y:p0[1]})" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tilsvarende fåes for $y$," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# anden vinkel, så det lettere ses\n", + "p_parab2 = dtuplot.plot3d(f,(x,-2,2),(y,-2,2),use_cm=True,camera={\"elev\":15, \"azim\":-60}, rendering_kw={\"alpha\":0.4}, show=False)\n", + "\n", + "dfy = f.diff(y)\n", + "ytan = p0+Matrix([0,1,dfy.subs({x:p0[0],y:p0[1]})])*t\n", + "\n", + "n1 = Matrix([1,0,0])\n", + "p_yplane = dtuplot.plot_geometry(Plane(p0,n1), (x,-2,2),(y,-2,2),(z,-3,1), rendering_kw={\"alpha\":0.3, \"color\":\"green\"}, show=False)\n", + "p_ytan = dtuplot.plot3d_parametric_line(ytan[0],ytan[1],ytan[2], (t,-1,1), use_cm=False, rendering_kw={\"color\":\"red\"}, show=False)\n", + "\n", + "(p_parab2 + p_point + p_yplane + p_ytan).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "med stigningsgrad" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dfy.subs({x:p0[0],y:p0[1]})" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "De to tangenter udspænder tilsammen **tangentplanen**. En normalvektor for tangentplanen må derfor være *krydsproduktet*," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n2 = Matrix([1,0,dfx]).cross(Matrix([0,1,dfy]))\n", + "n3 = n2.subs({x:p0[0],y:p0[1]})\n", + "n3" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Som her er tegnet sammen," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p_xyplane = dtuplot.plot_geometry(Plane(p0,n3), (x,-2,2),(y,-2,2),(z,-3,1), rendering_kw={\"alpha\":0.5, \"color\":\"grey\"}, show=False)\n", + "\n", + "(p_parab + p_point + p_xtan + p_ytan + p_xyplane).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Men hvad er stigningsgraden, hvis vi bevæger os i en vilkårlig retning?\n", + "\n", + "Til behandling af dette emne, har vi begrevet **retningsafledet**\n", + "\n", + "Det retningsafledede $f'(x;e)$ betegner stigningsgraden for $f$ når vi fra punktet $x=(1,-1)$ bevæger os i en given rening, som er bestemt ved en enheds-vektor $e$ afsat ud fra punktet $x$ i $(x,y)$-planen.\n", + "\n", + "Som eksempel afsætter vi enheds-vektoren $e=\\begin{bmatrix}-\\frac{1}{\\sqrt{5}}&-\\frac{2}{\\sqrt{5}}\\end{bmatrix}$ ud fra punktet $x$," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "e = Matrix([-S(1)/sqrt(5),-S(2)/sqrt(5)])\n", + "\n", + "p_2dline = dtuplot.plot(2*x-3,(x,-2,2),xlim=(-2,2),ylim=(-2,2),rendering_kw={\"color\":\"grey\"}, show=False)\n", + "p_2darrow = dtuplot.quiver((1,-1),e, rendering_kw={\"color\":\"red\"}, show=False)\n", + "p_2dpoint = dtuplot.scatter(1,-1, rendering_kw={\"color\":\"black\", \"s\":10}, show=False)\n", + "\n", + "(p_2dline + p_2darrow + p_2dpoint).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Den retningsafledede er naturligvis med hældningskoefficienten for fladetangenten i $p_0$ i den givne retning.\n", + "\n", + "Men hvordan bestemmer vi denne hældningskoefficient?\n", + "\n", + "Lad os betragte den tilsvarende snitkurve, sammen med $e$ (afsat ud fra $x$) og normalvektoren," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n4 = Matrix([2,-1,0]) # normal vektoren tilsvarende y=2x-3\n", + "p_vertical_plane = dtuplot.plot_geometry(Plane(p0,n4), (x,-2,2),(y,-2,2),(z,-3,1), rendering_kw={\"alpha\":0.35, \"color\":\"blue\"}, show=False)\n", + "p_normalvector = dtuplot.quiver(p0,n4, rendering_kw={\"color\":\"red\"}, show=False)\n", + "p_arrow_along_plane = dtuplot.quiver(p0,[e[0],e[1],f.subs({x:1,y:-1})], rendering_kw={\"color\":\"orange\"}, show=False)\n", + "\n", + "(p_parab + p_point + p_vertical_plane + p_normalvector + p_arrow_along_plane).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Som retningsvektor for den søgte tangent må vi kunne benytte $r=\\begin{bmatrix}e_1&e_2&f'(x;e)\\end{bmatrix}$, hvor $e_1$ og $e_2$ er første og andenkoordinaten for $e$. Vi skal altså finde den afledte i retningen $e$. \n", + "\n", + "Vi ved, at vores tangent må ligge i tangentplanen, hvormed det må gælde at\n", + "\n", + "\\begin{equation}\n", + "\\begin{aligned}\n", + "r\\cdot N= & 0\\\\\n", + "\\Leftrightarrow \\begin{bmatrix}e_1\\\\e_2\\\\f'(x,e)\\end{bmatrix}\\cdot \\begin{bmatrix}-f_x'(x)\\\\-f_y'(x)\\\\1\\end{bmatrix} = & 0\\\\\n", + "\\Leftrightarrow f'(x;e) = & e_1\\cdot f_x'(x)0e_2\\cdot f_y'(x)\\\\\n", + "\\Leftrightarrow f'(x,e)=&e\\cdot \\nabla f(x),\n", + "\\end{aligned}\n", + "\\end{equation}\n", + "\n", + "og dette er den generelle formel for den retningsafledede!" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For dette eksempel får vi altså," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Nabla = Matrix([dfx, dfy]).subs({x:1,y:-1})\n", + "Nabla" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Med stigningsgraden," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = e.dot(Nabla)\n", + "a" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hvorved tangenten angives som," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r = Matrix([e[0], e[1], a])\n", + "r\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tangent = p0+r*t\n", + "\n", + "p_linetan = dtuplot.plot3d_parametric_line(tangent[0],tangent[1],tangent[2], (t,-2,2), use_cm=False, rendering_kw={\"color\":\"red\"}, show=False)\n", + "\n", + "(p_parab + p_point + p_vertical_plane + p_linetan).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Og når vi samler alt dette, kan vi se, at denne tangentlinje netop er den linje hvor de to planer krydser," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "(p_parab + p_point + p_linetan + p_xyplane + p_vertical_plane + p_normalvector + p_arrow_along_plane).show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-F-Uge-1-StoreDag.ipynb b/Demos/Demo-F-Uge-1-StoreDag.ipynb new file mode 100644 index 0000000..7fb91de --- /dev/null +++ b/Demos/Demo-F-Uge-1-StoreDag.ipynb @@ -0,0 +1,545 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Partielle afledede, Gradienter, Retningsafledede\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "from dtumathtools import *\n", + "init_printing()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Velkommen tilbage efter jul og januar, og velkommen til foråret i mat1. Der kommer til at være en helt masse nyt pensum, og blandt andet en helt masse 3D-plots! Til dette har vi udviklet ``dtumathtools``, som vil følge jer i løbet af foråret. Den indeholder ``dtuplot`` som skal bruges til at plotte, samt flere gode hjælpefunktioner. Det kan hentes fra terminalen, hvor man så skal skrive ``pip install dtumathtools`` (tilsvarende med ``pip3``). Det tager op til ~5 minutter før den er helt færdig og tillader dig igen at skrive i terminalen. Efter dette kan resten af demoen nydes." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Partielt afledte ved brug af ``diff``\n", + "\n", + "I dag introducerer vi partielle afledte, samt hvordan vi kan benytte dem. For at vise hvordan man kan få de partielt afledte, kan vi kigge på funktionen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x, y = symbols('x y')\n", + "f = x*y**2+x\n", + "f" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "og finde de afledte med kommandoen som vi også brugte sidste semester" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f.diff(x), f.diff(y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "På samme måde kan man finde de afledte *af anden orden*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f.diff(x,2), f.diff(y,2), f.diff(x,y), f.diff(y,x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan så indsætte værdier i denne, for eksempel $\\frac{\\partial}{\\partial x}f(x,y)$ taget i $(-2,3)$ ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f.diff(x).subs({x:-2,y:3})" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Eller $\\frac{\\partial}{\\partial x\\partial y}f(x,y)$, taget i $(5,-13)$ ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f.diff(x,y).subs({x:5,y:-13})" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Grafer og niveaukurver\n", + "\n", + "Vi skal nu, for første gang til at plotte funktioner af flere variable, og altså i 3D! Her er et valg man skal tage, for man har nemlig mulighed for at rotere et plot rundt, så man kan se det fra flere vinkler. \n", + "\n", + "Hvis man ikke gør noget aktivt (eller hvis man bruger kommandoen ``%matplotlib inline``), kommer plots som I er vant til fra efteråret (som også kommer med hvis man eksporterer til pdf)," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f = 4-x**2-y**2\n", + "\n", + "p=dtuplot.plot3d(f, (x,-3,3),(y,-3,3))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ovenstående kommando laver plottet som en **statisk** PNG-fil, hvilket er smart hvis man skal printe Notebook'en eller eksportere til PDF. Hvis man i stedet kører ``%matplotlib qt`` (i den følgende blok udkommenteret, men prøv at fjerne udkommenteringen \\#), aktiverer man **interaktive** plots. Alle efterfølgende plots \"popper\" nu ud af VS Code, hvorefter man man rotere plottet rundt og se det fra flere vinkler! Prøv derefter at plotte 3D plottet igen!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# %matplotlib qt" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Om interaktive plots" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Bemærk: `%matplotlib qt` virker normalt kun hvis man kører fx VS Code på egen laptop. Hvis man fx kører Python på en online server i browseren som Google Colab, vil `%matplotlib qt` ikke virke. Her kan man prøve widgets i stedet for: `%matplotlib ipympl`. Det kører at man lige installerer pakken `ipympl`. Samlet oversigt:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Fjern udkommentering for den backend der ønskes brugt\n", + "# %matplotlib inline # statisk plots\n", + "# %matplotlib qt # QT (cute) interaktivt pop-ud plots\n", + "# %matplotlib ipympl # Widget/ipynpl interaktivt inline plots (ikke så stabil som QT og kan kræve restart af kernel)\n", + "# %matplotlib --list # liste over alle backends " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan også plotte højdelinjer, altså et 2D plot over en 3D struktur ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot_contour(f, (x,-3,3),(y,-3,3), is_filled=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Og hvis vi vil bestemme hvilke højder der vises, kan vi bruge," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "zvals = [-2,-1,0,1]\n", + "dtuplot.plot_contour(f, (x,-3,3),(y,-3,3), rendering_kw={\"levels\":zvals, \"alpha\":0.5}, is_filled=False)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I ovenstående plot er der brugt ``rendering_kw={....}`` som argument, og det kan se lidt underligt ud. Dette er blot hvilke æstetiske (rendering) indstillinger der skal bruges, eksempelvis ``color``, ``alpha``, osv. Man kan også i det fleste tilfælde \"bare\" skrive ``{....}``, og så ved den godt at det er det æstetiske, men det er mere tydeligt at skrive det med.\n", + "\n", + "Her er samme plot vist, nu med højder som farver, i 3D," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p=dtuplot.plot3d(f, (x,-3,3),(y,-3,3), use_cm=True, legend=True)\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gradientvektorfelter\n", + "\n", + "Vi kigger nu på vektorfeltet \n", + "\n", + "\\begin{equation}\n", + "f(x,y)=\\cos(x)+\\sin(y).\n", + "\\end{equation}\n", + "\n", + "Gradienten for $f$ taget i punktet $(x,y)$ er en vektor, som har symbolet $\\nabla f(x,y)$ ($\\nabla$ kaldes *nabla*). Den er sammensat af de to partielt afledte,\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f = cos(x)+sin(y)\n", + "nf = Matrix([f.diff(x), f.diff(y)])\n", + "nf" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Som let plottes ved," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot_vector(nf, (x,-pi/2,3/2*pi),(y,0,2*pi),scalar=False)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Eller hvis det skal være lidt flottere (her er ``rendering_kw`` splittet, så man kan specificere for pile og contours seperat)," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot_vector(nf, (x,-pi/2,3/2*pi),(y,0,2*pi),\n", + " quiver_kw={\"color\":\"black\"},\n", + " contour_kw={\"cmap\": \"Blues_r\", \"levels\": 20},\n", + " grid=False, xlabel=\"x\", ylabel=\"y\",n=15)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Som i 3D visualiseres ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# \"camera\" Juster hvorfra man skal se på grafen\n", + "# meget brugbart, hvis man vil have bestemt\n", + "# rotation med i pdf-filen\n", + "p = dtuplot.plot3d(f, (x,-pi/2,3/2*pi),(y,0,2*pi),use_cm=True, camera={\"elev\":45, \"azim\":-65}, legend=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Retningsafledt af funktion af to variable\n", + "\n", + "Vi betragter funktionen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f = 1-x**2/2-y**2/2\n", + "f" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi ønsker nu den retningsafledte af $f$ fra punktet $(1,-1)$ i retningen givet ved enhedsvektoren," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x0 = Matrix([1,-1])\n", + "e = Matrix([-1,-2]).normalized()\n", + "e, N(e)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p1 = dtuplot.scatter(x0, rendering_kw={\"markersize\":10,\"color\":'r'}, xlim=[-2,2],ylim=[-2,2],show=False)\n", + "p1.extend(dtuplot.quiver(x0,e,show=False))\n", + "p1.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi får gradienten i punktet $x_0$ ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Nabla = Matrix([diff(f,x),diff(f,y)]).subs({x:x0[0],y:x0[1]})\n", + "Nabla" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hvorefter den retningsafledte, $f'((1,-1), e)$, findes ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = e.dot(Nabla)\n", + "a" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Dette viser, at *f aftager* fra punktet $(1,-1)$ i retningen $e$. Dette er fordi den retningsafledte angiver raten, hvormed $f$ aftager." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Parameterkurve i (x,y)-planen og dens tangenter\n", + "\n", + "Vi betragter spiralen, givet ved parameterfremstillingen," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "u, t = symbols('u t', real=True)\n", + "r = Matrix([u*cos(u), u*sin(u)])\n", + "r" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tangentvektoren i et vilkårligt punkt fåes nu til" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "rd = diff(r,u)\n", + "rd" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi finder nu en parameterfremstilling for tangenten til spiralen i røringspunktet $((0,-\\frac{3\\pi}{2}))$, svarende til parameterværdien $u_0=\\frac{3\\pi}{2}$, som ses ved," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "u0 = 3*pi/2\n", + "rdu0 = rd.subs(u,u0)\n", + "ru0 = r.subs(u,u0)\n", + "ru0" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Parameterfremstillingen for tangenten i $u_0$ findes ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "T = ru0 + t*rdu0\n", + "T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Det hele kan nu visualiseres ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p = dtuplot.plot_parametric(r[0], r[1],(u,0,4*pi),rendering_kw={\"color\":\"red\"},use_cm=False,show=False)\n", + "p.extend(dtuplot.plot_parametric(T[0],T[1],(t,-1.5,1.5),rendering_kw={\"color\":\"royalblue\"},use_cm=False,show=False))\n", + "p.extend(dtuplot.scatter(ru0,rendering_kw={\"markersize\":10,\"color\":'black'}, show=False))\n", + "p.extend(dtuplot.quiver(ru0,rdu0,rendering_kw={\"color\":\"black\"},show=False))\n", + "\n", + "p.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-F-Uge-1-StoreDag_minversion.ipynb b/Demos/Demo-F-Uge-1-StoreDag_minversion.ipynb new file mode 100644 index 0000000..6c6d93a --- /dev/null +++ b/Demos/Demo-F-Uge-1-StoreDag_minversion.ipynb @@ -0,0 +1,1010 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Partielle afledede, Gradienter, Retningsafledede\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "from dtumathtools import *\n", + "init_printing()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Velkommen tilbage efter jul og januar, og velkommen til foråret i mat1. Der kommer til at være en helt masse nyt pensum, og blandt andet en helt masse 3D-plots! Til dette har vi udviklet ``dtumathtools``, som vil følge jer i løbet af foråret. Den indeholder ``dtuplot`` som skal bruges til at plotte, samt flere gode hjælpefunktioner. Det kan hentes fra terminalen, hvor man så skal skrive ``pip install dtumathtools`` (tilsvarende med ``pip3``). Det tager op til ~5 minutter før den er helt færdig og tillader dig igen at skrive i terminalen. Efter dette kan resten af demoen nydes." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Partielt afledte ved brug af ``diff``\n", + "\n", + "I dag introducerer vi partielle afledte, samt hvordan vi kan benytte dem. For at vise hvordan man kan få de partielt afledte, kan vi kigge på funktionen" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEcAAAAXCAYAAABZPlLoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAABJ0AAASdAHeZh94AAADCUlEQVR4nO3YS4gcVRQG4G867jKCuIoLdaEQ3UjARYKMopEhokjEB2ggOkE3akANUTK+DgfRMGhigkaJIE5wJzHgY6Gi4EKjMqIxRNSFmoUQMcLoxgdqxkVVY0/bPal+pHsM/lDc4tStc/7/VN1zHyNzc3P+R2ucMshgmTmJa7Ecv+NDTEbEoUHyqIragONdimdwEVbjT7ydmacPmEcljAxzWGXmKH7GNRHx2tCItMGg/5xmnFpymB0yj5YYdnJ24gA+GDKPlhhoQW5EZm7HGMYi4q8u3p/AC7gsIt7tL7sC85KTmW9hHNdHxMsN9pGSyC2YiogtmbkJ27A5Ira1IL8cB/FRRFzS9OxJ3KgQ9k2fNVVCFa3Nw+peHMMjmbmkwf6EIjHPRcSW0vZ+2a5qE/8pLMHGJlI7cRNWR8SXHavqH46rdV5yIuIzvIjzsR4y835swku4vaH7J/gVK5ujZuYNiq+yKyIONth3YQPWYTYzl5XXaI9CO0YVra0K8kP4DZGZG/Eo3sT6iDjW4PwPzODMzDyjbs/MpdiOH/Bwk+87FDPUOzjScG3uVWyXWFBry3VOZm5Fffjsx3hE/NKi32OYxHURsa+0TeE+bIiI6X4oyMzDOLuDV/ZExERF3221tputjjbc39oqMSXqdWcl9mXmebhHMTXvqUKuInbgtCbbCqwt4xxuenagA99ttf4rOZm5TlGUvscy3GV+rWnEfsz5pyg/rSjCd0ZE35beEbGjBc8JRXKmu53Kj6e11tT5SkzjEC7AV7itnJZbkZ7FF7iwDHQ5dkfEp92QHSSqaK01dB7DXnyHNRFxFA8q/q6pBeK8h6XYjR/xQF9VnABU1VorO6/A64pN4HhEHIGI2IuPsTYzL24Tq153RhXHD4tyn1RHJ1prmXku3lDUjjUR8XWTv8myfbxNvG/LdgbP90vEiUCnWns+ssjMV3EVVkXETE/OFhl62pWXRfhqPHuyJYYuduWZeZZi+X8ObsbnikXfSYdujiyuwFb8hFdw9wKLxP80hnpMutjxN46hPjQh1MkkAAAAAElFTkSuQmCC", + "text/latex": [ + "$\\displaystyle x y^{2} + x$" + ], + "text/plain": [ + " 2 \n", + "x⋅y + x" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x, y = symbols('x y')\n", + "f = x*y**2 + x\n", + "f\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "og finde de afledte med kommandoen som vi også brugte sidste semester" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left( y^{2} + 1, \\ 2 x y\\right)$" + ], + "text/plain": [ + "⎛ 2 ⎞\n", + "⎝y + 1, 2⋅x⋅y⎠" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f.diff(x), f.diff(y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "På samme måde kan man finde de afledte *af anden orden*" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/latex": [ + "$\\displaystyle \\left( 0, \\ 2 x, \\ 2 y, \\ 2 y\\right)$" + ], + "text/plain": [ + "(0, 2⋅x, 2⋅y, 2⋅y)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f.diff(x,2), f.diff(y,2), f.diff(x,y), f.diff(y,x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan så indsætte værdier i denne, for eksempel $\\frac{\\partial}{\\partial x}f(x,y)$ taget i $(-2,3)$ ved" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAAQCAYAAAAI0W+oAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAABJ0AAASdAHeZh94AAABcUlEQVR4nL3UMWhUQRDG8V/EyhAiBMTCQjyMpSkEgxZik1imSKmInaAooqUwjGCriGgtiL22aVIETRCsxYsJFoqNoiKx9CxuHzzv7nGEhw48hp1vd//z8diZ6PV6/kfsrS8ycxlnMIfjmMKziDjfdEFmHsIdnMMMPuM5MiK+Vfv2DJy7jasF9Glcl5nZwRtcwmvcxzauYz0zZ0Y6wg18xPvibHUM6zEO4FpEPKw1cK/cdReXhxxFxGpEbEbE2B9X3CzgAx4NyIEdXMjMySHQLuNsySsR8Xug4Z94iX2Ybws6VnK3Qd8sebYtaLrkHw16Vd/fFrSraAOqOp5u0Kv697agdyXPNuhHS+62BVVvbCEz/7onM6dwGr+w0QoUEVtYwWFcGZATk3gaETswUR+qmbmEpbI8iEX9kbJWal8i4lZtfwev9KfDC7zFSf031sWpiPg6ytEcLpZvsdSO1GrLI1ydwJMCuIkOHmC+ggw5+pfxB1DEa1xJ8xBBAAAAAElFTkSuQmCC", + "text/latex": [ + "$\\displaystyle 10$" + ], + "text/plain": [ + "10" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f.diff(x).subs({x:-2,y:3})" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Eller $\\frac{\\partial}{\\partial x\\partial y}f(x,y)$, taget i $(5,-13)$ ved" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAACsAAAAQCAYAAACP4IauAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAABJ0AAASdAHeZh94AAACM0lEQVR4nNXVO4hWVxAH8N/6QCwsRLTRKBY2ojZGxcIXi6YQxPUBFj6qpFqjICIIOkwRDAFR0c7Aboo0yjbKLipaaKG4ICsYQgwEV5QUvrVQ0dW1uPcLXy77LQpXwYHL3HPmP+f+z//M3NM2PDzsa7FxdS2UmVPQgbWYj+l4g1voQldEvB8lvx2dWIrJeFzmHouIPhhTF1lsxkkswXUcRQ/m4Vecysy2FkR/wUV8izM4jF5MxcoGrjZl8TfWobdZwczcj35sxIZyA81Ev8de/IYfIuJNJT6+8d72JWq2JPwTTkTEzqb5CbiHV5hTJVq1OpUdzd6Wfqgyv1px1EfxPjPXKsrmNfoj4loz+LOTzcxx2F4Oz1XCi0r/GgMKos25V7ApIh5Sb4O1sp9LEn0Rcb4Sm1b6vRjGMkzCAlzAcpxugP+nbGYOYtYnEPk9Ira2Cmbmj9iDv7BtBEhDrCGsi4jBcnwrMztwGysyc2lEXKsq+08J+Njn31GIduIY/sSqiHgyAuxZ6QeaiIKIeInGSSymomxEtLf6+KdYZu7GEfyB9oh40AJ6u/TPWsSfln4in6FmM3OfguhNhaKtiMIlRa3OzcyRuDQa7g41k83MA4qGuqFQ9NFo+Ii4i7OYiV2VtdbgO4Xq56jxUsjMHejGOxzH8xFggxHRXcmbgav4RqH0AGZjvUL1LRHRQ73/2dmlH4vdLTCXFRv6zyLifmYuxEHFdb0cLxSKH4qI/gb2i1y3ddkHmjfGtUx9GlEAAAAASUVORK5CYII=", + "text/latex": [ + "$\\displaystyle -26$" + ], + "text/plain": [ + "-26" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f.diff(x,y).subs({x:5,y:-13})" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Grafer og niveaukurver\n", + "\n", + "Vi skal nu, for første gang til at plotte funktioner af flere variable, og altså i 3D! Her er et valg man skal tage, for man har nemlig mulighed for at rotere et plot rundt, så man kan se det fra flere vinkler. \n", + "\n", + "Hvis man ikke gør noget aktivt (eller hvis man bruger kommandoen ``%matplotlib inline``), kommer plots som I er vant til fra efteråret (som også kommer med hvis man eksporterer til pdf)," + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": "/* Put everything inside the global mpl namespace */\n/* global mpl */\nwindow.mpl = {};\n\nmpl.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\nmpl.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_device_pixel_ratio', {\n device_pixel_ratio: fig.ratio,\n });\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\nmpl.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\nmpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n\nmpl.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\nmpl.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\nmpl.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\nmpl.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\nmpl.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\nmpl.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\nmpl.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\nmpl.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\nmpl.figure.prototype.handle_figure_label = function (fig, msg) {\n // Updates the figure title.\n fig.header.textContent = msg['label'];\n};\n\nmpl.figure.prototype.handle_cursor = function (fig, msg) {\n fig.rubberband_canvas.style.cursor = msg['cursor'];\n};\n\nmpl.figure.prototype.handle_message = function (fig, msg) {\n fig.message.textContent = msg['message'];\n};\n\nmpl.figure.prototype.handle_draw = function (fig, _msg) {\n // Request the server to send over a new figure.\n fig.send_draw_message();\n};\n\nmpl.figure.prototype.handle_image_mode = function (fig, msg) {\n fig.image_mode = msg['mode'];\n};\n\nmpl.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\nmpl.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\nmpl.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.\nmpl.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 https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\nmpl.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 * https://stackoverflow.com/a/24161582/3208463\n */\nfunction 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\nmpl.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\nmpl.figure.prototype._key_event_extra = function (_event, _name) {\n // Handle any extra behaviour associated with a key event\n};\n\nmpl.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\nmpl.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\nmpl.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\nvar _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\nmpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o\", \"download\"]];\n\nmpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\", \"webp\"];\n\nmpl.default_extension = \"png\";/* global mpl */\n\nvar 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\nmpl.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\nmpl.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\nmpl.figure.prototype.close_ws = function (fig, msg) {\n fig.send_message('closing', msg);\n // fig.ws.close()\n};\n\nmpl.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\nmpl.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\nmpl.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\nmpl.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\nmpl.figure.prototype._root_extra_style = function (el) {\n el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n};\n\nmpl.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\nmpl.figure.prototype._key_event_extra = function (event, _name) {\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\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n fig.ondownload(fig, null);\n};\n\nmpl.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.\nif (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": [ + "<div id='9bec2a1e-f310-4d80-85f5-2cd178daca7a'></div>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f = 4-x**2-y**2\n", + "\n", + "p=dtuplot.plot3d(f, (x,-3,3),(y,-3,3))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hvis man i stedet kører ``%matplotlib qt`` (i den følgende blok udkommenteret, men prøv at fjerne udkommenteringen), ændrer opførslen sig. Alle efterfølgende plots \"popper\" nu ud af VS Code, hvorefter man man rotere plottet rundt og se det fra flere vinkler! Prøv derefter at plotte 3D plottet igen!" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib\n", + "matplotlib.use('nbagg')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": "/* Put everything inside the global mpl namespace */\n/* global mpl */\nwindow.mpl = {};\n\nmpl.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\nmpl.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_device_pixel_ratio', {\n device_pixel_ratio: fig.ratio,\n });\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\nmpl.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\nmpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n\nmpl.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\nmpl.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\nmpl.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\nmpl.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\nmpl.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\nmpl.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\nmpl.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\nmpl.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\nmpl.figure.prototype.handle_figure_label = function (fig, msg) {\n // Updates the figure title.\n fig.header.textContent = msg['label'];\n};\n\nmpl.figure.prototype.handle_cursor = function (fig, msg) {\n fig.rubberband_canvas.style.cursor = msg['cursor'];\n};\n\nmpl.figure.prototype.handle_message = function (fig, msg) {\n fig.message.textContent = msg['message'];\n};\n\nmpl.figure.prototype.handle_draw = function (fig, _msg) {\n // Request the server to send over a new figure.\n fig.send_draw_message();\n};\n\nmpl.figure.prototype.handle_image_mode = function (fig, msg) {\n fig.image_mode = msg['mode'];\n};\n\nmpl.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\nmpl.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\nmpl.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.\nmpl.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 https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\nmpl.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 * https://stackoverflow.com/a/24161582/3208463\n */\nfunction 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\nmpl.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\nmpl.figure.prototype._key_event_extra = function (_event, _name) {\n // Handle any extra behaviour associated with a key event\n};\n\nmpl.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\nmpl.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\nmpl.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\nvar _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\nmpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o\", \"download\"]];\n\nmpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\", \"webp\"];\n\nmpl.default_extension = \"png\";/* global mpl */\n\nvar 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\nmpl.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\nmpl.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\nmpl.figure.prototype.close_ws = function (fig, msg) {\n fig.send_message('closing', msg);\n // fig.ws.close()\n};\n\nmpl.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\nmpl.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\nmpl.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\nmpl.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\nmpl.figure.prototype._root_extra_style = function (el) {\n el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n};\n\nmpl.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\nmpl.figure.prototype._key_event_extra = function (event, _name) {\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\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n fig.ondownload(fig, null);\n};\n\nmpl.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.\nif (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": [ + "<div id='cecd7b3a-becb-4ce8-8c50-4b863ec6ff36'></div>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "plt.plot(np.sin(np.linspace(0, 2*np.pi)))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Available matplotlib backends: ['tk', 'gtk', 'gtk3', 'gtk4', 'wx', 'qt4', 'qt5', 'qt6', 'qt', 'osx', 'nbagg', 'notebook', 'agg', 'svg', 'pdf', 'ps', 'inline', 'ipympl', 'widget']\n" + ] + } + ], + "source": [ + "%matplotlib --list" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib nbagg" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# %matplotlib ipympl # Samme som %matplotlib widget\n", + "# %matplotlib inline\n", + "%matplotlib nbagg" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Men sådan plottes 3D strukturer. Vi kan også plotte højdelinjer, altså et 2D plot over en 3D struktur ved," + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a3c309dbc9df4ed79ea35f65c1ddc92a", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + " <div style=\"display: inline-block;\">\n", + " <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n", + " Figure\n", + " </div>\n", + " <img src='data:image/png;base64,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' width=640.0/>\n", + " </div>\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<spb.backends.matplotlib.MatplotlibBackend at 0x7f07465eba30>" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dtuplot.plot_contour(f, (x,-3,3),(y,-3,3), is_filled=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Og hvis vi vil bestemme hvilke højder der vises, kan vi bruge," + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<spb.backends.matplotlib.MatplotlibBackend at 0x7fc10f574210>" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "zvals = [-2,-1,0,1]\n", + "dtuplot.plot_contour(f, (x,-3,3),(y,-3,3), rendering_kw={\"levels\":zvals, \"alpha\":0.5}, is_filled=False)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I ovenstående plot er der brugt ``rendering_kw={....}`` som argument, og det kan se lidt underligt ud. Dette er blot hvilke æstetiske (rendering) indstillinger der skal bruges, eksempelvis ``color``, ``alpha``, osv. Man kan også i det fleste tilfælde \"bare\" skrive ``{....}``, og så ved den godt at det er det æstetiske, men det er mere tydeligt at skrive det med.\n", + "\n", + "Her er samme plot vist, nu med højder som farver, i 3D," + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Bad pipe message: %s [b\"\\x84\\xc9\\x11\\x1ba5y\\x19\\xea\\xcb\\xc0\\x02y\\xba\\xc2\\xe78T\\x00\\x00|\\xc0,\\xc00\\x00\\xa3\\x00\\x9f\\xcc\\xa9\\xcc\\xa8\\xcc\\xaa\\xc0\\xaf\\xc0\\xad\\xc0\\xa3\\xc0\\x9f\\xc0]\\xc0a\\xc0W\\xc0S\\xc0+\\xc0/\\x00\\xa2\\x00\\x9e\\xc0\\xae\\xc0\\xac\\xc0\\xa2\\xc0\\x9e\\xc0\\\\\\xc0`\\xc0V\\xc0R\\xc0$\\xc0(\\x00k\\x00j\\xc0#\\xc0'\\x00g\\x00@\\xc0\\n\\xc0\\x14\\x009\\x008\\xc0\\t\\xc0\\x13\\x003\\x002\\x00\\x9d\\xc0\\xa1\\xc0\\x9d\\xc0Q\\x00\\x9c\\xc0\\xa0\\xc0\\x9c\\xc0P\\x00=\\x00<\\x005\\x00/\\x00\\x9a\\x00\\x99\\xc0\\x07\\xc0\\x11\\x00\\x96\\x00\\x05\\x00\\xff\\x01\\x00\\x00j\\x00\\x00\\x00\\x0e\\x00\\x0c\\x00\\x00\\t127.0.0.1\\x00\\x0b\\x00\\x04\\x03\\x00\", b'']\n", + "Bad pipe message: %s [b'\\xf1\\xc5\\xc5\\xea\\xb8c^\\n\\x84\\x89\\xba\\x12\\xd1\\x7f\\x82\\xcc\\x05?\\x00\\x00\\xa6\\xc0,\\xc00\\x00\\xa3\\x00\\x9f\\xcc\\xa9\\xcc\\xa8\\xcc\\xaa\\xc0\\xaf\\xc0\\xad\\xc0\\xa3\\xc0\\x9f\\xc0]\\xc0a\\xc0W\\xc0S\\xc0', b\"/\\x00\\xa2\\x00\\x9e\\xc0\\xae\\xc0\\xac\\xc0\\xa2\\xc0\\x9e\\xc0\\\\\\xc0`\\xc0V\\xc0R\\xc0$\\xc0(\\x00k\\x00j\\xc0s\\xc0w\\x00\\xc4\\x00\\xc3\\xc0#\\xc0'\\x00\"]\n", + "Bad pipe message: %s [b'@\\xc0r\\xc0v\\x00\\xbe\\x00\\xbd\\xc0\\n\\xc0\\x14\\x009\\x008\\x00\\x88\\x00\\x87\\xc0\\t\\xc0\\x13\\x003\\x002\\x00\\x9a\\x00\\x99\\x00E\\x00D\\xc0\\x07\\xc0\\x11\\xc0\\x08\\xc0\\x12\\x00\\x16\\x00\\x13\\x00\\x9d\\xc0\\xa1\\xc0\\x9d\\xc0Q\\x00\\x9c\\xc0\\xa0\\xc0\\x9c\\xc0P\\x00=\\x00\\xc0\\x00<\\x00\\xba\\x005\\x00\\x84\\x00/\\x00\\x96\\x00A\\x00\\x05\\x00\\n\\x00\\xff\\x01\\x00\\x00j\\x00\\x00\\x00\\x0e\\x00\\x0c\\x00\\x00\\t']\n", + "Bad pipe message: %s [b'7.0.0.1\\x00\\x0b\\x00\\x04\\x03\\x00\\x01\\x02\\x00\\n\\x00\\x0c\\x00\\n\\x00\\x1d\\x00\\x17\\x00\\x1e\\x00\\x19\\x00\\x18\\x00#\\x00\\x00\\x00\\x16\\x00\\x00\\x00\\x17\\x00\\x00\\x00\\r\\x000\\x00']\n", + "Bad pipe message: %s [b'\\x03\\x05\\x03\\x06\\x03\\x08\\x07\\x08\\x08\\x08\\t\\x08\\n\\x08\\x0b\\x08\\x04\\x08\\x05\\x08\\x06\\x04\\x01\\x05\\x01\\x06\\x01\\x03\\x03\\x02\\x03\\x03\\x01\\x02\\x01\\x03\\x02\\x02\\x02\\x04\\x02\\x05\\x02\\x06\\x02']\n", + "Bad pipe message: %s [b'U\\xa3\"L\\x8b\\x07\\xea\\xf2+ \\xd4H\\xc4\\x88\\xd7\\xa5\\x06?\\x00\\x00\\xa2\\xc0\\x14\\xc0\\n\\x009\\x008\\x007\\x006\\x00\\x88\\x00\\x87\\x00\\x86\\x00\\x85\\xc0\\x19\\x00:\\x00\\x89\\xc0\\x0f\\xc0\\x05\\x005\\x00\\x84\\xc0\\x13\\xc0\\t\\x003\\x002\\x001\\x000\\x00\\x9a\\x00\\x99\\x00\\x98\\x00\\x97\\x00E\\x00D\\x00C\\x00B\\xc0\\x18\\x004\\x00\\x9b\\x00F\\xc0\\x0e\\xc0\\x04\\x00/\\x00\\x96\\x00A\\x00\\x07\\xc0\\x11\\xc0\\x07\\xc0\\x16\\x00\\x18\\xc0\\x0c\\xc0\\x02\\x00\\x05\\x00\\x04\\xc0\\x12\\xc0\\x08\\x00\\x16\\x00\\x13\\x00\\x10\\x00\\r\\xc0\\x17\\x00\\x1b\\xc0\\r\\xc0\\x03\\x00']\n", + "Bad pipe message: %s [b'\\x15\\x00\\x12\\x00\\x0f\\x00\\x0c\\x00\\x1a']\n", + "Bad pipe message: %s [b'']\n", + "Bad pipe message: %s [b'\\x9be\\x8d\\x8f^\\x13\\xad\\x93\\xe4\\xd0Z\\x1bhc\\xd5[\\x00\\x00>\\xc0\\x14\\xc0\\n\\x009\\x008\\x007\\x006\\xc0\\x0f\\xc0\\x05\\x005\\xc0\\x13\\xc0\\t\\x003\\x002\\x001\\x000\\xc0\\x0e\\xc0\\x04\\x00/\\x00\\x9a\\x00\\x99\\x00\\x98\\x00\\x97\\x00\\x96\\x00\\x07\\xc0\\x11\\xc0\\x07\\xc0\\x0c\\xc0\\x02\\x00\\x05\\x00\\x04\\x00\\xff\\x02\\x01\\x00\\x00C\\x00\\x00\\x00\\x0e\\x00\\x0c\\x00\\x00\\t127.0.0.1\\x00\\x0b\\x00\\x04\\x03\\x00\\x01\\x02\\x00\\n\\x00\\x1c\\x00']\n", + "Bad pipe message: %s [b'\\x17\\x00\\x19\\x00\\x1c\\x00\\x1b\\x00\\x18\\x00\\x1a\\x00\\x16\\x00\\x0e\\x00\\r\\x00\\x0b\\x00\\x0c\\x00\\t\\x00\\n']\n", + "Bad pipe message: %s [b'=\\xa6\\x04e\\xe5\\xf87=\\x90\\x9d\\xb7\\x1b\\xb6-\\xe9\\xe6M\\x03\\x00\\x00\\xa2\\xc0\\x14\\xc0\\n\\x009\\x008\\x007\\x006\\x00\\x88\\x00\\x87\\x00\\x86\\x00\\x85\\xc0\\x19\\x00:\\x00\\x89\\xc0\\x0f\\xc0\\x05\\x005\\x00\\x84\\xc0\\x13\\xc0\\t\\x003\\x002\\x001\\x000\\x00\\x9a\\x00\\x99\\x00\\x98\\x00\\x97\\x00E\\x00D\\x00C\\x00B\\xc0\\x18\\x004\\x00\\x9b\\x00F\\xc0\\x0e\\xc0\\x04\\x00/\\x00\\x96\\x00A\\x00\\x07\\xc0\\x11\\xc0\\x07\\xc0\\x16\\x00\\x18\\xc0\\x0c\\xc0\\x02\\x00\\x05\\x00\\x04\\xc0']\n", + "Bad pipe message: %s [b'\\x08\\x00\\x16\\x00\\x13\\x00\\x10\\x00\\r\\xc0\\x17\\x00\\x1b\\xc0\\r\\xc0\\x03']\n", + "Bad pipe message: %s [b\"\\xad\\x8d1N\\xbb\\xc8\\xa4t\\xc6\\xe0\\xecb-~n\\x1d\\xd7\\x06\\x00\\x00\\x86\\xc00\\xc0,\\xc0(\\xc0$\\xc0\\x14\\xc0\\n\\x00\\xa5\\x00\\xa3\\x00\\xa1\\x00\\x9f\\x00k\\x00j\\x00i\\x00h\\x009\\x008\\x007\\x006\\xc02\\xc0.\\xc0*\\xc0&\\xc0\\x0f\\xc0\\x05\\x00\\x9d\\x00=\\x005\\xc0/\\xc0+\\xc0'\\xc0#\\xc0\\x13\\xc0\\t\\x00\\xa4\\x00\\xa2\\x00\\xa0\\x00\\x9e\\x00g\\x00@\\x00?\\x00>\\x003\\x002\\x001\\x000\\xc01\\xc0-\\xc0)\\xc0%\\xc0\\x0e\\xc0\\x04\\x00\\x9c\\x00<\\x00/\\x00\\x9a\\x00\\x99\\x00\\x98\\x00\\x97\\x00\\x96\\x00\\x07\\xc0\\x11\\xc0\\x07\\xc0\\x0c\\xc0\\x02\\x00\\x05\\x00\\x04\\x00\\xff\\x02\\x01\\x00\\x00g\\x00\\x00\\x00\\x0e\\x00\", b'\\x00\\t127.0.0.1']\n" + ] + } + ], + "source": [ + "p=dtuplot.plot3d(f, (x,-3,3),(y,-3,3), use_cm=True, legend=True)\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gradientvektorfelter\n", + "\n", + "Vi kigger nu på vektorfeltet \n", + "\n", + "\\begin{equation}\n", + "f(x,y)=\\cos(x)+\\sin(y).\n", + "\\end{equation}\n", + "\n", + "Gradienten for $f$ taget i punktet $(x,y)$ er en vektor, som har symbolet $\\nabla f(x,y)$ ($\\nabla$ kaldes *nabla*). Den er sammensat af de to partielt afledte,\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}- \\sin{\\left(x \\right)}\\\\\\cos{\\left(y \\right)}\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡-sin(x)⎤\n", + "⎢ ⎥\n", + "⎣cos(y) ⎦" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f = cos(x)+sin(y)\n", + "nf = Matrix([f.diff(x), f.diff(y)])\n", + "nf" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Som let plottes ved," + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<spb.backends.matplotlib.MatplotlibBackend at 0x7fd5766a9250>" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dtuplot.plot_vector(nf, (x,-pi/2,3/2*pi),(y,0,2*pi),scalar=False)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Eller hvis det skal være lidt flottere (her er ``rendering_kw`` splittet, så man kan specificere for pile og contours seperat)," + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<spb.backends.matplotlib.MatplotlibBackend at 0x7fd5767c4bd0>" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dtuplot.plot_vector(nf, (x,-pi/2,3/2*pi),(y,0,2*pi),\n", + " quiver_kw={\"color\":\"black\"},\n", + " contour_kw={\"cmap\": \"Blues_r\", \"levels\": 20},\n", + " grid=False, xlabel=\"x\", ylabel=\"y\",n=15)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Som i 3D visualiseres ved" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# \"camera\" Juster hvorfra man skal se på grafen\n", + "# meget brugbart, hvis man vil have bestemt\n", + "# rotation med i pdf-filen\n", + "p = dtuplot.plot3d(f, (x,-pi/2,3/2*pi),(y,0,2*pi),use_cm=True, camera={\"elev\":45, \"azim\":-65}, legend=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Retningsafledt af funktion af to variable\n", + "\n", + "Vi betragter funktionen" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKEAAAAXCAYAAABjwi/eAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAABJ0AAASdAHeZh94AAAFMUlEQVR4nO3aaYxkVRUH8F87E2MCGCMfxAAakAQ/uEwCkSWdEZkQCIJOj5AAYRmjfmAJDDAERpbDCQElCMwILgiGmRj4QByIGkRQAWUTJ8CwRCE6MKgsgYGRhH1rPtw3UFNUdb3qqu7qgv4nldd973nn3vuv885Wb2R8fNwsZjFIzB3k4pm5DIuwM17D37AsIh4a5L6mE7Mc8JEBr78Xfoo9sTfexJ8y85OD3NQ0Yy8fcg5GZlI4zswt8QIWRsTvBr2fQeDDyMFAw3ELbKV4542tJjPzU3hS8RxnYwxfxxexLV7Hg7gSV0bE21O/5b5jQg4YDh4y8yB8FfPwZeVcV0XE4c2ygw7HzViBtbirzfw3lT1fi4NxOXbD3ViO1fgCrsA1mTkytdudEnTigOHg4QwcpxjhExMJzhhPmJkXYRSjEfFWG7ExPIe/YgTfwPWNT3pmfh9/x7eUhH/1VO67n6jJAdPEQ2YuVrzp1yLi1i5vPxH/w78Vj3hLO8G+GmFm3oR9cFBErG4YH1EOcxTOj4jTmu67GIcoh320je6PK4n71dUXdHMruYh4OjN/jnOVpH9ajTAzT8KFWBoRF7aY3xkP4O6ImN8w3pGDSm4oeIiId40uMyeU7Xc4PgVv45zMnNMw/iPFAH/RwgBX4FDsHREPT6D7AHwU19XYxxvV9c26G+8j7qiuu7eZvwRzlFCFrjhgeHiojb56woi4PzN/pRjcEVhZhYWTcA2ObpTPzJ9UcguxMTO3qaZejIgXm9SP4SXcNNEeMnMujqz+/cPkTzNp3ItXlBxtM2TmwUqk+HFEPFCNdcMBw8NDbUxFYXImXkVk5nFKOLgRR7So0o5RqqY/46mGz9JGocz8GPbDDRHxaof1f6gk5b+PiBt7PEvXiIg3sAbbZ+anN41n5ha4CM/grIZbanFQ6RgaHrrBZp4wM9fjs13c/76SOyL+m5nLcZoSeu7Eooh4vfnmiKhbte2DLXUIQZl5PE7Gw4p36Yh+nLkF7sB87KFUsBTD2w7fjogXNgl2wQGD4+GWFnndqohYXEd3JzSH43WKF6uLJ9uMP9vw93ci4uWudvV+LFJ6X9e3E6i87gr8Awsi4vmauvt15kZsygt3w7WZ+XmlWrwLq7pYqxlTycNyfKJpbJ7SDlqF9U1za2vq7YjNjDAiFvSqMDMPUwqRp7ENTtCUC3apbw4OxM2NHqRJZgkuxkMK8c/U1d+PM7fAnRj3XnFyqVKMHBsRk/qJahp4WN5C32LFCFdOokVTG33NCTNzf6xUSPgSHsF3q7bEZDEfW2sTgjLzVIX4tUp7ozbxU4WI2Ih/YpfqoVyAyyLivh7UDh0PddE3I8zMUfxaaVDuGxHPKl3zuTi/B9VjStvnNy3WPFNJwO9RnvwNPazTb9yOLXAZNuD0HvUNKw8d0ZcXGDJzHm5VWhOjEbGuYW4NdsX8iLitS70jeBz/iYjRprmjFK/7llIAtQpR6yNiZTdr9guZeaT38r/vRcQVPegaCA+9/GKSmQuVthMlLdsXj2KTDWyIiKX0oU+YmTspfahxxQOuaxJZhj/iAu0buO2wK7ZXkuZm7FBd52BJm/v/onxBg8Bj1XUNftmjrmHkYZ7SL27EjtWH8lAtZYa9ytWMzDxPMeIdI+KxTvIzCZn5W+XNlt0jYk2PuoaWhzqYaW/RNGMM9w8b8VUxciB+1qsBVhhKHupiRnvCYUJmfgaH4XPKz2X/wlf60CP9wGPGvMr1AcB++AH+r1SwS2YNsB5mPeEsBo53AN//TO+yRcrjAAAAAElFTkSuQmCC", + "text/latex": [ + "$\\displaystyle - \\frac{x^{2}}{2} - \\frac{y^{2}}{2} + 1$" + ], + "text/plain": [ + " 2 2 \n", + " x y \n", + "- ── - ── + 1\n", + " 2 2 " + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f = 1-x**2/2-y**2/2\n", + "f" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi ønsker nu den retningsafledte af $f$ fra punktet $(1,-1)$ i retningen givet ved enhedsvektoren," + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left( \\left[\\begin{matrix}- \\frac{\\sqrt{5}}{5}\\\\- \\frac{2 \\sqrt{5}}{5}\\end{matrix}\\right], \\ -0.447213595499958, \\ -0.894427190999916\\right)$" + ], + "text/plain": [ + "⎛⎡ -√5 ⎤ ⎞\n", + "⎜⎢ ──── ⎥ ⎟\n", + "⎜⎢ 5 ⎥ ⎟\n", + "⎜⎢ ⎥, -0.4472135954999579, -0.8944271909999159⎟\n", + "⎜⎢-2⋅√5 ⎥ ⎟\n", + "⎜⎢──────⎥ ⎟\n", + "⎝⎣ 5 ⎦ ⎠" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x0 = Matrix([1,-1])\n", + "e = Matrix([-1,-2]).normalized()\n", + "e, float(e[0]), float(e[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA0OklEQVR4nO3dfXRU9b3v8U+GhwlBQwRCEhQwAQ/xAXkUnMiRUFISREsqlypyy8NFUAutGI4UvC0YrSdVUawWiyyVaI9W5SxBRQvFQOBGIgiSo1JMBZFoIFHAJBBggsy+f0QGx9kJBLJnkl/er7Vmyf7Nb+9858vO8HE/zERYlmUJAAAAzZ4r3AUAAACgcRDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAM4Wiwy8nJ0TXXXKMLL7xQXbp0UWZmpoqLi8+43vLly5WcnKzIyEj16dNH77zzjpNlAgAAGMHRYLdhwwbNmDFD77//vtauXasTJ05o5MiRqq6urnOdTZs2afz48Zo6daq2b9+uzMxMZWZm6pNPPnGyVAAAgGYvwrIsK1Q/7JtvvlGXLl20YcMGXX/99bZzbrnlFlVXV2vVqlX+sWuvvVb9+vXTkiVLQlUqAABAs9M6lD+ssrJSktSxY8c65xQWFiorKytgLD09XStXrrSd7/V65fV6/cs+n0+HDh1Sp06dFBERcf5FAwAANDLLsnT48GF17dpVLlfjnUANWbDz+XyaNWuWrrvuOl111VV1zisrK1NcXFzAWFxcnMrKymzn5+TkKDs7u1FrBQAACIUvv/xSl1xySaNtL2TBbsaMGfrkk09UUFDQqNudN29ewBG+yspKde/eXXv27FFMTEyj/qzmzOfzqbCwUB6Pp1H/z6A5oyf26EswemKPvgSjJ/boS7CKigolJibqwgsvbNTthiTYzZw5U6tWrdLGjRvPmErj4+NVXl4eMFZeXq74+Hjb+W63W263O2g8JiaGYPcDPp9P7du3V0xMDL9U36Mn9uhLMHpij74Eoyf26EvdGvuyMUe7a1mWZs6cqRUrVmjdunVKTEw84zoej0d5eXkBY2vXrpXH43GqTAAAACM4esRuxowZevnll/XGG2/owgsv9F8n16FDB7Vr106SNHHiRF188cXKycmRJN19990aNmyYHnvsMY0ePVqvvPKKtm7dqqVLlzpZKgAAQLPn6BG7v/zlL6qsrFRqaqoSEhL8j1dffdU/p6SkRPv37/cvp6Sk6OWXX9bSpUvVt29f/fd//7dWrlxZ7w0XAAAAcPiI3dl8RF5+fn7Q2Lhx4zRu3DgHKgIAADAXVzACAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAhHg93GjRt10003qWvXroqIiNDKlSvrnZ+fn6+IiIigR1lZmZNlAgAAGMHRYFddXa2+fftq8eLFDVqvuLhY+/fv9z+6dOniUIUAAADmaO3kxkeNGqVRo0Y1eL0uXbooJiam8QsCAAAwmKPB7lz169dPXq9XV111le6//35dd911dc71er3yer3+5aqqKkmSz+eTz+dzvNbm4lQv6Mlp9MQefQlGT+zRl2D0xB59CeZULyIsy7Ic2fKPf1BEhFasWKHMzMw65xQXFys/P1+DBg2S1+vVs88+q7/+9a/avHmzBgwYYLvO/fffr+zs7KDxVatWqX379o1VPgAAQKOprq7WjTfeqMrKSkVHRzfadptUsLMzbNgwde/eXX/9619tn7c7YtetWzcdPHiQ07k/4PP5VFBQoKFDh8rl4mZoiZ7Uhb4Eoyf26EswemKPvgSrqKhQp06dGj3YNclTsT80ePBgFRQU1Pm82+2W2+0OGne5XOw8NuhLMHpij74Eoyf26EswemKPvpzmVB+afHeLioqUkJAQ7jIAAACaPEeP2B05ckS7du3yL+/Zs0dFRUXq2LGjunfvrnnz5qm0tFQvvviiJOmJJ55QYmKirrzySh0/flzPPvus1q1bp3/84x9OlgkAAGAER4Pd1q1bNXz4cP9yVlaWJGnSpEnKzc3V/v37VVJS4n++pqZGs2fPVmlpqaKionT11Vfr3XffDdgGAAAA7Dka7FJTU1XfvRm5ubkBy3PmzNGcOXOcLAkAAMBYTf4aOwAAAJwdgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCEeD3caNG3XTTTepa9euioiI0MqVK8+4Tn5+vgYMGCC3261evXopNzfXyRIBAACM4Wiwq66uVt++fbV48eKzmr9nzx6NHj1aw4cPV1FRkWbNmqXbb79da9ascbJMAAAAI7R2cuOjRo3SqFGjznr+kiVLlJiYqMcee0ySdPnll6ugoECLFi1Senq6U2UCAAAYoUldY1dYWKi0tLSAsfT0dBUWFoapIgAAgObD0SN2DVVWVqa4uLiAsbi4OFVVVenYsWNq165d0Dper1der9e/XFVVJUny+Xzy+XzOFtyMnOoFPTmNntijL8HoiT36Eoye2KMvwZzqRZMKduciJydH2dnZQeOFhYVq3759GCpq2goKCsJdQpNDT+zRl2D0xB59CUZP7NGX06qrqx3ZbpMKdvHx8SovLw8YKy8vV3R0tO3ROkmaN2+esrKy/MtVVVXq1q2bPB6PYmJinCy3WfH5fCooKNDQoUPlcjWpM/BhQ0/s0Zdg9MQefQlGT+zRl2AVFRWObLdJBTuPx6N33nknYGzt2rXyeDx1ruN2u+V2u4PGXS4XO48N+hKMntijL8HoiT36Eoye2KMvpznVB0e7e+TIERUVFamoqEhS7ceZFBUVqaSkRFLt0baJEyf659955536/PPPNWfOHH366ad6+umn9dprr+mee+5xskwAAAAjOBrstm7dqv79+6t///6SpKysLPXv31/z58+XJO3fv98f8iQpMTFRb7/9ttauXau+ffvqscce07PPPstHnQAAAJwFR0/FpqamyrKsOp+3+1aJ1NRUbd++3cGqAAAAzMSJbgAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMEZJgt3jxYl166aWKjIzUkCFDtGXLljrn5ubmKiIiIuARGRkZijIBAACaNceD3auvvqqsrCwtWLBAH374ofr27av09HR9/fXXda4THR2t/fv3+x979+51ukwAAIBmz/Fg9/jjj2vatGmaMmWKrrjiCi1ZskRRUVF6/vnn61wnIiJC8fHx/kdcXJzTZQIAADR7rZ3ceE1NjbZt26Z58+b5x1wul9LS0lRYWFjnekeOHFGPHj3k8/k0YMAA/ed//qeuvPJK27ler1der9e/XFVVJUny+Xzy+XyN9Eqav1O9oCen0RN79CUYPbFHX4LRE3v0JZhTvYiwLMtyZMuS9u3bp4svvlibNm2Sx+Pxj8+ZM0cbNmzQ5s2bg9YpLCzUZ599pquvvlqVlZVauHChNm7cqB07duiSSy4Jmn///fcrOzs7aHzVqlVq3759474gAACARlBdXa0bb7xRlZWVio6ObrTtOnrE7lx4PJ6AEJiSkqLLL79czzzzjB588MGg+fPmzVNWVpZ/uaqqSt26dZPH41FMTEwoSm4WfD6fCgoKNHToULlc3Awt0ZO60Jdg9MQefQlGT+zRl2AVFRWObNfRYNe5c2e1atVK5eXlAePl5eWKj48/q220adNG/fv3165du2yfd7vdcrvdQeMul4udxwZ9CUZP7NGXYPTEHn0JRk/s0ZfTnOqDo91t27atBg4cqLy8PP+Yz+dTXl5ewFG5+pw8eVIff/yxEhISnCoTAADACI6fis3KytKkSZM0aNAgDR48WE888YSqq6s1ZcoUSdLEiRN18cUXKycnR5L0wAMP6Nprr1WvXr1UUVGhRx99VHv37tXtt9/udKkAAADNmuPB7pZbbtE333yj+fPnq6ysTP369dPq1av9H2FSUlIScDjy22+/1bRp01RWVqaLLrpIAwcO1KZNm3TFFVc4XSoAAECzFpKbJ2bOnKmZM2faPpefnx+wvGjRIi1atCgEVQEAAJiFKxgBAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADBGSYLd48WJdeumlioyM1JAhQ7Rly5Z65y9fvlzJycmKjIxUnz599M4774SiTAAAgGbN8WD36quvKisrSwsWLNCHH36ovn37Kj09XV9//bXt/E2bNmn8+PGaOnWqtm/frszMTGVmZuqTTz5xulQAAIBmzfFg9/jjj2vatGmaMmWKrrjiCi1ZskRRUVF6/vnnbef/6U9/UkZGhu69915dfvnlevDBBzVgwAD9+c9/drpUAACAZs3RYFdTU6Nt27YpLS3t9A90uZSWlqbCwkLbdQoLCwPmS1J6enqd8wEAAFCrtZMbP3DggE6ePKm4uLiA8bi4OH366ae265SVldnOLysrs53v9Xrl9Xr9y1VVVZIkn88nn893PuUb5VQv6Mlp9MQefQlGT+zRl2D0xB59CeZULxwNdqGQk5Oj7OzsoPHCwkK1b98+DBU1bQUFBeEuocmhJ/boSzB6Yo++BKMn9ujLadXV1Y5s19Fg17lzZ7Vq1Url5eUB4+Xl5YqPj7ddJz4+vkHz582bp6ysLP9yVVWVunXrJo/Ho5iYmPN7AQbx+XwqKCjQ0KFD5XLxKTcSPakLfQlGT+zRl2D0xB59CVZRUeHIdh0Ndm3bttXAgQOVl5enzMxMSbV/uXl5eZo5c6btOh6PR3l5eZo1a5Z/bO3atfJ4PLbz3W633G530LjL5WLnsUFfgtETe/QlGD2xR1+C0RN79OU0p/rg+KnYrKwsTZo0SYMGDdLgwYP1xBNPqLq6WlOmTJEkTZw4URdffLFycnIkSXfffbeGDRumxx57TKNHj9Yrr7yirVu3aunSpU6XCgAA0Kw5HuxuueUWffPNN5o/f77KysrUr18/rV692n+DRElJSUBqTUlJ0csvv6zf/e53uu+++3TZZZdp5cqVuuqqq5wuFQAAoFkLyc0TM2fOrPPUa35+ftDYuHHjNG7cOIerAgAAMAsnugEAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwhKPB7tChQ5owYYKio6MVExOjqVOn6siRI/Wuk5qaqoiIiIDHnXfe6WSZAAAARmjt5MYnTJig/fv3a+3atTpx4oSmTJmi6dOn6+WXX653vWnTpumBBx7wL0dFRTlZJgAAgBEcC3Y7d+7U6tWr9cEHH2jQoEGSpKeeeko33HCDFi5cqK5du9a5blRUlOLj450qDQAAwEiOBbvCwkLFxMT4Q50kpaWlyeVyafPmzfr5z39e57ovvfSS/uu//kvx8fG66aab9Pvf/77Oo3Zer1der9e/XFVVJUny+Xzy+XyN9Gqav1O9oCen0RN79CUYPbFHX4LRE3v0JZhTvXAs2JWVlalLly6BP6x1a3Xs2FFlZWV1rnfbbbepR48e6tq1qz766CP99re/VXFxsV5//XXb+Tk5OcrOzg4aLywsVPv27c/vRRiooKAg3CU0OfTEHn0JRk/s0Zdg9MQefTmturrake02ONjNnTtXDz/8cL1zdu7cec4FTZ8+3f/nPn36KCEhQSNGjNDu3bvVs2fPoPnz5s1TVlaWf7mqqkrdunWTx+NRTEzMOddhGp/Pp4KCAg0dOlQuFzdDS/SkLvQlGD2xR1+C0RN79CVYRUWFI9ttcLCbPXu2Jk+eXO+cpKQkxcfH6+uvvw4Y/+6773To0KEGXT83ZMgQSdKuXbtsg53b7Zbb7Q4ad7lc7Dw26EswemKPvgSjJ/boSzB6Yo++nOZUHxoc7GJjYxUbG3vGeR6PRxUVFdq2bZsGDhwoSVq3bp18Pp8/rJ2NoqIiSVJCQkJDSwUAAGhRHIvNl19+uTIyMjRt2jRt2bJF7733nmbOnKlbb73Vf0dsaWmpkpOTtWXLFknS7t279eCDD2rbtm364osv9Oabb2rixIm6/vrrdfXVVztVKgAAgBEcPR760ksvKTk5WSNGjNANN9ygoUOHaunSpf7nT5w4oeLiYh09elSS1LZtW7377rsaOXKkkpOTNXv2bI0dO1ZvvfWWk2UCAAAYwdEPKO7YsWO9H0Z86aWXyrIs/3K3bt20YcMGJ0sCAAAwFlcwAgAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAjcGypAMHFFlWJh04ULsMhBjBDgCA81FRIf3pT9Jll8kVF6drx4+XKy5Ouuyy2vGKinBXiBaEYAcAwLlas0a65BLpnnukzz8PfO7zz2vHL7mkdh4QAgQ7AADOxZo10ujR0rFjtaddf3zq9dTYsWO18wh3CAHHgt1DDz2klJQURUVFKSYm5qzWsSxL8+fPV0JCgtq1a6e0tDR99tlnTpUIAMC5qaiQxo6tDW4+X/1zfb7aeWPHcloWjnMs2NXU1GjcuHG66667znqdRx55RE8++aSWLFmizZs3q3379kpPT9fx48edKhMAgIZ74QXp6NEzh7pTfL7a+S++6GxdaPEcC3bZ2dm655571KdPn7Oab1mWnnjiCf3ud7/TmDFjdPXVV+vFF1/Uvn37tHLlSqfKBACgYSxLeuqpc1v3ySe5WxaOah3uAk7Zs2ePysrKlJaW5h/r0KGDhgwZosLCQt16662263m9Xnm9Xv9yVVWVJMnn88l3tv8n1QKc6gU9OY2e2KMvweiJvRbblwMH5Nq9u+HrWZa0e7d8Bw5InTo1fl1NWIvdV+rhVC+aTLArKyuTJMXFxQWMx8XF+Z+zk5OTo+zs7KDxwsJCtW/fvnGLNEBBQUG4S2hy6Ik9+hKMnthraX2JLCvTteex/pa8PB2Pj2+0epqTlrav1Ke6utqR7TYo2M2dO1cPP/xwvXN27typ5OTk8yqqIebNm6esrCz/clVVlbp16yaPx3PWN220BD6fTwUFBRo6dKhcLm6GluhJXehLMHpir8X25cCB81p98IgRLfKIXYvcV+pR4dCNNA0KdrNnz9bkyZPrnZOUlHROhcR//38v5eXlSkhI8I+Xl5erX79+da7ndrvldruDxl0uFzuPDfoSjJ7Yoy/B6Im9FteX2FipZ8/az6lryPVyERFSUpJcnTvX/rkFanH7Sj2c6kODgl1sbKxiY2MdKSQxMVHx8fHKy8vzB7mqqipt3ry5QXfWAgDgqIgI6de/rv3w4Yb6zW9abKhDaDgWm0tKSlRUVKSSkhKdPHlSRUVFKioq0pEjR/xzkpOTtWLFCklSRESEZs2apT/84Q9688039fHHH2vixInq2rWrMjMznSoTAICGmzRJahd8tqhOLpcUFSVNnOhcTYAcvHli/vz5euGFF/zL/fv3lyStX79eqampkqTi4mJVVlb658yZM0fV1dWaPn26KioqNHToUK1evVqRkZFOlQkAQMNFRkgTOkvPfiWd6Wysy1V7lO711yWu/YbDHAt2ubm5ys3NrXeO9aNrEyIiIvTAAw/ogQcecKosAADO3z9+J3Wtkm6Lkl47Kp1QbXj74b9rp065tmtXG+pGjgxLqWhZuIIRAICG2L1O+vD7b5Do1VrKulCacJX045sHk5KkJ56QSksJdQiZJvM5dgAANHnew9Kbvwkci75Q+vPbUodu8h04oC15eRo8YkSLvvsV4UOwAwDgbK1dIFV+GTj202wppnvtnzt1qv3w4U6dCHUIC07FAgBwNvZslLY+Fzh26b9LA/9PeOoBbBDsAAA4k5pq6c1fB461iZJ+9lTtXa9AE8HeCADAmeQ9IH37ReDYiAVSx8SwlAPUhWAHAEB99m6SNj8TONbdIw2eHp56gHoQ7AAAqEvNUemNGQr4FOLWkdKYxZyCRZPEXgkAQF3WPyQd+jxw7Ce/kzr1DE89wBkQ7AAAsPPlFqlwceDYJddI1/4qPPUAZ4FgBwDAj504HnwKtpX7+1OwrcJWFnAmBDsAAH4sP0c68K/AsdS5Umzv8NQDnCWCHQAAP1S6Tdr0ZOBY1/5Sym/s5wNNCMEOAIBTvvNKK2dIlu/0mKuNNOZpqRXfwommj2AHAMApGx+VvtkZODZsjhR3RXjqARqIYAcAgCTt/x/p/z0eOBbfRxp6T3jqAc4BwQ4AgO9qvj8Fe/L0mKv196dg24SvLqCBCHYAABQskso/DhwbmiUlXB2eeoBzRLADALRs5Ttqr637oS5XStffG556gPNAsAMAtFwnv5NW/krynTg9FtFKylwstW4bvrqAc0SwAwC0XJv+JO0vChy77u7az60DmiGCHQCgZfr6Uyn/j4FjnXtLw34bnnqARkCwAwC0PL6Ttd8Fe7Lm9FiES8p8WmoTGb66gPNEsAMAtDyFi6XSrYFjnhnSJYPCUw/QSAh2AICW5cAuaf1DgWOdeknD/2946gEaEcEOANBynDoF+93xHwxGSGMWS23aha0soLEQ7AAALceWpdKX7weODblT6n5teOoBGhnBDgDQMhzcLb2bHTh20aXSiN+HpRzACQQ7AID5fD7pzV9L3x0LHP/Zn6W27cNTE+AAgh0AwHxbn5P2vhc4ds3tUuK/h6cewCEEOwCA2b79Qlq7IHCsQ3cpLdt2OtCcEewAAOayLOnN30gnqgPHf/ak5L4gPDUBDiLYAQDMtS1X2rMhcGzAJKnn8LCUAziNYAcAMFPFl9I/fnTHa/TF0sgHw1MPEAIEOwCAeSxLeutuqeZw4PhNT0qRHcJTExACBDsAgHmKXpJ25wWO9ZsgXZYWnnqAECHYAQDMUrVPWn1f4NgF8VL6Q/bzAYMQ7AAA5rAsadU9krcycPymJ6R2F4WlJCCUCHYAAHN89Jr0r9WBY31+IfUeFZ56gBAj2AEAzHC4XPr7nMCx9l2kUQ+Hpx4gDAh2AIDmz7Kkt7Ok4xWB46Mfk6I6hqUkIBwcC3YPPfSQUlJSFBUVpZiYmLNaZ/LkyYqIiAh4ZGRkOFUiAMAUO16XPl0VOHblz6UrfhaeeoAwae3UhmtqajRu3Dh5PB4999xzZ71eRkaGli1b5l92u91OlAcAMEX1AemdewPHojpJNywMTz1AGDkW7LKza79cOTc3t0Hrud1uxcfHO1ARAMBI7/yHdPRg4NgNj0rtO4enHiCMmtw1dvn5+erSpYt69+6tu+66SwcPHjzzSgCAlumfb0o7VgSOXX6TdOXN4akHCDPHjtidi4yMDN18881KTEzU7t27dd9992nUqFEqLCxUq1atbNfxer3yer3+5aqqKkmSz+eTz+cLSd3Nwale0JPT6Ik9+hKMntgLe1+Oflt7CjbiB/8+tLtIGvVY7c0UlhXyksLekyaKvgRzqhcRlnX2e/7cuXP18MP13za+c+dOJScn+5dzc3M1a9YsVVRUNLi4zz//XD179tS7776rESNG2M65//77/ad9f2jVqlVq3759g38mAACA06qrq3XjjTeqsrJS0dHRjbbdBgW7b7755oynRpOSktS2bVv/8vkEO0mKjY3VH/7wB91xxx22z9sdsevWrZsOHjx41nfjtgQ+n08FBQUaOnSoXK4mdwY+LOiJPfoSjJ7YC2tfildLr/3vwLHLMqRb/ipFRIS2lh9gX7FHX4JVVFSoU6dOjR7sGnQqNjY2VrGxsY32w8/kq6++0sGDB5WQkFDnHLfbbXvnrMvlYuexQV+C0RN79CUYPbEX8r4c+1Z6+x7JOnl6LLKDdONjUh2X7YQa+4o9+nKaU31wrLslJSUqKipSSUmJTp48qaKiIhUVFenIkSP+OcnJyVqxovai1yNHjujee+/V+++/ry+++EJ5eXkaM2aMevXqpfT0dKfKBAA0N6vvk46UBY6l50jRdR8EAFoKx26emD9/vl544QX/cv/+/SVJ69evV2pqqiSpuLhYlZW1X9TcqlUrffTRR3rhhRdUUVGhrl27auTIkXrwwQf5LDsAQK3P1kr/83LgWK+fSv1uC089QBPjWLDLzc0942fY/fDyvnbt2mnNmjVOlQMAaO6OV0pv/iZwrO2F0k1PhPW6OqAp4UQ3AKB5+MfvpMP7AsfS/yB1uCQ89QBNEMEOAND07V4nffhi4FhSqjRgUljKAZoqgh0AoGnzHg4+BdumvXTTk5yCBX6EYAcAaNrWLpAqvwwc+2m2dFGP8NQDNGEEOwBA07Vno7T1ucCxS/9dGjQ1PPUATRzBDgDQNNVUS2/+OnCsTZT0syclPuQWsMVvBgCgacp7QPr2i8CxEfOljklhKQdoDgh2AICmZ2+htPmZwLFu10qD7b83HEAtgh0AoGmpOSq9MUPS6Q+xV+tIacxiTsECZ8BvCACgaVn/kHRod+DY8P8rde4VnnqAZoRgBwBoOr78QHr/6cCxiwdJnhnhqQdoZgh2AICm4cRx6Y1fSZbv9Firtt+fgm0VvrqAZoRgBwBoGjb8UTrwr8Cx1LlSl+Tw1AM0QwQ7AED4lW6T3vtT4FhCPynl7rCUAzRXBDsAQGjtKwpc/s4rrZwReArW1UbKfFpq1TqkpQHNHcEOABA6h8ulv42XvEdOj218VPpmZ+C86++V4q4MbW2AAQh2AIDQ+WyNdHifVLCodnn//0j/7/HAOXF9pH/PCn1tgAEIdgCA0CleXfvfTU9JB3Z9fwr25OnnXa2/PwXbJjz1Ac0cFy8AAELjxHHp8/W1fz7plZ4fKR09GDhnaJaUcHXoawMMwRE7AEBo7NkonTh6evnHoa7LFbXX1gE4ZwQ7AEBo/Ovv9T9/1c3Soc+lmurQ1AMYiFOxAADnWZb0rzX1z1n3h9qHJF0QL41bJvVIcb42wCAcsQMAOK/sY6mq9OzmtrtIGvssoQ44BxyxAwA471+rz25e53+Txr8iderpbD2AoQh2AADnFZ/h+jpJ6vkT6X8tk9rFOF4OYCpOxQIAnHW4TNr3Yf1zBt8h3bacUAecJ47YAQCcVd9NExGtpBsela6ZGrp6AIMR7AAAzqrr+rrIGOkXL0hJqaGsBjAawQ4A4JwTx6Td64PHO/WSxr8qde4V+poAgxHsAADO2bNR+u5Y4FhSqjQut/ZjTQA0Km6eAAA458d3w14zTZrw34Q6wCEcsQMAOOOH3zYR0Uoa9bA0eFp4awIMR7ADADhj//9Ih/dJkR1qT732/Em4KwKMR7ADADjjX6uljj2l216VOl8W7mqAFoFgBwBwxomj0u3vSlEdw10J0GIQ7AAAzvjJfKkV/8wAocRdsQAAZxDqgJAj2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYwrFg98UXX2jq1KlKTExUu3bt1LNnTy1YsEA1NTX1rnf8+HHNmDFDnTp10gUXXKCxY8eqvLzcqTIBAACM4Viw+/TTT+Xz+fTMM89ox44dWrRokZYsWaL77ruv3vXuuecevfXWW1q+fLk2bNigffv26eabb3aqTAAAAGM49iFDGRkZysjI8C8nJSWpuLhYf/nLX7Rw4ULbdSorK/Xcc8/p5Zdf1k9+UvudgsuWLdPll1+u999/X9dee61T5QIAADR7If30yMrKSnXsWPdXy2zbtk0nTpxQWlqafyw5OVndu3dXYWGhbbDzer3yer0BP0OSKioqGq9wA/h8PlVXV6uiokIuF5dWSvSkLvQlGD2xR1+C0RN79CXYqZxiWVajbjdkwW7Xrl166qmn6jxaJ0llZWVq27atYmJiAsbj4uJUVlZmu05OTo6ys7ODxhMTE8+rXgAAAKcdPHhQHTp0aLTtNTjYzZ07Vw8//HC9c3bu3Knk5GT/cmlpqTIyMjRu3DhNmzat4VXWY968ecrKyvIvV1RUqEePHiopKWnURjV3VVVV6tatm7788ktFR0eHu5wmgZ7Yoy/B6Ik9+hKMntijL8EqKyvVvXv3es9knosGB7vZs2dr8uTJ9c5JSkry/3nfvn0aPny4UlJStHTp0nrXi4+PV01NjSoqKgKO2pWXlys+Pt52HbfbLbfbHTTeoUMHdh4b0dHR9OVH6Ik9+hKMntijL8HoiT36EqyxT003ONjFxsYqNjb2rOaWlpZq+PDhGjhwoJYtW3bG4gcOHKg2bdooLy9PY8eOlSQVFxerpKREHo+noaUCAAC0KI5dwVhaWqrU1FR1795dCxcu1DfffKOysrKAa+VKS0uVnJysLVu2SKo9yjZ16lRlZWVp/fr12rZtm6ZMmSKPx8MdsQAAAGfg2M0Ta9eu1a5du7Rr1y5dcsklAc+dugPkxIkTKi4u1tGjR/3PLVq0SC6XS2PHjpXX61V6erqefvrps/65brdbCxYssD0925LRl2D0xB59CUZP7NGXYPTEHn0J5lRPIqzGvs8WAAAAYcGHyQAAABiCYAcAAGAIgh0AAIAhCHYAAACGaPbB7osvvtDUqVOVmJiodu3aqWfPnlqwYIFqamrqXe/48eOaMWOGOnXqpAsuuEBjx45VeXl5iKp23kMPPaSUlBRFRUUFfUVbXSZPnqyIiIiAR0ZGhrOFhti59MWyLM2fP18JCQlq166d0tLS9NlnnzlbaAgdOnRIEyZMUHR0tGJiYjR16lQdOXKk3nVSU1OD9pU777wzRBU7Y/Hixbr00ksVGRmpIUOG+D+GqS7Lly9XcnKyIiMj1adPH73zzjshqjS0GtKX3NzcoP0iMjIyhNU6b+PGjbrpppvUtWtXRUREaOXKlWdcJz8/XwMGDJDb7VavXr2Um5vreJ2h1NCe5OfnB+0nERERdX51aHOUk5Oja665RhdeeKG6dOmizMxMFRcXn3G9xnhfafbB7tNPP5XP59MzzzyjHTt2aNGiRVqyZInuu+++ete755579NZbb2n58uXasGGD9u3bp5tvvjlEVTuvpqZG48aN01133dWg9TIyMrR//37/429/+5tDFYbHufTlkUce0ZNPPqklS5Zo8+bNat++vdLT03X8+HEHKw2dCRMmaMeOHVq7dq1WrVqljRs3avr06Wdcb9q0aQH7yiOPPBKCap3x6quvKisrSwsWLNCHH36ovn37Kj09XV9//bXt/E2bNmn8+PGaOnWqtm/frszMTGVmZuqTTz4JceXOamhfpNpvFvjhfrF3794QVuy86upq9e3bV4sXLz6r+Xv27NHo0aM1fPhwFRUVadasWbr99tu1Zs0ahysNnYb25JTi4uKAfaVLly4OVRh6GzZs0IwZM/T+++9r7dq1OnHihEaOHKnq6uo612m09xXLQI888oiVmJhY5/MVFRVWmzZtrOXLl/vHdu7caUmyCgsLQ1FiyCxbtszq0KHDWc2dNGmSNWbMGEfraSrOti8+n8+Kj4+3Hn30Uf9YRUWF5Xa7rb/97W8OVhga//znPy1J1gcffOAf+/vf/25FRERYpaWlda43bNgw6+677w5BhaExePBga8aMGf7lkydPWl27drVycnJs5//iF7+wRo8eHTA2ZMgQ64477nC0zlBraF8a8n5jAknWihUr6p0zZ84c68orrwwYu+WWW6z09HQHKwufs+nJ+vXrLUnWt99+G5KamoKvv/7akmRt2LChzjmN9b7S7I/Y2amsrKz3S3W3bdumEydOKC0tzT+WnJys7t27q7CwMBQlNln5+fnq0qWLevfurbvuuksHDx4Md0lhtWfPHpWVlQXsKx06dNCQIUOM2FcKCwsVExOjQYMG+cfS0tLkcrm0efPmetd96aWX1LlzZ1111VWaN29ewAeNNyc1NTXatm1bwN+xy+VSWlpanX/HhYWFAfMlKT093Yh94pRz6YskHTlyRD169FC3bt00ZswY7dixIxTlNlktYV85V/369VNCQoJ++tOf6r333gt3OY6qrKyUpHqzSWPtK45980S47Nq1S0899ZQWLlxY55yysjK1bds26BqruLg4o87xN1RGRoZuvvlmJSYmavfu3brvvvs0atQoFRYWqlWrVuEuLyxO7Q9xcXEB46bsK2VlZUGnP1q3bq2OHTvW+/puu+029ejRQ127dtVHH32k3/72tyouLtbrr7/udMmN7sCBAzp58qTt3/Gnn35qu05ZWZmx+8Qp59KX3r176/nnn9fVV1+tyspKLVy4UCkpKdqxY0fQNxC1FHXtK1VVVTp27JjatWsXpsrCJyEhQUuWLNGgQYPk9Xr17LPPKjU1VZs3b9aAAQPCXV6j8/l8mjVrlq677jpdddVVdc5rrPeVJnvEbu7cubYXV/7w8eM3l9LSUmVkZGjcuHGaNm1amCp3zrn0pCFuvfVW/exnP1OfPn2UmZmpVatW6YMPPlB+fn7jvQgHON2X5sjpnkyfPl3p6enq06ePJkyYoBdffFErVqzQ7t27G/FVoLnxeDyaOHGi+vXrp2HDhun1119XbGysnnnmmXCXhiakd+/euuOOOzRw4EClpKTo+eefV0pKihYtWhTu0hwxY8YMffLJJ3rllVdC8vOa7BG72bNna/LkyfXOSUpK8v953759Gj58uFJSUrR06dJ614uPj1dNTY0qKioCjtqVl5crPj7+fMp2VEN7cr6SkpLUuXNn7dq1SyNGjGi07TY2J/tyan8oLy9XQkKCf7y8vFz9+vU7p22Gwtn2JD4+PuhC+O+++06HDh1q0O/CkCFDJNUeMe/Zs2eD6w2nzp07q1WrVkF3xdf3fhAfH9+g+c3RufTlx9q0aaP+/ftr165dTpTYLNS1r0RHR7fIo3V1GTx4sAoKCsJdRqObOXOm/6a0Mx21bqz3lSYb7GJjYxUbG3tWc0tLSzV8+HANHDhQy5Ytk8tV/4HIgQMHqk2bNsrLy9PYsWMl1d6dU1JSIo/Hc961O6UhPWkMX331lQ4ePBgQaJoiJ/uSmJio+Ph45eXl+YNcVVWVNm/e3OA7jkPpbHvi8XhUUVGhbdu2aeDAgZKkdevWyefz+cPa2SgqKpKkJr+v2Gnbtq0GDhyovLw8ZWZmSqo9dZKXl6eZM2faruPxeJSXl6dZs2b5x9auXduk3z8a6lz68mMnT57Uxx9/rBtuuMHBSps2j8cT9JEVpu0rjaGoqKhZvn/UxbIs/frXv9aKFSuUn5+vxMTEM67TaO8r53J3R1Py1VdfWb169bJGjBhhffXVV9b+/fv9jx/O6d27t7V582b/2J133ml1797dWrdunbV161bL4/FYHo8nHC/BEXv37rW2b99uZWdnWxdccIG1fft2a/v27dbhw4f9c3r37m29/vrrlmVZ1uHDh63/+I//sAoLC609e/ZY7777rjVgwADrsssus44fPx6ul9HoGtoXy7KsP/7xj1ZMTIz1xhtvWB999JE1ZswYKzEx0Tp27Fg4XkKjy8jIsPr3729t3rzZKigosC677DJr/Pjx/ud//Puza9cu64EHHrC2bt1q7dmzx3rjjTespKQk6/rrrw/XSzhvr7zyiuV2u63c3Fzrn//8pzV9+nQrJibGKisrsyzLsn75y19ac+fO9c9/7733rNatW1sLFy60du7caS1YsMBq06aN9fHHH4frJTiioX3Jzs621qxZY+3evdvatm2bdeutt1qRkZHWjh07wvUSGt3hw4f97xuSrMcff9zavn27tXfvXsuyLGvu3LnWL3/5S//8zz//3IqKirLuvfdea+fOndbixYutVq1aWatXrw7XS2h0De3JokWLrJUrV1qfffaZ9fHHH1t333235XK5rHfffTdcL6HR3XXXXVaHDh2s/Pz8gFxy9OhR/xyn3leafbBbtmyZJcn2ccqePXssSdb69ev9Y8eOHbN+9atfWRdddJEVFRVl/fznPw8Ig83dpEmTbHvywx5IspYtW2ZZlmUdPXrUGjlypBUbG2u1adPG6tGjhzVt2jT/G7gpGtoXy6r9yJPf//73VlxcnOV2u60RI0ZYxcXFoS/eIQcPHrTGjx9vXXDBBVZ0dLQ1ZcqUgKD749+fkpIS6/rrr7c6duxoud1uq1evXta9995rVVZWhukVNI6nnnrK6t69u9W2bVtr8ODB1vvvv+9/btiwYdakSZMC5r/22mvWv/3bv1lt27a1rrzySuvtt98OccWh0ZC+zJo1yz83Li7OuuGGG6wPP/wwDFU759RHdfz4caoPkyZNsoYNGxa0Tr9+/ay2bdtaSUlJAe8vJmhoTx5++GGrZ8+eVmRkpNWxY0crNTXVWrduXXiKd0hdueSHf/dOva9EfF8AAAAAmrkme1csAAAAGoZgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhvj/OJZe53SFs78AAAAASUVORK5CYII=", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p1 = dtuplot.scatter(x0, rendering_kw={\"markersize\":10,\"color\":'r'}, xlim=[-2,2],ylim=[-2,2],show=False)\n", + "p1.extend(dtuplot.quiver(x0,e,show=False))\n", + "p1.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi får gradienten i punktet $x_0$ ved" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}-1\\\\1\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡-1⎤\n", + "⎢ ⎥\n", + "⎣1 ⎦" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Nabla = Matrix([diff(f,x),diff(f,y)]).subs({x:x0[0],y:x0[1]})\n", + "Nabla" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hvorefter den retningsafledte, $f'((1,-1), e)$, findes ved" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEIAAAAaCAYAAAADiYpyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAABJ0AAASdAHeZh94AAACxElEQVR4nNWYS0hVURSGv2sPBSOQoJxkooOoiAYVNQiN7Ek36tYgKKFpkyY5EoLfBRUEDRpE1CiimhaRKUUpmFCzHtQgxB4UkoSUZBCS2uAcIY/ndB73uMEfLoez9l7/v/e6az/WKUxNTeESZparoKRCHjwFl4Ews43AZklXnYkmRIVjvf3AA8eaieA6EHWSPjvWTARngTCzFcBXV3pp4TIj9gFdDvVSwWUgtgDPHeqlgpNAmNkiYELSpAu9LFjoSGcb0B/VaGYfgVURzcOSauME/D1oCLgi6VRaXleB2ANciOkzClwKsY8l1DiIl+F3svDmGggzqwAqJP0JNNVI+h7j/kNSRxnyJWAE6MvCm9seYWY1eKfC8YC9ARjMSydCeymwA7gvaSILR54ZsQ4YBorAjX/sRZLdJivNrBWoA34Br4G+hBMrAouBu1l5c8sISf3AWWC3f0pMY62ktwkoaoGbwDm8Nd0DDJhZcwLfEt4kH2XlzfX4lDSAd3tsAjCzan+AcbgOtOANuhpYD1wD6oFuM9sQ5WhmVcBeoFvS76y8M5ZGzHEThtuSWgO2TrxUfQLsBB7HkUiygOkNcNLMxoA2oAPvXw/DLmAJIcsiDW8wIwaBdyl+QyED68SrMgG2A70RE0iC6XK96T99DgPjpKtqZ/HOyAhJLSnIovAUWG5mq4HKkHRNg2/+szqs0cwWAAeAHkmj5fDmfsX27xAPgTPAyzLptvrP9xHtTcAywk+LVLxzVWt04t0nYqtNM1vjb6pBez1w2X+9FeFeAiaBe+XyztUVuwt4IelLgr5HgTYz6wM+AT+BRrx9psrnuhh0MrMCcAh4Jmm4XN45yQhJI8CRhN178TKoETgGnAaa8Yq0E0BR0niI3yZgJbNri0y8Tj/e5gkzOw+0Aw2SPpTL5/qbZZ4oAa/yCALM44zIG/M5I3LFX8JyBaVbEOxnAAAAAElFTkSuQmCC", + "text/latex": [ + "$\\displaystyle - \\frac{\\sqrt{5}}{5}$" + ], + "text/plain": [ + "-√5 \n", + "────\n", + " 5 " + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = e.dot(Nabla)\n", + "a" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Dette viser, at *f aftager* fra punktet $(1,-1)$ i retningen $e$. Dette er fordi den retningsafledte angiver raten, hvormed $f$ aftager." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Parameterkurve i (x,y)-planen og dens tangenter\n", + "\n", + "Vi betragter spiralen, givet ved parameterfremstillingen," + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}u \\cos{\\left(u \\right)}\\\\u \\sin{\\left(u \\right)}\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡u⋅cos(u)⎤\n", + "⎢ ⎥\n", + "⎣u⋅sin(u)⎦" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "u, t = symbols('u t', real=True)\n", + "r = Matrix([u*cos(u), u*sin(u)])\n", + "r" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tangentvektoren i et vilkårligt punkt fåes nu til" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}- u \\sin{\\left(u \\right)} + \\cos{\\left(u \\right)}\\\\u \\cos{\\left(u \\right)} + \\sin{\\left(u \\right)}\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡-u⋅sin(u) + cos(u)⎤\n", + "⎢ ⎥\n", + "⎣u⋅cos(u) + sin(u) ⎦" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rd = diff(r,u)\n", + "rd" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi finder nu en parameterfremstilling for tangenten til spiralen i røringspunktet $((0,-\\frac{3\\pi}{2}))$, svarende til parameterværdien $u_0=\\frac{3\\pi}{2}$, som ses ved," + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}0\\\\- \\frac{3 \\pi}{2}\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡ 0 ⎤\n", + "⎢ ⎥\n", + "⎢-3⋅π ⎥\n", + "⎢─────⎥\n", + "⎣ 2 ⎦" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "u0 = 3*pi/2\n", + "rdu0 = rd.subs(u,u0)\n", + "ru0 = r.subs(u,u0)\n", + "ru0" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Parameterfremstillingen for tangenten i $u_0$ findes ved" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}\\frac{3 \\pi t}{2}\\\\- t - \\frac{3 \\pi}{2}\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡ 3⋅π⋅t ⎤\n", + "⎢ ───── ⎥\n", + "⎢ 2 ⎥\n", + "⎢ ⎥\n", + "⎢ 3⋅π⎥\n", + "⎢-t - ───⎥\n", + "⎣ 2 ⎦" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "T = ru0 + t*rdu0\n", + "T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Det hele kan nu visualiseres ved" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p = dtuplot.plot_parametric(r[0], r[1],(u,0,4*pi),rendering_kw={\"color\":\"red\"},use_cm=False,show=False)\n", + "p.extend(dtuplot.plot_parametric(T[0],T[1],(t,-1.5,1.5),rendering_kw={\"color\":\"royalblue\"},use_cm=False,show=False))\n", + "p.extend(dtuplot.scatter(ru0,rendering_kw={\"markersize\":10,\"color\":'black'}, show=False))\n", + "p.extend(dtuplot.quiver(ru0,rdu0,rendering_kw={\"color\":\"black\"},show=False))\n", + "\n", + "p.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-F-Uge-2-LilleDag.ipynb b/Demos/Demo-F-Uge-2-LilleDag.ipynb new file mode 100644 index 0000000..2424269 --- /dev/null +++ b/Demos/Demo-F-Uge-2-LilleDag.ipynb @@ -0,0 +1,308 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Intro til Keglesnit\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()\n", + "from dtumathtools import *" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Identifikation af et keglesnit\n", + "\n", + "Vi betragter en mængde $M$ af punkter i planen, der beskrives af ligningen\n", + "\n", + "$$\n", + "11x^2 - 24 x y + 4 y^2 - 20 x + 40 y - 60 = 0\n", + "$$\n", + "\n", + "Dette er en andengradsligning i to varaible. Den fremstiller et keglesnit, og vi er interesseret i, hvilket keglesnit det er. Det burde jo være lige til, da vi har en masse ligninger, der beskriver formen af de forskellige keglesnit, så vi burde bare kunne tjekke, hvilken der passer til vores ligning. Det er der bare ingen af dem, der gør, da vores ligning indeholder blandede led. Derfor er vi nødt til at lave et basisskifte.\n", + "\n", + "Vi opskriver ligningen på matrixform" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x,y = symbols(\"x y\")\n", + "var_vec = Matrix([x,y])\n", + "lignM = Eq(11*x**2 - 24*x*y + 4*y**2 - 20*x + 40*y - 60,0)\n", + "H = dtutools.hessian(lignM.lhs)\n", + "A = S(1)/2 * H\n", + "k = (var_vec.T * S(1)/2 * H * var_vec)[0].expand()\n", + "l = (Matrix([-20,40]).T * var_vec)[0].expand()\n", + "\n", + "A,k,l, k + l - 60" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Det hele ser ud som forventet. Nu vil vi fjerne de blandede led. Dette gør vi ved at diagonalisere $A$. Først finder vi egenvektorerne:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "A.eigenvects()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Da $A$ er symmetrisk vil de to tilhørende egenvektor være ortogonale på hinanden.\n", + "Vi finder en enhedsvektor i både $E_{20}$ og $E_{-5}$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "q1 = Matrix([S(3)/4,1])\n", + "q2 = Matrix([-S(4)/3,1])\n", + "q1 = q1.normalized() # Eller q1 = q1 / sqrt((q1.T * q1)[0])\n", + "q2 = q2.normalized() # q2 = q2 / sqrt((q2.T * q2)[0])\n", + "\n", + "q1, q2" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi ved nu at matricen $[ q1 \\mid q2 ]$ er ortogonal. Det eneste vi skal sikre os er, at den er positiv ortogonal." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Q = Matrix.hstack(q1,q2)\n", + "Q.det()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Det var den. Hvis ikke den var, kunne vi bare have byttet om på søjlerne, så vi havde fået $Q = [ q2 \\mid q1 ]$.\n", + "\n", + "Vi har et nyt koordinat system $(O,q1,q2)$, som svarer til en drejning af det givne koordinat system. Sammenhængen mellem de gamle koordinater $(x,y)=({}_e x,{}_e y)$ og de nye $({}_q x ,{}_q y)$ er\n", + "$$\n", + "\\begin{bmatrix} {}_e x \\\\ {}_e y \\end{bmatrix} = Q \\begin{bmatrix} {}_q x \\\\ {}_q y \\end{bmatrix}.\n", + "$$\n", + "da $Q = {}_e M_q$.\n", + "\n", + "Vi sætter $\\Lambda = \\begin{bmatrix} -5 & 0 \\\\ 0 & 20 \\end{bmatrix}$, og der skal så nu gælde\n", + "$$\n", + "Q ^ T A Q = \\Lambda.\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Lambda = Matrix([[-5,0],[0,20]])\n", + "Eq(Lambda,Q.T * A * Q)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu kan vi opstille vores ligning i det drejede koordinatsystem, hvor vi for nemhedsskyld omdøber $({}_q x ,{}_q y)$ til $(x_1 ,y_1)$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x1,y1 = symbols(\"x1 y1\")\n", + "var_vec_1 = Matrix([x1,y1])\n", + "lignM_1 = (var_vec_1.T * Q.T * A * Q * var_vec_1)[0] + (Matrix([-20,40]).T * Q * var_vec_1)[0] - 60\n", + "Eq(lignM_1,0)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Her bruger vi **kvadratkomplettering** til at omskrive ligningen til det følgende" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "-5*(x1-2)**2,expand(-5*(x1-2)**2), 20*(y1+1)**2,expand(20*(y1+1)**2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan her se, at de to konstanter, der opstår går ud med hinanden, så vi kan bare skrive de nye led direkte in i ligningen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lign = Eq((-5 * (x1 - 2) ** 2 + 20 * (y1 + 1) ** 2 - 60),0)\n", + "lign" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lign = Eq((lign.lhs + 60) / 60, (lign.rhs + 60) / 60)\n", + "lign" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Dette er en hyperbel med halvakserne $\\sqrt{3}$ og $\\sqrt{12}$. Vi kan finde centrum i det givne koordinatsystem vha. basisskifte. Koordinaterne $(x_1,y_1)$ er = $(2,-1)$\n", + "Vi finder dem for $(x,y)$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Q * Matrix([2,-1])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu er 1. aksen er linjen gennem hyperblens centrum med $e1$ som retningsvektor, og 2. aksen er linjen, der går gennem hyperblens centrum med $e2$ som retningsvektor.\n", + "Asymptoterne er givet ved $y_1 + 1= \\pm \\frac{\\sqrt{3}}{\\sqrt{12}}(x_1 - 2) = \\pm \\frac{1}{2}(x_1-2)$\n", + "\n", + "Nu oversætter vi asymptoterne til det koordinatsystem." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "((Q * Matrix([S(1)/2,1])).T * var_vec)[0], ((Q * Matrix([-S(1)/2,1])).T * var_vec)[0] + 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "t = symbols(\"t\")\n", + "M = dtuplot.plot_implicit(lignM,(x,-4,8),(y,-6,6),show=False,aspect=\"equal\",size=(6,6))\n", + "sym1 = dtuplot.plot_parametric(2 + q1[0]*t,1 + q1[1]*t,(t,-20,20),show=False)\n", + "sym2 = dtuplot.plot_parametric(2 + q2[0]*t,1 + q2[1]*t,(t,-20,20),show=False)\n", + "asymp1 = dtuplot.plot_implicit(Eq(-x/S(2)+y,0),(x,-4,8),(y,-6,6),show=False)\n", + "asymp2 = dtuplot.plot_implicit(Eq(-S(11)*x/10+y/S(5)+2,0),(x,-4,8),(y,-6,6),show=False)\n", + "q1p = dtuplot.quiver(Matrix([2,1]),q1 * 2, rendering_kw={\"color\":\"black\"},show=False)\n", + "q2p = dtuplot.quiver(Matrix([2,1]),q2 * 2, rendering_kw={\"color\":\"black\"},show=False)\n", + "\n", + "M.extend(sym1)\n", + "M.extend(sym2)\n", + "M.extend(asymp1)\n", + "M.extend(asymp2)\n", + "M.extend(q1p)\n", + "M.extend(q2p)\n", + "\n", + "#fjern legend\n", + "M.legend = False\n", + "\n", + "M.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-F-Uge-2-StoreDag.ipynb b/Demos/Demo-F-Uge-2-StoreDag.ipynb new file mode 100644 index 0000000..c3bfd3d --- /dev/null +++ b/Demos/Demo-F-Uge-2-StoreDag.ipynb @@ -0,0 +1,293 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Taylor i to variabler\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "init_printing()\n", + "from dtumathtools import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Approksimerende polynomier\n", + "Vi betragter følgende funktion af to variabler\n", + "\n", + "$$\n", + "f(x,y) = \\sin(x^2 + y^2)\n", + "$$\n", + "\n", + "Den er plottet herunder" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x,y = symbols(\"x y\")\n", + "f = sin(x ** 2 + y ** 2)\n", + "dtuplot.plot3d(f,(x,-1.5,1.5),(y,-1.5,1.5),rendering_kw={\"color\" : \"blue\"})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lad os udregne det approksimerende 1. gradspolynomium i udviklingspunktet $(0,0)$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "P1 = dtutools.taylor(f,[x,0,y,0],degree=2)\n", + "P1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p = dtuplot.plot3d(P1,(x,-1.5,1.5),(y,-1.5,1.5),show=false,rendering_kw={\"alpha\" : 0.5},camera={\"azim\":-81,\"elev\":18})\n", + "p.extend(dtuplot.plot3d(f,(x,-1.5,1.5),(y,-1.5,1.5),show=False))\n", + "p.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Her kan vi se at $P1$ ligger i $(x,y)$ planen. \n", + "\n", + "Lad os se hvordan det approksimerende 2. gradspolynomium ser ud." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "P2 = dtutools.taylor(f,[x,0,y,0],3)\n", + "P2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot3d(f,P2,(x,-1.5,1.5),(y,-1.5,1.5))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Denne gang er det approksimerende polynomium en elliptisk parabloide.\n", + "Lad os til sidst prøve at se hvordan, det approksimerende 6. gradspolyniom ser ud." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "P6 = dtutools.taylor(f,[x,0,y,0],7)\n", + "p = dtuplot.plot3d(f,(x,-1.5,1.5),(y,-1.5,1.5),show=False)\n", + "p.legend=True\n", + "p.show()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Som forventet ligger de nu meget tættere på hinanden.\n", + "Lad os undersøge fejlen for de polynomier i nogle forskellige punkter for at se, hvor godt de passer.\n", + "Lad starte med $(0.2,0.2)$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f_p1 = f.subs([(x,1/5),(y,1/5)])\n", + "P1_p1 = P1.subs([(x,1/5),(y,1/5)])\n", + "P2_p1 = P2.subs([(x,1/5),(y,1/5)])\n", + "P6_p1 = P6.subs([(x,1/5),(y,1/5)])\n", + "\n", + "f_p1 - P1_p1, f_p1 - P2_p1, f_p1 - P6_p1" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Det hele ser rigtigt ud. Fejlen er meget mindre for de approksimerende polynomier af højere grad.\n", + "Lad os prøve med $(0.5,0.5)$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f_p2 = f.subs([(x,1/2),(y,1/2)])\n", + "P1_p2 = P1.subs([(x,1/2),(y,1/2)])\n", + "P2_p2 = P2.subs([(x,1/2),(y,1/2)])\n", + "P6_p2 = P6.subs([(x,1/2),(y,1/2)])\n", + "\n", + "f_p2 - P1_p2, f_p2 - P2_p2, f_p2 - P6_p2" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Jo længere væk vi kommer fra udviklingspunktet $(0,0)$ jo større fejl må vi forvente. \n", + "\n", + "(Det skal nævnes, at vores sammenligninger baserer sig på antagelsen om, at SymPy's egne approksimeringer er bedre end vores. Det er nok en ret god antagelse i det her tilfælde, men det er vigtigt at vide, at SymPy, Maple og alle andre computerredskaber også approksimerer.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Andengradspolynomium på matrixform" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi betragter følgende 2. gradspolynomium af tre variable\n", + "\n", + "$$\n", + "f(x,y,z) = 7x^2 - 4xy + 6y^2 - 4yz + 5z^2 - 2x + 20y -10z\n", + "$$\n", + "\n", + "De første fem led i $f$ udgør en **kvadratisk form** $k$. Altså de led i $f$, der enten består af kvadratiske eller blandede produkter.\n", + "For at opskrive $k$ på matrix form skal beregne $f$'s Hessematrix. For at gøre dette opretter vi igen en hjælpefunktion med noget python magi, der gør det nemmere fremover." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "z = symbols(\"z\")\n", + "f = 7*x**2 - 4*x*y + 6*y**2 - 4*y*z + 5*z**2 - 2*x + 20*y - 10*z\n", + "H = dtutools.hessian(f)\n", + "H" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Udfra vores Hessematrix $H$ kan vi nu opskrive $k$ på matrixform på følgende måde\n", + "\n", + "$$\n", + "A = \\frac{1}{2} H \\\\\n", + "k = \\begin{bmatrix} x & y & z \\end{bmatrix} A \\begin{bmatrix} x \\\\ y \\\\ z \\end{bmatrix}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "var_vec = Matrix([x,y,z])\n", + "A = S(1)/2 * H\n", + "k = (var_vec.T * A * var_vec)[0].expand()\n", + "k" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "De led i $f$, der ikke tilhører $k$, kan opskrives som følgende matrix\n", + "\n", + "$$\n", + "\\begin{bmatrix} -2 & 20 & -10 \\end{bmatrix}\n", + "$$\n", + "\n", + "Nu kan vi så opskrive hele $f$ på matrix form\n", + "\n", + "$$\n", + "f(x,y,z) = \\begin{bmatrix} x & y & z \\end{bmatrix} A \\begin{bmatrix} x \\\\ y \\\\ z \\end{bmatrix} + \\begin{bmatrix} -2 & 20 & -10 \\end{bmatrix} \\begin{bmatrix} x \\\\ y \\\\ z \\end{bmatrix}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f_matrix = k + (Matrix([-2,20,-10]).T * var_vec)[0]\n", + "f_matrix" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "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.6 (main, Aug 10 2022, 11:40:04) [GCC 11.3.0]" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-F-Uge-3-StoreDag.ipynb b/Demos/Demo-F-Uge-3-StoreDag.ipynb new file mode 100644 index 0000000..ab9e6ff --- /dev/null +++ b/Demos/Demo-F-Uge-3-StoreDag.ipynb @@ -0,0 +1,592 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Esktremumsundersøgelser (basic)\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "from dtumathtools import * \n", + "init_printing()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lokale ekstrema, eksempel 1" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi vil forsøge at finde alle ekstremumspunkter for funktionen\n", + "\n", + "$$\n", + "f(x,y) = x^3 - 3x^2 + y^3 - 3y^2\n", + "$$\n", + "\n", + "Vi bemærker at $f$ er defineret på alle punkter i $\\mathbb{R}^2$. Alstå ingen rand- eller undtagelsespunkter, vi bør undersøge.\n", + "\n", + "Derfor kan vi nøjes med at undersøge de stationære punkter, der er givet ved løsningen til ligningerne:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x,y = symbols(\"x y\")\n", + "f = x**3 - 3 * x**2 + y**3 - 3 * y**2\n", + "lign1 = Eq(f.diff(x),0)\n", + "lign2 = Eq(f.diff(y),0)\n", + "display(lign1,lign2)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Disse ligninger er ikke-lineære, men løses alligevel let, enten i hånden eller i SymPy:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sols = nonlinsolve([lign1, lign2], [x,y])\n", + "sols" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu har vi vores stationære punkter. Nu kan vi finde de partielt afledede af 2. orden og opstille Hessematricen. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fxx = f.diff(x,2)\n", + "fxy = f.diff(x,y)\n", + "fyy = f.diff(y,2)\n", + "\n", + "H = Matrix([[fxx,fxy],[fxy,fyy]])\n", + "H" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu kan vi indsætte de stationære punkter og undersøge egenvædierne for $H$, hvilket er nemt, da $H$ allerede er diagonaliseret." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "[H.subs([(x,x0),(y,y0)]) for (x0,y0) in sols]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan se at $(0,0)$ er et egentligt maksimum i $(0,0)$. Den geometriske tolkning af dette er" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtutools.taylor(f,[x,0,y,0],3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan heraf se, at grafen for taylorpolynomiet af grad to er en **elleptisk parabloide** med toppunkt i $(0,0,0)$\n", + "\n", + "Da de to egenværdier for $(0,2)$ og $(2,0)$ har forskelligt fortegn, er de to punkter ikke ekstremum, men derimod saddelpunkter.\n", + "Geometrisk tolkning:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "display(dtutools.taylor(f,[x,0,y,2],3), dtutools.taylor(f,[x,2,y,0],3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Heraf kan vi se at taylorpolynomiet for begge punkter er **hyperbolske parabloider**, med toppunkter i hhv. $(0,2,-4)$ og $(2,0,-4)$\n", + "\n", + "Punktet $(2,2)$ er et egentligt minimum, da de to egenværdier begge er positive.\n", + "Geometrisk tolkning:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtutools.taylor(f,[x,2,y,2],3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Heraf kan vi se, at taylorpolynomiet af grad to er en **elliptisk parabloide**\n", + "\n", + "Lad os se grafen for $f$ med de fire punkter" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "pf = dtuplot.plot3d(f,(x,-0.8,2.8),(y,-0.8,2.8),use_cm=True,show=False,wireframe=True,rendering_kw={\"alpha\":0.6})\n", + "points = dtuplot.scatter(*[Matrix([x0,y0,f.subs([(x,x0),(y,y0)])]) for (x0,y0) in sols],show=False,\n", + "rendering_kw={\"s\" : 100,\"color\":\"red\"})\n", + "pf.camera = {\"azim\" : -50, \"elev\" : 30}\n", + "pf.extend(points)\n", + "pf.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lokale ekstrema, eksempel 2" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi betragter nu funktionen \n", + "$$\n", + "f(x,y) = x^4 + 4x^2y^2 + y^4 -4x^3 - 4y^3 + 2\n", + "$$\n", + "\n", + "Vi bemærker at $f$ er defineret på alle punkter i $\\mathbb{R}^2$. Alstå ingen rand- eller undtagelsespunkter, vi bør undersøge. Derfor kan vi nøjes med at undersøge de stationære punkter." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f = x ** 4 + 4 * x**2 * y ** 2 + y ** 4 - 4 * x ** 3 - 4 * y ** 3 + 2\n", + "lign1 = Eq(f.diff(x),0)\n", + "lign2 = Eq(f.diff(y),0)\n", + "lign1,lign2,f" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sols = nonlinsolve([lign1,lign2], [x, y])\n", + "sols" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "[(N(xsol),N(ysol)) for (xsol,ysol) in sols]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan her se, at der findes fire (reelle) stationære punkter. Nemlig:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "stat_punkter = list(sols)[:-2]\n", + "stat_punkter" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lad os finde Hessematricen for at kunne undersøge punkterne." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "H = dtutools.hessian(f)\n", + "H" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi indsætter de stationære punkter og bruger Python's `zip` til at udskrive Hesse-matricerne med deres tilhørende egenværdier:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Hesse_matricer = [H.subs([(x,x0),(y,y0)]) for x0,y0 in stat_punkter]\n", + "Eig_Hesse_matricer = [h.eigenvals() for h in Hesse_matricer]\n", + "\n", + "list(zip(Hesse_matricer,Eig_Hesse_matricer))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Heraf kan vi aflæse at $f$ har egenligt minimum i både $(0,3)$ og $(3,0)$. Vi kan se at $(1,1)$ er saddelpunkt og ikke et ekstremum. Men da begge egenværdier for puntket $(0,0)$ er nul, er vi nødt til at lave en særundersøgelse af punktet.\n", + "\n", + "Lad os prøve at se hvordan $f$ opfører sig på linjen $y=x$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot(f.subs(y,x),2,(x,-0.5,1.2),axis_center=\"auto\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Allerede her er det meget tydeligt, at $(0,0)$ ikke er et egentligt minimum.\n", + "Vist mere præcist:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tmp = f.subs(y,x) - f.subs([(x,0),(y,0)])\n", + "display(tmp, tmp.factor())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Heraf kan vi se\n", + "\n", + "\n", + "$f(x,x) - f(0,0) > 0$ når $x < 0$ og $f(x,x) - f(0,0) < 0$, når $0 < x < \\frac{4}{3}$\n", + "\n", + "Derfor kan $f$ ikke have ekstremum i $(0,0)$.\n", + "\n", + "Lad os foretage en geometrisk tolkning for særtilfældet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtutools.taylor(f,[x,0,y,0],3)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Her kan vi se at taylorpolynomiet af anden grad i dette tilfælde er planet med $z=2$. Her er $(0,0)$ et minimum (og maksimum), men ikke et egentligt et. Hvis taylorpolynomiet udviklet i et punkt, har et egentligt minimum eller maksimum, så har funktionen det også.\n", + "\n", + "Lad os se grafen for $f$ sammen med de stationære punkter." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "pf = dtuplot.plot3d(f,(x,-2,5),(y,-2,5),xlim=(-2,5),ylim=(-2,5),zlim=(-30,15),show=False,rendering_kw={\"alpha\":0.5})\n", + "points = dtuplot.scatter(*[Matrix([x0,y0,f.subs([(x,x0),(y,y0)])]) for x0,y0 in stat_punkter],show=False,rendering_kw={\"color\":\"red\",\"s\" : 30})\n", + "pf.camera = {\"azim\" : -161, \"elev\" : -5}\n", + "(pf + points).show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Globale ekstrema på begrænset og afsluttet mængde, eksempel 1\n", + "\n", + "Vi betragter nu funktionen\n", + "\n", + "$$\n", + "f(x,y) = 3 + x - x ^ 2 - y ^ 2\n", + "$$\n", + "\n", + "Igen er $f$ defineret på hele $\\mathbb{R}^2$, men denne gang vil vi undersøge funktionen begrænset til mængden $M$, \n", + "der indesluttes af linjerne $y = -1$, $y = 1-x$ og $x=0$. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "M = dtuplot.plot_implicit(Eq(x,0),Eq(y,1-x),Eq(y,-1), (1-x >= y) & (y >= -1) & (x >= 0),(x,-0.1,2.1),(y,-1.1,1.1),show=False)\n", + "M.legend = False\n", + "M.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi bemærker at $f$ er differentiabel over hele $M$, så der er ingen undtagelsespunkter, vi skal tage hensyn til. Derfor er den også kontinuert på hele $M$. Da $M$ er afsluttet og begrænset, har $f$ derfor et globalt minimum og maksimum på $M$. De to værdier må enten antages i **stationære punter** eller på **randen**.\n", + "\n", + "Da $M$ er en sammenhængende mængde, er værdimængden for $f(M) = [A;B]$, hvor $A$ er et globalt minimum, og $B$ er et globalt maksimum.\n", + "\n", + "Lad os først kigge på $f$'s niveaukurver" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f = 3 + x - x ** 2 - y ** 2\n", + "niveau = dtuplot.plot_contour(f,(x,-0.1,2.1),(y,-1.1,1.1),show=False)\n", + "niveau.extend(dtuplot.plot_implicit(Eq(x,0),Eq(y,1-x),Eq(y,-1),(x,-0.1,2.1),(y,-1.1,1.1),show=False))\n", + "niveau.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lad os nu bestemme de **stationære punkter**." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lign1 = Eq(f.diff(x),0)\n", + "lign2 = Eq(f.diff(y),0)\n", + "sols = nonlinsolve([lign1,lign2], [x,y])\n", + "sols" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan se at punkter ligger i $M$, og er derfor et relevant **stationært punkt.** Lad os plotte restriktionen af $f$ til hver af de tre randlinjer. \n", + "Derefter finder de **stationære punkter** for at de tre restriktioner." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot(f.subs(y,-1),(x,0,2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot(f.subs(y,1-x),(x,0,2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot(f.subs(x,0),(y,-1,1),ylim = (0,3),aspect=\"equal\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "stat_punkter = set(sols)\n", + "\n", + "lodret = solve(f.subs(x,0).diff(y))\n", + "vandret = solve(f.subs(y,-1).diff(x))\n", + "skrå = solve(f.subs(y,1-x).diff(x))\n", + "\n", + "stat_punkter.update(set([(0,y0) for y0 in lodret]))\n", + "stat_punkter.update(set([(x0,-1) for x0 in vandret]))\n", + "stat_punkter.update(set([(x0,1-x0) for x0 in skrå]))\n", + "stat_punkter" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu skal vi blot finde maksimum og minimum mellem de fundne stationære punkter og randlinjernes endepunkter, så $(0,1)$,\n", + "$(0,-1)$ og $(2,-1)$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "undersøgelses_punkter = list(stat_punkter) + [(0,1),(0,-1),(2,-1)]\n", + "f_værdier = [f.subs([(x,x0),(y,y0)]) for x0,y0 in undersøgelses_punkter]\n", + "\n", + "minimum = min(f_værdier)\n", + "maximum = max(f_værdier)\n", + "f_værdier, minimum, undersøgelses_punkter[f_værdier.index(minimum)], maximum, undersøgelses_punkter[f_værdier.index(maximum)]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu har vi endelig:\n", + "\n", + "Globalt minimum: $0$ i punktet $(2,-1)$ \n", + "Globalt maximum: $\\frac{13}{4}$ i punktet $(\\frac{1}{2},0)$ \n", + "Værdimængde: $[0,\\frac{13}{4}]$\n", + "\n", + "Lad os plotte det hele samlet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "u = symbols(\"u\")\n", + "pf = dtuplot.plot3d(f,(x,0,2),(y,-1,1),show=False,rendering_kw={\"alpha\":0.7})\n", + "punkter = dtuplot.scatter(Matrix([2,-1,0]),Matrix([1/2,0,13/4]),show=False,rendering_kw={\"color\":\"red\",\"s\":20})\n", + "l1 = dtuplot.plot3d_parametric_line(u,-1,f.subs({x:u,y:-1}),(u,0,2),use_cm=False,show=False,rendering_kw={\"color\":\"red\",\"linewidth\":2})\n", + "l2 = dtuplot.plot3d_parametric_line(0,u,f.subs({x:0,y:u}),(u,-1,1),use_cm=False,show=False,rendering_kw={\"color\":\"red\",\"linewidth\":2})\n", + "l3 = dtuplot.plot3d_parametric_line(u,1-u,f.subs({x:u,y:1-u}),(u,0,2),use_cm=False,show=False,rendering_kw={\"color\":\"red\",\"linewidth\":2})\n", + "combined = (pf + punkter + l1 + l2 + l3)\n", + "combined.camera = {\"azim\" : 118, \"elev\" : 61}\n", + "combined.legend = False\n", + "\n", + "combined.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-F-Uge-4-StoreDag.ipynb b/Demos/Demo-F-Uge-4-StoreDag.ipynb new file mode 100644 index 0000000..7a8c683 --- /dev/null +++ b/Demos/Demo-F-Uge-4-StoreDag.ipynb @@ -0,0 +1,422 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Kurveintegraler\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "from dtumathtools import *\n", + "init_printing()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## En venstresum\n", + "\n", + "Vi laver en venstresum for funktionen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "u,x,y,a,b = symbols('u x y a b')\n", + "f = exp(u)*sin(u)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi gør dette ved at opdele intervallet $-\\pi$ til $\\pi$ i $10$ lige store stykker, " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p = dtuplot.plot(f, (u,-pi,pi), {\"color\":\"red\"}, axis_center=\"auto\", show=False)\n", + "area = 0\n", + "for i in range(10):\n", + " xval = i*pi/5 - pi\n", + " yval = f.subs(u,xval)\n", + " \n", + " # Hjørner af firkant\n", + " c1 = Point(xval,0)\n", + " c2 = Point(xval+pi/5,0)\n", + " c3 = Point(xval+pi/5,yval)\n", + " c4 = Point(xval,yval)\n", + "\n", + " poly = Polygon(c1,c2,c3,c4)\n", + " p.extend(dtuplot.plot_geometry(poly,{\"color\":\"green\", \"alpha\":0.5},show=False))\n", + "\n", + " # Kan ikke finde areal af en linje\n", + " if yval != 0:\n", + " area += poly.area\n", + "\n", + "p.legend = False\n", + "p.show()\n", + "\n", + "# vis areal\n", + "area.evalf()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Prøv at gentage, men denne gang med flere firkanter, og se hvordan resultatet ændres." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Stamfunktion og bestemt integral\n", + "\n", + "Vi kigger på samme funktion som før, og finder stamfunktionen ved," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "F = integrate(f,u)\n", + "F" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Det bestemte integrale kan så bestemmes ved en af de to følgende metoder," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "display(F.subs(u,pi) - F.subs(u,-pi), integrate(f,(u,-pi,pi)))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan nu sammenligne arealet af firkanterne (med fortegn) med integralet," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "display(area.evalf(), integrate(f,(u,-pi,pi)).evalf())" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## En kurve i planen\n", + "\n", + "Vi får givet en parameter-kurve," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r = Matrix([sin(u), sin(u)*cos(u)])\n", + "r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p_kurve = dtuplot.plot_parametric(r[0],r[1], (u,0,2*pi),use_cm=False, label=\"r(u)\",axis_center=\"auto\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tangentvektor og tangent\n", + "\n", + "Vi finder tangentvektoren," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dr = r.diff(u)\n", + "dr" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi finder nu parameterfremstillingen for tangenten svarende til kurvepunktet $r(\\pi/3)$," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "t = symbols(\"t\")\n", + "r_tan = r.subs(u,pi/3) + t*dr.subs(u,pi/3)\n", + "r_tan" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p_point = dtuplot.scatter(r.subs(u,pi/3), show=False)\n", + "p_tan = dtuplot.plot_parametric(r_tan[0],r_tan[1], (t,-1,1), use_cm=False, label=\"r '(pi/3)\", show=False)\n", + "\n", + "(p_kurve + p_point + p_tan).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Kurvelængde" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# jacobi jacobi\n", + "jacobi = sqrt(dr.dot(dr))\n", + "simplify(jacobi)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For at finde kurvelængden, skal vi så bare integrere over jacobi-funktionen. Dette er dog ikke helt trivielt, og vi skal også bede om den numeriske tilnærmelse for at få et tal ud, som vi kan forstå," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrate(jacobi,(u,0,2*pi)), integrate(jacobi,(u,0,2*pi)).evalf()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Kurveintegrale i rummet\n", + "\n", + "Vi får givet en tæthedsfunktion," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x,y,z = symbols(\"x y z\")\n", + "f = sqrt(x**2 + y**2 + z**2)\n", + "f" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "og en parameterkurve for $u\\in[0,5]$," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r = Matrix([u*cos(u), u*sin(u), u])\n", + "r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p_rumkurve = dtuplot.plot3d_parametric_line(r[0],r[1],r[2], (u,0,2*pi), use_cm=False, label=\"r(u)\",aspect=\"equal\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi ønsker nu at bestemme $\\int_K f(x,y,z)\\, \\mathrm{d} \\mu$.\n", + "\n", + "Først finder vi tangentvektoren," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dr = r.diff(u)\n", + "dr" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Længden af tangentvektoren $||r_u'(u)||$ er lig med Jacobi-funktionen," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "jacobi = sqrt(dr.dot(dr))\n", + "\n", + "# Følgende linje virker kun hvis $u$ er en reel variabel\n", + "# altså hvis 'u = symbols('u', real=True)'\n", + "# jacobi = dr.norm()\n", + "\n", + "simplify(jacobi)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan nu finde **integralet langs kurven**," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrate(f.subs({x:r[0], y:r[1], z:r[2]})*jacobi,(u,0,5)).evalf()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "og **kurvens længde**," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrate(jacobi,(u,0,5)).evalf()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-F-Uge-5-LilleDag.ipynb b/Demos/Demo-F-Uge-5-LilleDag.ipynb new file mode 100644 index 0000000..8333b04 --- /dev/null +++ b/Demos/Demo-F-Uge-5-LilleDag.ipynb @@ -0,0 +1,666 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Flader i rummet \n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "from dtumathtools import * \n", + "init_printing()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Syv flader\n", + "\n", + "### Når fladen er en graf en for funktion\n", + "\n", + "Givet funktionen $h$ af to variable\n", + "$$\n", + "h(x,y) = x ^ 2 - y ^ 2 + 5\n", + "$$\n", + "\n", + "#### Eksempel 1 : Vi betragter den del af fladen, der ligger over kvadradet $\\{(x,y) \\mid -2 \\leq x \\leq 2$ og $ -2 \\leq y \\leq 2 \\}$\n", + "\n", + "Fladens (elementære) parameterfremstilling" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x,y,z,u,v = symbols(\"x y z u v\",real=True)\n", + "# sympy kan ofte lave bedre simplificeringer af udtryk, når den ved, at variablerne er reelle, \n", + "# så når vi kan er det en god ide at gøre. Ellers kan nogle integraler tage ret lang tid.\n", + "h = x ** 2 - y ** 2 + 5\n", + "r = Matrix([x,y,h])\n", + "r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "flade = dtuplot.plot3d_parametric_surface(*r,(x,-2,2),(y,-2,2),use_cm=True,camera={\"elev\":30,\"azim\":-130},show=False)\n", + "kvadrat = dtuplot.plot3d_parametric_surface(x,y,0,(x,-2,2),(y,-2,2),rendering_kw={\"color\" : \"black\"},show=False)\n", + "(flade + kvadrat).show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Eksempel 2 : Vi betragter den del af fladen, der ligger over cirkelringen $\\{ (x,y) \\mid 1 \\leq x^2 + y^2 \\leq 2\\}$\n", + "\n", + "Denne paratremiseres på følgende vis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r = Matrix([u*cos(v),u*sin(v),h.subs({x:u*cos(v),y:u*sin(v)})])\n", + "r" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hvor $u \\in [1,2]$ og $v \\in [0,2\\pi]$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "flade = dtuplot.plot3d_parametric_surface(*r,(u,1,2),(v,0,2*pi),show=False,camera = {\"azim\":-75,\"elev\":40})\n", + "skive = dtuplot.plot3d_parametric_surface(r[0],r[1],0,(u,1,2),(v,0,2*pi),show=False)\n", + "(flade + skive).show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Når fladen er en Omdrejningsflade\n", + "Det afgørende spørgsmål er, hvordan *profil-kurven er givet i $(x,z)$-planen.\n", + "\n", + "#### Eksempel 1 : Profil-kurven er givet som en parameterfremstilling i $(x,z)$-planen:\n", + "$$\n", + "(x,z) = (u ^2,u); u \\in [-1;1]\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot_parametric(u ** 2 + 1,u,(u,-1,1),use_cm=False,aspect=\"equal\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi opskriver profil-kurven på standard 3d form (tilføj blot $y=0$)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "profil = Matrix([u ** 2 + 1, 0, u])\n", + "profil_plot = dtuplot.plot3d_parametric_line(*profil,(u,-1,1),show=False,camera={\"azim\":-65,\"elev\":12},use_cm=False)\n", + "profil_plot.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu benytter vi metoden fra e-note 25.3 til at opskrive parameterfremstillingen for fladen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r = Matrix([(u ** 2 + 1) * cos(v),(u ** 2 + 1) * sin(v), u])\n", + "r" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hvor $u \\in [-1,1]$ og $v \\in [0,2\\pi]$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan også få $r(u,v)$ ved at rotere profil-kurven med rotations-matricen for at rotere om $z$-aksen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r = Matrix([[cos(v),-sin(v),0],[sin(v),cos(v),0],[0,0,1]]) * profil \n", + "r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "flade = dtuplot.plot3d_parametric_surface(*r,(u,-1,1),(v,0,2*pi),camera={\"azim\":-90,\"elev\":15},title=\"Omdrejningsfladen\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Eksempel 2: Når $z$ er enb funktion af $x$ i $(x,z)$-planen\n", + "\n", + "Profil-kurven er givet ved ligningen $z = (x-1) ^ 3 + 1; x \\in [0,2]$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot((x-1) ** 3 + 1,(x,0,2),axis_center=\"auto\",ylabel=\"z\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi opskriver ligningen til en parameterfremstilling på standard 3d form" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "profil = Matrix([u,0,(u-1) ** 3 + 1])\n", + "profil" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Fladen kan nu parametriseres på følgende vis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r = Matrix([[cos(v),sin(v),0],[sin(v),cos(v),0],[0,0,1]]) * profil\n", + "r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "flade = dtuplot.plot3d_parametric_surface(*r, (u,0,2),(v,0,2*pi),camera={\"azim\":-65,\"elev\":25},use_cm = True,legend=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Eksempel 3 : Profil-kurven er givet parametrisk i $(x,z)$-planen\n", + "Profil-kurven er nu fire perioder af en lodretstående sinuskurve med $x=2$ som svingningsakse. \n", + "Vi parametriserer kurven" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "profil = Matrix([2 + sin(u),0,u])\n", + "dtuplot.plot3d_parametric_line(*profil,(u,0,8*pi),use_cm=False,camera={\"azim\" : -28, \"elev\" : 13})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r = Matrix([(2+sin(u)) * cos(v),(2+sin(u)) * sin(v),u])\n", + "r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "flade = dtuplot.plot3d_parametric_surface(*r,(u,0,8*pi),(v,0,2*pi),camera={\"azim\":-62,\"elev\":15},use_cm=True,legend=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Når fladen er en Cylinderflade\n", + "\n", + "Givet at ledekurven i $(x,y)$-planen er ellipse $\\frac{x^2}{4} + \\frac{y^2}{1} = 1$.\n", + "\n", + "#### Eksempel 1 : Med betingelsen $z \\in [0,1]$\n", + "\n", + "Ellipsen har i $(x,y)$-planen parameterfremstillingen $(x,y) = \\begin{bmatrix} 2 \\cos(u) \\\\ \\sin(v) \\end{bmatrix}; u \\in [0,2\\pi]$ \n", + "På standard 3d form" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lede = Matrix([2*cos(u),sin(u),0])\n", + "dtuplot.plot3d_parametric_line(*lede,(u,0,2*pi),use_cm=False,ylim=(-2,2),xlim=(-2,2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan nu parametrisere cylinderfladen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r = Matrix([lede[0],lede[1],v])\n", + "r" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For $u \\in [0,2\\pi]$ og $v \\in [0,1]$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "flade = dtuplot.plot3d_parametric_surface(*r,(u,0,2*pi),(v,0,1),ylim=(-2,2),xlim=(-2,2),zlim=(0,2),use_cm=True,legend=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Eksempel 2 : Med betingelsen $z \\in [0,x + y ^ 2]\n", + "\n", + "Dvs. $z = v (x + y ^ 2) = v (2\\cos(u) + \\sin(u) ^ 2); \\,v \\in [0,1]$\n", + "\n", + "Vi oversætter direkte til en parameterfremstilling for fladen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r = Matrix([2*cos(u),sin(u),v*(2*cos(u) + sin(u) ** 2)])\n", + "r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot3d_parametric_surface(*r,(u,0,2*pi),(v,0,1),camera={\"azim\":-120,\"elev\":20},use_cm=True,legend=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Integral over en graf-flade\n", + "En funktion\n", + "\n", + "$$\n", + "h(x,y) = \\frac{x ^ 2}{2} + y + 2\n", + "$$\n", + "\n", + "Betragtes på mængden $\\{(x,y) \\mid x \\in [0,2] $ og $ y \\in [-2x,0]\\}$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "h = x ** 2 / 2 + y + 2\n", + "dtuplot.plot_implicit((x >= 0) & (x <= 2) & (y >= -2*x) & (y <= 0),(x,0,2),(y,-4,0),aspect=\"equal\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi ønsker at finde **arealet** af fladen (svarende til fladeintegralet med konstant massetæthed $f(x,y) = 1$). \n", + "Trekanten parametriseres:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "trekant = Matrix([u,v*(-2*u)])\n", + "u_range = (u,0,2)\n", + "v_range = (v,0,1)\n", + "trekant" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi hæver nu fladen med $h$ som højdefunktion. Dette resulterer i følgende parameter fremstilling:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r = Matrix([trekant[0],trekant[1],h.subs({x:trekant[0],y:trekant[1]})])\n", + "r" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lad os plotte fladen med grundfladen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "flade = dtuplot.plot3d_parametric_surface(*r,u_range,v_range,show=False,rendering_kw={\"color\":\"blue\"},camera={\"azim\":-155,\"elev\":15})\n", + "grundflade = dtuplot.plot3d_parametric_surface(r[0],r[1],0,u_range,v_range,show=False,rendering_kw={\"alpha\":0.6})\n", + "\n", + "(flade + grundflade).show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu finder Jacobi-funktionen, der længden af følgende vektor" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "kryds = r.diff(u).cross(r.diff(v))\n", + "kryds" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Jacobi = kryds.norm()\n", + "Jacobi.simplify()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Det ønskede areal** \n", + "$$\n", + "\\int_F 1 \\, \\mathrm{d}\\mu = \\int_0^2 \\int_0^1 Jacobi \\, \\mathrm{d}v\\mathrm{d}u\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "display(integrate(Jacobi,u_range,v_range), integrate(Jacobi,u_range,v_range).evalf())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## En omdrejningsflade\n", + "\n", + "En profil-kurve er i $(x,z)$-planen givet som en enhedscirkel med centrum i $(x,z) = (3,0)$.\n", + "\n", + "Vi betragter den omdrejningsflade, der opstår ved at profil-kurven drejes en omgang om $z$-aksen.\n", + "\n", + "Vores funktion $h$ er nu \n", + "\n", + "$$ \n", + "h(x,y,z) = z ^ 2\n", + "$$\n", + "Så vi vil gerne bestemme $\\int_F z^2 \\, \\mathrm{d}\\mu$\n", + "\n", + "Parametriseringen af profil-kurven på standard 3d form" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "profil = Matrix([3 + cos(u), 0, sin(u)])\n", + "u_range = (u,0,2*pi)\n", + "h = z ** 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot_parametric(profil[0],profil[2],u_range,xlim=(0,4),ylim=(-1,1),ylabel=\"z\",use_cm=False,aspect=\"equal\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan nu parametrisere hele fladen. Enten fra hukommelse, eller vi kan bruge rotationsmatricen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r = Matrix([[cos(v),-sin(v),0],[sin(v),cos(v),0],[0,0,1]]) * profil\n", + "v_range = (v,0,2*pi)\n", + "r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "flade = dtuplot.plot3d_parametric_surface(*r,u_range,v_range,zlim=(-4,4),use_cm=True,legend=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu finder vi Jacobi-funktionen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Jacobi = r.diff(u).cross(r.diff(v)).norm().simplify()\n", + "Jacobi\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Det ønskede fladeintegral:**\n", + "$$\n", + "\\int_F z^2 \\,\\mathrm{d}S = \\int_0^{2\\pi} \\int_0^{2\\pi} z^2 Jacobi \\,\\mathrm{d}u\\mathrm{d}v\n", + "$$ " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrand = h.subs({x:r[0],y:r[1],z:r[2]}) * Jacobi\n", + "integrate(integrand,u_range,v_range)\n", + "# Hvis ikke vi havde erklæret vores variable for reelle i starten, så tager dette integrale 24 sek i stedet 0.2 sek" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Det ønskede areal**\n", + "$$\n", + "\\int_F 1 \\,\\mathrm{d}S = \\int_0^{2\\pi} \\int_0^{2\\pi} Jacobi \\,\\mathrm{d}u\\mathrm{d}v\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrand = Jacobi\n", + "integrate(integrand,u_range,v_range)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-F-Uge-5-StoreDag.ipynb b/Demos/Demo-F-Uge-5-StoreDag.ipynb new file mode 100644 index 0000000..ca2e4da --- /dev/null +++ b/Demos/Demo-F-Uge-5-StoreDag.ipynb @@ -0,0 +1,505 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Planintegraler og Fladeintegraler (basic)\n", + "\n", + "Demo af Christian Mikkestrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import * \n", + "from dtumathtools import *\n", + "init_printing()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## En metode til parametrisering af plane områder\n", + "\n", + "Den simpleste parameterkurve er en ret linje. Et eksempel på dette er:\n", + "$$ \n", + "\\begin{bmatrix} x \\\\ y \\end{bmatrix} = \\begin{bmatrix} 3 \\\\ 2 \\end{bmatrix} + v \\begin{bmatrix} 1 \\\\ 2 \\end{bmatrix}, \n", + "$$\n", + "hvor $v \\in [-1,1]$. Når parameteren $v$ gennemløber intervallet $[-1,1]$ vil punktet $(x,y)$ linjen med start $(2,0)$ og slut $(4,4)$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "u,v = symbols(\"u v\")\n", + "dtuplot.plot_parametric(3 + v,2 + 2 * v,(v,-1,1),xlim=(0,5),ylim=(0,5))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan ofte gøre livet lidt nemmere, når vi skal parametrisere plane områder ved brug af linjestykker. \n", + "Lad os kigge på to eksempler:\n", + "\n", + "### Eksempel 1\n", + "Vi skal parametrisere området i planen begrænset af linjerne: \n", + "$y = 1-x$ \n", + "$y = 2x+1$ \n", + "$x=2$ \n", + "\n", + "Lad os se hvordan det område ser ud.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x,y = symbols(\"x y\")\n", + "område = dtuplot.plot_implicit(Eq(x,2),Eq(y,2*x+1),Eq(y,1-x),(x <= 2) & (y <= 2*x+1) & (y >= 1-x),(x,-0.1,5),(y,-1.1,5.1),aspect=\"equal\",size=(8,8))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "AB = dtuplot.quiver(Matrix([1,0]),Matrix([0,3]),show=False,rendering_kw = {\"color\" : \"black\"})\n", + "område.extend(AB)\n", + "område.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi vil gerne parametrisere linjen udspændt af den store pil, der går fra et givet punkt på bunden af området til et givet punkt på toppen, med pilen som retningsvektor.\n", + "Vi beskriver punktet ved bunden af pilen generelt med $A = (u,1-u)$ \n", + "Toppen beskriver vi generelt med $B = (u,2u+1)$ \n", + "Derfor er retningsvektoren $AB$ beskrevet ved $\\begin{bmatrix} 0 \\\\ 3u \\end{bmatrix}$ \n", + "\n", + "Vi kan så parametrisere et givet linjestykke mellem to punkter på toppen og bunden, der er overfor hinanden, på følgende måde\n", + "$$ \n", + "\\begin{bmatrix} x \\\\ y \\end{bmatrix} = \\begin{bmatrix} u \\\\ 1-u \\end{bmatrix} + v\\begin{bmatrix} 0 \\\\ 3u \\end{bmatrix};\n", + "v \\in [0,1]\n", + "$$ \n", + "\n", + "Hvis vi vælger et $u$, der løber i intervallet $[0,2]$, så vil vi gennemløbe alle linjerne fra venstre til højre, og på den måde dække hele trekanten. \n", + "Så hele område kan parametriseres som:\n", + "$$ \n", + "\\begin{bmatrix} x \\\\ y \\end{bmatrix} = \\begin{bmatrix} u \\\\ 1-u +3vu\\end{bmatrix}, \\quad\n", + "u \\in [0,2];v \\in [0,1]; \n", + "$$ \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot3d_parametric_surface(u,1-u+3*u*v,0,(u,0,2),(v,0,1),camera={\"elev\":90, \"azim\":-90})\n", + "## Man kan ikke plotte planer i 2d, så vi bruger \"camera\" argumentet til at kigge på plottet fra oven" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Eksempel 2\n", + "\n", + "Vi vil nu parametrisere enhedscirkelskiven med centrum $(2,1)$.\n", + "Fordi vi godt ved, hvordan en cirkel ser ud, så vi gå direkte efter af finde det linjestykke vi gerne vil parametrisere.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cirkel = dtuplot.plot_implicit(Eq((x-2) ** 2 + (y-1) ** 2,1),((x-2) ** 2 + (y-1) ** 2 <=1),(x,0,3),(y,0,3),show=False)\n", + "AB = dtuplot.quiver(Matrix([2,1]),Matrix([cos(pi /4),sin(pi / 4)]),rendering_kw={\"color\":\"black\"},show=False)\n", + "cirkel.extend(AB)\n", + "cirkel.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi vil nu parametrisere enhver linje, der går fra centrum til en punkt på cirkelskivens rand. Dette gøres på følgende måde. Vores $A$ er nu $(2,1)$, vores $B$ er $(2 + \\cos(u), 1 + \\sin(u))$, så vores retningsvektor $AB$ er derfor $\\begin{bmatrix} \\cos(u) \\\\ \\sin(u) \\end{bmatrix}$. Vores linje parametriseres derfor som:\n", + "$$ \n", + "\\begin{bmatrix} x \\\\ y \\end{bmatrix} = \\begin{bmatrix} 2 \\\\ 1 \\end{bmatrix} + v \\begin{bmatrix} \\cos(u) \\\\ \\sin(u) \\end{bmatrix}; v \\in [0,1]\n", + "$$\n", + "Hvis vi lader $u$ gennemløbe intervallet $[0,2 \\pi]$, så vi få alle linjerne mellem centrum og randen, og på den måde få hele cirklen med. Så fladen parametriseres:\n", + "$$ \n", + "\\begin{bmatrix} x \\\\ y \\end{bmatrix} = \\begin{bmatrix} 2 + v \\cos(u) \\\\ 1 + v \\sin(u) \\end{bmatrix}; u \\in [0,2\\pi]; v \\in [0,1]\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot3d_parametric_surface(2 + v * cos(u), 1 + v * sin(u), 0, (u,0,2*pi), (v,0,1),camera = {\"elev\" : 90, \"azim\" : -90})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Et planintegral\n", + "Vi er givet et område $B$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot_implicit(Eq(y,1),Eq(x,1),Eq(y,x+1),((x <= 1) & (y >= 1) & (y <= 1 + x)),(x,0,2),(y,0,2),title=\"Integrationsområde B\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Og vi er givet funktionen \n", + "$$\n", + "f(x,y) = 2xy\n", + "$$\n", + "\n", + "Vi vil finde planintegralet $\\int_B f(x,y) \\mathrm{d}\\mu $ af $f$ over $B$, så derfor har vi brug for en parameterfremstilling for $B$.\n", + "\n", + "For et givet punkt på $x$-aksen har den lodrette vektor mellem linjerne $y=1$ og $y=x+1$ koordinater af formen $\\begin{bmatrix} 0 \\\\ u \\end{bmatrix}$. En mulig parametrisering af $B$ er derfor:\n", + "$$\n", + "r(u,v) = \\begin{bmatrix} u \\\\ 1 \\end{bmatrix} + v \\begin{bmatrix} 0 \\\\ u \\end{bmatrix} = \\begin{bmatrix} u \\\\ 1 + uv \\end{bmatrix}; u \\in [0,1]; v \\in [0,1]\n", + "$$\n", + "\n", + "NB: Ved denne parameterfremstilling afbildes det akseparallelle kvadrat $[0, 1] \\times [0, 1]$ i (u,v)-planen over i den trekant vi skal integrere over i (x,y)-planen." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu får vi brug for Jacobi-funktionen, som lokalt måler, hvor meget $(u,v)$-parameterområdet deformeres, når det udsættes for afbildningen $r$. Vi opstiller først Jacobimatricen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r = Matrix([u,1+u*v])\n", + "f = 2*x*y\n", + "JacobiM = Matrix.hstack(r.diff(u),r.diff(v))\n", + "JacobiM" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu kan finde Jacobi-funktionen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Jacobi = abs(JacobiM.det())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Integralet af $f$ over $B$ er da ifølge transformation sætningen \n", + "$$\n", + "\\int_B f(x,y) \\mathrm{d}\\mu = \\int_0 ^ 1 \\int_0 ^ 1 f(r(u,v))Jacobi \\mathrm{d}u\\mathrm{d}v = \\int_0 ^ 1 \\int_0 ^ 1 f(u,1+uv) u \\mathrm{d}u \\mathrm{d}v\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrate(f.subs([(x,u),(y,1+u*v)])*Jacobi,(u,0,1),(v,0,1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Et planintegral og massemidtpunkt\n", + "Givet funktion \n", + "$$\n", + "f(x,y) = (x-1) ^ 2 (y+1) ^ 2\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Planintegralet\n", + "\n", + "Vi ønsker at finde planintegralet af $f$ over mængden $B$, som er en ellipsering, der afgrænses af to ligedannede ellipser med centrum i Origo. \n", + "$E1$ har halvakserne $a=1$ og $b=\\frac{1}{2}$ \n", + "$E2$ har halvakserne $a=2$ og $b=1$\n", + "\n", + "Først skal vi parametrisere integrationsområdet." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f = (x-1) ** 2 * (y+1) ** 2\n", + "r = Matrix([u*cos(v),u*sin(v)/2])\n", + "r" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hvor $u \\in [1,2]$ og $v \\in [-\\pi,\\pi]$.\n", + "Lad se hvordan dette område ser ud i $(u,v)$-planen og i $(x,y)$-planen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot3d_parametric_surface(u,v,0,(u,1,2),(v,-pi,pi),camera={\"elev\":90,\"azim\":-90},xlim=(0,3),ylim=(-3.5,3.5))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "område = dtuplot.plot3d_parametric_surface(r[0],r[1],0,(u,1,2),(v,-pi,pi),camera={\"elev\":90,\"azim\":-90},xlim=(-2,2),ylim=(-2,2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi finder nu Jacobi funktionen som beskrevet ovenfor." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "JacobiM = Matrix.hstack(r.diff(u),r.diff(v))\n", + "Jacobi = abs(JacobiM.det())\n", + "Jacobi.simplify()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu finder vi integralet via transformationsætningen igen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrand = f.subs([(x,r[0]),(y,r[1])]) * Jacobi\n", + "integrand" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "M = integrate(integrand,(u,1,2),(v,-pi,pi))\n", + "M" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Massemidtpunkt\n", + "Vi fortolker nu $f$ som en massetæthedsfunktion. Så har vi lige fundet den samlede masse for $B$. \n", + "Sætter vi $x(u,v) = u \\cos(v)$ og $y(u,v) = \\frac{u \\sin(v)}{2}$, så massemidtpunktets koordinater givet ved: \n", + "$$\n", + "\\begin{bmatrix} x_0 \\\\ y_0 \\end{bmatrix} = \\begin{bmatrix} \\int_1 ^ 2 \\int_{-\\pi} ^ {\\pi} x(u,v) f(x(u,v),y(u,v)) \\mathrm{d}v\\mathrm{d}u \\\\ \\int_1 ^ 2 \\int_{-\\pi} ^ {\\pi} y(u,v) f(x(u,v),y(u,v))\\, \\mathrm{d}v\\mathrm{d}u \\end{bmatrix}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Mmidtpunkt = Matrix([integrate(r[0] * integrand,(u,1,2),(v,-pi,pi)),integrate(r[1] * integrand,(u,1,2),(v,-pi,pi))]) / M\n", + "Mmidtpunkt " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "punkt = dtuplot.scatter(Matrix([Mmidtpunkt[0],Mmidtpunkt[1],0]),show=False,rendering_kw={\"color\":\"black\"},xlim=(-2,2),ylim=(-2,2))\n", + "område.extend(punkt)\n", + "område.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## En cylinderflade\n", + "\n", + "Vi betragter en funktion $f$\n", + "\n", + "$$\n", + "f(x,y,z) = 8 z\n", + "$$\n", + "\n", + "Vi betragter også en flade givet ved følgende parameterfremstilling" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "z = symbols(\"z\")\n", + "f = 8*z\n", + "r = Matrix([u*cos(u),u*sin(u),u*v])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hvor $u \\in [0,\\frac{pi}{2}]$ og $v \\in [0,1]$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot3d_parametric_surface(*r,(u,0,pi/2),(v,0,1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi finder Jacobi-funktionen og indsætter parameterfremstillingen i $f$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "kryds = r.diff(u).cross(r.diff(v))\n", + "Jacobi = sqrt((kryds.T * kryds)[0]).simplify()\n", + "Jacobi\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrand = f.subs(z,r[2]) * Jacobi\n", + "integrand" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrate(integrand,(u,0,pi/2),(v,0,1)).evalf()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "language": "python", + "name": "mat1-pilot" + }, + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-F-Uge-6-StoreDag.ipynb b/Demos/Demo-F-Uge-6-StoreDag.ipynb new file mode 100644 index 0000000..8f5a148 --- /dev/null +++ b/Demos/Demo-F-Uge-6-StoreDag.ipynb @@ -0,0 +1,386 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Rumintegraler\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "from dtumathtools import * \n", + "init_printing()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Rumligt område begrænset af graf-flade\n", + "Givet funktionen \n", + "$$\n", + "f(x,y,z) = (1-x) ^ 2\n", + "$$\n", + "skal vi finde rumintegralet af $f$ over det *tetraeder* $T$, som er udspændt af punkterne $(0,0,0), (1,0,0), (0,1,0)$ og $(0,0,1)$.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "## Tænk ikke for meget over dette\n", + "\n", + "x,y,z,u,v,w = symbols(\"x y z u v w\",real=True)\n", + "ur = (u,0,1)\n", + "l1 = dtuplot.plot3d_parametric_line(u,0,0,ur,show=False,use_cm=False,rendering_kw={\"color\":\"red\"})\n", + "l2 = dtuplot.plot3d_parametric_line(0,u,0,ur,show=False,use_cm=False,rendering_kw={\"color\":\"red\"})\n", + "l3 = dtuplot.plot3d_parametric_line(0,0,u,ur,show=False,use_cm=False,rendering_kw={\"color\":\"red\"})\n", + "l4 = dtuplot.plot3d_parametric_line(1-u,u,0,ur,show=False,use_cm=False,rendering_kw={\"color\":\"red\"})\n", + "l5 = dtuplot.plot3d_parametric_line(u,0,1-u,ur,show=False,use_cm=False,rendering_kw={\"color\":\"red\"})\n", + "l6 = dtuplot.plot3d_parametric_line(0,u,1-u,ur,show=False,use_cm=False,rendering_kw={\"color\":\"red\"})\n", + "grundflade = dtuplot.plot3d_parametric_surface(u * (1-v),v,0,ur,(v,0,1),show=False,rendering_kw={\"color\":\"blue\",\"alpha\":0.75})\n", + "dash1 = dtuplot.plot3d_parametric_line(0.3,0.7*u,0,ur,show=False,use_cm=False,rendering_kw={\"color\":\"grey\",\"linestyle\":\"dashed\"})\n", + "dash2 = dtuplot.plot3d_parametric_line(0.3,0.7-0.7*u,0.7*u,ur,show=False,use_cm=False,rendering_kw={\"color\":\"grey\",\"linestyle\":\"dashed\"})\n", + "dash3 = dtuplot.plot3d_parametric_line(0.3,0,0.7*u,ur,show=False,use_cm=False,rendering_kw={\"color\":\"grey\",\"linestyle\":\"dashed\"})\n", + "pil3d = dtuplot.quiver(Matrix([0.3,0.375,0]),Matrix([0,0,0.375]),show=False,rendering_kw={\"color\":\"black\"})\n", + "\n", + "bund = dtuplot.plot_implicit((x >= 0) & (x <= 1) & (y >= 0) & (y <= 1-x),(x,0,1),(y,0,1),show=False)\n", + "pil2d = dtuplot.quiver(Matrix([0.2,0]),Matrix([0,0.8]),show=False,rendering_kw={\"color\":\"black\",\"width\":0.025})\n", + "\n", + "skelet = (l1 + l2 + l3 + l4 + l5 + l6 + dash1 + dash2 + dash3 + pil3d)\n", + "tetra = grundflade + skelet\n", + "tetra.legend=False\n", + "tetra.camera={\"azim\":25,\"elev\":25}\n", + "tetra.size=(6,6)\n", + "trekant = bund + pil2d\n", + "trekant.legend=False\n", + "trekant.grid=False\n", + "\n", + "d = dtuplot.plotgrid(tetra,trekant, nr = 1, nc = 2,size=(6,6))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Bunden af $T$ er vist som den blå trekant, mens toppen beskrevet som grafen til funktionen $h(x,y) = 1 - x - y$.\n", + "\n", + "Vi parametriserer den blå trekant som sædvanlig vis, så et punkt på den blå trekant er beskrevet af\n", + "$$\n", + "\\begin{bmatrix} x \\\\ y \\end{bmatrix} = \\begin{bmatrix} u \\\\ v (u-1) \\end{bmatrix}, \\quad u \\in [0,1], \\, v \\in [0,1]\n", + "$$\n", + "I punktet $(u,v(u-1))$ har $h$ værdiern $z = h(u,v(u-1)) = 1 - u - v(u-1)$. Så nu vil vi gerne parametrisere det generelle linjestykke mellem et punkt $(u,v(u-1),0)$ og $(u,v(u-1),1-u-v(u-1))$. Dette resulterer i følgende parameterfremstilling:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f = (1-x) ** 2\n", + "h = 1 - x - y\n", + "bund_punkt = Matrix([u,v*(1-u),0])\n", + "top_punkt = Matrix([u,v*(1-u),h.subs({x:u,y:v*(1-u)})])\n", + "r = bund_punkt + w * (top_punkt - bund_punkt)\n", + "r" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "hvor $u \\in [0,1]$, $v \\in [0,1]$ og $w \\in [0,1]$. Lad os finde den Jacobi-funktion, der indgår i rumintegralet. Først udregnes Jacobi-matricen og derefter determinanten af denne:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Matrix.hstack(*[r.diff(v) for v in [u,v,w]])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "determinanten = _.det() # underscore holder værdien fra seneste output\n", + "Jacobi = determinanten\n", + "# vi ved at determinanten er positiv i det betragtede område, så det er ikke nødvendigt at tage absolut værdien\n", + "# Jacobi.simplify() \n", + "Jacobi.factor()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "Nu finder vi rumintegralet som det tredobbelte intregral:\n", + "$$\n", + "\\int_T f(x,y,z) \\, \\mathrm{d}\\mu = \\int_0^1 \\int_0^1 \\int_0^1 f(r(u,v,w)) Jacobi \\, \\mathrm{d}u\\mathrm{d}v\\mathrm{d}w\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "M = integrate(f.subs({x:r[0],y:r[1],z:r[2]}) * Jacobi, (u,0,1), (v,0,1), (w,0,1))\n", + "M" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fortolkning: Masse og Massemidtpunkt\n", + "\n", + "Hvis vi fortolker $f$ som en massetæthedsfunktion, har tetraederet altså massen $M=\\frac{1}{10}$.\n", + "Massemidtpunktets koordinater kan bestemmes ud fra formlen:\n", + "$$\n", + "\\xi = \\frac{1}{M} \\begin{bmatrix} \\int_T x f(x,y,z) \\, \\mathrm{d}\\mu \\\\ \\int_T y f(x,y,z) \\, \\mathrm{d}\\mu \\\\ \\int_T z f(x,y,z) \\, \\mathrm{d}\\mu \\end{bmatrix}\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "xi = Matrix([integrate(coord * f.subs({x:r[0],y:r[1],z:r[2]})*Jacobi,(u,0,1),(v,0,1),(w,0,1)) for coord in r])/M\n", + "xi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Omdrejningslegeme\n", + "Et profilområde ligger i $(x,z)$-planen ligger mellem hyperblen $z=\\frac{1}{x}$ og $x$-aksen for $x \\in [\\frac{1}{2},2]$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot_implicit((x >= 1/2) & (x <= 2) & (y <= 1/x) & (y >= 0),(x,0,2),(y,0,2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Området parametriseres som:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "profil = Matrix([u,0,v/u])\n", + "profil" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "hvor $u \\in [\\frac{1}{2},2]$ og $v \\in [0,1]$. For at finde parameterfremstillingen for omdrejnignslegemet ganger vi profil-områdets parameterfremstilling med rotationsmatricen:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "legeme = Matrix([[cos(w),-sin(w),0],[sin(w),cos(w),0],[0,0,1]]) * profil\n", + "legeme" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lad os nu finde den tilhørende Jacobi-funktion:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "determinanten = Matrix.hstack(*[legeme.diff(v) for v in [u,v,w]]).det()\n", + "Jacobi = abs(determinanten.simplify())\n", + "Jacobi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I dette tilfælde er Jacobi-funktionen enormt simpel. Vi kan nu udregne rumfanget af omdrejningslegemet:\n", + "$$\n", + "\\int_{\\omega}f(x,y,z) \\, \\mathrm{d}\\mu = \\int_0^{2\\pi} \\int_0^1 \\int_{\\frac{1}{2}} ^ 2 f(r(u,v,w)) Jacobi \\, \\mathrm{d}u\\mathrm{d}v\\mathrm{d}w\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrate(Jacobi,(u,S(1)/2,2),(v,0,1),(w,0,2*pi))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cylinderlegeme\n", + "En mur er rejst mellem de to ledekurver:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "l1 = Eq(y,cos(x))\n", + "l2 = Eq(y,cos(x)+1)\n", + "x_range = (x,0,2*pi)\n", + "\n", + "dtuplot.plot_implicit(l1,l2,x_range,(y,-1,2),aspect=\"equal\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Murens højde er variabel idet $z \\in [0,\\frac{x}{2}]$. En parameterfremstilling for muren er:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mur = Matrix([u,cos(u)+v,w*u/2])\n", + "mur" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "hvor $u \\in [0,2\\pi]$, $v \\in [0,1]$ og $w \\in [0,1]$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "determinanten = Matrix.hstack(*[mur.diff(v) for v in [u,v,w]]).det()\n", + "## antag at variablerne er positive\n", + "Jacobi = abs(posify(determinanten)[0])\n", + "Jacobi\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Betragt funktionen \n", + "$$\n", + "f(x,y,z) = \\frac{1}{x}\n", + "$$\n", + "Vi kan nu udregne dette tredobbelt integral:\n", + "$$\n", + "\\int_T f(x,y,z) \\, \\mathrm{d} \\mu = \\int_0^1 \\int_0^1 \\int_0^{2\\pi} f(r(u,v,w))Jacobi \\, \\mathrm{d}u\\mathrm{d}v\\mathrm{d}w\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f = 1/x\n", + "integrand = (f.subs({x:mur[0],y:mur[1],z:mur[2]}) * Jacobi).simplify()\n", + "integrand" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrand = S(1)/2\n", + "integrate(integrand,(u,0,2*pi),(v,0,1),(w,0,1))\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "language": "python", + "name": "mat1-pilot" + }, + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-F-Uge-7-LilleDag.ipynb b/Demos/Demo-F-Uge-7-LilleDag.ipynb new file mode 100644 index 0000000..4c0607c --- /dev/null +++ b/Demos/Demo-F-Uge-7-LilleDag.ipynb @@ -0,0 +1,292 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Divergens og Rotation\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "from dtumathtools import *\n", + "init_printing()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Gradient, divergens og rotation er 3 funktioner, som kommer til at blive brugt meget i denne og de kommende uger! De skal faktisk bruges så meget, at disse 3 funktioner er implimenteret i ``dtumathtools``. I det følgende kommer eksempler på hvordan de bruges." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ``gradient``" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x,y,z = symbols('x y z')\n", + "f = x**2*sin(y)*z\n", + "f" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df = dtutools.gradient(f)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Eller hvis det skal være med hensyn til bestemte variable," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtutools.gradient(f,[x,z])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Evalueret i bestemte punkter," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df0 = df.subs([(x,1),(y,2),(z,3)])\n", + "df0" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "som numerisk evauleres til:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "N(df0)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ``div``" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "V = Matrix([x*y*sin(z),x*ln(y),-x*y*z**3])\n", + "V" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "divV = dtutools.div(V)\n", + "divV" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Den forsøger altid at gøre det ud fra de variable, som den kan finde. Dette er som regel $(x,y,z)$. Man kan dog ende i en situation, hvor man bliver nødt til at fortælle den hvilke variable den skal gøre det efter, eksempelvis hvis nogle variable ikke optræder." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "u,v,w = symbols('u v w')\n", + "# v optræder ikke i vektorfeltet\n", + "V2 = Matrix([u,w**2,u*sin(w)])\n", + "V2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtutools.div(V2, var=[u,v,w])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Evalueret i bestemte punkter," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "divV0 = divV.subs([(x,1),(y,2),(z,3)])\n", + "divV0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "som numerisk evauleres til:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "N(divV0)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ``rot``" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "rotV = dtutools.rot(V)\n", + "rotV" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtutools.rot(V2, var=[u,v,w])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Evalueret i bestemte punkter," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "rotV0 = rotV.subs([(x,1),(y,2),(z,3)])\n", + "rotV0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "som numerisk evauleres til:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "N(rotV0)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "language": "python", + "name": "mat1-pilot" + }, + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-F-Uge-7-StoreDag.ipynb b/Demos/Demo-F-Uge-7-StoreDag.ipynb new file mode 100644 index 0000000..747f15a --- /dev/null +++ b/Demos/Demo-F-Uge-7-StoreDag.ipynb @@ -0,0 +1,377 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tangielt kurveintegral\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "from dtumathtools import *\n", + "init_printing()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tangielt kurveintegral i rummet\n", + "Vi betragter vektorfeltet \n", + "$$\n", + "V(x,y,z) = \\begin{bmatrix} -y \\\\ x \\\\ 2z \\end{bmatrix}\n", + "$$\n", + "samt to kurver $K_1$ og $K_2$ med parameterfremstillingerne\n", + "$$\n", + "r_1(u) = \\begin{bmatrix} \\cos(u) \\\\ \\sin(u) \\\\ \\frac{u}{2} \\end{bmatrix}\n", + "$$\n", + "$$\n", + "r_2(u) = \\begin{bmatrix} 1 \\\\ 0 \\\\ \\frac{u}{2} \\end{bmatrix},\n", + "$$\n", + "hvor $u \\in [0,4\\pi]$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x,y,z,u = symbols(\"x y z u\",real=True)\n", + "r1 = Matrix([cos(u),sin(u),u/2])\n", + "r2 = Matrix([1,0,u/2])\n", + "V = Matrix([-y,x,2*z])\n", + "u_range = (u,0,4*pi)\n", + "\n", + "K1 = dtuplot.plot3d_parametric_line(*r1,u_range,show=False,rendering_kw={\"color\":\"red\"})\n", + "K2 = dtuplot.plot3d_parametric_line(*r2,u_range,show=False,rendering_kw={\"color\":\"blue\"})\n", + "felt = dtuplot.plot_vector(V,(x,-1,1),(y,-1,1),(z,0,6),show=False,quiver_kw={\"alpha\":0.5,\"length\":0.1,\"color\":\"black\"},n=5)\n", + "\n", + "combined = K1 + K2 + felt\n", + "combined.legend = False\n", + "combined.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi vil udrenge det tangentielle kurveintegral af $V$ langs hver af de to kurver fra punktet $a = (1,0,0)$ til $b = (1,0,2\\pi)$. Dette svarer for begge til $u \\in [0,4\\pi]$. Først finder vi tangentvektorene:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r1d = r1.diff(u)\n", + "r2d = r2.diff(u)\n", + "r1d,r2d" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Funktionerne der skal integreres er i følge sætningen:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrand1 = V.subs({x:r1[0],y:r1[1],z:r1[2]}).dot(r1d)\n", + "integrand2 = V.subs({x:r2[0],y:r2[1],z:r2[2]}).dot(r2d)\n", + "integrand1.simplify(),integrand2.simplify()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Det tangentielle integrale af $f$ langs kurven $K_1$ er da**\n", + "$$\n", + "\\int_{K_1} V \\cdot e \\,\\mathrm{d}\\mu = \\int_0^{4\\pi} \\frac{u}{2} + 1 \\,\\mathrm{d}u\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrate(integrand1,(u,0,4*pi))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Det tangentielle integrale af $f$ langs kurven $K_2$ er da**\n", + "$$\n", + "\\int_{K_2} V \\cdot e \\,\\mathrm{d}\\mu = \\int_0^{4\\pi} \\frac{u}{2} \\,\\mathrm{d}u\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrate(integrand2,(u,0,4*pi))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Perspektivering: \n", + "Hvis vi opfatter $V$ som et kraft-vektorfelt , er det arbejde $V$ bidrager med når partiklen flyttes langs den lodrette linje, $4\\pi$ mindre end når partiklen flyttes langs spiralkurven. Arbejdets størrelse er altså i dette eksempel afhængig af transportvejen. $V$ kan derfor ikke være et gradient-vektorfelt.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Søgning efter stamfunktion med trappelinjenmetoden. Teori\n", + "En stamfunktion til et glat vektorfelt $V$ kan, hvis en stamfunktion findes, bestemmes ved det tangentielle kurveintegral af $V$ langs en vilkårlig kurve fra Origo til et vilkårligt fast punkt $P = (x, y, z)$. De nemmeste udregninger får man ved som kurve at benytte trappelinjen fra Origo til $P$. \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "u_range = (u,0,1)\n", + "r1 = dtuplot.plot3d_parametric_line(u,0,0,u_range,show=False,rendering_kw={\"color\":\"red\"})\n", + "r2 = dtuplot.plot3d_parametric_line(1,u,0,u_range,show=False,rendering_kw={\"color\":\"red\"})\n", + "r3 = dtuplot.plot3d_parametric_line(1,1,u,u_range,show=False,rendering_kw={\"color\":\"red\"})\n", + "xyz = dtuplot.scatter(Matrix([1,1,1]),show=False,rendering_kw={\"color\":\"black\"})\n", + "combined = r1 + r2 + r3 + xyz\n", + "combined.legend = False\n", + "combined.camera = {\"azim\":37,\"elev\":16}\n", + "\n", + "combined.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vist på plottet ovenfor er de tre trappelinjer, som metoden består af. Vi vil benytte følgende parametrisering af linjerne:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r1 = Matrix([u,0,0])\n", + "r2 = Matrix([x,u,0])\n", + "r3 = Matrix([x,y,u])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Her har vi hhv. $u \\in [0,x]$, $u \\in [0,y]$ og $u \\in [0,z]$. \n", + "En fordel ved denne metode er, at de tre tangentvektorer er meget simple." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r1d = r1.diff(u)\n", + "r2d = r2.diff(u)\n", + "r3d = r3.diff(u)\n", + "r1d,r2d,r3d" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Betragt nu et vilkårligt glat vektorfelt\n", + "$$\n", + "V(x,y,z) = \\begin{bmatrix} V_1(x,y,z) \\\\ V_2(x,y,z) \\\\ V_3(x,y,z) \\end{bmatrix}\n", + "$$\n", + "Det tangentielle kurveintegral af $V$ langs trappelinjen består af summen af det tangentielle kurveintegral af V langs hver af de tre linjestykker som trappelinjen består af. \n", + "Vi betragter de tre integrander, der indgår i tre integraler:\n", + "$$\n", + "V(r_1(u)) \\cdot r_1'(u) = V_1(u,0,0)\n", + "$$\n", + "$$\n", + "V(r_2(u)) \\cdot r_2'(u) = V_1(x,u,0)\n", + "$$\n", + "$$\n", + "V(r_3(u)) \\cdot r_3'(u) = V_1(x,y,u)\n", + "$$\n", + "\n", + "Vi har derfor følgende **formel for det tangentielle kurveintegral af $V$ langs trappelinjen**\n", + "$$\n", + "\\int_T V \\cdot e \\, \\mathrm{d}\\mu = \\int_0^x V_1(u,0,0) \\,\\mathrm{d}u + \\int_0^y V_2(x,u,0) \\,\\mathrm{d}u +\\int_0^z V_3(x,y,u) \\,\\mathrm{d}u\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Søgning efter stamfunktion med trappelinjenmetoden. Eksempel\n", + "\n", + "Vi skal undersøge om det følgende vektorfelt $V$ er et gradientvektorfelt\n", + "$$\n", + "V(x,y,z) = \\begin{bmatrix} y^2 + z \\\\ 2yz^2 + 2yx \\\\ 2y^2z + x \\end{bmatrix}\n", + "$$\n", + "Vi bestemmer det tangentielle kurveintegral af $V$ langs trappelinjen ved hjælp af formlen:\n", + "$$\n", + "\\int_T V \\cdot e \\, \\mathrm{d}\\mu = \\int_0^x V_1(u,0,0) \\,\\mathrm{d}u + \\int_0^y V_2(x,u,0) \\,\\mathrm{d}u +\\int_0^z V_3(x,y,u) \\,\\mathrm{d}u\n", + "$$\n", + "Vi finder de tre integrander:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "V = Matrix([y ** 2 + z, 2*y*z**2 + 2*y*x,2*y**2*z+x])\n", + "integrand1 = V[0].subs({x:u,y:0,z:0})\n", + "integrand2 = V[1].subs({y:u,z:0})\n", + "integrand3 = V[2].subs({z:u})\n", + "\n", + "integrand1,integrand2,integrand3\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nu kan vi finde det tangentielle kurveintegral af $V$ langs trappelinjen er dermed:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "F = integrate(integrand1,(u,0,x)) + integrate(integrand2,(u,0,y)) + integrate(integrand3,(u,0,z))\n", + "F" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hvis vi anser kurveintegralet som en funktion $F$ af $(x,y,z)$, kan vi nu teste om $F$ virkelig *er* en stamfunktion til $V$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "V_F = gradient(F)\n", + "V_F, Eq(V_F,V)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Da $V$ er identisk med gradienten af $F$, er $F$ en stamfunktion til $V$! Det betyder at det tangentielle kurveintegral af $V$ langs en vilkårlig *lukket* kurve skal give 0. Lad os tjekke det vi på følgende knude:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "t = symbols(\"t\")\n", + "knude = Matrix([-10*cos(t)-2*cos(5*t)+15*sin(2*t),-15*cos(2*t)+10*sin(t)-2*sin(5*t),10*cos(3*t)]) * S(1)/10\n", + "knude" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtuplot.plot3d_parametric_line(*knude,(t,-pi,pi),rendering_kw={\"color\":\"blue\"},legend=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "## OBS -- Dette integrale tager meget lant tid for sympy. Kan nemt tage mere end et minut, så vær tålmodig\n", + "integrate(V.subs({x:knude[0],y:knude[1],z:knude[2]}).dot(knude.diff(t)),(t,-pi,pi))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Det arbejde som kraftfeltet $V$ bidrager med når partiklen kører en tur rundt i knuden er altså 0.\n", + "Ganske som forventet, da V er et gradientvektorfelt." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "language": "python", + "name": "mat1-pilot" + }, + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-F-Uge-8-StoreDag.ipynb b/Demos/Demo-F-Uge-8-StoreDag.ipynb new file mode 100644 index 0000000..01bbd52 --- /dev/null +++ b/Demos/Demo-F-Uge-8-StoreDag.ipynb @@ -0,0 +1,668 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Flux og Gauss' sætning\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "from dtumathtools import *\n", + "init_printing()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Flux gennem flader og en lukket flade" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Der er givet et vektorfelt ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x,y,z = symbols('x y z')\n", + "V = Matrix([x,y,2])\n", + "V" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi betragter den del af standardparaboloiden $F_{parab}$, der ligger under planen $z=1$. Denne kan parametriseres ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "u,v = symbols('u v')\n", + "r = Matrix([u*cos(v), u*sin(v), u**2])\n", + "r" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "hvor $u\\in [0,1]$ og $v\\in [-\\pi,\\pi]$. Vektorfeltet og fladen illustreres ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p_parab = dtuplot.plot3d_parametric_surface(*r, (u,0,1), (v,-pi,pi), use_cm=False, camera={\"elev\":25,\"azim\":-55}, show=False)\n", + "p_felt = dtuplot.plot_vector(V, (x,-1,1), (y,-1,1), (z,0,1.2), n=4, use_cm=False, quiver_kw={\"alpha\":0.5, \"length\":0.1, \"color\":\"red\"}, show=False)\n", + "\n", + "(p_parab + p_felt).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan nøjes med at plotte vektorfeltet på selve fladen:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Kommer vektorer fra alle hjørner. Der kommer for mange \n", + "# vektorer hvis \"p_parab\" bruges, så her sættes n ned\n", + "dummy_surface = dtuplot.plot3d_parametric_surface(*r, (u,0,1), (v,-pi,pi), n=8, show=False)\n", + "p_felt2 = dtuplot.plot_vector(V, (x,-1,1), (y,-1,1), (z,0,1), slice=dummy_surface[0], use_cm=False, quiver_kw={\"alpha\":0.5, \"length\":0.1, \"color\":\"red\"}, show=False)\n", + "# bedre kamera vinkel til at se vektorerne her\n", + "p_parab.camera = {\"elev\":60,\"azim\":-50}\n", + "\n", + "(p_parab + p_felt2).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Beregning af flux \"ned\" gennem paraboloiden $F_{parab}$\n", + "\n", + "Det ligner tydeligvis, at der er (positiv) flux op gennem fladen. Vi regner derfor med at finde at fluxen ned gennem er negativ. Vi starter med at finde normalvektoren til parabloiden givet ved vores valgte parametrisering:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "N_parab = r.diff(u).cross(r.diff(v))\n", + "simplify(N_parab)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Læg her mærke til, at normalvektor $n$ peger i den forkerte retning (*ind imod* z-aksen og derfor med positiv $z$-koordinat) i forhold til at vi ønsker fluxen ned gennem fladen. Vi skal altså huske at skifte fortegn på normalvektoren $N_{parab}$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "N_parab = -simplify(N_parab)\n", + "N_parab" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Længden er normalvektoren skal ikke bruges, men vi bemærker at den ikke er konstant, men derimod givet ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "N_parab.norm().simplify()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi finder nu integranten:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrand = N_parab.dot(V.subs({x:r[0],y:r[1],z:r[2]}))\n", + "simplify(integrand)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hvormed fluxen udregnes ved\n", + "\n", + "\\begin{equation}\n", + "Flux(V, F_{parab}) = \\int_0^1\\int_{-\\pi}^\\pi V(r(u,v))\\cdot N_{parab}\\,\\mathrm{d}u\\,\\mathrm{d}v\n", + "\\end{equation}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrate(integrand, (u,0,1), (v,-pi,pi))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Den ønskede flux er altså $-\\pi$!" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Beregning af fluxen gennem parabloidens \"låg\" $F_{låg}$ i $z$-aksens (positive) retning " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "r2 = Matrix([u*cos(v), u*sin(v), 1])\n", + "n2 = r2.diff(u).cross(r2.diff(v))\n", + "simplify(n2)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Retningen på normalvektoren passer den ønskede retning gennem fladen $F_{låg}$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrand2 = n2.dot(V.subs({x:r2[0],y:r2[1],z:r2[2]}))\n", + "integrate(integrand2, (u,0,1), (v,-pi,pi))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Fluxen gennem låget er $Flux(V,F_{låg}) = 2\\pi$." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fluxen gennem den lukkede flade med parabloide og låg $F_{lukket} = F_{parab} \\cup F_{låg}$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p_låg = dtuplot.plot3d_parametric_surface(*r2, (u,0,1), (v,-pi,pi), use_cm=False, n1=4, n2=16, camera={\"elev\":25,\"azim\":-55}, show=False)\n", + "p_feltlåg = dtuplot.plot_vector(V, (x,-1,1), (y,-1,1), (z,0,1), slice=p_låg[0], use_cm=False, quiver_kw={\"alpha\":0.5, \"length\":0.1, \"color\":\"red\"}, show=False)\n", + "p_parab.camera = {\"elev\":15,\"azim\":-60}\n", + "\n", + "(p_parab + p_felt2 + p_låg + p_feltlåg).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi behøver dog ikke at regne yderligere! Vi har nemlig fluxen gennem alle fladerne, hvorved den samlede flux gennem den lukkede flade er $Flux(V,F_{lukket})=-\\pi+2\\pi=\\pi$." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Et eksempel med Gauss-sætningen" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Givet vektorfeltet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "V = Matrix([-x+cos(z), -y*x, 3*z+exp(y)])\n", + "V" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Samt den rummelige mængde $\\Omega$ bestemt ved \n", + "$$\n", + "\\bigl\\{(x,y,z) \\in \\mathbb{R}^3 : x\\in[0,3], \\, y\\in[0,2], \\,z\\in[0,y^2] \\bigr\\}\n", + "$$ \n", + "Her er mængden illustreret:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = symbols('a')\n", + "# Da man ikke kan plotte et 3D volumen (nemt), plotter vi overfladerne,\n", + "p = dtuplot.plot3d_parametric_surface(x,y,y**2, (x,0,3), (y,0,2), {\"color\":\"royalblue\"}, use_cm=False, aspect=\"equal\", show=False)\n", + "p.extend(dtuplot.plot3d_parametric_surface(0,y,a*y**2, (a,0,1), (y,0,2), {\"color\":\"royalblue\", \"alpha\":0.5}, use_cm=False, aspect=\"equal\", show=False))\n", + "p.extend(dtuplot.plot3d_parametric_surface(3,y,a*y**2, (a,0,1), (y,0,2), {\"color\":\"royalblue\", \"alpha\":0.5}, use_cm=False, aspect=\"equal\", show=False))\n", + "p.extend(dtuplot.plot3d_parametric_surface(x,2,a*4, (x,0,3), (a,0,1), {\"color\":\"royalblue\", \"alpha\":0.5}, use_cm=False, aspect=\"equal\", show=False))\n", + "p.extend(dtuplot.plot3d_parametric_surface(x,y,0, (x,0,3), (y,0,2), {\"color\":\"royalblue\", \"alpha\":0.5}, use_cm=False, aspect=\"equal\", show=False))\n", + "p_felt = dtuplot.plot_vector(V, (x,0,3), (y,0,2), (z,0,4), n=4, use_cm=False, quiver_kw={\"alpha\":0.5, \"length\":0.05, \"color\":\"red\"}, show=False)\n", + "\n", + "(p + p_felt).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi vil nu bestemme fluxen af vektorfeltet $V$ ud gennem den lukkede overflade af $\\Omega$ ved brug af gauss sætning!\n", + "\n", + "Først finder vi parameterfremstillingen for det massive volumen," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "u,v,w = symbols('u v w')\n", + "r = Matrix([u,v,w*v**2])\n", + "r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "M = Matrix.hstack(r.diff(u), r.diff(v), r.diff(w))\n", + "M, det(M)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan tage determinanten, da\n", + "$$\n", + "(r_u'(u,v,w)\\times r_v'(u,v,w))\\cdot r_w'(u,v,w)=\\det\\begin{bmatrix}|&|&|\\\\r_u'(u,v,w)&r_v'(u,v,w)&r_w'(u,v,w)\\\\|&|&|\\end{bmatrix}.\n", + "$$\n", + "\n", + "Vi skal dog stadig tage absolut-værdien (se Definition 25.19). Dog kan man som regel få flottere udtryk at lade være med at tage absolutværdien, hvis man kan garantere at determinanten altid er positiv. Det er den i dette tilfælde, da $v>0$, så" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "jacobi = M.det()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Divergensen bliver nu" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "divV = dtutools.div(V)\n", + "divV" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Divergensen begrænset til det parameteriserede område fåes altså til," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "divV_r = divV.subs({x:r[0], y:r[1], z:r[2]})\n", + "divV_r" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Da" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrate(divV_r*jacobi, (u,0,3), (v,0,2), (w,0,1))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "får af Gauss' sætning nu:\n", + "\n", + "\\begin{equation}\n", + "\\int_{\\delta\\Omega}V\\cdot n\\,\\mathrm{d}\\mu=\\int_0^1\\int_0^2\\int_0^3(2-u)\\cdot v^2\\,\\mathrm{d}u\\,\\mathrm{d}v\\,\\mathrm{d}w = 4\n", + "\\end{equation}" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I dette eksempel er det særligt oplagt at benytte Gauss' sætning, da vi både slipper for at udregne fluxen gennem $5$ sideflader, hvorefter vi vil skulle ligge delresultaterne sammen, og da divergensen er matematisk simpel i forhold til sit vektorfelt. Dette skal dog vurderes hver gang en ny opgave stilles!" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Flux gennem et stykke af en kugleflade\n", + "\n", + "Der er givet et vektorfelt," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x,y,z = symbols('x y z')\n", + "V = Matrix([-y+x,x,z])\n", + "V" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "og et udsnit af en kegleflade," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "u,v = symbols('u v')\n", + "radius = 2\n", + "r = radius*Matrix([sin(u)*cos(v), sin(u)*sin(v), cos(u)])\n", + "r" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "med $u\\in[\\pi/6,\\pi/2]$ og $v\\in[0,\\pi]$," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p_surface = dtuplot.plot3d_spherical(radius, (u,pi/6, pi/2), (v,0,pi),aspect=\"equal\",camera={\"elev\":25,\"azim\":55}, show=False)\n", + "dummy_surface = dtuplot.plot3d_spherical(radius, (u,pi/6, pi/2), (v,0,pi),show=False, n=8)\n", + "p_felt = dtuplot.plot_vector(V, (x,-1,1), (y,-1,1), (z,0,1), slice=dummy_surface[0], use_cm=False, quiver_kw={\"alpha\":0.5, \"length\":0.2, \"color\":\"red\"}, show=False)\n", + "\n", + "(p_surface + p_felt).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Med fluxen udregnet til," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "N = r.diff(u).cross(r.diff(v))\n", + "integrand = N.dot(V.subs({x:r[0],y:r[1],z:r[2]}))\n", + "integrate(integrand, (u,pi/6, pi/2), (v,0,pi))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Flux gennem et stykke af en kugleflade med Gauss\n", + "\n", + "Vi sammenligner resultatet fra fluxen udregnet med Gauss' sætning gennem en halvkugle med radius $a$ ($u\\in[0,a]$, $v\\in[0,\\pi/2]$ og $w\\in[-\\pi,\\pi]$), med fluxen gennem dens to overflader. Det skulle meget gerne være det samme!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "V = Matrix([8*x, 8, 4*z**3])\n", + "r = u*Matrix([sin(v)*cos(w), sin(v)*sin(w), cos(v)])\n", + "V, r" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Først ved Gauss' sætning," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "M = Matrix.hstack(r.diff(u), r.diff(v), r.diff(w))\n", + "# determinanten er positiv. Eneste led der ikke er \n", + "# kvadreret er sin(v), som er positiv indenfor v's grænser\n", + "jacobi = M.det()\n", + "divV = dtutools.div(V,[x,y,z])\n", + "divV_r = divV.subs({x:r[0], y:r[1], z:r[2]})\n", + "integrate(divV_r*jacobi, (u,0,a), (v,0,pi/2), (w,-pi,pi))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Og så gennem de to flader," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Første flade tilsvarer at fastsætte u til radius\n", + "r1 = r.subs(u,a)\n", + "n1 = r1.diff(v).cross(r1.diff(w)) # har tjekket at den pejer udad\n", + "integrand1 = n1.dot(V.subs({x:r1[0],y:r1[1],z:r1[2]}))\n", + "flux1 = integrate(integrand1, (v,0,pi/2), (w,-pi,pi))\n", + "# Anden flade tilsvarer at fastsætte v til pi/2\n", + "# Tilbageværende bliver skiven med radius a\n", + "r2 = r.subs(v,pi/2)\n", + "n2 = -r2.diff(u).cross(r2.diff(w)) # skal være negativ før at den pejer udad\n", + "integrand2 = n2.dot(V.subs({x:r2[0],y:r2[1],z:r2[2]}))\n", + "flux2 = integrate(integrand2, (u,0,a), (w,-pi,pi))\n", + "flux1+flux2" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Som forventet!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Demo-F-Uge-9-StoreDag.ipynb b/Demos/Demo-F-Uge-9-StoreDag.ipynb new file mode 100644 index 0000000..a9b1163 --- /dev/null +++ b/Demos/Demo-F-Uge-9-StoreDag.ipynb @@ -0,0 +1,430 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Stokes' sætning\n", + "\n", + "Demo af Christian Mikkelstrup og Hans Henrik Hermansen" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import *\n", + "from dtumathtools import *\n", + "init_printing()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Eksempel 1\n", + "\n", + "Vi får givet et vektorfelt," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x,y,z = symbols('x y z')\n", + "V = Matrix([3*z, 5*x, -2*y])\n", + "V" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "samt den lukkede kurve $s$ givet ved:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "u = symbols('u')\n", + "s = Matrix([cos(u),sin(u), sin(u)])\n", + "s" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "hvor $u\\in[0,2\\pi]$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p_kurve = dtuplot.plot3d_parametric_line(*s,(u,0,2*pi),{\"color\":\"orange\", \"linewidth\":5}, zlim=(-1.1,1.1),use_cm=False, aspect=\"equal\", show=False)\n", + "p_felt = dtuplot.plot_vector(V,(x,-1,1),(y,-1,1),(z,-1,1),n=4,use_cm=False,quiver_kw={\"alpha\":0.5, \"length\":0.05, \"color\":\"red\"}, show=False)\n", + "\n", + "(p_kurve + p_felt).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi vil nu udregne det tangentielle kurveintegral (cirkulationen) ad V langs kurven!\n", + "\n", + "### Metode 1: Sætning for tangentielt kurveintegral" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ds = s.diff(u)\n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrand = ds.dot(V.subs({x:s[0],y:s[1],z:s[2]}))\n", + "integrate(integrand, (u,0,2*pi))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Metode 2: Stokes' sætning, som rotationens flux gemmen den udspændte flade" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "u,v = symbols('u v')\n", + "r = Matrix([u*cos(v),u*sin(v), u*sin(v)])\n", + "r" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hvor $u\\in[0,1]$ og $v\\in[0,2\\pi]$. Rotationen fåes nu ved" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dtutools.rot(V)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Rotationen er konstant! Dette fremgår også af følgende plot, hvor også den udfyldte flade indgår," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p_flade = dtuplot.plot3d_parametric_surface(*r,(u,0,1),(v,0,2*pi),use_cm=False,show=False)\n", + "p_felt_rot = dtuplot.plot_vector(dtutools.rot(V),(x,-1,1),(y,-1,1),(z,-1,1),n=4,use_cm=False,quiver_kw={\"alpha\":0.5, \"length\":0.05, \"color\":\"red\"}, show=False)\n", + "\n", + "(p_kurve + p_flade + p_felt_rot).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Den normalvektor, som genereres af den valgte parameterfremstilling for fladen er," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "N = r.diff(u).cross(r.diff(v))\n", + "simplify(N)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi ligger nu mærke til i hvilken retning $N$ peger, og benytter det til at fastlægge omløbsretningen ved brug af højrekonventionen. Det ses også tydeligt når det plottes, her med $u=1$ og $v=0$ for $n$, samt $u=0$ for tangentvektoren, $r'(u)$," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p_normalvektor = dtuplot.quiver(s.subs(u,0), N.subs({u:1, v:0}),show=False)\n", + "p_omloebs = dtuplot.quiver(s.subs(u,0), ds.subs(u,0),show=False)\n", + "p_kurve.camera = {\"elev\":5, \"azim\":-35}\n", + "\n", + "(p_kurve + p_flade + p_normalvektor + p_omloebs).show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan se, at hvis vi står for enden af normal-vektoren, gennemløbes kurven i positiv omløbsretning (mod uret). Dermed er højrekonventionen opfyldt, og vi får via Stokes' sætning,\n", + "\n", + "\\begin{equation}\n", + "\\int_K V\\cdot e \\,\\mathrm{d}\\mu=\\int_F rot\\,V\\cdot n\\,\\mathrm{d}\\mu=\\int_0^1\\int_0^{2\\pi}rot\\,V(r(u,v))\\cdot N \\,\\mathrm{d}v\\,\\mathrm{d}u,\n", + "\\end{equation}\n", + "\n", + "som i dette tilfælde er særligt speciel, da rotationen er konstant, og derfor meget simplere end ovenstående metode," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrand = N.dot(dtutools.rot(V))\n", + "simplify(integrand)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi integrerer nu for at få resultatet," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrate(integrand, (v,0,2*pi), (u,0,1))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi har verificeret at Stokes' sætning gælder, i hvert fald på dette eksempel!" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Eksempel 2\n", + "\n", + "Vi får givet et vektorfelt og en parameterflade," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x,y,z,u,v = symbols('x y z u v')\n", + "\n", + "V = Matrix([y*x, y*z, x*z])\n", + "r = Matrix([cos(v)*(1+u**2), sin(v)*(1+u**2), sin(u)])\n", + "V,r" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "samt grænserne $u\\in[-\\pi/2,\\pi/2]$ og $v\\in[-\\pi,\\pi/2]$. Her illustreret både randen og fladen sammen med vektorfeltet," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p_flade = dtuplot.plot3d_parametric_surface(*r,(u,-pi/2,pi/2),(v,-pi,pi/2), use_cm=False,aspect=\"equal\", camera={\"elev\":30, \"azim\":-80}, show=False)\n", + "dummy_surface = dtuplot.plot3d_parametric_surface(*r,(u,-pi/2,pi/2),(v,-pi,pi/2), n=10, show=False)\n", + "p_felt_flade = dtuplot.plot_vector(V,(x,-1,1),(y,-1,1),(z,-1,1),slice=dummy_surface[0],quiver_kw={\"alpha\":0.5, \"length\":0.2, \"color\":\"red\"}, use_cm=False, show=False)\n", + "# Vi vil gerne kende retningen af normalvektoren, så vi \n", + "# sikrer os at vi gennemløber randen i den rigtige retning\n", + "N = r.diff(u).cross(r.diff(v))\n", + "# vektor dobbelt så lang, så den kan ses fra denne vinkel\n", + "p_normalvektor = dtuplot.quiver(r.subs({u:0,v:-pi/4}), 2*N.subs({u:0,v:-pi/4}),{\"color\":\"black\"},show=False)\n", + "\n", + "combined_flade = p_flade + p_felt_flade + p_normalvektor\n", + "combined_flade.title = \"Fladen og feltet\"\n", + "\n", + "# combined_flade.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "s1 = r.subs(u,-pi/2)\n", + "s2 = r.subs(u,pi/2)\n", + "s3 = r.subs(v,-pi)\n", + "s4 = r.subs(v,pi/2)\n", + "ds1 = s1.diff(v)\n", + "ds2 = s2.diff(v)\n", + "ds3 = s3.diff(u)\n", + "ds4 = s4.diff(u)\n", + "p_rand = dtuplot.plot3d_parametric_line(*s1,(v,-pi,pi/2),{\"color\":\"orange\", \"linewidth\":5}, use_cm=False, aspect=\"equal\", camera={\"elev\":30, \"azim\":-80}, show=False)\n", + "p_rand.extend(dtuplot.plot3d_parametric_line(*s2,(v,-pi,pi/2),{\"color\":\"orange\", \"linewidth\":5}, use_cm=False, show=False))\n", + "p_rand.extend(dtuplot.plot3d_parametric_line(*s3,(u,-pi/2,pi/2),{\"color\":\"orange\", \"linewidth\":5}, use_cm=False, show=False))\n", + "p_rand.extend(dtuplot.plot3d_parametric_line(*s4,(u,-pi/2,pi/2),{\"color\":\"orange\", \"linewidth\":5}, use_cm=False, show=False))\n", + "p_flade_mesh = dtuplot.plot3d_parametric_surface(*r,(u,-pi/2,pi/2),(v,-pi,pi/2), rendering_kw={\"alpha\":0}, wf_rendering_kw={\"alpha\":0.4}, wireframe=True, show=False)\n", + "p_felt = dtuplot.plot_vector(V,(x,-3,3),(y,-3,3),(z,-1,1),quiver_kw={\"alpha\":0.5, \"length\":0.2, \"color\":\"red\"}, n1=5, n2=5, n3=2, show=False)\n", + "# for hver af de 4 felter vil vi også gerne have retningen af deres afledte\n", + "# dette skal bruges til at bestemme hvilken retning vi skal omløbe linjerne i\n", + "p_omloebs = dtuplot.quiver(s1.subs({u:-pi/2,v:-pi}), ds1.subs({u:-pi/2,v:-pi}),{\"color\":\"red\"},show=False)\n", + "p_omloebs.extend(dtuplot.quiver(s2.subs({u:-pi/2,v:-pi}), ds2.subs({u:-pi/2,v:-pi}),{\"color\":\"green\"},show=False))\n", + "p_omloebs.extend(dtuplot.quiver(s3.subs({u:-pi/2,v:-pi}), ds3.subs({u:-pi/2,v:-pi}),{\"color\":\"blue\"},show=False))\n", + "p_omloebs.extend(dtuplot.quiver(s4.subs({u:-pi/2,v:-pi}), ds4.subs({u:-pi/2,v:-pi}),{\"color\":\"purple\"},show=False))\n", + "\n", + "combined_rand = p_rand + p_flade_mesh + p_felt + p_omloebs\n", + "combined_rand.legend = False\n", + "combined_rand.title = \"Feltet på randen af fladen\"\n", + "\n", + "# combined_rand.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# To 3D plots ved siden af hinanden!\n", + "dtuplot.plotgrid(combined_rand, combined_flade, nr=1, nc=2)\n", + "# kommer to gange. Ikke meningen, men ikke vigtigt." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi starter med at udregne flow langs randen. Dog skal vi være meget påpasselige med hvilken retning vi gennemløber integralet i! Kig først på normalvektoren til fladen, som viser at $r_2$ og $r_3$ (grøn og blå) gennemløber i den korrekte retning. At de andre ikke gennemløber korrekt kan fixes ved at trække disse fra den endelige sum, i stedet for at ligge dem til," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "i1 = ds1.dot(V.subs({x:s1[0],y:s1[1],z:s1[2]}))\n", + "i2 = ds2.dot(V.subs({x:s2[0],y:s2[1],z:s2[2]}))\n", + "i3 = ds3.dot(V.subs({x:s3[0],y:s3[1],z:s3[2]}))\n", + "i4 = ds4.dot(V.subs({x:s4[0],y:s4[1],z:s4[2]}))\n", + "simplify(-integrate(i1, (v,-pi,pi/2)) + integrate(i2, (v,-pi,pi/2)) + integrate(i3, (u,-pi/2,pi/2)) - integrate(i4, (u,-pi/2,pi/2)))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Herefter udregnes fluxen ved brug af Stokes' sætning gennem fladen," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "integrand = N.dot(dtutools.rot(V).subs({x:r[0],y:r[1],z:r[2]}))\n", + "simplify(integrand)\n", + "integrate(integrand, (u,-pi/2,pi/2), (v,-pi,pi/2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "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.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0ba7452ab71c50cb9c4d5c0b7e104e5d7d626d39ddaf30384c30e1499f7a54e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/Intro-SymPy.ipynb b/Demos/Intro-SymPy.ipynb new file mode 100644 index 0000000..f66ec45 --- /dev/null +++ b/Demos/Intro-SymPy.ipynb @@ -0,0 +1,489 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ce87215d", + "metadata": {}, + "source": [ + "# Velkommen til SymPy!\n", + "\n", + "\n", + "SymPy er navnet på programmet som vil hjælpe udregninger og matematik i løbet af de næste semestre i 01005, Matematik 1. SymPy løber dette semester en prøveordning for retningerne Matematik og Teknologi samt Kunstig Intelligens og Data i stedet for programmet Maple. \n", + "\n", + "SymPy er en forkortelse for \"Symbolic Python\". Som navnet siger kører SymPy altså i programmeringssproget \"Python\". I Python findes pakken \"SymPy\" som tillader at programmeringssproget kan have symbolske variable og løse symbolske ligninger, som er krævet i løbet af kurset. Vi kommer også til at introducere andre pakker, hvis de bliver nødvendige. På trods af, at Python er et programmeringssprog, er det ikke tiltænkt at dette er en guide til programmering. Dog vil dette have de fleste, hvis ikke alle, værktøjer der er brug for til løsning og visualisering af matematiske problemstillinger i en både teoretisk, anvendt og ingeniørmæssig sammenhæng. \n", + "\n", + "SymPy importeres og gøres klar til at printe matematik ved de følgende to linjer, som vil befinde sig i toppen af alle følgende SymPy Demoer:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d7ea932", + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import * # Vi importerer hele SymPy pakken\n", + "init_printing() # Dette initialiserer pæn LaTeX output" + ] + }, + { + "cell_type": "markdown", + "id": "6a280c14", + "metadata": {}, + "source": [ + "## SymPy Demo\n", + "\n", + "I løbet af dette og næste semester vil der være SymPy guides i samme format som dette dokument, i Jupyter Notebooks, kaldes SymPy demoer. De vil vise eksempler på værktøjer fra SymPy som kan bruges til at løse ugens grupperegningsopgaver og hjælpe med at løse de matematiske problemstillinger der introduceres i forelæsningerne. Demoerne vil ofte præsentere typiske opgaver og kort beskrive løsningsmetoderne samt matematikken bag dem. Løsningerne til typiske opgaver kommer i form af både \"simuleret håndregning\", indbyggede funktioner, der direkte løser opgaven, samt funktioner der bygges i løbet af disse demoer. Værktøjerne præsenteret til, og bygget op indtil, ugens demo burde være nok software-mæssigt til at løse ugens opgaver." + ] + }, + { + "cell_type": "markdown", + "id": "f103d650", + "metadata": {}, + "source": [ + "## Symbolske og Numeriske variable\n", + "\n", + "Python (uden SymPy) er et programmeringssprog som regner numerisk. Dette betyder, at alle tal og variable skal repræsenteres ud fra endeligt mange 0'er og 1'er. Studiet af numerisk matematik i computere overlades til andre kurser, men det kan være rart at vide at Python nogle gange ikke gør som man havde forudset, med mindre man gør en aktiv handling.\n", + "\n", + "Eksempelvis kan vi alle blive enige om, at\n", + "\n", + "\\begin{equation}\n", + " 0.3-(0.2+0.1) = 0.\n", + "\\end{equation}\n", + "\n", + "Alligevel er Python ikke altid enig i dette" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a476e347", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "0.3-(0.2+0.1)" + ] + }, + { + "cell_type": "markdown", + "id": "228048b8", + "metadata": {}, + "source": [ + "Vi får ikke præcis $0.0$, og hvis vi spørger om det er lig med $0.0$ får vi" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "361d6356", + "metadata": {}, + "outputs": [], + "source": [ + "0 == 0.3-(0.2+0.1)" + ] + }, + { + "cell_type": "markdown", + "id": "14863992", + "metadata": {}, + "source": [ + "Vi skal altså passe på med altid at spørge om numeriske udtryk er lig med hinanden når vi regner med kommatal! \n", + "\n", + "Man løber dog ikke ind i lige så mange problemer, hvis man lader SymPy tage sig af matematikken! Hvis man om enten tælleren eller nævneren sætter \"$\\text{S(tal)}$\", eller benytter \"$\\text{Rational(tæller, nævner)}$\", regnes matematikken af SymPy (pakken til Python der regner symbolsk), som her giver det forventede svar:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "92279e64", + "metadata": {}, + "outputs": [], + "source": [ + "Rational(3,10)-(S(2)/10 + 1/S(10))" + ] + }, + { + "cell_type": "markdown", + "id": "b10d640b", + "metadata": {}, + "source": [ + "og" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a89a467c", + "metadata": {}, + "outputs": [], + "source": [ + "Rational(3,10)-(S(2)/10 + S(1)/10) == 0" + ] + }, + { + "cell_type": "markdown", + "id": "25fc6f00", + "metadata": {}, + "source": [ + "Vi vil også meget gerne have mulighed for at løse ligninger. For eksempel,\n", + "\n", + "\\begin{equation}\n", + "3\\,x^2-x = 0.\n", + "\\end{equation}\n", + "\n", + "Ligninger som denne og meget mere kan løses ved brug af *symbolske variable* fra SymPy. En Python variabel kan laves symbolsk ved brug af kommandoen $\\text{Symbol()}$ eller $\\text{symbols()}$ der tager mindst ét argument, *'names'*. Man kan også give antagelser om variablen, blandt andet $x\\in \\mathbb{Z}$ ($\\text{integer=True}$), $x\\in \\mathbb{C}$ ($\\text{complex=True}$, dette er standard hvis intet skrives) eller $x\\in \\mathbb{R}$ ($\\text{complex=False}$ eller $\\text{real=True}$).\n", + "\n", + "Her gives kort et par eksempler på hvordan disse variable kan bruges:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ce41bb6a", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "x = symbols('x', complex=True)\n", + "3*x**2-x" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7a1c94bd", + "metadata": {}, + "outputs": [], + "source": [ + "l, p, t = symbols('lambda, phi, theta', real=True)\n", + "t**2 + sin(l)/tan(p)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e3e3f184", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "x_list = symbols('x0:3')\n", + "x_list" + ] + }, + { + "cell_type": "markdown", + "id": "953ce913", + "metadata": {}, + "source": [ + "Med symbolske udtryk kan vi også begynde at løse ligninger med $\\text{solve()}$ eller (hellere) $\\text{solveset()}$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bfb7fdf8", + "metadata": {}, + "outputs": [], + "source": [ + "solveset(3*x**2-x)" + ] + }, + { + "cell_type": "markdown", + "id": "4d167386", + "metadata": {}, + "source": [ + "Bemærk at $3x^2 - x$ er et udtryk og ikke en ligning man kan \"solve\". Kaldes solve og solveset med et udtryk, vil Python løse den ligning hvor udtrykkene sættes lig med $0$, dvs. vi løser her $3x^2-x=0$. Ligninger som fx $a=b$ kan i Python skrives som $\\text{Eq(a,b)}$. Dette er specielt nyttigt hvis højresiden ikke er nul. Fx:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf06c21a", + "metadata": {}, + "outputs": [], + "source": [ + "my_equality = Eq(3*x**2-x, p+27)\n", + "my_equality" + ] + }, + { + "cell_type": "markdown", + "id": "fed0e131", + "metadata": {}, + "source": [ + "Da ligningen har flere ubekendte (symboler), må vi fortælle med hensyn hvilke variable, Python skal løse ligningen:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "14790fd7", + "metadata": {}, + "outputs": [], + "source": [ + "solveset(my_equality, x)" + ] + }, + { + "cell_type": "markdown", + "id": "16507110", + "metadata": {}, + "source": [ + "## Funktioner og Plots\n", + "\n", + "SymPy har også et stort bibliotek inden for både funktioner og plots. Her vises kort et par eksempler på dette," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a0fa8ec1", + "metadata": {}, + "outputs": [], + "source": [ + "plot(x**2-x+3)" + ] + }, + { + "cell_type": "markdown", + "id": "91992231", + "metadata": {}, + "source": [ + "Eller hvis man vil bruge lidt mere tid på det, så det bliver flot:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "33e19fcc", + "metadata": {}, + "outputs": [], + "source": [ + "p = plot(x+3,-x**2+3,x**2+3*x+3, (x,-2,2), show=False)\n", + "p[0].line_color = 'red'\n", + "p[1].line_color = 'green'\n", + "p[2].line_color = 'blue'\n", + "p.xlabel = \"x-aksen\"\n", + "p.ylabel = \"y-aksen\"\n", + "p.title = \"Et meget flot plot\"\n", + "p[0].label = '$f_0(x)=x+3$'\n", + "p[1].label = '$f_1(x)=-x^2+3$'\n", + "p[2].label = '$f_2(x)=x^2+3x+3$'\n", + "p.legend = True\n", + "p.ylim = (0,8)\n", + "p.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5f1892be", + "metadata": {}, + "source": [ + "Dog netop plots kommer tilbage i stor stil i løbet af disse Demoer senere i løbet af mat 1." + ] + }, + { + "cell_type": "markdown", + "id": "5c2b9a7b", + "metadata": {}, + "source": [ + "## Ekstra noter\n", + "\n", + "Til sidst her gives et par ekstra fingerpeg til hvordan oplevelsen med SymPy bliver lettere og bedre.\n", + "\n", + "### Markdown og Code\n", + "\n", + "Som det allerede er vist her, findes to forskellige modes i en Jupyter Notebook, som man kan skrive i: \"Markdown\" og \"Code\". Når man befinder sig i et Code felt, arbejder man i Python. Man kan indsætte lige så mange linjer man vil i en boks. Hvis man til sidst i boksen skriver en linje med en variabel eller et udtryk, bliver dette printet lige under i pænt format," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9b8202c3", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "y = Symbol('y', complex=True)\n", + "sqrt(y**2+2)" + ] + }, + { + "cell_type": "markdown", + "id": "b313ab51", + "metadata": {}, + "source": [ + "og hvis man i sidste linje skriver flere ting adskildt af komma, bliver der printet flere ting pænt som ses her:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a23bc5a", + "metadata": {}, + "outputs": [], + "source": [ + "udtryk = sqrt(y**2+2)\n", + "udtryk, udtryk.subs({y:2/3}) <= 1.6" + ] + }, + { + "cell_type": "markdown", + "id": "6a9d6332", + "metadata": {}, + "source": [ + "Man kører en boks med enten $\\text{Ctrl+Enter}$ eller $\\text{Shift+Enter}$.\n", + "\n", + "Det er vigtigt at vide, at alle linjer der er blevet kørt er \"husket\" i alle bokse der køres efterfølgende. Dette er uanset hvilken rækkefølge man kører boksende i! Dette betyder, at man nogle gange hvis man kører tidligere bokse, ikke får det samme resultat som tidligere. Eksempelvis, " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b367a297", + "metadata": {}, + "outputs": [], + "source": [ + "y ** 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5327746b", + "metadata": {}, + "outputs": [], + "source": [ + "# Efter at have kørt denne boks, prøv at køre den tidligere boks igen\n", + "y = 2" + ] + }, + { + "cell_type": "markdown", + "id": "318b9c4c", + "metadata": {}, + "source": [ + "Til sidst er det værd at nævne, at ikke alle kommandoer man kører i Python virker hvis der ikke er en løsning, eller hvis man ikke bruger dem korrekt. Dette kan dog nogle gange være præcis hvad man ønsker at vise! Eksempelvis kan et symbol ikke transponeres," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6854d504", + "metadata": {}, + "outputs": [], + "source": [ + "y = Symbol('y')\n", + "y.Transpose()" + ] + }, + { + "cell_type": "markdown", + "id": "a558219d", + "metadata": {}, + "source": [ + "Hvis man gerne vil gøre dette uden der kommer en fejl, kan man lave en $\\text{try/catch}$ kommando i Python," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8a5d947a", + "metadata": {}, + "outputs": [], + "source": [ + "try:\n", + " y.Transpose()\n", + "except:\n", + " print(\"Symboler kan ikke transponeres!\")" + ] + }, + { + "cell_type": "markdown", + "id": "de82df4d", + "metadata": {}, + "source": [ + "### Gode fifs\n", + "\n", + "**Restart**: Hvis du vil have Python til at glemme alle gemte variable, fx at $y$ er tildelt værdien 2, skal du genstarte kernen (restart kernel) i \"main Notebook Editor toolbar\" i VS Code lige over editoren. \"Clear Outputs of All Cells\" i samme bar fjerner alle outputs, men glemmer ikke værdien af fx variable. \n", + "\n", + "**Shortcuts**: Hvis man bruger Visual Studio Code *skal* man kende til shortcuttet \"$\\text{Ctrl+Shift+P}$\" (\"⇧⌘P\" på mac). Dette åbner søgefunktionen efter kommandoer. Så hvis man gerne vil lave en ny celle, køre sit dokument, eller lave en ny fil, kan man søge efter kommandoen. Hvis man så tænker at man kommer til at bruge den fremover, kan mansuper hurtigt tilføje sit egen shortcut, så man selv kan huske det fremover.\n", + "\n", + "Shortcuts som vi har fundet ekstra brugbare i løbet af at lave disse Demoer er:\n", + "\n", + "- Lave nye bokse (*insert cell below*)\n", + "- Ændre en boks fra Code til Markdown (*change cell to code* og *change cell to markdown*)\n", + "- Genstarte notebook og kør alle bokse fra toppen og ned (*restart the kernel, then re-run the whole notebook*)\n", + "\n", + "**Latex**: I disse Jupyter Notebooks, vil der være eksempler på pæn matematik mellem tekstlinjer. Dette er $\\text{LaTeX}$ kode, og kan bruges til at opskrive flotte matematiske udtryk til opgaver og afleveringer. Hvis matematikken skal være *inline* med teksten, skal koden omringes af dollartegn (\\$ \\$), og hvis den skal skrives som ligning (centreret), kan man i en ny linje skrive \"\\\\ $\\text{\\\\begin\\{equation\\}}$\" før matematikken og \"\\\\ $\\text{\\\\end\\{equation\\}}$\" efter.\n", + "\n", + "**Funktioner**: Python er et stort værktøj, hvor kun en del af det er krævet for at komme igennem kurset. Dog kan store dele af Python gøre ting lettere, hvis man kender til dem. Et eksempel på dette er Python funktioner. Hvis en serie af steps skal laves for at løse en opgave, og den samme opgave gentager sig med forskellige tal, er det oplagt at lave en funktion i Python. Dette er også understøttet gennem SymPy, og eksempler herpå kommer også i løbet af disse Demoer. Altså, hvis der ikke allerede findes en funktion til at løse dit problem, kan du bygge din egen funktion!" + ] + }, + { + "cell_type": "markdown", + "id": "9a91c70b", + "metadata": {}, + "source": [ + "### Links\n", + "\n", + "Disse Demoer er sat sammen til at inkludere det vigtigste der er brug for i løbet af ugerne, samt hvilke værktøjer der er gode at have i mat 1. Hvis der står noget der er uklart, eller man vil vide endnu mere om funktionerne, henviser vi til dokumentationerne, hvor man kan søge efter funktionerne. De tre vigtigste links er:\n", + "\n", + "- Basis (variable, funktioner m.fl.): $\\text{https://docs.sympy.org/latest/modules/core.html}$\n", + "- Matricer: $\\text{https://docs.sympy.org/latest/modules/matrices/matrices.html}$\n", + "- Plotting: $\\text{https://docs.sympy.org/latest/modules/plotting.html}$" + ] + }, + { + "cell_type": "markdown", + "id": "b0d4913d", + "metadata": {}, + "source": [ + "## Sidste noter\n", + "\n", + "Vi har forsøgt vores allerbedste for at oplevelsen med SymPy bliver så god som overhovedet muligt i kurset 01005, matematik 1. Dog er det stadig en prøveordning, hvorfor vi stadig forsøger at forbedre både oplevelsen og mulighederne med SymPy. Derfor, hvis I finder fejl, bedre eksempler eller forbedringsforslag til disse demoer, tager vi imod forslag med åbne arme. Forslag er velkomne hos jeres nærmeste klasselærer eller pr. mail til $\\text{s194042@student.dtu.dk}$ eller $\\text{s194345@student.dtu.dk}$.\n", + "\n", + "Alt held og lykke med SymPy, og alt held og lykke med 01005, Matematik 1!" + ] + }, + { + "cell_type": "raw", + "id": "1fb34e5b", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "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.4" + }, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Demos/mit_plot.png b/Demos/mit_plot.png new file mode 100644 index 0000000000000000000000000000000000000000..a7835b5587a3fafb08f4a76f41d7beef976857f5 GIT binary patch literal 12741 zcmeAS@N?(olHy`uVBq!ia0y~yVBEmKz^K5%#=yXERYNV4fq}uY#5JNMI6tkVJh3R1 z!8fs_ASb^hCo@T*EVZaOGe6H*&s5J)M<Ju6q@dVJUq2VFKrg>2UH?Ynr@age44efX zk;M!Q+`=Ht$S`Y;1OtPik*AAeNX4ADcdKJUzV5RBaNgkX3Ey?fLKUor`b(b$8m?dY z#%lTOXPL^&*j6r0TA7)9H}aO}-AnoIv$p%_n%sGNYFkFww%kuq*91+u4{~d*;OuHx zp&{O0Syx{%LuMz(8J^8zb@$eb*PoeXdcG=R^9=s`TleXhC@Co@DFsQ2r<*&txP-{_ z7$_+Psj^833a%7l?&;_V>11?saanbQL0L&DG^s&QaH5vsfsPK3sS*h;E=#;fR9;@% zkZB^dCVv0D%-jCHzOL)z_C9#_tj#R<R><yqZM@O~Vq$D-!@6(Wh<I~nr?6Bn+y4Lm zs(Zg)Ul+?g*Dw9~x|L>0$;pC}k}uzweRwuIe^Ko2GShX%zYB|gf1EmXDr>J>vwYo; zgU{-uex<Klv4TTUQPIQGbLG`vPoF-0ab>0OzF)7j*~`N=-}={c|E*MR!_i~MoEBen zSbWi8`Q?SBudmIpC{+6N`Sa`8&+YPc4Q`7a!@{P;R{c30|Bop@KVQbSYRfJ84WB+0 z^~hR_1qKFM6hGs+SN-1h%gf8`mX?+re0<xy<+nxcud_9g@@>xB{AlmqucyzRUF%q# zq2tyg(OCTaoaOFbD{Wof)`JNRyLVfE`t)g4%=5R~@4NNO*<RS3?tgmItUlSbVcq8U zYlMx{&NST2$(!*0@XUQb9&u-EjpC8FyK{5x74OBo1`IFm@3${1Dw;5LYOAXEv<LD3 ze~Hhl{T7+NJ$2&5iH(iS?2CM7n`K;E6FK$ulP6CWtXRR(Z}&^X$;s)#<HyW<<N6mY zP}s2}<o~y+Q>R+4$~_vfEl0Abs7NP%x&QpKGVfJS-o5L4c6PS)?p~|k*Z2Qxy|y+w z`N9Inh}~tmOP_mtd42fz`+f4E7S5^jR=>Pa`D*3z3G?Uo=kNP@Y~ow%IX83MDl02{ zU$2SU%4M8>?#Q*Z(S`s1{A7D|rcSD~A++Yg_Kb^6&h30hw`5-a@OJzCMLTxvIQ6x- zs7OFomNz~=e#h?Jj~BMf9s2k8H{%_f-b?%I>lqwwZ_8bHG2_DpXa3OLZ@=HG=D)kE zw0Zh;@usFG0a@AJIdf#Zb$i{KC#(A>ottBMA;YBN^I3E4s}Z})bfdQAa56|3Brupr z@s_>26Z!Is)6vK4_y3dn`|E4-?Ag*`YokI}#(8>jw(-mNotta@`1}3(_KpWXpU-!X zh>*B*_pYFnRM+*mYTl(wmrlDLGN<X*o=Rh@k{1mA{{B2tCLHSi^S0zvpP6CE@bAZ2 zGc&VmpMEX%p1#Prov)y{*tw#@LQE%uVe-k8%6-1G&1M*<^DXn6%T-@rZ<2pcX8oQ| zr)29tFdR63oZZpUaoT$8T8{e9XU%`~|Np^nl6i@xv9YnEyZi9g?CUz`XP-^m^X*o4 z#<ew)d-m)BdHZO$`2CM2Z<cybH%L0dQBhU3sPgl(ioaj4D=JOBw)yzJ9}nB*FKo|` zH_5#v;yc^S_4>NlkMHaM|L*(!YO=qbV@8I?ojZ2~Bqck~obfqb{MGVm&BH^iM~)p^ z6uCJq<JK0<U*Fz#-`!mvy>@f*alVq5mss=i@?Kn8%3b#6M&Np@t3Mw!^9u+IH{ZAs zu_kWsu1lXq?O*fT|0!7dJj<#qCN}otjpY8jA48ry^V_z3e0)4wceZ`~zN=3gx`I!x z4qNN=`r6uuZ{PMVbZ&q2=xBG?`siIHno(Oa82S16Z9bh)wkUq)v-GX3MF9i9{U3up zd-hyd6KM>}1X>l^bz%0u-x!y?xWHJoSI)gpX63g3!OQ&;zrVXX!>-nfjaRCr-|p9n zWADQ!E}7WX**Q_sxh+E1+rvYEq3G!;Q9(gQ1y4^;C8Z>@*-OLM$6eZ*9e#6jdjFqq zxATQWMOF9h+gJ4Qk*ncMpG}pY(-;+ge|tN5&K#MO=g+S%``s<BKkfa#-+q2`tyHVO zznjV~UlYK_BcY(Aq&C^JsHkX(YqywD@iU*3Cr?gX9lkznRpH-Xr8l?d&u5r$cDA{< zpI_gUY12;i$y&2C%(1Nwb2;+q$Gz(JQ_s#eKfN+|`I9#{H&2=|LnCT!n2QS+7uS;b z{dJet$J=XaXb1>S{Pd}4rfv1MKYu=-pEPr(=4|u)X$ux8%rs8#TiU*}_<2`*dpjuP zHr4;Hvn+Wrq2%?ov!C{YtlN}&nx)~%lP4a2etjZhVo`CoSA}Zd+)=oAj#a7GzJI^6 zGjDEMy64}o*VBHjjovO6A0HpNqhO(oeO-**-!H)zv$lS^=q`Wt$G>~O?p-~$e*ZtM zsI_6sd}ph@eEIUzS@ZiIr>E(retB_mTB(qb(2>iRgYEwPNVcr|vqMEirDOj5`Kj_@ z={Ghc3W<rS-LL<@SH`X;!mU?I)pxepR;zz+HtPGRP5$xo=gHIh`*n`@%TIrNy#MsE zUg^~D@9tjx7WVPq*SELBzrDS!4vL4ky;Yvm^<t0Yn00qV$f_#^z5H?N%o!1eP3h<5 z1b0@(fRbh#zr3ENrskxH6BR!{KQF#FPXFc0mr6=S@9tQB{P1DIjT;f3-rkdQZ*M#K z_xt_)uluep^DFI>u~e$s8>bhyM?+Or_0jX^>egj%HbkZ0+LC!`d;Wc|^=r>=++6ds zh?9qBP2t=|X7*D%3LmeTc6PS8f7JH8+)5c?VdZ=G?g`1t>aJY5^3&sfd#}}DYoFXq zpTBj@=FH1#7qhlbnlM4(c%STK)9h;=2?-0XR!^8VO>N%1c}D5yWGsuGbbylIr!SZN zy(=nqh=_}KpE&#d*4?|Ypu}bW_se7%>#{SSBEzT7G)_Mi>~E{8q%^<w+srMwx33lX ztT-AgoRFEBDI_JOB`7F3Ep@xx3Ae?83?5NYv!4E(G)ah)i)+&VpY#6<3Qn}G{>H&@ z^30hv#rEv{av}_$e!t%zJ#A~=-Kb}0XNNz2o%jEPz{)?2!5@D-?zi7om3x%^@=W9O zCBe)6jB;)moIV&gxBPx>_^qwk>6JF+?_xk6n>{-_^4t0Pf59eFy-UM_f+pShxBJ4@ z?CVGF-i_UscQ<Qm&D~w4j~+ix-pW6(;t}WSQn|_}f}MSR>o)o`Tw3BO{PD||Ej4$g z_H387t=jVC&CSbMH<$U&c3FJUBP?uMM+XZ#do*iT$B7O><t&~JJv}^(3b(iAZr0J( z)t&m_LBi>e>Fa9)0|FEnv}yycr@XtflgYuz$VlgOpRBbS!;{_b_X$tj#U7EAw5X+} z<wUQv`I>E}85b00T9vNq=r}XaHaco+R_fMs({!WP)IG}zUT$@HneXJp!)=jr{<BOx z-TGuQx1PJO&{<VWYt^Of?BX{ee>O#hgoNbsZ{;;;KB%CosyZ!|TU>9-f&~hvAMdOE zeaiT}O>$`Zu^!2=_l`b3Jv|bJhqC5Qnj}<MUOxTFlN7<7KjX4Zq%3QHm29;Q*U;9U zeBgk?%`KUemrk2MfBv7}_y6yEoIQ0(pnu@)oyF>V_Us9Wi|e~|DTqhXh(*5UgX7fK z%a$%xR8U};YgM{QC;QS8P9-I!3Dc&9t<Tku*&*=q<x346oh>l}cD27uoSd9qedoRF zxIS*Lmag&avlSl>vR~YuA7At7r22)dtzqZa$L*EMzP83OEKF=&>~6NnCqrI7DlI73 zaMg6zgb4y297V;&7gvR@)~fdO_I55TH2n8_|Nq-rP41PImR??71s@-|dY{d^yDM_9 znTpDhS0dr1Vmc8G3!U4e<bMDB8M-?!DoTotUoK~B&VvJu0)k7HFF$<#Jpav`H(%V{ zz5S{czugaoeLo&`XT4swd^t12uP-l?BbQx&eQ|TTzlf-4<hI=Y+K11dw|{(m{P9G0 zxq}Z5HX9Z^aIpD$C3wg8d)2Go@-xgb%}z5F-dOwln}Gz6hrj>&>pmx^Oc9x5UoW?B z-@dTZ-rn91-@W5|@T~6T)z#Clt~^=y_t({(exY7oULQUlmw$Yi-+qfucW>{}21aI3 zE2g1=fx)4$(6FYaX4RU)<;lyFg4_!W4Q*^~SHE3qW>xm4L(O+qgj{<|%Y#F$+|!P~ zeECwsvS`WG>|bABx3{#goPG?l-J*~wE-o(Y_0%a-6qJ<@f7(&``PtQfKKHaNEhW=7 zOM)6>4YTK$Uc7iQVry3D)a5Z#R|T?1xVW%fTN}+j*RQ?$-Ol5$6jphK8ozW|a?be8 zxjB~2?((%F$;WyQ&ao^`Fp&80`~7}pBcn?TCu^_z<yc%;c<^z*eP6G%xst7|?DzZi z`=9RQl{QQG^yFkmfB*3Vjm)5`79{fR&CM{=FI9W5KJNM(cv)v{*K@O+8x7yy-VU$2 zcmMwWW52e}WW2Vg^0T#{;QqaNrKg|%Ul)1x>)vTv>q_sQoA*2E>#M6XtV*@E<=$?4 zzwb9+{+^F)({!W5p1QC`|6bR3Gso?CpX|grb7Edv^7He1|GoYF>D&J7;N@EJH6K~I zxVS!ix$GaUtFNzrd{^mfgW6vu4Cc+d7c5wCN~+wdjEjqF!PTs__h#STxnoDjt$y>o zJ1e%tg}#6JcKz<lh3RIq4b#p@oS9|1`ckoIBX7uG$$+V$tHTua_0PW&XBBJ=TYa>Z zTRg;g<?=xG8M}8^ueE<*RsODL&mNm4%a=#HB`#gM^v3pl`A3f)G5jf1xR=@F=;g)L z)!n_Z;$zZj#-axY8h_PEn?>&|QvFh83u;7wJjieJfq^06`@6dp4;tBZ>_0HP`l`;f z{oV8~!MNw==01G(tSxxCUu50s;$`RNS|?v$7aMlE?CmYqUbkkyxmE{{A7?*!@ZgV^ z%jd88_4nuV`R^md8NR){+im~%r9VU7IR;-(PsihZvbwKt6vy8wzhArK{l4FzQ1O{# zA-Fnh?JC0qdU1O?Cae1^>FDq<6#V&7_~iNX=wGW>%h^^vc-(K_wtc%f6EpMbnB~RK z&v|%xZL(6!`)|GJ)|Hi~*yU>)Zrq4CGsEz3R%K9-P}usoT+4a8%is5<o}PB~Y4m0f zU*Dt5{5AoPeeNGP;E<A@9<6I#@gZUE_Nyy{)&Kl>+&}HSB*Tx7$K}^vdwFp&d)@E1 z<}IzQH~*+>tNYD4@a^qwa5R7Z_;UGtx1^+`sg5gMdaJ~eVtM3jB=%N)J!E{|rdhuJ zk6=5${ISjF?YbvT67rd4!pU%9S84W+9XlS(&fn*lm#3!}zb__r?S~Hq875LHDk=)b z#=^7Bat}r4@4Y(VzMrc1G#y7DAD%WI$)uT)mGAd{S28sfoo$|f?BrzikN2wICq6#b zTe|M<w%llj1JmQ{I=jX77p+*q5f>L%@pkL=54W<{C*ItYYEkw^;?ku{A6_n>pY-g^ z%(B1tvL0Uzk3V{_nccAVSBZ>mmB{_N-@0*CFI9V_OivY^N<G#i8L_9r@ZZP&dIe== z=5BHQW7~3XXZ<;laebZayqZs*KJ#oOt;^mxR8?6W>zD6e9lk#5+Q#eqED9g7q@A17 zDPQ-4ak>BeWB&GkTWqVpMa=!SuB*MBeO~oDOBss-hTq@cyZiX?yxaf(U)BGGUsnV! zzOXGf+UDDh<Qv;^r8jNb^kM)1-}@tW6eybI-eO^xVUj5XN(tg|6^!nEG6%okuaD16 ziJxt?-P_;)IKTa$hK<R`qnh?S%0AS>X;JlMMXK22`oGuf6^)IB)6dUa`}zBh;^%%K z<4xBIOG<JszSwcz{=ba6-yDaU8k=u#ZU#TkJv+mYd4BCTNl>RYB_&0{&`{9R(=+Tf zsMBFl^n}B$U#_?I_cxG{)@5%FTv-`h`0C0^tK9snt3o+=d5>;LJgoKh@QM{0Ya%xv zTP9f5Ty$xxdHd=tu}5zUZs#m{^Cm~qFsbFoj~^YgXV2!5FmMP83R)BQ`P=P$?}CC2 zJ9g|iaiEcT_1e8TH;pncE^6JebEoJ1eYL5tudSV`ci?ulko(ccT-)R4hztIF9sgg; z&d%=BWq*6m$jF&{J{;l(wb*=Tn@ydl?0)LfQt!2DDQD(dhaWn0XiZj#>CDtuS5^v1 zNN7m)f>Nr^>FaAEm1B38O;z)q)v<p4`Y*4pdWWrv2z+cOVV)P$`#WsOyUhZwE}(|- z%X@owzxY~ZD8XY?_{e2-_m`(npBiOf)8XXc5b*c+2l+@RVuQn;J$tg&%$`17z5d_l z`9}{QcIIJgJ~PYIdtU9gn_kD~ul=oLZ5=(Y>XjxZC#T@vIQ{Q;iu-%y?e7`A-mE41 zK0YXD(w4ltQD3U|@<^F@_|36Mj9k8MvW3>Z=bggpUZBv~wF^Y?NSpca$=PH?9?vj2 zRr~#}dez=ItMYd`_v`=HF8#jNtTfLw^^^!FAK$vNZ880FwkcOu1Wr57Z~J9}PQ-=- zS#zyrt=0YKiOls=Pd_(jWtr^6*}{s;{N`$%on<O4FE8KO-96d-Ud7@|Dt)*6n^&pX z>c;JfXliagdiJbu8;_(?_VsmZzZn0$oxlI&WPdx&ef#!3diG2$F){JepU>x`)11S< zZm!yW=~7VUwKX$A#q_D?{PK1=rU%_$nkZ#;MlEVHFMAX5=hy4?ezvSWU$>{9mveD< zS5{VDeC&1B_O9;k=8gw{zuzw}C{J1KR?FM7LT}UN%@gO$>2Yjkb6kBj>GU++A3q-V zzpj;SowL6F|Gyd5<$6ZO#=6(Fvy;qbUtHwM4N3{T7i4dCDI2IqZcJk3le6KFmzO_X za&yrlC7q}(CydtqdOAIRok{LAndgUExg`vfSU~04lqpjd#O^Muc)4`?hd-asTkkei zTE)bC#`DtU%b*he>FMdwOgVplef{w1)1eKChc{$iRud5wP5koWqTjnI9Ue0+xG#EI zmA(qeESWlKQd1){JJXJz?%THh6&G-EDOYBj(G;_<=4O#QgT1|d%+8{tCuIc%HO18n zS4_E>(Q+|^h2hBY<JLQ+l@_%fX9yOMmzR&(Rl-?USGS|&rO=+edsoMr8yQ`C#UGfz zU%6o|51aGW|0)wor-n~1l?@keNcvZ)6Zu%vh4tmd#qCea+;^9~-SkU;lZ#7AFDMlD zR2W{me7W%Jt58s#5*QdLVU{ByrW@7r_V)I}2?h~&7f<NuSYvo#PRgw<nW1{~jnn-O zn>o2G39@PRpvKT&g>gLVuUD(rZ>arUmSG~bCFiD4VPWBg*I&=&b$56KS}+CAXli20 zxw}jB<HwI49v%%hbB^8HTRr!#nBc@m1_wk=<d`j9vxevC)2ABR+RgLl&)*!aq!c7G z&nZNrzP{e(;}Ky{+4!Z(c30Wku641yt#<1wEjO6?sqpWwJd@mCEGANQF%wODJ32Pc zUSKaGDypcc$f&>nkCBay&4+ip-!CeEe^0_7q2X$k+hRet#exh1^78$gHW}^yw(#=H z1f!X6qCla%dE?c+g^!ia&5dsP{QQ3V%^F#Ln-9`=?!Mo;a+z)gZ`8~m+P#OCEL)~z zU?6bs-aUqfjt&kP`?@_r4X$o(N=8PPK3VANpI=ui!Na!udP?l^t2sKQzRPN2c5M-A zZS54$WMkN|`}@JI*^E2N-k!6ySatougM{7JRc;#|5IL4$0IGkME?s)z^;ZvHU)P9; z8Jlk_6=}SFpyhgb+2IF|9(A6cK3PD(;O@=06P*kXh^X1v$n35De(cOl<AqnVE-v$x zUOiDPFgYl+fR)9k)la<X%o)3a^7qXA{p@q^s%eTa`!p_Ev`9cy^ywS34w+*qr`*G? z?LKibGEp?9s@9s}z*6t*fVg?x4Gp4x@1{)YVRUohUA9Xw+_iwQ;bu%vQ`1wK+KaM= z2RcqXT*b9+!-kzZ>h1<)-aS42|G|smSGkybI%JkD6P(`O&Uk%&^m&OVFS=hfF}k^w zh0hLd4SfjX1>b+bWbtd!uH**6iDz>-*Kx_z2F4m5=vZ;@jbIFedwhsJkAc!E<7(D$ z*1ml!>?9IgLbAW{=`}3YUuDlGA$WJ9a?@%i_xO-_kg{uY^M0mi_w73&2I3u=sJt$^ z@QdrVga*NhuCaMPQ&xW}>f3k1jK_d=SJ_*suyrw=o72xbExwp=X^CgX{e62k-(KXl zX5IFhP3_#`6~`+#@iO}~3JD8eTpMkEW`-fN+GNh9OP8L@>y%pAW))gty?Lj^^K*L- zUlhOD!nn-f`uh0e6P4W!DnF$#H25uV_B+14^UdkVgP{*UJ*|ImtoL)qy_(48oPH_w zIwLKgyga=<d-rZkI?6T2u2yQ{!i62Zy{)rn&)yup*e&V$y7v>OZx{Q1fB)u#&D=kd zpDo<}-C3q~qOXaP(z(2*e+8eOc%GSOEB*P|S?7uh3n5|Qhwt9?y?Bwa`fHDya*vxb zgMyu%Txx1+*<0u3mk*{G-Q247+G<@|?(1pO=DE+edu~wlq`aeBnvK7ouWV(s_|2Q% z6Q_RV+EsFsPk;Tsven!cdG}v^tpcUQLY8F)jEsyN92^c66&4H&%HQ9+u_ZHj=~pFX zWkE^F%*r{_)9-h`VQW74&NT9Rp=oyX_tX03k4{Z>H%K}n5VJpS_esfbZ?5O)9lN>t zKmWUTwGW<N4LAL5W?^yTo$1Lky>odDYkvOvrKF(1aP#I(hK4IwLbhaFJajTPFuCBd zo8C12{sS$Xw;#N_cTLmw&&Trk%X2r?X2n=A1uxi`d_3voBvpf%J{&weE-^84Hb*aV zOL%>4?tk-NuO3c$`+1#oN<NPPYu4puypJ9~o_m+gRO#B{_4d|F+3%G$zv*2r(D{zZ z+&zAuOl{!eLk!AUPb%JaOKG!71S%iDC~g|YW3b4rXR&_P8Hog!UJ3X3D>DoabVzCT z?OU-ixk1o0NTxP0`8b1eR*S{2MY|c9dsYZOdeQxk4WzAYvHq@Tg99B>l70JL<Q-&C z&T;`M;shyr_@eur8jnG%(d@H7PRIW{wEI%<+Nsm#J%7>tPK(E&_1Cl6`2s>hkKUMh zxSHks=vu75Yqh}v5e<8Ld3JueBNG&z=iKF5d8Ai*XT+8ljD7oFtUJUIykKkg^`tK^ zE?&qmIhWTO(sX^_i@YQMPpmOu=aXsZ@8@@NcAhwGTG(5pvW~y`V8V5~605m)vp20v z&I*h9UG;M5+>Dz=bMC$hTj9I^=1uRwxOv?dF4P}5zP#-IY^iU$nzP+pj@<OUAaD2c ziSV0yd!?h+ilwHeYUt^?t&iJlka}v0RQ&Y0b91lT@vt#}`t%80ga&^;t#5z)P;38# z>G3S8s{6`TM?duYJL~Mx6KCEq@7*UGwe3#A_FZ2eu6V2fO%gJVnrA>=i1c}tYzz~o zO>5JQ-gd`u&x?1ZukY7ZR{A=5cK)^B^ZrSHcD%M!&Fzx%$EF5KqK~)g@0wl6vMgb) zb-CN~b93k3Wz(GUHP-y!n<;V@zm(D+arAgB1x11^bB{-B#d&8XHi?N^g<o8cFenGf z_U-G)OKK2Y$>SdHVqPew6vzyk&)N6ySN5G9g^T0XfB&N6T=uQ{#r=B2V?CZ*tMb0Q zxF}(kGedUQ8p(9INkIiHZdV%2a&NW7*Z<vmZ#_R>Ui%`Y`j}l??q^j-MM>HHeq$Vc zd$)4mJ`Ya|CgrSz*xhAE?f?HgZ?*s3vECS)e-(ymJ~!HK+|Ug>Z~OPl<!@Q*-DGMf zPAXt=TOzdQn`=rhquUauIh7tElFU6GtQNnNR`oEtEh&(x6$}MQ6`Yf+ojSevi|eT) zksVx<r%!KxdV2ce4I2ccdf6sUoLKSYqWj#tVwRmk?=0#c9+Em|qvD#>pxG0)`sfV9 zWC1Cuu1AlO&df69j@?z_*e#|z=dP6H!Lt{yEBo#JR{HLawM^|qrH>+u4*mG~Q_;jk zgyF%vcYPBk2#AP?SnSj;Vsnl8z3Ypi&(Y_VZ@Wc08J8vO+`03_nKLfC%ihkp%VpVU zyuNno)RaXknq0Z_YPi?dzdLYITvNzjQ7gpLlT%1YNI+Veo1eem>%4TYn?$c01E^=h z!`2+Tef{N^Z{jAGGKPnTXPC^gzNVvV+yC^m@`p#=))zKCt=N5a@8n6Z)e9^Ojb`cI z>?|th)!X~cqRDN2Tlcm5%XWnp9;tq|;&H>2PR3;pYLhuRIXOYoXG%&+t76oRjD#jm zoH*@xWo2dA+k*)PH}<N%W-`ya)3AE=YuW6&pHJOlc7Eb$<9{Eu`t9{?d8Mbkj1un| z2%ioA$01+Nd+vON#5(^!yjIt%A1wMBeso`Hh%W<ZBCy(blPt4Oq6>?5_&OI44-UEd zKZWVro&7FMFy_zaUH2)v>Ga*Na_xE3Psm9ma23C~VF=1cYooRvTD^WB7lVXlk;<;} z_wSyZTd~mO$QfrgaZ@%PgVvW97BbuY|5Kd4-O=ySi;LpT-BQAA5)+#&vc4RBu;^F^ zquUaJK8aex9V-lz8w535Y~AB|^ma)b9Ow`^5Vu&LP5iE}M1l)f!s{2O?{Ak7=5fD} z<6+Mxe%DkY!No7_^o!L=N4~zC=&X^?#3p_>6eJin|Kjzx%enSTJ!t=0`7pxN=3?Vq zAx-Z5XWma-O7}jlIqF+BoA)LA;az(z>>nqJ<oO<))Wf$U>d7?*Sz%3f_XHQeklPo< z)zbw+k1;40O}Z8HJE=f0w4c%KiHd3OK8YBYa*%k_E4O$ay+yZ@8#FI0bZ(z8V+P0O zn>~uoZ3#CvB%aIbeDmfT$g?ZnNhEM3o6Y|CuwDMq*X!}_4h{_eeqG<c$h}`K<Km*$ z&C$x%AHV2q?%B6xmYjxXS5krCRp#Xv!;|msDm`)PRMv;L^DGLP9334q?(MNGv6B7u z<z@4fDO1?qH_NDNtl(W2^YLiG=TlynAKq<OcRKz-X_aW-fmMNVaeb`ZVh3*Dmj3(u zyZirte+2~u9(;H!CL$7%tFEBHASo%ycVEx6=TOu958WT%S8V>FduQ`Mjcq(1oRj>b zWBxwT`f$?w>$=&~rnTkW-F0()pps}pLum4w8yh=%dynex|I=h!{Vn0~v0e^-{^Jdd z%mRXfjOOOY|6E+r5fZiRVuqHku~e^tR4+rrj~^AF_9Lia3d#<RFWP4(pTBiF<J%i^ ziK#ca!#C&2xvyKd?dscWYo*=#WL9?7J~*+f@72^Pp30%MNkOXV=jR=rr0QMp?2P1# zuT@{(-WCrG4E*r@`}Wsmee(8wywYX~-`?D0Xn67@h2cQ3zisH_*PAwPetWC^V1h$j z+`QQAO?nDRZM%QJ*U-#N-9Ah7$|io9$m@Z7+1S}{?^V0mr@TQbW`CWm{r^A4-`?D8 zzP#LDSxJfM@v+|Kg9!)1<7->@|9zWZ@qBLin_Xu&Y%qB8<cWg0x%j_-|8DFq*I(u{ zGwFKngwGi!dLKT$>YF6=yZ(gG-CT);s~#R62iEWZ*VQL${m8%mmvGg$H=Ng_&waM} z{bqAVZ|~OMWm}_kkM+rRgQ6+N3^Y-ladXqsyW5>zmXz^q$ZBbCPrkFG@Wa=yYd=+r zi;J&`+j~p#_Pcv~twC9A!Yvn<URLHcQvP;7pU7U%ytKrVxx~rECG_F_MhcfZ@PHRn z+&dHQIBC+Pf(Hi}UzAvZCVdMF3qO4MQc@P};?i|Qa7GhoVwIDV6BIH9=WV}7{F62o z6bwDa5IkXB>~5#kSD6@YZO`v-YGP6^cX3$~!(-5TYhSJPuF}`f-k5cCh<Gb2J$j?| zP7TxuOiWB%`t;((i!W|&R%ZYuDvQcbDsh!hMKerhX}y*}l&hysoqBU?x!>~UlPR0B zeXo_qfHA{`*I&!ldu~f^&^&W)uJy;e<@XcM&9N-~)qnox&6{O!4<{HXfci1u79OaT z#|W#eZCY0-wDZXxdUkfUVezvwR;}WK7w>jlej)ngFu#4v$&^ETDnBzYJbd`D;$f@! zoI9d|6O9ZHh@`x{wDeqFV~2-n1=mDst~TNN@^pH<l9m=%__~<FGHn-^uA>aWGe85u z%a$EVFtFGys-)x!@+D{xI_ru?hKW@Ab|;r589WB8H}}`u|M~kD)NcZdRs88c!<%z& zPo;*A&YCSYR#s9cPoAv!`}KNu=<y7bLm4Ja438c^ep`1caQS7+CnjpISFH};dbKoU z{SqH3LBVu$#{)Bs(?48`&R^&`S&gCL&!3tfKYu1ZJk<K(>({-HUvCCwv3__KTlY9? z)4Io5Ob!JF8}4RLdTYTH+!3}mD)H<r(`m;itNR~2)XM$v?c29U)^&7D>AntLjAOwR zyyEHU>DIehm6Ti`b5L>JPK9|@>&;!I+WY=~i_X{@Rr3Cx>|*!+vNCT_(q#yqaJZd6 z`TxJaprrfY)vK=4)Ag-)t12lSeWdBadUIQ@bQ_;6S9o|hLqmUm|72?=r69e&10pKw z>g?|Qaz~fXuLDW;NE)-fy|uL%oFA453Ko_Lmrt(z{A}Td4I3_fdhsHo=GV*RFYfF# z1`VCgv8fd57SlbnDfRS%iy2yL^G&1@O{5qZK7RbDp{>0+d%o3NKDEgw*CA4<!}{yc z(uwWcG3oq}-*>j<-Ub!2y>88AZ*LtudXzPMeO&AI?d3~LmEnDv>FL+)c-fjkjbgM2 zso?c-tort*^Kd&qGsC9Mn-h&@Uf7ZutX}TwvcyNGQS-!ugUz7s9H^scHJ5L)y8pUQ zUlaue4G)O8F29_3YKrE$yygxMQ7WbQk7@h3CQY5%dUbU;XqY5wt=Qw^{m<)D)Rb1S zxhHUKs{31I^Y_c;AHVPa?*k3Z#_zv(Q&&(>Q;gZi(L{>3tGk<#;rjac_WASYLn3IN zQ^<rFGbD5(HZXX4dK%0=JHx(yA9&0~2Rw+fWA>TZ=KQU#ty8DDySpo!nu^Y~Ds_5) zZ|}zP_i;7<|9-D{+-tsSO)}9D!?;Yr(9keqcbTq<6t4@*#*G^zw&%sJjhhYXLc}3; zAt2*j3{B0=Z{sHC9M4YRdi4H%|CcW%3<n+_ZWk00dGe$Wk|{(|4z+N4`1rKk%xPP_ zT3gL$#)CK0IyywU8J8)@T9q8QoxlGrsO$`BTrSW_?rJtj@s7M!u6%KM)BL($oYH1F z2X+=e|FC`kU*5#T#A(kbO`g25_IDX*(qrfIdCuGO?#{WcAvm$AkmVVRZuGVz+Uxf; z^~qXC>Hh!w{XQrh_xyghdxmYbncbfc&NI%Ysh4`XEXm<9P|vuy$aU)fMK-FcthK+s zG_GE)&BV+sC?e7#tnO#A&{;|8X>x<6hod7S6BCn8|KGoV0|Npc9D#<4ObT)#W?TJj z%_mc(px3_;17Gn^JI;mmtvI=>Z#4*ea;ZKsDSm!#s<66Wgk1ie9f4+fcQPt%>i^YP zmc6+l`})ir%ggWfS}p<&DuD1Z<=2yPE4Tt3tG>Kw+*|$q(Xn3X6KBu5`uXwQ+M50R z&9;sXk<R4;a})0GtNrm}aeu+nQ=&(XA72bw7-d^+7PT#>lU=?>;PP_+_U>-(W4+Ss z;^P1M99=?0*=7iTd3BY0Z`IdTpLRYx+@Ad7!^6^5;*ye?{o7>XKtpsOe0gH&Ni(U5 zR%c`sl$3%v=FL}9QVM;f=`uB|<91+bYHH%wS64x!h+(Ub{`mO#t=Y<y*Voqm_;x#g z;nl2*d#lTP<ZN&0l`=j!t-t@sudlB+rk$0lsII;pqOGaP3F<=oEqDI>?5v=;IJ>|9 z`Ks&IB`*YogoP8$W*erQ5a5wEJG1N`gMz+3|LN)a?um(tCQ`gg%E}*KEbhM*BhGLp z%{cAsEY|vZ&=SnkdZz1RcehQ|4uACK=H?3-CZIvgTif&Vi|?-A_lxWH_WX9Y#g3<^ z>4GfV8yElFN;_=LfrHKL4<A2nZfRj*a0m<(1dZZ?rn@3Hr&auXI{o3(r>Vu~Q<T&F zo0t5utp2uUj&=FEOCf(Yr=LHiy?&2UYHDiH!$Yi<ACHPJ-Lq#;-0d0W`SWCKDgs<w z_+%^;il3j`>i&AttXW$5d%sSbGIeTaheu-K!q`_`9Wi?<0-v3quRmGMchc$U`nO}= zUs&jzWHi&oMMYE7bJC<quVPp4*%K32^U>9^{@<QEI|`jajSi3-&f1EJh@3b%S>4s; z$*-@kjZ#mE?7ku@cym)~w@%!i2r<2wjOkTMO5W4;L>FJwP*O6_yE9?YBBj~c&z?W` zj)|EwW!ki^4i6`%rZ+b>E{@xJ>C&YqPfkuYs{K`Rdef36DxQ9RVuBN&JV}||$Gk~? zo>R!mwjHul-4;6*78)`<`1SSmhtHokuYAsRdt2_|3k#hezIw&Q@Zsafjoz^g5!>@* z-Fl^1d)<<!SH<owYYkh?%CIH>{=H?^i|1hJD2U9i{_^>=b4G>+!-2bZWfc__%XT(< z*VWna$=P%$I=9`3S$*j1>+6M2P6&c#Kp7TXewib6@!l!q@$1#!Ki*myyxeQ?>M2u1 zcw{UD7z_#?IPBh&pJF}FDJO-Ci%URGF0V4@^xG9lNl6<L4l=2zsvgWSOaAxgXW2_b zjEeJ^-g33?@9*>1*Vk{!ynO7N+G@}+`<IuOm)~2z|8H0#BO~L96DKyfXNy7l;#*Gt zi`iYK>((!q`&0FpTv2f`Xjy=$cG!b2FE4ZO^19~a=-jz;Cuh~`_wW1F=T$IGR`YF& zTkn2-UF^lJ+2PiuyfOP~ZVGjP<|c}scHPYi{%d$Z<jlqGi+5c%3knVv6c%p2x3@a^ z{k^>rJBw8BRXpaM{d(5fG|*(p!6sHvYZR1dQ%_I3nsp^4`0kS@DWFwnTVJi;W~%+| z^RZrOP)^)m|KIBR`hcs|$?GR7F-(~<ML|)KapT5~A3l88u<}|XGy8+bkDD)C2w1Xo z>CKhS3-;`hnK^T&gmszDp~HtK&Y02RJKIdr%Iem#U9PUK9-f{DKRrGD@ZrP8^82;o zyUX7nYhYx4bH!3qklE*8mbBP*E)EWdy1IQ&3mqL9|NQ;?dTVd$>1hvlKA*?TVDsZa z^N$D3{8@M1eM`6J-frvY-~i2GWMAjg)6?5g^)+j)T1-gz_cJq%Pn<n_6x4Tr@a*OK zna1f!koMi$^7RZGil6&|W_*jEo!O{akXN7o>GS8eWl`5sj6hQnpiZTWOUv1>eX`bV ze}8{}JUzb7F)~sTv@9Xzq>#@{qod1qK?Yto%u#)DcelA&?yZ#K{VP|l<ly1iBI7J5 zC}>glXUAQpGslm!PuGiWnm=D&FLqbT=O+rA_~V$fQ{GfsYt`4+F99vE;gh%PS+GE1 z_m>-+)BR=aY9tsY%$>_S`DDv7-`Tf9Hixbbi`bmTJ54{n@9F93$_fe$`TPHVlRf;} zk5AUB<?L+p<Y#AQW?Wj*>AUsNp+gfUPj0?*CuW9^+MBz(#civ;Y*?vQP@J;8=&4sr zOUr|g$K|*0lw+{@e8w1*7C?q(US9Ta-|u&uE%z`SxPDz6lseCyV=FMOh}x2oSRC7Y zu%V}iXUeo`PA(H>&FY#kL16aluoo8>vx62?Fx=Rh9lkZ)VMXFc{+Xe#uH6o-tg4F2 zb7#F{b9Za<alRcpb|{#ciSgTfaM-)8@XL$9(^K-p!^6RotdR%A)Fz)S;&oYmIq}R4 zL(n3NoORW!Pfk`(et4+W?EkVqm%Q~4rWi%)y=rf7f7~h_x1xM+Gdq9M-Cd;yv(HMH zWCYB8zbk0!V)uT~^5TrEtEQ&5SQI_+D0zSH?z3C4(a9URQng`WVqxoII47TMIdH(? z$kC%WQ@wsYpI_g%xB9!&>Z_n-*)uE(7o{!=h}DVPBk}U(%N<o;wQ6c=1Vlw!=h;># zU0mdP;`C`ykNL~X%a*-yjF6S~q)*0OVK_J6zW@2WYQE)ubD0W0%T0ZJtatP4-lEQT zW;_Oq*aSpGS^^ilCBD40R6|$y=<oOY`x}|r7ZpE0cP_8jV{3)B<|4K)-)`qCo12SE z^|En`>#e!I_gBXYwY~!#QWqvDIv0F<6Zz+P{Xg}?-6z~YCI$rsHI=@;miXbp!5bSA znY+5W=G+yUxC%5{?va$FbZc8~cc-xWqU!JOBDQ8t-5jkHWXdKH$PCJ%3!U3_{(I}F zsj<zRIrGNm^!~}#%0c>mj}$=lH;xX?-+Jf2W-o4TeZPi*fq}u()z4*}Q$iB}iKkq6 literal 0 HcmV?d00001 diff --git a/Demos/test.ipynb b/Demos/test.ipynb new file mode 100644 index 0000000..885f75e --- /dev/null +++ b/Demos/test.ipynb @@ -0,0 +1,96 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "afi\n", + "\\begin{pmatrix}\n", + "\\begin{bmatrix}\n", + "<a>\n", + "\\end{bmatrix}\n", + "\\end{pmatrix}\n", + "afi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "afi\n", + "\\begin{pmatrix}\\begin{bmatrix}<a>\\end{bmatrix}\\end{pmatrix}\n", + "afi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "afi\n", + "\\begin{pmatrix}\n", + "\\begin{pmatrix}\n", + "<a>\n", + "\\end{pmatrix}\n", + "\\end{pmatrix}\n", + "afi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mat1-pilot", + "language": "python", + "name": "mat1-pilot" + }, + "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.6" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Demos/vogn_fig1.png b/Demos/vogn_fig1.png new file mode 100644 index 0000000000000000000000000000000000000000..80e00803644338486dfd50a7e40880452b32aa65 GIT binary patch literal 8149 zcmeAS@N?(olHy`uVBq!ia0y~yU_8gbz;KU)je&t-i~EE53=9k`#ZI0f92^`RH5@4& z3=9mCC9V-A!TD(=<%vb94C#6Kxv9Fv$wjHDdBqv|CGVN{+c7XO=z<hE7o{eaWaj57 zgk<KXGK7?-Di|3l_~n-=7#SEDDHs}AnHpIcn<xbMDmc4_Bu4MK$iN`4=jq}YQZeW4 z-RcO@(tqq9zCT>INNK^Mpbc)*wzmca26>*{J@aW+>TiycNZ!j=?tExt;#!iI8h2{y zour$l=G(6r1s6|lo*{lF^wPE~A{?RtfdLMV33c^7%i~{K7Cf6X)3W&3_t%v*=Qck- z^RsRr^Ui#G<NGrWIhqt2IyySmJbLtkQ$SGAQkYF$P;ep(kDro~5~su*7Z(>H1B=d% z4wVAq?`c6nlWu)hP*S?o)6&9nTAnLSMNMs1b#$TI;)$h^)4}Na!cyte4sxqhm6Rqm z9Q1T?QDJPJ+|l8|gv;E70wF;`&jSxs=&Qkl@#oK<9{&FBb#?m|FL!b=N-hx6Y&ht- zB%aMtpyl>`A1|*%4UEh(2C_=E8hU!i`edyQYJL>3u&`KES-Ge*Ud(WDa%y_Y%VNyN zBcT8ahu<E7Zi@rI&RTPN7X<CU7V&SUZAi9>)WjJxRs>8F78JD9pZ6HWqaKVgq25d4 zdHj@E4J<mpbRYCw((vFx!jU6K6f7)mTntuJnrUd!DRSU}$|ZfQAt-VnbgRp+qYqSq z7@8-0?3bA1!u4QPl+xcMn0GK^G65vDItyYO1DpE9I<OV!=D=ef9z#J4;a7!TiZ@U8 zVC3<GT7hDYB#WcKyNb&R3=9&zZd;!_ySO|Fa9b?M$;mm*T;L3YLc|Y@Fq$@F#*GKh zZ9=>uDFsV-Fsxgp3iA9!CW$#<pJFDIiA+0IO@nwop#bVa^l*ikkCGBu3qp0Fo`-}l zra36;Avppwd|~Ez%KrSx;pNZ%ZW3P)C?(|;@f59mB_tR3+kkIR3B%jj+ovacT$=r- zhGqG3=ELpLeE#O<3I-RpecZd3vA#Y!-Q6X{G_uL~ZGqIO)u$)!QI~w*Tjk%UXu5vM zCYHUIsuZ95TXKBhEBI0(5*`!S^Wpp9xA*VMS~q+tx%n)$*IoMdf&1}1anUSnU5)u} z8Ih6?9w+~+=K80ss9`T}Aa%Ar<NUs|7YT*&51*;Y1#)mP-AJ8$4k^ZT|33Xa)oLN% zdASO)&(`PN4}Is1`20a?Oa7w&>x$pb-1_6uA8`pe1DW+Ldmg=bsqyaa{Ch{wJ(?>a zW^iWN->;TcA`6Yv9<;Y|2R?qCT_)`uD{G?{w<WV~-Szc{_wKo~?ES9k(+_|BRXTg$ z>&lNxJf)?R_NT8{-MpOnTd3yI!|lom$N8S@`^<Oh&><OHS*6_)y>2QhDiQY_444}d z9xk@dvDoG)F~crEfW<Ll%2tmVJ2DrA-Zws;VRGwFY_-SQ=%`SwAG%+Ki_SgesPq2Y zvMAei)s?B;S9ZBx?_$}%wC>QvMatXW=cg@GV0g6pl+4HCbEi)WCnY7d?Ac>;HQRj0 zesO&+r?`2!^_w;yy+41ay|me#(Eah(u9n|Da^wh`{r2AhZ%;LA8}7cJ!*Jk?ow491 zBbNK|f8=7L%eR(ioQ*0hU_DkQ*B$q^T2ae{>-4_Jw(aeE-@eGyOuK1*T0m5)bwk63 z-AVON6L!g{T3JO!bGQ8Yn`<wA=R#dXVM&*V{+p=K*~NP7s#8@Z?q-@W9Jqa0y7<>w z$3O2XBGs0=hOb_qbatWX{y)iz>+)rcii`td0^dBCskwN^A_>Wzk{z$5*&Y7>))oh6 zl-*6mPY+I=A!R43*Y;oj+0%LYkN3O&cRjaLX1Drs*Y~nj{D+;|9_|bK&d9*Dhq><M zp)V({<jxXfd0AWk^bjZ;%x>PiViCvf`dfYCa#at_-&gOfOmuw0bmn)}yt|Vx&ssG* zG@`J8_1V||Z}+|2%DsE<ZIg?y{|O039)9*9rZ|Il-s^udQB~XaJl;HGgM>(&?vZzU z?w0xbWnbc3zVQCuzZY)q|D1pCdbW63_4dp~*Z-<2ZEEv97#SPhyXA1^3^BX2Z=UDr z<wckjOkB6?+^bz#d$#^xYrV@?cyDRqG!XSxUvT2q9IkV`$ITYF|CW34<od}+X8z^1 zQddi_{&;gF-OS(5`%?ch<t@1ya$FTB-aM~*eMqNtwp!Kg_?;is-n;xt4K7$`v4d&- zx4Nwdb9oFDDg%rjl^<Umw_<x{QB+`beD~7o=}C1@{;+Mo>@9vRVteMI>3>6+KxL~6 z`}28Cwky`HJ$B)Do7t|nD}K8#T$=8kW3lhxvXhxde<i=ZxG~h-g~iQe$K1GG8;*gT z`)0imxM)&gf8N!sZLs#ciA2JNtlw9T2ThzXvtjmEb5(yo?pLi<dnW#MTYPs}=jQUn zYh|<5&h6Xpl~^G3a{7`7XY@}WpVwsD!PUFzm-R%)i97DUulw_MfBj?|OWhw&>gOL= zzfzu!jekp4b^7~5Yu=jq&Z({M>{v2MWX^lJDsjU^!;EM5e1axEaXjg9((mBcsM~o< z-fA$hEJ<6gWEXU6?u0p8xhLPson--v!<&a*Jy^3Rvh&O0mlaE=e^F2Vl5w56mg#pw z>A9?v_e+<oRo`~#>QPZ;CpV8@^EQ_y2JQA0PQM$kq!b+?I|q~!dAeLS_;2uS72}WT zG5@}|bM@8m++X{Ym!vFDsH=Z{F8AKKo4X96LAq|oFD(R>zLBDHm{`_W?clmx?Z18J zh30?!Nmu?Z{&4Nz_8d89-`(flIHmfk&U^J|itqjMZF*;}<y}5<^ILc(sQ%fcWwGDt zuc*yk8$n5t%<zpZjGPtb&tqfOY<kPMFU#xZ<fh8M&m;F%-H=ItdFTx&WK!#|f~(8a z(1LX~J1(uuyR5PzRREM?@13YS{BGlvDSwO2&c#}{r|+^&zHV{uQtQpzxw9-z|6A1v zD$je_o}aul*`ns3fm+FY1@D7DCw`tdadzY8@bjmP<_QITTaw_n-?G4T$1U4w*LEB1 z+~q60_PxH~#Jy6y=Rz%48>~F8Qn9P*RM3Xp&D&<&DK-*I)t!`Tv$MAPU-X}Xm+YR` zSDCrIj-3&6cUkAP@6$U@#PPDFSC(4ZS$z{ssy=!u>dRO6xZ~60w?DY@G<Z{=cKeh! zB1gXVHt+7<os*okm3#8;+a?!Z{Sy*Ax$xkFKMzi@O9&b<z1?&BWYm@8r`e5_(~=UO zIYl1ddVM4J@d?Fx?D}?J7Oi=V(737-RF|JFDv)ZpYPnjvmaA)R+}poe-$dRx=6SAD zdVE{S)LPW|_nDUIv!}mF&R)wMyy~{e#asVY^@74?TJvYdk2NV3?FFt}=EeDKJO4gY zs@uNh_D#*FDK9<WoV(pSy?Wo86F;I}ADZ&Y%y-MS{aKGe?UYS2bM`Kb*q&*$^0<o3 z{sNibT;DaLj!Sue(>u83L*|EXAHvqOh3(pK+H|_;TQlD+oA&pC+d`iY-V|$)H&}Pt z!nM14N0q|Ei!7i5YEh|FaLr<gX#c#US3a!lx^~e^eA~n4yj^9p)uL|3D=Asd<Ue<h zfsZjyFR#l#A?bxn%!)k?>;3ANR_J=0{n^7fxyq-he|rC;tul98MZ-ms(?9wh-R(O$ z{@eCvo3y@mbWBOJv(RU@SaXgghId_rO@`sK_w)D}o2*>xpZ?kU`NW<Hoil6GRt25E z7<*$={<Or10|rp-AL3VCQC13?_4C0U?gd_ZJ$v5Th%rp4)r{V|X#1Y6|8;rt&1L@i z{taE7`Rb6~>N~A7!!G&l2%opxAyRu?zRb0G|6{Js>N^H%qFsHk@y41pI$NJLrvI6L z@YVdV#qnYGJ3OlQZ997^e_Hb0g{40hTxVbPPMd+}lXMHOeSSm!wDno0_y4|(<@qGd z63-uh_51c!`=l5q%%0tC)cn@`-1e!repi2a5x8Xea%CMIp2Wn&RoB?A+>f7sC#L1m zyPtnIy}KKDUFjeXLsM(Ni0CexkRKmTw6D54`}<cL#c$ma2Qy4og<W3qB5L9VrJbz- zC2KvlRza&^zMJ=te35WuU{N#<{(7tL#{E5eY!ubh+)kW69lUp&^0)94XZEbF+rMV@ z`(2%#oxFAH{Ib)R+L!(jp0sIFKyditinW`hQ$4KbEW4#N^EPV*dqTtkgRAFCwQBFC zB?~nzk`1~ZSYgREu`W}~V)xcJZF#x76yFxidbBm{`I=)d{1ywo5nfZF>#cUj+HtDr zHn01t9UU+77Oi~1((uIbWJU6O=@ok-S4Q-9&Ei^fDzeq`?=y|C!&3X?_N`j8p|oVX zr^^!cS={F?Y+KmD({<!jv$p8!kJt16cRB8tZt<&|E3!IKcj@}qDce0=RP@iXsx#<F z?cg~5UElp?uhGrp`vR+(PxI>>-}A3;Z}h~@OV>*`-7evY>vLKXKa1zw@7njrC-d8N z?tk;U`%Uuyw<qok+*6dfd%I+MZBDf2RghX4P`f<S$bvE9;bQKM-)?W!SgA8H_ss0C z<{RJ4PMvYTeqT=VDaV!TCf{B57~G7_G_zoiW>L~I;nJ)QN|82JHfNsu*LrdK?|GYg zHN|)C_A8s+cNA2=pJh{LIP=zCTweA!2kTSTvi?x@D~TuXsm_pJxi;^z%e!@x@2Uw- zG%}H$vv&5jW7-ebE1aB>@;yRc{=bCmta69{)xS?07^j{9xl%<bsBc-bFhiQ_nM2!x zZ-02aR6bYExuN08n~<|*v(<`9=e{xP?3l9n=YyPwH<{||o}7=Eu=Bt(L$m)IB+uH+ zO7u9cXmrj;@>|*5H)dNKLB)^v=YyOK!H1VWI&hQOA|~awvs3V<V3X~Wt_f9xd~ge# z`ImE?Q_J%;*#E!g$oszOf9}4u&vlQjm36Z>h-#dvdH5PAP|Co8V(D7IbfBAme@F1r z<r|hK^e=g@`rh-{o`0Vc8h)MU*fMo(tom->x1c`5^vf*EcXwM)VpB`Jcm3LZEq!Bq z;iaKVC9bE=X)+FOy8;Ont2t^Gj0sNLIW^Yn9p4swd(ADoRDZ5#-{y0RHwV8}V|WQN zPf4lNB6QIXiI@pC8j>G(KUQ?eD7gJM{rlrHQ;mNlf45&{V*NAncIl?uDoR29!K~^G zJ(USOHnFxFKmP9J&6~bSoptl?vu(4xXL}h>p1&1j;@gLyqOxe$1D1v>$AdN+6f0)E z&OTdLx8w&$k#~`xu-M{vM?@|}TtAr?JR8(WdOGEx<%{y>0{`yn33VoS-#lM=bL9+C zL+*L&=DqUsVeAFP%T`Enuh}dtu>0K6YO%*|Z+q|W`G0t+{D$w(_s+PIJgGTN&E6Yq zeNutY%juWd(kt2vZ0@{E{PXqp{(sN@UU?JZ^WIk0_wH<~jI>XiuRwe>|1z68g9^Xb zu}OQq0|J8?87yj_nw0(9A{<=hTlnG3lk)28C-WwEoG_eYWwCqPyRL=bd5?Z#KF!GB z{aw#BXMMz$4>=DX%sl!28zjV&E#7aH+OERq;qtz8@5dv|{t1`)XBQOR@^tt2G%T!r zeBtfhybi8jC$~JdK7Y%1FElOVQdI+DctpgQ8XFxP7#_TR`y%r1rd4Jd8XeCqJ4=qO zwDx0oabuP8v2w}&gObf3A05^|w7qlv;^j*ug0EXzB!9SjJ2xzpaef__iz}m@U6Myz z3j;Gd)A#%QCi#3@G8k=s>wGw0&lJASB4yUBJu**!l|J~Ac_2e1e)TFDTV<u?Prk^i zGaPY0_PBd;{DZ9>*JW%)j~@NndszMd?<eo9w?~GvuZd>YiC~D?!?7ikxksAa=Es5? zscdXa&(C$<eZDgIz_#22$K{!QXFn?Uw`FZ<>vCKz<hy3o+Les|KFdG2|DSE&52hU@ zFVE%H)HEEIXP;NWBw;C(an0v%rI4j$vjRu?o!#dW1m>$GnMhro$NzH5`HPD=<{C2Z ze7~o8(*^_2`?*mO9eSLc8D-CSPRUhquwJ~V@%!(4#_4VRGfeCYnPkm!oo2`G4tV~y zcm6UT$CDo(etXk)Ib(CSxYe?y2R}b@y<(Q%=Uw}Ik(LIB>A!y~^6pB_6W2eqc#DWH z7x%;M`SLdFVjOcfr)kVFU`#*W@4k2Wmh1&@fBqH9>_rTjFmQ<31x>k_5wch9^(qzP zU;&1Yp<Qos96x*&Z7F-pl6YEdwwJt@zj%vd^O0YdmvJ6CJKL;Rd8%{Wxz<*v$nANL z_O-QhADSM|<>c#o`2NcE;`Qf}k9XaFeZf({?te^FY;^s8qaCaN$!%PxB_u2?{pZfh z^M#Z8-rnWrkyMiFy1QRq!uZ&-M6KrL#`XJ{9zALZU45kR)vG6SSBuHm^SQVzh^(`l zFpp2hf}ux(amQ}+Keo+`FRuIBl<&!xzpzgB!;{GlUR_d~)rzcm{4Ooy7C*vjckp0R z0~_m2^LeYaH<W08`1kw3^mwMr%TF8mp0z0Bd2wH!p`hezmV#9jkIPCWr6cpdAL(?c zvH5U_+sJ>)iJvc%3I$#UgiP6?RQB9&L8$i6W3?|;3teAMQa$j#p5G_v*|nZkaeYC7 zj6L%D>kRJgm!G=a|F-$O<;!nuEPKPDqSCSc<Ht=tQ$6@^6i)h9^LMMnjMLK?V|Smj zuglUhDA6z|*DLtB>Ca>5r>6sxl8@H&{COS!=vC5AofwWIM>-zvtlV7lSjf_nO+EAc zqoW7*e%HFjdnkcnnm+rwIMzv%MKu@Rda7~1j(bhKep}4_eV_XGm+4;EtZtAiwf?ut zuGWK|w~D@KOqj}gX5QT&i^Qr+UMkJoU;W<JHE+^_r~<t>o*%!N*K3yWZf<Aaki=T> z&*sCm=u=k|ii~*tE=_xT`{--q`E^l0qb92{UcLJ0EaRMuox%sMtxd|%s(jpJS9|3C z@lC0ZeugaCEz>-COX_pK1@8PCyMv<o<sN0lrrXwU&z=24N_1(>+RV#GF5KA{`!mW# z>i7edw*o95Zyj!AzPj47NM*vzm2tL~Z*MS`yyx4JzrJQ|2gk=>=X_^RS?{`}kjL** zpLX~W=jGq;ERH+dC)>Em=%c2#QBY0jT7{15(R^}i&ivS3T*&Cw%T)F@Xt~_PwvSeR zLGA?xpM1Mhxwsnk?6KaisUZ;0%XVPefsfy&)pcxlX8-v0j^%=2^_Ql)2CV5NC0mTR zTTY!ivV87}O5vY=a~m!N6_(~+UiRv$>Lm#_^_9vN60FM}_;@i13G3!tm#+HZuGSy5 zIq?0xZT7aR1_A}Y-^MR}AZ>1-uE21x_&HNt+_U}9pQZgSoo=4rwf^SK@|bR^Df9L1 ztj-A4*WaEOS@o>v$F9uFb3g0p9lKfhSl~o@|E1W5gPyOt``F}6h0|GCAF+N9UdHh7 z;icniR~Y<$vF6X8n$xlOHzq%_jgqhb)AwQXt(%)2a^L3P<NEgL(3=K^9}!%>3_A)J zKWxbEcqufi{(tnJ&#!N7>&@8PDSUQcthDgrJa(Ta3Os&6@dX=x{%_XR6^*wp7dsrP z#u^#PVJ3d1p(6Lu^7%~J*KS;EHB~Uz=I)PLmAziRUZmbnzP{%8QtQaxt9wgMZaeK| z_nT*iA@h&p_GijYsj8};YB!t6W?<oIT~m9M``!7u!RyoN>@F;7eY0@oj%~R|uTK(s zdH?J8?Qe_b&yxCB`X*xYbBp|xR8RTICpZg3bu-%!GJJWZI&XXM>2q@(QkGPGee&or zvq@&sZ6&Sfxi*|XeikMQ-2EysXNhhzJF}(bquP|I-yZiLSQ&ia#l=nhYkxe|SeBmg z@45Y{p8DOtsy?=HJGZR}?)Nwh(b28#c6EpIS$Fx)>*`j?1xyD%Jbd(M+2`j|S0`?& zw+{$Wkz1y^>$IVTXY{XcqT+isYMnn`3i|l$>Eq+w<wqvY)H1J>H}$GHdm><6+sRd- zk18JsD#MbbSTkeA-_i#c6jSqCx2JSgDE?pM+QqZptHAC<!wud2f499UxBJ!0%-+x| z-MGWzd9;h`5(ZHImH)3{*I)dr<fB+k(e2&gZ_MV`$6edaYI&rI_0dz+{QYas{4h0r z^nPJ&b;32B)GPr@NjCM&{&w~ad9ok=em`($=cm5d7@fH95<-jmpL>6MqxsJ{`J&Q; z+4)c8>p!J@OuV@|tk6`~@=E#rT6RYP8CzZk9=}Vg6rCHw<3+8Vcb<DVbxKD$$Ep<q z`BfM8?6i4ob!(RCf!gnk=k2ub9re)b7Gr$*@{z94{3@?~g`Fy=PM&nk$k4DVd(+V? zZEj`bAUS7AZ2lfawilnzGr!-Te?LOqzl*!yZw`aqPnVd6B?_ToS7%jJcW=MDdIf`$ z(uFhkW?jAdXf406(2@DIHG5<>t89u44Haeh`2MQ#d7H-{7*Y!+l~q=DZm*O!^|DEk zkmjB;-CKI`IzCyme6jpTae<2Wq|06exGwvhy^2j;!EXBJYrV>cmie*%`&a()Vsg;i z`}%S6zxwMLPM$o#E`P!%Q0cd&708jf^X5HDym~!O_<VKQOQt1DP30C`U*G+`@a;ur zMeVSTgOv{$E-Y@>x*V1o`u6RvQs!^(-BSxT+%Ww1QaO%4yJ}LG>az6ee-HT&DED_< z&(6EabY}kgV{1Bd(n=ey<s5%9jZK1Q`@b!7dUWUS<&h6>_ARYkA9cyDy!^pg^Ty}% znB(dq-`Fkp7e61~*4Cw6@P4oOkDuuaHVFK<|Nn^J)=fe?-rLp8pVPBWtG&UwNtl6& zxv=DGmQB?+9fNc}gCdm+t3(abdMYY*)mDFGdz*f~i?Q;P%7)U_75}!UdMl{1&ae#L zGgp4%WCPY0Z*FehSn@KcN8VnJ?eKc1i^&#YPixy5xfdB`#+s_FncaGBYWIboohh?l znM%xYi<YlUS$yYCOuNkHv{?03yK^LG&9`XWw!7?L{rk9z+D|8CXNPRhY`%0{?r`gI zIp@gl?@s)EXB`vrbARfAgZ9ra1nj8!p%^7=*K^HH`HxwCTXoeh+1uBusu!CmF-@1N zWSRc^i{sqs;sqZTye*ykb-(tttFE!Z4Sw_OWVyxlTyk>Wto7&l@ZoJA=V|i?mpTj1 z%&=gvcA9@|m+a@9S(9%*kTFPLICbijLBRuu*=(vo-O>%!3@nTq3;`Sqz8zwH@cH~v z`!C&U47Z&BREjcbFa?ALGQPQ``cLsv=c7kSJ~NG2eP^5PeZ0c|#Egj?r*3s{ubZb~ zJ*!nm{AGK#E*q$rui}=@J9+l3YevS3Ri=@U39<0orL2wz&dfBHzOycLb=Z!ww^CWz z*%vpb`}@qZk-V5T?{)OeD;;KWc^Vd5Sbx8I_GoUSU3t#s8yCa6+q0URn?vpGlMN)M zRDaNay-5#*tWxi`@m;N|u3o%o5mS>w!mBGQJ9>Lv)xFDEcK?&TrXqi|`1O6a*VEGy zVuPgaNy?~K`o+k&xVZQoKYNyU>(;FtoScq1IXY^7b2`+-#J65uXk;(EI&DvH*LC|t zi|TX*w(jI`mXGEDPu^KQfA_BM<KyGWAWJ$rGX8Lz#y{M8VWP)wE`?$<IZcUPU*+I} z6UU+xKU?`J&Ab}>gH3yWJ&S+8WOw`g$gaDtTl?k-O$^SidTn<y_tqB2tSqf_^K84n zzP=tUK8xXjAyf8gR*oiyg*Ccvzij$SxBuI&d!tb3<jQ9(my+f=Ei&NGPy2EB>HN)x zb&JF|ZS!?E_jmX2J7L+{-v0Q+MCBLv_FBip#>(2tmd$bbBv_F8e748U(C$F}qYuh; znGD~x8h$wAb#&5N@rAw5tpqHWZ`feq+oE>hfy$)*0@0h%cFq&C!&^!}wsjwDP@B7J z@#^2IH9J+g!)MHK*#%PM{WkN7oSysMYKB`sJO3M%ea!7OTlaOvpLZ7LK7^=G)HAT? ze4-R{to8HO2JhkubK&=HNguMBmgza<dTO4!Q7H5hG-_;iXzk}2c|V?p`21b_U1FBY zu7eL$CUq|qjoMz!{AzW<<F*-74)uD4Tw%_88+G{jHgyTXiN`<&KN4$t$6tAP={k<1 zOTRKS{JO-wBj7pH`we*<50Az}+}FKORq41*<2Lht<?qL}7#yyieEj2K8pAOg$<AqS zEILaX4|=LdGyicvcj)y*^Nn8*_iE^zKmO~x{qeJmn+>z4*w2{l^6NmeyGzlhH*J}c z@{2!RwNI|P!dfC}%|3tW-llbOee)y)PqrTPR59Mp=Pd9)Q}0)Ls^t?yAD1OM)SKXi zPq!8wiRtL*Fi})gJoqR*4K!)oapv*DDD-(~$ZX_?dMU*Vv$PyOf~M;kJYD@<);T3K F0RW82SPK9E literal 0 HcmV?d00001 diff --git a/Demos/vogn_fig2.png b/Demos/vogn_fig2.png new file mode 100644 index 0000000000000000000000000000000000000000..e1b02cac0d7e7c30ed142f4efa6a4046b685a3a9 GIT binary patch literal 11413 zcmeAS@N?(olHy`uVBq!ia0y~yU_8gbz;KU)je&t-i~EE53=9k`#ZI0f92^`RH5@4& z3=9mCC9V-A!TD(=<%vb94C#6Kxv9Fv$wjHDdBqv|CGVN{+c7XO=z<hE7o{eaWaj57 zgk<KXGK7?-Di|3l_~n-=7#SEDDHs}AnHpJ{8Y%?%Dmc4_L@hjR&%mI-;OXKRQZeW4 z-O8Adum6sJyw32bZPBw?Q>UcuT$-ABPpm-v?An-Mmff+w#+P?xPUF(My46+p^t!ax z=$W&g>2(?1`IP?h>#pfbRhOyF;#PZi;OF1MFV}n>*q)u4DS7Yw@nkuX;%7DXha27( zpZi|DFTOodf=y|XzBpg~Vew-7)Iukt|M$KMw_nx^UUX>fm8>5Oy4EF&%de+h(U46j zpQ-f7jgNJCM~BC~mjMwjE=O3o`~(FB#WgHkU0h-oJP;8SENpBF21z(t+8U;vk?_B! zsHF7BG$}c`xbD&k$C#KHKmW*6FH2U%Ze3k=b=|Gd-P^WS@BMRmX%r4~a9S{65=WFY zH8qbMKR$WVq@;39P>38h=y@|w!Z?jbP*6}#&;3Y!&h2fziq35Ym7h|iOfnM6EtMv@ z`z@b*<Hn6S<_1Lq;^NaU2Tv=qnwu5=_LuAK-{0SxCnY8I{QdpCde7TKUyAi|-oE;N zs_Odb{WAJjt>*e2>yb=$ozX4Am6(`#<j4^LF|o9A%}4H6SQGZgG#l&booim&(Q)GI zi-t3GQZgz^kDNv3d<!n<>gd?va8NTz@T+U*4|Ue%9j+pCl>T`_MMO&+((ECENvy2P z|BB2}QnGVlPXTNEApjLo(hDf)ig2k7glc46-ccU}5lLc|op941WE$)82*-n&Aj3NN zFEY-A8U+>U;1-#qBo-Jy1*-9&=A-#gkqAfjlyBUdb~6apFMS}Q{pNms!;c>hc{^fe zt>4#p<F0^YPI+i+_c;q!7d^-S0R<N8K6A8&PJg3o`evE+iugRPU_0I8=EvWxUAiHt zpsR!B@D|~M674N|d{f${iXSvMbNr}@M;)t^Y?(OM_Iq(NPj2SFV0`4A7neTk@(vCM zfsi%4SG!_<hZJboNbvHDf31nU$#w2Xw3lWN$axnP`0PJQyWHjA6is*;_*K2DDfoyH zm*4+_H1nG2-us^|4SlA1=k?eAwr}jKce$TmZ+?DC?7Q~A#rN|xYBsW*VyW_<zs?*S zQj4={Z{%Otwn9>F>3^nZz2|!}3smNq)xGCG`?9b~YRBUgQ&rX0A2Z`WMPGY=U;7@9 zSv?!??ZdZnFDR|&Wj#FQ?}w8P9Gq?Y&o)G*FAQUk_#*FNz0CN{8w;Mp2AgURC4OtN zp6lm-O<5^P`f*X^y;mXaPi2x1iQm7ZapK_3x!XU#Iic{Y_MdKV_m2FM02h}X-nXsi zo@9U|(6Y-*UX+-z$tE9qWP4}ZW~ur0^Zl0V?GLj2aZ9TA%p@K8Qt|mLGEcr5vhTF~ zP`};K$ZJ!@58FMvjVDXzS)bfszVGqApg04eQ)-B`%^<PUCRcL#<(D7Lz_~l?x&hDO z9T^gTy`<Te@+Ln$s(s(vyk}qNzYqWGv%Wv_I;>H9_p|R|jl1U!Hr;GJ{q6nze3$Qa z_g@GmNwi2DTfx~DxO-+|j{W@8-9|i*oBP@V_jV_~IensTvhjbTo?Qpq1aI9l;7du{ z-+R7(U!{n+`1IGGcZFyxO`1LF!$p0|_)TBFEWNd1gF(_F`9&oR0t^cm7JSrxVaM<- z_RK@q#t%=#H{>&h@Smv@b~n_J<Vg=Zc;xG|nUhoe4{9nsI-GU<z@_gG{>W53(fna( z-&}d_@bAYDKkmG+P3MdRv$fui-9i5sJ`ma1;db@cyvx-OmY;S|tNAZG=k$i%i{7Np z(Q(UCo4|S8&*AO<Lzm1S{E&HJd~@r?-RZ#(<ZTt-vPxWGOw(_>HGAQ6h8tBe>GN&| zg0j`Ym(J_%Obc9Qr!tTI+@T9>0iW3P_sBjL+Vj_?blN=Db51_G5v6kf@=fQQXjt#= zymQaBTF!Z^`IV;~(0-dxD)nctZq7cA`$rGkUQOJ(eQ&+~0+9Ri+&?NFG<aKLRy%q5 z-uGoaQ{sa(?r+uq{eAhLxMa?XtgVs7&saU|Cm!GR|HnRm=i5dGkGGWXug?c-ZVFzr zKwA=8DnN2PqJViaG4Vj3Y+1NsSun`;wSoUq?^^A6%(o(5-Yj?1ZmErvn}Uxharyn< zP^@l}#iAQ^;NIS6-_On6yj^YMbdc1m?oYYw{7$pYo=HA?cD5}1vo*wuBth2Y`Ci`5 z$K~5M7<hOX{5IX&*>t(iu}oY+=@GA9Y|}#Lht2#Ciu7LR-|}S#7g`<*%_|IiW~a5K z$K~8ktGl~zZx3(!l0=gXgO({%3~XvI&Ak3yS}e`(&(x-17p|>$cPE|_xgKX+^5W|M zRqx*weLAuGc5ip{ookKXO1b<5yJOyVuL@f`OK)}MMyt{@o6l~)-<H3>b%DZ(9p_eQ zOjdJjX4_EvyX@8V?=>Bj)w}=wd%f;~$i@>_AN2I~g%wootowWBcpLABXR|k?a9YSr zm^$_EH(n_R7ZwYd%$D}*Eg=g&Y<-<;vMTI|lGKrh)p8XKV)|{i)n^oV`OKKF%+3f| z3o1p$0t<evn`Qd&@Aron6eUc#oSfgTdr{8i_gmA#)ukw4Aybbe^U9SU-t7+9y6Wd& zA=NjlJt1My5#zow>BE=HA3mR-Fe%CJV7fT8Jg*cHV7R*KW^C&XUr@<SRLx*gJfY*q zo+S7Frpq(`PIh!Gxa|A$cA*Ey6#e<{cdc2#Z1mfbNBQ^8ce3HjP8U4;a#}+vX>-!b zl_61kXD#?rk{7k(!n>k>$DdvZFzOaRe?412Y(;~h#EVa_dk#40g{_#d-psgL{CSaG zdX>hB>b+A=SDP|1Yi>^EcE7#lq0`e-KX297S<LlIDxSIY->&pI59MaeD0sZEw<P|; z+#h})S^mkqm}vH2$I>$L?W)+Vue0A;%@vS8U%uGgIVkAc?Ua-Q4-fymU0-D-V?Xcl zWlc>@%XvRVE$ikey?psIYuk;5&O6VU%%3*RZKhG`x>_aW!*lcv?ALvc%M}!6{`hfD z-i3x^cXwB>x%qmo!L7QLWydedmdv|8bD?kBrO%(|*~I^?Jakd#(7zY)?EhT1_uic$ zZ#Mr!*1!Lf;>WHAZd;bCniV86-{u=9|GiHOj^ElFvTly$>s{@#9)4<P+L))jy;qh{ z@@I$So}UwMJ33`)9Xb9yf4|r!Q;Y9&@3`OInOnL2?e3D5cUwC)a44m_6}i8)eo^7> zZtX2>e!HN6Iaa)6Y4O!_CD9jpf5!f`x8c71N~6<W)#%&pjeCB4=(aKYZ#eB+jMw8; zy>IorZ5G!2{PUgl`M2#4m&Uek>s@90<+ftf*}S7SmL<Oo+Re?-yV@-6P^@r8*3V#_ zA7zcPOFL)R*1pJ=`}-#FnVr@2dE39F)Ls7xvg`@-$+GEbD-W4;C_g;TQl<Oq=#E{F zCB7Xncw~L_^2f`4IlgzZ$}{WS7iYaq_b!mLFP{^(Ir?MC;^mc(-l_k4zH`>ntW9cJ zyv||#iRbz(%ciL3ZTUI<Y{{(aoso0XFFx8P#?TVZtuOL0GNP&Y>Ak5g`h97h{i;`V zW5pXzNKN#~w(s3me0$UD8+x;~zvy%M{jRjJI3Hu>{N#>@+}f`i=glkaZs)!VU2}Yw z-Rp|XyWVGhoaf;W*Lb(-=?Sr0^_S-LTh+O|ezo@h^PPu;=KagN$$z>c>7=kub&cfr z`z8PX+g$(H*XNUGJo8#{)aS#U@;R$6{1=(VY?S}(;)6XC3LE+6mn{gq>eiEQW_LaJ zy-vNlr=jPbPfxY?Z2xJ?AFA<glWwVWf6XV3%eVcPzkQp#`L5f;m$${<NBZnf{Tp#H zoAvwMiui4}OV(eWdwte^x9&*YA1|-?%dNX$uW9l2`NjulPMlhByD2Y3H*~7z#Nba~ zX1z*X{kW&lsPM6iTHc(D!q!K6*8Oi)it<!~Z~HDiEGt`dH|*id*<y9OCp2oaZCZ6* zODZgL#_Mghuf8WfIjo#%xSG{|{=b{fqFoWkl@HELO%eR;%ERz+?jz2ECwp&ZExh_8 z{C>S*?dg)ZpPxj#wM5Eq{(YSnbw2N`^~CoVex5s5S=GD0ZTbFhu4iwX_8(l$wplHU zmsiXD#O3T?rf-g4P;<_-TWz_2&d;NdxLnsfo%o<8?W(biUGa>cvCoA?9{iFu2=xwC z-I;GR|J|P{fu4(XRs`HhJpa*l%dERyoom%EZ7mC*9{0Nc;miJmmgUc5=EZ-u$^N}& zY248&y}jRNx}E>9z4{+0kSxl+&2Sa%ia7u2fy~Z2mDzmxNtx%Dig0U9d;d2?E0Qz4 zXYx~fo#(Av^>=J^Dr}ec`{Qu>rtZuONldn{zMZ&k_ea;}?^^w=XWwS>#9PlPt-Thw z+-Yvj+vFR}hhGG4XV*>N{^ZC{;k<Pl3O*cXHi}QqEZDd8qpn!(_KwiKVS!pZLK?q^ z?{lfV=Dz-UJo~?+#;fNYRJfg4cJ%PKxp&;VBXuS2=h*Ch|0;Gt?a$zfU%>@+JH9%* zt(8Ce>&4eQk^jyyz0EH9k#XzZy=m7rM;HHklxZFsQK4b+Ha)VSZp&BYd$+&HWiPrG zu&?EJn7Bst8lCLL*EW4U5%x>}wg0q<Pq)=}zy7xT?ee2*#E!Tf5sJ0HrThEK@(*9w zFK_or&-oN_&3*myXS}9&H=VyeYyUClt8$CZ&M{jOf9iQiZtE0#*$F?jyqk(2Zs(Sq zYck6;Fnh<!61(Z2PrANbwA8c1E8+gh+Apz}ru!&gew%yZtE@$BLz?ky!$%7R|9pM7 ze^=>!F8}uirJqCMe!nuEv}p2*z;$iW-)&cZRgntGJD@z@=Fra5&+qKYuV40H%lzBT z#b^7oCAJg^XjiW-`7M7-eyUE;B+<QL1txzr_S(I7bqhPE&Drr=_Rm{|vuS3J-`D@N z{ww`$`x4&P<$Le_d?tJE)(<hyi=KDFzL|O7nsF;nYx~r_y?&pq3KbtWspfX<m>u0* z{CHvSm$)mlkJ^eAhcDfIXXoo2QGTs+ljeC_l>d~uD^~J2=$Y#2+aeY<&kW9{nI#uI zK4?>W|MIkLPftI5dAc@G*xc{Q-28irnpT|~j1s49eSF|x51+9{{34s!XXO{~Z}`Eo zo%Q+Erw5<eShcH}n-*TrTfaIZA<*vqKg&kO#*%+)Hupv8mZ|*Z0C`|#_54RSkDaet z;v3KFAJ2R4y7``S_W%F-Px`G^?EOM_+IH~=90}hRZ`PCwnKEzw_mJz|6}H=1p36^X z&ko%?)w=BEBqc`I8P`+gQoE)u{JZ?^)%c`|i_`lr<)j(U+wr?o=DFmyF8#LU`rlml z{(8E)X3yK?Nx#*Cw}yoFZ<T(*@#OMxyQfLVTo;MCW?qQbtNGe+X1<7p#pY<aGklGG z4r%4{&gw4QE?{XMr2O^Ho9o5<FV&<KSKYrl`yoHi_N8p`-2U<0=Qf^9p1HeN@0^5s zsMD&7J%1k@NDwQFKJl^mcxBPc$-D0AuygtS7S*sQ2ARs($B<Ss!*MQGX@=$QrSAlb zCqI7Pcey65c-NJ8hfeeF&B@l?CpK?iQphC@P>HnUg^JeHH7U`uN1M7ny7udXiaMSc z!wcK2_RL%_JK^Wz8us+KY3!Sunc0JH`#$|Q``z-NXP(WPyQINyp1tSko4PLx+}R%~ zJ$j?Z9#FCCc1Njl#J9gjpyZx(va4*mbElGO#J?X!+m_}fXB-OHefpynm*4NF+7_{q za%c1=NBJ*G{W{HL_D!G9Nza0BwVFho&2xSIYVF>4#bFh@j&o<nC!Foiju78_ZmsZC zkr0mpj@8xcpPgooH%hw8vHP^(PkBA|^tx&6n@?w-jemSGs$WP@{@}zf%4O3Z2m8g_ z_^!UWwu7VlfxPa&#B$4<pT2$g@@?OWg`CcX%Pc(KOg_PTG=IbHIoT~@ysC;?jZ>?` zjm#?7+<n^dXS(;n$O%smz7dj^^Y&?$IAqWF{6RkZTfO7zb9R=rnHAr<@Z_1=o|~_H zcb`5v)x3SVIs0?t)$<Y`AM926=D8$i<EFCdlNU>O-9K<^#nv;oP5ZB#@5w8-RBGrx z7<u98!8b;48WVZ4OgcXFAHF$%+x>S%d!l|VEm3;za%qE?^S!*!+wMMn(z(5Dx%oF& zNeP}9!wLUoe)4B8x+V~1a^>Bmb*qz3cBy>xeA4{C=D-x+d$m(f3-9^aux7)F;(}e- zl?J<c@@!^2<mXdYvTNF_{{2>LU$|BEPo1}RneKPHN@rfWw*6n@r(++!Y<qCVXw!@R zYwUOTy;WLR&a||9+P2+GY<6$F(!1vM<~~npbx@_V`}D@CO_%E`x%|rY`O~KV<Na-{ zmc--xc=o5a>+gfiwk-cC^VUA|{M)B_&;PpLJKlKs-K3ajy$@gNZtBsQ7xPQSe$J1^ z(7oY;LNZC^o_f1gzlaI_Rx$b)|9Ixs+G%&6-Z*xf?*!N4*KEr}PdDFGUFOJ>zon{K zY;)9xzc0#mpZ>@tZlrgiFwT9|)Ro7+e7jt0WU@Y}B2N4A36*Ev5_NWejkT-SE=id< zscia`d{9|*#ICa^!o2BxS$$f$<+gx=Tl(K0tm$2Py7}hP^t<!+-2N7O>rCe1XYppY zWBb<XrNu3|yvHwuZ{?YGS-UTtjPchOfA|x-Y@+A<qqP=Q-!x9k#k+MXslL%$c_8av zz~q*DoIH`XEvo8fH)8ulocInKY?^!hRN!I8xepI_@UN5$x_h~_^2jk^>B_&quS<rf z%al65z7^YdJoenKGb>^jYY2ukP2B1(lyG;~vu!u(s;molKkis9?Ed${FS&esQ`4ze zSBGC-<}0lgzV6M(Z^peo$Lh`J6-z#s2rrj8$aqk0{Xwtl%iljen)ZB#?Q<S;JKLFC z*m&RQdEQxbW?SwRd83xMlWl+hw3_P&8p*qN-~=OoLP2q#fAq1JB~@GYw$yUE9W~dI z%Ga;Fz4&e1)0f|?Lz99QU3_?%&u#k8*q)v>JpEf=zx@8%r|{OdpK7YAk_{85OnLHg zoA6|z-s5)FXDXgdcJJYq6t}syZn^#a_0#=Kwe~d_zCGJ0m-}67_rE%B-`$>`ZH&jZ zot$iYD<>u<X5IPcHC-DSHCVRWZd-M)3)JG+Zrx{Uzi#7hnf?<eP9>aqXZSyMqS6Jy zjB?LuJF9M*<(1Dlu7CU1Rq;~I&q5n_C!IWT>cQu{`N1X|R=D5(zU0`_tdBp_Kh*qk zFPr|zP%1Rr{{Jqs>HZI|9s&h+VE5vPe}{{9pWYa<Y@+A+^VO4F#paj(J+u7X@w4kc zWIa4`wexeu{N=I-D-Ay@^`EWpad21Q-leNxabdsS`LyQ;=PS-Vw3%;x)8#s@bK0-k zuBHBbeER3@P5U>#*zH<2J-O3IdGfvPs^Wj2Dj#JX4^&yuaaXm{=kJAIb@mA_oQ|<t zoqz4qsifMmRycZv-TmcVTQ}}z>A$!l>bIuF{|Eb|-zS&8zseJ3+2LPan^kU^S6aI3 zNbqz2kCorgb6>Sz75?*c#_i9N&tF=sS5EDo{&ezjyN|C=zXy#tsB2pMUsAX97bw%W zn(7Pe*S+_y=#J9q6OYz=|M$wO(u)7`<Iwuwd)6J7Km7UC6Va(&VM$@nBU|-MTy1<0 z&g{J<nl)KuvdbFdX_?W>ZpQjGN=ST(zShs2$sTbjxzpco`is1IT>k!FT<7ksnYOL? zc9HiB-6Q2);Tc^O4Nb=E+o$iAP4Ah^8SndGZvMTEyXVvx8c1xYVW{?h_jUH{`*)8D zKg=vGh?_fM|1)0GnHLk=;(g*2A8~(~KCL_Y^c}CF`ziPCep%<Qm-*$)sq`DAIpW%K z@eeOwUK4rr)rT#c^j~f7-hZ*mFZ)&4n$ugpT^5<u+TnKfmVbTj^}^zpvpwI<_W84| z;+RVR#@%yls>{A^&avEdG+q76Hxcc_msdU5v+KkU+t7E3S-V%-*>2yk!w)o~nJyQ? zxw6Ul*vUoj#SFn!#m;s6*Z;JZ=FdwheSg(%@2uYCKQ1*a3>Nphm=wl6>&~4P&58TA zewn?a9c1;vneL+AVJWp=s;>RpF>N8I^IJW2cYU>e9mYpr8h49SbH{U>7k=)4At{Vo z>5$TlD^-*3KJD-Y59jWB(DulDgI<+vy!@|OjoNHU6W;#$u}yMkoeHPD+6J{O-qfzC z8+Xghe|+{~<)1r+v(D%Et$ww(V)0Yyvgyh}D>N-)MWRfmYz@o?HS$5FXQbP-yQ+)= z&wG+ze)o=)-a4)5=;@oWedmkPD|W5ce|6(#vdQe5J>SZ=Jm30ky=X?fQcwZcxf%{m zzQoY=p?_+Ar7se5pO~3)E9$&<{Jukn^2ImlRn3jpG0QVAZ(VNP^!dfj#U^uaPSM-C z+hE<x9X0RWUGBIaoawLHH6<bPeCm=|kHyCi$;F)8mE$cdZ03`2uFrB!cbt2xkZ8`z zgYr9-ZMbiVm#X~b5d0|kW!3fWiw_rn-pc>c9+Wd#(-}p$wT?Y{*M0KLsV5uH%RNqd z=GwpQ|FvV=e`LINU(+AwzjV@6n_Fdx0T({#cofLl70>w4fB5C?1^W87UnZSiFaCe& zgDvx$Ha9deH_yCZYNy&YWx?a+vX=7;?<v3C_xJ4WKcDaa2gTB=mXMDgvs)+1GPi*$ zgopC&pReroH+<8WD3=*r1Bud?Y>teMXKHiwraEa|%*(Sr7iX89S^Yk@uD^U=W&78Q zuUAH`TD3H{GySl!s&4Bt<Jm?#J|@h|{xoN4ZfAZ_!7cxTFV!0R9PHlxFf=`Nb-~v+ z*Z!1!H21zWb6cuZ{=fUP*YwAoKf5%4+Y;WL)6@@rULI_Ju_P^cUj8SWW@-LyOLzq} zEm)UJvsy6CxK<}s9=>z-w9U~)uMTN$fA|0JTKP}6rmx><S7m$EY4y(1`$e_u+LmkA z2LASYxA^6mWjz%IEX?nvU$kYp9?|0RGcSIS;PpgAZrwLf>-q7IosaWwzCZKUSn{!q zbJBd5Jl*2e(cd)J6|35OmYM^qd_kQBs~VHPQs0V`w<>|=5nS(O{ABCDQq$7$gQIVr zZPbF=vo{UfC%$%{bVGfj)YGgTE1gcR-_w>J_iNENnfuP0XP%X~o+DGg_xF0S5bb|% zi?iM?f3W4kj%ANuM6OqVDBoWE<IKaFx5@X`Rr2`DoV&GR>y<qVm(A9m^5>LyMV!7x z`Tt$BpKYFHyznW@qSx-x5o>=4gGai=s(&t={_^?;dH(u82JC+F1uwU9?~6T9%z1vJ zS{85lwEdSCajEX-GD^sJzH#oBIaeobkJ{_HzG|<|s(?Qe!5Q@><9XA{zUQ-S++Au| z?C1S5^j{yjC*80)oL5aztI<mIRYc6fC*gI6ilbkdfre5*UFOAk{N36j^@~Ai>$3B_ zeeW~l>RzPII%b}F{-f>Ayxm`ZF9o%^LidIRu1^9D82o(dRgq`8srAIpi9WgJQ}wp) zu2|tDSg6jroZYta{Nz2i{)EmtpLOnBvi0V>X;1G>1(mH&`}LPQK4p_z7w}1Y_lG~l z@mHS3n_bS!vtG7+zTb0e>)R1)J49S2++`Ip+xz~N@5Kd+K>cme{`EiRKNqU=dC;lq zzv0ctRFgHAE-d3x-TzNw-sj!tj(Zq(^!KY<S<Sk#AjInI>m%;6_KV)W&3&sE>cVv( zQNnH8YC~%oK887d%hg|NnwZVGabR}!y(d?9$1M$88I@zXwe{ou-se+ytq<5;lDqr# zWF}}6L?R~9fZa^y!8P{$)K42v?g@FV`cAug{@tfPryAYf7Fd5mV4MFupD5<<u?so( z6f{1Vtgc!0MnYUW<U!ERq7*UxciaAoyJTf)tqxzm%y+g~$hw%D?}~I%uRgD~#X9Hk zHmm&Uy{T?D!%u^=4!BVg|M$<-<G1vD?9;7pl`gaB?aB`^VLKz25K^;v(Z+Abx6aGm zKjF`u-X$uB8Io^5Imvqa{LRg68w(aDy0}WZWvoa%u(dyEDbM2S^20N1ZyWf{GvPTr zZ+>x5&?H6)Pft&|eCylatKZE@d~-X!PVD!$nfBi0h1Z|IUbJJ!j+pt^mqtmuUh7B+ zSsUo{t4fG_m)?WM+4389s}xTDAGhuA7U|DbXBKBh1n>5q^d=?kP>-ZRmdKx9+97K= zVs{;wTkiDqRKaE6f*%G;mL0mccS90u%{R#@8jR=dye}}%`#*bYZOGfD-V<hUaEl%I z^t8Zc_RWi@rZl?CHS)<W$c@&By!5#=%Hv?>=IT@T4xgV}w{17iMu&>61<%Z9`d38k zxVzM&Y~O#mU1hCvtrunnOV~=u)k!d|Gfw+-|9_ii@Pn_{Gh;TX?D@>+Qk}=dZQZ>2 z(XFi)cALvsv80}MI^GwsTI^26;>rnyF9c*Pne6{CoSt@Yj-`MU*WtE<7ZyHHoxYpf z>!7Am>-q5bng3si>vF}{B>pRpyIZY)W)A1!wu$$a^QR^yC7c$UVIkP`=ga&n&g~1_ z`Ll9wF!V|t{POa`B32R2NuRTMn9Xt;JSRVRIz91KNX7r!jQjVBOQT)3FYbtN30_>e za{a!hX}V{<H%goD5}Q>YvYgNQUd?5j*|Us}-tkXcR-OHoZFiaDWVH>|=GAdEg8TkS zDJd88`!cjM%hd?j{g?Uo{{I3m(HB=Z<0_9DmqvSlM#Wi|i(8fPRDEgKU|{U9S~RE9 zPFaCL&8LCiu3@V7!<*@MgO_i=u~S&C>cpS->-Rm%m~ED(uxpj4@aN~UqO8j9hlKri zZ1>{_&4?WN<|tFN)~@!!70rkp7v3x`o~}N>MLfRc`#od*<fs$L>?to_rpXt0bX2Cr zEpG^}7t`hX_|YJZr)IAD|1bsy?nj`t0Dla7<lj#-dJCD3xqNy}G&?8fhhMK*`5WKt z`K7fbi&fd}z{$z)?*A8+<37j8{NT8J;ys(<2mQNy<aiAY1*EyV#dqiLms|2cWa6R3 zI~F^hioHm`nDmgZ-BRG$_WL@vvp=0+yt)5BZ}Ib4is?sn%`Y#T*}P_6CEK~V#sB~5 zE_)y%_<wt@w2J!S4-c=)UkMV}nmzk(dGPXC(_3^OOne|?&Ub2h`}295)BYbk_~F~_ z52y7%T#LT8B~g)edB>0ap{vjQHr`#jdEeT)zYiX{78fzZfBF0UneB}8w&`z=uztUv zUnjSIf8Mv{zXU+D(I%^|b*rd29Bz9SIpwO9nTh-BUm5>pwb$v`U0mM(HP`lYkL0Y? zVUhQzNo!iT>MVNjMW`+DUiFPD&6nl2<#Ky^&dWYOH*9@d)z>pO8`fM~(pg#me39$5 z?N8l6b2=FzYo}Y3p4wAV_4(|)?9bb7E9ml`n^*dKovy8dG0*3^(_*@J_P>9_!s4*I zY(v@F^jpQk_H*UEj?{7a@pEuD@37DdS;xc9ci`XO>v_cw8h&1V*zl*t*Q4Y0^orGC zru*gWcucc*-AmJ3$Ch4FvgLRE_Dh!@{Hgr>{FSC@_MuMUXD@CEsoGr6W7M#4JyPD< z>X@S=K56pV*{>fzD!Ny8LE-a5x9fBF?JrC&UOM5=j+e`Fp6}z`UC=159j=yhghM0j z&8_RKtWW>%JAHck+4b>tGvDrAaWyDNVY%t7)6>oQjbgrD_J4NWwR_!KYg5rS9z*_~ zJsnNKE`OX$Oj^=~Q`z}unBU=-$?yw!x9ZE6H`C7@viW`b+nW66e#L#)+~rRGKk~kv z&(ZCe>3u%!u%3rgwS(1mUtrl$p!mFC_q^5HFX%)h*!{ax_V3#)^T5EH_5WXqvg$7a zr40eGX@6CZ39Fx3zcp)T?a%ehCr`GdieJm$o67e5_xtDXb>3KQQ&$(B7rUEvYkL3B z;$Lqz=j7k@Jh%4l<Kv&pqfbs!HAvw&GjHzSnMDyd-cP^1w*@pa82)?Fs?gQT>in#y zYNy{TsQ<Cy`7IyM#!E|eIeooDSEbb1R$cjeeVYFK{kLoNVvY9O{mM93J10(Tj#Q|2 zlHlFGN2)S>JKo!EzJD%QNa&2~##-N*M$eKi&-*j???d(-5838RO0aPG37*afSu37- zk;yFA==sF0x8~VyC|{q-Z5CbSP*%!&_K3^(_tw^tk<VJVb)&16*_uNqX<ehX7`XRT zCAH1+w=;b2|K;cdmW<2CWbS-9t$*#!|9-Q)7G?J{r?=R-9Mn|$_r8(+jH7;-zee4o z7R$=Y>+7ENScq--)37Gi`t$2GksuArd<=g#Dl4zeKiw-bN9oaj8NP~#tT*=DytVSf zzmNQ%-TrM%*3CZj>A{}Ie4leFAGvs^+5K9-et+A~&xtn-rn3dUy|Iz`u)&(u+WaDO zl!7e2yh>en{O6m^&qQk8eY+a|>}J~ieR=bBPds+(HOkkYX>oDZ-}qfAb$sUcIL_P8 ze?C3;)|Sp+UtbsB&fRWU|F7mYQwXRS>|OQM=-@$vWVSc=c$M9Dl;2;u@>y-aY1WS? zzb0MZ@jdRdL-L!58ygP({r&#_{TQ9<QzFydF3;P&=|!oR7uVh0<=b@~L_teG3aS=P z(@p%4@cGPz*xCyB{#nK>OP9}{EH_2#>Ab(U-v0f*u&VUM#lv%so`^lxXS&>7#+c2j zT<^lVPa+GZhh4P4(s;P=so<^o`qOM&XCAo!zy7M~^;@B!>E^{*d#_}#pUHS@yME0F z$HubIKMx#>A6)!?|L~#KXACOcm2Vn!RF2Fk)3?1F^Dq1RyQa7AAGsF4I(#GIbGm)e zlIT+{uURq*q?f(9e^8zIy_(7nv-;T|ZML3U7QFg!h1lQc3Yo{32}!<*ss@!E8Wwv) zHYPnY$$xum=5!u*o`%cIV{f~ssqOi#_nk)~fvx*8=h~>qpm*~tzj(Rrt=jJ|^YKA* zNYvh2F;!<mrOju3Z$CGW_wn(=?(#dgpVQvNAHaU_>8p#ymzMAObwSatr)$B}+fOAw zU-T~7_gl@Wn{C&fzQZRTKH6~jAw$BaCns5}l$Dh3X($*^W}l|N+_A{$x%bpZudl7W zS$*C%=1k_N5``C^QuA(a?fxw!tXcoVfc@Q`$zSj8`WU^lNN)A-CnqQ8+}hIV)+-fw z&iQTIlBI%{#cJm7?)$&e-TuKhMaBO58qcr<y@kmVcXrg<ms`)ha${rjmkR-tc9lL} zZdLjz_V~Wq-xc5QmVe$;yR+zNM_=Ev<l}t|b8dh1pI4V>cl_ONYx%uGo=X|rx2-R> zntSBfv1fadmDvRa1>Ia+S{Pp}Y?rJ0@%FKtfmvf>L!n#`YeEmpVtxt1@O}Guj>Q;U zTA#C>zsD~wVE1zQy$38Ro~9QF_4FT<U~_w~ZNK_n!XAcW><LTaZtC&&Oh2HJmwb13 z*;^x?!v>ekk4pABH}y6wn00J(w!dVg<&${O0<()55^af3EKXLtxUgKjcu`LN24t#! z{rih%;6*8|yYFs3Fzx;R<(F=4wb_)&92*q8{^ql!qg``${IC0FmhTs}x60;qfxyGX z@3$+w{TH&FZ~3;Ig-w?|*Y`?mPCA?Vu4jUPpGoGScl-aePX2!1|8&w(jT1|%!tcM| zmU~;msw89G?P<Ev(~Q&4O_(_G;NI`|y#N3EyE1q=-<<mge?Q*-@yDIckcuJ><6}O{ z-!~s#G5<4bo6OT)R$dViGmigGm*HzSJ^geAc!6AAo|4iTJAZ@g2W=`Y#7tcrWxC^M zS{EB@p>o0E-M7!OTi>p=u(>nmP{EIa&$FMOpMCkWtPO|xeV))&0wIf7rZ#xx<$SMt zZ?2-!^5shj&*6j%3mkbQ3>s#cW;4y4<LjAnYC`9d{U11!<#l}LA9c^TT4Q3%9+L1* zdT&O6-HbQ-x6=GicXf9Bi3||9Q?>f%ggc`8dH1#j?cJq&mYtP#;>3xLy;7zU1_=y- zfq^3Waeuz^>aBga^H=W7f6^07=IocrIKODy`VBvo1pc#p*ZDPT>VCiC%#^iF!7eT} zK@*i+U)<WN-OR?j$aAvV&3qA=lUpvcUH<oB?Y8B-X(9_^@AfGrHJ(Y9u2}v){>8PA zf$v`0HGXwBdZXug<oVPcMyCUgc8OMgy&7&=@<O2a`MI-}Cc2A^{RGQ*f3dxsY$cq& z=g92Mr-TjCEn*jUP2BS+@|D=u-4=rPudWDG-j;XQYj4$8jx%q=B)VVr1Rq(;<EOgk zq;|G(#`hGS?bG&k>iL%}$@sMTPx8(65@plXA3X-G<IB!yY6?EGx99$kPu;3AoNJt$ zZz-}^$cU_u?6-35+x)3J#ZS}HwPs#Z@R7Mjbt%86T}}~Q=`&UO%;HB4MWQPtW*ogK zyZeV{?A%Gx+-fS~--8Rfc1$jul)OL1!9ml>YgT!iWtZr37lsrWTgO@FEL6?Kd_45t zEkEd}l$RRw@;J|<{dWx_!}l$}Fy-~HTBlEs@0%xigs`lBU7mdG)%1+eYg41Y9QCq# zEK;cM9;p?=*|erOW=DeB(!z&2FCzs)mNKP&$)Eqk^@Hq}-rBBP#{%nCmx!0Qy%Ik@ zTf@Tjj^+xsukZL26+UyURNusK!m6+*c_w3v$qH}Y*vAuXibS*>Pd-pMw`SIXBVRLj zB|HQzCVcmV<LSdb*%c*~;<vxgVSaFjfA^1fMX6S0RT6V8Jm&pLbo#U{wLa<CjF)eA zB$NjhO>GK3vQ}nF{%;$7o0^%a^5>sFcq#I%Zo`z*f`=>j#a2#Nn>6jvi8&Mg$lJ!N zylw55ypqVUS)70Qw`Ui>$b2x2?vKATbGi71R%O9*?WpPLX|>009;|<U)9(0+zc0FV zX8toNHIWKhr`|6-Y5IoU=bZcwY9=)<SfwlZ^Jkfym*2M3pXwh2E9XqGxjEVNq-n{@ zFwi<x%9fEnFyK+Xee&D!9!X~xmzMU^f`Wn@r(b@lVrFJ`{CV-*CwE_#?Ak3SC@468 w+GEM(9UUDp-nDa-l)%d>J34ke_|M4Gc=cQ4jw??X7#J8lUHx3vIVCg!0QvW}7ytkO literal 0 HcmV?d00001 -- GitLab