CSS 420 Lecture 1 Intro to jupyter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Introduction to Sympy and the IPython Notebook for engineering calculations\n",
    "===========================================================================\n",
    "\n",
    "Sympy is a computer algebra module for Python. You are looking at the convenient IPython Notebook interface. This notebook aims to show some of the useful features of the Sympy system as well as the notebook interface.\n",
    "\n",
    "This notebook will use Python as the programming language. This means that most of what you learned in MPR can be applied in Sage. The notebook interface provides \"cells\" where one can input code. To run the code, click on a cell and press Shift+Enter. For a quick list of shortcuts press h.\n",
    "\n",
    "A quick tour\n",
    "------------\n",
    "\n",
    "Take a second to go through the tour of the notebook interface by clicking on \"Help, User Interface Tour\". Also note that there is help available for a number of other things under that menu, specifically a list of keyboard shortcuts, notice the two different \"modes\" for a cell - grey box around the cell = command mode, green = edit mode. To add a line above a cell press a in command mode and to delete one press dd.\n",
    "\n",
    "Now that you are familiar with the nomenclature, let's run some code!\n",
    "\n",
    "*Evaluate the cell below to print out a message by clicking inside the cell and then pressing Shift + Enter*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for word in ['Hello', 'World']:\n",
    "    print word"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Math in text boxes\n",
    "------------------\n",
    "\n",
    "The text editor supports math in [$\\LaTeX$]() notation. You can double-click on a text box to see the codes used to enter it:\n",
    "\n",
    "$$f(a)=\\int_\\infty^0 \\frac{1}{a+2} \\mathrm{d}a$$\n",
    "\n",
    "Double-click on the formula above to see the code that produced it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SymPy\n",
    "-----\n",
    "\n",
    "We need to import [the SymPy module](http://docs.sympy.org/latest/index.html) to get symbolic math capabilities. Note that you should not use `import *` in your programs, but it makes typing a little easier in the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from sympy import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to start the pretty-printer to get nicely typeset math\n",
    "\n",
    "_Note that this changes somewhat based on the version of sympy_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "init_printing()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to do symbolic calculations, we need to create a variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = var('x')\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sympy allows us to do many mathematical operations that would be tedious by hand. For instance, we can expand a polynomial:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "polynomial = (2*x + 3)**4\n",
    "polynomial.expand()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice what happened - we defined a new name called \"polynomial\" and then used the .expand() method to expand the polynomial. We can see all the methods associated with an object by typing its name and a dot then pressing \"tab\".\n",
    "\n",
    "Call up the list of methods for the polynomial variable by pressing tab at the end of the line in the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "polynomial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get help about any method, we can type its name and append a ? at the end, then evaluate the cell\n",
    "\n",
    "Obtain help about the .expand() method by evaluating the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "polynomial.expand?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, we can also factor polynomials:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(x**2 + 2*x + 1).factor()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculus\n",
    "--------\n",
    "\n",
    "Sympy knows how to integrate and differentiate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "polynomial.diff(x) # First derivative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "polynomial.diff(x, 2) # Second derivative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "polynomial.integrate(x) # indefinite integral - note no constant of integration is added"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "polynomial.integrate((x, 1, 2)) # Note that integrate takes one argument which is a tuple for the definite integral"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To enumerate this, use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "N(polynomial.integrate((x, 1, 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Limits\n",
    "------\n",
    "\n",
    "We can evaluate limits using Sage, even for \"interesting\" limits where we would need L'Hopital's rule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "limit((2*sin(x) - sin(2*x))/(x - sin(x)), x, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Approximation\n",
    "-------------\n",
    "\n",
    "SymPy has built-in support for taylor series expansion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nonlinear_expression = sin(x)\n",
    "series(nonlinear_expression, x, 2, 2) # taylor expansion in terms of the x variable, around x=2, first order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To remove the order term use .removeO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "temp=series(nonlinear_expression, x, 2, 2)\n",
    "temp.removeO()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is not quite right, to get the full expression we must add the first two terms:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "tfix = series(sin(x), x, x0=2, n=None)\n",
    "sum([next(tfix) for _ in range(2)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To plot within the notebook we need to use the following command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SymPy has built-in plotting but it is rather limited"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plot(polynomial)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We prefer to use matplotlib directly so we need to import it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "func = sin(x)\n",
    "evalfunc = lambdify(x, func, modules=['numpy'])\n",
    "\n",
    "t = np.linspace(-5.0, 5.0, 100)\n",
    "plt.plot(t, evalfunc(t), 'b', label='sin(x)')\n",
    "plt.legend(loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can easily combine this with the first order Taylor approximation around the value 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "taylorfix = series(sin(x), x, x0=1, n=None)\n",
    "taylor=sum([next(taylorfix) for _ in range(2)])\n",
    "evaltaylor = lambdify(x, taylor, modules=['numpy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotted together on the same plot with a marker at the expansion point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "t = np.linspace(-2.0, 2.0, 100)\n",
    "plt.plot(t, evalfunc(t), 'b', label='sin(x)')\n",
    "plt.plot(t, evaltaylor(t), 'r', label='Taylor')\n",
    "plt.scatter(1, sin(1), s=100, color='magenta')\n",
    "plt.legend(loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also plot functions of two variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from matplotlib import cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.gca(projection='3d')\n",
    "func2 = cos(x)\n",
    "evalfunc2 = lambdify(x, func2, modules=['numpy'])\n",
    "x1 = np.linspace(-2.0, 2.0, 20)\n",
    "y1 = np.linspace(-2.0, 2.0, 20)\n",
    "x1, y1 = np.meshgrid(x1, y1)\n",
    "z1 = evalfunc(x1) + evalfunc2(y1)\n",
    "surf = ax.plot_surface(x1, y1, z1, rstride=1, cstride=1, cmap=cm.jet,\n",
    "        linewidth=0, antialiased=False)\n",
    "fig.colorbar(surf, shrink=0.5, aspect=5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, to generate an interactive plot we need to turn off inline plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib qt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And then plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.gca(projection='3d')\n",
    "func2 = cos(x)\n",
    "evalfunc2 = lambdify(x, func2, modules=['numpy'])\n",
    "x1 = np.linspace(-2.0, 2.0, 20)\n",
    "y1 = np.linspace(-2.0, 2.0, 20)\n",
    "x1, y1 = np.meshgrid(x1, y1)\n",
    "z1 = evalfunc(x1) + evalfunc2(y1)\n",
    "surf = ax.plot_surface(x1, y1, z1, rstride=1, cstride=1, cmap=cm.jet,\n",
    "        linewidth=0, antialiased=False)\n",
    "fig.colorbar(surf, shrink=0.5, aspect=5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solving equations\n",
    "-----------------\n",
    "\n",
    "Sympy can help us solve manipulate equations using the `solve` function. Like many solving functions, it finds zeros of a function, so we have to rewrite equalities to be equal to zero, \n",
    "\n",
    "$$ 2x^2 + 2 = 4 \\therefore 2x^2 + 2 - 4 = 0$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "init_printing(use_latex='mathjax')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "polynomial = 2*x**2 + 2 - 4\n",
    "solutions = solve(polynomial)\n",
    "solutions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "solutions[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For simple expressions, we can use the roots function to calculate all roots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "polynomial = (x-1)**2\n",
    "roots(polynomial)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The return value contains the roots and their multiplicity\n",
    "\n",
    "We can also solve systems of equations by passing a list of equations to solve and asking for a list of variables to solve for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x, y = var('x y')\n",
    "solve([x + y - 2, \n",
    "       x - y - 0], [x, y])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This even works with symbolic variables in the equations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a, b, c = var('a, b, c')\n",
    "solve([a*x + b*y - 2,\n",
    "       a*x - b*y - c], [x, y])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "##Work session 1\n",
    "\n",
    "Use the information above to do the following tasks:\n",
    "\n",
    "##Task 1\n",
    "\n",
    "Plot the left hand side and the right hand side of the following equation as red and green curves, then plot a red dot at the point at which they intersect\n",
    "$$x^2 = x + 2$$\n",
    "\n",
    "##Task 2\n",
    "\n",
    "Use jupyter to solve a CIR mass balance problem: A feed stream containing 50 % A and 50 % B on a mass basis is enriched in a separator which yields a product stream containing 75 % A and another stream containing 20 % A. The product stream is removed and the other stream is mixed with the feed. What is the composition of the mixed stream entering the separator?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}