{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Symbolisches Rechnen mit SymPy\n", "\n", "[SymPy](http://www.sympy.org) ist eine Bibliothek für symbolisches Rechnen in Python." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Variablen und symblische Ausdrücke\n", "\n", "Als allererste Zutat für symblische Ausdrücke müssen Variablen definiert werden.\n", "Hierfür gibt es entweder die einfache `from sympy.abc import x` Variante,\n", "oder über die `sympy.symbols` Funktion werden Name(n) und eventuell spezielle Abschätzungen (\"ganzzahlig\", ...) festgelegt." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [], "source": [ "from __future__ import division\n", "import sympy as sy" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [], "source": [ "from sympy.abc import x, y" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "sympy.core.symbol.Symbol" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ein einfacher, erster Ausdruck:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "x + y" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x + y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "... und dessen Typ ist (ein wenig überraschend?) `Add`." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "sympy.core.add.Add" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(x + y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Das liegt daran, dass ein symbolischer Ausdruck ein Baum von Operationen mit Argumenten ist.\n", "Die Wurzel ist in diesem Fall die Addition, und die beiden Variablen sind die Argumente der Addition." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Zusammensetzung eines anderen, größeren Ausdrucks:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "(2*x**2 + 3)/(y + 5)" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(2*x**2 + 3) / (y + 5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Zuweisung an eine Variable und Auswertung durch Substitution:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "885/(y + 5)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ex1 = (2*x**2 + 3) / (y + 5)\n", "ex1.subs(x, 21)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "30.0982800982801" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ex1.subs({x : 11, y : 3.14})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`.evalf()` wertet Ausdrücke numerisch aus:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "sqrt(2)*sqrt(sin(x))/pi" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sympy import pi, sin, sqrt\n", "ex2 = sqrt(2 * sin(x)) / pi\n", "ex2" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "0.412937855327941" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ex2.evalf(subs = {x : 1})" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "0.4129378553279408383569413918993854348289426830297614114255099495993100683862339505790006113904633237" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ex2.evalf(100, subs = {x : 1})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Sympy's \"`srepr`\" Funktion zeigt den Aufbau des Ausdrucks als Komposition aller Funktionen an:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "\"Mul(Add(Mul(Integer(2), Pow(Symbol('x'), Integer(2))), Integer(3)), Pow(Add(Symbol('y'), Integer(5)), Integer(-1)))\"" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sy.srepr(ex1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2D-Text Darstellung\n", "\n", "Der Ausdruck wird in [ASCII-Art](http://en.wikipedia.org/wiki/ASCII_art) umgewandelt." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 2 \n", "2⋅x + 3\n", "────────\n", " y + 5 \n" ] } ], "source": [ "sy.pprint(ex1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### LaTeX Konvertierung und Darstellung\n", "\n", "Sympy's `latex()` Funktion konvertiert den Ausdruck zu einem entsprechenden LaTeX-Formel string.\n", "Anschließend zeigt die `Math()` Funktion von IPython diese LaTeX Formel hier im Notebook an." ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "'\\\\frac{2 x^{2} + 3}{y + 5}'" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sy.latex(ex1)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/latex": [ "$$\\frac{2 x^{2} + 3}{y + 5}$$" ], "text/plain": [ "" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.display import Math\n", "Math(sy.latex(ex1))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## IPython Notebook Support für SymPy Ausdrücke\n", "\n", "Durch einmaliges Ausführen von `init_printing()` werden alle SymPy Ausdrücke automatisch in $\\LaTeX{}$ dargestellt." ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false }, "outputs": [], "source": [ "from sympy import init_printing\n", "init_printing()" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEQAAAAzBAMAAADcGrP4AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIpm7MhCriUTv3c12\nVGZoascqAAAACXBIWXMAAA7EAAAOxAGVKw4bAAACAklEQVQ4Ed2VMWvbQBiGX8eWZMuRo3hpOrSY\nuiRDaFKSNEMXm/yB3uShZDBZu5gUmqUQD4HSyS5ZUryYDs2QQDzXBGRDksVg/4GAf4FpoYbShKgn\nnT73Tshkzw137/feo+/TibsTILXdNSZFUdKw9VaUL3mmnfglhVHSrMb+RPmKZ42VkIJsfoMkTGci\nfRHbez8AtDL2qzSxSyIYs7DuAJ0hVQ+cTC4QliNEf4C/QKoJ/Xcw8wkHQhHyuardAOnxBEmcX79S\nEfiFuGeOsX25cOWkXPdnGHlb8Z1aRatkTs2WmPZ6KoRH35jvfofBjLFlRyAwjjx3JgcN6ZcTwGi3\nfzTa7bIwvnppup6ec7yeGhWaBwoDXjcHrt4UadobCXGZj2wBHYv1MetlDBohh8CZjdjx3mKzNijg\nKc3zkZARrFv+6VzXbZZ62yvDCCT5LF+VbFlSFtkLac0OGQ8s5F/unvZQFpy+SLy4Zy38UFWmILRV\n0h86U4jJntSnAf+3bRjRug4eixNAhfRRtygnMqw6+sIgJM7Ui+/JTAvrKsKj13IWlnLADwzU47yq\nbPIaSwRXFRV6B+kO9NItY7Yu0hLSAFbFAoSPTcTLQhKSA06EE/R51IZCEpJF5ouClD7SuxESW9pR\n6nB8OXiEECUDD/SWRj+IacfZHMad8GOhONl7HnKk8B9wa5sChgfrqQAAAABJRU5ErkJggg==\n", "text/latex": [ "$$\\frac{2 x^{2} + 3}{y + 5}$$" ], "text/plain": [ " 2 \n", "2⋅x + 3\n", "────────\n", " y + 5 " ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ex1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Grafische Darstellung\n", "\n", "Den Baum des symbolischen Ausdruckt kann man auch grafisch Darstellen.\n", "Zuerst konvertiert `dotprint` den Ausdruck in das `dot`-Format zur Visualisierung von Graphen,\n", "und dann wird es mit dem passenden Linux Utility gerendert und dargestellt." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def expr_to_dotgraph(name, expr):\n", " from sympy.printing.dot import dotprint\n", "\n", " # input and output filenames\n", " import os\n", " fname = os.path.join(\"res\", name)\n", " fname_dot = fname + \".dot\"\n", " fname_svg = fname + \".svg\"\n", "\n", " # writing the output of dotprint to the given file\n", " with open(fname_dot, \"w\") as dot_file:\n", " dot_file.write(dotprint(expr))\n", "\n", " # rendering the *.dot to *.svg\n", " ! dot -Tsvg -o $fname_svg $fname_dot\n", "\n", " # showing the resulting *.svg file here in the notebook\n", " from IPython.display import SVG\n", " return SVG(filename = fname_svg)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "%3\n", "\n", "\n", "Mul(Add(Integer(3), Mul(Integer(2), Pow(Symbol(x), Integer(2)))), Pow(Add(Integer(5), Symbol(y)), NegativeOne()))_()\n", "\n", "Mul\n", "\n", "\n", "Pow(Add(Integer(5), Symbol(y)), NegativeOne())_(0,)\n", "\n", "Pow\n", "\n", "\n", "Mul(Add(Integer(3), Mul(Integer(2), Pow(Symbol(x), Integer(2)))), Pow(Add(Integer(5), Symbol(y)), NegativeOne()))_()->Pow(Add(Integer(5), Symbol(y)), NegativeOne())_(0,)\n", "\n", "\n", "\n", "\n", "Add(Integer(3), Mul(Integer(2), Pow(Symbol(x), Integer(2))))_(1,)\n", "\n", "Add\n", "\n", "\n", "Mul(Add(Integer(3), Mul(Integer(2), Pow(Symbol(x), Integer(2)))), Pow(Add(Integer(5), Symbol(y)), NegativeOne()))_()->Add(Integer(3), Mul(Integer(2), Pow(Symbol(x), Integer(2))))_(1,)\n", "\n", "\n", "\n", "\n", "Add(Integer(5), Symbol(y))_(0, 0)\n", "\n", "Add\n", "\n", "\n", "Pow(Add(Integer(5), Symbol(y)), NegativeOne())_(0,)->Add(Integer(5), Symbol(y))_(0, 0)\n", "\n", "\n", "\n", "\n", "NegativeOne()_(0, 1)\n", "\n", "-1\n", "\n", "\n", "Pow(Add(Integer(5), Symbol(y)), NegativeOne())_(0,)->NegativeOne()_(0, 1)\n", "\n", "\n", "\n", "\n", "Integer(5)_(0, 0, 0)\n", "\n", "5\n", "\n", "\n", "Add(Integer(5), Symbol(y))_(0, 0)->Integer(5)_(0, 0, 0)\n", "\n", "\n", "\n", "\n", "Symbol(y)_(0, 0, 1)\n", "\n", "y\n", "\n", "\n", "Add(Integer(5), Symbol(y))_(0, 0)->Symbol(y)_(0, 0, 1)\n", "\n", "\n", "\n", "\n", "Integer(3)_(1, 0)\n", "\n", "3\n", "\n", "\n", "Add(Integer(3), Mul(Integer(2), Pow(Symbol(x), Integer(2))))_(1,)->Integer(3)_(1, 0)\n", "\n", "\n", "\n", "\n", "Mul(Integer(2), Pow(Symbol(x), Integer(2)))_(1, 1)\n", "\n", "Mul\n", "\n", "\n", "Add(Integer(3), Mul(Integer(2), Pow(Symbol(x), Integer(2))))_(1,)->Mul(Integer(2), Pow(Symbol(x), Integer(2)))_(1, 1)\n", "\n", "\n", "\n", "\n", "Integer(2)_(1, 1, 0)\n", "\n", "2\n", "\n", "\n", "Mul(Integer(2), Pow(Symbol(x), Integer(2)))_(1, 1)->Integer(2)_(1, 1, 0)\n", "\n", "\n", "\n", "\n", "Pow(Symbol(x), Integer(2))_(1, 1, 1)\n", "\n", "Pow\n", "\n", "\n", "Mul(Integer(2), Pow(Symbol(x), Integer(2)))_(1, 1)->Pow(Symbol(x), Integer(2))_(1, 1, 1)\n", "\n", "\n", "\n", "\n", "Symbol(x)_(1, 1, 1, 0)\n", "\n", "x\n", "\n", "\n", "Pow(Symbol(x), Integer(2))_(1, 1, 1)->Symbol(x)_(1, 1, 1, 0)\n", "\n", "\n", "\n", "\n", "Integer(2)_(1, 1, 1, 1)\n", "\n", "2\n", "\n", "\n", "Pow(Symbol(x), Integer(2))_(1, 1, 1)->Integer(2)_(1, 1, 1, 1)\n", "\n", "\n", "\n", "\n", "" ], "text/plain": [ "" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "expr_to_dotgraph(\"sympy-ex1\", ex1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Spezielle Variablen\n", "\n", "**Ganzzahlig:** $i \\in \\mathbb{Z}$:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "i = sy.symbols(\"i\", integer=True)\n", "i.is_integer" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(3*i + 1).is_integer" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "None\n" ] } ], "source": [ "print(i.is_nonnegative)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Reel und nicht negativ**: $t \\in\\mathbb{R}\\;\\bigwedge\\;t \\geq 0$" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n" ] } ], "source": [ "t = sy.symbols(\"t\", real=True, nonnegative=True)\n", "print((3*t).is_nonnegative)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n" ] } ], "source": [ "print(t.is_real)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "None\n" ] } ], "source": [ "print((i * t).is_integer)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n" ] } ], "source": [ "# squared value plus non-negative variable is non-negative\n", "print((i**2 + t).is_nonnegative)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Manipulieren eines Ausdrucks\n", "\n", "Hiervon gibt es verschiedene Varianten, je nach dem welche Art der Vereinfachung vorgenommen werden soll. \n", "\n", "* `.simplify()`: probiert intern einige Varianten, bewertet die Verbesserungen (wenn vorhanden), und sucht die beste aus.\n", "* `.expand()`: Ausmultiplizieren, ...\n", "* `.collect()`: Herausziehen eines oder mehrerer Faktoren bzw. Subausdrücke\n", "* `.factor()`: Faktorisieren\n", "* `.cancel()`: Kürzen\n", "* `.trigsimp()`: Trigonometrische Formeln\n", "* usw. [siehe Dokumentation](http://docs.sympy.org/latest/tutorial/simplification.html)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAN0AAAAUBAMAAAD7DSVVAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIma7zZnddlTvRIkQ\nMqvFy5UvAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAC3UlEQVRIDa2Wz2sTQRTHv7tJ86O7aYOiB0/b\nUj1HD14bcelBsARBEAo1heCPWzyUIgZbL4qgoNCTiPakR3NQvIhdoVBEKPkPtGIRL20OgiLV+t6b\nnclO88OLDzp5832fed+d7XRSwAnwj3CLCnCCfuBYXDjQD1C6YAcHM1zdVEh/ckQ9kVNCulG40Lth\noQLBTvUua/VuBKypSW8y9xjwy0Kki8jv7TUVvX/MlARzK/sLMr+jVH9rJwK8Os9sMicasDG7S7XX\nDOAokH57TVI9aAy4XhIsU9Ql6zP2AxYjevwHXLNJ0yjLfu8ZwBwwIklnMJgzQX6EHe7UkpnlhzNc\nsknTSPzSKwQ41QF+Xpr8CJsnUMf6zSM36mpi+51nkckOYfsNVaiYpWFkfL4Ff2HzuXrDMNgY+xF2\nglup8Jvu5UxZ5bbfBItEJgjTSPbnlglIBfQTOb/wAcfqNRIoNObX2c8t4wqrKrzI280VVW773WaR\nyAShG0H8clUCMks0ACfxBqvRLcmNnwf2I+wRPfXUJYpayxeNuJdheDUMp2UFnxd85JTJmPDCcGo5\nDD+xLH6FNmX5FZ7jYjHCackS2H1ZSRh16cRoXef2/rQfYAh7f8bvC7C6AvzQfWLMb2q/xPukfbQ0\nZ/s9Y1lIQ9h+w1UC+H0u0/4iFH7TVCLGctvbO0/qICxxXnLRIrKR4mw/fV4ShO3nlmkZn5cKUMO9\nbBsNEigMhnxJzssrpfP4YmkS+sa1/Wa4TGSCMI3k9zfUJMAjs0NwHw7/TLWdgAQKg2GU/AiTV6Vq\nGwvr5wKVQvvNPp0m6SyrRCYI3Wjo2/fP9IfcIoBfqjOzFflfG/PjvIJCY/Am/wSM2beUgmjUfiI4\nVf6wSdNICHX3zEluDV2YfQsb9p3JKOl1X/vFJGHu66TIeTd2fD/SPV9TUn8y/j5KWc/Q3Uew/t+i\nZkFs1J+MjRw6EoNCMCcYhHDtf/4/8RdIn7PB47hmVwAAAABJRU5ErkJggg==\n", "text/latex": [ "$$\\left(- x + 1\\right) \\left(x + 1\\right) \\left(5 x + 4\\right)$$" ], "text/plain": [ "(-x + 1)⋅(x + 1)⋅(5⋅x + 4)" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ex2 = (1 - x) * (4 + 5 * x) * (1 + x)\n", "ex2" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAALoAAAAWBAMAAACF/ptXAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEM3dMnaZVO+JqyJm\nu0Qehw73AAAACXBIWXMAAA7EAAAOxAGVKw4bAAACIElEQVRIDZ2TP2gUQRTGv70/rHt30UG4Ilbh\nDFiliViJcJVglZyQg2hhOglEjJWgXbCTg7MwRUCiQiwSi62sgh7YWARUBFtTaGHlBRQDEs/Z3Xlv\n3s4x5+k28+3ve983y+MOGH6i9pNhSGT9oyL5f+cKbniDUVyZ8ppjGct4650rxqVfXnNMw//txf3q\n7zFLfGPBPZ+jeXgwwhzHujw/Yqo4yvTlCq3SdfaGN3ORvXVWmcgFc57N4Nhg0GVvbpWlERcI1JZI\nmTMXzHmcAQobV42lt/6qlxsDyh0CX/E5k6HZkA3mucgAFYoD5/FG2bdU7c4YUDpz+30mqV0EU4M4\nOKOxGLq0uGO6+OhSu95DP6PUIoKpQRyc0biy124iWNj58pArrajFur1+5eWi2UbiUIsbJJ5mqGJC\n6b/JJF7PzxIRZx0zCLq1c8UpC6nFDRJPMvL5gAfYVHclMrqrJyMVHYSxNalFk1yQeJLBybPJM52k\nbsZK3medsKl5gMI77o4ajdNrjcbjDNig5WmG558Cm/vADwZCTCK99YTYut27GzTfbjKmZU1/u0Lp\nuyhleWd7+3ALmGsy0YI24AYNNxmTWAJmcavcR0tWsO4gVNdQVgy43Q3SrUDHDr9A7f7xnxP9as8y\noY7wbfUTdgWhFjdIHDiy09XlZyrYarX3LBLq0eD5qYX6Sk8ganGDxKEzYvwfJbc4OR93xv7yGojf\nvhyV/A9d8ofnWO4M5gAAAABJRU5ErkJggg==\n", "text/latex": [ "$$- 5 x^{3} - 4 x^{2} + 5 x + 4$$" ], "text/plain": [ " 3 2 \n", "- 5⋅x - 4⋅x + 5⋅x + 4" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ex3 = ex2.expand()\n", "ex3" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOAAAAAUBAMAAABmACzdAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEM3dMiJmu5l2VO9E\niat+9JXfAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAC3UlEQVRIDX2WP2gUQRTGv73c/+Tiku6QhONU\nbEQkIqLVlXY5EBILi6AkWAZEW68SEZLcFcKl0ESClSAaEBvBAysrz0ptjAiRBCEmIoh/IL73Zt7s\nDnt3A+57897vvm93djIrEI3MbJT7WbZu5tN+OTabs3l/ggHVsfCMjT3CltQyCz1apjRqbomIVCt9\ntzd2ATA62j6miR8fh8CYlFL2Qf0+is+AoCJFIoYPDrqSJy5nVcd2so0EQoVg+zsZlprcu+YBRakB\nE0v7VP8oPSJSn+71xFB4oTq2P1T3QDdZJcPgKU/PuBonaogCGx6WHhGjkkQXh00fVx3bvBhBXsaG\nOEH/Mqe8ulMSw1THEn0Nu2QoOqrSpqT84PL9phZsFMM7NCk06BIRvmGem0yMzrdrCFa23phFdguR\nrbMh6+i4SU/czZ4bqmjBRjG8QpPcrEf4htmKJXJh5h/GcbU5SQUaipXBhqyj4zy907C0X6xrwUYx\nXKfJ0JpHqJJ5h0VebyZoXMc7bIaPJHeGXTFcx9hpHkep+ZLuH6kFwaIqIIZTVB7uRESpWj2yUa1+\nZlreYXqPMiZoLNdDUaf7c1ixJiXW0UGGwKGmTl30DGOE/4TO8Auw2QF+6+8tNo6EIS0pMFVT0EUx\nfE1Ts2CO8A1HdEk36AlDpH/q7y32ZHf37w7AOjpo0xTDVRRCLdgohrppYoRv6DZNA5jEw8IeWub3\nDgP94Xub5gPwdu0WEsevGC4SXCKtGOGU5B3mu5a4hOzzkT+5Pf0UOAy/iGAdHfS0Eyvl27M6t3Hp\n1Ukq8a7iVYsRqpT/9uMrnWg1S2QWt8Ngp9WepzkPxfD+gDDW0dHvaOO+OWT6HG0iYM4pn5CGM4x0\npE4fq4ZNeoReh3dQj4Pu8I4XOfcwo6PIDU2S0Xyecp6FRwUVmQ4gpG90JKXLjCbJaO5lwAfYOg0g\nRNR/Jt1XST/9r0FiBzt0zmb9CQZI5z96pamVcCT6eQAAAABJRU5ErkJggg==\n", "text/latex": [ "$$- \\left(x - 1\\right) \\left(x + 1\\right) \\left(5 x + 4\\right)$$" ], "text/plain": [ "-(x - 1)⋅(x + 1)⋅(5⋅x + 4)" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ex3.factor()" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGkAAAA1BAMAAACw4NiFAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMnZUZs0Qu91E7yKJ\nmaurDqYVAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADXklEQVRIDc1WTUhUURT+ZsaZN+MbdSiCcuMg\n5UpTMipq4SwKgogmYugXewluymyQaBOhGC36gabatAgSKqFF+YKgWjlIBWGW/VCLTERqk4RTkhCR\n0zn33Tfz7nPGBjd1wbnn+873vXve5d7zBJQxcspQcEkgbFbGSxIqoqDp+aUQJYFgSv9ZktAl8s26\niJJgMCpk94uJy8x8ptrSEjEiSD2Zz7miqTyuScu4bFQEfscT8ypsNIB2B7bDa7jE4XYbi9kXFVPg\n67QBhC0gGPnj2dV8gsPzThLSBTQaQKAvl7sXscLybDZDkd6Ty3CguLBX5JasXaV3T3j2vaqdtLVe\nertA7dTlIYtQXR+ZDCQRhH8CwS4M2nugxYAObI2eKeTawmSoH15oE9D6UBUjzCPYBDzFS2OTBdW1\nNgjyYpcJjVxxVEUFAZSnAAO7BQonEntuJRITDHg3UMMROg7+hkaupOoCvnOWh7qWcOkGdqQ01cUV\nwvONHTxU11VJVcY01cW7sc6bQR0L3C6xG75+aCaV56wwPIrQjJbRY8LkWmuMydDjlc8803OHpueW\ndt+1VAj1IDBZ17BZQrvC8YHWGLBTsvOnIieKha5z4/SqpzdgOnIFTq+d1Zw6m7TmdhU60QK38qRT\n54pL6gAuz/8Fs4sYmX/4CuH37xax+jA+L8J1HjXiMNmXZP4jts2ncBaDKaYfFMhZVGXBI9picHa/\nJXH90g1GIO4iBezlX/mRsPNrrKBznD9uQzbrmOny0wiqZUgXvOw67FDboXUfH9rQmhWXP8Xk0edv\nEBiqT4EaPkLpUIS4BvprW/2oPkozDcVVwdXoN1BtLjfRJRr+sub1BpHH6a3TZb3BOMU0FFcZk/44\nWiIXqBGv4IY/kM2y7DR93YzwrM9k4HL5eog5Rgt6ZoCqNDd8OW7TWvAnBXqSSJxLJFo5FrvhyVB0\nPUrNlf7JqEpyw5eDXMREJVIrFK7cWh+44UsdVUg1Rwq6Qj1E03uh6Q6teSWKypjU0W74jEZ4DQvP\n3w39JsJmdQQHRMOXrhF6SlM37E6luCrSLOp8PQx97EWKG740gb42nbVtb2MSS1fFlx+fqLhc4bba\nnoucKJF2nRvbQrPr9B5xpAqeXpkv3pcL3xTLVvxWLvDhwF86wB910/uqA0kg0gAAAABJRU5ErkJg\ngg==\n", "text/latex": [ "$$\\frac{\\sin^{2}{\\left (x + 1 \\right )}}{\\cos^{2}{\\left (x + 1 \\right )}}$$" ], "text/plain": [ " 2 \n", "sin (x + 1)\n", "───────────\n", " 2 \n", "cos (x + 1)" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ex5 = sy.sin(1 + x)**2 / sy.cos(1+x)**2\n", "ex5" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGkAAAAZBAMAAADAjh3IAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMARBCZZlSr3XbNiSLv\nMrtOylR5AAAACXBIWXMAAA7EAAAOxAGVKw4bAAABzElEQVQ4EY2UO0jDUBSG/z7SV5raUQQxIIiI\nQyYdFRQVXERwElRQRHxAwUkECQoinbr46CKii5sZBHedHIQqIjq16CSI1BcqKvWemyb0JlVyILn3\n/Of/bk4uNwEcsXenOhQPacwIZTzYHJawoXw5JA9pOCk/ebC5LNKzS/IghHVuOvzT2l+tssdFuVCt\nxrWQwQafWA5qPI9SyR3SMeCnTW4Ua3WoJ6FLUCXdTJva6KX32SXWlfWhW3Is0s0Oi0KEqFZAerFr\nNImXSkU2yClBFaloEj3vkwPoS+u4Oble1S1vRGP9r83UUjMsRCrAivNMXEQbsKTL9rFIdAIt6NUX\nOOSgghmTOkODigfg1TQB4QFgFwfqcDVKSnEKSrrDwD3wYVHxJKBim6exbHbzNJsdo4TvhlLklH/b\nyOfw6KAqUvG9TEpPpJC/UCsp6hDKDy1PIVI+1uEGtJodjJ7nKinajcFIEcscclC0G+3Q4gUcXArP\nimnwvSWKMoMpxGcFdoDQtCGPp5u3rkpzI99j5GHBmvBPLa90m5lNBWY/J4Boriy7hj9OFPcdudyW\nIJ5Ov2HpNJYPTKVUnicEn2DgX4qg2IlcsKfOyT8L4t8/wC9mB3WogvJVQAAAAABJRU5ErkJggg==\n", "text/latex": [ "$$\\tan^{2}{\\left (x + 1 \\right )}$$" ], "text/plain": [ " 2 \n", "tan (x + 1)" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ex5.trigsimp()" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWMAAAAyBAMAAAB7Sac0AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA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\n", "text/latex": [ "$$\\log{\\left (a \\right )} - \\log{\\left (\\frac{1}{b} \\right )} + \\log{\\left (b \\right )} + \\log{\\left (a + 1 \\right )}$$" ], "text/plain": [ " ⎛1⎞ \n", "log(a) - log⎜─⎟ + log(b) + log(a + 1)\n", " ⎝b⎠ " ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a, b = sy.symbols('a b', positive=True)\n", "ex6 = sy.log(a) + sy.log(b) + sy.log(1 + a) - sy.log(1/b)\n", "ex6" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAI8AAAAcBAMAAACqv/FNAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMqvNiRDvuyJ2RN1U\nmWaBK2/dAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAC7klEQVQ4EZ1US2gTURQ902SSaWYSalfiJlmp\nVSmh0UX90AjdVIiEKroQaVWKgiKlIt1YGNxqbRalUqEQRdxaXNWFJTtFhBYVpCuzED+I0GL9UKrx\n3DeZSSZMQvHCe3PPufedd++bNwO0ttxEvnXCFqNhuy29xdSAtB01zrS13zXUzGsPDmijNd4sGhs1\n1MyLpQIjId+pWD8Ck/zkcT+sohUfaxYUvOMj68Bn8U3u3bm/jhXXcEs4fVlgTiYYde0qwpvabLrt\ny4B+3uMcJ0zSsR4+Eg4K2VXO97BGuD5NyljlNOaLAZGSS2zSeYj7Ar+5nDytgoMGX0vxAwIWORqF\nknmJ0GJM0w6/ui7+gkyuuUJoF6FTQr/jaBT6KAGx8DzLq1SkaoNuzfxCoSIjMxwUOjl7DHiQ+3JX\nkt9wGG9XRhDqmisJQZPDxGRuJq+QXygusceMjEFbQLTARhbVDR0n/8gOrWLogO7e6miZnV5CH0M0\nv1AiTSrZIUJmFtpa2zz2qrQevomriI9iKY91xfCelHgWZXUSZPxC1jypqaIIJZm2Hh+uCj0D4j9g\nFtij7gpFmPc+j6dcEs5kDl3IZFJ0ncPWVulNlURoqQj8Mtb0K2QAVhQZxVAHjiAmF0BMhC5CX1Og\noSJHiAlORX+M6Wn2SaPQUBZLwF+pzDG2xuos2Zvmby0mrSVtEYosI7ZhFYnFdlGohGuWvSHH4li0\nDH0T0fQLBf1C6rDlrY1DO4dQNnZwm63SeCVChcSTMLoxoQhO8tn04msqqwi/UFxIXr7Oym5M9u8B\n+io/ma6uhN519OY9nJ0rCxaT8gent3cVFXKF4ju/d3PXDpJys6sWLem35a2og3VJ7xn8iajwLZl7\nvUw8p/tJoCq1xjue76PV7frwAIHuvhX6Z1jhDUnQhmVusKjdQHhQ/UYSKQ9D75/NSbfAvhrpec1/\nbGoL01nppTvOiQasYOtf7YegJbCWA+kWZLN6X7ZYExiK5wPp/yP/ASCgsYoP810nAAAAAElFTkSu\nQmCC\n", "text/latex": [ "$$\\log{\\left (a b^{2} \\left(a + 1\\right) \\right )}$$" ], "text/plain": [ " ⎛ 2 ⎞\n", "log⎝a⋅b ⋅(a + 1)⎠" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ex6.simplify()" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGcAAAAqBAMAAABcqVh4AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAVO8Qq5l2zWYiRInd\nuzLEnmxuAAAACXBIWXMAAA7EAAAOxAGVKw4bAAACOklEQVRIDe1TPWsUURQ9w2QnuzObdUUsLMSo\nhRAQXxHSaLFY+NEFVBBkYTGaxiIBwW0UgiAEtNhG8KPYwcI2C6IoIlbGj8b8gyw2VpKVQGIhru/O\n+5j7xp1dIpbe4t1zz7ln3ps3d4C/C+/wzn3T5zd3bkLw36Ru7V9eRFQ/N+RTpDtVYtb2CqdZZWGg\nUGr6ZiUJPmKjxWuNw1oCUtN13vQJ7ZjXBr8kUDi5fUYRhYbKZj0gDOK57LJtgdLrN1XbsWoRB8Es\nr/AcuA/vh+EiVzV0qWdQkg8CC1X8NNwdA7yGQUn+wKuKnPYnsb+tubATdhXMmOrcVJykyh7v6+79\nQskZ02XFqrWwSPlEB/782acvcKzf16oxzVx5dK0BrOhnJerEmkyP3wkcx73Ge22gpE1+p7halg/e\n6DJtvEZFNIVneCv2MUGbIhFtei3QN+8nQS3l2aTxkBC4lVqiZvPmkWazBvgYp7OgXU1V0E4PgXXJ\nbTHaHg/Y1SDemS4y9QWZKr9ItGEuQr+NM8djcvOjwOfWnqCHOWuxO3liAYHI3F4wCSzD2wq/T/RK\nS3+aVqrreCDp20xCKCcivFCP/VNzV5e5oI83PT9zcUnyzkRgincybN9JcTeYBFxyqrTwWymWNy8P\nxOILw/mwWHO0MfmFRke56/T4i06ZU9wlXs8uwb20jIjSmmwws0u9Xkzr8CgIqZvZHd6aUc3sZuhR\npZrdUV0Z3fkTM1pOaWY3Rx5Mm9kdrOawZnZz5IH0b7WEgZPZdteqAAAAAElFTkSuQmCC\n", "text/latex": [ "$$\\frac{1}{x} \\left(3 x^{2} + x\\right)$$" ], "text/plain": [ " 2 \n", "3⋅x + x\n", "────────\n", " x " ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ex7 = (3*x**2 + x) / x\n", "ex7" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAADgAAAAQBAMAAACxV6F2AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIom7VJlmdt1E7xDN\nqzIhoty3AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAy0lEQVQYGWNgEFIyYcAFGAMY/BOwSbKsZmBg\n/8LA34As6Q7h7I39zcDAuZJh/wEskgzsQEkgQDUWqhMqyd3EwLC9VrKoAKIfRZJRI5qBW4GtneMA\nFkkGBq0JTBuYfrMIYJXkWs3NwGMAltI5c6brzJmzIDbIQYwCDMxfGBj4oTYyMCDbyf8bLPn+AVgn\nkECW5DJg4PjIsqGegX0DRBpZki2Bwb9gvoM9gxhUK7Ikw9RQS4a95dvDElAlWW/9uQYVQaJgOpGE\nEMyNCCYAl9003kw+TvcAAAAASUVORK5CYII=\n", "text/latex": [ "$$3 x + 1$$" ], "text/plain": [ "3⋅x + 1" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ex7.cancel()" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAREAAAAUBAMAAABYABS6AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIpmJdu8QRM1mu90y\nVKvMIHo8AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAD9UlEQVRIDaVWTYgbZRh+Jtn9MvmZzaBWUUFD\nt4oLirGNWmjRsRvqyd9Dq+Bhyu5C8WCCWhAUE/HgoFLS2oPiJYKie6jdooIHlXjw5GFHsPXQw261\noOLBWGUrpev6vDPfTCbJbnbFF+b7nud732/eZ973y0yAjex67Ti2UcDAutFKLGTtBBkB10lS+KXc\nv8Foaz4xcFP1wUJ/pGY3AFfvOhm5zkcgOW8tydxycg9gRgJUs98BcyBSu1+BUcJSS7PDeo4ndZpw\nS0lyy/GmAByPaUUjywlB0Y9dCZAtYWwVxaheaR2M73WM1SXYPMk6QfIIoc3pOVLScPVC35S3kTmI\nWlMvqkc1iJSkxDOoZDjJcJARPRz7VA9vGinZE9KB8caAx93Ba9ofKcmXuTCgZCCJMbnjQBikKtN1\nZH6aqraBsRKgquefZ2tShGKRkqPVO8jU5E4fM9V7UXjoRJN8Hy+oT4DZh6+bdoDtwmlaycunPnYC\nJSOSHLHNLndQ7rc23kfDzbdkTwuYwbvO50C2STdNK1F/uzUb2OYXHiucRs55Gligd56XsedWqHL2\n03wTeJtcLKrJkpCRSdSTSLXDID7QYuc3TMiN8z5wD+53v6MC4TStxFpBsQx4sK6w4oUrR1w49H4p\nIbi7nnbTK5YNnAt4T8ltwqlk4ySpFeSdIKiwCua4JVQyXgdcvC7bC10Oac974wnPW2azmqiVoS5y\ncdEH/sxffoAQB2XA+AEFsy1oUYbdnveZ5x0VSAWiZESS8TZqnSDIukQl7Zs7c7w/RAnwlwyBEs66\nJmYJDR8ZcS0x6LLavVYiphLDRk6exiENlXDW3VG8uSgZkYTPp1sYyC1dU9kre6Q7LL3AzIKMsZJi\nC3e6vZpcvBZZycLuFFcCJYsdiX5RBppWkumyxFFN1k9S8/GR9JUtfBxo1H8I9gcn9uxYF/uHTmyx\nzqMl5wTWeAmZS0z1K/k869hG/g/LfQRj7tCJTTetziZJTCf7VRoMauObDl7FCy99TYY0k6zmuvJZ\nS5VlIa7JRCtXItvWwl2Fp2CWz7h4j3wnJbew5DT8U5Dv2iQvMV2T1PIsycgk6sLemx5kI37/xzYm\n76vDXFtjbaQl6sL+fe8Qmh0ONH1O1I4pYerHaRtX7foZz514q04u3Xh2+4d4pjo7Rfl4k5eYVmLM\nc3ELScJNwXgSh845RL0Xcfj2jJUkYpMwbycZ4tenVtLnxMZJenFWm1XmhePxWkUj1Z8r9oeAX8Ck\npR3NDiVXNR6RpBetvmA3ffJclFc1e95RSA5Lzw734DDaWpKZyvTtsjf+pxRLGr5j3wr/KSWsX1fC\nEcD/lkR+AGLHwmnT8f/+e/wXsdwwbQrzZKwAAAAASUVORK5CYII=\n", "text/latex": [ "$$a \\log{\\left (x \\right )} + b \\cos{\\left (3 x \\right )} + t \\log{\\left (x \\right )}$$" ], "text/plain": [ "a⋅log(x) + b⋅cos(3⋅x) + t⋅log(x)" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ex8 = a*sy.log(x) + b*sy.cos(3*x) + t * sy.log(x)\n", "ex8" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOMAAAAUBAMAAACNN5feAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAELvv3c2rVESJdpki\nZjI6QXVuAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADzklEQVRIDa2WUYgbRRjH/5PbvU0um2TxqHBH\nIQuiFWlp+1aoSkBUlEMOIUWhSB4UtFaM2IdShAu0Cip4EVuxqdTti3qpYEREruV0bYtUpZgHfbAq\nBPRRuFyhvWpLz/+3mdns3sU3P9iZ7///zcx3M7OXBPiPcLsJUAgTYpCmeIL+lsgT6SWdC1Z3VBJk\nmJ4Dvju+xej9Jol78pExHtIuPtNMQ9fXejxkYtfYbIy9cDuYM1vdtGHA3g0ODTUDNStgsibtMOxQ\n5xEu1YdkmBU6mFhFqaKdXKCTQ7onT4RxnT7QEj9TS1Cmv8ZS8LwXy0RihcjuQnlWW2qHTszi5Ikw\nbp7jJ8VfX3ImHiz4aKySyYVIxAeLJzQ0iw+4mWFcq8mLatBdV9KtmJER3tP+klotnqhjqv0eih9d\nlq2dljHqEWD6w4sLAXBWNMMsLtxdPLMzMo372va7AuQ79FhStRYayD631PaBCXqqvf+NFgSrq145\nBM7Xi/cWZ5AJbgMqnLONj3v0M6hm4VGLf8PP1BKmpPDDod2PzNidoyxwtJT8M8Q9vDWrG1B2gSn8\nFDwYYWcFpSZQhXOLx1K8ddgDx+BhPsA7jZyXW3FC4ECkhyXJ1X3I+wPb/CFfUDoVNizJE1ruPY1x\nkVYdeBsfeK9EmDdebkLdIFgm+Nu68glT7JIGYzsVbF+yZWmOVasPVKt7JCXPr8AK0i7LoNhnk6kV\nV8G9fD4oOdYAPDxOINjuYL6O7D9UcwRX1LG1DnMu6YbIyLyAclCSvdkP+ZiPck9Y7KrrzHVJh3nJ\n/7E3yX1ASgJSQ3Cpi6+94S5vfIOCTOTBlVaikss9GXlEGoYpSc7DkbuT0G62z71kKzT0Ljvft04K\nl4PlpUlKXGrwTuQu4Yx1kL3O2S9Q8/XgLqybjvcpJryRr0+5jjvlmhm6ZG7W6cWvz27+yzcORjh6\nfV6a6ONU9PqMdzMd+ue7eL94P+zmyx62Up8g7GIumK9vxyXqxcFcs7hwOyg8lBvYumS+Ns0rbtLL\n+Pijhyfx6lt/yYgcN7Oa6ctXAbE6sySmen4hxA/Hn8Xrl39pUMtBvnn2btzenl7iQDzFR0IvLlzt\nO/ntxynX3cahdo9n+OK10F18twF7bY27ldNU+06d/p2p4NFhhSk//vgwJdPcuDLnQnLiFmw+ENCY\nic0Ujl1J0h/byAWabtZ9mhtXYEuPkM7xuRKfdR/rNEbF1pS5KaVEpPkQD768tFaP8VrrFJnQOLM6\nGdGdS3kbC6T5cHC8eGRNtRa+ksT1I5morXWyS/3Q+F9/iPwLwdj9PYxXm8wAAAAASUVORK5CYII=\n", "text/latex": [ "$$b \\cos{\\left (3 x \\right )} + \\left(a + t\\right) \\log{\\left (x \\right )}$$" ], "text/plain": [ "b⋅cos(3⋅x) + (a + t)⋅log(x)" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ex8.collect(sy.log(x))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Gleichungen\n", "\n", "Die Gegenüberstellung zweier Ausdrücke ergibt eine Gleichung. \n", "SymPy ist hier etwas unfreundlich und verlangt die Verwendung des `sympy.Eq` Operators." ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKQAAAAVBAMAAAA6DViiAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIom7VJlmdt1E7xDN\nqzIhoty3AAAACXBIWXMAAA7EAAAOxAGVKw4bAAACB0lEQVQ4Ea2Sv0sbYRjHv3eJd2cuPw4HaTuV\nQLDo0IB1EAd/0E4dzJIupZBJHINQMkhRXJohYCgUt1YXUbMcgjgFAy1toQXN0oodDP4DiRL8QcT4\nvu9dkruXl3IHvSF5nufzeR7e97kDvDyJMdOL5sORjUjFh+5F1YzouRfPh6MVpRsfujc12PLm+bC0\nrA8ZA/FnYn0vXu2CRDeyAik9WuNKvVRKYTbTS3uRvolHhp0qqV6dRWXI4u0GS4DaRGyZa2BpZB2R\nzqQP+ORW/gI77oqVld+Qpfdv46AiorEK5IYFol+fT7iVLeC05i5ZmWq9R/HFD5JQ7ywv1G7bwztT\nDs1/jtRXgP13DxeyHd+eQ055IwK2tmrquerakLsJ7JTSk9fQHyvvtQqh8i/20B2SW4cvu4DrJAu7\nwC7mswUO2BcfLsqm3AoaHP2OmaYQME87wgiemtNckz0yVNIRTnIMUHJndy6g/8iTp1BjZhow8YWF\nzjodKRkINIEYt0nmRggXAvLt0d3gimnOHzoy1mIj6zUGZHqOfP7IssLk3wbONhq/oGeJ2l+EA9KR\noSS086C5BNV0EBIqG6gbIkC1aAqq8VJtYNHdxN64ksFs9vPUJAZ5+FP/BhGg3oN44ri/GWhIGb6L\nnBIf0+Mo5/Zf8RCJdFEMSNNhu32t/1l8O8dN7Du5/c2V/kd6D8g1kE24eAT7AAAAAElFTkSuQmCC\n", "text/latex": [ "$$3 x = 9 x^{2} - 2 x - 1$$" ], "text/plain": [ " 2 \n", "3⋅x = 9⋅x - 2⋅x - 1" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "eq1 = sy.Eq(3 * x, 9 * x**2 - 2*x - 1)\n", "eq1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Linke- und Rechte-Seite mittels `.lhs` und `.rhs`:" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHIAAAAVBAMAAABoAqesAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJmJqyLvZs27djJE\nVN3lLQH2AAAACXBIWXMAAA7EAAAOxAGVKw4bAAABjUlEQVQ4EZVRvS8DYRx+zvV6dddeL3Tqomkk\nVq6bRQ0lMXATiwgDNrHZpCYhodhMrpi6kPgD2sTG4CtGe2OgjQjR1rnP9n3fNJJ7l3s+7/fe7wDi\naEcqwQJAXg/lA8SJqKLLnwQNAJWK0AwQp6KxOkUDEMUIEEZfJteOa23kAiF9fMlIHcqtYlb3qJjq\n6A5KgO/+5bElILSIkF+4xi1dHQdWaMVliUFrIfE8+JrL5b2XQzq3Bsx0va5kNQcOIDXcfNg0vXf4\n/YL6TzNszWwieT5/Zvh56vmucqXczSilAfZM66qRL25YfFXyjOvQ6Af6sWlUGc9uYhdPLV7l6zF/\nw1RIyWIEY+ozJbozIZauGhwiB22P23+zTtXdTBpQseN4pO7MtH6MNTputJskkFI2+yElB3vNSBYo\nuyPYyCMEHbK3e8K0m+IyynpMvYCkEo4H5RQk/UGqoch4dlPa4rZxd3+COca06UJGm462emvCOmM6\nt9XSFSRKySHWtLMF0/zlpoqnG0yxZ+J7kpEC0D9S1GN/CpwNXgAAAABJRU5ErkJggg==\n", "text/latex": [ "$$9 x^{2} - 2 x - 1$$" ], "text/plain": [ " 2 \n", "9⋅x - 2⋅x - 1" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "eq1.rhs" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "... was wieder einen Ausdruck (siehe oben) liefert, in dem z.B. Substituiert werden kann." ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAB0AAAAPBAMAAADqo9msAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAVO8Qq5l2zWYiuzKJ\nRN0MreaOAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAArElEQVQIHVWMMQ7BcByFP/nTpJTNAbDLf3AA\nqcVEI22cwDGkvYGewGDs1ANIWGphcAOj0WDogvq1GuJN78uX9yCP6UUxWIej9EoPBlhP1JK5VPcO\nI+hSd4jEG8J9mMaXMJ8W7GvhTYEFS7vpdLs4lx6aD5UGdL7cGqpMM9OfPXjwgpUM8n8MB67CQclt\nzND++YaDEe5kX/6tT8mE6l7Jf81Ox/hZJm+JG4v/zxuTTDNzr312yAAAAABJRU5ErkJggg==\n", "text/latex": [ "$$126$$" ], "text/plain": [ "126" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "eq1.lhs.subs({x : 42})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Lösen von Gleichungen: `solve`\n", "\n", "Eine der Standardanwendungen symbolischer Software is das symbolische Lösen von Gleichungen bzw. Gleichungssystemen." ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPkAAAA/BAMAAADQ0HMKAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMARM1UEHYyme+JqyJm\nu90NP0whAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAESUlEQVRYCe1ZTWgVVxT+kveX92ei7s3joaWm\nEgJBFBEclIBYMFkYrFRIdoVuErEoukkM3XWhKCKKYlQ0FgJ5lIpL3yag0kUWQheFNkgXXdk0DWjQ\nMD13/t45kzt3JkXyEN5dzNxzvu+cb86Zn3cvD922XUEzxh+23Yfu/v6uZohje/8hUm+KtCPa8Wmo\nF+1gLMU260nAtY3kxLUXNvJs3Iu9PpeQWP2nhAkVrVhJSE6sfjZhQkXL9SUkM/X2E9loifQicPPU\naLKsx4lmIO+yvvEuj6l32PaVyOxUzuGuXAXYb0VyAoCKMJEv26selam33/o6iF83oXJ+RXkhPTNn\nrcPCDtUnE3n3w5oXwtQL4Szcvo229449YnG3dp6vm8nTQVRCdSqnPOkEJVCnPhnJevVfTo46AppD\npo7Oz66fISSB+mmYybPz5zwJVnvZKv6jEcZWcm4BBveAyDHqbV1EXowhv8IzRaPB1Mn63fHJQ2aK\n7GFKuILc93HqX1WAzFAsubzoakj1iZrr5cefR+hCid25iBL1xtj54gAxqE9x5Jz7BPPa7wN3vY5w\ndQwuoHSFklZQ+hCjjvQa8IKiTeRCBXnvFrPaqcMTltB1DbrQLeQvTMbXThlq+JPCTOSOCnIrbmqm\nPg68dp3yWHzrlJOl+z4ZVzuejas+wUTOOa1xNJj6U5R+kLqeNWepcvAjjvbFqhdWVJ+M5OI4ntcU\nRzzzxQszluMLH8auUVuA/PlHwMXLPfUwzu3s6j7HNJGf3vrOC2G18yRi3j5lCdtofL7TCEswiXrq\nrYwxWoecPhkpDTBSPTXUIH3RmMbO2r1bGiLuDdmumUhdG7kxZ0s93K9W5wG5+chXq71T1eo0daqz\ngQSzcAPTvW9ovB5lWQLuEpGvVqt/Vas9KoylI6vVedWT0OBfmxD0f8yP+b6nlzd6BR9THW+sDcon\nUR84dcbPquk8R/Vfcz8YSA/f6GpYgFT30cYzrzZo4yj0eTFpmT+E5nnm8DxFS19awDzg/i8Dg6O+\nurNBS9Ujtt7r0IEg2frJsYu0ajsI6Hf8AvXVnSVTfgG0ZdIOWkhztK4lec4Mqd8Bjus5HBXqbWsW\n7QC1g9QNqAxR+btf4bb0+hZHhTrmPkSEOJuIaNTP7J5V/oL9oi69vsVRqZ63o1ZlVDuiUT+ze1b5\ncXeZInSDo1L9wI534j1pRCv1aLTBUzOVP3Xv70vS61scFeqlaYzQ26IbpG5AZYTK/xKZd5Z0exZH\nhXpHDdl/tSHqvhtQGaPy075kzP90RKNCfZB4s5LrW6RuQH2Weyb19BI9eHXp9iyOCnWqDr9pQ7za\no1AZ49VepmyawVGh3rYTpSFNALmodgMqY1T+bRbmpde3OBqoOxu0by8EvzI+2T2bUcnNPV6eRXZG\n/soEFIEG6gG8mZOW+mZ2m2u1Os+7sZnzVuc3s9tcq/mdb+q/wEea9y9wf+0/6XeDcNmQ/OQAAAAA\nSUVORK5CYII=\n", "text/latex": [ "$$\\left [ \\frac{5}{18} + \\frac{\\sqrt{61}}{18}, \\quad - \\frac{\\sqrt{61}}{18} + \\frac{5}{18}\\right ]$$" ], "text/plain": [ "⎡5 √61 √61 5 ⎤\n", "⎢── + ───, - ─── + ──⎥\n", "⎣18 18 18 18⎦" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "eq1_sol = sy.solve(eq1)\n", "eq1_sol" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lösung 1 einsetzen:" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAACoAAAAPBAMAAABgjEDtAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMA782r3SJ2ZjIQmUS7\nVIlAnjihAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAv0lEQVQYGWNg/GQs72z0hQEV8Acw5BcwNKIK\nMsxiAIkyo4mGg0XZJqAKR4BFOUCi0Q2c3QFwWaAJ3Iq5j0LXH+A9n8DAuvwxWAooysC4dn4B0wEG\n/gSGLRO4JUEaQKJMDgwMPGBROQYGMaAgRNQAKsrxq7zcHC66ACrK/hckBARgExbA1H4DiyFEmQ8w\nxCcwODEwTIOpZQGqZRdguHiSob+AYSUDA/caeZkV3Of/XGBgeJc2RWQCp1XeBKghaBQAM0c287zN\nvm0AAAAASUVORK5CYII=\n", "text/latex": [ "$$\\mathrm{True}$$" ], "text/plain": [ "True" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "eq1_sol1 = eq1.subs({x:eq1_sol[0]})\n", "eq1_sol1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ein ganzes Gleichungssystem lösen.\n", "(Die rechte Seite nach links bringen erspart den Aufruf von `Eq( ... )`)" ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{x: 0, z: 6, y: -2} -> eingesetzt: [0, 0, 0]\n", "{x: 1/2, z: 7, y: -3/2} -> eingesetzt: [0, 0, 0]\n" ] } ], "source": [ "from sympy.abc import x, y, z\n", "\n", "eqn3 = [2 * x**2 - y - 2,\n", " 3 * x - y - z + 4,\n", " x + y - z + 8]\n", "\n", "sol3 = sy.solve(eqn3)\n", "\n", "for sol in sol3:\n", " subsol = [e.subs(sol).simplify() for e in eqn3]\n", " print(\"%-30s -> eingesetzt: %s\" % (sol, subsol))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Differentialgleichungen\n", "\n", "Der fundamentale Unterschied zu normalen Gleichungen ist,\n", "dass es symbolische Variablen für Funktionen gibt: $f$, $g$, ...\n", "Diese werden mit der `symbols` Funktion erzeugt,\n", "deren `cls` (Klasse) auf `Function` gesetzt wird,\n", "bzw. das Argument `function = True` angegeben wird.\n", "Dadurch lässt sich eine Funktion $f(x)$ ganz allgemein in Python durch `f(x)` konstruieren." ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAACUAAAAUBAMAAAD4luk4AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJl2IquJVETdZu8y\nu83OyatpAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAA/klEQVQYGVWQP04CURCHv4WVP8ouxMJAbLbw\nAIAX2BYbC4kNjcbKCkywhsQLWGgJIWqjrRfgCDT0XMBkiYUUFv7m7YbgJDPze9+bmZc3kNlZlt/S\nfNiO8RcZ24uduBwNCFMJ3sqYt6nDiylnNxaLicKTO1s4tlB4BF+eWTiG/d5zRD7SjNPugxpzklSb\nEMzgiPfmVDUrsfM5lAdwTb821HgbM5IfjKHGlxSVROFWbgy+LTi2lLBeKr/GStb7Kbc37vIJrfQN\nbyNWiCj9BImvq9yVatdiavAuWu0PyXCukoXEzt86cB/OjP3bwaRhiCB2Kd3V64k7bHe6vRTe2f0f\nX/ExQF2OnBgAAAAASUVORK5CYII=\n", "text/latex": [ "$$f{\\left (x \\right )}$$" ], "text/plain": [ "f(x)" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sympy import symbols, Function, Eq\n", "f = symbols(\"f\", cls=Function)\n", "f(x)" ] }, { "cell_type": "code", "execution_count": 45, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKsAAAArBAMAAAD1dmXyAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJl2IquJVETdZu8y\nu83OyatpAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADVElEQVRIDa1WPWgUQRT+NnfZ+0lusxgiSsAs\nKhai5nLBtFlsNEowmGBjE00hFuIJWljlxMrqDvzDQjn8KWIhQS20UFLYSiKYRpAcaKGi4YJgUgj6\n3szO3m0uG2e5e7Dz3vveN+92Zm7ePkBT3j3TJEakrUbk69GTK3q8iCyzFHGCHt1y9HiRWIem5vOR\nJmiRky+wZGsxI5F6yzgQaYIeud/GbT1mJNZrGGuRJmiRjd9IVLWYkUjGKjKVS5GmaJE/Y2ZsUou5\nnnTUAx6tD7DfM/R2vFAfiJell3br0aC9JecivuBh7ZsQBcXYtRsYVRkmlNGoT07nYbkeblQaCQGk\n/SzVsi8K2qGMBm2sbQMe+PCUZyWyPhQw+q4WkHYUZIawIP87NxUPvZ4Vlnaa4ilX0Y1ZZa3XXPLi\n9HhiFaQRlvYchUc8LqmvNTNgpU/dchBzAGNw4hrtQBuZLCFpH786AeQo3n3wyBDtwE5Brg1GLotj\nNvldFMyUga2Yyd4H0hXJCUmLXxT+SC8xmb6RIupTZpvLQhw2E7MYZuz4HG1WHjiNCzZdpUSJwdC3\njf+h2B2abpsrCRe4wtw6OdxWwSf2+Qw6CoCNn+x2Vmmgn//2Znl5jIGgiOLwkt4W1gJH5oNh2B1Z\nsSDwGXBaSFekJUdtQtffmhAsvmmUVm5eY1oU7U5eEBbp4U2AdJMlBmtppeePGV4BbQIlnOPxOg/m\nXSEconofm2X9nB4+souxKgb+e2S0RnFkCXsYMds7MoJ8WYT4ZVGgTQfJ1UyVK0jbpGSoTfD50ugr\nkD4DFPNL4PK0R8K1cT+KZfJEX0ErN8YHck/It+ZoIAlJW6Q35JX3DHbvLZP5g56A9Ez1uwSYC4zW\nLu8IuyQhac9zrHZ5664nB4Tw1/SyVWa7sdQYLuNS/L4uMfadkU1KTXtF7Oq97WJmxhWK/o8Vzwgo\nqoVCUu9LQn/wfDQUxlQ5k6XgQyrKJH4Z9/ML2Bv8vi6dcwU0qqJ+fgUkB/cpkzWfKsuGHx1xB2Rc\njjofnXr+xrblbIw3hYq+zquDTSUKTBZ9naqDgUhTjujrVB1sKlNgsujrVB0MRJpyvL6OPyItFNXX\nyTrYssSyr1N1sGVpIfo6VQdbl1b0daoOaqb9B4Quu2yf/zJMAAAAAElFTkSuQmCC\n", "text/latex": [ "$$f{\\left (x \\right )} + \\frac{d}{d x} f{\\left (x \\right )} = y$$" ], "text/plain": [ " d \n", "f(x) + ──(f(x)) = y\n", " dx " ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dgl1 = Eq(f(x) + f(x).diff(x), y)\n", "dgl1" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKEAAAAVBAMAAADcJJPmAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJl2IquJVETdZu8y\nu83OyatpAAAACXBIWXMAAA7EAAAOxAGVKw4bAAACc0lEQVQ4EZ1Vz2sTQRh9m013k3YTl2KLIkJA\nPYi1pgmCKOqeFNtDxF8HC5KSUy9t/HWUBjx66ArtQUS7tF70VBC8GvwLesmxEAQvgjGitUU8+H2z\nM5vdjRvEBzPzvve+/XZmdnYX+G/UJk43B108Lc1Xg5LCnm7fyTbCQoiPlhykt6Qw5IQcSbXzN2+n\nqzHdwueY0gtvLdWRd2SstXuGYuc8mCc8FeHRNsEGfgRKjGh7B4D1QKwFTJHDT4mdclSoRqtrSXpf\nSXI0u0RWAvFQwBT5SvPBExWpsWK4huTxioYLpKlJ5BuKyTG1y+RDTMXYmdqc1GIVh2dXC9ALgFa+\n8ZiWnCIaQUXcbb+vjZePRkwRyIpaqYgZXs++IpDzgHG8Lr4EhtuctdBhfGS6SD7DagOZFVwSQaST\nFQ1zExfZqDSBbB2Yw6L9ADDdSDawRj7BOkbGTF2bEFGkkxUvp9rYZmOJ2kgDsPGFQ6vLfQjvbQ5s\ncavZjbMiCtm0muedzidOGSniOzvz1Lgi/LCv4hpbZlNU3GHeBzlHLNvWbzZb1HjV8MOMy+L8M8Yq\nU3ESU/52/GShD6riJPRNNt9S4ydzV+9iSj0ZNiQqVSJ0UHiD3wG60nujqthC7iqp2h51RgGZ3Vw3\n7dHpqVIchvkLuGf7FS9ASz49OIllj67MfOPOhXZ9qvSGaL5JXQSjrWsNEniO+hFOiUPNcawmdsjY\n4oTeW3glnq/ivmOlDKiKwCRpD/MeO+vcCfR/KaRB5zcB8n0aaosdfHFQpOUcmf23r5mw0sd3ijIn\nYch6Oc7Y8Hc6+OIGpRMuGyBnypH3aVqm/vNfIan0H2GvgJDnQn2PAAAAAElFTkSuQmCC\n", "text/latex": [ "$$f{\\left (x \\right )} = C_{1} e^{- x} + y$$" ], "text/plain": [ " -x \n", "f(x) = C₁⋅ℯ + y" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sympy import dsolve\n", "dsolve(dgl1, f(x))" ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIwAAAAvBAMAAADDZj9NAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJl2IquJVETdZu8y\nu83OyatpAAAACXBIWXMAAA7EAAAOxAGVKw4bAAACvElEQVRIDa1WPWgUQRR+i5fd7Ca5LIaAIphF\nxcJCw0nSulipIB4qNjYhFmIhXKGIVc5GEIQEJEklHIiFjYhaaKGksJUkoo1NDhT8QY4cipdCON+b\n2bfJzs5udrgM3Myb977v8WZu37wHUHxMf/CLgzORdtjXzDQWN7jh4J/i6EykWy9tZBpNDE7bBK3F\nvn8O4I5rTUbKDsC0EUEL7m+DF2gtRkp7Du7CfSOKDlwOBr/dWtVZDHQnryzXBrrddQOKBtr/EtZ2\nIBH2NeCoxrup6pgPC6YcDf4NWDuQB9ZfcHq8XYrN6sBQ84YmSkPVF3hSnSrEKTUkzAs18NHJdxfq\nKb1C2V1B6llGXWQhb7UOHkpRLs3UAL4yaz8LeWvfVUz4JMXa2ANbstcel3wnWrXexu7UVYr4L92Q\n4dazAm5mEKNQ8AkAOM1eAL4XcHMtRfEuzwcAFdSPTJyaxJMc2N7N49fnU5RhuoTP+JFNeQ/cJsDT\n7d3A7zTl3BLqFgFs3247IcBt3OLIu+LSPwQoFLoueIXRQHmFxGX82a3Wj7etVhXF4W5yrKNO/CsK\nha6L3CCDjifc4JIXjfhXFMon4mKE6GCJ5ns05bsZojAVygsi4RU7/gnY5edfcdRUDFDYSYp8kLCS\nzdbW4AyaD5NbfTTcVIzVEZCkYB3DgScZPT5ypIHiL9rr3XBTMYtBKxR7hUibX3ZpjvZJN1TAaXBT\ncV1sQpppIOVmuUGSF9BMg1PTCsVWTh2Wqalwqj9pm6A83CsRHxmoeyjkwQlBTYW7KgPeSnmE7w+N\n+NmKjVIvZvGdCImaCq8SCllHUV5EgYunchCJmwdBRS4l5sYCFfAo/XtoKkQBl+nfS1MhCrhM/16a\nClHAOf3jkxoLUQGX6W/MZgIXcJn+rDVeZQHn9DemxwRRwDn9Y62xIAo4p38G+z98677THMFqggAA\nAABJRU5ErkJggg==\n", "text/latex": [ "$$f{\\left (x \\right )} + \\frac{d^{2}}{d x^{2}} f{\\left (x \\right )}$$" ], "text/plain": [ " 2 \n", " d \n", "f(x) + ───(f(x))\n", " 2 \n", " dx " ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dgl2 = f(x).diff(x, x) + f(x)\n", "dgl2" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQYAAAAUBAMAAACdco4rAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJl2IquJVETdZu8y\nu83OyatpAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADVElEQVRIDa2WS2gTURSG/2ljJpNO2qFqUVAJ\nooIPMFgfoKijK18lpT6QujAWEXVRgyKiLppVQRRUtIiIdKDgUltUcCEYdOHCRaPVjZsGURSUVKvV\nIpZ6zuTezp3JEF30LO553PPd+8+ZNCkgLOKUg7gtCv/ppolrXEX3tsg798jA89rGve2RjJe/SHlx\nFS6IeRBFAW5fVxZ4LzsWyMDzGxzoyx0vH8x4cRUuiHkQRX5OG58DxJOyI6o8ZLk2/yr5lbZs8PkQ\n7pRoqIYF79O/EmTY8mitX0bSj1gUXZSZ34dwUkM1LHhf9Aodu907+pMXulHNL3ZPlequ/FQSwgkN\nldgURIGfix/oSQKrqD5zzba1KWCh2ktxmjVilqg+O7cpMtxqfl7RvJsrIZzQ4Me0JR1ZNDUfhbmu\nr1jJNdC9eAtomfg1g/bvUorOEts7Dk/wPplZpEUrwEB9K4whpG3KgxyVhAaJdbyyqLgzaz4wryOR\nmg/wMwW4dJ5qN4CoFf2m28BZSlXrzbuZuZjZ2ABqkWhFoh8NDuUhnNAgsKg9o0h9Jeh/jAzMPxct\n8DMFuC4q4RE9IuoLHA7yotgTixMLOmtA75DtaijCnV+Qo/ndKpU+UKPADNv8QWePUmUwC/w0Jlbz\nMQHumKihfGqFhl7e1/NCQ9PIqKuhMKUhyMk5lDEjFxmn8X2nrCsHTGidk0mKSYPKveGUZkNC87xe\n4OXYTbYeDt1vhhqSwXOIWLiX43chNAQ5ahEaJAb9mzKH0S2Ik6bgffepxJ8R3dqMWpq7+5nkmrB0\nhoJDQoOewgxH0RDCCQ0Sg5EivkR8XRKxcdptp9zPaSwLHcDl7DB2ULiEc8X038BJ0ubOQR9AwqYh\nyDmEcEKDxPho+rtwcNh8jPrMeQuvKfdzMRqV+wJmN89c5lD4hXPVGt+05Sh3NcSOrz9qHhybd3Ds\n+fBDKtKLC3JCAwQWT1IbtLa1NrYe2Y/uvjs5yv1ctMA93ndu5ArnIeZqCNZDOKlBtHbjUhCi3Med\nrne4JZ7kla3yN6tch94vAtWFcLPUfZgfz7z0FcqJj7s9t1zkl+RayG+3W48sHUuJFtX9i6ubnPyq\n9stY5foWlastFZuyUN1PJzdN/5NVF6zsKvf9BRdz+6IZPTuoAAAAAElFTkSuQmCC\n", "text/latex": [ "$$f{\\left (x \\right )} = C_{1} \\sin{\\left (x \\right )} + C_{2} \\cos{\\left (x \\right )}$$" ], "text/plain": [ "f(x) = C₁⋅sin(x) + C₂⋅cos(x)" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dsolve(dgl2, f(x))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Ungleichungen\n", "\n", "Ähnlich zu Gleichungen, [können auch Ungleichungen behandelt werden](http://docs.sympy.org/latest/modules/solvers/inequalities.html)." ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "collapsed": false }, "outputs": [], "source": [ "from sympy.solvers.inequalities import solve_univariate_inequality\n", "from sympy import symbols" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "collapsed": false }, "outputs": [], "source": [ "x = symbols(\"x\", real=True)" ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAAmBAMAAAAYddAjAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA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\n", "text/latex": [ "$$\\left(x \\leq - \\sqrt{2} \\wedge -\\infty < x\\right) \\vee \\left(\\sqrt{2} \\leq x \\wedge x < \\infty\\right)$$" ], "text/plain": [ "(x ≤ -√2 ∧ -∞ < x) ∨ (√2 ≤ x ∧ x < ∞)" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "solve_univariate_inequality(x**2 + 1 >= 3, x)" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAANEAAAAmBAMAAACog2N9AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAZnbNRO8QMqsimd27\nVInIquLFAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADvklEQVRIDbVVS2gTURQ9+XRikjYNiIogGhFB\nQTQbFRFpFm5cWcUoKtjxUyh1keDGnQ3+EFQMaFddNBtBKlJRUKGIRRBFKmarCM3GhSL+WykW671v\nPpm5zmQyCy/Nfe+cd947ufdNpgAQyVJqP24W9wtxf/GQYNxwwIJrrEm74z9OARvjeUMQlxsD9gFy\nQ3/QjnWGoL8cJJTroZ1ixv1ckgf54tEFjpY1WRL3GclZxok5N9sCnTfXWtRkScQpqppYRbC+MGle\nbIt7siXikCGdiNGqYH1hqm4u+ddkS8QhsRwRtwXpD09aS/5OtsSSmmOklyZ7BekP71hL/k62xJKa\nY/InkPwlSF+o3UVybKpM675OTYk85Qi9ir5K0g9nshhAhr6c4aQpnc7Z/uU2JWrRkc4BqbsO3HJK\nd3ARKJJG1RRjcbLC2XZqSph2xiYgPekkWs1XA4eBa9Q+5ZRmrXBqSuRB01V011yk6onRGAcfLxCg\n4nt0XychUZt1ziphqI7uHEMrBvr2AJmXZy1sjmvzQDSnwBPduyYhIa12YSYLfLql9pWyoD9HPMem\nvLYDiYaDox4do+dAdQvxP7Ti0T0pIVVnOfoDx+s4w2dRQaNOp0gZXfOxMrCcV5uhzQMrFUxXaPBw\ngpCQahkwPbmVnu4qge4GN5AK3T5Bcb8cpfmXe5Qi9GnSwHgVDxQ1xtnLSUhIlaN7+E0JXAs9DkM8\nWsFOnd8p8cQZo7VIg3G0xtnTyS0hVY4+rznxh5xc3VNOfQXgKC06Y9FsWmf8FknqRdMpUWFW/Z7c\nEmJz9HlGF6xxLaUGSkxYEdGBjcMHgfUWY46JP295lqghajmlCkREVUeUk1tCa0tp+UOxqnZwQXRV\njqghU0vMFKhVpbyDBjZvYTjy+eNlGlRN2jaavWPWfEc4JNoPYlPARwztMx4lehw6Kqy1YvDWK2Bw\nht6H6QcWp8bpGg89Cwu/aVBOuH719IoKs6aTUzKhU9fGrtShjRcbLNldQKf7u2tMq/SGZ3bEqGl2\nGE44NWY22XjvOSVdSq7zDpWwSkeml6FHNDw4kzKdbIH9hrWZjD0zJ++BrllJGljLefPMBjsdk5sf\nUae+SdLAEW9ascFOWbFbubwQZBsw2Eke0jVHzBLJBuPwTqk8nVqqBx8tFOGdOridUbYLF+Gd1iqD\nA+FsSB3eif6/UixWOUwK7WT2LZYL48La0E7DVWWhPfzfTtpj02HEcGzXb8PUrJCWpp4Kxg07+cnj\nSJaNsc18Y2dBKOM7dwnGDU8w/As33erM/6ER1QAAAABJRU5ErkJggg==\n", "text/latex": [ "$$\\left(-\\infty, - \\sqrt{2}\\right] \\cup \\left[\\sqrt{2}, \\infty\\right)$$" ], "text/plain": [ "(-∞, -√2] ∪ [√2, ∞)" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "solve_univariate_inequality(x**2 + 1 >= 3, x, relational=False)" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWIAAAAUBAMAAABFfiohAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIma7zZnddlTvRIkQ\nMqvFy5UvAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAFDUlEQVRIDdVXX2hbVRz+7m2SJrk3acasMHzY\ndQzGEDQKisikcS8T7WZkFKSdXUCFwWTLYKPIlEYfBPHPUvVBy3B50A2fFjaqSFh7H7qOIZi+zBfF\nxmLRKa5/Vl23tY3f73eutd6+rg87kN+953x/7pfTc89JAcvD3dPsDLNuBC6eu6Chd/lXSmjf+yRw\nX+1xIPJ66gW4PcNkXTrejdShnlpNi0FCsBEq3WjUUt3krnZ8XAeMwcXaz3ysFKt2vgS3b6iC76dq\ntWoYVg2Qygd0KvAU8DTGmAo41bwNt4GRipXHCQ+JZrOKy541AOSRLtnNZnNZi0FCsAoN3WjE0Qzy\nZrQSzQHv+FAD90NsymhBO+JziAK/4SH6N8Iw4ifFJ5aFoY8Cdh52GQ7tgGd/zSDtI1FuXUBbAZHh\nI8BVYApxD1Yuym/V0GKQEKxCQ1eNGBo3uXkULVl3atqHGqTLSOe1oL+Ev/EWcA+eJ30N/F3voshf\ny8LQnSJiGbQ0ENfxBrFEAeml5CDqOerZ5oEROPyKBQdwxrUYJASr0NBVI2LjxmtyVrv9PtSgLQdn\nRgu+rLjzOA+MoQpcWAOjVZJZW7MwdLeMe4G2BpIL4tjgJ7LIxLxyVUgk9zrQP5687jsee2f4kaJh\nQ7AKlf6jaoS64tZS1i4Ts51BPYvWJS3sclWc3YFzvEsW18Ka2IlkjQZ4BseAeh7JG8Kd3PaiXGL8\nWu5B5tpybBwfc44rmJ4TR2SDoshamEKlG41w2cQNbbu/7ubFJM4iwTm+pYWDY1Wkmw94vGvhRx6y\nGtbE9zNxQO/CI8DmKlK3hbsDmyu8nK3C+mofDXzrFpcEnvPgNDsJ6DxLUWQNLEKlGw0F0jjISdmJ\nRClITANnBpE5LdyWXvE5KfMsOs/ykNWwJHaLTBzQt+IAE+eDxIxSoPAQP/imIvUxRIrxkRI+OH2T\n/boMaRGE7f+wCJVuNEJgU7f6IqIng8RisAvvLpjCeRhE/PfDgww2I/wQLIkdMHFAfxtkrqwKIMo3\nJJoXYYIPAPZnsO2NkXG7gX72j8qQFkXCsAqFrhrhshk37jz2rSCxGNh9PyyZws6n/oNovemjNceO\n+q+CJfH7mlgHMSGJ+ebF5c1L57i6ICvb4gaygF90CQPTfiKDFBkviaMURdbAFErjFhYU6ZnBWA72\nXJBYXZBmEikbgI7SADBRQowTGTxkBZa9wq1qYqUzMVdFSxa26Lm2o4uI57GhbVES8wXa73N8j/6l\nJuEus6NFkTAsQhJI/7fwGgymyytzrAZcPg2iLE0fHe9xOaQ91GUoBEvi+LVr058VDR2n5c3jCSIH\nkpw8nIsrwJFEFrFZHnR4GdszqVlwjvEwUn+RpEWRMCxCQ1cNuWw6SBXXcdnMsRjYA5jIaMFHwOEM\n57glgwk6qv8q2OzHYCBDx1YMkXUAl8e5j/Ns3p6xDtZ6C7aHE0UeoGQd9Uc9JDthFxHns0xRJASr\n0NBVU8+RrYO0xh+4XDKJxaW1091pCrYgfgOf+9jGI0ASh+AgcRs3cNEAPZxl4Nu+P/Wdbh/ehwhP\n9wK+6HqCj+uZ8uF0dZPxUw+r9QnvTBEkBBuh0rXEXiXbDHK7cLr4iN5TezxjMNRVAbQku/ZWkJoa\nYn9TiQr1/w+OXp2fpLpj2TN07JZTep3am+vhaxXkl9A6tep6+PKXEN+o9Wkuve98G6Xlxjtvq472\nuvjK/Foey93S+F/TP4p6TTtGQk5GAAAAAElFTkSuQmCC\n", "text/latex": [ "$$\\left(0.523598775598299, 2.61799387799149\\right)$$" ], "text/plain": [ "(0.523598775598299, 2.61799387799149)" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sympy import sin\n", "solve_univariate_inequality(sin(x) > 0.5, x, relational=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Diophantische Gleichungen\n", "\n", "Das Ziel ist, eine Gleichung $f(x_1,\\,x_2,\\,\\dots,\\,x_n) = 0$ mit $n \\geq 2$ vielen Variablen $x_i \\in \\mathbb{Z}$ zu lösen.\n", "Siehe [hier](http://docs.sympy.org/latest/modules/solvers/diophantine.html)" ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "collapsed": false }, "outputs": [], "source": [ "from sympy.solvers.diophantine import diophantine\n", "from sympy import symbols\n", "a, b = symbols(\"a, b\", integer=True)" ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAH0AAAAVBAMAAACZCfwhAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAZpkQ3Ynvq81UMrtE\nInZCK3CHAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAB0UlEQVQ4EZ2UPUgDQRCF33l3+SMxaQQ7oxIU\nBEkpFnKFQQUFEbXU1GKRwlZIoY0oWIiWBkstJJUgiBaipSJ2Ihz2gpBGRIlvNsTdhDsRB3aY2f3e\n3e7sDwCrF/+yxHBedHZBfCoj/s9m3RNNrghvvYl/EverPQydG+PrEg+Kc4vidziRGQnCzC5h+Uoz\nI8LNi1N6KwvE1USkK8iieUSKmnF9QosCKr3D9XSUJQ2ziIfoh2bsIkGtf2TmzNKFWqwmes1sk9T6\nF+D28swPVasBp2YwfU19tMyoynYIdC79Noe7WYPppqKHDfsVuik27kYXDhiE2YTJ7JGKZYETdQhW\nmfEcTSOdb1PbG+O0yQrrS1ozp8Kt+cBNhQH19ifsD0R2mQUba2Qwoo+V6NT6Of/kG0a/4GSCxTwe\nWTwbzDU5tX7XY8T6ueX4cQ2OzyzQjoBXg5H66f2b4/JKY4kvRHz7PVCeKiwMeE2GRK5Fz9mkqhmu\nP32F8fYSqu/F6vW698MAWy16Ob80Vf94I1YdAa6xRymPQ3r+VpYp8CL776ow1CkGrk9A6Rv3/0Lx\nbq4fGAuVagbq/qr7j03pNt6P0B00vyv/S8qp48bK+/eP9yuRY6G/Aa46bcV77f9mAAAAAElFTkSu\nQmCC\n", "text/latex": [ "$$\\left\\{\\left ( t_{0}, \\quad - 2 t_{0}\\right )\\right\\}$$" ], "text/plain": [ "set([(t₀, -2⋅t₀)])" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "diophantine(2 * a + b)" ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAALYAAAAcBAMAAAA+WVi/AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMolUmd12EKvNu+8i\nZkT6JHTOAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAC+0lEQVRIDa1VTWgTQRT+srtxk+aHID3pwahV\n7MmKIngyCmKrl1goWvSQQ48e9qIgCs3FHhQh/lUjKBWFiiIGetc99FSE5qIIIq7ioXhpq0ipiHHe\nm93OZLNJK+07vN9vvpm8ebMB2kvPU6d9cX0Vw01U1scAxHYSQ8wL88Td2J9wbg1xiTHfcmyOsdnS\nsizupf+2JFdPzDEk/YDMpiUO7rFuVqYsNSdXi4w6I1J5YWRTrRJnmlU8KtkMiYhOc66L7kpyzzoK\nZezeLoMelZPeuNPdF84F8fSJx9IdYcO0klujsR9hALjgIlMI1gX2TeNH4IatXcZeD/Y5YJZLGveU\nwnYV8Bw4DHzFFz970Le3xlzfazEJB6kazAUgXqei4o5ptzbvUm0Asdv7J8kTEnCXOYpUqSISi7Aq\ngDVBAMWdqakFL9gdRKrREKdgWQN3com443kxeMzF3F0TYjntF8jy5hEve+33WBALG3DfeH9Ey4bd\n+NLcq2clZLkHzH25JDC8gcTay3VMcePU2oB7ErOeyoa9+TzdEmKLVMiIHdJ3yEuWSbPYDQcnHf2H\nqHOLQxQDXKs9Q7ckGOVr3pXDO5dA8QJwaYjkJn4Bnz1qnC+91erZavW+jKzwJ8a+S6uGc6KvBWBQ\noNI/GWqPw3xInnZuDAvu+qjHAF/5PRE9NNp/YsSbsanqn/tQXYx6n4h17ut07nnYGrnPnarA0oZV\nAwjXLOBtdgEO5NczS13na0xMKOA20W/0Yp/KBHNiieZVtHST2w2cNypmTp8THhY5kxKbyNtT6LdL\n2kr/3OkCPrr2slZQbnpwR3/RKl8UE1KjLNOykjPpI3v6c5j5pJapOZnecxwYcvRS4CcbjUYx/bLe\n+i7xOsBEWv/csma6kZiVZLJErjo3jq6UopwretLQgwh/lH+Xxr01AtQmJVraUT5wVeNO9HXE60XR\n0o5yiqv8v2PUyLcrHfH/UczkGUwvHZCv+QBnNkDNSI6rDlnzCWuP9AaImFIh31fr3Dp3+genK63p\nsFqgyAAAAABJRU5ErkJggg==\n", "text/latex": [ "$$\\left\\{\\left ( - 6 t^{2} + 5, \\quad - 2 t\\right )\\right\\}$$" ], "text/plain": [ " ⎛⎡⎛ 2 ⎞⎤⎞\n", "set⎝⎣⎝- 6⋅t + 5, -2⋅t⎠⎦⎠" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "diophantine(2 * a + 3 * b**2 - 10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Limes\n", "\n", "Die Definition des Limes: \n", " \n", "$$\\lim_{x\\to a}f(x)=L \\; \\text{iff} \\; \\forall\\; \\epsilon>0\\; \\exists\\; \\delta \\; \\text{such that} \\; \\forall\\; x: |x-a|<\\delta \\Rightarrow |f(x)-L|\\leq \\epsilon $$" ] }, { "cell_type": "code", "execution_count": 57, "metadata": { "collapsed": false }, "outputs": [], "source": [ "from sympy import limit\n", "from sympy.abc import x" ] }, { "cell_type": "code", "execution_count": 58, "metadata": { "collapsed": false }, "outputs": [], "source": [ "f = (3 * x**3) / (1 - 2*x**2 + x**3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Numerische Approximation\n", "\n", "`f.subs(, )` substituiert hier die angegebene Variable mit dem gegebenen Wert;\n", "und `.evalf()` wertet den Ausdruck aus." ] }, { "cell_type": "code", "execution_count": 59, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 1000 -> 3.00601202104\n", " 2000 -> 3.00300300263\n", " 3000 -> 3.00200133411\n", " 4000 -> 3.00150075033\n", " 5000 -> 3.00120048017\n", " 6000 -> 3.00100033343\n", " 7000 -> 3.00085738782\n", " 8000 -> 3.00075018754\n", " 9000 -> 3.00066681484\n", " 10000 -> 3.00060012002\n", " 11000 -> 3.00054555373\n", " 12000 -> 3.00050008335\n", " 13000 -> 3.00046160948\n", " 14000 -> 3.00042863266\n", " 15000 -> 3.00040005334\n", " 16000 -> 3.00037504688\n", " 17000 -> 3.00035298270\n", " 18000 -> 3.00033337037\n", " 19000 -> 3.00031582272\n" ] } ], "source": [ "for x_val in range(1000, 20000, 1000):\n", " fx = f.subs(x, x_val).evalf()\n", " print(\"%7d -> %14.11f\" % (x_val, fx))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "*Bemerkung:* SymPy's `oo` steht für $\\infty$" ] }, { "cell_type": "code", "execution_count": 60, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAOBAMAAADkjZCYAAAAKlBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADmU0mKAAAADXRSTlMAIom7VJlmdt1E7xDNIS4hGwAA\nAAlwSFlzAAAOxAAADsQBlSsOGwAAAFJJREFUCB1jYBBSMmFgYAxg8E1gYL/CwNvAwLmSYe8BBiAA\nijAwcDcBCUaNaCDJwKA1AURyrWZgFGBgBiq+DSK5DBg4LjKwJTD4FjAwTA21ZAAAM4UOK1ZklQ8A\nAAAASUVORK5CYII=\n", "text/latex": [ "$$3$$" ], "text/plain": [ "3" ] }, "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sympy import oo\n", "limit(f, x, oo)" ] }, { "cell_type": "code", "execution_count": 61, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAOBAMAAADkjZCYAAAAKlBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADmU0mKAAAADXRSTlMAIom7VJlmdt1E7xDNIS4hGwAA\nAAlwSFlzAAAOxAAADsQBlSsOGwAAAFJJREFUCB1jYBBSMmFgYAxg8E1gYL/CwNvAwLmSYe8BBiAA\nijAwcDcBCUaNaCDJwKA1AURyrWZgFGBgBiq+DSK5DBg4LjKwJTD4FjAwTA21ZAAAM4UOK1ZklQ8A\nAAAASUVORK5CYII=\n", "text/latex": [ "$$3$$" ], "text/plain": [ "3" ] }, "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], "source": [ "limit(f, x, -oo)" ] }, { "cell_type": "code", "execution_count": 62, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAOBAMAAADkjZCYAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJmJZjLNVN0i77ur\nRHZ72Yd1AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAVElEQVQIHWNgEDIxZWBgSGeQmMDAsoCBOYGB\n+wAD+0cG/gMMvN8Z5BUYeP8xzDdgYP3MMF8BREJEgLLs3xm4NzCwfATpYkpgYGhnkApgYBB+d5QB\nAPogE3QldevOAAAAAElFTkSuQmCC\n", "text/latex": [ "$$0$$" ], "text/plain": [ "0" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "limit(f, x, 0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Dies ist auch mit mehrstelligen Funktionen machbar:" ] }, { "cell_type": "code", "execution_count": 63, "metadata": { "collapsed": false }, "outputs": [], "source": [ "from sympy import sin\n", "from sympy.abc import x, y\n", "f2 = (sin(x) + x**2 * y**2 - x**3 * y**3) / (1 - x - 2 * (x + 2 * y)**3)" ] }, { "cell_type": "code", "execution_count": 64, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAOBAMAAADkjZCYAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJmJZjLNVN0i77ur\nRHZ72Yd1AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAVElEQVQIHWNgEDIxZWBgSGeQmMDAsoCBOYGB\n+wAD+0cG/gMMvN8Z5BUYeP8xzDdgYP3MMF8BREJEgLLs3xm4NzCwfATpYkpgYGhnkApgYBB+d5QB\nAPogE3QldevOAAAAAElFTkSuQmCC\n", "text/latex": [ "$$0$$" ], "text/plain": [ "0" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "limit(f2, x, oo)" ] }, { "cell_type": "code", "execution_count": 65, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAABYAAAAwBAMAAADnb5cjAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NVLsy\nme8Q6PJIAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAA8UlEQVQoFWNggICkywJQFgNvAe8GODuB/QOM\nzcCAEGdgkDsAF2eaBGeiquH5BZOQO8DyHcbmcGB/CGQLKbuqKfAkJTswMDAmsDdxTIDIswmwfeQC\nioEAIwMn3CUMDPwKYEEwcf4AjM0loM/AJADhxS/Yz+AOlRBWErpeAFNEY/o/AlDDpjS1AyBj1gF9\nJRnAOwEYDrb2QPZeBu4NIHF9AQbWLyAGEADZ3A/ALDCbf07SVTAPKC4/nYFvAYgDYn9k4AWFOYjN\n38DA/hXKBgY6OzhegOLMDxDiPED1D6BqGMwY5BYA2ZffTy5gYLtrAxJGAACsjztZboL5TAAAAABJ\nRU5ErkJggg==\n", "text/latex": [ "$$\\frac{x^{3}}{16}$$" ], "text/plain": [ " 3\n", "x \n", "──\n", "16" ] }, "execution_count": 65, "metadata": {}, "output_type": "execute_result" } ], "source": [ "limit(f2, y, oo)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bei Polstellen ist es wichtig, von welcher Seite der Limes angegangen wird:" ] }, { "cell_type": "code", "execution_count": 66, "metadata": { "collapsed": false }, "outputs": [], "source": [ "f_pol = 1 / (-27 + x**3)" ] }, { "cell_type": "code", "execution_count": 67, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAABMAAAALBAMAAABv+6sJAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEKvvZom7mXYyzVQi\n3UQ6SGZXAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAaklEQVQIHWNgYBBgAAIQwaj82YGBIayogYGB\nbQLHLwapDQxTGRg8GRj2J6xkYGA5wACUYP0LJBgcQEyGfBDRAGYm/wNqd2BwZGDgiDE+wMBxgIGd\ngSGcYb4dgytQolxtAwNjvXEAUDncNgBJUBUwaYAbUgAAAABJRU5ErkJggg==\n", "text/latex": [ "$$\\infty$$" ], "text/plain": [ "∞" ] }, "execution_count": 67, "metadata": {}, "output_type": "execute_result" } ], "source": [ "limit(f_pol, x, 3, dir=\"+\")" ] }, { "cell_type": "code", "execution_count": 68, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAACMAAAALBAMAAAAHCCkxAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEM3dMqvvZom7mXZU\nIkRJD0iWAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAfklEQVQIHWNggAMBEAtMQIUYw74VMDB0Lt0A\nV8LA6cD9iUHoAIMHQqiEgeH8BBUGBvYLDELGIKDCANTA8RmkC6gdCkC8+SAChCEAxJr2j4GBsQAm\nwlDIwMDdm3aBgfsCXIiLgaGLwT+PoQIuwsC4KvIAA+P6tAaEENThAgwMAMSLGqu/gFQwAAAAAElF\nTkSuQmCC\n", "text/latex": [ "$$-\\infty$$" ], "text/plain": [ "-∞" ] }, "execution_count": 68, "metadata": {}, "output_type": "execute_result" } ], "source": [ "limit(f_pol, x, 3, dir=\"-\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Reihenentwicklung\n", "\n", "Ein Ausdruck wird an einem bestimmten Punkt entwickelt." ] }, { "cell_type": "code", "execution_count": 69, "metadata": { "collapsed": false }, "outputs": [], "source": [ "from sympy import sin\n", "from sympy.abc import x" ] }, { "cell_type": "code", "execution_count": 70, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEYAAAAUBAMAAADCRlZLAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NVLsy\nme8Q6PJIAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABQklEQVQoFWNgwAFYCiAS7A6oCs4pIPjeMKYJ\njAGhzycg+FNgTEkYA4NmvwATYlOAsdBpDgeYCOMDGAtM+xyAcz3gLIapDAxCyq5qCgwMh5Zrsuw3\n4Jl3R8kIJK0LxFCZuwyMCexNHBMYGDcwcDBwGjBwbGLwdwDKb2eAyTBUMrAJsH3kcmBgfcjAxMBt\nwMD9gIEfFDJdDDAZhhUMjAycG4BiDP2bHMBqJjDwKwC5T4HmQGXOA7lgMQax+X/BajbA1cBkQGrO\nHwASLAIM9QEgu6BqgHZBZRgiGLgE9BmYBBi4FBiYC5DUAN0MlQG6OX7BfgZ3oMBDBm4HoCEwc3IZ\nYDIM1xiElYSuAz3Cmq6eymP/Wcb+86n9j4HWRDDAZBjmgKzFBhBxwdKATR4kRkycMmyB6cadNhjg\naQyuGKYJQSOlVQA9/UaYflkNhgAAAABJRU5ErkJggg==\n", "text/latex": [ "$$x \\sin{\\left (x \\right )}$$" ], "text/plain": [ "x⋅sin(x)" ] }, "execution_count": 70, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f3 = sin(x) * x\n", "f3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An der Stelle $x_0 = 0$ mit 10 Gliedern:" ] }, { "cell_type": "code", "execution_count": 71, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAASoAAAAwBAMAAABULipVAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA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\n", "text/latex": [ "$$x^{2} - \\frac{x^{4}}{6} + \\frac{x^{6}}{120} - \\frac{x^{8}}{5040} + \\mathcal{O}\\left(x^{10}\\right)$$" ], "text/plain": [ " 4 6 8 \n", " 2 x x x ⎛ 10⎞\n", "x - ── + ─── - ──── + O⎝x ⎠\n", " 6 120 5040 " ] }, "execution_count": 71, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f3_series_0 = f3.series(x = x, x0 = 0, n = 10)\n", "f3_series_0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An der Stelle $x_0 = \\pi$ mit 5 Gliedern:" ] }, { "cell_type": "code", "execution_count": 72, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAosAAAAqBAMAAAApGwxGAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA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\n", "text/latex": [ "$$- \\pi \\left(x - \\pi\\right) - \\left(x - \\pi\\right)^{2} + \\frac{\\pi}{6} \\left(x - \\pi\\right)^{3} + \\frac{1}{6} \\left(x - \\pi\\right)^{4} + \\mathcal{O}\\left(\\left(x - \\pi\\right)^{5}; x\\rightarrow\\pi\\right)$$" ], "text/plain": [ " 3 4 \n", " 2 π⋅(x - π) (x - π) ⎛ 5 ⎞\n", "-π⋅(x - π) - (x - π) + ────────── + ──────── + O⎝(x - π) ; x → π⎠\n", " 6 6 " ] }, "execution_count": 72, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f3_series_pi = f3.series(x = x, x0 = sy.pi, n = 5)\n", "f3_series_pi" ] }, { "cell_type": "code", "execution_count": 73, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAG4AAAAUBAMAAACezBVvAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMARJkQid3Ndrsyq+9U\nImbvW+pYAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAB2klEQVQ4EY1UP0gbcRT+Lme8/DPJIg4OPVq7\nZOkN4lhFB3EQbaEdrKBuVigNEekkUQpuanBwECHi4qKoi3TrUIpCEdKh4FSy6CjBDCKo1/f97nL+\nhCvxg7zvve+9j9/xu3cBYLzonpgC0VZV1DSkKxwpGItrbpbZGcNTsCdDiXyng+Ikxz/J75fDrAl6\npJ8zD4FMTbK0DXN7/ym+ljyMemQBaK2LL1qRUAz3WewFMA8QtVNSxmoS/lD/jy9lsxlgCs9KLGIH\nEgrM6BsTNr/sdQxS8DHqcdF13SvgOV7JHJC0JawwE595JNyN8/x7Cj5OFLcMHf+drwAXWFV1OSs0\nzrTxnAMYcU5VzwvWV/Imhq2S8E98VuctUZR7ffA5mGYJvHznwXvFWEjQUMY+7fE7TjzyAdfUAhhv\nVBrfipLLGNkS6smyePSciN9QC7CunguRaoZJO3rvZS8XVbtxL6r4YdUwG7i8XZKy18nwjAuk3d3f\nuYoa6GfkfX6TZb+N1fQ1N2w2gTkk+4S6gI2JtyUqPFy27vtMFR/k9e3MFi6V6oWIP7OCRJ8oH7WW\nt2cULF0Ny9tGdVX22kNTn+y1jmW/eK2LYTm/Iw2N77aqaaFp4wC/qV9g6Lwvyv/EP7sqY5gGZbPF\nAAAAAElFTkSuQmCC\n", "text/latex": [ "$$\\mathcal{O}\\left(1; x\\rightarrow\\pi\\right)$$" ], "text/plain": [ "O(1; x → π)" ] }, "execution_count": 73, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f3_series_pi.expand()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Integral\n", "\n", "Sympy kann bestimmte und unbestimmte Integrale berechnen." ] }, { "cell_type": "code", "execution_count": 74, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS0AAAAZBAMAAACWUWXSAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEM3dMnarIkSJZlS7\nme8N5bApAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAENUlEQVRIDc1WXWgcVRT+Znc2s3/dDMVWAqLL\nUtQH0UWpaVE0FNsX0WyFtFQprtJSKUhXFNTSnwXxwQftWpE2Qu2ilKIgRkQELWYRq1LFrCCFSgsJ\n+NMXMYGYtqZxPWfuPXd2frYlb3sg93znnO+c+ebemcwCAcuc/zkQ90twBE/3i5SAjmGM1gKJPgnW\n4WC9T6SEZEy6oUSfhGtjdDhNlcwu84z36lknY2bGpa7Bz7R1w6MVv3OfwF0CxO8//43AqHdaOjcQ\nvp+Xx3/QJft3v683H/hIaKMNQcBtAlcK0N6q4ng9lPPDhMixin6SkdPGZFOl7CvK89qTD6Qb6RGf\nqFG2LalMRZDyAy4K08FUV2TuEW/r7GfKpxYxWO4iahjlG86GL0+5JhCQrAmypgUpXyhjYD6Y6oqG\nDb5ZI60rfRG3FE3RgCjflP7udDR+YcQknzcIt/uQUWLuGrocf0sSddWndVEg5+g8pCq0xvApa43t\nelW2e+MXjzlTVfvOX8Z2ctd2+lu15aVtFeACxwFLzknNOndsAkNjR2E/caJInFTbTF1BkM3ostZT\nxLx9C9jw18YtNDqOT9khvF+5mzyZ1UISiSqSp3GwRvEZSjWya5NF4D2uB+xQQ2oHJuw/7WHkKzcB\nZeLkm2Zqtqh6RJfzFn+GPd6twP0V5xKFMXzKvonj7ueqOz2DFPJV5Kcx2KTUfUDGzczlSOOnitG1\n3mtqJeTmkw3Y82+44PtPTpipOdZJJrqAd+uAx/sW+An4l4pB/sp72NbAxR3c6dmDp2ueriIG+QIX\nab+QaHFplBdpYUwnpGvWEoWjpOVK8upWLhXqkKn2LMWHS6UHSiXaH7bCDAlhHun6GviHU/Ugn2ls\nXFM2dNeSp6tldEEhpUto7PnZU7U090/WgavW4U6bMF9HT/V0UaD3y6HbXqSbZR7p+tHXFeLzANu8\n8I6Lj+t8jloXnSPtxAivr/DSZbk2XtQ1s19LzyF7mTh8Lnpquqx6tK7BOU+Xx/N1xfCp65PULDar\n7lwFA80uXWeAnPskUm70uX8E2Cq1EtEKbaQv09V30yR+jvXU0HNfaCF5ydu93V37FcOnf/SL+VmH\nBrHlZpCv0WbJfh0DDk1MYS+VznkEszjrx8+WpXagiSP2b0g0vnLxHVHoUytTVzRUi96vbBOTFcDj\n0SHqc4zh01nv3Lz9Q3299DuPH7X3LNywZ+HhqT8oR4e3emzVr02CazRFu0Sn0ylLzXp2Ww37x5/B\nayc+qBOBDk+mJkYoJtO68PqF7yli3qbOU5s6O079V43lc09v879Djn5OenO7K8MmkC+G6DKFAIjy\nA+VI0Pu7HaEGEtHv8I2BejiI8sOMUMxPi2fh3zmSj/f5ms5bxXhCKLtcPszvQiMwNDE+NL/zzAXj\neZJdLh/yomZlA2TSdTy/wWwnlbvu2sX/H7obLAYMLEE9AAAAAElFTkSuQmCC\n", "text/latex": [ "$$- x^{2} \\sin{\\left (x \\right )} - 2 x \\cos{\\left (x \\right )} + 3 \\sin{\\left (x \\right )}$$" ], "text/plain": [ " 2 \n", "- x ⋅sin(x) - 2⋅x⋅cos(x) + 3⋅sin(x)" ] }, "execution_count": 74, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sympy import integrate, cos, pi, exp, sqrt\n", "from sympy.abc import x\n", "\n", "integrate((1 - x**2) * cos(x), x)" ] }, { "cell_type": "code", "execution_count": 75, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAABYAAAAPBAMAAAASQyJbAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMpndu3bvImbNiRBU\nq0Qb3U6NAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAf0lEQVQIHWNgYGAQAmIYMIExGBhYUxDsiikI\n9gIEm6MAyI7/////JwaGrQxTGLgWHq0IL2BgWABkyzAsZxVgYOARALIZGBx4NzAw7GIAsRkvMAMF\nzt69++0qA1MDP1AcCIB27d/A/wDM/sLAEMzAtgDEXvL/BoMHAy+YDeKDAQBrfx/PxTZgwwAAAABJ\nRU5ErkJggg==\n", "text/latex": [ "$$4 \\pi$$" ], "text/plain": [ "4⋅π" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sympy.abc import t\n", "integrate((1 - x**2) * cos(x), (x, -pi, pi))" ] }, { "cell_type": "code", "execution_count": 76, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFAAAAAXBAMAAABuYtVKAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEIl2mSJE3e9UMqtm\nzbsXyEShAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABPElEQVQoFW2QL0zDQBSHf7emHaPZ2ix1hHAB\ngSAhwCbHDJlBdSg0poKQYJjAkOAgCByONGBw/JkhqAIWUYMHgSUDg0CMkrverfd25n2/79617w4w\n1uTsh2GyeLEYEllDRBzenF0iq5jxiUzZF3HA2RhXoV8Eex3TOE1nxBT9M9gtPcw6dSqDLi/IUvPy\noTz8KThnAWX/YFiccdlNe4WuLJQ8/8p0iKsJcd0IbS0rn9l6B7zRy53/Sx936OvGnK4R56hqD8eK\nJdiDeXBTYt8ZmI71t1Z8U2K7nQrH5pqjkwlZb3TkCRbWEoFRaHMpVXH2sCGDy3cE2UcIYtUhYfOU\nrUt0nrgg96TxKJ0u988tMqx3o/cV/SrS4HHNir4VaZjgwJKOgg4By3RWioA8zypY/jy6v9lKdJBk\nrb2Y7g+UkjoJ2DHwKAAAAABJRU5ErkJggg==\n", "text/latex": [ "$$e^{- x^{2}} e^{- y^{2}}$$" ], "text/plain": [ " 2 2\n", " -x -y \n", "ℯ ⋅ℯ " ] }, "execution_count": 76, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sympy.abc import y\n", "exp2 = exp(-x**2)*exp(-y**2)\n", "exp2.simplify()\n", "exp2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Integral der Funktion $\\operatorname{exp2}(x,\\,y)$ nach $y$" ] }, { "cell_type": "code", "execution_count": 77, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIIAAAAtBAMAAACQZ671AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAInarRM2ZVBDdiWbv\nuzJCz3LGAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAC7ElEQVRIDaWVTWgTQRTH/7vd1E3aJOtRPDR6\nCNIWqfUDrahB8BBBSFFEQWwUrGIRcyoqgkurBb00gorgwaAg2FMQFLEX6UGr9pDqQS+FYA9ehFQR\njS0S3+xHujszSHd9kJn3/72P3Z2dnQCOdTQsc2WIeUuIGl+JkvPJEKK1EKLIV3Ldp8KI02GKvDV6\n0avC+LEyVPY282GKrRpahokv656sFhskJmZFKCFdSBRixkZJJI6shPqQliHJliGO7b6ALSIYNyXY\ni7ppL6kpIvNWH2/I9i+KyEeUkR9AlKEh1H0RR+j9Mupl+h/gBQG9Duol2qgpMo6cN3CXkFrEWy7C\npH7ihoT6UUe+rUQkXkafP4BY+vPuaOM3Ry251oZtBptb6lHT1vy4oSV3i2dab4WQwgZmm9iQWBxm\nk8SqkbJAv15lqxWxrk3ONSvh2BE+b9Uc2Scg6SYuJ5yz3GcuiKWYdyXPRpnVUOXxZgvcdLH+knnN\nW3KxMysLj1HiGKwOSrGJDzW9pqM/SDv3rvfu7zQdrgw9NPZNXeqfn2Et1DwwchLKNDDoJHimrKGU\nPNJxs6Y2jVcXlrCLAXrzKF2GugA8FXKV1xirCpRttikcJW51iBagFE4hXgHEr6bl3frnYoPEz8nJ\nnTjodmjPQKeOyRRQg/1H0xyR7BHrgbZfjB6mn3UP1AFaHbUq68BbssQTphPf2djsQE+B1hy6iYnn\nT3sJSFGEs9u0+Msd2ErGe/CBksSVVHMYM7hykrUyzuAOOXMsFsvTPVS0JXLPMu23dBddQDB9W6d5\noPER8433FNOK9Nn3pb+Re1xIXRmwdjWtBNzdqQzOVVdW6mTRl7UV4xl6npRNRhGTnnBOvjjFDdwD\nex776wY75mfEtH8QOmH2pquUMOskvQH2ML1y851yVDZgBu0gudZ9UwKDIG0xSLYsN9ojo0GY5KgJ\nUm4fW8Eq+OxhKAbPAulEHur/dVgz8WhHoEsKyQMN+f+rkCgBfwFcMqmBzO4cXAAAAABJRU5ErkJg\ngg==\n", "text/latex": [ "$$\\frac{\\sqrt{\\pi}}{2} e^{- x^{2}} \\operatorname{erf}{\\left (y \\right )}$$" ], "text/plain": [ " 2 \n", " -x \n", "√π⋅ℯ ⋅erf(y)\n", "──────────────\n", " 2 " ] }, "execution_count": 77, "metadata": {}, "output_type": "execute_result" } ], "source": [ "integrate(exp2, y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bestimmtes Integral:\n", "\n", "$$\\int_{-\\infty}^{\\infty}\\!\\int_{-\\infty}^{\\infty}\\!\\!\\operatorname{exp2}(x,\\,y)\\,\\mathrm{d}x = ?$$" ] }, { "cell_type": "code", "execution_count": 78, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAwAAAAJBAMAAAD0ltBnAAAALVBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAOrOgAAAADnRSTlMAdpmJMlQiZrurEN1E71u8\n6TcAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAA+SURBVAgdY2CQe/fu3SMGZpPAdLEEBlcGM0YHBiBo\n4FwAJFkmcIM4TAV8IN66BXwHgJQ0A68BkGpn4DRgAADO5AwIf9stDwAAAABJRU5ErkJggg==\n", "text/latex": [ "$$\\pi$$" ], "text/plain": [ "π" ] }, "execution_count": 78, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sympy import oo\n", "integrate(exp2, (x, -oo, oo), (y, -oo, oo))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Unausgewertete Ausdrücke\n", "\n", "Viele der bislang vorgestellten Funktionen haben äquivalent dazu Kontruktoren für Ausdrücke.\n", "Diese können wie gehabt dargestellt werden,\n", "es sind Substitutionen möglich,\n", "und werden mit der `.doit()` Methode ausgewertet." ] }, { "cell_type": "code", "execution_count": 79, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAI8AAAAmBAMAAAAPXtWGAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMqvNiRDvuyJ2mUTd\nZlSFEfbmAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAC9klEQVRIDY1WTWgTQRR+22SbtGmanLwIJhgQ\nVCQxQcGDsCBWAiKxij9YaC0evIgFwR96aCJS8JTYihCDJPFUf/FkvVlEtIeiQUTwUJqT4KkSFPzX\nmTc7m/nZbDKEmfd973tf3s7uZAPgMVY9ckJqVIhdw4GUK62RoW66pzm1pk9jUDGn6mRsnpYxQGgk\nr1KIfQ1XmpN9cR4561DeCcUg+E1EWhzLa1QHI9isKUUiLQIWdzKKue8dKwp+793IV9K1DjO45IRO\n0Kmj8IQj0YN+/VuM6mNdR5ngL+SNhAUbtLJi1L3IlT3D2GNxiFmqYE0lIPKPDJX9lKNMgtGBOFul\n+aGEVPCZEea2JBpVGXQ1eq3WStg2Aqii0Xoes8SooO3IT6lQBYpRrGkbBWfixu56eWuoPM1LfvAA\n16PlBYDr2XecVIzGG5ggHfniMHQFihX4YEvNP7yGrqFluAbQXPRzUjGKlDBBjOhnAiJTwE9YUDKa\nbZp1Ii1zH1CNLNEoBRELYvZmGX9p6sgKHTthy8c7OQBrOoz6fZnMq0yGnUW22ZEaJuyOpoB06BhJ\nHbVQt+PmDVzJpHZUw4SbkXxpX7kBXxWjcaujkSndNXIEBrgHropR0b5rUxDAj3BpIDUxDya5/cJQ\njNhzZCRbhWTrcLK1aWbS//alLZ8UymDg3qoI23t093yaNvP8iZwW0QURaLHTEcuskXvaaYx0SiB/\nQs56idc9vkR2IeiFxrQJ+/i0CY9IPk/KfpGHq+cxTF8U2fpcFCsqZD75iJzxQwg9f9BR0Z4GU+Q5\nyyWGWC/HAczti2fDC0aJSkw8bG2xV9TfADBgry0xLtOn9+JtgGfIzHuVyrlbCMn1HbhEx+88Odw+\n8h4fRr4/Kqs90DmaM74YTBK2gBgFVgA2IhFOMb77jH+kiv4l+2fvKmklCg/Gdpk1VrunuwVTzObJ\nOlrJ7meQnsr396PmwXSOEWM9Xpv5hun5bJdzSF7Ey+3YKwo0vLI0V+gmYPlTdPkPokakvYma0SwA\nAAAASUVORK5CYII=\n", "text/latex": [ "$$\\lim_{x \\to \\infty}\\left(- e^{\\frac{1}{x}} + 1\\right)$$" ], "text/plain": [ " ⎛ 1 ⎞\n", " ⎜ ─ ⎟\n", " ⎜ x ⎟\n", "lim ⎝- ℯ + 1⎠\n", "x─→∞ " ] }, "execution_count": 79, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sympy import exp, sin, Limit, latex, oo\n", "from sympy.abc import x\n", "\n", "limit_expr = Limit(1 - exp(1 / x), x, oo)\n", "limit_expr" ] }, { "cell_type": "code", "execution_count": 80, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAOBAMAAADkjZCYAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJmJZjLNVN0i77ur\nRHZ72Yd1AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAVElEQVQIHWNgEDIxZWBgSGeQmMDAsoCBOYGB\n+wAD+0cG/gMMvN8Z5BUYeP8xzDdgYP3MMF8BREJEgLLs3xm4NzCwfATpYkpgYGhnkApgYBB+d5QB\nAPogE3QldevOAAAAAElFTkSuQmCC\n", "text/latex": [ "$$0$$" ], "text/plain": [ "0" ] }, "execution_count": 80, "metadata": {}, "output_type": "execute_result" } ], "source": [ "limit_expr.doit()" ] }, { "cell_type": "code", "execution_count": 81, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/latex": [ "$$\\int \\frac{2 x + 2}{- \\left(x + 1\\right)^{2} + 4}\\, dx=- \\log{\\left (x^{2} + 2 x - 3 \\right )}$$" ], "text/plain": [ "" ] }, "execution_count": 81, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sympy import Integral\n", "from sympy.abc import y\n", "from IPython.display import Math\n", "\n", "int_expr = Integral((1 + x + y) / (4-y**2) , x)\n", "int_expr2 = int_expr.subs(y, 1+x)\n", "\n", "Math(latex(int_expr2) + \"=\" + latex(int_expr2.doit()))" ] }, { "cell_type": "code", "execution_count": 82, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAALEAAAAuBAMAAACVN+VgAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAmYkQdqvvRN27IjJm\nVM1kwppwAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEM0lEQVRYCa1XPYwTRxR+3l2fd723t6eIFIjo\nMOEKultFd5SwBwdSKp8SQEoU5YyAAgqwIroUPkUUICHOKICEKOykSJpEXBUpaewSRVGwFCkFCOEi\nRaIoh8N/Aocz897s7Iy9e7eOmGL2ve9979vdNzPPawAaubcDbryxU/iv73Jg9yITs94/kV3SO5aF\naz6zQ8bbWz03wPY4rI0ImXvzkYanOFYPA+WhcKQTByRiZVK265h6IRYQltSREYlkU74Z8sziY8o3\nFz48O02m0DHnQ/gK1xhGVC5XuZD1jOTegVvhJU3Z8CpQ1hDGzlSNBj6PI7g7YSa4o+l8m+vCdQ3J\nqvwUs/wKJQfwBxrG2trvp9fWFgGCsRB4qWIko7L7BJVaTIOGKDjIqtYC9wWFRquzRUrlUAhHKrHy\nFFiV/6Ps0NI1cB0BfmHbe7+ucxUc8UKjPbNPS9cPUK6w7vSKbV15K9QGkGx7o7XMddznfAYwD+2f\n/4lMWee56e1NgqJnzh159ZEgbXC5jW86Tuuo8SIdgCmBx4gkfn9UmgCaA0shD+XljoiJZhPtfNcU\npwgEElOYta56mrOCS2dHySqPbLvthMNohBTU06g5Ji3dXpUQZdG1sLBNBzTPWFZczfHoCN6vKIRR\nzIlJha05xj8YmakrhOzmF9OtDswe+HpfyHK4ozTGiYeo86CElxGnwiloBGZp/JzdBUBHaYw+LWe/\nM6Io0ne32YY0AuOR1wRAR2mMN//lnGKfhfjw+1lHj7G3B/AZmDBR56noRI2R+fc5A7w+n0ceJwG3\nuh/yTHLixjjT5ajxis+jDvMhePzBWqtsEk7cGBuTXM/5m8+JY8flIBFnoLkOTveOF5TBCoQDcWM8\n0+F5Y9qxVJWMZr6r+pr9G9xaLNU6DfiGweiAbIybHkG76eIaa4qRM7fvh0PVuYXZt9oMQQdkYyzQ\nEaxVIvLg1a4Wh1qKixUcZEa+aIwWdc/yYoQPX72hliK+fYaprGfKxph/ifGldhKNMPzqY2bcnA/W\nU9lxY7TpV3llNZULO0RIKhd/TleOG6Pfw7wNDsr45KCyQWcu/Vkw0sLbu9TwBrizW6B4DD6BTwmX\nz/xjJuVyiadZ1PBIQc6lX8HquX/d+5yQSNkMMykvVXlafmhjMbDYmQKnPtbvU8HkChqiA9H9UucV\njNgimWh7zvPxpwnHgXoNg5WPurvZlKkT+V3S1Gf2e4m9RqCiGmYpk7JLBW6VdE3ycl04qOBC2Tt8\neOlEqODJ5jht59urSWH2NXdVwaMVZP2rrsApZr6CgSOJ4Vy9QCeUorGyn0HZL2FW4qYD8715tc1J\nZaPxpE0322CuYRkKVJNhHqt0PKRyDKVau+ADFjOW88lv9zH796nkmk3F2cS85p5iDKfyXXLORbiy\niUBq+Mt3eTGK0zeSGWfnsVbJwQ3R/wB2gzuRlYOkSwAAAABJRU5ErkJggg==\n", "text/latex": [ "$$\\iint \\frac{x + y + 1}{- y^{2} + 4}\\, dx\\, dy$$" ], "text/plain": [ "⌠ ⌠ \n", "⎮ ⎮ x + y + 1 \n", "⎮ ⎮ ───────── dx dy\n", "⎮ ⎮ 2 \n", "⎮ ⎮ - y + 4 \n", "⌡ ⌡ " ] }, "execution_count": 82, "metadata": {}, "output_type": "execute_result" } ], "source": [ "int_expr_xy = Integral(int_expr, y)\n", "int_expr_xy" ] }, { "cell_type": "code", "execution_count": 83, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAv8AAAAyBAMAAAA5PKlSAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA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\ngg==\n", "text/latex": [ "$$\\frac{x}{8} \\left(x - 2\\right) \\log{\\left (y + \\frac{2 x \\left(x - 2\\right) + 8 x}{x^{2} + 2 x} \\right )} - \\frac{x}{8} \\left(x + 6\\right) \\log{\\left (y + \\frac{1}{x^{2} + 2 x} \\left(- 2 x \\left(x + 6\\right) + 8 x\\right) \\right )}$$" ], "text/plain": [ " ⎛ 2⋅x⋅(x - 2) + 8⋅x⎞ ⎛ -2⋅x⋅(x + 6) + 8⋅x⎞\n", "x⋅(x - 2)⋅log⎜y + ─────────────────⎟ x⋅(x + 6)⋅log⎜y + ──────────────────⎟\n", " ⎜ 2 ⎟ ⎜ 2 ⎟\n", " ⎝ x + 2⋅x ⎠ ⎝ x + 2⋅x ⎠\n", "──────────────────────────────────── - ─────────────────────────────────────\n", " 8 8 " ] }, "execution_count": 83, "metadata": {}, "output_type": "execute_result" } ], "source": [ "int_expr_xy.doit()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Extrahieren des symbolischen Ausdrucks aus dem nicht-evaluierten Integral `int_expr` via `.args[0]`.\n", "Daraus wird ein bestimmtes Integral über `x` und `y` zusammengebaut:" ] }, { "cell_type": "code", "execution_count": 84, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMIAAABKBAMAAAAbLJa3AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMs2Zq91U7yJ2iRBE\nu2Z2muS3AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAE2UlEQVRYCe1ZT2gjZRR/0yTTZCZpQj14TIju\nUaxlPbiyGpaVtYq2LIoW1MaDriJLg+xBEdyAoiBiR7qw1FUyCgvWPXQOBa2X5CZ7SpSFRWRJUIQ9\n7ca11j+txm++P/PebDJhsp0elH6Hmd/vfe+9X+Z7872ZdgDUmFSAnbUCO0Q9bnsIM2oH55BEh14g\nqfR9BbIaFO6vEl2NILz3q3SCSOsVQqKCby3MeKmS925aHtkH/7sVOHQBLyn2hYMkKpR69BSmOvNl\nCUlUqN6Y91KZO4nwt6v+hhc3HNTIdKpLCId6v+LLwmf94PbNzgH8WWJPtAjhMFgBUiEVkn+SpEt9\nvzgChdQOUag1BNk48/5HQkwpbNwHSbnucpVCX0OGXmvb4QqmPTGfKHCoFOwToIo0qkK2In42P/4u\nsOEY23qVY6mQLE9DpiVmR1XIl0Sce9Q2BTZhjGczisUDrxaLJQATXoesxWY/KxafKhbvdP3CVrrm\nxsmR8qrOs7lWtUrpbcjnhNuo19BuiDj3mPGqrrJ5CrECnJWOoyr0HFTIyqrrTg1Swq6uIVOCS7em\noP2GApCfE6RZbsMHAiqFWCv9z60pTMji8ujrJZFkfWXjgY6ASsF8ZPkPYQG5SrFjNx6XlqGnuFdc\n5jZr9fkqBQBWCTFUHdBXuzwVQJg54RWXkYUGOkpkVgU4AvWGNH0lz+SULQcRgDrZ0iatOglx4XPw\n/U0WSpvithAmHwFYrKCnLrc0WhBdXM4h6UPnqcVHANZaOGn8jXg0dAd19xGAu22cHPsL8QgoeejD\nLTBXHr64yoI4IY0YoFfGXNktxCOgb6qsP38NP1vHWRAnpBFDslfFXEvqjkdTCGS+6d7IF2DNeYl1\nSJfQRgx6j+RY7ErSCz1YQGwbEjY4cJcbzInXiF2LccM9yrFWUGiU83hLbBW+dQUhjRgyv5Jk7SlC\nQsO6DYvMWfvFjRCENGIYp8U9XXadBg3j8P2DzNxWL8N3evUV9ow9xxQ4IY047Jb+HI4EKoxZE08Y\n6a1MN9kB4ARII4ZmBSPTwVv6achX0dGPzJlP3/7YnDm3fI3ZOQHSiKFWQvcUbeRodtEzsNTwW0Ab\nWjSvEcNsBwPj6hGDJkSLDmKO+l8P0YE0YljIoT3B7wbkPjQvmfdwONvyzfsIbcR0w2W7PjcfMaYk\nVQrJH4cokEas0W6aHxLzk9JTCoZ4o1LmwHOKdtOaPcDPXLbgXSdtp3NiUilcDakQ3yFJZxuEKGiw\nP+JrMPniSUdYpIJphVRIdFUmdl4g2IPvsPvuCpzuqYJJBUO+d3p+QSBbIDO0CYJ54Ek2jueccQt4\nT3Md8aX1+bAKeRsVNFoTNDcd0dOkRVyDaYdVuC7r54ZPDN4O05CqoJ58HdOPHp09ZRFzIDxGZuI0\nEdovAeuUOGQdANiTIMygC5O1B0YchmaHTHgK2VAKabowzRxJhHB99cEqMvXSCkZ7s0PMg6ExF8ff\ncR4eG+wFME0nvGugxiCcqdxe9eYua695mIJ4waS7Ega8tFJ3P06ufouG9z4ZvEiJTsZCr71A6ZV7\n9iJtpDm1Akk3SXBU0Pc9gH4oiEqA/b08R3LRf+4S8+7gvkKY9dvDVTp5hQ1HVFp38Q8A/9VKV8ha\n0g8FxLwr6PseQD8U7CorD/4XX4pq+a1VCl4AAAAASUVORK5CYII=\n", "text/latex": [ "$$\\int_{-1}^{1}\\int_{-1}^{1} \\frac{x + y + 1}{- y^{2} + 4}\\, dx\\, dy$$" ], "text/plain": [ "1 1 \n", "⌠ ⌠ \n", "⎮ ⎮ x + y + 1 \n", "⎮ ⎮ ───────── dx dy\n", "⎮ ⎮ 2 \n", "⎮ ⎮ - y + 4 \n", "⌡ ⌡ \n", "-1 -1 " ] }, "execution_count": 84, "metadata": {}, "output_type": "execute_result" } ], "source": [ "int_expr_i2 = Integral(int_expr.args[0], (x, -1, 1), (y, -1, 1))\n", "int_expr_i2" ] }, { "cell_type": "code", "execution_count": 85, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAADcAAAAUBAMAAADbzbjtAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMqvNiRDvuyJ2RN1U\nmWaBK2/dAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABVklEQVQoFW2Sv0vDQBTHv2l6TZqmov0HXEWX\nDk4uZgiIQiGDuHRRBwVxkC4ughkcBK04FKSTwcE5Yx3UbI5mcxLc1EGx+AsVje/dpQipb7h77/vJ\nfe/y7oC+2FPKHU2V8Qw112C6UxFyPiAWM1D30YT9A1El0MjAB+Awwhcw/Q/sAMeBeAbm+qEZshPZ\nQg+k7Wx7Bjiq3R+QXIwZ1h2gTFkDWgfGvvWKsyLJxg0NW6ceMFBlWHKgdXMhxkhGKeIxv0LWIcNh\nql/K8woWAoZY8qA9Mbyk+t3silVWGW4Dm1EKeeW32WoNMmTbxGNoSdtCDOvTDhipAy0D57480Dq0\nBeiONTHkM8zHwCPsD/oVB5VkBE13FJhM3kiXZtb1VUBNkNvwAhiR2D3hhNqnYqeXABeU3nJJjVfB\njU+jTiYbnBu+UuSVqRTCbdfkJnTZMnofpTyd/p7JLxSLVaTvtDPjAAAAAElFTkSuQmCC\n", "text/latex": [ "$$\\log{\\left (3 \\right )}$$" ], "text/plain": [ "log(3)" ] }, "execution_count": 85, "metadata": {}, "output_type": "execute_result" } ], "source": [ "int_expr_i2.doit()" ] }, { "cell_type": "code", "execution_count": 86, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJ4AAAAPBAMAAADnkWuuAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAVO8Qq5l2zWbdiTIi\nu0T8UsK3AAAACXBIWXMAAA7EAAAOxAGVKw4bAAACYklEQVQ4Ea2UPWgTYRiAn/RLmv/2UAe3Rjo4\nWPQoYnFKLRSKgg2SUihYOliFKjTQDoKgR5UOXcwgCCKYwdZSkWTQxaVZxMWh+DNp4TZxirZKqrbG\n994vpdJ29IbnQp77nrxf7hJoHmZkroIZeVzFXJ73IbHwtGleXfwICjVWszRRQXFqYnS7oedQp56i\njnlIt5fqIgJnMDcZlvcPuJheyr7CGtX0+JGCRY6wA1oJcDK/rr0ZeEIf9HMYXpPOsYrpH3QJu7Rk\nFNao5gPpFUXII1WwFZtqtb330OHWocwzOE2tqp8yKbEi4d8Ka1S3bYpWJFYwRdDKDuA71A5uwWSl\n9o5F3moO6UXXpadAjSKdEa9o23IT3t6e+SG9saMynx9uzHnUX477skR6csSDLQjUKNpvLIyiYHBj\nUezOaHa/qV+wXCrDLY9y3TV1jyNyme3VSvIygBiL7HVaHAWJxpTYPT2Zb7kUHQuVndD5R8dNw+WC\nrLW9e7IAQWAssutEOhUc+rLm7+3Z/TJ7tVy5Q+ua+xPuymXai+QkF0CNor1I7I8i1sukPCa75wvu\nR4cj6wbdLpnUuS89r9kbl7cJoEYRLxDbULRUSX7bp7cqAdkg0+YrhD15ErfnC+V4QwA1t1WHMzKf\nIitrBvbpyfM8zEw1uRlMka4uy/cnVwb7fQHXLNQokvL9ZRQyH59297IF4o45xhW3x+Ozyyzhkmne\n39SDpXxRYY1qztLtKNqmiI3904v01QeI92IWLlVIDMlvO9k/78N8vgL5E9NetNFoFBXWWJ0YOif/\nGQGej8garShkU//z+AuZTwVjs9zSWwAAAABJRU5ErkJggg==\n", "text/latex": [ "$$1.09861228866811$$" ], "text/plain": [ "1.09861228866811" ] }, "execution_count": 86, "metadata": {}, "output_type": "execute_result" } ], "source": [ "int_expr_i2.doit().evalf()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Der interne Graph des Integralausdrucks `int_expr`:" ] }, { "cell_type": "code", "execution_count": 87, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "%3\n", "\n", "\n", "Integral(Mul(Pow(Add(Integer(4), Mul(NegativeOne(), Pow(Symbol(y), Integer(2)))), NegativeOne()), Add(One(), Symbol(x), Symbol(y))), Tuple(Symbol(x)))_()\n", "\n", "Integral\n", "\n", "\n", "Mul(Pow(Add(Integer(4), Mul(NegativeOne(), Pow(Symbol(y), Integer(2)))), NegativeOne()), Add(One(), Symbol(x), Symbol(y)))_(0,)\n", "\n", "Mul\n", "\n", "\n", "Integral(Mul(Pow(Add(Integer(4), Mul(NegativeOne(), Pow(Symbol(y), Integer(2)))), NegativeOne()), Add(One(), Symbol(x), Symbol(y))), Tuple(Symbol(x)))_()->Mul(Pow(Add(Integer(4), Mul(NegativeOne(), Pow(Symbol(y), Integer(2)))), NegativeOne()), Add(One(), Symbol(x), Symbol(y)))_(0,)\n", "\n", "\n", "\n", "\n", "Tuple(Symbol(x))_(1,)\n", "\n", "Tuple\n", "\n", "\n", "Integral(Mul(Pow(Add(Integer(4), Mul(NegativeOne(), Pow(Symbol(y), Integer(2)))), NegativeOne()), Add(One(), Symbol(x), Symbol(y))), Tuple(Symbol(x)))_()->Tuple(Symbol(x))_(1,)\n", "\n", "\n", "\n", "\n", "Pow(Add(Integer(4), Mul(NegativeOne(), Pow(Symbol(y), Integer(2)))), NegativeOne())_(0, 0)\n", "\n", "Pow\n", "\n", "\n", "Mul(Pow(Add(Integer(4), Mul(NegativeOne(), Pow(Symbol(y), Integer(2)))), NegativeOne()), Add(One(), Symbol(x), Symbol(y)))_(0,)->Pow(Add(Integer(4), Mul(NegativeOne(), Pow(Symbol(y), Integer(2)))), NegativeOne())_(0, 0)\n", "\n", "\n", "\n", "\n", "Add(One(), Symbol(x), Symbol(y))_(0, 1)\n", "\n", "Add\n", "\n", "\n", "Mul(Pow(Add(Integer(4), Mul(NegativeOne(), Pow(Symbol(y), Integer(2)))), NegativeOne()), Add(One(), Symbol(x), Symbol(y)))_(0,)->Add(One(), Symbol(x), Symbol(y))_(0, 1)\n", "\n", "\n", "\n", "\n", "Add(Integer(4), Mul(NegativeOne(), Pow(Symbol(y), Integer(2))))_(0, 0, 0)\n", "\n", "Add\n", "\n", "\n", "Pow(Add(Integer(4), Mul(NegativeOne(), Pow(Symbol(y), Integer(2)))), NegativeOne())_(0, 0)->Add(Integer(4), Mul(NegativeOne(), Pow(Symbol(y), Integer(2))))_(0, 0, 0)\n", "\n", "\n", "\n", "\n", "NegativeOne()_(0, 0, 1)\n", "\n", "-1\n", "\n", "\n", "Pow(Add(Integer(4), Mul(NegativeOne(), Pow(Symbol(y), Integer(2)))), NegativeOne())_(0, 0)->NegativeOne()_(0, 0, 1)\n", "\n", "\n", "\n", "\n", "Integer(4)_(0, 0, 0, 0)\n", "\n", "4\n", "\n", "\n", "Add(Integer(4), Mul(NegativeOne(), Pow(Symbol(y), Integer(2))))_(0, 0, 0)->Integer(4)_(0, 0, 0, 0)\n", "\n", "\n", "\n", "\n", "Mul(NegativeOne(), Pow(Symbol(y), Integer(2)))_(0, 0, 0, 1)\n", "\n", "Mul\n", "\n", "\n", "Add(Integer(4), Mul(NegativeOne(), Pow(Symbol(y), Integer(2))))_(0, 0, 0)->Mul(NegativeOne(), Pow(Symbol(y), Integer(2)))_(0, 0, 0, 1)\n", "\n", "\n", "\n", "\n", "NegativeOne()_(0, 0, 0, 1, 0)\n", "\n", "-1\n", "\n", "\n", "Mul(NegativeOne(), Pow(Symbol(y), Integer(2)))_(0, 0, 0, 1)->NegativeOne()_(0, 0, 0, 1, 0)\n", "\n", "\n", "\n", "\n", "Pow(Symbol(y), Integer(2))_(0, 0, 0, 1, 1)\n", "\n", "Pow\n", "\n", "\n", "Mul(NegativeOne(), Pow(Symbol(y), Integer(2)))_(0, 0, 0, 1)->Pow(Symbol(y), Integer(2))_(0, 0, 0, 1, 1)\n", "\n", "\n", "\n", "\n", "Symbol(y)_(0, 0, 0, 1, 1, 0)\n", "\n", "y\n", "\n", "\n", "Pow(Symbol(y), Integer(2))_(0, 0, 0, 1, 1)->Symbol(y)_(0, 0, 0, 1, 1, 0)\n", "\n", "\n", "\n", "\n", "Integer(2)_(0, 0, 0, 1, 1, 1)\n", "\n", "2\n", "\n", "\n", "Pow(Symbol(y), Integer(2))_(0, 0, 0, 1, 1)->Integer(2)_(0, 0, 0, 1, 1, 1)\n", "\n", "\n", "\n", "\n", "One()_(0, 1, 0)\n", "\n", "1\n", "\n", "\n", "Add(One(), Symbol(x), Symbol(y))_(0, 1)->One()_(0, 1, 0)\n", "\n", "\n", "\n", "\n", "Symbol(x)_(0, 1, 1)\n", "\n", "x\n", "\n", "\n", "Add(One(), Symbol(x), Symbol(y))_(0, 1)->Symbol(x)_(0, 1, 1)\n", "\n", "\n", "\n", "\n", "Symbol(y)_(0, 1, 2)\n", "\n", "y\n", "\n", "\n", "Add(One(), Symbol(x), Symbol(y))_(0, 1)->Symbol(y)_(0, 1, 2)\n", "\n", "\n", "\n", "\n", "Symbol(x)_(1, 0)\n", "\n", "x\n", "\n", "\n", "Tuple(Symbol(x))_(1,)->Symbol(x)_(1, 0)\n", "\n", "\n", "\n", "\n", "" ], "text/plain": [ "" ] }, "execution_count": 87, "metadata": {}, "output_type": "execute_result" } ], "source": [ "expr_to_dotgraph(\"sympy-int\", int_expr)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Anaconda (Python 3)", "language": "python", "name": "anaconda3" }, "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.5.1" } }, "nbformat": 4, "nbformat_minor": 0 }