Python_SymPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Symbolic Mathematics (`sympy`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "import sympy as sp\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.init_printing()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `sympy` treats stuff fundementally different than `numpy`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "np.sqrt(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(np.sqrt(8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.sqrt(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(sp.sqrt(8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sqrt(8) == sp.sqrt(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "np.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.pi + 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.pi + 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### You can use `np.float64()` to turn a `sympy` float to a `numpy` float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sympy_to_numpy_pi = np.float64(sp.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(my_sympy_to_numpy_pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sympy_to_numpy_pi + 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `sympy` has its own way to handle rational numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.Rational(3,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.Rational(3,5) + sp.Rational(1,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding `.n()` to the end of a sympy expression will `evaluate` expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.Rational(3,5).n()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.pi.n()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### You can add a value to `.n(value)` to set the number of significant figures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.Rational(222,7).n()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.Rational(222,7).n(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.Rational(222,7).n(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `nsimplify()` will sort-of do the reverse of `.n()`\n",
    "\n",
    "- This is a bit like a `numpy` to a `sympy` conversion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.nsimplify(0.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.nsimplify(4.242640687119286)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.nsimplify(sp.pi, tolerance = 1e-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.nsimplify(sp.pi, tolerance = 1e-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.nsimplify(sp.pi, tolerance = 1e-6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ... to $\\infty$ and beyond"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.oo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.oo + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.oo / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "1e199 < sp.oo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Symbolic\n",
    "\n",
    "### You have to explicitly tell `SymPy` what symbols you want to use.\n",
    "\n",
    "* Once you declare symbols to use in `sympy` they are unavaliable for other packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "x, y = sp.symbols('x y')\n",
    "a, b, c = sp.symbols('a b c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Expressions are then able use these symbols\n",
    "\n",
    "$$ \\large\n",
    "F(x, y) = a x^{2} y + b x y + c x y^{2}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "my_equation = (a * x**2 * y)  + (b * x * y) + (c * x * y**2)\n",
    "\n",
    "my_equation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "my_equation + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "my_equation / x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `sp.simplify()` attempts to arrive at the simplest form of an expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.simplify(my_equation / x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `sp.collect()` attempts to collect like terms of an expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.collect(my_equation, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.collect(my_equation, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### You can evaluate equations for specific values - `.subs()`\n",
    "\n",
    "- #### Send the values as a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "my_equation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\large\n",
    "F(x, y);\\ y = \\frac{1}{2},\\ a = 4,\\ b = 2,\\ c = 8\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "my_equation.subs(\n",
    "    {y : sp.Rational(1,2), \n",
    "     a : 4,\n",
    "     b : 2,\n",
    "     c : 8}\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### You can also evaluate equations sybolically"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\large\n",
    "F(x, y);\\ y = 2x + 3\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_equation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_y = (2*x + 3)\n",
    "\n",
    "my_y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Replace $y$ with $2x + 3$ using `.subs()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_equation.subs( {y: my_y} )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Multiply everything through using `.expand()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.expand(my_equation.subs( {y: my_y} ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Collect the terms of $x$ using `.collect()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.collect(sp.expand(my_equation.subs( {y: my_y} )), x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Evaluate the expression for some values of $a, b, c$ using `.subs()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.collect(sp.expand(my_equation.subs( {y: my_y} )), x).subs({a:4, b:2, c:8})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Calculus\n",
    "\n",
    "$$ \\large\n",
    "F(x, y)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "my_equation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\large\n",
    "\\frac{\\partial}{\\partial x}\\ F(x, y)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.diff(my_equation, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\large\n",
    "\\frac{\\partial\\,^{2}}{\\partial x^{2}}\\ F(x, y)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.diff(my_equation, x, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\large\n",
    "\\frac{\\partial}{\\partial y}\\ F(x, y)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.diff(my_equation, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\large\n",
    "\\int  F(x, y)\\ dx\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.integrate(my_equation, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\large\n",
    "\\int  F(x, y)\\ dy\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.integrate(my_equation, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\large\n",
    "\\int_{0}^{5}  F(x, y)\\ dx\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.integrate(my_equation, (x, 0, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\large\n",
    "\\int_{0}^{5}  F(x, y)\\ dx;\\ y = \\frac{1}{2},\\ a = 4,\\ b = 2,\\ c = 8\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.integrate(my_equation, (x, 0, 5)).subs({y : sp.Rational(1,2), a : 4, b :2, c : 8})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.integrate(my_equation, (x, 0, 5)).subs({y : sp.Rational(1,2), a : 4, b :2, c : 8}).n()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Solving equations - `solve`\n",
    "\n",
    " - ### Sympy's `solve()` function will solve $F()\\ =\\ 0$\n",
    " - ### If you want $F() = \\mathrm{Value}$, rewrite function as $F() - \\mathrm{Value}\\,=\\,0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_equation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Values of $x$ that solve $F(x, y) = 0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.solve(my_equation, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check the non-trivial solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_x = sp.solve(my_equation, x)[1]\n",
    "\n",
    "my_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_equation.subs( {x: my_x} )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.expand( my_equation.subs( {x: my_x} ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Values of $y$ that solve $F(x, y) = 0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.solve(my_equation, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Values of $y$ that solve $F(x, y) = 2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sp.solve([my_equation - 2], y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## There is an alternative way to write equations in `sympy`.\n",
    "\n",
    "- ### If you have an equation of the form: $F(x,y) = a$\n",
    "- ### You can use: `sp.Eq(F(x,y), a)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# System of equations\n",
    "\n",
    "$$ \\large\n",
    "\\begin{array}{c}\n",
    "9x - 2y = 5\\\\\n",
    "-2x + 6y = 10\\\\\n",
    "\\end{array}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "equation_a = sp.Eq(9*x - 2*y, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "equation_a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "equation_b = sp.Eq(-2*x + 6*y, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "equation_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.solve([equation_a, equation_b], [x, y])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Matrix\n",
    "\n",
    "* There are a couple of different ways to create a Matrix\n",
    "* `Matrix(rows of lists)`\n",
    "* `Matrix(shape, list)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `rows of lists` is pretty straightforward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.Matrix([[1,2],[3,4]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `shape, list` gives you more flexibility\n",
    "\n",
    "- Works like numpy's `reshape()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.Matrix(2,2,[1,2,3,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.Matrix(1,4,[1,2,3,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.Matrix(4,1,[1,2,3,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_matrix = sp.Matrix(2,2,[1,2,3,4])\n",
    "\n",
    "my_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_matrix.det()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_matrix ** -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(my_matrix ** -1) * my_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We can also do it the Linear Algebra (Matrix) way\n",
    "\n",
    "$$ \\large\n",
    "\\begin{bmatrix}\n",
    "9 & -2 \\\\\n",
    "-2 & 6 \\\\\n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix}\n",
    "x \\\\\n",
    "y\n",
    "\\end{bmatrix}\n",
    "=\n",
    "\\begin{bmatrix}\n",
    "5 \\\\\n",
    "10\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "$$ \\large\n",
    "A \\vec x = b\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_A = sp.Matrix(2,2,[9, -2,-2, 6])\n",
    "\n",
    "my_A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_b = sp.Matrix(2,1,[5,10])\n",
    "\n",
    "my_b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\large\n",
    "\\vec x = A^{-1}b\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(my_A ** -1) * my_b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# `lambdify()`\n",
    "\n",
    "## Turning a `sympy` function into a `numpy` function\n",
    "\n",
    "### This is very useful for plotting!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&nbsp;\n",
    "\n",
    "$$\n",
    "\\Large f(x) = 2 \\ e^{-x}\\,\\cos(5x)\n",
    "$$\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sp_fx = 2 * sp.exp(-x) * sp.cos(5 * x)\n",
    "my_sp_fx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `lambdify([sympy variables], sympy function)`\n",
    "\n",
    "### The result will be a `numpy` function\n",
    "\n",
    "### This is the equivalent of writing the `numpy` function:\n",
    "\n",
    "```\n",
    "def my_np_fx(my_np_x):\n",
    "    result = 2 * np.exp(-1 * my_np_x) * np.cos(5 * my_np_x)\n",
    "    return result\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_np_fx = sp.lambdify([x], my_sp_fx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_np_fx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_np_fx(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Make a numpy array of x-values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_np_x = np.linspace(-np.pi, np.pi, 500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Apply the function to the array of x-values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_np_y = my_np_fx(my_np_x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plt.style.use('ggplot')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(\n",
    "    figsize = (10, 6), \n",
    "    constrained_layout = True\n",
    ")\n",
    "\n",
    "ax.set_ylim(-11, 11)\n",
    "ax.set_xlim(-np.pi, np.pi)\n",
    "\n",
    "ax.set_xlabel(\"This is X\", fontsize = 14)\n",
    "ax.set_ylabel(\"This is Y\", fontsize = 14)\n",
    "\n",
    "ax.plot(my_np_x, my_np_y, \n",
    "        color = (1.0, 0.0, 0.0, 0.5), \n",
    "        marker='None', \n",
    "        linestyle='-', \n",
    "        linewidth = 6,\n",
    "        label = \"F(x)\")\n",
    "\n",
    "ax.legend(loc = 0, fontsize = 24, shadow = True);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Taylor Series\n",
    "\n",
    "- Taylor series are polynomial approximations at a specific point\n",
    "- Use the `sympy` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "my_sp_fx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Taylor series of f(x) at f(x) = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.series(my_sp_fx, x, x0 = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If you want different number of terms\n",
    "\n",
    "- n = magnitude of the highest term\n",
    "- n = 4 means all terms up to x$^{4}$ or $\\mathcal{O}(4)$, not including $\\mathcal{O}(4)$\n",
    "- Think of it like a slice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.series(my_sp_fx, x, x0 = 0, n = 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use `.removeO()` to remove the $\\mathcal{O}()$ term at the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sp.series(my_sp_fx, x, x0 = 0, n = 4).removeO()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let us use `lambdify()` to do some plotting\n",
    "\n",
    "- ### Start with a first-order term (a line)\n",
    "- ### `lambdify()` the first-order term"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.series(my_sp_fx, x, x0 = 0, n = 2).removeO()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_np_1order_fx = sp.lambdify([x], sp.series(my_sp_fx, x, x0 = 0, n = 2).removeO())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot using the `numpy` x-values and the new function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(\n",
    "    figsize = (10, 8), \n",
    "    constrained_layout = True\n",
    ")\n",
    "\n",
    "ax.set_ylim(1, 2.75)\n",
    "ax.set_xlim(-0.2, 0.2)\n",
    "\n",
    "ax.set_xlabel(\"This is X\", fontsize = 14)\n",
    "ax.set_ylabel(\"This is Y\", fontsize = 14)\n",
    "\n",
    "# Original Function\n",
    "\n",
    "ax.plot(my_np_x, my_np_y, \n",
    "        color = (1.0, 0.0, 0.0, 0.5), \n",
    "        marker='None', \n",
    "        linestyle='-', \n",
    "        linewidth = 10,\n",
    "        label = \"f(x)\")\n",
    "\n",
    "# first-order term\n",
    "\n",
    "ax.plot(my_np_x, my_np_1order_fx(my_np_x), \n",
    "        color='b', \n",
    "        marker='None', \n",
    "        linestyle='--', \n",
    "        label=\"1-order term\")\n",
    "\n",
    "ax.legend(loc = 0, fontsize = 14, shadow = True);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make and `lambdify()` the 2, 3, and 4-order terms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_np_2order_fx = sp.lambdify([x], sp.series(my_sp_fx, x, x0 = 0, n = 3).removeO())\n",
    "my_np_3order_fx = sp.lambdify([x], sp.series(my_sp_fx, x, x0 = 0, n = 4).removeO())\n",
    "my_np_4order_fx = sp.lambdify([x], sp.series(my_sp_fx, x, x0 = 0, n = 5).removeO())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(\n",
    "    figsize = (10, 8), \n",
    "    constrained_layout = True\n",
    ")\n",
    "\n",
    "ax.set_ylim(1, 2.75)\n",
    "ax.set_xlim(-0.2, 0.2)\n",
    "\n",
    "ax.set_xlabel(\"This is X\", fontsize = 14)\n",
    "ax.set_ylabel(\"This is Y\", fontsize = 14)\n",
    "\n",
    "# Original Function\n",
    "\n",
    "ax.plot(my_np_x, my_np_y, \n",
    "        color = (1.0, 0.0, 0.0, 0.5), \n",
    "        marker='None', \n",
    "        linestyle='-', \n",
    "        linewidth = 10,\n",
    "        label = \"f(x)\")\n",
    "\n",
    "# first-order term\n",
    "\n",
    "ax.plot(my_np_x, my_np_1order_fx(my_np_x), \n",
    "        color='b', \n",
    "        marker='None', \n",
    "        linestyle='--', \n",
    "        label=\"1-order series\")\n",
    "\n",
    "# second-order term\n",
    "\n",
    "ax.plot(my_np_x, my_np_2order_fx(my_np_x), \n",
    "        color='k', \n",
    "        marker='None', \n",
    "        linestyle='--', \n",
    "        label=\"2-order series\")\n",
    "\n",
    "# third-order term\n",
    "\n",
    "ax.plot(my_np_x, my_np_3order_fx(my_np_x), \n",
    "        color='g', \n",
    "        marker='None', \n",
    "        linestyle='--', \n",
    "        label=\"3-order series\")\n",
    "\n",
    "# forth-order term\n",
    "\n",
    "ax.plot(my_np_x, my_np_4order_fx(my_np_x), \n",
    "        color='y', \n",
    "        marker='None', \n",
    "        linestyle='--', \n",
    "        label=\"4-order series\")\n",
    "\n",
    "ax.legend(loc = 0, fontsize = 14, shadow = True);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The second order fit is just fine since everything is a harmonic oscillator if you look closely enough..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## General Equation Solving - `nsolve`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\Large f(x) = 2 \\ e^{-x}\\,\\cos(5x) \\\\[10pt]\n",
    "\\Large g(x) = \\frac{3}{2} \\left [\\frac{x^3}{\\pi} - \\pi x \\right]\\\\\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sp_gx = sp.Rational(3,2) * (x ** 3 / sp.pi - sp.pi * x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sp_fx, my_sp_gx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `lambdify(gx)` for plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_np_gx = sp.lambdify([x], my_sp_gx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Where do they cross? - The graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(\n",
    "    figsize = (10, 8), \n",
    "    constrained_layout = True\n",
    ")\n",
    "\n",
    "ax.set_ylim(-7,7)\n",
    "ax.set_xlim(-np.pi,np.pi)\n",
    "\n",
    "ax.set_xlabel(\"This is X\", fontsize = 14)\n",
    "ax.set_ylabel(\"This is Y\", fontsize = 14)\n",
    "\n",
    "ax.plot(my_np_x, my_np_fx(my_np_x), \n",
    "        color = (1.0, 0.0, 0.0, 0.5), \n",
    "        marker='None', \n",
    "        linestyle='-', \n",
    "        linewidth = 6,\n",
    "        label = \"f(x)\")\n",
    "\n",
    "ax.plot(my_np_x, my_np_gx(my_np_x), \n",
    "        color = (0.25, 0.0, 0.75, 0.5), \n",
    "        marker='None', \n",
    "        linestyle='-', \n",
    "        linewidth = 6,\n",
    "        label = \"g(x)\")\n",
    "\n",
    "\n",
    "ax.legend(loc = 0, fontsize = 24);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Where do they cross? - The `sympy` solution\n",
    "\n",
    "### Want to find where `f(x) - g(x) = 0`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Need to provide an initial guess"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "my_guess = 3.0\n",
    "\n",
    "sp.nsolve(my_sp_fx - my_sp_gx, x, my_guess)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "all_guesses = (3.0, 0, -1.0)\n",
    "\n",
    "for val in all_guesses:\n",
    "    result = sp.nsolve(my_sp_fx - my_sp_gx, x, val)\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your guess has to be (somewhat) close or the solution will not converge:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "my_guess = -40\n",
    "\n",
    "sp.nsolve(my_sp_fx - my_sp_gx, x, my_guess)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Primes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# List of primes in the range 0 -> 100\n",
    "\n",
    "list(sp.primerange(0,100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# The 100th prime number\n",
    "\n",
    "sp.prime(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# The next prime after 2020\n",
    "\n",
    "sp.nextprime(2022)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# The prime factors of this year\n",
    "\n",
    "sp.factorint(2022)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `SymPy` can do *so* much more. It really is magic. \n",
    "\n",
    "## Complete documentation can be found [here](http://docs.sympy.org/latest/index.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}