01_Getting_started.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ This notebook is part of the addition lecture *An overview of key ideas* in the OCW MIT course 18.06 by Prof Gilbert Strang [1]\n",
    "+ Created by me, Dr Juan H Klopper\n",
    "    + Associate Professor\n",
    "    + Department of Biostatistics and Bioinformatics\n",
    "    + Milken Institute School of Public Health\n",
    "    + The George Washington University\n",
    "    + <a href=\"mailto:juanklopper@gwu.edu\">Email me with your thoughts, comments, suggestions and corrections</a> \n",
    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\"><img alt=\"Creative Commons Licence\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-nc/4.0/88x31.png\" /></a><br /><span xmlns:dct=\"http://purl.org/dc/terms/\" href=\"http://purl.org/dc/dcmitype/InteractiveResource\" property=\"dct:title\" rel=\"dct:type\">Linear Algebra OCW MIT18.06</span> <span xmlns:cc=\"http://creativecommons.org/ns#\" property=\"cc:attributionName\">Jupyter notebook study notes by Dr Juan H Klopper</span> is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\">Creative Commons Attribution-NonCommercial 4.0 International License</a>.\n",
    "\n",
    "+ [1] <a href=\"http://ocw.mit.edu/courses/mathematics/18-06sc-linear-algebra-fall-2011/index.htm\">OCW MIT 18.06</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Philosopher:400,700,400italic,700italic' rel='stylesheet' type='text/css'>\n",
       "\n",
       "<style>\n",
       "\n",
       "@font-face {\n",
       "    font-family: \"Computer Modern\";\n",
       "    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "/* Formatting for header cells */\n",
       ".text_cell_render h1 {\n",
       "    font-family: 'Philosopher', sans-serif;\n",
       "    font-weight: 400;\n",
       "    font-size: 2.2em;\n",
       "    line-height: 100%;\n",
       "    color: rgb(0, 80, 120);\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\t\n",
       ".text_cell_render h2 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "    font-weight: 400;\n",
       "    font-size: 1.9em;\n",
       "    line-height: 100%;\n",
       "    color: rgb(245,179,64);\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\t\n",
       "\n",
       ".text_cell_render h3 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "    margin-top:12px;\n",
       "    margin-bottom: 3px;\n",
       "    font-style: italic;\n",
       "    color: rgb(94,127,192);\n",
       "}\n",
       "\n",
       ".text_cell_render h4 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "}\n",
       "\n",
       ".text_cell_render h5 {\n",
       "    font-family: 'Alegreya Sans', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 16pt;\n",
       "    color: grey;\n",
       "    font-style: italic;\n",
       "    margin-bottom: .1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h6 {\n",
       "    font-family: 'PT Mono', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 10pt;\n",
       "    color: grey;\n",
       "    margin-bottom: 1px;\n",
       "    margin-top: 1px;\n",
       "}\n",
       "\n",
       ".CodeMirror{\n",
       "        font-family: \"PT Mono\";\n",
       "        font-size: 100%;\n",
       "}\n",
       "\n",
       "</style>\n",
       "\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "css_file = 'style.css'\n",
    "HTML(open(css_file, 'r').read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](GWU_Logo_Horizontal.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to symbolic python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preamble"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This first notebook introduces Python and the computer algebra package `sympy`.  As with most of the notebooks, we begin by importing the `sympy` package into Python.  We also initialize the notebook to be able to print our results using LaTeX."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Importing\n",
    "from sympy import init_printing\n",
    "init_printing()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating mathematical variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The equal symbol, `=`, is an assignment operator in Python.  It assigns what is on the right-hand side (RHS) to what is on the left hand side (LHS).  The LHS is is a name called a computer variable and we are free to choose this name, within certain limits.  The name is basically a reference to a part of computer memory that stores what is on the RHS.  The RHS is then an object, which can be of various types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most common convention in Python is to use a descriptive name that may consist of more than one word, i.e. a phrase.  The first letter of each word is in lowercase and the words are concatenated by an underscore.  This convention is referred to as _snake case_.  For instance, if I want to create a computer variable to hold a number, I might call it `my_number`.  The name makes sense in as much as if I viewed my code months down the line or if I gve it to someone else, we should all be able to figure out what is was meant to hold."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python contains many reserved words that make up the syntax of the language.  It is not advised to use these as you computer variable names.  Also steer clear from symbols and place numbers at the end of names."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use your favorite search engine and look up naming conventions.  Find the one that suits you.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's then create a computer variable named `my_number` and assign the valye $4$ to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_number = 4  # Creating a computer variable and assigning a value to it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A small part of the computer memory is now _called_ `my_number` and it contains the value $4$.  We can access this value by simply calling the name of the computer variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAOCAYAAAAWo42rAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAArklEQVQoFWP4//8/AzZcX19vBMQzYXJMDLjBaqCUEEwaq8KGhoYymAIYjaEQqMgIKPkBimHqGDAUAmXCgYpnwVVAGSgKoVbORFcE4sMVAhUpAfkfgPQ9vAqBkunYrIRpApsIVJAGFMBqJVwh1EoBXFbCFDICQ98FyEmHCSDRIUA2KJj2APE9rNEHijagAe+BeDUxUSgANAmEwYARpAMZAN0K8hQoqEBOAoE1QHwaAIFUXZ4aMJQ9AAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle 4$"
      ],
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The value $4$ is an instance of an object and as an object, is of a certain type.  We can check up the object type with the `type()` function (a keyowrd from the Python syntax that actually perform a, well, _function_.).  All functions in Python have a set of parenthesis at the end.  Inside of these parenthesis we pass the information that the function required to do its job.  These pieces of information are called _arguments_.  We will pass `my_number` as argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(my_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We note that it of type `int`, which is short for, _integer_, a whole number.  We can reassign the computer variable to hold another value, which may be an instanceof another type of object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_number = 4.0  # The .0 indicates that this is a decimal value (we can also just type 4.)\n",
    "type(my_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our computer variable is now an instance of a floating point (`float`) object.  We use the term _instance_, because in each case we create a single example of an object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computer variables and the assigment operator do not behave in the same way as their mathematical namesakes.  Look at the code below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABkAAAAPCAYAAAARZmTlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABjElEQVQ4Ea2U723CQAzFU9QBItgg3QDaDdIN2m5QukH5mHyrwgYwQmED0gkQbAAbgNgg/b3kjEKUP1VUSy/ne2efz/blvCzLvCiKxhrLgPNBUOb66vdeIT9xHPuoezeXLpkUQ/cX/8RZnRgfQAJ3FDfQBzmDCxgDBViDCUbiOgW7HUZbxhmYo8/ABj3InVUCyrLqWwp8p+BQ9YdLwEa8ZZIH7Pl5xc/KXN5iyyQkG/8/goRspnJXJe8HZGiN94g4hVA/RkC1/IKrOyFLhbAu+y4ZWiYy/sZpDtQ0YYeuU7bJ0C22XZCiXGz2DK6G6Eo1BYu2CH9cG1kmdfYKFBBQpWuSul6YrWV5GrCJ7rPueZM01h0/y77OxrijMnkERpQD5Sdho9bm46Cy1mVrmaQKsmQjPQNVUdO1QZesMNBBq6Inaa9sFWSBctNg5p/OQz9aLnA+yMBNaZkvMTgzvjhTD12VeQPv4u7020MqXV1bidJUQ/UOXUSYMD+gp4wfxmlkrk31QMpeD+QTuP5nv4JEA14+QuryAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle 5.0$"
      ],
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_number = my_number + 1\n",
    "my_number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initially, this makes no sense.  Just to be sure that we are all on the same page, let's create another computer variable called `x` and assign the integer value $7$ to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAPCAYAAADd/14OAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAu0lEQVQoFYWR0Q3CMAxEU8QAsEJHQLABbAAzMAKfyW9WATaADZAYgRGgG5R3CoSkWKqlq93z+RI5jfe+dc6twTGE0JHNaBBu6ZzMbiI7DOZT6hW4gkfiq69OOoiR0DGxUS4DTldS76ws4U2FERHRLvN937shuHcEi5K3RC2iSylSPcnWvyJSCnWUkzjJ7VVy33rouMfGWtPf0Vr+sz4z/WVHVjGD0u7MZ8xCBMs0O+KISI6KUcf7R2S+1Bs1T3OSPIJvGwAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle 7$"
      ],
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 7  # Creating a computer variable and assigning the integer value 7 to it\n",
    "x  # Caling the computer variable to access the value that it holds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we'll repeat the ` + 1` we did above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAOCAYAAAAWo42rAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAA+UlEQVQoFW2SsXHCQBBFD2jALdhOiXADCnAHogSbEhgiKXUJuAW5AxMo95gO7NQZ0IF4b+E00oz/zGrv7/z7u3enSdd1SdR1fUfaBrl+5A31fVCFRlVVu7zOmVpDlPKpana9kr5j5/jzAo0uIYQ8Es9jzZhl4RflEudPwtky3ljsJBP7CwQNqQyS0oZsFzd+WMuOClfwd4tApyVxkIihULczoZNX8kD8YBBdojXEUz+R1+TATeA4br7PjrZyrh4InU13D7ec3RbU6+GrUE6pKIpT27Zzln9TBFqfyc70H3Tc59ae2He12APu7F7R7/AeFxRtf+yVg5/iAl5gbKb5R2kWAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle 8$"
      ],
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = x + 1\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algebraically this makes no sense, until we remember that the `=` symbol is not an equal sign, but an assignment operator, assigning what is on the RHS to what is on the LHS.  On the RHS then we have `x + 1`.  At the moment `x` holds the value `7`.  We then add $1$ to it to make it $7+1=8$.  This new value, $8$, is then assigned to the LHS, which is the computer variable `x`.  The value $8$ then overwrites the previous value held in `x`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In mathematics, then, we are used to mathematical variables, such as $x$ and $y$ and not computer variables, `x` and `y`.  We have to use a package such as `sympy` to help Python deal with this.  More specifically, we import just the `symbols()` function from the `sympy` package.  Note the syntaxh for doing so."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import symbols"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have the `symbols()` function added to the many built-in Python functions.  We will use it to reassign our computer variable `x` and turn it into a mathematical variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sympy.core.symbol.Symbol"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = symbols('x')  # Setting x as a mathematical symbol\n",
    "type(x)  # Looking at the type of x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now `x` is a mathematical symbol (in Python a `sympy.core.symbol.Symbol` object) and we can write an expression such as $x+1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAC4AAAAQCAYAAABpyU3qAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABfklEQVRIDc2W7U3DMBCGU5QBKtigI1DYoCPwMQF0AxD/+g+VDYARygZlg0JHYISqG5TnMY5lKoqQSJqc9ObO58T3+nLnpLfZbIquy2QyOYbjDAyx1/ItvXRRINiH1zNYgRMwAEkaJU7wEZEG6KcU8Y9GzOy5t2PfoMx6koNkNWOYNVG7NE28dsLVgqlUeB1m5jpOnKKvgHV1GX0L7nmJdusqz/gUYg8CVgtgY4wY36Ld1BR0RkLGIWemc2JrxmfArCuHIJ8PzjYvVam8Qf4jIzLEXuJzAwU6dHc2/81k/hGHJ8i2uGGfH29PMHb9X9f94ZnkqjK+TJ4v4wJ1v+XbOdxBTMK+NY9Dy69WyWs8LEwQM2dNp0bE1xe1Rv7nYmUk5OfU5nxF+1rX2Hnp3DG2STsjZtwMi1XchJ/YJPic85RpU45i8NAz2iUwy36SJVhAdAzmwIZ7B24olY337EuIayUogRt6hs9KmPea/DskyP6a0+3VKB6n4Uitcc2w1Cfm03LmS5W2QQAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle x + 1$"
      ],
      "text/plain": [
       "x + 1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might wonder what type `x+1` is.  Certainly, `1` is a Python `int`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1)  # Checking the type of the mumber 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sympy.core.add.Add"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x + 1)  # Checking the type of x + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We note that its is a `sympy.core.add.Add` type.  This allows Python to do the actual mathematical addition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's add `y` as a mathematical symbol and try to create $\\frac{x}{y}$.  Here we are not using an assignment operator, we simply write the expression $\\frac{x}{y}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = symbols('y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just so that you know, the forward slash, `/`, symbol is used for division."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAwAAAApCAYAAAABFMhiAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABvUlEQVQ4Ee2VPVJCMRRGH8oC0NISd4BjT4E7EF2BWlo6VNA5uANgBQ7sQAt6BnYgpZ0MO8BzwssjYKG0Dnfme/cnuTc3CXwprVarTOl0OhXUfXCy7BJ9B6rgNo9NmDM6yh1Vl8CLwJ6AAWjgP6Et1gVZ2Q9BK4eAPrIE18BVlFOwHreldrtdU0fg98A0+qkOLbHCLNTZfG4wXzfuxkr3EKIkNzDseRSnEasI/XJuDLHd9Dv6ASyx5+goLXw3n7mCFcUiT15gF0LMMU8tyHG9Xv/E8hROwAUTWuPx+AM8gjNiK2JFeyVPYB/5senfkg8Jv52Q4yV+lXtdxOHi/nKs/+HHV44bzQlABjwHU/z+ztiAWDPdtFQir76BlDbNk9ikzkAzGRNr2JFKrrC3qAbfmJy1TkDPSYpUYrWeg4nITa5crCBbu5IDUmLav6sb21oBP0iT74zEUCCPWUTqDISdbtrxKkg51VjRv85uwtbkvMWifxPKfhKRoT1vj/ULeCdK6D9Y6euya/N/7+6+REVLVgXTUIUPtifjzT/HmLpIwPYm02fKV7RPYrwfXGgm0j0DJvhOWNneh8Q2vRNQvgHzCc+TWBUxRAAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle \\frac{x}{y}$"
      ],
      "text/plain": [
       "x\n",
       "─\n",
       "y"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x / y  # Stating a calculation without an assigment operator is an expression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `sympy` package is great at creating mathematical typesetting.  Let's create an expression with a power.  In Python, two asterisks, `**`, are used to indicated powers.  Below we create the expression $x^2 -x$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAADoAAAATCAYAAADBGB7WAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABxElEQVRYCd2WQU4CMRSGQTmAunSJN5C4ZzHeAPQE4NIlmd3sDN6AeAQ9giazB7mBLl0SbjB+/6TTNIQMMw0xLzZ5vNc3bfn/vtfXdoui6LRtWZadMSd18/pOT/Bv2671V+N7kX80h9RDNRd7gf2JXFU+a/okEtAUckkwd47dx3cd+EyZsUQVzZUpJgfAdGPO6O6aRFIRHaH/Xep6ri5dRzgG3mnQiE3dkgokVXEVzQG22YorsLFVt+NIztC3Wsj1pb/Vt9aizqgjpStlFhBSgRJxk5GNjajuTD0apH2DpL9bvdOI4SMKSAGfOlw36AmiM3jvfEvGvDnblGqCPSxGeu08S2CxRF6QhL7SU5ugomO1HcRepi5kFMmQiM6ZrgxFVe0CCb+XTgs/TbFXZ3TFhLBa6k5c4xPhDnp8DFKso8z4QKSbtjHz1jWDG2GvIrq70B0LP9UsHvUJwNq4oz4s9mzCXuxVRD1wJiZ0tOO+8OArI+CA+rHWjDrsPUfiFdA60O9oXRFb7DCVU/rhnWmCYxvsqrqKoGTjJm5CFvj0TVXYYmuM/XQ4HP7AQFX1HNGbNc3z/At5RC7xFfh8GtM308DXGPsvAMTKfselR7gAAAAASUVORK5CYII=",
      "text/latex": [
       "$\\displaystyle x^{2} - x$"
      ],
      "text/plain": [
       " 2    \n",
       "x  - x"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x**2 - x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transformation of expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will get right into things and examine the power of `sympy`.  One of the common tasks in algebra is factorization, as in $x^2 -x = x \\left( x - 1 \\right)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python functions that act on objects (or expressions) that we create are termed _methods_.  The `.factor()` method is a function that will factor our expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAE0AAAAUBAMAAAA6pq28AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABE0lEQVQoFX2SMW7CQBBF/xqwsWMSy25SIQQSbW4QuYnS5gagcAEKWiQL5QC0dNwAbgAFB6Cjzg1CmS4za3Z3jAPT+M3fP+sZewAb75au4SAFtZZZhRu5SEOZOD3+BtTS5ZgLdphNzpR8OgFfggUG7Os6oVk4lqR94QeQDt6GPcA70umFaz7/CDUOFm3qM5pSvxeu+YIl/MQ/t3KgvYflmi8uoBCtWX+kFgyrlY4t67q/hx+ipx7n7DPMZML5drqO3wuUbDz81L5WgTh5gZeUcxiu+WiO0X4D3gAa3bL0efydO2Nk/fQ0JaSrLQtf5/X3BIS6tVK+8d/04bOo/H8PSoPcgygXRVWs7NWdPa1ecXvvZ8AfJhM63ZZi4acAAAAASUVORK5CYII=",
      "text/latex": [
       "$$x \\left(x - 1\\right)$$"
      ],
      "text/plain": [
       "x⋅(x - 1)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x**2 - x).factor()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also expand an expression using the `expand()` method.  By the way, we use the single asterisk, `*` symbol for multiplication."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAADkAAAAUBAMAAADFBIheAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAApElEQVQoFWNggIDctQJQFhaKzYF5AhZhqBCHA/cXPLIBLF9xyzIw8HzEJ8uhgE82F58k+wV8smEM0bilueecWYhblu///w9YZYWUXdUUMGUgwowJ7E0cmKEIFWYTYPvI6oChFyrMyMC1AC4nORMEZgP5cGF+BbgsMgMqvH8DsiCcDRbmEdBnYBKAi8EYUOH4A+sZ3GFiCBoqLKwkdL0AIQpjQYQBmAAkMWfQpQ0AAAAASUVORK5CYII=",
      "text/latex": [
       "$$x^{2} - x$$"
      ],
      "text/plain": [
       " 2    \n",
       "x  - x"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x * (x - 1)).expand()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just to be clear, we can import the actual functions, `factor()` and `expand()`, from `sympy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import factor, expand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can use them as functions (instead of the method syntax we used above)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAE0AAAAUBAMAAAA6pq28AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABE0lEQVQoFX2SMW7CQBBF/xqwsWMSy25SIQQSbW4QuYnS5gagcAEKWiQL5QC0dNwAbgAFB6Cjzg1CmS4za3Z3jAPT+M3fP+sZewAb75au4SAFtZZZhRu5SEOZOD3+BtTS5ZgLdphNzpR8OgFfggUG7Os6oVk4lqR94QeQDt6GPcA70umFaz7/CDUOFm3qM5pSvxeu+YIl/MQ/t3KgvYflmi8uoBCtWX+kFgyrlY4t67q/hx+ipx7n7DPMZML5drqO3wuUbDz81L5WgTh5gZeUcxiu+WiO0X4D3gAa3bL0efydO2Nk/fQ0JaSrLQtf5/X3BIS6tVK+8d/04bOo/H8PSoPcgygXRVWs7NWdPa1ecXvvZ8AfJhM63ZZi4acAAAAASUVORK5CYII=",
      "text/latex": [
       "$$x \\left(x - 1\\right)$$"
      ],
      "text/plain": [
       "x⋅(x - 1)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(x**2 - x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAADkAAAAUBAMAAADFBIheAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAApElEQVQoFWNggIDctQJQFhaKzYF5AhZhqBCHA/cXPLIBLF9xyzIw8HzEJ8uhgE82F58k+wV8smEM0bilueecWYhblu///w9YZYWUXdUUMGUgwowJ7E0cmKEIFWYTYPvI6oChFyrMyMC1AC4nORMEZgP5cGF+BbgsMgMqvH8DsiCcDRbmEdBnYBKAi8EYUOH4A+sZ3GFiCBoqLKwkdL0AIQpjQYQBmAAkMWfQpQ0AAAAASUVORK5CYII=",
      "text/latex": [
       "$$x^{2} - x$$"
      ],
      "text/plain": [
       " 2    \n",
       "x  - x"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(x * (x - 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, we are still using Python, so we can assign any `sympy` expression to a computer variable and use all of the functions and methods we have learned about."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAE0AAAAUBAMAAAA6pq28AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABE0lEQVQoFX2SMW7CQBBF/xqwsWMSy25SIQQSbW4QuYnS5gagcAEKWiQL5QC0dNwAbgAFB6Cjzg1CmS4za3Z3jAPT+M3fP+sZewAb75au4SAFtZZZhRu5SEOZOD3+BtTS5ZgLdphNzpR8OgFfggUG7Os6oVk4lqR94QeQDt6GPcA70umFaz7/CDUOFm3qM5pSvxeu+YIl/MQ/t3KgvYflmi8uoBCtWX+kFgyrlY4t67q/hx+ipx7n7DPMZML5drqO3wuUbDz81L5WgTh5gZeUcxiu+WiO0X4D3gAa3bL0efydO2Nk/fQ0JaSrLQtf5/X3BIS6tVK+8d/04bOo/H8PSoPcgygXRVWs7NWdPa1ecXvvZ8AfJhM63ZZi4acAAAAASUVORK5CYII=",
      "text/latex": [
       "$$x \\left(x - 1\\right)$$"
      ],
      "text/plain": [
       "x⋅(x - 1)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_expression = x * (x - 1)  # Creating a computer variable\n",
    "my_expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAADkAAAAUBAMAAADFBIheAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAApElEQVQoFWNggIDctQJQFhaKzYF5AhZhqBCHA/cXPLIBLF9xyzIw8HzEJ8uhgE82F58k+wV8smEM0bilueecWYhblu///w9YZYWUXdUUMGUgwowJ7E0cmKEIFWYTYPvI6oChFyrMyMC1AC4nORMEZgP5cGF+BbgsMgMqvH8DsiCcDRbmEdBnYBKAi8EYUOH4A+sZ3GFiCBoqLKwkdL0AIQpjQYQBmAAkMWfQpQ0AAAAASUVORK5CYII=",
      "text/latex": [
       "$$x^{2} - x$$"
      ],
      "text/plain": [
       " 2    \n",
       "x  - x"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(my_expression)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common mathematical functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `sympy` package is really great for symbolic (mathematical) computation.  In this section we higlight the difference between numerical (Python) and symbolic (`sympy`) computation. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an example of numerical computation, let's calculate $\\frac{5}{3}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAALQAAAAPBAMAAAC/7vi3AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAVO8Qq4lmdpnN3TJEuyJIWJmAAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABcklEQVQ4EbWUsUpCARiFT1w1uSX6Bhm+gFRLkyIEQYuDZtDiG9gSNYpQEETcqaWGGttcWlr0DZKmliB6AkEIjOj2+6eef/hx6w4fh3OOh58LV2D2JE8OAQ9oHHdhwI4xtTNPnnbr9SqwVNDx4BYX8IDtfjoyYMeY2mHSiuO4jK3aSKczbbzBA16RGRiwY0ztMLkCErKa+pt+fhftYfVHAsJ0aKoyibwMebuz6ReR8JDJS0CYDk1VJpFbjuRX06vHj6d9eMjeNC5BmA5NVSaRW2R5Oh2Mm7j3gNI1whzBzoIE2DfTMdDZdFAsDZEuEMG8syBBMOQ0voBW30P2DqlvwhRpqjIJliMz/SDTTQ9hhNQnAXZoqjIJwoGZrkyu9pDIy9UE2KGpyiTIls10r4gOPKyMkM4TpkNTlUnQa0+ml+WTKUVIVIN1F9jBRs6ARWNqxyRrVVlOV8bnCMvAQa3rI3m2J/9bc5giTVUm+chNrv635xfkpjtv9oRIdwAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$1.6666666666666667$$"
      ],
      "text/plain": [
       "1.6666666666666667"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 / 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We get an approximation, i.e. the reciprocal $6$ is terminated by rouding to a $7$.  The real solution is obviously $1.\\dot{6}$.  Better yet, the exact solution is $\\frac{5}{3}$.."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is package called `math` that expands Python's ability to do numerical computations.  Let's import it and calculate the square root of eight."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because we did not import any specific `math` functions, we have to refer to them by dot notation, i.e. `math.sqrt()` for the square root function in the `math` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAALMAAAAPBAMAAABdMuPOAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJm7MquJRO/dIs12VGbfGimAAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAC/klEQVQ4EbWUy2sTQRzHP5vH1qZJuwiKUqE1YgsiWF9nowfBU5ciogftUjUXi4k3QaH1hS/EoujBS6MHUQ9SxF41iIqo0CgK4sHmYik+W7U+Khi/M1P1L3Agu9/v7zPzncns7OJlV+ZQ8x73FLHGKki0Ops415bPmx4we9EqcxPZ0JXPR5Lr9Ou9n9NVzWvbWZIdy5HKb6/AHPxvph6Drc5YBfWhs421Wm0KXgR4IYWiuop8VDGUPAfNxdiQxcyrpg7QUPEucInML1gIx0z0K3Vyxip4EDobK0HobeoOiAXM6ldXkSWQlEofgRXEOyxmM3QxDrsYqfADjkO3BrMd5jtjFam3obM++Dn4qNwBktNYEsEODbo+TJ0qasL8hAKrYTTYWzTmdkB3TqxvObudsQq/IfzL9ruxDZMkv2giEagr6xINE+/X3UZ7n2GkpL3rq2A3ROVBzUiyNqaKMU69sQGOdahulqVtngRH4nKNpWGabva2z+CTWvWeT4ouawciFan7aq4UfprBxhjlld3aDPOrurjovugP2a3aAoZpuUW91mRwQXvwRgM6y1w+41YSqheZ9sGjuunpW+Vjo2WhxXAXrRPhiDehWmSiJ4gdcDhezhReatWdkR6wCSNrLrwm/V0zyVj1zEVb9shwGx1rBUfSQ1pNTtFNAzTq9Fr86m5h7cyGcExhaXVX08ydFWuMehLZaMfOGm7H3tF74Uh9B8xF0fVDNOoMuz9Fd6DHOFq5Bmsq8JRUSSMm9CSrxlw06n1XdtnB8gxTbzc208q1jCNNITzPZr8vTfb/W7WZaqXpWgtMdCIirWhOQLxkjVUwK5xhCf1HF70eHkqK0NlqihwhMUms3+HxIDHtXplD9thdzfdsoWWIfQHvsMYqBXQ4S8acEkYCUufziwckRRiNTBFlbGJexWIeBc1VHRfvMB/sub5dq/0w5yLRpc+TNVbhr5mqWkvqlDIWn75RbdCHQ9GGcEVxeoVr2/DbNjqM39Oune29l6Muu6ho+P9qvwFlyxXr+Rie0QAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$2.8284271247461903$$"
      ],
      "text/plain": [
       "2.8284271247461903"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(8)  # An approxximation of the square root of 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `math` package contains numerical approximations of constants such as $\\pi$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKoAAAAPBAMAAACGiUnsAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIom7VJlmdt1E780QqzJwzRuQAAAACXBIWXMAAA7EAAAOxAGVKw4bAAACwUlEQVQ4Ea2TzUtUURjGfzOjzqj36iUowk3DyEgbP8AgChdDkIsgmoIhNIuhjSCEbkIoSIl2Ec6mVQuLIrIUhyAhKLwEUSTRFGnRxkEQ2o2aRH7Q7T3vmZH5Azow9z7zPO/znI/7HtiXOELVWC3jOX81xdvEZ3Ay3UUIj3aAkmpQ5Iwmczjn2j1+LiYScVuucijNmawmnfLN6478DJoNNnAe0+LzkfAWzksuWNIajEwtfOVDNjTNcBAEBS23cnST5nFJcr4sSxbRmTJ6/s3DvY+bZgCeEknTDYa0BoPohQV+wCJnwbXlVq6fojkvcTDsy+PA6zIqyFuE8BpPYNmblBAwpDUYRCu8Zwc6iUOHLd/LK5+ApsarUz91EV1n3me5eNykaKq8xKCpkz20Ob9gTKasH8GWqyx7v6kOXWudV0ldGrxEg6x1y4gT/s7K1RwY0hoUucHlFM9krSJFqJRrXuiwHJwZZq3vqKT2cCgn22/8LUr9hrOT5RYYEjUoonPHl+0zn4U2aRMtr+Rdk6lkmNT4XqrMPs5RTmyKEis4AfSLbkhQg6CavokpIiM1nSmcNeHL5TavYVoYTa0pVqXWrlMzuPJXlAz8Ed1MLqRs1RgEXSG67dN7o7NINC9UuVzkkEfErEdT31BJdctH6u5Kt6XhtuhZJdVgZQkvpcQpPRnrMhG4uzavebcq9XQms31e8+VD1UogjQU4KVNLVw7nlFSDIrNrNytF8i2apU5GY8HmNXQRM3bNkueMRXJtYvm6aUoeTXGiXsmn39ylWF4Ningg5+wN+U1yKqU0aLnNq8tK+znSyoz58uChRXLxhrzoK2cODiaS33HjziOUVIMi7vkMct1fyEqPxuWkTLnKcDdzTG//xdkXorYGSyja3z4AiUxO+iYI5Fsl24ugpBoUNS0mc4STfUBLSh5arrL8+f/jH88yGn6MoZOcAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$3.141592653589793$$"
      ],
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `exp()` function contains an approximation of Euler's number.  We can get this approximation by passing the argument `1`, as in $e^1 = e$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKkAAAAPBAMAAABtvvLvAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJm7MquJRO/dIs12VGbfGimAAAAACXBIWXMAAA7EAAAOxAGVKw4bAAACyklEQVQ4EbWUTWsTURSG32kykzQf00GoWBQyDdqCoE1xpQgGQcFVQxDxsxmqzU7NVlzYuvELbPciHbuqq6Yu3NkGFyJSbBQRVxoXimjVFrWtbdPxPXcmkP4Ah3Dz5rlnnjlz72SgpfdlweNYvlh0JECbHShBYZUUw45n3ZyR2gCGbWDaOlzFluJpwHh5QeoI4x/De4B2GMsCfnqel0NyGGgBzvlYJeCdBdjQq5tgaw4Y8Zag3cWEhSfocCkhjHqeA3QCN/kbuwEd7YOLwHtgu49V0k4ULCRr0MpNEHhO6+OzLvQh6LY5BKNMCWF88AXDLaDg8tsBeBMmreeBDh+rxNuwYGSgjTbD2Dda+UFbGcZCiHfJMwXqZMCMhUJWpUjFt17rxSUfq6SskV+WUWuGRjywpjJIrLblEKlzdQl9K4VjlrKGOEqvuve5KmDMChJ7RWHjoipqwK9i7Z/fiSh7XU7ZiKwDAvUfT7NSGVmSEWzQt+LymlxGsJ/EanhTUtOAWkWsvZgsGQuIb0w6CK9DwZAVU7svu8lDW+AgvSa7x24wEgdJrK+vrJSaoAGxAqFRHMTb+qSN8BIacL/MpGUAEmUOYv2ExAo9xEGi1cxhbpjzDfgmsLasIjl/9Le/Ag3Y49Jms5pHa4aDWHl2X1VhP8kzELUQ5nZIrcBXjlh1WVKepC9yt5J1TcEzXLcS7w0xl1PgjLLKSug1wQ/8JNYU5/pVrYLf8+me6xVuVAu74AVCGfaTVPAO0MMWHCRcTqHP5iC93uZyuQqrpJ6sqAsc8GsDGM3Jn7C1bA6jzzWDfwEhLfeAh8WBU0iVgQ8OrQlar1qY97FKwJyFyBTMyiYYzSBm44ubmNKmgfvYluXphOMwed0Zz/sr+42JKl8BJ9f2Ipzn20VhlbBr5FENR7r4dmmCxqE/NYwPdgLFdAnYOnucUoGxrrzF+D+Of2IfBEFCG7AYAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$2.718281828459045$$"
      ],
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.exp(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we are dealing with approximations when doing numerical calculations, we have to deal with a bit of rounding.  Here is $\\sin \\left( \\frac{\\pi}{6} \\right) = 0.5 $."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMAAAAAPBAMAAABATN1VAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAiXZmMs1UEN0i77urRJlR0qN3AAAACXBIWXMAAA7EAAAOxAGVKw4bAAABqUlEQVQ4EbWUP0tbURjGf/l3LzYJieBWMUXrbHB0Sr9AFYR2CVTp2uG2IJQMzeaU4YKD4JKAiIMO0k8QqIsO6kdIuzfUfylpKe173tN4T+90lt7hl4TnPM9zz3tzLmQWZrDXc/gwffYX4efZmAReirodD0gkL3gf24IO4T57kYJWferQgY+SNkpqB3I9MmtakD2m1KM0UHAOFw58lLQRJJJin+C7Fuw0qayR+abgHmoOfJS0ESSSSp/ySAuqTdonZMeK8Ccs7T4g9lFSRhm8RNIeUL4xBbm4ySPZwS8FB7KDqwQ+StqokXSr5LXgHU2ZD4VbhcyHV/UEPkraiImkOyB/bXZQNb8+sjmyKD4JahsJvBR1Ox6NnIwoaJiCYPnZnQWvn9YaDnwUXZN4bKQ85MA85LeYAiiZv5SCy0i+JvBR/jHayOIJOZP5Zjj88UU+C/0JbKG2KnwUXTMx2sjkoHFM7pDVWMFKlB878FHSRrlTOWhs02qEcqzgiOzLcN2CxWir7sBH0TWORyNl+POn+s7g8e9PTA+vsMjMfYUEXoq6HY9Gmlv/n9cfqYxJsm5mlbQAAAAASUVORK5CYII=",
      "text/latex": [
       "$$0.49999999999999994$$"
      ],
      "text/plain": [
       "0.49999999999999994"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sin(math.pi/6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `log()` function in the `math` package calculates the natural logarith.  The naural logarithm of Euler's number is $1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABkAAAAPBAMAAADjSHnWAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAVO8Qq4lmdpnN3TIiu0Sg0+p/AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAeUlEQVQIHWNggIHw1A1AJqMymM8pwLyGgcEk5DOYl8TAEAlksEF4VxgY5A3gvC8MDO8FYDzmH0BeAYzH85WBYT+CB5TbHwCTQ1XJADRFHm4Kw10GhnwDmEoGqO3sQNvtJzBwCTBrMzBwOP1sY+ByYGAOL9kAdiKCAAAD3iJZ6a1zTAAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$1.0$$"
      ],
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log(math.exp(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's change to symbolic computation and import some useful functions from `sympy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import Rational, sqrt, log, exp, sin, pi, I"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Rational()` function calculates an exact solution for fraction.  Here is $\\frac{5}{3}$ again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAsAAAAqBAMAAACXcryGAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAzWYQMplU74mrdiK7RN1/7zyFAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAApUlEQVQYGWNgEDJwTWBgYKj//wNIMkjM2gCiJoAIODVJKwTEO8yw/wKIZuB5AKZYfzMwcAowcPxlYGAXYGD9zMDAysDAJ8DAwB3AoA4yZmtnMFghecR/EPhAlN4dHceA6oDW5iswMHB9Y+B/wMDAW8vAD3QLEIAEGRiYX4BI7j6ok5ZfAHEZ2IuBYhsYeL4xMPB/BlPsBxj4gF5hUoDouxp6loEBADAYKDzhapJbAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$\\frac{5}{3}$$"
      ],
      "text/plain": [
       "5/3"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Because we imported the function directly, we don't have to use the dot notation\n",
    "Rational(5, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `evalf()` method still allows us to get a numerical approximation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKAAAAAPBAMAAACRq9klAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAVO8Qq4lmdpnN3TJEuyJIWJmAAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABdklEQVQ4Ea2UsUrDUBSGf0mbhmhJ3sBKX6Coi1NKQRBcMrRWcOkb1EV0LAUFQSSTiw46unVxcWnfwOLkIohPUCgIFTGenNv2HK8dzfBx+L/TPzchFJhd+eMDwAKaRz0oiFYh72TmcafRiIGlMlc6NziHBWwNvERBtAp5h007TdMqNutjLix28AoLeEFxqCBahbzD5hLIUZdrCp/eaLaw8k2ZQGkJeTKGHpfe2qzwmUZYKJYoEygtIU/G0M0P6QfTE04eTgawEFw3LyBQWkKejKGbU9+00Jm0cGcB0RX8UCB6oaGuPVWYAt2N36hEI3hlgTPXC00FzkgK8Qm0BxaCW7hfArUjIU/GoJCownsqbFnwE7gfAoiWkCdj4A9VYS07oYVciU4ogGgJeTIGQVUV9ivowsLyGF5JoLSEPBmDficrLNCHHSXIxc6aDWxjPVSQHRXyDhusxtTn1SZn8KvAfr33B/nTXfrDmEPtSMiTMe9hdsJ/vn4AQMYRv2+W++cAAAAASUVORK5CYII=",
      "text/latex": [
       "$$1.66666666666667$$"
      ],
      "text/plain": [
       "1.66666666666667"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(Rational(5, 3)).evalf()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can even specify the number of significant digits we require by passing it as an argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACQAAAAPBAMAAAB+RXBeAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAVO8Qq4lmdpnN3TJEuyJIWJmAAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAtElEQVQYGWNggAHW8miGXR6hoQEMDIzKYEHmOQydDPn///93YDAJ+QwW4m1guMvQx8DAAuSxQYTOPwCygZqiEUKXgEwg4CkAElBVP7dWHADyeIEYKsT8M4FhIZAXhiT0n4GhyYCB+QNCiOEXA0P+AQb2CUhCK4FCCQxcF5CEnMCq+B2QhPYbMDQxMOxvAAmxA51qP4GBJYBZkYFBPgAowuH0s42By4GBISJkAwPDIwGQKgwAAKVIMCwm4N/GAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$1.67$$"
      ],
      "text/plain": [
       "1.67"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(Rational(5, 3)).evalf(3)  # Significant digits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now for the square root of $8$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACUAAAAVBAMAAAAzyjqdAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEJm7MquJRO/dIs12VGbfGimAAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAA+0lEQVQYGWWQP08CQRBH31085P5ANiYUVJwYSxMTraiobKW1glDQoXaWWGposNBWLNUPgbE0JhI/gZW1ECOR5pxZjgRzU/x23stmZrOwUkGi9bViwDv9hxYes4qdrHMGWZcbp86p7tXTtgwbW/sCJXKz1B3jNDiR3ZtwsXAyzjXkz+ESmkMrow/yA7w5jAzNOmdifQgneN/2wq2J+tK8WvAneqz/cPcmkxev67XU+Q2o7FJ8UuDaZlXSneMbJTfWjDSDKZ8KPNt8JxjKe8yVUiHmAdZaROIOu7G6A3iB+077SCDs67jgprMt60dJ8itUmEoQyteLW1Zt2cAft3w2wfi3IegAAAAASUVORK5CYII=",
      "text/latex": [
       "$$2 \\sqrt{2}$$"
      ],
      "text/plain": [
       "2⋅√2"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's beautiful!  For even more beauty, here's $\\pi$ and then a numerical approximation with $40$ significant digits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAwAAAAJBAMAAAD0ltBnAAAALVBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAOrOgAAAADnRSTlMAdu+ZiTJUIma7qxDdRMHqV70AAAAJcEhZcwAADsQAAA7EAZUrDhsAAAA+SURBVAgdY2AQevfu3WMGFtfECvEChjAGd8YABiCYwLUBSLIu4AFxmBv4QLx9G/guACkZBiYHIDWNgcuBAQDxTw0d+kKa7QAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$\\pi$$"
      ],
      "text/plain": [
       "π"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$$3.141592653589793238462643383279502884197$$"
      ],
      "text/plain": [
       "3.141592653589793238462643383279502884197"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pi.evalf(40)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Euler's number is just as spectacular."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAkAAAAJBAMAAAASvxsjAAAALVBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAOrOgAAAADnRSTlMAEIl2mSJE3e9UMqtmzXCQkgMAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAA4SURBVAgdY2BgVDYJYGBID2BVYGDsZBBZwMDdY3yQgYFvAwMQ8CmASHYgacDAfIFBBKjS5MwBBgDXogiIdN7mwgAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$e$$"
      ],
      "text/plain": [
       "ℯ"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$$2.718281828459045235360287471352662497757$$"
      ],
      "text/plain": [
       "2.718281828459045235360287471352662497757"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp(1).evalf(40)  # Foury significant digits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The trigonometric and logarithmic expressions from above will also now give us an exact solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAsAAAAqBAMAAACXcryGAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAVO8Qq4lmdpnNuzJE3SJtjddMAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAdElEQVQYGWNggAEhAyCL2dUfRDEw5FNG1YO1t+jPSACbRhbxHwQ+EKXVoms1UB2zA0P8AQYGDgMGJgUGBqYLDCz/GBg4PzOw/AYbwvsZTJ0PAFNXwCRHA5iqAJOMDQzvgIytDAx1DAx8V0NbLgC1A91wgQEArVYi1VLQ2fQAAAAASUVORK5CYII=",
      "text/latex": [
       "$$\\frac{1}{2}$$"
      ],
      "text/plain": [
       "1/2"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sin(pi / 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAPBAMAAAArJJMAAAAAIVBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADdcGRXAAAACnRSTlMAVO8Qq4lmdpnNpXqjvAAAAAlwSFlzAAAOxAAADsQBlSsOGwAAACBJREFUCB1jYAADRmUGBpOQxUA2GykEO1Axh9PKNrAZAEESCWTnoGnkAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$1$$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log(exp(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Substitutions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While we create symbolic expressions, `sympy` does not exclude use from substituting actual numerical values into our mathematical variables.  The `.subs()` method does the job.  Below we create an expression and assign it to the computer variable `expr`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAC8AAAAQBAMAAAB0JTvnAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAqElEQVQYGWNgwAa4L2ATBYpxGKBI8CjAuHo4JFgqcUiwcYIkhJRd1SBmwI0qAUkwJrA3cUwAGw6TYFQASbAJsH1kdUCRYGMA62DgWgASZps5c8bLmTNBhp8GSzAw8CuAJIAAahRjAlRi/waIOEyCx/bu/bcKDDwC+gxMAsg6gGw+oInxB9YzuEO0wFwFlFjAwCCsJHS9AE2Cbf1nqBCaBISLIBkhVkEEAF5HG3EFAR5CAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$x + 4$$"
      ],
      "text/plain": [
       "x + 4"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr = x + 4  # x is a mathematical symbol\n",
    "expr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have to specify the mathematical variable we want substituted and then the value we want to substitute with."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAOBAMAAADkjZCYAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMt2rmYlmIkR2uxDNVO+L8+I6AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAR0lEQVQIHWMQMgkNDWDI////vwGDOwMDMwNDAANDIAMQcEwAkVwggiEMRHB/AJGcB0Ak0wIQyW8AIuUdQOR9oD4GhroLDAwAT0AMQV/gN1YAAAAASUVORK5CYII=",
      "text/latex": [
       "$$7$$"
      ],
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have more than one mathematical symbol, we can substitute all of them using the syntax below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAOBAMAAADkjZCYAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMt2rmYlmIkR2uxDNVO+L8+I6AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAR0lEQVQIHWMQMgkNDWDI////vwGDOwMDMwNDAANDIAMQcEwAkVwggiEMRHB/AJGcB0Ak0wIQyW8AIuUdQOR9oD4GhroLDAwAT0AMQV/gN1YAAAAASUVORK5CYII=",
      "text/latex": [
       "$$7$$"
      ],
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr = x + y  # Overwriting the expr computer variable\n",
    "expr.subs([(x, 2), (y, 5)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The square bracket, `[]` notation creates a list object.  An alternative syntax uses dictionary objects with curly braces, `{}`.  We will learn more about these at a later stage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABkAAAAOBAMAAAAoFKpzAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMt2rmYlmIkR2uxDNVO+L8+I6AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAmUlEQVQIHWMQMgkNDWAAgshUAQaG/P///xsAOTwXuNUZGNwZGJhBUnkMDDEMDEBVgSDeYgaG+xuANMcEEO8zA0P/BSDNBeJwfwHyQMJhIB77VwYGeSCP+wOYB5STD2Bg4DwA4sFUMi0A8UCm3L/AwMBvAOatAjpkA1C1A5gHsZ3hPlDv/gMMTBe4HwKF64CqmQwYuCMnCzAAALeiJGcBJiYbAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$7.0$$"
      ],
      "text/plain": [
       "7.00000000000000"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.evalf(subs = {x:2, y:5})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Equality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Substitution provides a great segway into Boolean logic.  The double equal symbol, `==` evaluates both sides of an equation to see of they are indeed equal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x, 3) == 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indeed $7 = 7$, the LHS equals the RHS."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `sympy` adheres to the principle of exact structural equality.  Let's look at the expression $\\left( x+1  \\right)^2$ and its expansion $x^2 + 2x +1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEYAAAAbBAMAAAAzEOSeAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAImYQu82Z3XZU70SJqzJu81j5AAAACXBIWXMAAA7EAAAOxAGVKw4bAAABTElEQVQoFWNgIACOuRkQUMHAI8AbQEgNuwDfR4JqNjD+JqSGgYHzM2E17A2E1RwDKmFUABJYwUSQKFMCkDABsbACXgGg8B6GfQwMgVjlORczMDADQ4YvcqYzxCyEshkQpu1ZkG9OMDBw/f//gYEdZCACQNUwMIHUWEHFxRHyIBaKGtYNEMk2IGXRK93TAOGiqOFJgAg6Ad12gKmCHeg+EEBRwwQVrGRg4DHg+cwNdRaKGs4CiMbVQHMYWBzAnKOhoVWhobEgNtjNfB/AwgxANQwM/A0QDppdMDVAuxgY3j/AqoYbahfQzZwG/QwcBhBVKO6BuRkYrfsn+DMIQQ2CqeEAhSHbASABBNsZGGw7LJIUwBy4e9hufU1iYGB9ABHFERdgSXOoRnD6gLKBlDGCCY5TCNcRWRSFDUobEIA7jbEIwNQwKsBY6LQiVAAAJiVCQuLeCkwAAAAASUVORK5CYII=",
      "text/latex": [
       "$$\\left(x + 1\\right)^{2}$$"
      ],
      "text/plain": [
       "       2\n",
       "(x + 1) "
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x + 1)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGgAAAAWBAMAAADeGsQjAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABYUlEQVQ4EWNggIDctQJQFvEUmwPzBOJVQ1VyOHB/IV1TAMtXkjUxMPB8JEMThwIZmnLR9DDeXbUBTQiDy34BTUiYgQ27L3kewlWGMURD2DwKEPoiA8M7uCyQARMXToZ7nnvOmYUQJTDJFwwM9g5IumDiDOxwTXz//39A1TRfgMEe2VOomoSUXdUUEEbCJRkY+gUYlUyCklANA9vEmMDexDEBmybWbwxiDBUKnVg0sQmwfWR1wKaJw4AhkSFfIASLJkYGrgVwLWwzZ854OXOmAVjgLgODAMMqMBNZHBIQ/ApwTUAG3E9MF0DCn2BycHGIpv3IgYTQdJaBxYGB+zdWTTwC+gxMAjAphE3cCQxMDgeZPjAoQuRQbIo/sJ7BHaEHbpNHWq4F6x+uDywFaJqYgJErrCR0HSoOloWZOP///x+MRoq65VADYeK8dj+vI9mBZiKaDEwTmjCEy4jkP2QFyOIAm+pOydly2f4AAAAASUVORK5CYII=",
      "text/latex": [
       "$$x^{2} + 2 x + 1$$"
      ],
      "text/plain": [
       " 2          \n",
       "x  + 2⋅x + 1"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((x + 1)**2).expand()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We know that these two expression are equal to each other.  Let's test this assumption."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x + 1)**2 == x**2 + 2 * x + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see a `False`.  This is what we mean by adherence to the principle of exact structural equality. If we expand the LHS or factor the RHS, we will get equality."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((x + 1)**2).expand() == x**2 + 2 * x + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((x + 1)**2) == (x**2 + 2 * x + 1).factor()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Roundtripping to numerical packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While `sympy` is great at symbolic computations, we often need numerical evaluations.  We did this using `.subs()` and `.evalf()` methods.  They do single substitutions, but what if want computations on many values.  To do this, we rondtrip to some of the Python packages that are designed for numerical computations such as `numpy` (numerical Python) and `scipy` (scientific Python)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fortunately, `sympy` provides the `lambdify()` function.  Imagine then that we want to calculate the $\\sin \\left( x \\right)$ for the integere values in the closed domain $\\left[ -3, 3 \\right]$.  The `arange()` function in the `numpy` package will let us create this list of values.  We will ause three argument.  The first is the start value, the second is the end value (`numpy` excludes this from the final list, so we will use `4`), and the step size, which is $1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import arange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3, -2, -1,  0,  1,  2,  3])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_domain = arange(-3, 4, 1)  # Creating the list of integers in our chosen domain\n",
    "my_domain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `arange()` function creates a `numpy` object called an `array`.  We note the seven integers in our array object, `my_domain`.  Now we overwrite the `expr` computer variable to hold the sine function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAADcAAAAUBAMAAADbzbjtAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMnZUZs0Qu91E7yKJmaurDqYVAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABKUlEQVQoFWNgQAdboALWUJp7CUIFWwGUzbcBwmD8g5BkhYoxsAUgBGEsXxiD4RCcBWd0w1lZEBa3IFyEuwHOZJ3AwKjsFLD9H4PoWiE9BaA40wUGBjal15OAZvJcYEhnYGhgiGNgaFfg/g2UZHdgYMhh8FBoZWBgCWCYlcCgwFDHwFDFwPAFKMlhwMBwjOF8wmwGBuYGBo7v2gwgyVIGhk9ASa4JDAwJDOVAFgPjBwa2o/8vgCSBfJgkhAWS3MbA8hNJEmQsA+NHkE7OBoZJDAxPkCRBDjJj+sCgBnNQNchMqLFA93N+Zv/ADVTDe4BhjpPPBLn/z+T+PzT/9QBsFtsjNV0XoLGsAkACFSCCLwNVAsTDG/DsG6AasEUZPLLhqpBNhyUTbwYGACt9SFbRUwsSAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$\\sin{\\left (x \\right )}$$"
      ],
      "text/plain": [
       "sin(x)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr = sin(x)\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import lambdify  # Importing the required function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `lambdify()` function as used below takes three arguments.  First is the mathematical variable of interest.  Then follows teh actual expression, and finally the package we want to use for the calculation.  We assign this to the computer variable `f`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambdify(x, expr, 'numpy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is now a simple matter of providing the seven numbered array to the computer variable.  All seven values in the array will be passed to the expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.14112001, -0.90929743, -0.84147098,  0.        ,  0.84147098,\n",
       "        0.90929743,  0.14112001])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(my_domain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}