01_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "<table>\n",
    " <tr align=left><td><img align=left src=\"https://i.creativecommons.org/l/by/4.0/88x31.png\">\n",
    " <td>Text provided under a Creative Commons Attribution license, CC-BY. All code is made available under the FSF-approved MIT license. (c) Kyle T. Mandli</td>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Review: Python\n",
    "\n",
    "APMA 4300 Resources:\n",
    " - [Intro to Python](https://github.com/mandli/intro-numerical-methods/blob/master/01_intro_to_python.ipynb)\n",
    " - [Intro to NumPy](https://github.com/mandli/intro-numerical-methods/blob/master/02_NumPy.ipynb)\n",
    " - [Intro to Matplotlib](https://github.com/mandli/intro-numerical-methods/blob/master/03_matplotlib.ipynb)\n",
    "\n",
    "Other resources:\n",
    " - [Basic Python](https://docs.python.org/2/tutorial/introduction.html)\n",
    " - [Software Carpentry - Programming in Python](http://swcarpentry.github.io/python-novice-inflammation/)\n",
    " - [NumPy Intro](http://mentat.za.net/numpy/intro/intro.html)\n",
    " - [Jessica Hamrick's nbgrader Intro](http://github.com/jhamrick/nbgrader-demo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Installation\n",
    "\n",
    "There are two options this semester for getting the necessary software:\n",
    "1. Install on your own machine\n",
    "1. Use a cloud computing platform"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Your Own Machine\n",
    "\n",
    "The easiest way to install all the components you will need for the class is to use the [Anaconda](http://anaconda.com/download) distribution.  We will be using python 3.x for all in class demos and homework so I strongly suggest you use the Python 3.6 version.\n",
    "\n",
    "Alternatives to using Anaconda also exist in the form of Enthought's [Canopy](http://store.enthought.com/downloads/) distribution which provides all the tools you will need as well along with an IDE (development environment)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Cloud Computing\n",
    "\n",
    "Instead of running things locally on your machine there are a number of cloud services that you are welcome to use in order to get everything running easily.\n",
    " 1. CoCalc - Create an account on [cocalc.com](https://www.cocalc.com) and interact with python via the provided terminal or Jupyter notebook inteface.\n",
    " \n",
    "There are a number of other options now available but note that some will not have the required packages or may be otherwise incompatible:\n",
    " 1. Azure Notebooks - Microsoft has free notebook hosting at http://notebooks.azure.com\n",
    " 1. Google - Google has notebook hosting at http://colab.research.google.com/\n",
    "\n",
    "Homework will be turned in on Vocareum which also has a cloud solution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Basic Python\n",
    "\n",
    "Python is a dynamic, interpreted language used throughout computational engineering and science.  Due to its ease of use, cost, and available tools we will be learning the material in this course using Python tools exclusively.  For those who are coming in without prior Python knowledge but a strong programming background this lecture should acquaint you with the basics.  For people who do not know Python and do not have a strong programming background it is strongly recommended that you take the time to look through the other tutorials mentioned above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Math\n",
    "\n",
    "Basic math in Python is fairly straight forward with all the usual types of operations (`+`, `-`, `*`, `/`, `**`) which are addition, subtraction, multiplication, division and power."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Note that in Python 2 this would give you `floor(1 / 2) = 1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 + 4**(3/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python also understands imaginary numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4+3j)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 + 3j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Some of the more advanced mathematical functions are stored in modules.  In order to use these functions we must first `import` them into our notebook and then use them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "math?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(2.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "math.sin(math.pi / 2.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2246467991473532e-16"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import *\n",
    "sin(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Variables\n",
    "\n",
    "Variables are defined and assigned to like many other languages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "num_students = 80\n",
    "room_capacity = 85\n",
    "(room_capacity - num_students) / room_capacity * 100.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Control Flow\n",
    "\n",
    "`if` statements are the most basic unit of logic and allows us to conditionally operate on things."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "x = 4\n",
    "if x > 5:\n",
    "    print(\"x is greater than 5\")\n",
    "elif x < 5:\n",
    "    print(\"x is less than 5\")\n",
    "else:\n",
    "    print(\"x is equal to 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`for` allows us to repeat tasks over a range of values or objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "for animal in ['cat', 'dog', 'chinchilla']:\n",
    "    print(animal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "for n in range(2, 10):\n",
    "    is_prime = True\n",
    "    for x in range(2, n):\n",
    "        if n % x == 0:\n",
    "            print(n, 'equals', x, '*', n / x)\n",
    "            is_prime = False\n",
    "            break\n",
    "    if is_prime:\n",
    "        print(\"%s is a prime number\" % (n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Functions\n",
    "\n",
    "Functions are a fundamental way in any language to break up the code into pieces that can be isolated and repeatedly used based on their input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def my_print_function(x):\n",
    "    print(x)\n",
    "\n",
    "my_print_function(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def my_add_function(a, b):\n",
    "    return a + b, b\n",
    "\n",
    "my_add_function(3.0, 5.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def my_crazy_function(a, b, c=1.0):\n",
    "    d = a + b**c\n",
    "    return d\n",
    "\n",
    "my_crazy_function(2.0, 3.0), my_crazy_function(2.0, 3.0, 2.0), my_crazy_function(2.0, 3.0, c=2.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def my_other_function(a, b, c=1.0):\n",
    "    return a + b, a + b**c, a + b**(3.0 / 7.0)\n",
    "\n",
    "my_other_function(2.0, 3.0, c=2.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    \"\"\"Return a list of the Fibonacci sequence up to n\"\"\"\n",
    "    values = [0, 1]\n",
    "    while values[-1] <= n:\n",
    "        values.append(values[-1] + values[-2])\n",
    "        print(values)\n",
    "    return values\n",
    "\n",
    "fibonacci(100)\n",
    "fibonacci?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## NumPy\n",
    "\n",
    "The most important part of NumPy is the specification of an array object called an `ndarray`.  This object as its name suggests stores array like information in multiple dimensions.  These objects allow a programmer to access the data in a multitude of different ways as well as create common types of arrays and operate on these arrays easily."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Constructors\n",
    "\n",
    "Ways to make arrays in NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "my_array = numpy.array([[1, 2], [3, 4]])\n",
    "print(my_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "numpy.linspace(-1, 1, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "numpy.zeros([3, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "numpy.ones([2, 3, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "numpy.empty([2,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Access\n",
    "\n",
    "How do we access data in an array?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_array[0, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "my_array[:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "my_vec = numpy.array([[1], [2]])\n",
    "print(my_vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "numpy.dot(my_array, my_vec)\n",
    "numpy.cross?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "my_array * my_vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Manipulations\n",
    "\n",
    "How do we manipulate arrays beyond indexing into them?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "A = numpy.array([[1, 2, 3], [4, 5, 6]])\n",
    "print(\"A Shape = \", A.shape)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "B = A.reshape((6,1))\n",
    "print(\"A Shape = \", A.shape)\n",
    "print(\"B Shape = \", B.shape)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "numpy.tile(A, (2,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "A.transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "A = numpy.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "print(A)\n",
    "print(A.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "B = numpy.arange(1,10)\n",
    "print(B)\n",
    "print(B.reshape((3,3)))\n",
    "C = B.reshape((3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "print(A * C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "numpy.dot(A, C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Mathematical Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "x = numpy.linspace(-2.0 * numpy.pi, 2.0 * numpy.pi, 62)\n",
    "y = numpy.sin(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "x = numpy.linspace(-1, 1, 20)\n",
    "numpy.sqrt(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "x = numpy.linspace(-1, 1, 20, dtype=complex)\n",
    "numpy.sqrt(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Linear Algebra\n",
    "\n",
    "Some functions for linear algebra available in NumPy.  Full implementation in `scipy.linalg`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "numpy.linalg.norm(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "M = numpy.array([[0,2],[8,0]])\n",
    "b = numpy.array([1,2])\n",
    "print(M)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "x = numpy.linalg.solve(M,b)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "lamda, V = numpy.linalg.eig(M)\n",
    "print(lamda)\n",
    "print(V)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## SciPy\n",
    "\n",
    "NumPy contains the basic building blocks for numerical computing where as the SciPy packages contain all the higher-level functionality.  Refer to the [SciPy webpage](http://www.scipy.org) for more information on what it contains.  There are also a number of [SciKits](http://scikits.appspot.com/scikits) which provide additional functionality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Matplotlib\n",
    "\n",
    "The most common facility for plotting with the Python numerical suite is to use the `matplotlib` package.  We will cover a few of the basic approaches to plotting figures.  If you are interested in learning more about `matplotlib` or are looking to see how you might create a particular plot check out the matplotlib [gallery](http://matplotlib.org/gallery) for inspiration.\n",
    "\n",
    "Refer to the [APAM 4300 Notes](https://github.com/mandli/intro-numerical-methods/blob/master/03_matplotlib.ipynb) on matplotlib for detailed examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Jupyter Notebooks\n",
    "\n",
    "All class notes and assignments will be done within Jupyter notebooks (formally IPython notebooks).  It is important that you become acquainted with these as there are a couple of pitfalls that you should be aware of.\n",
    " - Before turning in an assignment make sure to go to the \"Kernel\" menu and restart the notebook.  After this select \"Run All\" from the \"Cell\" menu to rerun everything.  This will ensure that you have properly defined everything in your notebook and have not accidentally erased a variable definition.\n",
    " - Use version 4.0 of the notebook so as not to run into problems with deleting notebook cells."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Debugging\n",
    "\n",
    "(based on Jessica Hamrick's [debugging demo](https://github.com/jhamrick/nbgrader-demo))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Debugging is one of the most critical tools we have at our disposal.  Apart from standard inspection approaches (`print` statements) the Jupyter notebook has a number of ways to debug as well.\n",
    "\n",
    "Jupyter notebooks provide an interface to the python debugger `pdb`.  The easiest way to use this functionality is by using the \"magic\" `%pdb` at the top of your notebook which will allow cause the notebook to jump into the python debugger anytime an exception is reached.  This will allow you to step through your code and figure out what is wrong.  If you want to step through code or just activate the trace back for the current cell use the `%debug` magic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# for inline plotting in the notebook\n",
    "%matplotlib inline \n",
    "\n",
    "# debugger\n",
    "%pdb\n",
    "\n",
    "import numpy\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def plot_log():\n",
    "    figure, axis = plt.subplots(2, 1)\n",
    "    x = numpy.linspace(1, 2, 10)\n",
    "    axis.plot(x, np.log(x)) # correct is plt.plot()\n",
    "    plt.show()\n",
    "\n",
    "plot_log()  # Call the function, generate plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Paths to debugging\n",
    "1. Check the traceback\n",
    "1. Use the `%debug` magic\n",
    "1. `print` statements\n",
    "\n",
    "and if all else fails\n",
    "1. Copy and paste your error message into Google to see if anyone else has experienced similar problems. You'd be surprised how often this works!\n",
    "2. Search [StackOverflow](https://stackoverflow.com/questions/tagged/python)\n",
    "3. Consult fellow classmates\n",
    "4. Consult the GSIs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Code Styling\n",
    "\n",
    "Very important in practice to write readable and understandable code.  Here are a few things to keep in mind while programming in and out of this class, we will work on this actively as the semester progresses as well.  The standard for which Python program are written to is called [PEP 8](http://www.python.org/dev/peps/pep-0008) and contains the following basic guidelines:\n",
    " - Use 4-space indentation, no tabs\n",
    " - Wrap lines that exceed 80 characters\n",
    " - Use judicious use of blank lines to separate out functions, classes, and larger blocks of contained code\n",
    " - Comment!  Also, put comments on their own line when possible\n",
    " - Use `docstrings` (function descriptions)\n",
    " - Use spaces around operators and after commas, `a = f(1, 2) + g(3, 4)`\n",
    " - Name your classes and functions consistently.\n",
    "   - Use `CamelCase` for classes\n",
    "   - Use `lower_case_with_underscores` for functions and variables\n",
    " - When in doubt be verbose with your comments and names of variables, functions, and classes\n",
    " \n",
    "Good coding style will mean that we can more easily grade your assignments and understand what you are doing.  Please make sure to keep this in mind especially when naming variables, making comments, or documenting your functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Last Notes\n",
    "\n",
    " - Live coding demos $\\Rightarrow$ Bring your laptops to class.\n",
    " - All notebooks are found on [github](https://github.com/Hadrien-Montanelli/numerical-methods-pdes).\n",
    " - Highly recommend obtaining a github account if you do not already have one.  Will allow you start to become comfortable with `git`.\n",
    " - Also note that you can watch what changes were made and submit **issues** to the github project page if you find mistakes (PLEASE DO THIS!)."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.6.1"
  },
  "latex_envs": {
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 0
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}