{
"metadata": {
"name": ""
},
"nbformat": 3,
"nbformat_minor": 0,
"worksheets": [
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[](http://cse.illinois.edu/)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# SymPy\n",
"\n",
"## Contents\n",
"- [Introduction](#intro)\n",
"- [Printing](#printing)\n",
"- [Gotcha!](#gotcha)\n",
"- [Basic Operations](#ops)\n",
"- [Trigonometry and Powers](#trigops)\n",
"- [Calculus](#calc)\n",
" - [Derivatives](#deriv)\n",
" - [Integrals](#int)\n",
" - [Limits](#limits)\n",
" - [Series Expansion](#exp)\n",
"- [References](#refs)\n",
"- [Credits](#credits)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"# Introduction\n",
"\n",
"## What is symbolic computation?\n",
"\n",
"Symbolic computation deals with the computation of mathematical objects symbolically. This means that the mathematical objects are represented exactly, not approximately, and mathematical expressions with unevaluated variables are left in symbolic form.\n",
"\n",
"If that did not make any sense to you, let's give it another shot with an example.\n",
"\n",
"Let's look at the `sqrt` function in Python's `math` module."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"math.sqrt(9)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 2,
"text": [
"3.0"
]
}
],
"prompt_number": 2
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"But this was an easy one because 9 is a perfect square! Now let's look at some number which is not."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"math.sqrt(28)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 3,
"text": [
"5.291502622129181"
]
}
],
"prompt_number": 3
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here we got an approximate number, because the $\\sqrt 28 $ is an irrational number, so it cannot be represented in finite precision. If this is all that we wanted, we'd be happy with this approximate result.\n",
"\n",
"But if we think a little further, $\\sqrt 28 = 2\\sqrt 7$ and there is no way for us to deduce this from the approximated result. This is where symbolic computation comes in. With a symbolic computation system like SymPy, square roots of numbers that are not perfect squares are left unevaluated by default."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import sympy\n",
"sympy.sqrt(28)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 4,
"text": [
"2*sqrt(7)"
]
}
],
"prompt_number": 4
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"sympy.sqrt(9)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 5,
"text": [
"3"
]
}
],
"prompt_number": 5
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"** A more interesting example **\n",
"\n",
"The above example starts to show how we can manipulate irrational numbers exactly using SymPy. But it is much more powerful than that. Symbolic computation systems (which are also often called computer algebra systems, or just CASs) such as SymPy, Mathematica etc. are capable of computing symbolic expressions with variables.\n",
"\n",
"Let us define a symbolic expression, representing the mathematical expression $2x+5y$."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from sympy import symbols\n",
"x,y= symbols('x y')\n",
"expr= 2*x + 5*y\n",
"expr"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 6,
"text": [
"2*x + 5*y"
]
}
],
"prompt_number": 6
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We write 2\\*x + 5\\*y just as we would if x and y were ordinary Python variables. But in this case, instead of evaluating to something, the expression remains as just 2\\*x + 5\\*y. Now let us play around with it:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr +1"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 7,
"text": [
"2*x + 5*y + 1"
]
}
],
"prompt_number": 7
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr - x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 8,
"text": [
"x + 5*y"
]
}
],
"prompt_number": 8
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Notice that when we typed expr - x, we did not get 2\\*x + 5\\*y - x, but rather just x + 5\\*y. The x was automatically subtracted from the 2x . This is similar to how sqrt(28) automatically turned into 2\\*sqrt(7) above. This isn\u2019t always the case in SymPy, however:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x*expr"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 9,
"text": [
"x*(2*x + 5*y)"
]
}
],
"prompt_number": 9
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Aside from obvious simplifications like 2x\u2212x=x, most simplifications are not performed automatically. This is because we might prefer the factored form $x(2x+5y)$, or we might prefer the expanded form $2x^2+5xy$. Both forms are useful in different circumstances. In SymPy, there are functions to go from one form to the other"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from sympy import expand, factor\n",
"expanded_expr=expand(x*expr)\n",
"expanded_expr"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 10,
"text": [
"2*x**2 + 5*x*y"
]
}
],
"prompt_number": 10
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"factored_expr=factor(x*expr)\n",
"factored_expr"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 11,
"text": [
"x*(2*x + 5*y)"
]
}
],
"prompt_number": 11
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Snippets of Symbolic Computation**\n",
"\n",
"The real power of a symbolic computation system such as SymPy is the ability to do all sorts of computations symbolically. SymPy can compute derivatives, integrals, and limits, solve equations, work with matrices, and much, much more, and do it all symbolically. It includes modules for plotting, printing (like 2D pretty printed output of math formulas, or LATEX), code generation, physics, statistics, combinatorics, number theory, geometry, logic, and more. Here is a small sampling of the sort of symbolic power SymPy is capable of, to whet your appetite."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from sympy import *\n",
"x,t,z,nu= symbols('x t z nu')"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 12
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This will make all further example pretty print with unicode characters."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"init_printing(use_unicode=True)"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 13
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Take the derivative of $sin(x)e^x$"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"diff(sin(x)*exp(x), x)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$e^{x} \\sin{\\left (x \\right )} + e^{x} \\cos{\\left (x \\right )}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAALsAAAAVBAMAAADsqILHAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEIl2mSJE3e9UMqtm\nzbsXyEShAAAClklEQVQ4EZWVTWgTURSFz0ycpJ00yVAiCAWNBgXRYppUQVohKG5czUZwITroQoVC\ngyC4ESnWhdBFtQiuNFDQYhUj4kYU/EUQwSAuTQ0UQRAl+FOsivG+vDcvb34i8S4mZ86938nkzgwB\nWpXdM1Lm6j+OXUMR60HMCQm+IbwXIT10ghCgTLx1A8wzrgKMutDxctuUSoGkx0QY9d2dML+4CkhY\nrq66wvMpIY8bQpkN0zPCT/LSc9VK6ZAIh+DOQqqDeklXQaHPSm+VUDPSATpACFID27JDAjSuy4Ro\nScrENJdqvALJORI+SssO26Jtbi9UD/zCzcnZkRxZehHQCncPZ7kkB268AiG9biO0bN7B7MwOGtGL\nHuqIbWTAazVQwkdgIWewu5Z8CPTjee4U0FflE268AhnnMGdfs7Go1RELUNRNlzmLoxYyLP4D8Jus\nGG1kLbZYF4HeEh8R8SqUqOJK+Thw6+oE2A30UvGpwiORjtifrWDxn4Cv5PU4gIUF1jUb7CiXo0Jr\nitReBlKZ04s2jXipVIVhvLTBZpHFf27Hc8XjB2u1k7XaG5pVofEc/bgl8ur9775Rj8W3qVSGnfHa\ni74lJZ79TJg/obUfB7EcFZJXv9vGK4cvp031ZAD6/lZdAO4r8ezWno80QM+s79aqEO0e05PA+LEM\n4kR4qUgVaZun45KF92wzYjl6BdHlZMMgZkWRj4irVyFjCro9V8br3gkkKclHDY8SzuvQk8fOfPP2\nfPPe5R+V1ka0O0P5l9RMOHxCxEOBMLBrPYydm5zo5tENNEWvlZ/ibOB4Qjr7hHLjZSNEBKmQIWY9\nlT69uK0ak05nEaQ6zLJVtkqrdpgIs7um5B+DJMLi/F731H6BPvNH/PNcof4C2uW7P/izEjkAAAAA\nSUVORK5CYII=\n",
"prompt_number": 14,
"text": [
" x x \n",
"\u212f \u22c5sin(x) + \u212f \u22c5cos(x)"
]
}
],
"prompt_number": 14
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Computing the $\\int e^xsin(x)+e^xcos(x) dx$."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"integrate(exp(x)*sin(x) + exp(x)*cos(x), x)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$e^{x} \\sin{\\left (x \\right )}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAE8AAAAVBAMAAAD1D64kAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEIl2mSJE3e9UMqtm\nzbsXyEShAAABhElEQVQoFX2Su0vDUBSHf0mNrenDIB0EQSqZxb4UpA6dnboIDqJBBx2zODqpg+Cg\nguAkBTerUBEXUfCJIA75A6S4CIIoQVF8YT23ufc2Q+0Zcj9+5wvn3psAtTKHc0WPmj8DxnHQaqDs\n8Oxa9HTcSpwXBGh3nMNFGb4J0l8EAVFDsCNAd3WBvjUtWdCEaqsyrMOixE5OXQNmiqO2LbuttsTo\nCqCY2QIP9MGMM/6N3YWtXJIiNU/dzMGU6eF0QUvAq27AxiNQSWrscLEToANXyTkg4kBbQrzoeZgx\nkGDiA/BDUZDm9aDPWAfabISXM6fcQ/C3H0x8Al4pC1mAgQrr6i7aywy8UnqreSY+10WPamJCaMAI\nIu8+kY2G/gUFoAsIkciOyGoNOPKJ7DCrARd0c3SYgIN4oaYBGwbu2Vw+Wi2j9TPmauS35IHsEIFX\nk+dnVqm6V6oebn7Q1mmesp9K31AzanGl8TIr41FJDeFCpvRxmlVMbF5xmmm+H1e+8Z8/xhuXwB/4\nRV4ARLaiqQAAAABJRU5ErkJggg==\n",
"prompt_number": 15,
"text": [
" x \n",
"\u212f \u22c5sin(x)"
]
}
],
"prompt_number": 15
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Computing the $\\int_{-\\infty}^{\\infty} sin(x^2) dx$."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"integrate(sin(x**2), (x, -oo, oo))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\frac{\\sqrt{2} \\sqrt{\\pi}}{2}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAADoAAAAvBAMAAABAjsQzAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAInarRM2ZVBDdiWbv\nuzJCz3LGAAABi0lEQVQ4EbWTP0vDQBjGn6R/TGpb4iI41eJYkQ4O6mK/gY4OQgOCHaTYqatBJ7eM\nIoidHLpYHJ1cFQe/gCII+gUcYkHje7m7NBd7neo7vH+e53K/5JIAIiohCzml62paSM7GdnJK9/mO\nonBODDpVTKQ4LRj7z69ySYpj+ThB4VO6KU5hgDXgUbopDo33wKbcuiWX8VoDml7sEkdGtkEdHy89\nLhLHZCfnAst0DuYik7NDlimI0/+o3swBxjHdqR2J9lNUgBrKnYKzwibrG7iN5DblmFNiD0Fx6OCM\nVbNOKea8iXupuLM95nZhOCPOAQImIhPYHpWyC9OJOVYAfnLlYZctWuhfrVMRHNPHA1OB3R2Wm2H4\nRUVwSgNsMBU4cqPCk+CMlJwz6iE4CUVpOUeREoPCSei8VTh/3KkJ7C1rY2qUf9xovv2i392q47qh\ntTMeindat+gj86N1c8Ekly6z+Xeq2WCrpzEi+WKSmZc/2thFS2NVIc64oJ9WF+9AVefBOO/v+Vo3\nR5+Q4v4Cg8V6kI46rBwAAAAASUVORK5CYII=\n",
"prompt_number": 16,
"text": [
" ___ ___\n",
"\u2572\u2571 2 \u22c5\u2572\u2571 \u03c0 \n",
"\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n",
" 2 "
]
}
],
"prompt_number": 16
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Solve $x^2\u22122=0$."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"solve(x**2 - 2, x)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\begin{bmatrix}- \\sqrt{2}, & \\sqrt{2}\\end{bmatrix}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAGwAAAAZBAMAAAAmp9aMAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAu90iEM0ydqtEmVSJ\nZu+3WVRUAAABUUlEQVQ4EZ2Uv0oDQRCHfyR35LyQECys18XCIoWgglgdgnUEwYewsbDQTt9AwcrK\n2Ak2PkJ6FX0AC5v0gkEwje5e3D8zO2ncZnfm+32Zu0suWNRroKv5Y9cHbc6qGfrWfagEF5dJyzUc\n2hK0TRdKd4ck7T6Nu45DgpYpbN8uuSDZPRK08iE7x4t4fx4J2g6KCt13Muav8EjQntFVKL4kzaNU\nM9efT2QtoFRrvdo5jYkwLSCqXVuhzt+MmEYR0Vpjkz2p88vMYqjWdrVdB9g4M49dWaHsMY0hMg2D\nHjojK5wyCwxRrfxEozJGe4h1s8WLIqo1p3iz2UPgOHbMmSKq4aJasZH+053CYI+YMQLTjh6HJpub\nt1Txry5GXMvHVRhxFY72s2LEprWnUbT+ufiaIKZh38eQUS1G/CKDBHTigp35NIbnlf/WdPI/OW+E\n7y/o1V+Wn163L48W7wAAAABJRU5ErkJggg==\n",
"prompt_number": 17,
"text": [
"\u23a1 ___ ___\u23a4\n",
"\u23a3-\u2572\u2571 2 , \u2572\u2571 2 \u23a6"
]
}
],
"prompt_number": 17
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Solve the differential equation $y^{\u2033}\u2212y=e^t$"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"y = Function('y')\n",
"dsolve(Eq(y(t).diff(t, t) - y(t), exp(t)), y(t))\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$y{\\left (t \\right )} = C_{2} e^{- t} + \\left(C_{1} + \\frac{t}{2}\\right) e^{t}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAAyBAMAAACuW3N5AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEImZdiLvVM27RDKr\nZt3KPpNmAAAFUElEQVRYCbVYXWgcVRQ+M7uzszvb7A6mgmIwq6nQt660lkZLM9ggipYuPlR80CyK\n1hZrA5GKFNyFPriomAgqBILuk0+1G/DFF8mKRRSjWdEHfZCOP/HRREkRm2o85947d2dmZ+8kmebA\n3nvO933n7NmZO3fvLsCNNL0ZV20oTpCQH4nNt+qxkiQCvR2f/UO8JIHinK1K1paJzZVUmoScdlpZ\nwFwlWjupFCUjc2VlfqrO6HNKUTKyprwJUCix8mJK9lZ9sn/tg3P44vtzDnnmVR7vwDgQU7om3lPd\naJLGCjPq7EOCvqK+WeoiSnahqaThF0EPO2rdZtnXe4QHe5AAoF0TYbbuw3vL+Eilq/3ZQz/fgwQA\naxX45U/71ktEmUCSIjDdMJn/N4wEY71uzjPEWOsSptv1t+YZRy7wct00/0frol0v1d4tglMSDJT5\nhOCBcFmpDTvZyTCSq4aRYGy87Qjg3S7hK2PMMPirLim93XOLnUdlJJxiJYxkeAXQHlr82iiFWX+8\nr5vrK5O1AW6vQNav5H76DMAUvoSZs2hvwQdeLOfhMncf6IB5sCPhCOdKU4K+MvcjiJtWuiRJ4Wjv\nYW8p3/Ll+CNahTs3ewkth3m3/ozTmCDR9XSM5MOCIwNZBuAZBHHT0qqSFE6WHjurBz6gC/5FMUNt\nknnT2LD/CpmOJ5Czd7UQkGXAcjGkTetVfAVsjArnywEMg4sPC0R2cHyekNTfNH5EA7eIDoptj2Rl\ntBEHTth6Gawv/7kMED7pGf+RWmPVQdtztCKThSM74Fd+wiX8NkHiFNXBDKNvGr+HzbpZheOQ66B2\nFQF2jNMbzMoY62tMBfro3QCXKr2LPNTBPofr8/xdIjvI1EljLQN/wh7Do8ssFCbxAhLxCpE+K6zz\n4C74AoyTMDjv45grO1iyKV7hgvxhl7HRHTDuxKR2H9PYGQfWINMEfoZZEInelFklT4NlWKjsOjP+\nrYfLudsBg86y0QbTZU63g+IGGQMLVZo+//4Y6xmgZefXWQfDTcTDHRRYB+fhNEw0fSuISqDtbTR+\nbzQuMH+JjSs04heA6eIMeDvffK7RKJPfNd7BdQkcgnSV3YUWflS4RLj+B7M2unwnoBI1u1jCKWzy\nGoyxT8TWYwqbcIUwYiUWGPeXEADMQa7NVuJeOC9WouQADBLqVPw3yJQAHPQCJjvge+1ECdk71B1k\nXKrwFO5/NAOMQqsDehvgsOYA7CfIbzXcZPExAHxe03UYrPg58mUHfD8w8Tt6Chs2XeTIIq4BfxYe\nBI0/jTC0B68c7UiPj2PCa5TlN2108V6Kv8PX0WMdP8V82YHY7QfnPmsiYbo4kEV0UJwhIn3gJ5qY\n0RFymbtGlc89o1Wy5ntAAmQHtaafN10RyQ6M/bOigm9XJtGuOjvA0UdE0x0couzjl162o3D40ENb\njufRbFZFZHWEMwT6Ne76vpkIKDg5B6dchQK4hY0Rw1nxLEdQAgp8MuPIdSck/RTgWQ6J7zCPt8bZ\nziROKO948NZnvr76570AsMRvA39qepRPEDLAr0QPuRkgt6pWTdteB3zvUqu3w6bpIKG2FZvxp9Sq\nbbN5djJQpVt8G/Sf1lXyrXMxv1hw0c+wonHH+q2/s5cx5jn95lFO5Nx+gqR4q6mukG5zvuioddtn\nC2V17hQYFVLs3K/3AfXDkMevNtbBG+pGk7BPK5OfvHPkGxJYV5WyRKT6n6zpjQ127o75xy1RB9mY\nhcCLq//2TNQAGOubyI/523MTFVSS8FE/SruTNwGPte2o9wxiPwbDGx1dji1o1WMliQSpZlz6kB1W\n/A9dWQnNN0T9GAAAAABJRU5ErkJggg==\n",
"prompt_number": 18,
"text": [
" -t \u239b t\u239e t\n",
"y(t) = C\u2082\u22c5\u212f + \u239cC\u2081 + \u2500\u239f\u22c5\u212f \n",
" \u239d 2\u23a0 "
]
}
],
"prompt_number": 18
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Find the eigenvalues of $ \\begin {bmatrix} 1&2 \\\\ 2&2 \\\\ \\end{bmatrix} $"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
" Matrix([[1, 2], [2, 2]]).eigenvals()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\begin{Bmatrix}\\frac{3}{2} + \\frac{\\sqrt{17}}{2} : 1, & - \\frac{\\sqrt{17}}{2} + \\frac{3}{2} : 1\\end{Bmatrix}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAQ0AAAAmBAMAAAAsINN6AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAVLsyIs3dRBCZ76tm\niXbIwtSaAAAEGElEQVRYCcVWTWhcVRQ+kzeZeTOZaVMRFRc1oAvdDUIXXWiGLISuOgoJ3fiDtBUR\ndLCFrEofXZQQsQkBS6EtLZXSioV2obaI6GzNJiO4KcU4LtwEgrUUW6g4nnvuOTf3773STeZBc+75\nvvN995v31wcAUHoR/4zsaNzkrctz3ZGFUBtv3NLbn+yMNAakl/X+F7LR5oDjPQpwqDjGX0M+isdc\nVjR3XTje7Vwm/FKcZbTaL6Tj5JOJ6jfIRedYv5NFPccyeBXgl4WFKJsDjmXJFDSfWwgsm5t8U9rC\n+hR1lKPWq+nOHlDr3bD3O4CfhsM47Y/rfndy9j2YGA7v+fQ5WPEhACdHvxG/lh2AZwBuzn+ahQa5\nSAdKmGN+/mV/4jys+ZCbA6CGO4ZHo0c5JuHZkMtFUIQ5SlDqhiNfhJB9PgAWW+EEwDiCeD4g7cfY\nHAxFmAPg85BPvwwxJ8epd4KB8iTAH4iqHBNZQMcBFlGO8J5M/xyEMicHhPfpsYeQTqFM5cBnxj4O\n2I2zZpHKkUw5jG7c+5R83BzJ34HqbaipK6xy/OaQMw+d1mm0SOVoxq7lNJ5kc2gfzvFIwYut8r9M\np21ewPFsRi1VDueqnThbkEOLVI7xAQrpEEu8O/b3GMPCPpWOgqp0HirtxlUeKA14AeP9b9Tyefx3\nTTCqOwpyaFHpIj6PPREZy4OwmgmIVfs0yU2nSdbvtHnAiKD64AZi+z75EeADJnUpykGi8ulHA6h0\nRWQsX9ukXya49km/xr78ViYoVyMCeLftcRUVTH6Hx0kbiPApHggp9SNa8O954xae9EmhpFqi1wWT\nutihVdH5gEAUycHfHOKz2oLPXpI9pFo5BPKr6H08r8+zZJ/qhyhco6uoPhjuahsR7ZSPCK7WJkGO\ndO4wHodaEBc5lqHPRgsxfbcK2Zydnbs8O7ssfbwGOeJjGi2w1D5VemOk/9H47VcyNpPw3G4RDGB5\nXI7mypmtYVwZS4/QPmMXafgr9bfZnuhQZ4motwjmsTwux6/w7dYwrkwOj9A+db2zenqh0k7us9SI\nqLcI7K3nZUlys8wuB2G6bffGUgjneeH3+iWlqHfLD1hpRNRbBPb6/VH7/p8foFLwTr0C+7vsRsVY\nGoLeH+TjfweVxNeI2MkQtjOuj3q9076Q2a1l6RI0ZJ8P/KkDVlZ7vOBiCBcGb8xlP3Zay9IlaMrN\ncdtRWk0OkfasGX/ZXPYR7mOEk6ORp8wjGjk7EfxzHhkjnBzH4Ehcm0vExwmt9qutKB0l7BzJm7uC\nj3xyyiWi+zC4Z9dTWZSPEpzjfaWom/9ePH0u4c057fXh0OlNEyU4x5yZGtFiSd+aa5Mj2l+2/V3f\nS7XwQ10mtqXukA/01QPbsl/OJsnhrjBPy2IUNaGr8j8vRzAyWmGMgwAAAABJRU5ErkJggg==\n",
"prompt_number": 19,
"text": [
"\u23a7 ____ ____ \u23ab\n",
"\u23aa3 \u2572\u2571 17 \u2572\u2571 17 3 \u23aa\n",
"\u23a8\u2500 + \u2500\u2500\u2500\u2500\u2500\u2500: 1, - \u2500\u2500\u2500\u2500\u2500\u2500 + \u2500: 1\u23ac\n",
"\u23aa2 2 2 2 \u23aa\n",
"\u23a9 \u23ad"
]
}
],
"prompt_number": 19
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**But why SymPy?**\n",
"\n",
"There are many other computer algebra systems out there, Mathematica, Sage to name a few. What distinguishes SymPy from the its counterparts?\n",
"\n",
"- It is **free**. This contrasts with popular commercial systems like Maple or Mathematica that cost hundreds of dollars in licenses.\n",
"- SymPy uses Python. Most computer algebra systems invent their own language. Not SymPy. SymPy is written entirely in Python, and is executed entirely in Python. This means that if you already know Python, it is much easier to get started with SymPy, because you already know the syntax (and if you don\u2019t know Python, it is really easy to learn). \n",
"- SymPy is that it is lightweight. In addition to being relatively small, it has no dependencies other than Python, so it can be used almost anywhere easily.\n",
"- A final important feature of SymPy is that it can be used as a library. Many computer algebra systems focus on being usable in interactive environments, but if you wish to automate or extend them, it is difficult to do. With SymPy, you can just as easily use it in an interactive Python environment or import it in your own Python application. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"#Printing\n",
"SymPy can pretty print its output using Unicode characters. There are many printing options available in SymPy. There are several printers available in SymPy. The most common ones are\n",
"\n",
"- str\n",
"- repr\n",
"- ASCII pretty printer\n",
"- Unicode pretty printer\n",
"- LaTeX\n",
"- MathML\n",
"- Dot\n",
"\n",
"If you want the best pretty printing, you can use the `init_printing` function. This will automatically enable the best printer available in your environment."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from sympy import init_printing, init_session\n",
"init_printing()"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 20
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To render $LaTeX$,"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\n",
"init_session(quiet=True)\n",
"Integral(sqrt(1/x),x)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"IPython console for SymPy 0.7.3 (Python 2.7.6-64-bit) (ground types: python)\n"
]
},
{
"latex": [
"$$\\int \\sqrt{\\frac{1}{x}}\\, dx$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAFYAAAA0BAMAAADiRNKVAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAmYkQq+9E3XYiMrvN\nZlRfnEjBAAACqElEQVRIDX1Uz2vTUBz/NumaNE3THTx5MagwEbRBFAYeGgRhIjKvHmT1IHhrBQ8e\nBMM2ZHiwRcTLlPY/6EDEi9CKePJgb/OgrOBFT61W59y08+Xl5b3vS5f3Dn2fX01e8j4vAAcNbZ+N\n0UGurBkyVbJ1pSubX2WqZIeVrmzWZZpgmaOeUPReiN8KQUbHz/lCcFyC18dCkJC+bQRC0KoA5w+l\nZU3ppdvhesy0rOGLqwLYIUnNtgKcvaHMNto4+0iZ7eIovFBm/0pZuhVp67W+46zlq65r/sNZs6/K\nFnZxNttUZUsjnI2anrbeDn2aOE+bnrn4+0osSPOWj+lHTAjOvZxFymKACEw1vTRA9lIVEZAWFBo1\nT9j6PiIQNV24AHOIOL8QAdp0LMAbxLQ9RvJtAsKmo5G/8HAC+tqlWyeoaP9gnh0QQJvOBDLdbBbG\ncAY2g3tUK02YNfQJoE1nAoB+HTI9OAZl7xvVWn8iS9+8SgBtevQ9IywzBsMFD95HERiOIuAQA+A0\nU6NpZgMqVQJ3mFruMVAMF0ObzgSAigtDcllrF3SqdWeZlQ8fss5zIagM4LXT/EIO+grVlwZ0Ij/k\nfERNjwWwg+IdLTcpjPL9UEPb9oGcdarxrL5w8skDfWFl+TOVcmLbym2Ims6zCWD+5MKwD+pvelac\ntooP6m+6IU7bTB2STef3pACdtux4uulSuLPBqbkdv9751afLAdc5aLgcWjus6bpbvGv0uM7BYpVD\n2GNN1zxt7DSFHqP7MSDzu0yVMh1ssTLkk43l48izGJaCGKHZiusWalufYqfTJvVKjqJ4vQCt25Ht\neA0wp7PZOvp3fJxqgy48RzqDJRdp5BzScXZt/lQf6QzWmkjT8E2QTuEcXMZSzsUsgV9Z1xJKOn28\n2k43Zec/XWyhPua9ohwAAAAASUVORK5CYII=\n",
"prompt_number": 21,
"text": [
"\u2320 \n",
"\u23ae ___ \n",
"\u23ae \u2571 1 \n",
"\u23ae \u2571 \u2500 dx\n",
"\u23ae \u2572\u2571 x \n",
"\u2321 "
]
}
],
"prompt_number": 21
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"** str **\n",
"\n",
"To get a string form of an expression, `str(expr)` is used. This is also the form that is produced by `print expr`. String forms are designed to be easy to read, but in a form that is correct Python syntax so that it can be copied and pasted. The `str` form of an expression will usually look exactly the same as the expression as you would enter it."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x, y, z = symbols('x y z')"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 22
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"str(Integral(sqrt(1/x), x))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 23,
"text": [
"'Integral(sqrt(1/x), x)'"
]
}
],
"prompt_number": 23
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"print(Integral(sqrt(1/x), x))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Integral(sqrt(1/x), x)\n"
]
}
],
"prompt_number": 24
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**repr**\n",
"\n",
"The repr form of an expression is designed to show the exact form of an expression. "
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"srepr(Integral(sqrt(1/x), x))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 25,
"text": [
"\"Integral(Pow(Pow(Symbol('x'), Integer(-1)), Rational(1, 2)), Tuple(Symbol('x')))\""
]
}
],
"prompt_number": 25
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"** ASCII Pretty Printer**\n",
"\n",
"The ASCII pretty printer is accessed from pprint. If the terminal does not support Unicode, the ASCII printer is used by default. Otherwise, you must pass use_unicode=False."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"pprint(Integral(sqrt(1/x), x), use_unicode=False)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
" / \n",
" | \n",
" | ___ \n",
" | / 1 \n",
" | / - dx\n",
" | \\/ x \n",
" | \n",
"/ \n"
]
}
],
"prompt_number": 26
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"print(latex(Integral(sqrt(1/x), x)))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"\\int \\sqrt{\\frac{1}{x}}\\, dx\n"
]
}
],
"prompt_number": 27
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from sympy.printing.mathml import print_mathml\n",
"print_mathml(Integral(sqrt(1/x), x))\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"\n",
"\t\n",
"\t\n",
"\t\tx\n",
"\t\n",
"\t\n",
"\t\t\n",
"\t\t\n",
"\t\t\t\n",
"\t\t\tx\n",
"\t\t\t-1\n",
"\t\t\n",
"\t\n",
"\n",
"\n"
]
}
],
"prompt_number": 28
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"#Gotcha!\n",
"\n",
"##Try the following -\n",
"\n"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from sympy import *"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 29
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"#Symbols can be more than one letter!\n",
"crazy = symbols('unrelated')\n",
"crazy + 1"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$unrelated + 1$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAHwAAAAQBAMAAAAmBgasAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEImZdiLvVGbNu0Qy\n3auaTOLnAAAB4ElEQVQoFZWRPWgUURSFvzc/GZ1x3cGIhUIy4FYWEsQUEX8Gs0UsxEEwiIVZNKKx\n2sZOcAMpLBRHEGQLwWIriyQ2FoI6jaQSg5h+iiWo1SZNhETxzuxs1tlNirzics555zzuvQ92Ppe3\n+vX3t3u05z28S/e1MqxWuuJGFyboxlqe/8f0MCNW5x1w2nYVtK+Ont89PuBn8e13QFtONatzZewe\nn4qyeMHLAOwfSWEuro77TLrOiWvlJs7JYyUfVRoPeCbOm6Uv7seFeZ9D5dGEfa32x3WrwhV0u8Fw\noNkv7QofAtPjl4x6hwV4JGCFqylz++PXZbg3LBVCpqKlQuxE5l0GI6bhSI0zMAaTVXU2YQKTk2ve\nlSVN4w4vSr9J5eC98iwH5NsvuHyHb7A6N+EmTGBfnE9u4pUef6aVYiweowL3UVuoTfibhIQJRKvX\nX83U6+kS082fw2ilPf5WaXtFT1x27Kp1rJZyWrjrIrSZgJ7mmcd+PcstrDVNKgx44BdrntrADh9o\noRWJarRZks7PLut5N+KZm2jhE6niDBkMim99XvA09vT4MJdQo222Q3yo9LAZOcuYjapUOeMTNYxT\nMHTxc3PRbPgYpx9nLBfXV//8SIW9le2P21us43ZqHQT/ACvogihYfjESAAAAAElFTkSuQmCC\n",
"prompt_number": 30,
"text": [
"unrelated + 1"
]
}
],
"prompt_number": 30
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = symbols('x')\n",
"expr = x + 1\n",
"x = 2\n",
"print(expr)\n",
"\n",
"#What happens here?"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"x + 1\n"
]
}
],
"prompt_number": 31
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = symbols('x')\n",
"expr = x + 1\n",
"expr.subs(x, 2)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$3$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAOBAMAAADkjZCYAAAALVBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAOrOgAAAADnRSTlMAIom7VJlmdt1E7xDNMpCR\nWcAAAABSSURBVAgdY2AQUjJhYGAMYPBLYGB/wsDXwMC5kmHfAQYgAIoAwVEg5tUIADEZtC6ASK7V\nDIwCDMxAxa8ZmJ8xcBkwcDxkYEtg8CtgYJgaaskAAFKHDvy4QzOnAAAAAElFTkSuQmCC\n",
"prompt_number": 32,
"text": [
"3"
]
}
],
"prompt_number": 32
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"** Equals signs **\n",
"\n"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a=symbols('a')\n",
"a + 1 == 4"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 33,
"text": [
"False"
]
}
],
"prompt_number": 33
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In SymPy, == represents exact structural equality testing. This means that a == b means checking if a=b. We always get a `bool` as the result of ==. There is a separate object, called `Eq`, which can be used to create symbolic equalities."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"Eq(x + 1, 4)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$x + 1 = 4$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAFUAAAAQBAMAAACVTi62AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NVLsy\n75nQ6/gxAAAA2klEQVQoFWNgwAYmYgryPMAUA4l4f8QU59iAIsboAOFKP8aiVhdVLZcCVCsTplqW\nSuLVsnGC1Aopu6pBDMRnbglILWMCexPHBLDl6GozZ4LAPJAcowJILZsA20cuBxCfAV0tWBBCsDGA\nzQWTYBE8atdAVfErgFSyzZw54+bMmQ9AbIxwYEyAqj1/gEEApALDDRkdINAMkjE2tr+swMAloM/A\nhF0t2AAYwQv0W/yC/QzuEAE87mVg4AeqFVYSSi9AVctn+8McZhyMZtv/GaoKVS1MHh/NiqITUyUA\nJRA2IktDjQEAAAAASUVORK5CYII=\n",
"prompt_number": 34,
"text": [
"x + 1 = 4"
]
}
],
"prompt_number": 34
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"** Question **\n",
"\n",
"Try the following:\n"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"(x + 1)**2 == x**2 + 2*x + 1"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 35,
"text": [
"False"
]
}
],
"prompt_number": 35
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = (x + 1)**2\n",
"b = x**2 + 2*x + 1\n",
"simplify(a - b)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$0$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAOBAMAAADkjZCYAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJmJdjLNVN0iZu+7\nq0QgoRR7AAAAVklEQVQIHWNgEDJRZWBgSGeQmMDAtYGBOYGB5wID+0cG/gsMfN8Z5BUY+L4wzDdg\nYP0MJeUNQCL8Cgzs3xk4DjBwfWRg2cDAlMDA0M4gHcDAIOxylQEA9FISlFfRJtkAAAAASUVORK5C\nYII=\n",
"prompt_number": 36,
"text": [
"0"
]
}
],
"prompt_number": 36
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = cos(x)**2 - sin(x)**2\n",
"b = cos(2*x)\n",
"a.equals(b)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 37,
"text": [
"True"
]
}
],
"prompt_number": 37
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"** The ^ and the / **\n",
"\n",
"We have been using \\*\\* for exponentiation instead of the standard ^. That\u2019s because SymPy follows Python\u2019s conventions. In Python, ^ represents logical exclusive or. SymPy follows this convention:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"True ^ False"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 38,
"text": [
"True"
]
}
],
"prompt_number": 38
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"True ^ True"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 39,
"text": [
"False"
]
}
],
"prompt_number": 39
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"When you type something like `x + 1`, the SymPy Symbol `x` is added to the Python `int` 1. Python\u2019s operator rules then allow SymPy to tell Python that SymPy objects know how to be added to Python ints, and so 1 is automatically converted to the SymPy Integer object.\n",
"\n",
"This sort of operator magic happens automatically behind the scenes, and you rarely need to even know that it is happening. However, there is one exception. Whenever you combine a SymPy object and a SymPy object, or a SymPy object and a Python object, you get a SymPy object, but whenever you combine two Python objects, SymPy never comes into play, and so you get a Python object."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"type(Integer(1) + 1)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 40,
"text": [
"sympy.core.numbers.Integer"
]
}
],
"prompt_number": 40
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"But in Python / represents either integer division or floating point division, depending on whether you are in Python 2 or Python 3, and depending on whether or not you have run from `__future__ import division`:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"1/2\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$0.5$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAAOBAMAAADDIxFwAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJmJdjLNVN0iZu+7\nq0QgoRR7AAAAo0lEQVQIHWNgEDJRZQCBFIGgBwwM6QwSE0C8/f+/MDBwbWBgTgByGJKvAAV5LjCw\nfwTxLoAI/gsMfN/hPHkFBj6gBgaGW0uAps03YGD9DOIdZJj/AMEDGtHAIG8AVcnAwPSTgV+BgR1k\nCm8CA/M/Bo4DDFwgG7gTGJg+MrBsYGBKAPKYGBg4gHQ7g3QA4zcGTgWG1UDHCLtcZWDoZWCYZKvI\nAAAOvSbLME1RkwAAAABJRU5ErkJggg==\n",
"prompt_number": 41,
"text": [
"0.5"
]
}
],
"prompt_number": 41
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To avoid this, we can construct the rational object explicitly"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"Rational(1, 2)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\frac{1}{2}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAAsAAAAqBAMAAACXcryGAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAzRAiu5mrdu/dZjKJ\nRFRer8KoAAAAcklEQVQYGWNgYGBUYAACZn8QxeSaD6IYGOqpQYX1T1sAMow88B8EPhCl1zTEG6iO\nKYHh/AUGBjYFBo4GBgaOCQxsv4G++wSmgNKcn8Bm3T8ApqaASVYHMFUGJvkCGIyBjK0MDMXA8Jhz\nJmwCUDvQDRMYAFKIIjdUG6QaAAAAAElFTkSuQmCC\n",
"prompt_number": 42,
"text": [
"1/2"
]
}
],
"prompt_number": 42
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x + Rational(1, 2)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$x + \\frac{1}{2}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAADMAAAAqBAMAAADsVn5KAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NVLsy\n75nQ6/gxAAAA5klEQVQ4EWNgwAo4BbAKAwVZ9uOSYtxnj0uKgUF/VAoRoo/vNxcgeOSzRHBrXUS8\nlJCyq5oCRDmaLsYE9iaOCVil2ATYPnI5YJViZODcAJFgYIAZ+B8EPgBF+RXAUpkzZ/bOnDkPpgxM\nnz/AIAARgOmCSnMJ6DMwYZeKX7CfwR2qDE2XsJJQegF2KagomILr8nu9B1kcyA6H8hkNGPID0OSg\nXGYBBt4L2KV4GxiY/2CX4vyIUwqogeMjdl1A0fgEnFLdOGX4NuCUUsYpw/WAwQWH5DkGBhXsUixt\naY8bsEtxAuO/gQEACx80gB8e/tEAAAAASUVORK5CYII=\n",
"prompt_number": 43,
"text": [
"x + 1/2"
]
}
],
"prompt_number": 43
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"#Basic Operations\n",
"\n",
"This section aims to describe some of the most basic SymPy operations. \n",
"\n",
"**Substitution**\n"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr = cos(x) + 1\n",
"expr.subs(x, y)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\cos{\\left (y \\right )} + 1$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAFwAAAAVBAMAAAA5lpTPAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJmJVCLvMs1Edmar\n3bti/yyrAAABmElEQVQoFaWRPUjDYBCG3zSNNq1txSI4iC2KIMUh+AP+DZ0cCmJ2QVrRRZdMBRVp\n/RniZAYnRVpaEMGlOLlZEFRwEUQHF7O4FAcrOogI3mcSadMUBA+S7+59nxx3X4D/xqrRwKf8qZGg\nm9hlHb5epwCeVlP02M3Zil2humBpXsnM2o2zq98JX7BwLmFmcfP0OuDijYVjywlvGxwCN1bQsBI/\nIp+PAKEohCQw4IAL80jJazLKnA4/+YEiIE3C+wKcOuCeDKaVWyC9nARPvj8GIdaHgA5MOeDhCND8\nBgSlx7JMfpMGDosI5qiDA54l3f1BuB7aeTVwiBWkFRMfUdV7Vd1gX7Kb+e3eK+NM+xkGrgwOyT5g\nDEX1RdLsiM0B2V0JLUVj1UAJz4Q5rSosgZdTCjbdSQRoeL4EuHTxk/BuelhUd0dndBhCz4Qmjh+P\nksd+E3eef6d0m7EUJu66+Lo2hOr3HStoeggJllFY3Y3K9j4BrhCmpfmc6ezbiJqSFnhAmaSOGrlR\nIejYyyvkPjUiavUZo/TRNdXFN8fOXTz2Y+66AAAAAElFTkSuQmCC\n",
"prompt_number": 44,
"text": [
"cos(y) + 1"
]
}
],
"prompt_number": 44
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Substitution is usually done for one of two reasons:\n",
"\n",
"- Evaluating an expression at a point. For example, if the expression is cos(x) + 1 and we want to evaluate it at the point x = 0, so that we get cos(0) + 1, which is 2.\n",
"\n",
"- Replacing a subexpression with another subexpression. There are two reasons we might want to do this. The first is if we are trying to build an expression that has some symmetry, such as $x^{x^{x^{x}}}$. To build this, we might start with `x**y`, and replace y with `x**y`. We would then get `x**(x**y)`. If we replaced y in this new expression with `x**x`, we would get `x**(x**(x**x))`, the desired expression."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr = x**y\n",
"expr"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$x^{y}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAABUAAAAQBAMAAAAL9CkWAAAALVBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAOrOgAAAADnRSTlMAEHarIkSJZt3NVLsy74SE\ntloAAAB9SURBVAgdY2AAA9ZkBg4BCJOBjU/gLJTJ4BjBoA1jM5gxGMHZrQx34Owe1gdwdrD2BCBb\nSNlVTYHRgbuAgYExgb2JYwJzQiRQmE2A7SGXA1dZApDNyMC5AUhBAZ8CjMXAcO4AgwCExyWgx8AE\nZcct2MfgDlUkrCSUXgBhAwBfCxJgl9ls6gAAAABJRU5ErkJggg==\n",
"prompt_number": 47,
"text": [
" y\n",
"x "
]
}
],
"prompt_number": 47
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr = expr.subs(y, x**y)\n",
"expr"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$x^{x^{y}}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAUBAMAAABscEDKAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NVLsy\nme8Q6PJIAAAAkklEQVQYGWNgQIBlCtwIDgPD0guHkbm8C9SRuZwCe2DcpDvKB9iVHkC5TAKWHAHu\nXAlQLg/DdAaGY0pQHpD6gmACWTwfeJD4/mwNbEhcYdUkRQhXSNlVTQEuw5jA3sQxAc5lE2D7yOUA\n5zIycG6Ac0AMfgUU7vkDDAJwAS4BfQYmBDd+wX4Gd7gkg7CSUHoBnAsA6V8X7bupG44AAAAASUVO\nRK5CYII=\n",
"prompt_number": 48,
"text": [
" \u239b y\u239e\n",
" \u239dx \u23a0\n",
"x "
]
}
],
"prompt_number": 48
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr = expr.subs(y, x**x)\n",
"expr"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$x^{x^{x^{x}}}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAACUAAAAYBAMAAACPVClDAAAALVBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAOrOgAAAADnRSTlMAEHarIkSJZt3NVLsymT3i\nYlMAAACWSURBVBgZY2BABU5JxagCQN6CaDYMMQYlTKGErVwogiCzzNV0UMTINSvpjvIBNLOYBCw5\nAlAMZ2DgYZiOJgLiPsEU43nAgy7ox9aA4U9h1SRFJHVCyq5qCkh8IJMxgb2JYwKqGJsA20MuB1Qx\nRgbODagiIB6fAqbYuQMMAqiiXAJ6DExoYnEL9jG4oypjEFYSSi9AFQMAQj4YJwejzyQAAAAASUVO\nRK5CYII=\n",
"prompt_number": 49,
"text": [
" \u239b \u239b x\u239e\u239e\n",
" \u239c \u239dx \u23a0\u239f\n",
" \u239dx \u23a0\n",
"x "
]
}
],
"prompt_number": 49
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"There are two important things to note about `subs`. First, it returns a new expression. SymPy objects are immutable. That means that `subs` does not modify it in-place. For example,"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr = cos(x)\n",
"expr.subs(x, 0)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$1$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAPBAMAAAArJJMAAAAAJFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAADHJj5lAAAAC3RSTlMAzRAiu5mrdu/dZmiL4QAAAAAjSURBVAgd\nY2BgEGJgYDDZxMCgEgYkGNhJJVgzdmYB9TEwAACPpQrvlUCHcAAAAABJRU5ErkJggg==\n",
"prompt_number": 51,
"text": [
"1"
]
}
],
"prompt_number": 51
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr "
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\cos{\\left (x \\right )}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAADkAAAAVBAMAAAAOWFv7AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJmJVCLvMs1Edmar\n3bti/yyrAAABP0lEQVQoFZWRL0gDURzHP+ft3J1uczgwCQ7EYpqoYVNwBovFSxbTRJNlaaAiHtj1\ngsmyjRXRIoIYRLRYTAMRbF5eGjIQTf52vL0NXfEX3vu83/f3770H/7R9FX/bL88KlDdW7CPbyY7T\n60DPXtPcJe1iW+OYJg1OXaOdh9HZOYxczWdv9VwEMw3GxdNZLkRri5J74NIwAuKiJq4gxX3lDYY9\nbI+14gsc7hYwRY3nYYal5ApE6kxIpWgLRjLvDVfUQR+SHAsRbVKuSNCXqEHq5EOp8K1UnTvl8iB5\n7cpEPzFAxpe+5DehfJohJhO1p1oealINp7J2MN1SkaNIgYQr13jEaSWalgQNpGF8eh5rctF3Fi6z\nUlTKGc/V2p2g7cvyy171eV1TF641ynP9sXbz0AxPQe+mf1+H9apsqNMN/AAQ00PuNbV4pAAAAABJ\nRU5ErkJggg==\n",
"prompt_number": 52,
"text": [
"cos(x)"
]
}
],
"prompt_number": 52
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The value of `expr` remains unchanged.\n",
"\n",
"To perform multiple substitutions at once, pass a list of `(old, new)` pairs to `subs`."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr = x**3 + 4*x*y - z\n",
"expr.subs([(x, 2), (y, 4), (z, 0)])"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$40$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAABQAAAAPBAMAAAAWtvJmAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMpndu3bvImbNiRBU\nq0Qb3U6NAAAAkUlEQVQIHT3NMQ6CQBCF4R+VZGM2QDwB3sHSwkvYU3AASjuvYLGlxRZyAYwWNJzA\nBAsTG24hFECCs4VO9eXN5A3ACop8LYANnLlmIj9FJSxPwoNhUaMHoTWENcEIKjNUMUELNwxHi9fL\n/k8dCSvrDkqEYYweeTRN95rvUK6MFD9h5l7wgS33SHSZ3pT7pwt/8wVNsydniKnjSgAAAABJRU5E\nrkJggg==\n",
"prompt_number": 54,
"text": [
"40"
]
}
],
"prompt_number": 54
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"It is often useful to combine this with a list comprehension to do a large set of similar replacements all at once. For example, say we had $x^4\u22124x^3+4x^2\u22122x+3$ and we wanted to replace all instances of $x$ that have an even power with $y$, to get $y^4\u22124x^3+4y^2\u22122x+3$."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr = x**4 - 4*x**3 + 4*x**2 - 2*x + 3\n",
"replacements = [(x**i, y**i) for i in range(5) if i % 2 == 0]\n",
"expr.subs(replacements)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$- 4 x^{3} - 2 x + y^{4} + 4 y^{2} + 3$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAOgAAAAYBAMAAAACFaxSAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEM3dMpm7du8iZolU\nq0RaI+fpAAADAElEQVRIDZVWT0gUURz+xl33jzPuDl0kRFq28rwYaNJlCTp1cJPcQxHNITpVjl0s\nFtEgvGV7Ccoit6LILm1FWXlQIYqg0LqIwZKXCLqsC/1H297MvDfzG90Z13eY3+993/f7vuG9YVlg\n45JzHzaCfojmScrZQ56cmziCrBvYZKdUPAUv8NGTcxNH8dANbLJr9Q7tRk9+k2mb7rW7epoB79Ax\nTCzXY8E00sU6haYsOOcdCsyr9XlJZ/X6hJZKlvxCu/ytghmbX/8hXcmesLkNzWSN0ANCJTumFnR9\n+pTgjBrQ2MNaPbOiM6u0gJllF0I2kl4jtFMI7oqG12gG8wWCndOsDbvRCYoDzSoiIxZpPbeTjdLX\n96OwDg6PckGsGEu7uPAq4ilOshK9rfFNN+6rDs66SArN3ynyhm4QFXdqw+PtXLD/3WtuxbnYGHYk\nnGm5QeObg7klBza6hopv6L21WUtvhxZF6OVq1aJgc67jnWSh0uDS1ymucpdABS1DN3O6y116quMq\nORRh3JRvhxcH7HacJZ2FtuKO3uFgpCsXpWJTVyBhQdxdVkYwTEQitAXt8OKCTzLOhAwW+ggz6lsH\nI10nZFWuKHkL4u43GhM4SUQitMhCvTjgeRrb9hhrF14ZoSpT20vaaTAdaQNoZEdvCPji7mpExy+B\nscphJc1sPDimilwQI1LR8qQegmN1yOjjuok8Tib3JpPmzZTVoP1VO3ArjHevzUXzCK2aNuyhlEqf\nL+lgHpKASFUyuAb0pNlRmEucYy/CI0TG4fel0u9F1ObiFYT+kpGIhrnwCgYIJFr2q3ZeUYcRXhd6\nGqEFoWFVvAswCtTmWEjgDxmJa7HV0Eq0QCDeRvdNH0uVZ/sxzgHhnkWZygUM/AT7I1CLaypg3rol\n00ruX7u1OJB7wH1paahWq6m2wZaXIkG4t00dzxOhgPGs+gke3Je+M2RiK63tzm6OLAc2QT+OTNXb\nfrOEzQnpHx3hsAn5cXRmy31AD5H7cY/7cW7lFnexwcOeE37cf6njxyRW2whHAAAAAElFTkSuQmCC\n",
"prompt_number": 55,
"text": [
" 3 4 2 \n",
"- 4\u22c5x - 2\u22c5x + y + 4\u22c5y + 3"
]
}
],
"prompt_number": 55
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"** Converting strings to SymPy expression **\n",
"\n",
"The `sympify` function can be used to convert strings into SymPy expressions."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"str_expr = \"x**2 + 3*x - 1/2\"\n",
"expr = sympify(str_expr)\n",
"expr"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$x^{2} + 3 x - \\frac{1}{2}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAGwAAAAqBAMAAACkSaOPAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NVLsy\nme8Q6PJIAAABuUlEQVRIDe1TPU/CQBh+qKXUgtDAZBxsNHFVJ520ix+Ji5OTRid0wfATjJObuonR\n4GxiwMFFY+Qf2MTRMDiY6GIkQSUstS20fXsWSpm9ofd8Xi93LRB+HIevGI2VWj+1kae+auD+a+xx\n0yPJ3cus3YmTmqAOHHWKsTqpiWqiztqdOKklV/mvTjFWJzVA6vXuh+YaM+5KouJiEy1mb72CP8t5\nZV5DKe+V/FhMa6sR1QJcE6m9ttRlWsN6y5UUa46+YjT4ShKnl9eemkG6bzI9vjChJHX9k62dA5bX\n0plnZCu2L5LttDeJxI4G1iNVQRZqkuoKdg3YrbCem0IEg2VC4daSL443fGCOMzOX0s1hAsWk1hAK\nhZP3QkEDeBXxpsezM/b8WIFsY+MjUyycqiH+A3g9NwVJngT3t5YsQ6yzHqltXjxgifD222J5lBTW\nI7HMWHo7T7h9JBvVG7AeibHQrrG6w/nqXcUhDojSVzsqARkIPf/RpDYNfBDaK3wD5iu9ht1cUe6r\nZixwSO7ZXS8IRb+DEr6+WPaVg8TnoICvz035ykHilflXhR4JDZwauoXlbG42fAtFXW/gF2L/ZJmj\nNodmAAAAAElFTkSuQmCC\n",
"prompt_number": 57,
"text": [
" 2 1\n",
"x + 3\u22c5x - \u2500\n",
" 2"
]
}
],
"prompt_number": 57
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr.subs(x,2)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\frac{19}{2}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAABUAAAAqBAMAAACuFQ3dAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAzRAiu5mrdu/dZolE\nVDLjuNgcAAAAzUlEQVQYGWNgYGBUYGBQ3R7MAATM/goMTF0MFgYMDEyu+QoMbA0MbA4giXoFBn4B\nBu5PULa+AwP7HyibAyj+C8rm/sDA+B3KZhBnuA0TZ+Aqf/0XJs7AwAYzByjEmAAV52pmeA+0F2wX\nuxCTFIgZ1j9tAcPWkAMgNo3Bfzj4QLFNpiF+MDOYEhj2H4By2BQYOBqgbI4JDGz/oGzGTwg2UIgT\nHDoQufMboGqA1BQEk9UBwS5DMHkDGIxhvKcMDMVQNvPs3WEToGxGoDdBbADhFDj9qcHC3AAAAABJ\nRU5ErkJggg==\n",
"prompt_number": 59,
"text": [
"19/2"
]
}
],
"prompt_number": 59
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**evalf**\n",
"\n",
"To evaluate an expression in floating point,"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"exp=sqrt(10)\n",
"exp.evalf()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$3.16227766016838$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAKAAAAAPBAMAAACRq9klAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIom7VJlmdt1E7xDN\nMqsI8sYEAAACqklEQVQ4Ea2UzWsTURTFTzKZSTOTLxU3IhgibUUoxq+FipiV20SlC8XGQRB3Jhak\nOw3qumTjSqERuikVHBSxFCFBVJAiFkFwITYL24UgrVpq20TiufdF8Q/wwZz33rl3fvM+bgJszR6C\ntnjALjs6j+1njsPIh8VsNqOC8OBQL/xkcETy5/iI6Y3112AoT0fPAqEiCr4khE4Q+KxmN70W9tVU\nUO52uy0V7zXOmzBeYCYNbGsDatrA5x6liGQe0VWkquR5h5cJfA4rlwzg1lVwCkgaiWdw0ISdOsJN\nPC4RqOZJYKehRHyEmohNodEkELgRwPnG3q0i+UsFGWDISJmLMmGrhQhhUT5q7gZmDCWcg1dlWm/L\nArTqnMbbBKpwEqsYOcrOhFMtxFYNUM2JYxiQYMGP/QjCvgxfiugKU28GeaxAHz9vxJIppfPuWg0a\nbhQR+2mAaia7F31JImV5TdCJPUWZK7DxCm6ew4nMH9GPD8Dr+JiEhndlkPiuQGPiQoeHrxS7K1cP\n7J3XjltutGFPc3JLDBFvxYjXDXAu0PA/QDWdkbdTkk7KpY+bNRm6wjBbrsLZAOwcpyrRJkci67yC\nGsvB2Whk/m5ZzStwNgNmudNOC+VphNKweMZsXKHbhLMGXJepSp+gRR4Q6Gs4VUSkdylqcjULeaW4\nARIswjYsMtgI5C1zhZEithhBo8WACC+0XNMw8U6vbMS8u8Ja9ZXSYO4S3Bz6pPoUyAKz63gPXDWC\nhSIDIgWeodSfXY/WYTfNLat5n1WQVoqbBvbD8VGoeB2+xxXiAGbzoZvZUlWFHAGKWBlv0oRxG7Pz\nBqjmvQCXDSU2B6cC3Bk+AowDpYfjPsLDXxHnD7iqAuzIE6jSXyJFwng0RrG/rC8BYiYW5c9BKZ9O\naxXzlf/YfgPdoQy8RsM+hgAAAABJRU5ErkJggg==\n",
"prompt_number": 60,
"text": [
"3.16227766016838"
]
}
],
"prompt_number": 60
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Sometimes there are roundoff errors smaller than the desired precision that remain after an expression is evaluated. Such numbers can be removed at the user\u2019s discretion by setting the `chop` flag to True."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"one = cos(1)**2 + sin(1)**2\n",
"(one - 1).evalf()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$-4.0 \\cdot 10^{-124}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAHIAAAAVBAMAAABoAqesAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEM3dMpm7du8iZolU\nq0RaI+fpAAABgElEQVQ4EaWRsUvDUBCHf6+JNmkiFgcdW8HRoSAIDkL/AMGiuCjFOOgmzSJ0ERxc\nhU6uipNOFqE4mkGdhDqKWHRwc9AqDiK13iXtS14GofWG5N539+W9ewF6Ct0BautpYLAnDdCLOViV\noSxQJ7unsHPQKvoXxEUfpvFk/iCZ6cME7Cbm+jM1F1XF1As8sljZykdGH1cJzUmXi1RFMTWHjYQn\nZvgdxH6zQ643KNJgM1XAGBSz7HD3MXAWWPQcLZIZJWy+4PlqaXVZNsE8cnixqfyrJJlRYu9An7xZ\nAw7SoWklfLMFvHqSshkh5mLLNdrtN6RKD7IHJ74pPsl0JSUzRmRJJsL1TfMbmK9KSmaMyJJMLKhm\nMMdf5sgUxwQuA1PQnnxa8e5/k0/bIXKPWCKqgQmas+5RcdZvIFOSmNFd2o3G4x7fzDRwGpyUS2yq\npCtE34bDqzKwEFI2VRLWwmzYQSYLzRO7IWNTJWFNZlapdajdQpxv5yUbuPu4V4ks/SP5Bcd3bMxv\ny7poAAAAAElFTkSuQmCC\n",
"prompt_number": 61,
"text": [
"-0.e-124"
]
}
],
"prompt_number": 61
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"(one - 1).evalf(chop=True)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$0$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAOBAMAAADkjZCYAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJmJdjLNVN0iZu+7\nq0QgoRR7AAAAVklEQVQIHWNgEDJRZWBgSGeQmMDAtYGBOYGB5wID+0cG/gsMfN8Z5BUY+L4wzDdg\nYP0MJeUNQCL8Cgzs3xk4DjBwfWRg2cDAlMDA0M4gHcDAIOxylQEA9FISlFfRJtkAAAAASUVORK5C\nYII=\n",
"prompt_number": 62,
"text": [
"0"
]
}
],
"prompt_number": 62
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**lambdify**\n",
"\n",
"If you wanted to evaluate an expression at a thousand points, using SymPy would be far slower than it needs to be, especially if you only care about machine precision. Instead, you should use libraries like NumPy and SciPy.\n",
"\n",
"The easiest way to convert a SymPy expression to an expression that can be numerically evaluated is to use the lambdify function. lambdify acts like a lambda function, except it converts the SymPy names to the names of the given numerical library, usually NumPy. For example"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import numpy\n",
"a = numpy.arange(10)\n",
"expr=10*x\n",
"f = lambdify(x, expr, \"numpy\")"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 67
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"f(a)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 68,
"text": [
"array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])"
]
}
],
"prompt_number": 68
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**simplify**\n",
"\n",
"One of the most useful features of a symbolic manipulation system is the ability to simplify mathematical expressions. SymPy has dozens of functions to perform various kinds of simplification. There is also one general function called `simplify` that attempts to apply all of these functions in an intelligent way to arrive at the simplest form of an expression."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"simplify(sin(x)**2 + cos(x)**2)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$1$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAPBAMAAAArJJMAAAAAJFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAADHJj5lAAAAC3RSTlMAzRAiu5mrdu/dZmiL4QAAAAAjSURBVAgd\nY2BgEGJgYDDZxMCgEgYkGNhJJVgzdmYB9TEwAACPpQrvlUCHcAAAAABJRU5ErkJggg==\n",
"prompt_number": 69,
"text": [
"1"
]
}
],
"prompt_number": 69
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"simplify((x**3 + x**2 - x - 1)/(x**2 + 2*x + 1))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$x - 1$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAC4AAAAPBAMAAABpZ+CXAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NVLsy\nme8Q6PJIAAAAdklEQVQYGWNgwAYmYhNkYPD+iFVc+jJ2cQYmfOJCyq5qCqjmgdQzJrA3cUzAFGcT\nYPvI5YApzsjAuQEkyjijAwg6D4DYEHv5FUBsZAARP3+AQQBZFKKeS0CfgQmLePyC/QzuqMrB5gsr\nCaUXoIrz2v0wRxVB8ADsXhxGPMeYxwAAAABJRU5ErkJggg==\n",
"prompt_number": 70,
"text": [
"x - 1"
]
}
],
"prompt_number": 70
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"But simplify has a pitfall. It just applies all the major simplification operations in SymPy, and uses heuristics to determine the simplest result. But \u201csimplest\u201d is not a well-defined term. For example,"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"simplify(x**2 + 2*x + 1)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$x^{2} + 2 x + 1$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAGgAAAAWBAMAAADeGsQjAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NVLsy\nme8Q6PJIAAABa0lEQVQ4EWNggIDcvQJQFvEUmwPzBOJVQ1VyOPB8IVkTXwDLV5I1MTBwfSRDE4cC\nGZpy0fSw3N19AE0Iyp0IF2a/AGdCGMIMbNh96Y3wRxhDDEQxowOENmRgeAdhoYpLX4Zr4pm1aiNE\nkksBQr9gYLA/AGGCSZg4AxNcE9///x8gKmCS8wXwaRJSdlVTQBgJ0wQU6RdgVDIJSkI1DGwTYwJ7\nEwdSEkJoYv3GIMZQodCJRRObANtHLgeIBIhEaOLYwJDIkC+wBCIHFwf5iZGBcwNCC7Km2wwMAgyz\nYXIomhgY+BVgEgxsM2fOeDlzJjjOmAxAwp/Aciji4NA7fwBoIhzATVzLwOLAwPMH6BQwgIuDnMcl\noM/AhEUTzwUGJoeFTB8YFLFoil+wn8EdIo5iokdargXrL+4PLAVYNAkrCaVDxVE0zf///wejkaJa\nOdRAmPN47X6YQ4UQFEwSIQJh4RIHy7IiW4ukE1kcAEJLUX2t8S2aAAAAAElFTkSuQmCC\n",
"prompt_number": 71,
"text": [
" 2 \n",
"x + 2\u22c5x + 1"
]
}
],
"prompt_number": 71
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**expand**\n",
"\n",
"Given a polynomial, expand will put it into a canonical form of a sum of monomials."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expand((x + 1)**2)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$x^{2} + 2 x + 1$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAGgAAAAWBAMAAADeGsQjAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NVLsy\nme8Q6PJIAAABa0lEQVQ4EWNggIDcvQJQFvEUmwPzBOJVQ1VyOPB8IVkTXwDLV5I1MTBwfSRDE4cC\nGZpy0fSw3N19AE0Iyp0IF2a/AGdCGMIMbNh96Y3wRxhDDEQxowOENmRgeAdhoYpLX4Zr4pm1aiNE\nkksBQr9gYLA/AGGCSZg4AxNcE9///x8gKmCS8wXwaRJSdlVTQBgJ0wQU6RdgVDIJSkI1DGwTYwJ7\nEwdSEkJoYv3GIMZQodCJRRObANtHLgeIBIhEaOLYwJDIkC+wBCIHFwf5iZGBcwNCC7Km2wwMAgyz\nYXIomhgY+BVgEgxsM2fOeDlzJjjOmAxAwp/Aciji4NA7fwBoIhzATVzLwOLAwPMH6BQwgIuDnMcl\noM/AhEUTzwUGJoeFTB8YFLFoil+wn8EdIo5iokdargXrL+4PLAVYNAkrCaVDxVE0zf///wejkaJa\nOdRAmPN47X6YQ4UQFEwSIQJh4RIHy7IiW4ukE1kcAEJLUX2t8S2aAAAAAElFTkSuQmCC\n",
"prompt_number": 72,
"text": [
" 2 \n",
"x + 2\u22c5x + 1"
]
}
],
"prompt_number": 72
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"** factor **\n",
"\n",
"`factor` takes a polynomial and factors it into irreducible factors over the rational numbers. For example:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"factor(x**3 - x**2 + x - 1)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\left(x - 1\\right) \\left(x^{2} + 1\\right)$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAIoAAAAcBAMAAABMljoJAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMmYiu80QdonvRN2Z\nVKvu110NAAACWUlEQVQ4Ea1VO4gTURQ9k+wkk59uY2OTqJUoEmQbbTaovRGMlciALquNTrUbQTQo\naiOaehuDjYXgKqKLqJDCTycLilaL4AexECJCBGVZ773z5s28vAm44IWZe+45593c9/JIgHWE9/zl\nOtzjrJfwZZz0D/xm5XmAat22BzaVxjgNxS5gumcb7tpUGuP6mv0QQ815NYIOv1Jji2JfxepSDGP0\niOBUXCbREWDDpBDZoea9voYKkA3n6OFsxxQvbQqfWLpz1Ci2aSDfGVW4PvGau7RFKixLolexUwzH\nw/GQCm2lGgr1yGPkPHc5JVTVj5RNK28Vfq8osZUbuBNZzCyyK1Ns18rNtTWFjS75Lq4RP3t+bzvQ\nXgHSJTyRF0Tk5j/dvppwGF2KQ+wjSyezVGomPASlS0bIA1SexI7gYcJhdHF+4Bng+d6wUk94oi6V\ne0weo+cKbvhvuFBhdMn+xgLNArch6swTjkOMZRZnwPApPT4OM9RhdlnlLsDGQOsKJLrwLMAvJVC6\n3Go9brWOMiE2moV2BFQn6dOMELmodwTaey5hMGZxfvLpVvwLyKd1CU/3M61+lx9gblwX+o6uA4vL\nB7E7YWEos5T7DM/SpV2dGGRrXKgwZsl0+dadnp+9WIv0MJe//fkIuD2uFn3kvs61tzKOQnUJbXR3\nS/VIsfMeoQo9W4lmEcUNkOnbnogJb2u5E9VxvhVD4IwP7E8SBs41pXS6BmsXu4ga8ytFyoTa7Hd7\nocHcp8o4e0PdpqoZg7WKTMei0ohKP43V3PjNaIuAFbMcqf7H/6W0/AtAS4v9uvCcFwAAAABJRU5E\nrkJggg==\n",
"prompt_number": 73,
"text": [
" \u239b 2 \u239e\n",
"(x - 1)\u22c5\u239dx + 1\u23a0"
]
}
],
"prompt_number": 73
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**collect**\n",
"\n",
"collect collects common powers of a term in an expression. For example"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr = x*y + x - 3 + 2*x**2 - z*x**2 + x**3\n",
"collected_expr = collect(expr, x)\n",
"expr"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$x^{3} - x^{2} z + 2 x^{2} + x y + x - 3$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAAYBAMAAADHZzbDAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NVLsy\nme8Q6PJIAAADG0lEQVRIDa1VTWgTQRR+m2Y36TapSyuCl7Kt0Ju0igc9uQdFEdTgQT2IralURILB\ng/XipXjQg1oEwfWHRvFUKVY9FmlAED014qnEYj0IFqWm4k8tQpzdmTfz0oyxabuHed/73vu+fTs7\nmwDwK93nCFQRMs+1tOqxim9UsgqUzCbHNHLLaxjS0IQ6CTtItnKY7I2VNOq4l/iuoQl1CSY9kq4C\nJnWP2pyK/qjt+REOpmp3LLfaltd22vNampCPHZKsHLbc0Gvjrp5X7KCCq0LaQwiQ0ZlGp8fzyFsF\nRHXHaP+ZnBIlFhVWKKa1bwVLHo2LqrletB/sX6hpy0clRi6Ih+EYSQ2PJ1sA5gRt9pp5DtcLZmlA\n0VIeoCsHC8jGvdgHxCQmbo88Iant8uQTwM48h69HHolD+IATVSuKqgpwPGX8RjaR7vMQk9hcLpdI\nil7Djhzga7ksGuofAPgraNm0u9MldxGQ0Ec/JrIhiwOw5LpjdGw7lCY6HCAUGhkXDvCtQRExlKrG\nAoDRGxuMD0kKAaGNp5vfchq9AMyfsAEuuFewnUUxABda9gx0VYiIoRS9vMqg5Vjztic5BIQ2INrN\naTVAfAxOwFnnIbazKAbgwn3sh3W8QkQMlcj6wnYAGscks/FycN1leQX9QjSoAYoADtyRugDgDoR+\nTrML33hZiKShugerzzlsWefyziWros1CULJ8/9as74c40h0w4g4BPO3713z/XgC5X4+T+MMwFSnD\nsA1gF8BEjuHJPHua6kvRo1iUOzAKUQ/YHQyssIiHkPtNQWSGF6VIGQpV2YGJLNhOF0SqByC0XYCG\nSq9EASLe/UgJ2oVVEMQAQvgMmsJdYp+aGzYRwzBny2f2MXnQk5uAPUipSOhX58/d5AV8mL39me3m\nYlMpmlUCHEAIi9AjikJEDFE0ADZ7i60dLaeoj6gSuhCbTVUOMFwuLxhb2zsH0CqIYgeEsDX93uNV\nMQAx5Dz7lqeLwhiZ/0XcAW2fPAOiOiViTZHW6d+kqdkq2X1EIgYahgz8v6wpopo1xXG3yV1Tw3rN\nzI53y5T8BdxkuuzPBzMcAAAAAElFTkSuQmCC\n",
"prompt_number": 76,
"text": [
" 3 2 2 \n",
"x - x \u22c5z + 2\u22c5x + x\u22c5y + x - 3"
]
}
],
"prompt_number": 76
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\n",
"collected_expr"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$x^{3} + x^{2} \\left(- z + 2\\right) + x \\left(y + 1\\right) - 3$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAASEAAAAZBAMAAACMbYVcAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NVLsy\nme8Q6PJIAAADyElEQVRIDb2WXUgUURTHz+jMfq8NFoIEtmr4ZkpEIUTsQ9FDWIsv+ZSbhhERSkQW\nFCwikUS1BYHbB2zRQxSVWI+BC0EfD+GWTyGCRT5IUWsEmQTb/Tjnztx11iTIeZhzzu+c/7lnZu7s\nDoA8unts9DTjm3qrxasXRPujo16rHYI2L7wKLJr0F7yWGYKJuBdfDRZNe60yC/sSXnw1WF3Oe5XH\ntjf/77T6apklBgV/WSarsD+n3FKnrPZMaaUee+9s8OV5mTmqF+tR+9QzgO06c6Iy2isAlTmnSnhm\n79GsgyKLju/yzgo/uNyjM1qhLwFBl0hzvbV75llRWisEaIfQT0J1ORN9I06MWytp5Zhp4v6SY50k\nlTZUzUBFEvNIVbWmpe7rJ/lEWorFLVlYIF0g7v8g/VCMGLev7z/gt+eTmyn/jvSqUlD5G4wZ5EhV\nlaZV3Sv4RHWqSDoHEsYvQpHunrj0lUaE34pFZq2UzJWcce3gPJ8IrmO2ZCJdq7qLiYLZko7yqVU3\n7mqKORnSGA1bOroRy+2NQedspF+6ztoBdsXHMI+U9Fxb8w5M+QioO4iJtL5CHmTVRtI/GEhjN2ZI\nUwOnYsOIwzgCD42x5knEzkRdSYDTOiU91yYfQUVBpKm7nMjvWlekX1xkxmf75kNxEYsTaQ5Cn30X\ncSDr5A0wWzFyJrrAyD2dkp5pzex7CI+KNHWXE4VSqFHG94VdMwRlMVLS2HBD1VUlAGrP8+MmY8+J\nq4nEb9kEYqSkZ1oDPsKamEhTdzlRpMCgMcIbD+dEHr7azGIxJ75MZmQuk8mL7Hdx5ic+kTosmT2S\nyVzKZG4J3MjPYiI3lXquteZhIqd3F/tITCQ6yNNOgPEsc1mx7WB1FRH2RiN2PzV4qGrpHoXywHp1\nIieKeq5l/+KbZFZ1FxPp7yFA0YbxfgjZLVDhMdFtthfrcRH3zmbLV5as/QZg45KdTXquDbfCE6+J\nSnf2Z4DLcejKjsNuXIIbvAprMVwwWTNx+FrRYebVyePXMMK7YZ7rnUwBTGtU6bk2OmrhP4J+j6J5\n1KAZgBB71Gsbqg/TyjyBGmNzfdMA1bvvbt4/l0COEwWLxWIKQJ9T6bnW2Nr8Q2poouiOhW0AQeqE\nDa3pqRLCE6TBImmGtIgC2jEiNmcQa5QxoaXvQb37XpQsbyz3DaNS+QVAEdn95HDri2GkUcaYtg02\n4LXr3btR8g8mHP+rqLZcBdMOwphX1kh70ZWxMl9dbvFTd+D2mbajOecm5K/gOql0qXW/jUuzjPjj\nnpjDstoTnpI/ejri4qz7jIoAAAAASUVORK5CYII=\n",
"prompt_number": 75,
"text": [
" 3 2 \n",
"x + x \u22c5(-z + 2) + x\u22c5(y + 1) - 3"
]
}
],
"prompt_number": 75
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"** cancel **\n",
"\n",
"`cancel` will take any rational function and put it into the standard canonical form, $\\frac{p}{q}$, where $p$ and $q$ are expanded polynomials with no common factors, and the leading coefficients of $p$ and $q$ do not have denominators (i.e., are integers)."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"cancel((x**2 + 2*x + 1)/(x**2 + x))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\frac{1}{x} \\left(x + 1\\right)$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAE8AAAAqBAMAAAAAIxtcAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAzRAiu5mrdu/dZkSJ\nVDL+6OvUAAABbUlEQVQ4Ee1SLU/DUBQ9G4yysY6WBN8EwpATEwQMCQ7DFL+BoKbALOEHYObAkDTB\nEywYhgAS1Nzs/gFkDgWv7yM7d30jdRhe0t57Pvp638sBgDX1FFntSREXsHlc0Ijg3/jblf7d9VRO\nvk7NZI103oR3UmhL6JAK19LYAV0V41k6XBELwYARNgwy4eqxtNxihJFF+va2WXpgAGksDUl8UX3z\nbK/XNZzYsd4h4yFQHtSuqpHHWLOklm6AelKfhC2PMezjW69Mu1Q7orRvbDMzNj4dbYzAalczz3F8\nHcfrWa9PLYzq18DHGElWZ3Zc6RtSv9VhwuQCQWI4cWpxmFfgaXiEXfutMFY6ls2KuvCt8+Z7ailr\nNOEq3Vs2K9UWgemMmtxhqcbbA4+svTHAgUAMyhEjzAmu8izKqRZS8R2B26ynwJCUbzkweZUYDgzR\n+ZYDk1cFYwMjOC+YBsYrO5ID4zhv5cB4DY7kwDjOV38ArMRaUfNUcswAAAAASUVORK5CYII=\n",
"prompt_number": 77,
"text": [
"x + 1\n",
"\u2500\u2500\u2500\u2500\u2500\n",
" x "
]
}
],
"prompt_number": 77
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**apart**\n",
"\n",
"`apart` performs a partial fraction decomposition on a rational function."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr = (4*x**3 + 21*x**2 + 10*x + 12)/(x**4 + 5*x**3 + 5*x**2 + 4*x)\n",
"expr"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\frac{4 x^{3} + 21 x^{2} + 10 x + 12}{x^{4} + 5 x^{3} + 5 x^{2} + 4 x}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAMsAAAAxBAMAAACG3EB/AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMpndu3bvImbNiRBU\nq0Qb3U6NAAAE20lEQVRYCe1YT2gcVRz+djf7b2azWXpThGxLDrUlJgdrqSiu1VsPWYQoJpRGLJYi\nmiEK9mQWxVrx4KLtYbXQJRjUSsigpkKgpBbFgy3GSmykhsSDIF6aUmulqY6/N+/PvJmdmV0LHoS+\nw7zfe7/v+33vvZnZ/XYBrU3P2NooJDT6tofM/supZC1Ziad8gB/jAZ1kk83cejxuJ3qteERH2WQ9\nHvY8JtfiER1lT5Xawb612yEi85tkZu6YjESf3fIoE37Pm97hhTzKk+4n05uD015you9hPrhXYZIV\nFbrBaRh/Ay9uqFmjrEIeZIdI5jg+tQLz7pAlzUXMrrFRer87xy6Jmzw0BesS8Aw+6/dkXpFQgTB3\nr9rIjcGoywTr9WS3jcwYmzx0lF2pnSpl/+RRocr7p4HVEtJKptgslvwI7LPRtYiCgrC0pLNkZhDd\nV9hkU8qkrNyzbMLDnbD9Mnec+9L2I1ilnkUUxTG0JvMbXCZnkczc3pdHqonpGSuAAx6y3d2Ywxd/\nmca443CAb8ELZRSv8RIBOq2BWoptdQ5HYTZzO1J1jmFXtWsUb9DNI9g8Xq3u8gAegipNNpG4oZdQ\ndC5zuUnEJskYtrFREDthtRQOqQqX+Riz9tcsJZpCSBm9hJ4kPHuSCyW2G+Qrgu92Coc+GrPd2ITS\nm0KQzEKTDk0voSeBZIWI83AL9FQp5s1oNN452GiU2Si9yC7uY3SNjXnTESTTU0aBHgFRIpAE9jLS\n+ZWVP5aA3hItWDW1nLPIWlwmcYX27DWFIBk62BytxCuhJ1Eo4yWXtx8Fex/SITKJMtJc5pv0OkY9\nFe/ukUx6DMm6XsInQx9lT7jE33H5zBAOhRR54eTU9+6hFW92rWdrIQj23uABerP1ErpM9v6T/YOM\n+L6zfHp47sOwIicc5yqSP1xdNpdGR45oKmo3/eMP1jA//B30ElKGJfOO47gyOlvEEheS6gTRns6r\nFGvRAh0g2tPblb+dv30Ct3gC9Pb89239Fhf3v6B1Ra/SGLkUnZzaTR+gnbcY67rV/SINL2VY3fXw\nTOisORu9qG14K5TDJlNW4npksjWRXgjI5EcT9yjY3SriwTF70xqPMmtZ8sD+lij7x9rorqBMxnGq\nMm8+JSPRjzuePfC7TgZgliiiNaWM9ND5Gf79SnjzSSn4uWC/u2SpOimRlETg8YpKBoKcJWXk91K3\njmBeirWveIdF0bNuSsSSiOwbFTHV0s0hVqb3DGeEyOTKopiSMfzGT6RdD312y8BWPpbo7iOPleDa\nZ7ozkzWelDLLr20W5hu/4Wc/Ea+TDPfdPOFepQGetP3oLpseIW6fd+KwSEqZPfRDlBMTx8/t8RPN\nKskEfbf00Lmhn/xoGj0Cbp/vHLnIc+reAF2D3DnTA7nuJxrMLQd9d4yHxoAVtM9yN+SOr+vOmQnJ\n0/6CyQSJlA/30PRnA/vh6L0f+KjRuK/ReJsY9PnCfpiGEs0mk/ERaUTNM8BsJBd1EBiwEbDPYjeZ\nOpI+56wRCysrq89Vg8RID10GdiFon4VMkt50n3PWZCjMVFqIkR56ArkDLfZZyGTLOGzpztkv01Np\nIfoMsI7Obrtgt9hn+QhMzGyPJMIY+uvNoO9mlX1N3hvfpBxIGTnW+1iiDnTjWBP8awvcm4gi/gO7\n3PMtCpDrIQAAAABJRU5ErkJggg==\n",
"prompt_number": 78,
"text": [
" 3 2 \n",
"4\u22c5x + 21\u22c5x + 10\u22c5x + 12\n",
"\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n",
" 4 3 2 \n",
" x + 5\u22c5x + 5\u22c5x + 4\u22c5x "
]
}
],
"prompt_number": 78
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"apart(expr)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\frac{2 x - 1}{x^{2} + x + 1} - \\frac{1}{x + 4} + \\frac{3}{x}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAANYAAAAsBAMAAADrxFtiAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIpm7MhCriUTv3c12\nVGZoascqAAAC2klEQVRYCe1XMYgTQRT9ObJZs7m9i2djJcGDq4NoncPG0ohg4xVWBzYazuIKQVMI\nYuMJimAXtBBPwUO0MQhrcyIIl8JSIdaCnGBETnHdvZk/+yf59yeGpLstMv+/ef+/mQm7+xbAXHPz\nx01sBa+sbM9EouVWr3RIoXcBrjdJbsJDPRNKgUibg/AvKS7UoXiH5BieXRhKS6ZtdWAHGyZjsQWF\nHyQ34fRQWiDSbjW936YhQKk3QS2wzzCRDXqwtHn4XURWkITigjOqg1aqZNQ0Wmt4jZlnwYaNOpog\nWaadeog8PT4Cv+73wrINy00M10Hz7xlmGkxVwYNSNQ291+vJ9XQxjR1NUkp6uWgP6oqnfjfTYTZS\nSfbraqKZIu0gQK2TtYSwAgl0ehGsBbgXPIxWXIdal2idBHgb1rdgegJadwGelzOt3OPVhdZapwZH\nMmw3Eg8n44q0bxD+yahQiuO4de7D0rUuAZNw6uLOJRthM5l24Oh8ky3bB10ncMZFGOP8pzH2crXa\n13KdkHu+7wyTO/h/ru1E4Hz6Dlh/mUrtVaqXgVqKpsFJDFfb7Sft9otJtOZ64r7suZVjfU93e3rE\njNXyy4WNEftJZaxWUM5/l4pGnGO1is3cL3c/ybGT6nwFE1Yr8Ypudys6dmyfjEEVk9sY2GMQqZx5\nNGtIduwApvK90bIlTLaiI2bbCIlveQCk5b46tGYqY9PylcU0uyCBcvA34YbCcHXE2CPE7YuhfWG0\nFE05+PybzycsLWrsBS2G5kWDWpqmHHwxjrctLWrsBS2G5mubTo4OPxPQweOUbkxhQYuhfWS0DI04\nePpo1jCBuP8L/b+heQ1Gy3wm2A4eN0GMPUKsVlataOHy8uX7EZ6SGXdp/Q5eN6awoMXRoDhwf2la\nv4PXjSksaHE0mB3Q0rR+B68bU1hDnGNnaODXfnbN2amA0sgUbkKGyKwJmUozxwfMo5mBuFon7R+e\noUKyk6onXwAAAABJRU5ErkJggg==\n",
"prompt_number": 79,
"text": [
" 2\u22c5x - 1 1 3\n",
"\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 - \u2500\u2500\u2500\u2500\u2500 + \u2500\n",
" 2 x + 4 x\n",
"x + x + 1 "
]
}
],
"prompt_number": 79
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"#Trigonometric Simplification and Powers\n",
"\n",
"**trigsimp**\n",
"\n",
"To simplify expressions using trigonometric identities, "
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"trigsimp(sin(x)**2 + cos(x)**2)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$1$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAPBAMAAAArJJMAAAAAJFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAADHJj5lAAAAC3RSTlMAzRAiu5mrdu/dZmiL4QAAAAAjSURBVAgd\nY2BgEGJgYDDZxMCgEgYkGNhJJVgzdmYB9TEwAACPpQrvlUCHcAAAAABJRU5ErkJggg==\n",
"prompt_number": 80,
"text": [
"1"
]
}
],
"prompt_number": 80
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**expand_trig**\n",
"\n",
"To expand trigonometric functions, that is, apply the sum or double angle identities, "
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expand_trig(sin(x + y))\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\sin{\\left (x \\right )} \\cos{\\left (y \\right )} + \\sin{\\left (y \\right )} \\cos{\\left (x \\right )}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAQUAAAAVBAMAAAC9GeaNAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMnZUzRC73UTviSKZ\nZqszMyTAAAADwklEQVRIDc1WUWgUVxQ9k+zsTnaycRsK6kfNkDYfTW1dhCrqRxbc2uKP+1GEhqJL\nKEIJLaHtl/lwSD9K/UlqDQhGWGILEq1dEALBFrYi/UgLjSIUWqVRFMS2YBoqqdqm5719894bd7Lf\nPsjOufece+6d995AgKdxPaeGupI8nLPQyK9BmyLlk8ublI2ebOMcM6xfUbgruXi2BZ3oc9N4W6ip\njfPQsKlyhIsRiD1fi6IEOtEnFRXEni3b9GupQToFtFWjIKLdWpSJPSPaqrB5TcMgzZ/U6C2NLNCh\nO0Z0e2DRBmofd8IkDdI0lI//jCa9EQ1TBQ0N+ETDiLZmSPbZrUsMiLdxnu8tzv6HZ6e6XwmoydYB\nt/f3sekGhDs/U8Bg7xkIHflzpM8FmCtLJRNQMyT4DF6CPylLgLdnTsOd7g/RvfUFFsXb7AdG8D6w\nJ/AfkUwvAIP4OfgIyBUZzxWck84o0oHUAe+xvn0CWxRNhZohwae6A233gWsU+Z9jY219DUNuBRnG\n8TafllEVM7wL/EsywwP4El+Xd9F8hHEJ7UuZKpwlqQM+BC50FnFI0VSoGZp9/MJlpCvAdopSRQzk\nDwM9GyaRZRxvk3nwEsQM7wB/kewIgTL2EMHhO7iPCXo410OpA06Q7giEVNBiqRmafVwcw7qA5RQd\nrLNgGVhXPTJUYxxv436xWhcz8M2iGRpINvFEbiAEHkidnAHjZWdJzZAtlV4/XiqxQ4KP9zd68o0Z\nxgMOu8IZKoP7xGuJGUybi8itWDOITeLOwwW8EWsfHkudPAtcRttEgxZGah8SfDqLeJEC8Snpffih\nht/CxlmYNjuBP60ZxGV5lTepT126Ept01OGtSJ28k1SnF5vuZIIPVdxgeSd5H1CYAsY/rqKLLeJt\ndpQxLA5CnUV2Ed5y+r5PXWedBnMLOOt8hlRV6oDzzH2P8YhmpPah2QedFU9c8x/5559CtrYxj73t\nk0jX+G3F2hy9+ku4afXOptWb2/5ZlDvs3urrv8G6VMgf94/+Gr6ZuQuhYyw29sD0T7RJhYRcaoZm\nH7j3NovP/Q2hOnDpLPz586H31ctnGPKcY22ExKxRDec0skCG3cEbwR1SWTWDivRD+vBGwJ/QOQu0\nbHNdC6c1skCujq6iyxuOiPYWLNpA+tzGwZDbHpikQS3biNOSyy0qEH8MIxOkAx5SMq3F9PkAQwzf\n1CkbtGyj/7nQKrsUmIXX+x1Ta9BaTJ+xzXmGwzplg9ZtvlXSX+0Sg8UXI9YadIMUv8onF+2rYSSy\n2vwP/2woFsmuhKYAAAAASUVORK5CYII=\n",
"prompt_number": 81,
"text": [
"sin(x)\u22c5cos(y) + sin(y)\u22c5cos(x)"
]
}
],
"prompt_number": 81
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**powsimp**\n",
"\n",
"`powsimp` applies identities 1 and 2 from above, from left to right."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a,b=symbols('a b')\n",
"powsimp(x**a*x**b)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$x^{a + b}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAACkAAAAUBAMAAADiqgm2AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NVLsy\nme8Q6PJIAAAAxElEQVQYGWNgQAesMzFEQAK56KLcIIFZWEW/IERllWyAHJBa1k/KAlBxxh6ej1BR\npkamC1BR3gs8DVBRbgX2CVBRvgVMBgyWM+fNnFnAF8BrABWVd+AuBJoGMpdfgG8BTO2B8+FAJkiU\nQ6AaKsjAarToOlSU51oCkCWk7KqmAKRBAKQWDBgT2Js4YJbywkTZBNg+cjnAeDCakYFzA4yNTPMr\nIPNg7PMHGIBORQVcAvoMTBii8Qv2M7ijKgTyhJWE0gvQRQGUhB8bLqp6JwAAAABJRU5ErkJggg==\n",
"prompt_number": 83,
"text": [
" a + b\n",
"x "
]
}
],
"prompt_number": 83
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"powsimp(x**a*y**a)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$x^{a} y^{a}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAACoAAAAUBAMAAAAJnbK1AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NVLsy\nme8Q6PJIAAAA6klEQVQYGWNggABZJRsoi/GS8gEYs4fnI5QpceC8AJTJe4GnAcq8y3ACymLgW8Bk\nAGW/YlCGico7cBdC9DF+YdguCBXmO3A+HMp8w/O1AMpkNVp0HcoM1tIFigopu6opgEUYcxUY/KDm\nJLA3cUwAi7JxPWDQh+hgE2D7yOUAZnvxTmDYDRFlZODcAGExCPApMHyCshn4FWCseAGePzD2+QMM\nECsYbjIwPYCIcgnoMzBBRTczcBtAROMX7Gdwh2q7zRBfAGEKKwmlQ5kMwkn3HaAKUKibKDwwh3kC\n41dMUQ4FbgVMUValO1BBAEaKLcNiHDwBAAAAAElFTkSuQmCC\n",
"prompt_number": 84,
"text": [
" a a\n",
"x \u22c5y "
]
}
],
"prompt_number": 84
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**expand_power_exp and expand_power_base**\n",
"\n",
"`expand_power_exp` and `expand_power_base` apply identities 1 and 2 from right to left, respectively."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expand_power_exp(x**(a + b))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$x^{a} x^{b}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAACkAAAAUBAMAAADiqgm2AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NVLsy\nme8Q6PJIAAAAuElEQVQYGWNgQAesM9FFwPxcrKKzsIp+QYjKKtlAOayflAWgTMYeno9QJlMj0wUo\nk/cCTwOUya3APgHK5FvAZABjBvDCmPIO3IUCEGF+Ab4FMAUHzodDmRwC1VAWA6vRoutQNs+1BCBL\nSNlVTQEigmAyJrA3cUAsRWKyCbB95HIAq0ViMjJwboDoZ0BiMjDwK0BFUZjnDzBAncoAZ3IJ6DMw\nQUSRmPEL9jO4Q4xAYgorCaUXQEQRTABAMyUzj8MplwAAAABJRU5ErkJggg==\n",
"prompt_number": 86,
"text": [
" a b\n",
"x \u22c5x "
]
}
],
"prompt_number": 86
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expand_power_base((x*y)**a)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\left(x y\\right)^{a}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAC4AAAAXBAMAAACG4mBhAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMmYiu80QdonvRN2Z\nVKvu110NAAABKklEQVQoFW2RvUoDQRSFv8T9SzYbt7fIii8QxCaCINFat7KeyiCCbJcUmgSbNEFi\nKwj2grGzElYw2AjmEXwERVBI5Y2Z3bDEU8w952PmXi4Di7Je2v4ihWO/ov7jr6wIzgVypFoVd01b\nzo2UTU3Zx/qifggHGU4Il7lJgN3N8hbcnZ0GFKpZfqTjbRZjjmegL6XR3mxFVj+ipnDiGa+D1c0/\nuKHjDehAXgZP9QiOcr696lYpZBe8+xm/kvuY26AKET+y5kfKYTmSMFS5zzmXPlDxUYywB1DUfWSu\npzrYij2M9/ncC2kw3mcdnhkGUIrlvUj2Omk2zgMpvbcqmDf8yRWfaCSmpkM+1qYcWhOxPR3Z0caN\njEh2CROe/Eux+STISNsuBcmNaV3T4Re+ADmsRZDWAgAAAABJRU5ErkJggg==\n",
"prompt_number": 88,
"text": [
" a\n",
"(x\u22c5y) "
]
}
],
"prompt_number": 88
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"** expand_log and logcombine **\n",
"\n",
"To apply identities 1 and 2 from left to right, use expand_log. As always, the identities will not be applied unless they are valid."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x, y = symbols('x y', positive=True)\n",
"\n",
"expand_log(log(x**2))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$2 \\log{\\left (x \\right )}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAEUAAAAVBAMAAADiLT7tAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIpm7MhCriUTv3c12\nVGZoascqAAABkUlEQVQoFaVSPUvDUBQ9aZI2bVIRNwUl6B8oFLIJGcRROyk6tYMgIlgKUgfBTE4O\nCi4KQru4KFpw0K0FKV06VMXZ+jGJSNFKqyjx3jQNtbp5h3fPOe/cd+97CfCPmHBrHygLw1ETGD/t\nOk6IuIKfdqcQaALyfpdHjbWFHDAH7BA12pKbSx4ntAssmb89W55nBsjH/vIoGc+jVhgeU2/qNV1e\nAdZTT+ckBXSasZzYWG1BKA0SDUhZiAXlDUcaUbFKNXgsHAA9NDRCEccTSkKq+zNYIIYQNVjGWuwC\nCGeIj7BoYJLkhm+z5QlaQAwnvCPVAC3OyMCNBbwKdXmPKXuAT17Ycwmht33Oi1AqmbzBvag1ZICu\nKOnQHE9Qh9IMW+xozXyt1VB0Zh5Ip3jKKKRtqEnlbIwK6MJxKF9iTagCPh152/6gb2on0Jeepye1\n33XyUAN5sVh6JqhatHSGWJEHD1nIemq/h1xwRfme8Z0rAPTUP2PWBEZZEp2xCMg5pp0hp8spkwXv\nH/PMnTYXD7n5FvgGLalfmUXXVqkAAAAASUVORK5CYII=\n",
"prompt_number": 93,
"text": [
"2\u22c5log(x)"
]
}
],
"prompt_number": 93
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"logcombine(log(x) + log(y))\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\log{\\left (x y \\right )}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAEMAAAAVBAMAAADvM06qAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMqvNiRDduyJ2RFSZ\n72bxr6VbAAABkElEQVQoFZ2SsUvDQBTGvzRJ0yRtrf0H6iTilEEXF4N0qQQJRYQOQnGyCCJdKgia\nTbAqQQKSqcXBtd0cjXRwtK661EndLFjEotR3baSN3Ty43Pu+98t7d8cB/xhca/SnJxLJuVGH4sOA\nDiUAcSNgAfNBrZEsBi1ZD2pnHIlZQWR9HLkMEuDr/Uar7jJwYbyeU9qgmTs7cmzRsHFiQvAYwm1C\nspUOtmVK79MJ9HghrAlqExUgTvstIqyDa4fymCYCW4BgCh3VKkc1lAA1z5AUtXuPNgfIA1UBvwOY\nMRufAPfGkOsq8BFpi4+sCiHAhE2fmsm1fxFW5SviOAmWpUZAKgETDchNQMmzKjEPSletslx/u6pZ\ngWxSQpoabLcE7h68rixMWgxZog71A5wCt6i1gKiHZG8Gx+lZYLH37RFCV5d1cyuUzGbuLICvkjkY\nUl0sFygMW75BS4PmyVBeUfhMM+75XkgTuxRmfEnLGp1nj8ld3wvbkk13pPmSFjHtGkQNn5Ti3pCS\nLOb9GZHWqPEC/AAl4FyeL/bsxgAAAABJRU5ErkJggg==\n",
"prompt_number": 94,
"text": [
"log(x\u22c5y)"
]
}
],
"prompt_number": 94
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"# Calculus\n",
"\n",
"\n",
"##Derivatives\n",
"\n",
"The `diff` function is used for the purpose of differentiation."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"diff(cos(x), x)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$- \\sin{\\left (x \\right )}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAEoAAAAVBAMAAAATJmVgAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEM3dMnZUu0TviSKZ\nZquXRLrEAAABSklEQVQoFaWSPUvDYBSFTz6a1ITYUOziIBVEdHIQXc2i4NQidBH8AHHP0kkkgj/A\ndHOSjA62vIOgi+jg6BD8A2bQubhL8b4mNwmazQvJeXI4OfcNBPjn6HFa4Hi/i7a7hXPH+M7A2omY\ngHlGlaFCaxGbBbFT6JRgVkKmTG+93DjPCYsFYvN4xw4Sffm59yHdG7pa+/e79D0Ss1F8aDATqH08\nymWngBI5a1obeKXHbOoDWDATmCEaMXnrgOVanwa9cYTmqpwFsjf64ifVRoO24JK6oPpE6MhbNrMr\nXzCpy89TSKmcsgXezkop2kgtHlyg9LlGhOm4lKLTG+4BapQqnd4YwBS0jjeOgIvDAA/U+CJr06kP\n96718WRmPNkKrsiiNXO91jAmXMoiFaIJNu2Q6a86T+xZXaYKPWGvyVCl+V+Yx6tStjw4jSPwDWX2\nRQ0oD4CmAAAAAElFTkSuQmCC\n",
"prompt_number": 95,
"text": [
"-sin(x)"
]
}
],
"prompt_number": 95
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"diff(x**4, x, x, x)\n",
"#diff(x**4, x, 3)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$24 x$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAB4AAAAPBAMAAAABlGKvAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIpm7MhCriUTv3c12\nVGZoascqAAAAvElEQVQIHWNgVDJ2YGBgYFEAEiAQxsD+A0hxGYB5DAypDAwzgcyTMP4sBoZ8BwbG\n1zD+/gAQn50bxgeqXR/A8BDIZz2T2FMD5HJ8Z2A9AOSHM7w6sBrIBxrNzgDklzLUB1wE8pUZGK6A\n+AEMm4E8Bp4EBtYCEJ+B4Q+If4mBUTYtLX/aAQaWLwysIIfyCDAwcBowXOX5wHCUQaq8KAuoit+A\n4y/zB8YHDPv////FwMBu/+1pztHj70AGoAAAzuItVAGSqRAAAAAASUVORK5CYII=\n",
"prompt_number": 96,
"text": [
"24\u22c5x"
]
}
],
"prompt_number": 96
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"##Integrals\n",
"\n",
"To compute an integral, use the integrate function. There are two kinds of integrals, definite and indefinite. To compute an indefinite integral, that is, an antiderivative, or primitive, just pass the variable after the expression."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"integrate(cos(x), x)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\sin{\\left (x \\right )}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAADcAAAAVBAMAAAAQkWtIAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMnZUzRC73UTviSKZ\nZqszMyTAAAABLElEQVQoFZWRvUvDUBRHTzRpa2NFxdUSKl0qSBcFdcnUOZOgk4MIIkgGN5fgpqOr\nDiI66yQUEfInqIvgB1TBSYSoIH6g8b0kfYndvEPeeffc/Lgk8K8aTqbPk1PbSl835xPu649B+0yl\n7rTZbkN61hSmpFrbimZjMgdUp+Aq1OtoIxX7+IehncExS/SLPhiVx/W9CGfAZQUalvklZO4M5ri0\nVqFks+GwK+USfAuZr8MBh840dLvk30aRcgFehOzxwKEhCC3A2A99KRdTGZOUJ5TeM1LGoj1jgFh8\nCp4yUi403hVQjRaadFiWmUlssUXhNReYYqbXZ/PiyiuHD+XwbuKjFWUZ99XarQjXPfH4W2vq2lSk\n4EaR+EidlTtKOobdqUD9bDWVnTlNLtfwC1XgR6gJ3g8BAAAAAElFTkSuQmCC\n",
"prompt_number": 97,
"text": [
"sin(x)"
]
}
],
"prompt_number": 97
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"integrate((x), (x, 0, 1))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\frac{1}{2}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAAsAAAAqBAMAAACXcryGAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAzRAiu5mrdu/dZjKJ\nRFRer8KoAAAAcklEQVQYGWNgYGBUYAACZn8QxeSaD6IYGOqpQYX1T1sAMow88B8EPhCl1zTEG6iO\nKYHh/AUGBjYFBo4GBgaOCQxsv4G++wSmgNKcn8Bm3T8ApqaASVYHMFUGJvkCGIyBjK0MDMXA8Jhz\nJmwCUDvQDRMYAFKIIjdUG6QaAAAAAElFTkSuQmCC\n",
"prompt_number": 101,
"text": [
"1/2"
]
}
],
"prompt_number": 101
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"integrate((x*y), (x, 0, 1), (y,0,1))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\frac{1}{4}$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAAsAAAArBAMAAABcLm8jAAAALVBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAOrOgAAAADnRSTlMAzRAiu5mrdu/dZjKJVGPm\nxm4AAABgSURBVBgZY2BgYFRgAAJmPxDF5JoHohgY6qhBhfVNWwAyjDzwDgQeEKl3K0TdFDDF3gKm\nrETA1AEwxWUAptQZwNQBMMW7AUzpMICpa2lpL9LBOiDaGZ6AOUfeZYFpIAEAWrAbDZuk2eYAAAAA\nSUVORK5CYII=\n",
"prompt_number": 103,
"text": [
"1/4"
]
}
],
"prompt_number": 103
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If `integrate` is unable to compute an integral, it returns an unevaluated `Integral` object."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr = integrate(x**x, x)\n",
"print(expr)"
],
"language": "python",
"metadata": {},
"outputs": []
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$\\int x^{x}\\, dx$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAEcAAAAvBAMAAABDOcobAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAmYkQq+9E3XYiMrvN\nZlRfnEjBAAABmUlEQVQ4Ea2UPUjDQBiGX5PShLRNnEUwiGAXMUMLHTsKCsWxODS7Q4uTm6EWcWsR\ncZN2dWo3x3R0Ebo52tXJ2Grxt2p7SXs5DnKCWe57n++5cHccB/zhW1i1ou21bD5SkkeKEympXqQC\nKHkBqekISPWWgOQKOPgUkLQnAUn9EpAS7wKSIXKW7Qr9p/RSrUVnv77PU1C1dhR7mvd3KYyCQyUN\nt0EaB8VkLNl0wpuf4kMKy9+hG6d5GmlK9FL1F2oGmlJFIjm5SHHpww+52kXVyZykjyf5PN3uY0qm\n3eSASLKZOlS6pEa8CNeiiOHvQrKkod7wpWwPy6BI09+OjGTHV4AVCwegyKMXtAwnqLAHefQbZmSz\nG7TaLViklgfQPRmYEXeRNHSrDjWQxkh0HyhS6hOp3HdxSUrgBnd5c05mB545zW30AilTvdqy5yQe\nOvBAYkb1mQG8GBO54cr/3fAObxEMq5sM4MWCzaMMO2IyNwq9Fq/cqWGYEjmmWCU8iZsMk4vDsNwI\nZ05axzaHMuhaKzKEE8+4b1FY/AGAVWLPwk0PigAAAABJRU5ErkJggg==\n",
"prompt_number": 106,
"text": [
"\u2320 \n",
"\u23ae x \n",
"\u23ae x dx\n",
"\u2321 "
]
}
],
"prompt_number": 106
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"##Limits\n",
"\n",
"SymPy can compute symbolic limits with the limit function. The syntax to compute: $$\\lim_{x \\to x_0} f(x)$$ is `limit(f(x), x, x0)`\n"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"limit(sin(x)/x, x, 0)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$1$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAPBAMAAAArJJMAAAAAJFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAADHJj5lAAAAC3RSTlMAzRAiu5mrdu/dZmiL4QAAAAAjSURBVAgd\nY2BgEGJgYDDZxMCgEgYkGNhJJVgzdmYB9TEwAACPpQrvlUCHcAAAAABJRU5ErkJggg==\n",
"prompt_number": 107,
"text": [
"1"
]
}
],
"prompt_number": 107
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`limit` should be used instead of `subs` whenever the point of evaluation is a singularity."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr = (cos(x) - 1)/x"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 112
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"print (expr.subs(x, 0))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"nan\n"
]
}
],
"prompt_number": 115
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"limit(expr, x, 0)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$0$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAOBAMAAADkjZCYAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJmJdjLNVN0iZu+7\nq0QgoRR7AAAAVklEQVQIHWNgEDJRZWBgSGeQmMDAtYGBOYGB5wID+0cG/gsMfN8Z5BUY+L4wzDdg\nYP0MJeUNQCL8Cgzs3xk4DjBwfWRg2cDAlMDA0M4gHcDAIOxylQEA9FISlFfRJtkAAAAASUVORK5C\nYII=\n",
"prompt_number": 114,
"text": [
"0"
]
}
],
"prompt_number": 114
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"##Series Expansion\n",
"\n",
"SymPy can compute asymptotic series expansions of functions around a point. "
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr = (sin(x))"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 117
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"expr.series(x, 0, 4)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"latex": [
"$$x - \\frac{x^{3}}{6} + \\mathcal{O}\\left(x^{4}\\right)$$"
],
"metadata": {},
"output_type": "pyout",
"png": "iVBORw0KGgoAAAANSUhEUgAAAJMAAAAvBAMAAAAVw+UoAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NVLsy\nme8Q6PJIAAAC9ElEQVRIDa1WPWzTQBR+F5w/J2mtIEXqUpxW6gaNEFMZyFIxNmJFIiEduoDqAQES\nEpVYSoeKClSpEQOpxMRCl05I1AtsKIFMCBXKwFCmBJCgFSi8O/tsX4jts8hJvnvf+773+e58uRbA\nv9UXNX8yEpMzcjuRCvzFuVqy689GZHIbEQv85ZOmPxeNyT+Mpg9Sj2zbAbLHQS+KwE2ays8I8iBp\nqpz8HMTLcfnp+Rk9W18sy8kDVKSWvJcazZlKaIme+v8zopMlkI706wsUj+vUUrKpvSBhywQtiKfc\nKy4o9CDG48FR1WYhFmaVdZZV7EG8NOhh42pzDy76cE46zd+V3cYFLjl5MTg5lV8yxBRH8beFB5sM\nvOOpBEGrFDfm2fBxOr77pl9BneLs9Q1qFWuH14qKE/oVDWY3MJngtUSnVkpXFPoiUrapDvkCME7L\nxpp2St3f/2MArNowbFB1SxHv0SssTdfW0pwittYPDgwOuFWqraIwQ2d11624870JcAYxuwXc/NCI\nW1VNSmcOsHuPD5k6d6mOI21VDaRuAW71ia1qrI2lL/ApwG19jfpgw9+H1C3ArfasqgoOj/C5Csva\nU5YCWKg4twDZuo9tzaRM322WkFs9YbOia4N1fDR4bPHYLzSxC7sFEo3G1mGjQVd1wcRO+YEdmxXA\nNxqyhrNiq2Qvs3PDBj6r5RKyE7TIssr+xlVZrVUGqVuAW53CP0HKLqs9j/12rAtF2wq/oNQtwK2S\n/bn5TpkV4zmKH2e6imFb4TkLuAVsEQ7cCi73100rjbMgZ4szt7go4LQn6te4ymPlpsbYjrnY//8L\nssnOsy2N82W4pbmaG2NEbweflq6x8+zDYjp7IHDJkgC9YKXsRcPiOSGZMgXoBS+9YGg8IWRvCkgA\nR69PD+yrQCNQ256MsuMBYkiODPgqpv5BzzyZnOYBYkj6Gnz0p0VxCPoFsFIJ0UjSh2hlSGpDZPgF\nRzWr57hXIW+TpTM1EvYFZa3geseU1lrCv+87oTp1NC1AAAAAAElFTkSuQmCC\n",
"prompt_number": 118,
"text": [
" 3 \n",
" x \u239b 4\u239e\n",
"x - \u2500\u2500 + O\u239dx \u23a0\n",
" 6 "
]
}
],
"prompt_number": 118
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## References\n",
"\n",
"- [SymPy documentation](http://docs.sympy.org/latest/index.html)\n",
"- [SymPy Wiki](https://github.com/sympy/sympy/wiki)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Credits\n",
"\n",
"Lakshmi Rao and Neal Davis developed these materials for [Computational Science and Engineering](http://cse.illinois.edu/) at the University of Illinois at Urbana\u2013Champaign.\n",
"\n",
"![](\"http://i.creativecommons.org/l/by/3.0/88x31.png\")
\n",
"This content is available under a [Creative Commons Attribution 3.0 Unported License](https://creativecommons.org/licenses/by/3.0/).\n",
"\n",
"[](http://cse.illinois.edu/)"
]
}
],
"metadata": {}
}
]
}