Introduction_to_Scientific_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"title\"></a>\n",
    "# A Quick Introduction to Scientific Python\n",
    "\n",
    "\n",
    "[Joseph C. Slater](joseph.slater@wright.edu)\n",
    "\n",
    "Dedicated to [John D. Hunter](https://en.wikipedia.org/wiki/John_D._Hunter) and [Hans Petter Langtangen](https://en.wikipedia.org/wiki/Hans_Petter_Langtangen)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. [A Quick Introduction to Scientific Python](#title)\n",
    "2. [Overview](#overview)<br>\n",
    "    2.1 [The Zen of Python](#zen)    \n",
    "    2.2 [Integrated Development Environments](#ides)\n",
    "3. [Namespaces](#namespaces)    \n",
    "4. [Basic math and arrays](#math)\n",
    "5. [File IO](#fileio)\n",
    "6. [Variables/Methods/Help](#variables)\n",
    "7. [Numerical Methods and Plotting](#nummethods)<br>\n",
    "    7.1 [Other plotting](#other_plotting)\n",
    "8. [Optimization](#optimization)\n",
    "9. [Formatted output](#formatoutput)\n",
    "10. [More advanced plotting](#aplotting)\n",
    "11. [Manipulating Excel Spreadsheets](#excel)\n",
    "12. [Mixing with other languages](#cross-language)\n",
    "13. [Compiling Python](#compiling)\n",
    "14. [Parallel Python](#parallel)<br>\n",
    "     13.1 [Other Parallel processing](#other_parallel) \n",
    "15. [Your own package](#mycode)\n",
    "16. [Other resources](#other)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"overview\"></a>\n",
    "# Overview\n",
    "1. Python programs can be be written as object oriented or imperative. \n",
    "2. Python uses *duck typing* for variables. \n",
    "  - If it looks like a duck, and it acts like a duck, then it is a duck.\n",
    "  \n",
    "  - A float is a float and string is a string without the variable having to be predefined. \n",
    "  \n",
    "  - One *can* specify if appropriate and necessary. \n",
    "3. It is a more formal language than Matlab. For instance: `f(2)`, is that the second element of a vector `f` or are you sending 2 to a function named `f`?\n",
    "4. Codes can be, and for some are commonly, executed from a terminal, natively: In Unix/Linux/MacOS, starting a python code file with `#! /usr/bin/env python` or the appropriate path and changing the permissions allows the code to be executed as a terminal command itself. \n",
    "5. No end statements. This is weird to new users. Formatting, specifically indenting, defines the level within loops and conditional statements. This is frustrating if you are sloppy in formating but results in much more readable code. \n",
    "6. 0-indexing. We start counting at zero, just like for time, unlike matrices. This is common to the vast majority of modern computer languages- specifically not Matlab and not Fortran. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"zen\"></a>\n",
    "## [The Zen of Python, PEP 20](https://www.python.org/dev/peps/pep-0020/)\n",
    "* Beautiful is better than ugly.\n",
    "* Explicit is better than implicit.\n",
    "* Simple is better than complex.\n",
    "* Complex is better than complicated.\n",
    "* Flat is better than nested.\n",
    "* Sparse is better than dense.\n",
    "* Readability counts.\n",
    "* Special cases aren't special enough to break the rules.\n",
    "* Although practicality beats purity.\n",
    "* Errors should never pass silently.\n",
    "* Unless explicitly silenced.\n",
    "* In the face of ambiguity, refuse the temptation to guess.\n",
    "* There should be one– and preferably only one –obvious way to do it. (often not true)\n",
    "* Although that way may not be obvious at first unless you're Dutch.\n",
    "* Now is better than never.\n",
    "* Although never is often better than *right* now.\n",
    "* If the implementation is hard to explain, it's a bad idea.\n",
    "* If the implementation is easy to explain, it may be a good idea.\n",
    "* Namespaces are one honking great idea – let's do more of those!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"ides\"></a>\n",
    "\n",
    "## Python Editors and Integrated Development Environments\n",
    "\n",
    "Python has a substantial number of standards for how to write and document code.\n",
    "\n",
    "These seem very restrictive, but most are not enforced. They are recommendations (requirements for submitting to the code-base, though). \n",
    "\n",
    "These standards result in beautiful and readable code and actually make documenting your code fun. \n",
    "\n",
    "A good editor helps. All of this is available free, or in a free version:\n",
    "1. Spyder: A Matlab-style IDE- best for scientific usage of Python writing longer codes. Open source. \n",
    "2. Jupyter: A Mathematica-like notebook better for using, or dabbling in Python, or for making usable notes and reports demonstrating usage.  Open source. \n",
    "4. Atom: GitHub's editor. With add-ins it is a powerful IDE itself. I tend to use it simultaneously with Jupyter when developing code (Atom is multi-language. I like having a single editor I'm good with).  Open source. \n",
    "3. Visual Studio Code: Modern open-source IDE well-suited for multiple languages (supported by MicroSoft). Python support modules available.  Open source. \n",
    "3. PyCharm: An IDE that is likely the best for non-scientific usage of Python. Certainly worth using to clean up errors/formatting of code. Better editor than Spyder. *Not open source.*\n",
    "4. Sublime Text: An IDE written in Python (closed source) with strong support for Python. *Not open source.* \n",
    "5. Emacs: Very powerful editor. Love it or hate it. I don't use it as much as I once did, but may try it again. \n",
    "6. VI/VIM: Very powerful editor. Love it or hate it. I hate it. Some very smart people love it. The problem is with me and not the editor. In the end- if you manage hard-core programming, you must at least be willing to use it. It's on *all* supercomputing systems/unix systems."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What do I use?\n",
    "Most of my work is done in Jupyter Notebooks with more substantial functions/codes written in Atom, but called in Jupyter. Exception: Prerequisite checking code- PyCharm is nicer for non-math code. Spyder is fine- but since I like notes intermingled with my work, Jupyter works better. Thus an IDE without the variable management and plotting serves better as my editor. \n",
    "\n",
    "I've only recently played a bit with Visual Studio Code- it might be better than Atom. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"namespaces\"></a>\n",
    "# Namespaces"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has very few restricted words. 33 to be exact. My installation of Matlab has over 20,000. This means every name is subject to risk of overwriting another name, or yielding an unintended result. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Hit Shift-Enter** to run the cell below.\n",
    "\n",
    "You can edit the contents, then hit **Shift-Enter** again to see how they change. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import keyword\n",
    "print(len(keyword.kwlist))\n",
    "str(keyword.kwlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This keeps code clean- we don't have to worry about clashing with other names accidentally. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What we do in Python is `import` what we need as we go. These eventually become habit for regularly used modules. \n",
    "\n",
    "We import them, and \"put them in their own namespace\". "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['void',\n",
       " 'void0',\n",
       " 'vsplit',\n",
       " 'vstack',\n",
       " 'w',\n",
       " 'warnings',\n",
       " 'where',\n",
       " 'who',\n",
       " 'zeros',\n",
       " 'zeros_like']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np  # We've decided to give it a short name\n",
    "dir(np)[-10:] # Let's list all the commands that are now available. \n",
    "# I'm listing the last 10 for brevity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0.],\n",
       "       [0., 0.]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((2,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even numbers and strings stored in variables have their own namespace- because they are objects with methods. This will not be our focus in programming, but we will use these concepts. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__abs__', '__add__', '__bool__']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = -1.0\n",
    "dir(a)[0:3] # Let's list only 3 methods (function) in the namespace of `a`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.__abs__()  # Applying the __abs__ method on the number 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This feels awkward... \n",
    "but is just a different way of looking at things. We can also just use the `numpy.abs` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.abs(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"math\"></a>\n",
    "\n",
    "# Basic math and arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we need to import a few libraries that we will need. \n",
    "\n",
    "The first line is specific to using Python in the Jupyter environment. It defines how and where to put plots. \n",
    "\n",
    "The second two lines load the packages we will wish to use. They are comparable to Matlab toolboxes. In computational usage of Python, you almost **always** use these two, perhaps additional libraries as well. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a comment unlike Matlab where a % is a comment. \n",
    "# Special to Jupyter are `magics` which start with a %. More later. \n",
    "# %matplotlib inline- but this isn't necessary anymore. \n",
    "\"\"\"Comment the previous line and uncomment the following one to \n",
    "have a GUI for your plot. Note that you will restart the kernel \n",
    "for this to work.\"\"\" \n",
    "# %matplotlib notebook # new feature I haven't worked with yet. \n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could have used `from numpy import *`, but this dumps every function within Numpy into our namespace. If we want to use that name elsewhere, we no longer can. By importing like this we are managing the namespace so that all functions in Numpy can be accessed with `np.function_name`. `np` is a convention short hand that is commonly used, but we could have used `import numpy` (functions are called with `numpy.function_name`) or `import numpy as pickles` (functions in Numpy are access with `pickles.function_name`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's get a list of functions that Numpy provides by using the `dir` command. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ALLOW_THREADS',\n",
       " 'AxisError',\n",
       " 'BUFSIZE',\n",
       " 'CLIP',\n",
       " 'ComplexWarning',\n",
       " 'DataSource',\n",
       " 'ERR_CALL',\n",
       " 'ERR_DEFAULT',\n",
       " 'ERR_IGNORE',\n",
       " 'ERR_LOG',\n",
       " 'ERR_PRINT',\n",
       " 'ERR_RAISE',\n",
       " 'ERR_WARN',\n",
       " 'FLOATING_POINT_SUPPORT',\n",
       " 'FPE_DIVIDEBYZERO',\n",
       " 'FPE_INVALID',\n",
       " 'FPE_OVERFLOW',\n",
       " 'FPE_UNDERFLOW',\n",
       " 'False_',\n",
       " 'Inf',\n",
       " 'Infinity',\n",
       " 'MAXDIMS',\n",
       " 'MAY_SHARE_BOUNDS',\n",
       " 'MAY_SHARE_EXACT',\n",
       " 'MachAr',\n",
       " 'ModuleDeprecationWarning',\n",
       " 'NAN',\n",
       " 'NINF',\n",
       " 'NZERO',\n",
       " 'NaN',\n",
       " 'PINF',\n",
       " 'PZERO',\n",
       " 'RAISE',\n",
       " 'RankWarning',\n",
       " 'SHIFT_DIVIDEBYZERO',\n",
       " 'SHIFT_INVALID',\n",
       " 'SHIFT_OVERFLOW',\n",
       " 'SHIFT_UNDERFLOW',\n",
       " 'ScalarType',\n",
       " 'Tester',\n",
       " 'TooHardError',\n",
       " 'True_',\n",
       " 'UFUNC_BUFSIZE_DEFAULT',\n",
       " 'UFUNC_PYVALS_NAME',\n",
       " 'VisibleDeprecationWarning',\n",
       " 'WRAP',\n",
       " '_NoValue',\n",
       " '_UFUNC_API',\n",
       " '__NUMPY_SETUP__',\n",
       " '__all__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__config__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__getattr__',\n",
       " '__git_revision__',\n",
       " '__loader__',\n",
       " '__mkl_version__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__path__',\n",
       " '__spec__',\n",
       " '__version__',\n",
       " '_add_newdoc_ufunc',\n",
       " '_distributor_init',\n",
       " '_globals',\n",
       " '_mat',\n",
       " '_pytesttester',\n",
       " 'abs',\n",
       " 'absolute',\n",
       " 'add',\n",
       " 'add_docstring',\n",
       " 'add_newdoc',\n",
       " 'add_newdoc_ufunc',\n",
       " 'alen',\n",
       " 'all',\n",
       " 'allclose',\n",
       " 'alltrue',\n",
       " 'amax',\n",
       " 'amin',\n",
       " 'angle',\n",
       " 'any',\n",
       " 'append',\n",
       " 'apply_along_axis',\n",
       " 'apply_over_axes',\n",
       " 'arange',\n",
       " 'arccos',\n",
       " 'arccosh',\n",
       " 'arcsin',\n",
       " 'arcsinh',\n",
       " 'arctan',\n",
       " 'arctan2',\n",
       " 'arctanh',\n",
       " 'argmax',\n",
       " 'argmin',\n",
       " 'argpartition',\n",
       " 'argsort',\n",
       " 'argwhere',\n",
       " 'around',\n",
       " 'array',\n",
       " 'array2string',\n",
       " 'array_equal',\n",
       " 'array_equiv',\n",
       " 'array_repr',\n",
       " 'array_split',\n",
       " 'array_str',\n",
       " 'asanyarray',\n",
       " 'asarray',\n",
       " 'asarray_chkfinite',\n",
       " 'ascontiguousarray',\n",
       " 'asfarray',\n",
       " 'asfortranarray',\n",
       " 'asmatrix',\n",
       " 'asscalar',\n",
       " 'atleast_1d',\n",
       " 'atleast_2d',\n",
       " 'atleast_3d',\n",
       " 'average',\n",
       " 'bartlett',\n",
       " 'base_repr',\n",
       " 'binary_repr',\n",
       " 'bincount',\n",
       " 'bitwise_and',\n",
       " 'bitwise_not',\n",
       " 'bitwise_or',\n",
       " 'bitwise_xor',\n",
       " 'blackman',\n",
       " 'block',\n",
       " 'bmat',\n",
       " 'bool',\n",
       " 'bool8',\n",
       " 'bool_',\n",
       " 'broadcast',\n",
       " 'broadcast_arrays',\n",
       " 'broadcast_to',\n",
       " 'busday_count',\n",
       " 'busday_offset',\n",
       " 'busdaycalendar',\n",
       " 'byte',\n",
       " 'byte_bounds',\n",
       " 'bytes0',\n",
       " 'bytes_',\n",
       " 'c_',\n",
       " 'can_cast',\n",
       " 'cast',\n",
       " 'cbrt',\n",
       " 'cdouble',\n",
       " 'ceil',\n",
       " 'cfloat',\n",
       " 'char',\n",
       " 'character',\n",
       " 'chararray',\n",
       " 'choose',\n",
       " 'clip',\n",
       " 'clongdouble',\n",
       " 'clongfloat',\n",
       " 'column_stack',\n",
       " 'common_type',\n",
       " 'compare_chararrays',\n",
       " 'compat',\n",
       " 'complex',\n",
       " 'complex128',\n",
       " 'complex256',\n",
       " 'complex64',\n",
       " 'complex_',\n",
       " 'complexfloating',\n",
       " 'compress',\n",
       " 'concatenate',\n",
       " 'conj',\n",
       " 'conjugate',\n",
       " 'convolve',\n",
       " 'copy',\n",
       " 'copysign',\n",
       " 'copyto',\n",
       " 'core',\n",
       " 'corrcoef',\n",
       " 'correlate',\n",
       " 'cos',\n",
       " 'cosh',\n",
       " 'count_nonzero',\n",
       " 'cov',\n",
       " 'cross',\n",
       " 'csingle',\n",
       " 'ctypeslib',\n",
       " 'cumprod',\n",
       " 'cumproduct',\n",
       " 'cumsum',\n",
       " 'datetime64',\n",
       " 'datetime_as_string',\n",
       " 'datetime_data',\n",
       " 'deg2rad',\n",
       " 'degrees',\n",
       " 'delete',\n",
       " 'deprecate',\n",
       " 'deprecate_with_doc',\n",
       " 'diag',\n",
       " 'diag_indices',\n",
       " 'diag_indices_from',\n",
       " 'diagflat',\n",
       " 'diagonal',\n",
       " 'diff',\n",
       " 'digitize',\n",
       " 'disp',\n",
       " 'divide',\n",
       " 'divmod',\n",
       " 'dot',\n",
       " 'double',\n",
       " 'dsplit',\n",
       " 'dstack',\n",
       " 'dtype',\n",
       " 'e',\n",
       " 'ediff1d',\n",
       " 'einsum',\n",
       " 'einsum_path',\n",
       " 'emath',\n",
       " 'empty',\n",
       " 'empty_like',\n",
       " 'equal',\n",
       " 'error_message',\n",
       " 'errstate',\n",
       " 'euler_gamma',\n",
       " 'exp',\n",
       " 'exp2',\n",
       " 'expand_dims',\n",
       " 'expm1',\n",
       " 'extract',\n",
       " 'eye',\n",
       " 'fabs',\n",
       " 'fastCopyAndTranspose',\n",
       " 'fft',\n",
       " 'fill_diagonal',\n",
       " 'find_common_type',\n",
       " 'finfo',\n",
       " 'fix',\n",
       " 'flatiter',\n",
       " 'flatnonzero',\n",
       " 'flexible',\n",
       " 'flip',\n",
       " 'fliplr',\n",
       " 'flipud',\n",
       " 'float',\n",
       " 'float128',\n",
       " 'float16',\n",
       " 'float32',\n",
       " 'float64',\n",
       " 'float_',\n",
       " 'float_power',\n",
       " 'floating',\n",
       " 'floor',\n",
       " 'floor_divide',\n",
       " 'fmax',\n",
       " 'fmin',\n",
       " 'fmod',\n",
       " 'format_float_positional',\n",
       " 'format_float_scientific',\n",
       " 'format_parser',\n",
       " 'frexp',\n",
       " 'frombuffer',\n",
       " 'fromfile',\n",
       " 'fromfunction',\n",
       " 'fromiter',\n",
       " 'frompyfunc',\n",
       " 'fromregex',\n",
       " 'fromstring',\n",
       " 'full',\n",
       " 'full_like',\n",
       " 'fv',\n",
       " 'gcd',\n",
       " 'generic',\n",
       " 'genfromtxt',\n",
       " 'geomspace',\n",
       " 'get_array_wrap',\n",
       " 'get_include',\n",
       " 'get_printoptions',\n",
       " 'getbufsize',\n",
       " 'geterr',\n",
       " 'geterrcall',\n",
       " 'geterrobj',\n",
       " 'gradient',\n",
       " 'greater',\n",
       " 'greater_equal',\n",
       " 'half',\n",
       " 'hamming',\n",
       " 'hanning',\n",
       " 'heaviside',\n",
       " 'histogram',\n",
       " 'histogram2d',\n",
       " 'histogram_bin_edges',\n",
       " 'histogramdd',\n",
       " 'hsplit',\n",
       " 'hstack',\n",
       " 'hypot',\n",
       " 'i0',\n",
       " 'identity',\n",
       " 'iinfo',\n",
       " 'imag',\n",
       " 'in1d',\n",
       " 'index_exp',\n",
       " 'indices',\n",
       " 'inexact',\n",
       " 'inf',\n",
       " 'info',\n",
       " 'infty',\n",
       " 'inner',\n",
       " 'insert',\n",
       " 'int',\n",
       " 'int0',\n",
       " 'int16',\n",
       " 'int32',\n",
       " 'int64',\n",
       " 'int8',\n",
       " 'int_',\n",
       " 'intc',\n",
       " 'integer',\n",
       " 'interp',\n",
       " 'intersect1d',\n",
       " 'intp',\n",
       " 'invert',\n",
       " 'ipmt',\n",
       " 'irr',\n",
       " 'is_busday',\n",
       " 'isclose',\n",
       " 'iscomplex',\n",
       " 'iscomplexobj',\n",
       " 'isfinite',\n",
       " 'isfortran',\n",
       " 'isin',\n",
       " 'isinf',\n",
       " 'isnan',\n",
       " 'isnat',\n",
       " 'isneginf',\n",
       " 'isposinf',\n",
       " 'isreal',\n",
       " 'isrealobj',\n",
       " 'isscalar',\n",
       " 'issctype',\n",
       " 'issubclass_',\n",
       " 'issubdtype',\n",
       " 'issubsctype',\n",
       " 'iterable',\n",
       " 'ix_',\n",
       " 'kaiser',\n",
       " 'kron',\n",
       " 'lcm',\n",
       " 'ldexp',\n",
       " 'left_shift',\n",
       " 'less',\n",
       " 'less_equal',\n",
       " 'lexsort',\n",
       " 'lib',\n",
       " 'linalg',\n",
       " 'linspace',\n",
       " 'little_endian',\n",
       " 'load',\n",
       " 'loads',\n",
       " 'loadtxt',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'logaddexp',\n",
       " 'logaddexp2',\n",
       " 'logical_and',\n",
       " 'logical_not',\n",
       " 'logical_or',\n",
       " 'logical_xor',\n",
       " 'logspace',\n",
       " 'long',\n",
       " 'longcomplex',\n",
       " 'longdouble',\n",
       " 'longfloat',\n",
       " 'longlong',\n",
       " 'lookfor',\n",
       " 'ma',\n",
       " 'mafromtxt',\n",
       " 'mask_indices',\n",
       " 'mat',\n",
       " 'math',\n",
       " 'matmul',\n",
       " 'matrix',\n",
       " 'matrixlib',\n",
       " 'max',\n",
       " 'maximum',\n",
       " 'maximum_sctype',\n",
       " 'may_share_memory',\n",
       " 'mean',\n",
       " 'median',\n",
       " 'memmap',\n",
       " 'meshgrid',\n",
       " 'mgrid',\n",
       " 'min',\n",
       " 'min_scalar_type',\n",
       " 'minimum',\n",
       " 'mintypecode',\n",
       " 'mirr',\n",
       " 'mkl',\n",
       " 'mod',\n",
       " 'modf',\n",
       " 'moveaxis',\n",
       " 'msort',\n",
       " 'multiply',\n",
       " 'nan',\n",
       " 'nan_to_num',\n",
       " 'nanargmax',\n",
       " 'nanargmin',\n",
       " 'nancumprod',\n",
       " 'nancumsum',\n",
       " 'nanmax',\n",
       " 'nanmean',\n",
       " 'nanmedian',\n",
       " 'nanmin',\n",
       " 'nanpercentile',\n",
       " 'nanprod',\n",
       " 'nanquantile',\n",
       " 'nanstd',\n",
       " 'nansum',\n",
       " 'nanvar',\n",
       " 'nbytes',\n",
       " 'ndarray',\n",
       " 'ndenumerate',\n",
       " 'ndfromtxt',\n",
       " 'ndim',\n",
       " 'ndindex',\n",
       " 'nditer',\n",
       " 'negative',\n",
       " 'nested_iters',\n",
       " 'newaxis',\n",
       " 'nextafter',\n",
       " 'nonzero',\n",
       " 'not_equal',\n",
       " 'nper',\n",
       " 'npv',\n",
       " 'numarray',\n",
       " 'number',\n",
       " 'obj2sctype',\n",
       " 'object',\n",
       " 'object0',\n",
       " 'object_',\n",
       " 'ogrid',\n",
       " 'oldnumeric',\n",
       " 'ones',\n",
       " 'ones_like',\n",
       " 'os',\n",
       " 'outer',\n",
       " 'packbits',\n",
       " 'pad',\n",
       " 'partition',\n",
       " 'percentile',\n",
       " 'pi',\n",
       " 'piecewise',\n",
       " 'place',\n",
       " 'pmt',\n",
       " 'poly',\n",
       " 'poly1d',\n",
       " 'polyadd',\n",
       " 'polyder',\n",
       " 'polydiv',\n",
       " 'polyfit',\n",
       " 'polyint',\n",
       " 'polymul',\n",
       " 'polynomial',\n",
       " 'polysub',\n",
       " 'polyval',\n",
       " 'positive',\n",
       " 'power',\n",
       " 'ppmt',\n",
       " 'printoptions',\n",
       " 'prod',\n",
       " 'product',\n",
       " 'promote_types',\n",
       " 'ptp',\n",
       " 'put',\n",
       " 'put_along_axis',\n",
       " 'putmask',\n",
       " 'pv',\n",
       " 'quantile',\n",
       " 'r_',\n",
       " 'rad2deg',\n",
       " 'radians',\n",
       " 'random',\n",
       " 'rate',\n",
       " 'ravel',\n",
       " 'ravel_multi_index',\n",
       " 'real',\n",
       " 'real_if_close',\n",
       " 'rec',\n",
       " 'recarray',\n",
       " 'recfromcsv',\n",
       " 'recfromtxt',\n",
       " 'reciprocal',\n",
       " 'record',\n",
       " 'remainder',\n",
       " 'repeat',\n",
       " 'require',\n",
       " 'reshape',\n",
       " 'resize',\n",
       " 'result_type',\n",
       " 'right_shift',\n",
       " 'rint',\n",
       " 'roll',\n",
       " 'rollaxis',\n",
       " 'roots',\n",
       " 'rot90',\n",
       " 'round',\n",
       " 'round_',\n",
       " 'row_stack',\n",
       " 's_',\n",
       " 'safe_eval',\n",
       " 'save',\n",
       " 'savetxt',\n",
       " 'savez',\n",
       " 'savez_compressed',\n",
       " 'sctype2char',\n",
       " 'sctypeDict',\n",
       " 'sctypeNA',\n",
       " 'sctypes',\n",
       " 'searchsorted',\n",
       " 'select',\n",
       " 'set_numeric_ops',\n",
       " 'set_printoptions',\n",
       " 'set_string_function',\n",
       " 'setbufsize',\n",
       " 'setdiff1d',\n",
       " 'seterr',\n",
       " 'seterrcall',\n",
       " 'seterrobj',\n",
       " 'setxor1d',\n",
       " 'shape',\n",
       " 'shares_memory',\n",
       " 'short',\n",
       " 'show_config',\n",
       " 'sign',\n",
       " 'signbit',\n",
       " 'signedinteger',\n",
       " 'sin',\n",
       " 'sinc',\n",
       " 'single',\n",
       " 'singlecomplex',\n",
       " 'sinh',\n",
       " 'size',\n",
       " 'sometrue',\n",
       " 'sort',\n",
       " 'sort_complex',\n",
       " 'source',\n",
       " 'spacing',\n",
       " 'split',\n",
       " 'sqrt',\n",
       " 'square',\n",
       " 'squeeze',\n",
       " 'stack',\n",
       " 'std',\n",
       " 'str',\n",
       " 'str0',\n",
       " 'str_',\n",
       " 'string_',\n",
       " 'subtract',\n",
       " 'sum',\n",
       " 'swapaxes',\n",
       " 'sys',\n",
       " 'take',\n",
       " 'take_along_axis',\n",
       " 'tan',\n",
       " 'tanh',\n",
       " 'tensordot',\n",
       " 'test',\n",
       " 'testing',\n",
       " 'tile',\n",
       " 'timedelta64',\n",
       " 'trace',\n",
       " 'tracemalloc_domain',\n",
       " 'transpose',\n",
       " 'trapz',\n",
       " 'tri',\n",
       " 'tril',\n",
       " 'tril_indices',\n",
       " 'tril_indices_from',\n",
       " 'trim_zeros',\n",
       " 'triu',\n",
       " 'triu_indices',\n",
       " 'triu_indices_from',\n",
       " 'true_divide',\n",
       " 'trunc',\n",
       " 'typeDict',\n",
       " 'typeNA',\n",
       " 'typecodes',\n",
       " 'typename',\n",
       " 'ubyte',\n",
       " 'ufunc',\n",
       " 'uint',\n",
       " 'uint0',\n",
       " 'uint16',\n",
       " 'uint32',\n",
       " 'uint64',\n",
       " 'uint8',\n",
       " 'uintc',\n",
       " 'uintp',\n",
       " 'ulonglong',\n",
       " 'unicode',\n",
       " 'unicode_',\n",
       " 'union1d',\n",
       " 'unique',\n",
       " 'unpackbits',\n",
       " 'unravel_index',\n",
       " 'unsignedinteger',\n",
       " 'unwrap',\n",
       " 'use_hugepage',\n",
       " 'ushort',\n",
       " 'vander',\n",
       " 'var',\n",
       " 'vdot',\n",
       " 'vectorize',\n",
       " 'version',\n",
       " 'void',\n",
       " 'void0',\n",
       " 'vsplit',\n",
       " 'vstack',\n",
       " 'w',\n",
       " 'warnings',\n",
       " 'where',\n",
       " 'who',\n",
       " 'zeros',\n",
       " 'zeros_like']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(np) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that base Python has only 23 functions! Any others need to be imported to be used. This speeds up the load time of Python and keeps your name space clean. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.cos(np.pi)\n",
    "a # will be printed as a default in Jupyter without using a `print` command. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has the normal infix operators for addition, subtraction, etc. For exponentiation, is uses `**` unlike Matlab's or LaTeX's `^`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 9]]\n",
      "[[1]\n",
      " [2]\n",
      " [3]]\n"
     ]
    }
   ],
   "source": [
    "# To make an array, we use the Numpy array function\n",
    "a = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 9]])\n",
    "c = np.array([[1], [2], [3]])\n",
    "print(a)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Linear algebra tools reside in the `numpy.linalg` package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy.linalg as la"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.66666667],\n",
       "       [ 1.        ],\n",
       "       [-0.        ]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = la.solve(a, c)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's infix operators presume element by element operations, not linear algebra operations, so be careful. It's backwards from Matlab. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 9]]\n",
      "[[ 0  1  4]\n",
      " [ 9 16 25]\n",
      " [36 49 81]]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(a*a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The linear algebra operation is `@` for multiplication. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 15,  18,  23],\n",
       "       [ 42,  54,  71],\n",
       "       [ 75,  97, 128]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a@a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can append matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 9],\n",
       "       [0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 9]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((a, a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The construct (a, a) is a `tuple`, which is a non-mutable list. \n",
    "\n",
    "We can pull out slices. This is a very long topic, and Python has some great tricks to learn. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 9]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((a, a))[0:3,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 9]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((a, a))[(0,1,2),:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: \n",
    "1. We can index any object, including a result, using the square brackets. \n",
    "2. We can use `:` as a through statement\n",
    "3. The first index is inclusive, the last is exclusive. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 4, 5],\n",
       "       [6, 7, 9],\n",
       "       [0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 9]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((a, a))[1::,:] # through the end. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [6, 7, 9],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((a, a))[0:6:2,:] # by steps of 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy has numerous other stacking tools. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2, :] = np.array([[0,0,0]])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"fileio\"></a>\n",
    "# File IO\n",
    "Let's write this to a file. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('my_filename.txt','w')\n",
    "f.write(str(a))\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'[[0 1 2]\\n [3 4 5]\\n [0 0 0]]'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = open('my_filename.txt', 'r')\n",
    "aa = f.read()\n",
    "aa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a problem, it's now a string! `\\n` is the newline character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "print(aa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'[[0,1,2],[3,4,5],[0,0,0]]'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aa2 = aa.replace('\\n ',',').replace(' ',',')\n",
    "aa2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aa2 = np.array(eval(aa2))\n",
    "aa2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That was harder than it should have been. How about seeing if there is a function in Numpy to do this. Yes! It's `savez`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez('my_filename2', a=a, b=b) # The second variable name is the \n",
    "#                                    name it will be given in the file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n"
     ]
    }
   ],
   "source": [
    "a = b = 0\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [0 0 0]]\n",
      "[[-0.66666667]\n",
      " [ 1.        ]\n",
      " [-0.        ]]\n"
     ]
    }
   ],
   "source": [
    "mydata = np.load('my_filename2.npz')\n",
    "print(mydata['a'])\n",
    "print(mydata['b'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, let's use the Matlab format!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'__header__': b'MATLAB 5.0 MAT-file Platform: posix, Created on: Wed Dec 19 17:12:33 2018',\n",
       " '__version__': '1.0',\n",
       " '__globals__': [],\n",
       " 'a': array([[0, 1, 2],\n",
       "        [3, 4, 5],\n",
       "        [0, 0, 0]]),\n",
       " 'b': array([[-0.66666667],\n",
       "        [ 1.        ],\n",
       "        [-0.        ]])}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import scipy.io as sio\n",
    "sio.savemat('my_filename3', {'a':mydata['a'], 'b':mydata['b']}) # a and b are still 0!\n",
    "loaded_variables = sio.loadmat('my_filename3.mat')\n",
    "loaded_variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loaded_variables['a'] # loaded_variables is a dictionary. Here we \"look up\" 'a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = loaded_variables['a']\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"variables\"></a>\n",
    "# Variables/methods/help"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "globals()['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['T',\n",
       " '__abs__',\n",
       " '__add__',\n",
       " '__and__',\n",
       " '__array__',\n",
       " '__array_finalize__',\n",
       " '__array_function__',\n",
       " '__array_interface__',\n",
       " '__array_prepare__',\n",
       " '__array_priority__',\n",
       " '__array_struct__',\n",
       " '__array_ufunc__',\n",
       " '__array_wrap__',\n",
       " '__bool__',\n",
       " '__class__',\n",
       " '__complex__',\n",
       " '__contains__',\n",
       " '__copy__',\n",
       " '__deepcopy__',\n",
       " '__delattr__',\n",
       " '__delitem__',\n",
       " '__dir__',\n",
       " '__divmod__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__float__',\n",
       " '__floordiv__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__iadd__',\n",
       " '__iand__',\n",
       " '__ifloordiv__',\n",
       " '__ilshift__',\n",
       " '__imatmul__',\n",
       " '__imod__',\n",
       " '__imul__',\n",
       " '__index__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__int__',\n",
       " '__invert__',\n",
       " '__ior__',\n",
       " '__ipow__',\n",
       " '__irshift__',\n",
       " '__isub__',\n",
       " '__iter__',\n",
       " '__itruediv__',\n",
       " '__ixor__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lshift__',\n",
       " '__lt__',\n",
       " '__matmul__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__neg__',\n",
       " '__new__',\n",
       " '__or__',\n",
       " '__pos__',\n",
       " '__pow__',\n",
       " '__radd__',\n",
       " '__rand__',\n",
       " '__rdivmod__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rfloordiv__',\n",
       " '__rlshift__',\n",
       " '__rmatmul__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__ror__',\n",
       " '__rpow__',\n",
       " '__rrshift__',\n",
       " '__rshift__',\n",
       " '__rsub__',\n",
       " '__rtruediv__',\n",
       " '__rxor__',\n",
       " '__setattr__',\n",
       " '__setitem__',\n",
       " '__setstate__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__sub__',\n",
       " '__subclasshook__',\n",
       " '__truediv__',\n",
       " '__xor__',\n",
       " 'all',\n",
       " 'any',\n",
       " 'argmax',\n",
       " 'argmin',\n",
       " 'argpartition',\n",
       " 'argsort',\n",
       " 'astype',\n",
       " 'base',\n",
       " 'byteswap',\n",
       " 'choose',\n",
       " 'clip',\n",
       " 'compress',\n",
       " 'conj',\n",
       " 'conjugate',\n",
       " 'copy',\n",
       " 'ctypes',\n",
       " 'cumprod',\n",
       " 'cumsum',\n",
       " 'data',\n",
       " 'diagonal',\n",
       " 'dot',\n",
       " 'dtype',\n",
       " 'dump',\n",
       " 'dumps',\n",
       " 'fill',\n",
       " 'flags',\n",
       " 'flat',\n",
       " 'flatten',\n",
       " 'getfield',\n",
       " 'imag',\n",
       " 'item',\n",
       " 'itemset',\n",
       " 'itemsize',\n",
       " 'max',\n",
       " 'mean',\n",
       " 'min',\n",
       " 'nbytes',\n",
       " 'ndim',\n",
       " 'newbyteorder',\n",
       " 'nonzero',\n",
       " 'partition',\n",
       " 'prod',\n",
       " 'ptp',\n",
       " 'put',\n",
       " 'ravel',\n",
       " 'real',\n",
       " 'repeat',\n",
       " 'reshape',\n",
       " 'resize',\n",
       " 'round',\n",
       " 'searchsorted',\n",
       " 'setfield',\n",
       " 'setflags',\n",
       " 'shape',\n",
       " 'size',\n",
       " 'sort',\n",
       " 'squeeze',\n",
       " 'std',\n",
       " 'strides',\n",
       " 'sum',\n",
       " 'swapaxes',\n",
       " 'take',\n",
       " 'tobytes',\n",
       " 'tofile',\n",
       " 'tolist',\n",
       " 'tostring',\n",
       " 'trace',\n",
       " 'transpose',\n",
       " 'var',\n",
       " 'view']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# What does the variable 'a' know that we can do with 'a'?\n",
    "dir(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's make our own dictionary. \n",
    "# A dictionary is just a collection of data. The data can be of any type. \n",
    "mydict = {'ham':'$2','bacon':'$3'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'$2'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict['ham']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Running this takes time... but lists all available modules. \n",
    "# help('modules')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['In',\n",
       " 'Out',\n",
       " '_',\n",
       " '_1',\n",
       " '_12',\n",
       " '_14',\n",
       " '_15',\n",
       " '_16',\n",
       " '_17',\n",
       " '_18',\n",
       " '_19',\n",
       " '_2',\n",
       " '_20',\n",
       " '_22',\n",
       " '_24',\n",
       " '_25',\n",
       " '_29',\n",
       " '_3',\n",
       " '_30',\n",
       " '_31',\n",
       " '_32',\n",
       " '_33',\n",
       " '_35',\n",
       " '_4',\n",
       " '_5',\n",
       " '_6',\n",
       " '_8',\n",
       " '_9',\n",
       " '__',\n",
       " '___',\n",
       " '__builtin__',\n",
       " '__builtins__',\n",
       " '__doc__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " '_dh',\n",
       " '_i',\n",
       " '_i1',\n",
       " '_i10',\n",
       " '_i11',\n",
       " '_i12',\n",
       " '_i13',\n",
       " '_i14',\n",
       " '_i15',\n",
       " '_i16',\n",
       " '_i17',\n",
       " '_i18',\n",
       " '_i19',\n",
       " '_i2',\n",
       " '_i20',\n",
       " '_i21',\n",
       " '_i22',\n",
       " '_i23',\n",
       " '_i24',\n",
       " '_i25',\n",
       " '_i26',\n",
       " '_i27',\n",
       " '_i28',\n",
       " '_i29',\n",
       " '_i3',\n",
       " '_i30',\n",
       " '_i31',\n",
       " '_i32',\n",
       " '_i33',\n",
       " '_i34',\n",
       " '_i35',\n",
       " '_i36',\n",
       " '_i37',\n",
       " '_i4',\n",
       " '_i5',\n",
       " '_i6',\n",
       " '_i7',\n",
       " '_i8',\n",
       " '_i9',\n",
       " '_ih',\n",
       " '_ii',\n",
       " '_iii',\n",
       " '_oh',\n",
       " 'a',\n",
       " 'aa',\n",
       " 'aa2',\n",
       " 'b',\n",
       " 'c',\n",
       " 'exit',\n",
       " 'f',\n",
       " 'get_ipython',\n",
       " 'keyword',\n",
       " 'la',\n",
       " 'loaded_variables',\n",
       " 'mydata',\n",
       " 'mydict',\n",
       " 'np',\n",
       " 'plt',\n",
       " 'quit',\n",
       " 'sio']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This lists all names known at the current level.  \n",
    "dir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"nummethods\"></a>\n",
    "# Numerical Methods and Plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following line imports (loads) some functions from the file\n",
    "``newton_raphson.py``. It should be easy to understand which ones. \n",
    "Loading them one at a time make sense when there is one or two.\n",
    "When their are more, you can use\n",
    "``import newton_raphson as nr`` and *all* functions will be loaded\n",
    "with names in the ``nr`` name subspace. That is, you would call the function ``newton_raphson`` as ``np.newton_raphson``. This keeps your name space from clashing and getting swamped with potentially conflicting names. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# See ``newton_raphson.py`` for the content of these functions. \n",
    "from newton_raphson import newton_raphson_plot\n",
    "from newton_raphson import myfunc\n",
    "function_name = 'myfunc'\n",
    "newton_raphson_plot(function_name,6)\n",
    "# See the semicolon on the next line? I'm using it to hid the errors. \n",
    "plt.savefig('Newton_Raphson_Solution.svg');  # There is now a file in Scaled Vector Format saved"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you really want to understand the Jupyter *magics* execute the next line. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "IPython's 'magic' functions\n",
       "===========================\n",
       "\n",
       "The magic function system provides a series of functions which allow you to\n",
       "control the behavior of IPython itself, plus a lot of system-type\n",
       "features. There are two kinds of magics, line-oriented and cell-oriented.\n",
       "\n",
       "Line magics are prefixed with the % character and work much like OS\n",
       "command-line calls: they get as an argument the rest of the line, where\n",
       "arguments are passed without parentheses or quotes.  For example, this will\n",
       "time the given statement::\n",
       "\n",
       "        %timeit range(1000)\n",
       "\n",
       "Cell magics are prefixed with a double %%, and they are functions that get as\n",
       "an argument not only the rest of the line, but also the lines below it in a\n",
       "separate argument.  These magics are called with two arguments: the rest of the\n",
       "call line and the body of the cell, consisting of the lines below the first.\n",
       "For example::\n",
       "\n",
       "        %%timeit x = numpy.random.randn((100, 100))\n",
       "        numpy.linalg.svd(x)\n",
       "\n",
       "will time the execution of the numpy svd routine, running the assignment of x\n",
       "as part of the setup phase, which is not timed.\n",
       "\n",
       "In a line-oriented client (the terminal or Qt console IPython), starting a new\n",
       "input with %% will automatically enter cell mode, and IPython will continue\n",
       "reading input until a blank line is given.  In the notebook, simply type the\n",
       "whole cell as one entity, but keep in mind that the %% escape can only be at\n",
       "the very start of the cell.\n",
       "\n",
       "NOTE: If you have 'automagic' enabled (via the command line option or with the\n",
       "%automagic function), you don't need to type in the % explicitly for line\n",
       "magics; cell magics always require an explicit '%%' escape.  By default,\n",
       "IPython ships with automagic on, so you should only rarely need the % escape.\n",
       "\n",
       "Example: typing '%cd mydir' (without the quotes) changes your working directory\n",
       "to 'mydir', if it exists.\n",
       "\n",
       "For a list of the available magic functions, use %lsmagic. For a description\n",
       "of any of them, type %magic_name?, e.g. '%cd?'.\n",
       "\n",
       "Currently the magic system has the following functions:\n",
       "%alias:\n",
       "    Define an alias for a system command.\n",
       "    \n",
       "    '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'\n",
       "    \n",
       "    Then, typing 'alias_name params' will execute the system command 'cmd\n",
       "    params' (from your underlying operating system).\n",
       "    \n",
       "    Aliases have lower precedence than magic functions and Python normal\n",
       "    variables, so if 'foo' is both a Python variable and an alias, the\n",
       "    alias can not be executed until 'del foo' removes the Python variable.\n",
       "    \n",
       "    You can use the %l specifier in an alias definition to represent the\n",
       "    whole line when the alias is called.  For example::\n",
       "    \n",
       "      In [2]: alias bracket echo \"Input in brackets: <%l>\"\n",
       "      In [3]: bracket hello world\n",
       "      Input in brackets: <hello world>\n",
       "    \n",
       "    You can also define aliases with parameters using %s specifiers (one\n",
       "    per parameter)::\n",
       "    \n",
       "      In [1]: alias parts echo first %s second %s\n",
       "      In [2]: %parts A B\n",
       "      first A second B\n",
       "      In [3]: %parts A\n",
       "      Incorrect number of arguments: 2 expected.\n",
       "      parts is an alias to: 'echo first %s second %s'\n",
       "    \n",
       "    Note that %l and %s are mutually exclusive.  You can only use one or\n",
       "    the other in your aliases.\n",
       "    \n",
       "    Aliases expand Python variables just like system calls using ! or !!\n",
       "    do: all expressions prefixed with '$' get expanded.  For details of\n",
       "    the semantic rules, see PEP-215:\n",
       "    http://www.python.org/peps/pep-0215.html.  This is the library used by\n",
       "    IPython for variable expansion.  If you want to access a true shell\n",
       "    variable, an extra $ is necessary to prevent its expansion by\n",
       "    IPython::\n",
       "    \n",
       "      In [6]: alias show echo\n",
       "      In [7]: PATH='A Python string'\n",
       "      In [8]: show $PATH\n",
       "      A Python string\n",
       "      In [9]: show $$PATH\n",
       "      /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...\n",
       "    \n",
       "    You can use the alias facility to access all of $PATH.  See the %rehashx\n",
       "    function, which automatically creates aliases for the contents of your\n",
       "    $PATH.\n",
       "    \n",
       "    If called with no parameters, %alias prints the current alias table\n",
       "    for your system.  For posix systems, the default aliases are 'cat',\n",
       "    'cp', 'mv', 'rm', 'rmdir', and 'mkdir', and other platform-specific\n",
       "    aliases are added.  For windows-based systems, the default aliases are\n",
       "    'copy', 'ddir', 'echo', 'ls', 'ldir', 'mkdir', 'ren', and 'rmdir'.\n",
       "    \n",
       "    You can see the definition of alias by adding a question mark in the\n",
       "    end::\n",
       "    \n",
       "      In [1]: cat?\n",
       "      Repr: <alias cat for 'cat'>\n",
       "%alias_magic:\n",
       "    ::\n",
       "    \n",
       "      %alias_magic [-l] [-c] [-p PARAMS] name target\n",
       "    \n",
       "    Create an alias for an existing line or cell magic.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    ::\n",
       "    \n",
       "      In [1]: %alias_magic t timeit\n",
       "      Created `%t` as an alias for `%timeit`.\n",
       "      Created `%%t` as an alias for `%%timeit`.\n",
       "    \n",
       "      In [2]: %t -n1 pass\n",
       "      1 loops, best of 3: 954 ns per loop\n",
       "    \n",
       "      In [3]: %%t -n1\n",
       "         ...: pass\n",
       "         ...:\n",
       "      1 loops, best of 3: 954 ns per loop\n",
       "    \n",
       "      In [4]: %alias_magic --cell whereami pwd\n",
       "      UsageError: Cell magic function `%%pwd` not found.\n",
       "      In [5]: %alias_magic --line whereami pwd\n",
       "      Created `%whereami` as an alias for `%pwd`.\n",
       "    \n",
       "      In [6]: %whereami\n",
       "      Out[6]: u'/home/testuser'\n",
       "    \n",
       "      In [7]: %alias_magic h history \"-p -l 30\" --line\n",
       "      Created `%h` as an alias for `%history -l 30`.\n",
       "    \n",
       "    positional arguments:\n",
       "      name                  Name of the magic to be created.\n",
       "      target                Name of the existing line or cell magic.\n",
       "    \n",
       "    optional arguments:\n",
       "      -l, --line            Create a line magic alias.\n",
       "      -c, --cell            Create a cell magic alias.\n",
       "      -p PARAMS, --params PARAMS\n",
       "                            Parameters passed to the magic function.\n",
       "%autoawait:\n",
       "    \n",
       "    Allow to change the status of the autoawait option.\n",
       "    \n",
       "    This allow you to set a specific asynchronous code runner.\n",
       "    \n",
       "    If no value is passed, print the currently used asynchronous integration\n",
       "    and whether it is activated.\n",
       "    \n",
       "    It can take a number of value evaluated in the following order:\n",
       "    \n",
       "    - False/false/off deactivate autoawait integration\n",
       "    - True/true/on activate autoawait integration using configured default\n",
       "      loop\n",
       "    - asyncio/curio/trio activate autoawait integration and use integration\n",
       "      with said library.\n",
       "    \n",
       "    - `sync` turn on the pseudo-sync integration (mostly used for\n",
       "      `IPython.embed()` which does not run IPython with a real eventloop and\n",
       "      deactivate running asynchronous code. Turning on Asynchronous code with\n",
       "      the pseudo sync loop is undefined behavior and may lead IPython to crash.\n",
       "    \n",
       "    If the passed parameter does not match any of the above and is a python\n",
       "    identifier, get said object from user namespace and set it as the\n",
       "    runner, and activate autoawait. \n",
       "    \n",
       "    If the object is a fully qualified object name, attempt to import it and\n",
       "    set it as the runner, and activate autoawait.\n",
       "    \n",
       "    \n",
       "    The exact behavior of autoawait is experimental and subject to change\n",
       "    across version of IPython and Python.\n",
       "%autocall:\n",
       "    Make functions callable without having to type parentheses.\n",
       "    \n",
       "    Usage:\n",
       "    \n",
       "       %autocall [mode]\n",
       "    \n",
       "    The mode can be one of: 0->Off, 1->Smart, 2->Full.  If not given, the\n",
       "    value is toggled on and off (remembering the previous state).\n",
       "    \n",
       "    In more detail, these values mean:\n",
       "    \n",
       "    0 -> fully disabled\n",
       "    \n",
       "    1 -> active, but do not apply if there are no arguments on the line.\n",
       "    \n",
       "    In this mode, you get::\n",
       "    \n",
       "      In [1]: callable\n",
       "      Out[1]: <built-in function callable>\n",
       "    \n",
       "      In [2]: callable 'hello'\n",
       "      ------> callable('hello')\n",
       "      Out[2]: False\n",
       "    \n",
       "    2 -> Active always.  Even if no arguments are present, the callable\n",
       "    object is called::\n",
       "    \n",
       "      In [2]: float\n",
       "      ------> float()\n",
       "      Out[2]: 0.0\n",
       "    \n",
       "    Note that even with autocall off, you can still use '/' at the start of\n",
       "    a line to treat the first argument on the command line as a function\n",
       "    and add parentheses to it::\n",
       "    \n",
       "      In [8]: /str 43\n",
       "      ------> str(43)\n",
       "      Out[8]: '43'\n",
       "    \n",
       "    # all-random (note for auto-testing)\n",
       "%automagic:\n",
       "    Make magic functions callable without having to type the initial %.\n",
       "    \n",
       "    Without arguments toggles on/off (when off, you must call it as\n",
       "    %automagic, of course).  With arguments it sets the value, and you can\n",
       "    use any of (case insensitive):\n",
       "    \n",
       "     - on, 1, True: to activate\n",
       "    \n",
       "     - off, 0, False: to deactivate.\n",
       "    \n",
       "    Note that magic functions have lowest priority, so if there's a\n",
       "    variable whose name collides with that of a magic fn, automagic won't\n",
       "    work for that function (you get the variable instead). However, if you\n",
       "    delete the variable (del var), the previously shadowed magic function\n",
       "    becomes visible to automagic again.\n",
       "%autosave:\n",
       "    Set the autosave interval in the notebook (in seconds).\n",
       "    \n",
       "    The default value is 120, or two minutes.\n",
       "    ``%autosave 0`` will disable autosave.\n",
       "    \n",
       "    This magic only has an effect when called from the notebook interface.\n",
       "    It has no effect when called in a startup file.\n",
       "%bookmark:\n",
       "    Manage IPython's bookmark system.\n",
       "    \n",
       "    %bookmark <name>       - set bookmark to current dir\n",
       "    %bookmark <name> <dir> - set bookmark to <dir>\n",
       "    %bookmark -l           - list all bookmarks\n",
       "    %bookmark -d <name>    - remove bookmark\n",
       "    %bookmark -r           - remove all bookmarks\n",
       "    \n",
       "    You can later on access a bookmarked folder with::\n",
       "    \n",
       "      %cd -b <name>\n",
       "    \n",
       "    or simply '%cd <name>' if there is no directory called <name> AND\n",
       "    there is such a bookmark defined.\n",
       "    \n",
       "    Your bookmarks persist through IPython sessions, but they are\n",
       "    associated with each profile.\n",
       "%cat:\n",
       "    Alias for `!cat`\n",
       "%cd:\n",
       "    Change the current working directory.\n",
       "    \n",
       "    This command automatically maintains an internal list of directories\n",
       "    you visit during your IPython session, in the variable _dh. The\n",
       "    command %dhist shows this history nicely formatted. You can also\n",
       "    do 'cd -<tab>' to see directory history conveniently.\n",
       "    \n",
       "    Usage:\n",
       "    \n",
       "      cd 'dir': changes to directory 'dir'.\n",
       "    \n",
       "      cd -: changes to the last visited directory.\n",
       "    \n",
       "      cd -<n>: changes to the n-th directory in the directory history.\n",
       "    \n",
       "      cd --foo: change to directory that matches 'foo' in history\n",
       "    \n",
       "      cd -b <bookmark_name>: jump to a bookmark set by %bookmark\n",
       "         (note: cd <bookmark_name> is enough if there is no\n",
       "          directory <bookmark_name>, but a bookmark with the name exists.)\n",
       "          'cd -b <tab>' allows you to tab-complete bookmark names.\n",
       "    \n",
       "    Options:\n",
       "    \n",
       "    -q: quiet.  Do not print the working directory after the cd command is\n",
       "    executed.  By default IPython's cd command does print this directory,\n",
       "    since the default prompts do not display path information.\n",
       "    \n",
       "    Note that !cd doesn't work for this purpose because the shell where\n",
       "    !command runs is immediately discarded after executing 'command'.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    ::\n",
       "    \n",
       "      In [10]: cd parent/child\n",
       "      /home/tsuser/parent/child\n",
       "%clear:\n",
       "    Clear the terminal.\n",
       "%colors:\n",
       "    Switch color scheme for prompts, info system and exception handlers.\n",
       "    \n",
       "    Currently implemented schemes: NoColor, Linux, LightBG.\n",
       "    \n",
       "    Color scheme names are not case-sensitive.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    To get a plain black and white terminal::\n",
       "    \n",
       "      %colors nocolor\n",
       "%conda:\n",
       "    Run the conda package manager within the current kernel.\n",
       "    \n",
       "    Usage:\n",
       "      %conda install [pkgs]\n",
       "%config:\n",
       "    configure IPython\n",
       "    \n",
       "        %config Class[.trait=value]\n",
       "    \n",
       "    This magic exposes most of the IPython config system. Any\n",
       "    Configurable class should be able to be configured with the simple\n",
       "    line::\n",
       "    \n",
       "        %config Class.trait=value\n",
       "    \n",
       "    Where `value` will be resolved in the user's namespace, if it is an\n",
       "    expression or variable name.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    \n",
       "    To see what classes are available for config, pass no arguments::\n",
       "    \n",
       "        In [1]: %config\n",
       "        Available objects for config:\n",
       "            TerminalInteractiveShell\n",
       "            HistoryManager\n",
       "            PrefilterManager\n",
       "            AliasManager\n",
       "            IPCompleter\n",
       "            DisplayFormatter\n",
       "    \n",
       "    To view what is configurable on a given class, just pass the class\n",
       "    name::\n",
       "    \n",
       "        In [2]: %config IPCompleter\n",
       "        IPCompleter options\n",
       "        -----------------\n",
       "        IPCompleter.omit__names=<Enum>\n",
       "            Current: 2\n",
       "            Choices: (0, 1, 2)\n",
       "            Instruct the completer to omit private method names\n",
       "            Specifically, when completing on ``object.<tab>``.\n",
       "            When 2 [default]: all names that start with '_' will be excluded.\n",
       "            When 1: all 'magic' names (``__foo__``) will be excluded.\n",
       "            When 0: nothing will be excluded.\n",
       "        IPCompleter.merge_completions=<CBool>\n",
       "            Current: True\n",
       "            Whether to merge completion results into a single list\n",
       "            If False, only the completion results from the first non-empty\n",
       "            completer will be returned.\n",
       "        IPCompleter.limit_to__all__=<CBool>\n",
       "            Current: False\n",
       "            Instruct the completer to use __all__ for the completion\n",
       "            Specifically, when completing on ``object.<tab>``.\n",
       "            When True: only those names in obj.__all__ will be included.\n",
       "            When False [default]: the __all__ attribute is ignored\n",
       "        IPCompleter.greedy=<CBool>\n",
       "            Current: False\n",
       "            Activate greedy completion\n",
       "            This will enable completion on elements of lists, results of\n",
       "            function calls, etc., but can be unsafe because the code is\n",
       "            actually evaluated on TAB.\n",
       "    \n",
       "    but the real use is in setting values::\n",
       "    \n",
       "        In [3]: %config IPCompleter.greedy = True\n",
       "    \n",
       "    and these values are read from the user_ns if they are variables::\n",
       "    \n",
       "        In [4]: feeling_greedy=False\n",
       "    \n",
       "        In [5]: %config IPCompleter.greedy = feeling_greedy\n",
       "%connect_info:\n",
       "    Print information for connecting other clients to this kernel\n",
       "    \n",
       "    It will print the contents of this session's connection file, as well as\n",
       "    shortcuts for local clients.\n",
       "    \n",
       "    In the simplest case, when called from the most recently launched kernel,\n",
       "    secondary clients can be connected, simply with:\n",
       "    \n",
       "    $> jupyter <app> --existing\n",
       "%cp:\n",
       "    Alias for `!cp`\n",
       "%debug:\n",
       "    ::\n",
       "    \n",
       "      %debug [--breakpoint FILE:LINE] [statement [statement ...]]\n",
       "    \n",
       "    Activate the interactive debugger.\n",
       "    \n",
       "    This magic command support two ways of activating debugger.\n",
       "    One is to activate debugger before executing code.  This way, you\n",
       "    can set a break point, to step through the code from the point.\n",
       "    You can use this mode by giving statements to execute and optionally\n",
       "    a breakpoint.\n",
       "    \n",
       "    The other one is to activate debugger in post-mortem mode.  You can\n",
       "    activate this mode simply running %debug without any argument.\n",
       "    If an exception has just occurred, this lets you inspect its stack\n",
       "    frames interactively.  Note that this will always work only on the last\n",
       "    traceback that occurred, so you must call this quickly after an\n",
       "    exception that you wish to inspect has fired, because if another one\n",
       "    occurs, it clobbers the previous one.\n",
       "    \n",
       "    If you want IPython to automatically do this on every exception, see\n",
       "    the %pdb magic for more details.\n",
       "    \n",
       "    .. versionchanged:: 7.3\n",
       "        When running code, user variables are no longer expanded,\n",
       "        the magic line is always left unmodified.\n",
       "    \n",
       "    positional arguments:\n",
       "      statement             Code to run in debugger. You can omit this in cell magic mode.\n",
       "    \n",
       "    optional arguments:\n",
       "      --breakpoint <FILE:LINE>, -b <FILE:LINE>\n",
       "                            Set break point at LINE in FILE.\n",
       "%dhist:\n",
       "    Print your history of visited directories.\n",
       "    \n",
       "    %dhist       -> print full history\n",
       "    %dhist n     -> print last n entries only\n",
       "    %dhist n1 n2 -> print entries between n1 and n2 (n2 not included)\n",
       "    \n",
       "    This history is automatically maintained by the %cd command, and\n",
       "    always available as the global list variable _dh. You can use %cd -<n>\n",
       "    to go to directory number <n>.\n",
       "    \n",
       "    Note that most of time, you should view directory history by entering\n",
       "    cd -<TAB>.\n",
       "%dirs:\n",
       "    Return the current directory stack.\n",
       "%doctest_mode:\n",
       "    Toggle doctest mode on and off.\n",
       "    \n",
       "    This mode is intended to make IPython behave as much as possible like a\n",
       "    plain Python shell, from the perspective of how its prompts, exceptions\n",
       "    and output look.  This makes it easy to copy and paste parts of a\n",
       "    session into doctests.  It does so by:\n",
       "    \n",
       "    - Changing the prompts to the classic ``>>>`` ones.\n",
       "    - Changing the exception reporting mode to 'Plain'.\n",
       "    - Disabling pretty-printing of output.\n",
       "    \n",
       "    Note that IPython also supports the pasting of code snippets that have\n",
       "    leading '>>>' and '...' prompts in them.  This means that you can paste\n",
       "    doctests from files or docstrings (even if they have leading\n",
       "    whitespace), and the code will execute correctly.  You can then use\n",
       "    '%history -t' to see the translated history; this will give you the\n",
       "    input after removal of all the leading prompts and whitespace, which\n",
       "    can be pasted back into an editor.\n",
       "    \n",
       "    With these features, you can switch into this mode easily whenever you\n",
       "    need to do testing and changes to doctests, without having to leave\n",
       "    your existing IPython session.\n",
       "%ed:\n",
       "    Alias for `%edit`.\n",
       "%edit:\n",
       "    Bring up an editor and execute the resulting code.\n",
       "    \n",
       "    Usage:\n",
       "      %edit [options] [args]\n",
       "    \n",
       "    %edit runs an external text editor. You will need to set the command for\n",
       "    this editor via the ``TerminalInteractiveShell.editor`` option in your\n",
       "    configuration file before it will work.\n",
       "    \n",
       "    This command allows you to conveniently edit multi-line code right in\n",
       "    your IPython session.\n",
       "    \n",
       "    If called without arguments, %edit opens up an empty editor with a\n",
       "    temporary file and will execute the contents of this file when you\n",
       "    close it (don't forget to save it!).\n",
       "    \n",
       "    Options:\n",
       "    \n",
       "    -n <number>\n",
       "      Open the editor at a specified line number. By default, the IPython\n",
       "      editor hook uses the unix syntax 'editor +N filename', but you can\n",
       "      configure this by providing your own modified hook if your favorite\n",
       "      editor supports line-number specifications with a different syntax.\n",
       "    \n",
       "    -p\n",
       "      Call the editor with the same data as the previous time it was used,\n",
       "      regardless of how long ago (in your current session) it was.\n",
       "    \n",
       "    -r\n",
       "      Use 'raw' input. This option only applies to input taken from the\n",
       "      user's history.  By default, the 'processed' history is used, so that\n",
       "      magics are loaded in their transformed version to valid Python.  If\n",
       "      this option is given, the raw input as typed as the command line is\n",
       "      used instead.  When you exit the editor, it will be executed by\n",
       "      IPython's own processor.\n",
       "    \n",
       "    Arguments:\n",
       "    \n",
       "    If arguments are given, the following possibilities exist:\n",
       "    \n",
       "    - The arguments are numbers or pairs of colon-separated numbers (like\n",
       "      1 4:8 9). These are interpreted as lines of previous input to be\n",
       "      loaded into the editor. The syntax is the same of the %macro command.\n",
       "    \n",
       "    - If the argument doesn't start with a number, it is evaluated as a\n",
       "      variable and its contents loaded into the editor. You can thus edit\n",
       "      any string which contains python code (including the result of\n",
       "      previous edits).\n",
       "    \n",
       "    - If the argument is the name of an object (other than a string),\n",
       "      IPython will try to locate the file where it was defined and open the\n",
       "      editor at the point where it is defined. You can use ``%edit function``\n",
       "      to load an editor exactly at the point where 'function' is defined,\n",
       "      edit it and have the file be executed automatically.\n",
       "    \n",
       "      If the object is a macro (see %macro for details), this opens up your\n",
       "      specified editor with a temporary file containing the macro's data.\n",
       "      Upon exit, the macro is reloaded with the contents of the file.\n",
       "    \n",
       "      Note: opening at an exact line is only supported under Unix, and some\n",
       "      editors (like kedit and gedit up to Gnome 2.8) do not understand the\n",
       "      '+NUMBER' parameter necessary for this feature. Good editors like\n",
       "      (X)Emacs, vi, jed, pico and joe all do.\n",
       "    \n",
       "    - If the argument is not found as a variable, IPython will look for a\n",
       "      file with that name (adding .py if necessary) and load it into the\n",
       "      editor. It will execute its contents with execfile() when you exit,\n",
       "      loading any code in the file into your interactive namespace.\n",
       "    \n",
       "    Unlike in the terminal, this is designed to use a GUI editor, and we do\n",
       "    not know when it has closed. So the file you edit will not be\n",
       "    automatically executed or printed.\n",
       "    \n",
       "    Note that %edit is also available through the alias %ed.\n",
       "%env:\n",
       "    Get, set, or list environment variables.\n",
       "    \n",
       "    Usage:\n",
       "    \n",
       "      %env: lists all environment variables/values\n",
       "      %env var: get value for var\n",
       "      %env var val: set value for var\n",
       "      %env var=val: set value for var\n",
       "      %env var=$val: set value for var, using python expansion if possible\n",
       "%gui:\n",
       "    Enable or disable IPython GUI event loop integration.\n",
       "    \n",
       "    %gui [GUINAME]\n",
       "    \n",
       "    This magic replaces IPython's threaded shells that were activated\n",
       "    using the (pylab/wthread/etc.) command line flags.  GUI toolkits\n",
       "    can now be enabled at runtime and keyboard\n",
       "    interrupts should work without any problems.  The following toolkits\n",
       "    are supported:  wxPython, PyQt4, PyGTK, Tk and Cocoa (OSX)::\n",
       "    \n",
       "        %gui wx      # enable wxPython event loop integration\n",
       "        %gui qt4|qt  # enable PyQt4 event loop integration\n",
       "        %gui qt5     # enable PyQt5 event loop integration\n",
       "        %gui gtk     # enable PyGTK event loop integration\n",
       "        %gui gtk3    # enable Gtk3 event loop integration\n",
       "        %gui tk      # enable Tk event loop integration\n",
       "        %gui osx     # enable Cocoa event loop integration\n",
       "                     # (requires %matplotlib 1.1)\n",
       "        %gui         # disable all event loop integration\n",
       "    \n",
       "    WARNING:  after any of these has been called you can simply create\n",
       "    an application object, but DO NOT start the event loop yourself, as\n",
       "    we have already handled that.\n",
       "%hist:\n",
       "    Alias for `%history`.\n",
       "%history:\n",
       "    ::\n",
       "    \n",
       "      %history [-n] [-o] [-p] [-t] [-f FILENAME] [-g [PATTERN [PATTERN ...]]] [-l [LIMIT]] [-u] [range [range ...]]\n",
       "    \n",
       "    Print input history (_i<n> variables), with most recent last.\n",
       "    \n",
       "    By default, input history is printed without line numbers so it can be\n",
       "    directly pasted into an editor. Use -n to show them.\n",
       "    \n",
       "    By default, all input history from the current session is displayed.\n",
       "    Ranges of history can be indicated using the syntax:\n",
       "    \n",
       "    ``4``\n",
       "        Line 4, current session\n",
       "    ``4-6``\n",
       "        Lines 4-6, current session\n",
       "    ``243/1-5``\n",
       "        Lines 1-5, session 243\n",
       "    ``~2/7``\n",
       "        Line 7, session 2 before current\n",
       "    ``~8/1-~6/5``\n",
       "        From the first line of 8 sessions ago, to the fifth line of 6\n",
       "        sessions ago.\n",
       "    \n",
       "    Multiple ranges can be entered, separated by spaces\n",
       "    \n",
       "    The same syntax is used by %macro, %save, %edit, %rerun\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    ::\n",
       "    \n",
       "      In [6]: %history -n 4-6\n",
       "      4:a = 12\n",
       "      5:print a**2\n",
       "      6:%history -n 4-6\n",
       "    \n",
       "    positional arguments:\n",
       "      range\n",
       "    \n",
       "    optional arguments:\n",
       "      -n                    print line numbers for each input. This feature is only available if numbered prompts are in use.\n",
       "      -o                    also print outputs for each input.\n",
       "      -p                    print classic '>>>' python prompts before each input. This is useful for making documentation, and in conjunction with -o, for producing doctest-ready output.\n",
       "      -t                    print the 'translated' history, as IPython understands it. IPython filters your input and converts it all into valid Python source before executing it (things like magics or\n",
       "                            aliases are turned into function calls, for example). With this option, you'll see the native history instead of the user-entered version: '%cd /' will be seen as\n",
       "                            'get_ipython().run_line_magic(\"cd\", \"/\")' instead of '%cd /'.\n",
       "      -f FILENAME           FILENAME: instead of printing the output to the screen, redirect it to the given file. The file is always overwritten, though *when it can*, IPython asks for confirmation first. In\n",
       "                            particular, running the command 'history -f FILENAME' from the IPython Notebook interface will replace FILENAME even if it already exists *without* confirmation.\n",
       "      -g <[PATTERN [PATTERN ...]]>\n",
       "                            treat the arg as a glob pattern to search for in (full) history. This includes the saved history (almost all commands ever written). The pattern may contain '?' to match one\n",
       "                            unknown character and '*' to match any number of unknown characters. Use '%hist -g' to show full saved history (may be very long).\n",
       "      -l <[LIMIT]>          get the last n lines from all sessions. Specify n as a single arg, or the default is the last 10 lines.\n",
       "      -u                    when searching history using `-g`, show only unique history.\n",
       "%killbgscripts:\n",
       "    Kill all BG processes started by %%script and its family.\n",
       "%ldir:\n",
       "    Alias for `!ls -F -G -l %l | grep /$`\n",
       "%less:\n",
       "    Show a file through the pager.\n",
       "    \n",
       "    Files ending in .py are syntax-highlighted.\n",
       "%lf:\n",
       "    Alias for `!ls -F -l -G %l | grep ^-`\n",
       "%lk:\n",
       "    Alias for `!ls -F -l -G %l | grep ^l`\n",
       "%ll:\n",
       "    Alias for `!ls -F -l -G`\n",
       "%load:\n",
       "    Load code into the current frontend.\n",
       "    \n",
       "    Usage:\n",
       "      %load [options] source\n",
       "    \n",
       "      where source can be a filename, URL, input history range, macro, or\n",
       "      element in the user namespace\n",
       "    \n",
       "    Options:\n",
       "    \n",
       "      -r <lines>: Specify lines or ranges of lines to load from the source.\n",
       "      Ranges could be specified as x-y (x..y) or in python-style x:y \n",
       "      (x..(y-1)). Both limits x and y can be left blank (meaning the \n",
       "      beginning and end of the file, respectively).\n",
       "    \n",
       "      -s <symbols>: Specify function or classes to load from python source. \n",
       "    \n",
       "      -y : Don't ask confirmation for loading source above 200 000 characters.\n",
       "    \n",
       "      -n : Include the user's namespace when searching for source code.\n",
       "    \n",
       "    This magic command can either take a local filename, a URL, an history\n",
       "    range (see %history) or a macro as argument, it will prompt for\n",
       "    confirmation before loading source with more than 200 000 characters, unless\n",
       "    -y flag is passed or if the frontend does not support raw_input::\n",
       "    \n",
       "    %load myscript.py\n",
       "    %load 7-27\n",
       "    %load myMacro\n",
       "    %load http://www.example.com/myscript.py\n",
       "    %load -r 5-10 myscript.py\n",
       "    %load -r 10-20,30,40: foo.py\n",
       "    %load -s MyClass,wonder_function myscript.py\n",
       "    %load -n MyClass\n",
       "    %load -n my_module.wonder_function\n",
       "%load_ext:\n",
       "    Load an IPython extension by its module name.\n",
       "%loadpy:\n",
       "    Alias of `%load`\n",
       "    \n",
       "    `%loadpy` has gained some flexibility and dropped the requirement of a `.py`\n",
       "    extension. So it has been renamed simply into %load. You can look at\n",
       "    `%load`'s docstring for more info.\n",
       "%logoff:\n",
       "    Temporarily stop logging.\n",
       "    \n",
       "    You must have previously started logging.\n",
       "%logon:\n",
       "    Restart logging.\n",
       "    \n",
       "    This function is for restarting logging which you've temporarily\n",
       "    stopped with %logoff. For starting logging for the first time, you\n",
       "    must use the %logstart function, which allows you to specify an\n",
       "    optional log filename.\n",
       "%logstart:\n",
       "    Start logging anywhere in a session.\n",
       "    \n",
       "    %logstart [-o|-r|-t|-q] [log_name [log_mode]]\n",
       "    \n",
       "    If no name is given, it defaults to a file named 'ipython_log.py' in your\n",
       "    current directory, in 'rotate' mode (see below).\n",
       "    \n",
       "    '%logstart name' saves to file 'name' in 'backup' mode.  It saves your\n",
       "    history up to that point and then continues logging.\n",
       "    \n",
       "    %logstart takes a second optional parameter: logging mode. This can be one\n",
       "    of (note that the modes are given unquoted):\n",
       "    \n",
       "    append\n",
       "        Keep logging at the end of any existing file.\n",
       "    \n",
       "    backup\n",
       "        Rename any existing file to name~ and start name.\n",
       "    \n",
       "    global\n",
       "        Append to  a single logfile in your home directory.\n",
       "    \n",
       "    over\n",
       "        Overwrite any existing log.\n",
       "    \n",
       "    rotate\n",
       "        Create rotating logs: name.1~, name.2~, etc.\n",
       "    \n",
       "    Options:\n",
       "    \n",
       "      -o\n",
       "        log also IPython's output. In this mode, all commands which\n",
       "        generate an Out[NN] prompt are recorded to the logfile, right after\n",
       "        their corresponding input line. The output lines are always\n",
       "        prepended with a '#[Out]# ' marker, so that the log remains valid\n",
       "        Python code.\n",
       "    \n",
       "      Since this marker is always the same, filtering only the output from\n",
       "      a log is very easy, using for example a simple awk call::\n",
       "    \n",
       "        awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py\n",
       "    \n",
       "      -r\n",
       "        log 'raw' input.  Normally, IPython's logs contain the processed\n",
       "        input, so that user lines are logged in their final form, converted\n",
       "        into valid Python.  For example, %Exit is logged as\n",
       "        _ip.magic(\"Exit\").  If the -r flag is given, all input is logged\n",
       "        exactly as typed, with no transformations applied.\n",
       "    \n",
       "      -t\n",
       "        put timestamps before each input line logged (these are put in\n",
       "        comments).\n",
       "    \n",
       "      -q \n",
       "        suppress output of logstate message when logging is invoked\n",
       "%logstate:\n",
       "    Print the status of the logging system.\n",
       "%logstop:\n",
       "    Fully stop logging and close log file.\n",
       "    \n",
       "    In order to start logging again, a new %logstart call needs to be made,\n",
       "    possibly (though not necessarily) with a new filename, mode and other\n",
       "    options.\n",
       "%ls:\n",
       "    Alias for `!ls -F -G`\n",
       "%lsmagic:\n",
       "    List currently available magic functions.\n",
       "%lx:\n",
       "    Alias for `!ls -F -l -G %l | grep ^-..x`\n",
       "%macro:\n",
       "    Define a macro for future re-execution. It accepts ranges of history,\n",
       "    filenames or string objects.\n",
       "    \n",
       "    Usage:\n",
       "      %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...\n",
       "    \n",
       "    Options:\n",
       "    \n",
       "      -r: use 'raw' input.  By default, the 'processed' history is used,\n",
       "      so that magics are loaded in their transformed version to valid\n",
       "      Python.  If this option is given, the raw input as typed at the\n",
       "      command line is used instead.\n",
       "    \n",
       "      -q: quiet macro definition.  By default, a tag line is printed \n",
       "      to indicate the macro has been created, and then the contents of \n",
       "      the macro are printed.  If this option is given, then no printout\n",
       "      is produced once the macro is created.\n",
       "    \n",
       "    This will define a global variable called `name` which is a string\n",
       "    made of joining the slices and lines you specify (n1,n2,... numbers\n",
       "    above) from your input history into a single string. This variable\n",
       "    acts like an automatic function which re-executes those lines as if\n",
       "    you had typed them. You just type 'name' at the prompt and the code\n",
       "    executes.\n",
       "    \n",
       "    The syntax for indicating input ranges is described in %history.\n",
       "    \n",
       "    Note: as a 'hidden' feature, you can also use traditional python slice\n",
       "    notation, where N:M means numbers N through M-1.\n",
       "    \n",
       "    For example, if your history contains (print using %hist -n )::\n",
       "    \n",
       "      44: x=1\n",
       "      45: y=3\n",
       "      46: z=x+y\n",
       "      47: print x\n",
       "      48: a=5\n",
       "      49: print 'x',x,'y',y\n",
       "    \n",
       "    you can create a macro with lines 44 through 47 (included) and line 49\n",
       "    called my_macro with::\n",
       "    \n",
       "      In [55]: %macro my_macro 44-47 49\n",
       "    \n",
       "    Now, typing `my_macro` (without quotes) will re-execute all this code\n",
       "    in one pass.\n",
       "    \n",
       "    You don't need to give the line-numbers in order, and any given line\n",
       "    number can appear multiple times. You can assemble macros with any\n",
       "    lines from your input history in any order.\n",
       "    \n",
       "    The macro is a simple object which holds its value in an attribute,\n",
       "    but IPython's display system checks for macros and executes them as\n",
       "    code instead of printing them when you type their name.\n",
       "    \n",
       "    You can view a macro's contents by explicitly printing it with::\n",
       "    \n",
       "      print macro_name\n",
       "%magic:\n",
       "    Print information about the magic function system.\n",
       "    \n",
       "    Supported formats: -latex, -brief, -rest\n",
       "%man:\n",
       "    Find the man page for the given command and display in pager.\n",
       "%matplotlib:\n",
       "    ::\n",
       "    \n",
       "      %matplotlib [-l] [gui]\n",
       "    \n",
       "    Set up matplotlib to work interactively.\n",
       "    \n",
       "    This function lets you activate matplotlib interactive support\n",
       "    at any point during an IPython session. It does not import anything\n",
       "    into the interactive namespace.\n",
       "    \n",
       "    If you are using the inline matplotlib backend in the IPython Notebook\n",
       "    you can set which figure formats are enabled using the following::\n",
       "    \n",
       "        In [1]: from IPython.display import set_matplotlib_formats\n",
       "    \n",
       "        In [2]: set_matplotlib_formats('pdf', 'svg')\n",
       "    \n",
       "    The default for inline figures sets `bbox_inches` to 'tight'. This can\n",
       "    cause discrepancies between the displayed image and the identical\n",
       "    image created using `savefig`. This behavior can be disabled using the\n",
       "    `%config` magic::\n",
       "    \n",
       "        In [3]: %config InlineBackend.print_figure_kwargs = {'bbox_inches':None}\n",
       "    \n",
       "    In addition, see the docstring of\n",
       "    `IPython.display.set_matplotlib_formats` and\n",
       "    `IPython.display.set_matplotlib_close` for more information on\n",
       "    changing additional behaviors of the inline backend.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    To enable the inline backend for usage with the IPython Notebook::\n",
       "    \n",
       "        In [1]: %matplotlib inline\n",
       "    \n",
       "    In this case, where the matplotlib default is TkAgg::\n",
       "    \n",
       "        In [2]: %matplotlib\n",
       "        Using matplotlib backend: TkAgg\n",
       "    \n",
       "    But you can explicitly request a different GUI backend::\n",
       "    \n",
       "        In [3]: %matplotlib qt\n",
       "    \n",
       "    You can list the available backends using the -l/--list option::\n",
       "    \n",
       "       In [4]: %matplotlib --list\n",
       "       Available matplotlib backends: ['osx', 'qt4', 'qt5', 'gtk3', 'notebook', 'wx', 'qt', 'nbagg',\n",
       "       'gtk', 'tk', 'inline']\n",
       "    \n",
       "    positional arguments:\n",
       "      gui         Name of the matplotlib backend to use ('agg', 'gtk', 'gtk3', 'inline', 'ipympl', 'nbagg', 'notebook', 'osx', 'pdf', 'ps', 'qt', 'qt4', 'qt5', 'svg', 'tk', 'widget', 'wx'). If given, the\n",
       "                  corresponding matplotlib backend is used, otherwise it will be matplotlib's default (which you can set in your matplotlib config file).\n",
       "    \n",
       "    optional arguments:\n",
       "      -l, --list  Show available matplotlib backends\n",
       "%mkdir:\n",
       "    Alias for `!mkdir`\n",
       "%more:\n",
       "    Show a file through the pager.\n",
       "    \n",
       "    Files ending in .py are syntax-highlighted.\n",
       "%mv:\n",
       "    Alias for `!mv`\n",
       "%notebook:\n",
       "    ::\n",
       "    \n",
       "      %notebook filename\n",
       "    \n",
       "    Export and convert IPython notebooks.\n",
       "    \n",
       "    This function can export the current IPython history to a notebook file.\n",
       "    For example, to export the history to \"foo.ipynb\" do \"%notebook foo.ipynb\".\n",
       "    \n",
       "    The -e or --export flag is deprecated in IPython 5.2, and will be\n",
       "    removed in the future.\n",
       "    \n",
       "    positional arguments:\n",
       "      filename  Notebook name or filename\n",
       "%page:\n",
       "    Pretty print the object and display it through a pager.\n",
       "    \n",
       "    %page [options] OBJECT\n",
       "    \n",
       "    If no object is given, use _ (last output).\n",
       "    \n",
       "    Options:\n",
       "    \n",
       "      -r: page str(object), don't pretty-print it.\n",
       "%pastebin:\n",
       "    Upload code to dpaste's paste bin, returning the URL.\n",
       "    \n",
       "    Usage:\n",
       "      %pastebin [-d \"Custom description\"] 1-7\n",
       "    \n",
       "    The argument can be an input history range, a filename, or the name of a\n",
       "    string or macro.\n",
       "    \n",
       "    Options:\n",
       "    \n",
       "      -d: Pass a custom description for the gist. The default will say\n",
       "          \"Pasted from IPython\".\n",
       "%pdb:\n",
       "    Control the automatic calling of the pdb interactive debugger.\n",
       "    \n",
       "    Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without\n",
       "    argument it works as a toggle.\n",
       "    \n",
       "    When an exception is triggered, IPython can optionally call the\n",
       "    interactive pdb debugger after the traceback printout. %pdb toggles\n",
       "    this feature on and off.\n",
       "    \n",
       "    The initial state of this feature is set in your configuration\n",
       "    file (the option is ``InteractiveShell.pdb``).\n",
       "    \n",
       "    If you want to just activate the debugger AFTER an exception has fired,\n",
       "    without having to type '%pdb on' and rerunning your code, you can use\n",
       "    the %debug magic.\n",
       "%pdef:\n",
       "    Print the call signature for any callable object.\n",
       "    \n",
       "    If the object is a class, print the constructor information.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    ::\n",
       "    \n",
       "      In [3]: %pdef urllib.urlopen\n",
       "      urllib.urlopen(url, data=None, proxies=None)\n",
       "%pdoc:\n",
       "    Print the docstring for an object.\n",
       "    \n",
       "    If the given object is a class, it will print both the class and the\n",
       "    constructor docstrings.\n",
       "%pfile:\n",
       "    Print (or run through pager) the file where an object is defined.\n",
       "    \n",
       "    The file opens at the line where the object definition begins. IPython\n",
       "    will honor the environment variable PAGER if set, and otherwise will\n",
       "    do its best to print the file in a convenient form.\n",
       "    \n",
       "    If the given argument is not an object currently defined, IPython will\n",
       "    try to interpret it as a filename (automatically adding a .py extension\n",
       "    if needed). You can thus use %pfile as a syntax highlighting code\n",
       "    viewer.\n",
       "%pinfo:\n",
       "    Provide detailed information about an object.\n",
       "    \n",
       "    '%pinfo object' is just a synonym for object? or ?object.\n",
       "%pinfo2:\n",
       "    Provide extra detailed information about an object.\n",
       "    \n",
       "    '%pinfo2 object' is just a synonym for object?? or ??object.\n",
       "%pip:\n",
       "    Run the pip package manager within the current kernel.\n",
       "    \n",
       "    Usage:\n",
       "      %pip install [pkgs]\n",
       "%popd:\n",
       "    Change to directory popped off the top of the stack.\n",
       "%pprint:\n",
       "    Toggle pretty printing on/off.\n",
       "%precision:\n",
       "    Set floating point precision for pretty printing.\n",
       "    \n",
       "    Can set either integer precision or a format string.\n",
       "    \n",
       "    If numpy has been imported and precision is an int,\n",
       "    numpy display precision will also be set, via ``numpy.set_printoptions``.\n",
       "    \n",
       "    If no argument is given, defaults will be restored.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    ::\n",
       "    \n",
       "        In [1]: from math import pi\n",
       "    \n",
       "        In [2]: %precision 3\n",
       "        Out[2]: u'%.3f'\n",
       "    \n",
       "        In [3]: pi\n",
       "        Out[3]: 3.142\n",
       "    \n",
       "        In [4]: %precision %i\n",
       "        Out[4]: u'%i'\n",
       "    \n",
       "        In [5]: pi\n",
       "        Out[5]: 3\n",
       "    \n",
       "        In [6]: %precision %e\n",
       "        Out[6]: u'%e'\n",
       "    \n",
       "        In [7]: pi**10\n",
       "        Out[7]: 9.364805e+04\n",
       "    \n",
       "        In [8]: %precision\n",
       "        Out[8]: u'%r'\n",
       "    \n",
       "        In [9]: pi**10\n",
       "        Out[9]: 93648.047476082982\n",
       "%prun:\n",
       "    Run a statement through the python code profiler.\n",
       "    \n",
       "    Usage, in line mode:\n",
       "      %prun [options] statement\n",
       "    \n",
       "    Usage, in cell mode:\n",
       "      %%prun [options] [statement]\n",
       "      code...\n",
       "      code...\n",
       "    \n",
       "    In cell mode, the additional code lines are appended to the (possibly\n",
       "    empty) statement in the first line.  Cell mode allows you to easily\n",
       "    profile multiline blocks without having to put them in a separate\n",
       "    function.\n",
       "    \n",
       "    The given statement (which doesn't require quote marks) is run via the\n",
       "    python profiler in a manner similar to the profile.run() function.\n",
       "    Namespaces are internally managed to work correctly; profile.run\n",
       "    cannot be used in IPython because it makes certain assumptions about\n",
       "    namespaces which do not hold under IPython.\n",
       "    \n",
       "    Options:\n",
       "    \n",
       "    -l <limit>\n",
       "      you can place restrictions on what or how much of the\n",
       "      profile gets printed. The limit value can be:\n",
       "    \n",
       "         * A string: only information for function names containing this string\n",
       "           is printed.\n",
       "    \n",
       "         * An integer: only these many lines are printed.\n",
       "    \n",
       "         * A float (between 0 and 1): this fraction of the report is printed\n",
       "           (for example, use a limit of 0.4 to see the topmost 40% only).\n",
       "    \n",
       "      You can combine several limits with repeated use of the option. For\n",
       "      example, ``-l __init__ -l 5`` will print only the topmost 5 lines of\n",
       "      information about class constructors.\n",
       "    \n",
       "    -r\n",
       "      return the pstats.Stats object generated by the profiling. This\n",
       "      object has all the information about the profile in it, and you can\n",
       "      later use it for further analysis or in other functions.\n",
       "    \n",
       "    -s <key>\n",
       "      sort profile by given key. You can provide more than one key\n",
       "      by using the option several times: '-s key1 -s key2 -s key3...'. The\n",
       "      default sorting key is 'time'.\n",
       "    \n",
       "      The following is copied verbatim from the profile documentation\n",
       "      referenced below:\n",
       "    \n",
       "      When more than one key is provided, additional keys are used as\n",
       "      secondary criteria when the there is equality in all keys selected\n",
       "      before them.\n",
       "    \n",
       "      Abbreviations can be used for any key names, as long as the\n",
       "      abbreviation is unambiguous.  The following are the keys currently\n",
       "      defined:\n",
       "    \n",
       "      ============  =====================\n",
       "      Valid Arg     Meaning\n",
       "      ============  =====================\n",
       "      \"calls\"       call count\n",
       "      \"cumulative\"  cumulative time\n",
       "      \"file\"        file name\n",
       "      \"module\"      file name\n",
       "      \"pcalls\"      primitive call count\n",
       "      \"line\"        line number\n",
       "      \"name\"        function name\n",
       "      \"nfl\"         name/file/line\n",
       "      \"stdname\"     standard name\n",
       "      \"time\"        internal time\n",
       "      ============  =====================\n",
       "    \n",
       "      Note that all sorts on statistics are in descending order (placing\n",
       "      most time consuming items first), where as name, file, and line number\n",
       "      searches are in ascending order (i.e., alphabetical). The subtle\n",
       "      distinction between \"nfl\" and \"stdname\" is that the standard name is a\n",
       "      sort of the name as printed, which means that the embedded line\n",
       "      numbers get compared in an odd way.  For example, lines 3, 20, and 40\n",
       "      would (if the file names were the same) appear in the string order\n",
       "      \"20\" \"3\" and \"40\".  In contrast, \"nfl\" does a numeric compare of the\n",
       "      line numbers.  In fact, sort_stats(\"nfl\") is the same as\n",
       "      sort_stats(\"name\", \"file\", \"line\").\n",
       "    \n",
       "    -T <filename>\n",
       "      save profile results as shown on screen to a text\n",
       "      file. The profile is still shown on screen.\n",
       "    \n",
       "    -D <filename>\n",
       "      save (via dump_stats) profile statistics to given\n",
       "      filename. This data is in a format understood by the pstats module, and\n",
       "      is generated by a call to the dump_stats() method of profile\n",
       "      objects. The profile is still shown on screen.\n",
       "    \n",
       "    -q\n",
       "      suppress output to the pager.  Best used with -T and/or -D above.\n",
       "    \n",
       "    If you want to run complete programs under the profiler's control, use\n",
       "    ``%run -p [prof_opts] filename.py [args to program]`` where prof_opts\n",
       "    contains profiler specific options as described here.\n",
       "    \n",
       "    You can read the complete documentation for the profile module with::\n",
       "    \n",
       "      In [1]: import profile; profile.help()\n",
       "    \n",
       "    .. versionchanged:: 7.3\n",
       "        User variables are no longer expanded,\n",
       "        the magic line is always left unmodified.\n",
       "%psearch:\n",
       "    Search for object in namespaces by wildcard.\n",
       "    \n",
       "    %psearch [options] PATTERN [OBJECT TYPE]\n",
       "    \n",
       "    Note: ? can be used as a synonym for %psearch, at the beginning or at\n",
       "    the end: both a*? and ?a* are equivalent to '%psearch a*'.  Still, the\n",
       "    rest of the command line must be unchanged (options come first), so\n",
       "    for example the following forms are equivalent\n",
       "    \n",
       "    %psearch -i a* function\n",
       "    -i a* function?\n",
       "    ?-i a* function\n",
       "    \n",
       "    Arguments:\n",
       "    \n",
       "      PATTERN\n",
       "    \n",
       "      where PATTERN is a string containing * as a wildcard similar to its\n",
       "      use in a shell.  The pattern is matched in all namespaces on the\n",
       "      search path. By default objects starting with a single _ are not\n",
       "      matched, many IPython generated objects have a single\n",
       "      underscore. The default is case insensitive matching. Matching is\n",
       "      also done on the attributes of objects and not only on the objects\n",
       "      in a module.\n",
       "    \n",
       "      [OBJECT TYPE]\n",
       "    \n",
       "      Is the name of a python type from the types module. The name is\n",
       "      given in lowercase without the ending type, ex. StringType is\n",
       "      written string. By adding a type here only objects matching the\n",
       "      given type are matched. Using all here makes the pattern match all\n",
       "      types (this is the default).\n",
       "    \n",
       "    Options:\n",
       "    \n",
       "      -a: makes the pattern match even objects whose names start with a\n",
       "      single underscore.  These names are normally omitted from the\n",
       "      search.\n",
       "    \n",
       "      -i/-c: make the pattern case insensitive/sensitive.  If neither of\n",
       "      these options are given, the default is read from your configuration\n",
       "      file, with the option ``InteractiveShell.wildcards_case_sensitive``.\n",
       "      If this option is not specified in your configuration file, IPython's\n",
       "      internal default is to do a case sensitive search.\n",
       "    \n",
       "      -e/-s NAMESPACE: exclude/search a given namespace.  The pattern you\n",
       "      specify can be searched in any of the following namespaces:\n",
       "      'builtin', 'user', 'user_global','internal', 'alias', where\n",
       "      'builtin' and 'user' are the search defaults.  Note that you should\n",
       "      not use quotes when specifying namespaces.\n",
       "    \n",
       "      -l: List all available object types for object matching. This function\n",
       "      can be used without arguments.\n",
       "    \n",
       "      'Builtin' contains the python module builtin, 'user' contains all\n",
       "      user data, 'alias' only contain the shell aliases and no python\n",
       "      objects, 'internal' contains objects used by IPython.  The\n",
       "      'user_global' namespace is only used by embedded IPython instances,\n",
       "      and it contains module-level globals.  You can add namespaces to the\n",
       "      search with -s or exclude them with -e (these options can be given\n",
       "      more than once).\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    ::\n",
       "    \n",
       "      %psearch a*            -> objects beginning with an a\n",
       "      %psearch -e builtin a* -> objects NOT in the builtin space starting in a\n",
       "      %psearch a* function   -> all functions beginning with an a\n",
       "      %psearch re.e*         -> objects beginning with an e in module re\n",
       "      %psearch r*.e*         -> objects that start with e in modules starting in r\n",
       "      %psearch r*.* string   -> all strings in modules beginning with r\n",
       "    \n",
       "    Case sensitive search::\n",
       "    \n",
       "      %psearch -c a*         list all object beginning with lower case a\n",
       "    \n",
       "    Show objects beginning with a single _::\n",
       "    \n",
       "      %psearch -a _*         list objects beginning with a single underscore\n",
       "    \n",
       "    List available objects::\n",
       "    \n",
       "      %psearch -l            list all available object types\n",
       "%psource:\n",
       "    Print (or run through pager) the source code for an object.\n",
       "%pushd:\n",
       "    Place the current dir on stack and change directory.\n",
       "    \n",
       "    Usage:\n",
       "      %pushd ['dirname']\n",
       "%pwd:\n",
       "    Return the current working directory path.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    ::\n",
       "    \n",
       "      In [9]: pwd\n",
       "      Out[9]: '/home/tsuser/sprint/ipython'\n",
       "%pycat:\n",
       "    Show a syntax-highlighted file through a pager.\n",
       "    \n",
       "    This magic is similar to the cat utility, but it will assume the file\n",
       "    to be Python source and will show it with syntax highlighting.\n",
       "    \n",
       "    This magic command can either take a local filename, an url,\n",
       "    an history range (see %history) or a macro as argument ::\n",
       "    \n",
       "    %pycat myscript.py\n",
       "    %pycat 7-27\n",
       "    %pycat myMacro\n",
       "    %pycat http://www.example.com/myscript.py\n",
       "%pylab:\n",
       "    ::\n",
       "    \n",
       "      %pylab [--no-import-all] [gui]\n",
       "    \n",
       "    Load numpy and matplotlib to work interactively.\n",
       "    \n",
       "    This function lets you activate pylab (matplotlib, numpy and\n",
       "    interactive support) at any point during an IPython session.\n",
       "    \n",
       "    %pylab makes the following imports::\n",
       "    \n",
       "        import numpy\n",
       "        import matplotlib\n",
       "        from matplotlib import pylab, mlab, pyplot\n",
       "        np = numpy\n",
       "        plt = pyplot\n",
       "    \n",
       "        from IPython.display import display\n",
       "        from IPython.core.pylabtools import figsize, getfigs\n",
       "    \n",
       "        from pylab import *\n",
       "        from numpy import *\n",
       "    \n",
       "    If you pass `--no-import-all`, the last two `*` imports will be excluded.\n",
       "    \n",
       "    See the %matplotlib magic for more details about activating matplotlib\n",
       "    without affecting the interactive namespace.\n",
       "    \n",
       "    positional arguments:\n",
       "      gui              Name of the matplotlib backend to use ('agg', 'gtk', 'gtk3', 'inline', 'ipympl', 'nbagg', 'notebook', 'osx', 'pdf', 'ps', 'qt', 'qt4', 'qt5', 'svg', 'tk', 'widget', 'wx'). If given, the\n",
       "                       corresponding matplotlib backend is used, otherwise it will be matplotlib's default (which you can set in your matplotlib config file).\n",
       "    \n",
       "    optional arguments:\n",
       "      --no-import-all  Prevent IPython from performing ``import *`` into the interactive namespace. You can govern the default behavior of this flag with the InteractiveShellApp.pylab_import_all configurable.\n",
       "%qtconsole:\n",
       "    Open a qtconsole connected to this kernel.\n",
       "    \n",
       "    Useful for connecting a qtconsole to running notebooks, for better\n",
       "    debugging.\n",
       "%quickref:\n",
       "    Show a quick reference sheet\n",
       "%recall:\n",
       "    Repeat a command, or get command to input line for editing.\n",
       "    \n",
       "    %recall and %rep are equivalent.\n",
       "    \n",
       "    - %recall (no arguments):\n",
       "    \n",
       "    Place a string version of last computation result (stored in the\n",
       "    special '_' variable) to the next input prompt. Allows you to create\n",
       "    elaborate command lines without using copy-paste::\n",
       "    \n",
       "         In[1]: l = [\"hei\", \"vaan\"]\n",
       "         In[2]: \"\".join(l)\n",
       "        Out[2]: heivaan\n",
       "         In[3]: %recall\n",
       "         In[4]: heivaan_ <== cursor blinking\n",
       "    \n",
       "    %recall 45\n",
       "    \n",
       "    Place history line 45 on the next input prompt. Use %hist to find\n",
       "    out the number.\n",
       "    \n",
       "    %recall 1-4\n",
       "    \n",
       "    Combine the specified lines into one cell, and place it on the next\n",
       "    input prompt. See %history for the slice syntax.\n",
       "    \n",
       "    %recall foo+bar\n",
       "    \n",
       "    If foo+bar can be evaluated in the user namespace, the result is\n",
       "    placed at the next input prompt. Otherwise, the history is searched\n",
       "    for lines which contain that substring, and the most recent one is\n",
       "    placed at the next input prompt.\n",
       "%rehashx:\n",
       "    Update the alias table with all executable files in $PATH.\n",
       "    \n",
       "    rehashx explicitly checks that every entry in $PATH is a file\n",
       "    with execute access (os.X_OK).\n",
       "    \n",
       "    Under Windows, it checks executability as a match against a\n",
       "    '|'-separated string of extensions, stored in the IPython config\n",
       "    variable win_exec_ext.  This defaults to 'exe|com|bat'.\n",
       "    \n",
       "    This function also resets the root module cache of module completer,\n",
       "    used on slow filesystems.\n",
       "%reload_ext:\n",
       "    Reload an IPython extension by its module name.\n",
       "%rep:\n",
       "    Alias for `%recall`.\n",
       "%rerun:\n",
       "    Re-run previous input\n",
       "    \n",
       "    By default, you can specify ranges of input history to be repeated\n",
       "    (as with %history). With no arguments, it will repeat the last line.\n",
       "    \n",
       "    Options:\n",
       "    \n",
       "      -l <n> : Repeat the last n lines of input, not including the\n",
       "      current command.\n",
       "    \n",
       "      -g foo : Repeat the most recent line which contains foo\n",
       "%reset:\n",
       "    Resets the namespace by removing all names defined by the user, if\n",
       "    called without arguments, or by removing some types of objects, such\n",
       "    as everything currently in IPython's In[] and Out[] containers (see\n",
       "    the parameters for details).\n",
       "    \n",
       "    Parameters\n",
       "    ----------\n",
       "    -f : force reset without asking for confirmation.\n",
       "    \n",
       "    -s : 'Soft' reset: Only clears your namespace, leaving history intact.\n",
       "        References to objects may be kept. By default (without this option),\n",
       "        we do a 'hard' reset, giving you a new session and removing all\n",
       "        references to objects from the current session.\n",
       "    \n",
       "    in : reset input history\n",
       "    \n",
       "    out : reset output history\n",
       "    \n",
       "    dhist : reset directory history\n",
       "    \n",
       "    array : reset only variables that are NumPy arrays\n",
       "    \n",
       "    See Also\n",
       "    --------\n",
       "    reset_selective : invoked as ``%reset_selective``\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    ::\n",
       "    \n",
       "      In [6]: a = 1\n",
       "    \n",
       "      In [7]: a\n",
       "      Out[7]: 1\n",
       "    \n",
       "      In [8]: 'a' in get_ipython().user_ns\n",
       "      Out[8]: True\n",
       "    \n",
       "      In [9]: %reset -f\n",
       "    \n",
       "      In [1]: 'a' in get_ipython().user_ns\n",
       "      Out[1]: False\n",
       "    \n",
       "      In [2]: %reset -f in\n",
       "      Flushing input history\n",
       "    \n",
       "      In [3]: %reset -f dhist in\n",
       "      Flushing directory history\n",
       "      Flushing input history\n",
       "    \n",
       "    Notes\n",
       "    -----\n",
       "    Calling this magic from clients that do not implement standard input,\n",
       "    such as the ipython notebook interface, will reset the namespace\n",
       "    without confirmation.\n",
       "%reset_selective:\n",
       "    Resets the namespace by removing names defined by the user.\n",
       "    \n",
       "    Input/Output history are left around in case you need them.\n",
       "    \n",
       "    %reset_selective [-f] regex\n",
       "    \n",
       "    No action is taken if regex is not included\n",
       "    \n",
       "    Options\n",
       "      -f : force reset without asking for confirmation.\n",
       "    \n",
       "    See Also\n",
       "    --------\n",
       "    reset : invoked as ``%reset``\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    \n",
       "    We first fully reset the namespace so your output looks identical to\n",
       "    this example for pedagogical reasons; in practice you do not need a\n",
       "    full reset::\n",
       "    \n",
       "      In [1]: %reset -f\n",
       "    \n",
       "    Now, with a clean namespace we can make a few variables and use\n",
       "    ``%reset_selective`` to only delete names that match our regexp::\n",
       "    \n",
       "      In [2]: a=1; b=2; c=3; b1m=4; b2m=5; b3m=6; b4m=7; b2s=8\n",
       "    \n",
       "      In [3]: who_ls\n",
       "      Out[3]: ['a', 'b', 'b1m', 'b2m', 'b2s', 'b3m', 'b4m', 'c']\n",
       "    \n",
       "      In [4]: %reset_selective -f b[2-3]m\n",
       "    \n",
       "      In [5]: who_ls\n",
       "      Out[5]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']\n",
       "    \n",
       "      In [6]: %reset_selective -f d\n",
       "    \n",
       "      In [7]: who_ls\n",
       "      Out[7]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']\n",
       "    \n",
       "      In [8]: %reset_selective -f c\n",
       "    \n",
       "      In [9]: who_ls\n",
       "      Out[9]: ['a', 'b', 'b1m', 'b2s', 'b4m']\n",
       "    \n",
       "      In [10]: %reset_selective -f b\n",
       "    \n",
       "      In [11]: who_ls\n",
       "      Out[11]: ['a']\n",
       "    \n",
       "    Notes\n",
       "    -----\n",
       "    Calling this magic from clients that do not implement standard input,\n",
       "    such as the ipython notebook interface, will reset the namespace\n",
       "    without confirmation.\n",
       "%rm:\n",
       "    Alias for `!rm`\n",
       "%rmdir:\n",
       "    Alias for `!rmdir`\n",
       "%run:\n",
       "    Run the named file inside IPython as a program.\n",
       "    \n",
       "    Usage::\n",
       "    \n",
       "      %run [-n -i -e -G]\n",
       "           [( -t [-N<N>] | -d [-b<N>] | -p [profile options] )]\n",
       "           ( -m mod | file ) [args]\n",
       "    \n",
       "    Parameters after the filename are passed as command-line arguments to\n",
       "    the program (put in sys.argv). Then, control returns to IPython's\n",
       "    prompt.\n",
       "    \n",
       "    This is similar to running at a system prompt ``python file args``,\n",
       "    but with the advantage of giving you IPython's tracebacks, and of\n",
       "    loading all variables into your interactive namespace for further use\n",
       "    (unless -p is used, see below).\n",
       "    \n",
       "    The file is executed in a namespace initially consisting only of\n",
       "    ``__name__=='__main__'`` and sys.argv constructed as indicated. It thus\n",
       "    sees its environment as if it were being run as a stand-alone program\n",
       "    (except for sharing global objects such as previously imported\n",
       "    modules). But after execution, the IPython interactive namespace gets\n",
       "    updated with all variables defined in the program (except for __name__\n",
       "    and sys.argv). This allows for very convenient loading of code for\n",
       "    interactive work, while giving each program a 'clean sheet' to run in.\n",
       "    \n",
       "    Arguments are expanded using shell-like glob match.  Patterns\n",
       "    '*', '?', '[seq]' and '[!seq]' can be used.  Additionally,\n",
       "    tilde '~' will be expanded into user's home directory.  Unlike\n",
       "    real shells, quotation does not suppress expansions.  Use\n",
       "    *two* back slashes (e.g. ``\\\\*``) to suppress expansions.\n",
       "    To completely disable these expansions, you can use -G flag.\n",
       "    \n",
       "    On Windows systems, the use of single quotes `'` when specifying \n",
       "    a file is not supported. Use double quotes `\"`.\n",
       "    \n",
       "    Options:\n",
       "    \n",
       "    -n\n",
       "      __name__ is NOT set to '__main__', but to the running file's name\n",
       "      without extension (as python does under import).  This allows running\n",
       "      scripts and reloading the definitions in them without calling code\n",
       "      protected by an ``if __name__ == \"__main__\"`` clause.\n",
       "    \n",
       "    -i\n",
       "      run the file in IPython's namespace instead of an empty one. This\n",
       "      is useful if you are experimenting with code written in a text editor\n",
       "      which depends on variables defined interactively.\n",
       "    \n",
       "    -e\n",
       "      ignore sys.exit() calls or SystemExit exceptions in the script\n",
       "      being run.  This is particularly useful if IPython is being used to\n",
       "      run unittests, which always exit with a sys.exit() call.  In such\n",
       "      cases you are interested in the output of the test results, not in\n",
       "      seeing a traceback of the unittest module.\n",
       "    \n",
       "    -t\n",
       "      print timing information at the end of the run.  IPython will give\n",
       "      you an estimated CPU time consumption for your script, which under\n",
       "      Unix uses the resource module to avoid the wraparound problems of\n",
       "      time.clock().  Under Unix, an estimate of time spent on system tasks\n",
       "      is also given (for Windows platforms this is reported as 0.0).\n",
       "    \n",
       "    If -t is given, an additional ``-N<N>`` option can be given, where <N>\n",
       "    must be an integer indicating how many times you want the script to\n",
       "    run.  The final timing report will include total and per run results.\n",
       "    \n",
       "    For example (testing the script uniq_stable.py)::\n",
       "    \n",
       "        In [1]: run -t uniq_stable\n",
       "    \n",
       "        IPython CPU timings (estimated):\n",
       "          User  :    0.19597 s.\n",
       "          System:        0.0 s.\n",
       "    \n",
       "        In [2]: run -t -N5 uniq_stable\n",
       "    \n",
       "        IPython CPU timings (estimated):\n",
       "        Total runs performed: 5\n",
       "          Times :      Total       Per run\n",
       "          User  :   0.910862 s,  0.1821724 s.\n",
       "          System:        0.0 s,        0.0 s.\n",
       "    \n",
       "    -d\n",
       "      run your program under the control of pdb, the Python debugger.\n",
       "      This allows you to execute your program step by step, watch variables,\n",
       "      etc.  Internally, what IPython does is similar to calling::\n",
       "    \n",
       "          pdb.run('execfile(\"YOURFILENAME\")')\n",
       "    \n",
       "      with a breakpoint set on line 1 of your file.  You can change the line\n",
       "      number for this automatic breakpoint to be <N> by using the -bN option\n",
       "      (where N must be an integer). For example::\n",
       "    \n",
       "          %run -d -b40 myscript\n",
       "    \n",
       "      will set the first breakpoint at line 40 in myscript.py.  Note that\n",
       "      the first breakpoint must be set on a line which actually does\n",
       "      something (not a comment or docstring) for it to stop execution.\n",
       "    \n",
       "      Or you can specify a breakpoint in a different file::\n",
       "    \n",
       "          %run -d -b myotherfile.py:20 myscript\n",
       "    \n",
       "      When the pdb debugger starts, you will see a (Pdb) prompt.  You must\n",
       "      first enter 'c' (without quotes) to start execution up to the first\n",
       "      breakpoint.\n",
       "    \n",
       "      Entering 'help' gives information about the use of the debugger.  You\n",
       "      can easily see pdb's full documentation with \"import pdb;pdb.help()\"\n",
       "      at a prompt.\n",
       "    \n",
       "    -p\n",
       "      run program under the control of the Python profiler module (which\n",
       "      prints a detailed report of execution times, function calls, etc).\n",
       "    \n",
       "      You can pass other options after -p which affect the behavior of the\n",
       "      profiler itself. See the docs for %prun for details.\n",
       "    \n",
       "      In this mode, the program's variables do NOT propagate back to the\n",
       "      IPython interactive namespace (because they remain in the namespace\n",
       "      where the profiler executes them).\n",
       "    \n",
       "      Internally this triggers a call to %prun, see its documentation for\n",
       "      details on the options available specifically for profiling.\n",
       "    \n",
       "    There is one special usage for which the text above doesn't apply:\n",
       "    if the filename ends with .ipy[nb], the file is run as ipython script,\n",
       "    just as if the commands were written on IPython prompt.\n",
       "    \n",
       "    -m\n",
       "      specify module name to load instead of script path. Similar to\n",
       "      the -m option for the python interpreter. Use this option last if you\n",
       "      want to combine with other %run options. Unlike the python interpreter\n",
       "      only source modules are allowed no .pyc or .pyo files.\n",
       "      For example::\n",
       "    \n",
       "          %run -m example\n",
       "    \n",
       "      will run the example module.\n",
       "    \n",
       "    -G\n",
       "      disable shell-like glob expansion of arguments.\n",
       "%save:\n",
       "    Save a set of lines or a macro to a given filename.\n",
       "    \n",
       "    Usage:\n",
       "      %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...\n",
       "    \n",
       "    Options:\n",
       "    \n",
       "      -r: use 'raw' input.  By default, the 'processed' history is used,\n",
       "      so that magics are loaded in their transformed version to valid\n",
       "      Python.  If this option is given, the raw input as typed as the\n",
       "      command line is used instead.\n",
       "    \n",
       "      -f: force overwrite.  If file exists, %save will prompt for overwrite\n",
       "      unless -f is given.\n",
       "    \n",
       "      -a: append to the file instead of overwriting it.\n",
       "    \n",
       "    This function uses the same syntax as %history for input ranges,\n",
       "    then saves the lines to the filename you specify.\n",
       "    \n",
       "    It adds a '.py' extension to the file if you don't do so yourself, and\n",
       "    it asks for confirmation before overwriting existing files.\n",
       "    \n",
       "    If `-r` option is used, the default extension is `.ipy`.\n",
       "%sc:\n",
       "    Shell capture - run shell command and capture output (DEPRECATED use !).\n",
       "    \n",
       "    DEPRECATED. Suboptimal, retained for backwards compatibility.\n",
       "    \n",
       "    You should use the form 'var = !command' instead. Example:\n",
       "    \n",
       "     \"%sc -l myfiles = ls ~\" should now be written as\n",
       "    \n",
       "     \"myfiles = !ls ~\"\n",
       "    \n",
       "    myfiles.s, myfiles.l and myfiles.n still apply as documented\n",
       "    below.\n",
       "    \n",
       "    --\n",
       "    %sc [options] varname=command\n",
       "    \n",
       "    IPython will run the given command using commands.getoutput(), and\n",
       "    will then update the user's interactive namespace with a variable\n",
       "    called varname, containing the value of the call.  Your command can\n",
       "    contain shell wildcards, pipes, etc.\n",
       "    \n",
       "    The '=' sign in the syntax is mandatory, and the variable name you\n",
       "    supply must follow Python's standard conventions for valid names.\n",
       "    \n",
       "    (A special format without variable name exists for internal use)\n",
       "    \n",
       "    Options:\n",
       "    \n",
       "      -l: list output.  Split the output on newlines into a list before\n",
       "      assigning it to the given variable.  By default the output is stored\n",
       "      as a single string.\n",
       "    \n",
       "      -v: verbose.  Print the contents of the variable.\n",
       "    \n",
       "    In most cases you should not need to split as a list, because the\n",
       "    returned value is a special type of string which can automatically\n",
       "    provide its contents either as a list (split on newlines) or as a\n",
       "    space-separated string.  These are convenient, respectively, either\n",
       "    for sequential processing or to be passed to a shell command.\n",
       "    \n",
       "    For example::\n",
       "    \n",
       "        # Capture into variable a\n",
       "        In [1]: sc a=ls *py\n",
       "    \n",
       "        # a is a string with embedded newlines\n",
       "        In [2]: a\n",
       "        Out[2]: 'setup.py\\nwin32_manual_post_install.py'\n",
       "    \n",
       "        # which can be seen as a list:\n",
       "        In [3]: a.l\n",
       "        Out[3]: ['setup.py', 'win32_manual_post_install.py']\n",
       "    \n",
       "        # or as a whitespace-separated string:\n",
       "        In [4]: a.s\n",
       "        Out[4]: 'setup.py win32_manual_post_install.py'\n",
       "    \n",
       "        # a.s is useful to pass as a single command line:\n",
       "        In [5]: !wc -l $a.s\n",
       "          146 setup.py\n",
       "          130 win32_manual_post_install.py\n",
       "          276 total\n",
       "    \n",
       "        # while the list form is useful to loop over:\n",
       "        In [6]: for f in a.l:\n",
       "          ...:      !wc -l $f\n",
       "          ...:\n",
       "        146 setup.py\n",
       "        130 win32_manual_post_install.py\n",
       "    \n",
       "    Similarly, the lists returned by the -l option are also special, in\n",
       "    the sense that you can equally invoke the .s attribute on them to\n",
       "    automatically get a whitespace-separated string from their contents::\n",
       "    \n",
       "        In [7]: sc -l b=ls *py\n",
       "    \n",
       "        In [8]: b\n",
       "        Out[8]: ['setup.py', 'win32_manual_post_install.py']\n",
       "    \n",
       "        In [9]: b.s\n",
       "        Out[9]: 'setup.py win32_manual_post_install.py'\n",
       "    \n",
       "    In summary, both the lists and strings used for output capture have\n",
       "    the following special attributes::\n",
       "    \n",
       "        .l (or .list) : value as list.\n",
       "        .n (or .nlstr): value as newline-separated string.\n",
       "        .s (or .spstr): value as space-separated string.\n",
       "%set_env:\n",
       "    Set environment variables.  Assumptions are that either \"val\" is a\n",
       "    name in the user namespace, or val is something that evaluates to a\n",
       "    string.\n",
       "    \n",
       "    Usage:\n",
       "      %set_env var val: set value for var\n",
       "      %set_env var=val: set value for var\n",
       "      %set_env var=$val: set value for var, using python expansion if possible\n",
       "%store:\n",
       "    Lightweight persistence for python variables.\n",
       "    \n",
       "    Example::\n",
       "    \n",
       "      In [1]: l = ['hello',10,'world']\n",
       "      In [2]: %store l\n",
       "      In [3]: exit\n",
       "    \n",
       "      (IPython session is closed and started again...)\n",
       "    \n",
       "      ville@badger:~$ ipython\n",
       "      In [1]: l\n",
       "      NameError: name 'l' is not defined\n",
       "      In [2]: %store -r\n",
       "      In [3]: l\n",
       "      Out[3]: ['hello', 10, 'world']\n",
       "    \n",
       "    Usage:\n",
       "    \n",
       "    * ``%store``          - Show list of all variables and their current\n",
       "                            values\n",
       "    * ``%store spam bar`` - Store the *current* value of the variables spam\n",
       "                            and bar to disk\n",
       "    * ``%store -d spam``  - Remove the variable and its value from storage\n",
       "    * ``%store -z``       - Remove all variables from storage\n",
       "    * ``%store -r``       - Refresh all variables, aliases and directory history\n",
       "                            from store (overwrite current vals)\n",
       "    * ``%store -r spam bar`` - Refresh specified variables and aliases from store\n",
       "                               (delete current val)\n",
       "    * ``%store foo >a.txt``  - Store value of foo to new file a.txt\n",
       "    * ``%store foo >>a.txt`` - Append value of foo to file a.txt\n",
       "    \n",
       "    It should be noted that if you change the value of a variable, you\n",
       "    need to %store it again if you want to persist the new value.\n",
       "    \n",
       "    Note also that the variables will need to be pickleable; most basic\n",
       "    python types can be safely %store'd.\n",
       "    \n",
       "    Also aliases can be %store'd across sessions.\n",
       "    To remove an alias from the storage, use the %unalias magic.\n",
       "%sx:\n",
       "    Shell execute - run shell command and capture output (!! is short-hand).\n",
       "    \n",
       "    %sx command\n",
       "    \n",
       "    IPython will run the given command using commands.getoutput(), and\n",
       "    return the result formatted as a list (split on '\\n').  Since the\n",
       "    output is _returned_, it will be stored in ipython's regular output\n",
       "    cache Out[N] and in the '_N' automatic variables.\n",
       "    \n",
       "    Notes:\n",
       "    \n",
       "    1) If an input line begins with '!!', then %sx is automatically\n",
       "    invoked.  That is, while::\n",
       "    \n",
       "      !ls\n",
       "    \n",
       "    causes ipython to simply issue system('ls'), typing::\n",
       "    \n",
       "      !!ls\n",
       "    \n",
       "    is a shorthand equivalent to::\n",
       "    \n",
       "      %sx ls\n",
       "    \n",
       "    2) %sx differs from %sc in that %sx automatically splits into a list,\n",
       "    like '%sc -l'.  The reason for this is to make it as easy as possible\n",
       "    to process line-oriented shell output via further python commands.\n",
       "    %sc is meant to provide much finer control, but requires more\n",
       "    typing.\n",
       "    \n",
       "    3) Just like %sc -l, this is a list with special attributes:\n",
       "    ::\n",
       "    \n",
       "      .l (or .list) : value as list.\n",
       "      .n (or .nlstr): value as newline-separated string.\n",
       "      .s (or .spstr): value as whitespace-separated string.\n",
       "    \n",
       "    This is very useful when trying to use such lists as arguments to\n",
       "    system commands.\n",
       "%system:\n",
       "    Shell execute - run shell command and capture output (!! is short-hand).\n",
       "    \n",
       "    %sx command\n",
       "    \n",
       "    IPython will run the given command using commands.getoutput(), and\n",
       "    return the result formatted as a list (split on '\\n').  Since the\n",
       "    output is _returned_, it will be stored in ipython's regular output\n",
       "    cache Out[N] and in the '_N' automatic variables.\n",
       "    \n",
       "    Notes:\n",
       "    \n",
       "    1) If an input line begins with '!!', then %sx is automatically\n",
       "    invoked.  That is, while::\n",
       "    \n",
       "      !ls\n",
       "    \n",
       "    causes ipython to simply issue system('ls'), typing::\n",
       "    \n",
       "      !!ls\n",
       "    \n",
       "    is a shorthand equivalent to::\n",
       "    \n",
       "      %sx ls\n",
       "    \n",
       "    2) %sx differs from %sc in that %sx automatically splits into a list,\n",
       "    like '%sc -l'.  The reason for this is to make it as easy as possible\n",
       "    to process line-oriented shell output via further python commands.\n",
       "    %sc is meant to provide much finer control, but requires more\n",
       "    typing.\n",
       "    \n",
       "    3) Just like %sc -l, this is a list with special attributes:\n",
       "    ::\n",
       "    \n",
       "      .l (or .list) : value as list.\n",
       "      .n (or .nlstr): value as newline-separated string.\n",
       "      .s (or .spstr): value as whitespace-separated string.\n",
       "    \n",
       "    This is very useful when trying to use such lists as arguments to\n",
       "    system commands.\n",
       "%tb:\n",
       "    Print the last traceback.\n",
       "    \n",
       "    Optionally, specify an exception reporting mode, tuning the\n",
       "    verbosity of the traceback. By default the currently-active exception\n",
       "    mode is used. See %xmode for changing exception reporting modes.\n",
       "    \n",
       "    Valid modes: Plain, Context, Verbose, and Minimal.\n",
       "%time:\n",
       "    Time execution of a Python statement or expression.\n",
       "    \n",
       "    The CPU and wall clock times are printed, and the value of the\n",
       "    expression (if any) is returned.  Note that under Win32, system time\n",
       "    is always reported as 0, since it can not be measured.\n",
       "    \n",
       "    This function can be used both as a line and cell magic:\n",
       "    \n",
       "    - In line mode you can time a single-line statement (though multiple\n",
       "      ones can be chained with using semicolons).\n",
       "    \n",
       "    - In cell mode, you can time the cell body (a directly\n",
       "      following statement raises an error).\n",
       "    \n",
       "    This function provides very basic timing functionality.  Use the timeit\n",
       "    magic for more control over the measurement.\n",
       "    \n",
       "    .. versionchanged:: 7.3\n",
       "        User variables are no longer expanded,\n",
       "        the magic line is always left unmodified.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    ::\n",
       "    \n",
       "      In [1]: %time 2**128\n",
       "      CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s\n",
       "      Wall time: 0.00\n",
       "      Out[1]: 340282366920938463463374607431768211456L\n",
       "    \n",
       "      In [2]: n = 1000000\n",
       "    \n",
       "      In [3]: %time sum(range(n))\n",
       "      CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s\n",
       "      Wall time: 1.37\n",
       "      Out[3]: 499999500000L\n",
       "    \n",
       "      In [4]: %time print 'hello world'\n",
       "      hello world\n",
       "      CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s\n",
       "      Wall time: 0.00\n",
       "    \n",
       "      Note that the time needed by Python to compile the given expression\n",
       "      will be reported if it is more than 0.1s.  In this example, the\n",
       "      actual exponentiation is done by Python at compilation time, so while\n",
       "      the expression can take a noticeable amount of time to compute, that\n",
       "      time is purely due to the compilation:\n",
       "    \n",
       "      In [5]: %time 3**9999;\n",
       "      CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s\n",
       "      Wall time: 0.00 s\n",
       "    \n",
       "      In [6]: %time 3**999999;\n",
       "      CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s\n",
       "      Wall time: 0.00 s\n",
       "      Compiler : 0.78 s\n",
       "%timeit:\n",
       "    Time execution of a Python statement or expression\n",
       "    \n",
       "    Usage, in line mode:\n",
       "      %timeit [-n<N> -r<R> [-t|-c] -q -p<P> -o] statement\n",
       "    or in cell mode:\n",
       "      %%timeit [-n<N> -r<R> [-t|-c] -q -p<P> -o] setup_code\n",
       "      code\n",
       "      code...\n",
       "    \n",
       "    Time execution of a Python statement or expression using the timeit\n",
       "    module.  This function can be used both as a line and cell magic:\n",
       "    \n",
       "    - In line mode you can time a single-line statement (though multiple\n",
       "      ones can be chained with using semicolons).\n",
       "    \n",
       "    - In cell mode, the statement in the first line is used as setup code\n",
       "      (executed but not timed) and the body of the cell is timed.  The cell\n",
       "      body has access to any variables created in the setup code.\n",
       "    \n",
       "    Options:\n",
       "    -n<N>: execute the given statement <N> times in a loop. If <N> is not\n",
       "    provided, <N> is determined so as to get sufficient accuracy.\n",
       "    \n",
       "    -r<R>: number of repeats <R>, each consisting of <N> loops, and take the\n",
       "    best result.\n",
       "    Default: 7\n",
       "    \n",
       "    -t: use time.time to measure the time, which is the default on Unix.\n",
       "    This function measures wall time.\n",
       "    \n",
       "    -c: use time.clock to measure the time, which is the default on\n",
       "    Windows and measures wall time. On Unix, resource.getrusage is used\n",
       "    instead and returns the CPU user time.\n",
       "    \n",
       "    -p<P>: use a precision of <P> digits to display the timing result.\n",
       "    Default: 3\n",
       "    \n",
       "    -q: Quiet, do not print result.\n",
       "    \n",
       "    -o: return a TimeitResult that can be stored in a variable to inspect\n",
       "        the result in more details.\n",
       "    \n",
       "    .. versionchanged:: 7.3\n",
       "        User variables are no longer expanded,\n",
       "        the magic line is always left unmodified.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    ::\n",
       "    \n",
       "      In [1]: %timeit pass\n",
       "      8.26 ns ± 0.12 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)\n",
       "    \n",
       "      In [2]: u = None\n",
       "    \n",
       "      In [3]: %timeit u is None\n",
       "      29.9 ns ± 0.643 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n",
       "    \n",
       "      In [4]: %timeit -r 4 u == None\n",
       "    \n",
       "      In [5]: import time\n",
       "    \n",
       "      In [6]: %timeit -n1 time.sleep(2)\n",
       "    \n",
       "    \n",
       "    The times reported by %timeit will be slightly higher than those\n",
       "    reported by the timeit.py script when variables are accessed. This is\n",
       "    due to the fact that %timeit executes the statement in the namespace\n",
       "    of the shell, compared with timeit.py, which uses a single setup\n",
       "    statement to import function or create variables. Generally, the bias\n",
       "    does not matter as long as results from timeit.py are not mixed with\n",
       "    those from %timeit.\n",
       "%unalias:\n",
       "    Remove an alias\n",
       "%unload_ext:\n",
       "    Unload an IPython extension by its module name.\n",
       "    \n",
       "    Not all extensions can be unloaded, only those which define an\n",
       "    ``unload_ipython_extension`` function.\n",
       "%who:\n",
       "    Print all interactive variables, with some minimal formatting.\n",
       "    \n",
       "    If any arguments are given, only variables whose type matches one of\n",
       "    these are printed.  For example::\n",
       "    \n",
       "      %who function str\n",
       "    \n",
       "    will only list functions and strings, excluding all other types of\n",
       "    variables.  To find the proper type names, simply use type(var) at a\n",
       "    command line to see how python prints type names.  For example:\n",
       "    \n",
       "    ::\n",
       "    \n",
       "      In [1]: type('hello')\n",
       "      Out[1]: <type 'str'>\n",
       "    \n",
       "    indicates that the type name for strings is 'str'.\n",
       "    \n",
       "    ``%who`` always excludes executed names loaded through your configuration\n",
       "    file and things which are internal to IPython.\n",
       "    \n",
       "    This is deliberate, as typically you may load many modules and the\n",
       "    purpose of %who is to show you only what you've manually defined.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    \n",
       "    Define two variables and list them with who::\n",
       "    \n",
       "      In [1]: alpha = 123\n",
       "    \n",
       "      In [2]: beta = 'test'\n",
       "    \n",
       "      In [3]: %who\n",
       "      alpha   beta\n",
       "    \n",
       "      In [4]: %who int\n",
       "      alpha\n",
       "    \n",
       "      In [5]: %who str\n",
       "      beta\n",
       "%who_ls:\n",
       "    Return a sorted list of all interactive variables.\n",
       "    \n",
       "    If arguments are given, only variables of types matching these\n",
       "    arguments are returned.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    \n",
       "    Define two variables and list them with who_ls::\n",
       "    \n",
       "      In [1]: alpha = 123\n",
       "    \n",
       "      In [2]: beta = 'test'\n",
       "    \n",
       "      In [3]: %who_ls\n",
       "      Out[3]: ['alpha', 'beta']\n",
       "    \n",
       "      In [4]: %who_ls int\n",
       "      Out[4]: ['alpha']\n",
       "    \n",
       "      In [5]: %who_ls str\n",
       "      Out[5]: ['beta']\n",
       "%whos:\n",
       "    Like %who, but gives some extra information about each variable.\n",
       "    \n",
       "    The same type filtering of %who can be applied here.\n",
       "    \n",
       "    For all variables, the type is printed. Additionally it prints:\n",
       "    \n",
       "      - For {},[],(): their length.\n",
       "    \n",
       "      - For numpy arrays, a summary with shape, number of\n",
       "        elements, typecode and size in memory.\n",
       "    \n",
       "      - Everything else: a string representation, snipping their middle if\n",
       "        too long.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    \n",
       "    Define two variables and list them with whos::\n",
       "    \n",
       "      In [1]: alpha = 123\n",
       "    \n",
       "      In [2]: beta = 'test'\n",
       "    \n",
       "      In [3]: %whos\n",
       "      Variable   Type        Data/Info\n",
       "      --------------------------------\n",
       "      alpha      int         123\n",
       "      beta       str         test\n",
       "%xdel:\n",
       "    Delete a variable, trying to clear it from anywhere that\n",
       "    IPython's machinery has references to it. By default, this uses\n",
       "    the identity of the named object in the user namespace to remove\n",
       "    references held under other names. The object is also removed\n",
       "    from the output history.\n",
       "    \n",
       "    Options\n",
       "      -n : Delete the specified name from all namespaces, without\n",
       "      checking their identity.\n",
       "%xmode:\n",
       "    Switch modes for the exception handlers.\n",
       "    \n",
       "    Valid modes: Plain, Context, Verbose, and Minimal.\n",
       "    \n",
       "    If called without arguments, acts as a toggle.\n",
       "    \n",
       "    When in verbose mode the value --show (and --hide) \n",
       "    will respectively show (or hide) frames with ``__tracebackhide__ =\n",
       "    True`` value set.\n",
       "%%!:\n",
       "    Shell execute - run shell command and capture output (!! is short-hand).\n",
       "    \n",
       "    %sx command\n",
       "    \n",
       "    IPython will run the given command using commands.getoutput(), and\n",
       "    return the result formatted as a list (split on '\\n').  Since the\n",
       "    output is _returned_, it will be stored in ipython's regular output\n",
       "    cache Out[N] and in the '_N' automatic variables.\n",
       "    \n",
       "    Notes:\n",
       "    \n",
       "    1) If an input line begins with '!!', then %sx is automatically\n",
       "    invoked.  That is, while::\n",
       "    \n",
       "      !ls\n",
       "    \n",
       "    causes ipython to simply issue system('ls'), typing::\n",
       "    \n",
       "      !!ls\n",
       "    \n",
       "    is a shorthand equivalent to::\n",
       "    \n",
       "      %sx ls\n",
       "    \n",
       "    2) %sx differs from %sc in that %sx automatically splits into a list,\n",
       "    like '%sc -l'.  The reason for this is to make it as easy as possible\n",
       "    to process line-oriented shell output via further python commands.\n",
       "    %sc is meant to provide much finer control, but requires more\n",
       "    typing.\n",
       "    \n",
       "    3) Just like %sc -l, this is a list with special attributes:\n",
       "    ::\n",
       "    \n",
       "      .l (or .list) : value as list.\n",
       "      .n (or .nlstr): value as newline-separated string.\n",
       "      .s (or .spstr): value as whitespace-separated string.\n",
       "    \n",
       "    This is very useful when trying to use such lists as arguments to\n",
       "    system commands.\n",
       "%%HTML:\n",
       "    Alias for `%%html`.\n",
       "%%SVG:\n",
       "    Alias for `%%svg`.\n",
       "%%bash:\n",
       "    %%bash script magic\n",
       "    \n",
       "    Run cells with bash in a subprocess.\n",
       "    \n",
       "    This is a shortcut for `%%script bash`\n",
       "%%capture:\n",
       "    ::\n",
       "    \n",
       "      %capture [--no-stderr] [--no-stdout] [--no-display] [output]\n",
       "    \n",
       "    run the cell, capturing stdout, stderr, and IPython's rich display() calls.\n",
       "    \n",
       "    positional arguments:\n",
       "      output        The name of the variable in which to store output. This is a utils.io.CapturedIO object with stdout/err attributes for the text of the captured output. CapturedOutput also has a show()\n",
       "                    method for displaying the output, and __call__ as well, so you can use that to quickly display the output. If unspecified, captured output is discarded.\n",
       "    \n",
       "    optional arguments:\n",
       "      --no-stderr   Don't capture stderr.\n",
       "      --no-stdout   Don't capture stdout.\n",
       "      --no-display  Don't capture IPython's rich display.\n",
       "%%debug:\n",
       "    ::\n",
       "    \n",
       "      %debug [--breakpoint FILE:LINE] [statement [statement ...]]\n",
       "    \n",
       "    Activate the interactive debugger.\n",
       "    \n",
       "    This magic command support two ways of activating debugger.\n",
       "    One is to activate debugger before executing code.  This way, you\n",
       "    can set a break point, to step through the code from the point.\n",
       "    You can use this mode by giving statements to execute and optionally\n",
       "    a breakpoint.\n",
       "    \n",
       "    The other one is to activate debugger in post-mortem mode.  You can\n",
       "    activate this mode simply running %debug without any argument.\n",
       "    If an exception has just occurred, this lets you inspect its stack\n",
       "    frames interactively.  Note that this will always work only on the last\n",
       "    traceback that occurred, so you must call this quickly after an\n",
       "    exception that you wish to inspect has fired, because if another one\n",
       "    occurs, it clobbers the previous one.\n",
       "    \n",
       "    If you want IPython to automatically do this on every exception, see\n",
       "    the %pdb magic for more details.\n",
       "    \n",
       "    .. versionchanged:: 7.3\n",
       "        When running code, user variables are no longer expanded,\n",
       "        the magic line is always left unmodified.\n",
       "    \n",
       "    positional arguments:\n",
       "      statement             Code to run in debugger. You can omit this in cell magic mode.\n",
       "    \n",
       "    optional arguments:\n",
       "      --breakpoint <FILE:LINE>, -b <FILE:LINE>\n",
       "                            Set break point at LINE in FILE.\n",
       "%%file:\n",
       "    Alias for `%%writefile`.\n",
       "%%html:\n",
       "    ::\n",
       "    \n",
       "      %html [--isolated]\n",
       "    \n",
       "    Render the cell as a block of HTML\n",
       "    \n",
       "    optional arguments:\n",
       "      --isolated  Annotate the cell as 'isolated'. Isolated cells are rendered inside their own <iframe> tag\n",
       "%%javascript:\n",
       "    Run the cell block of Javascript code\n",
       "%%js:\n",
       "    Run the cell block of Javascript code\n",
       "    \n",
       "    Alias of `%%javascript`\n",
       "%%latex:\n",
       "    Render the cell as a block of latex\n",
       "    \n",
       "    The subset of latex which is support depends on the implementation in\n",
       "    the client.  In the Jupyter Notebook, this magic only renders the subset\n",
       "    of latex defined by MathJax\n",
       "    [here](https://docs.mathjax.org/en/v2.5-latest/tex.html).\n",
       "%%markdown:\n",
       "    Render the cell as Markdown text block\n",
       "%%perl:\n",
       "    %%perl script magic\n",
       "    \n",
       "    Run cells with perl in a subprocess.\n",
       "    \n",
       "    This is a shortcut for `%%script perl`\n",
       "%%prun:\n",
       "    Run a statement through the python code profiler.\n",
       "    \n",
       "    Usage, in line mode:\n",
       "      %prun [options] statement\n",
       "    \n",
       "    Usage, in cell mode:\n",
       "      %%prun [options] [statement]\n",
       "      code...\n",
       "      code...\n",
       "    \n",
       "    In cell mode, the additional code lines are appended to the (possibly\n",
       "    empty) statement in the first line.  Cell mode allows you to easily\n",
       "    profile multiline blocks without having to put them in a separate\n",
       "    function.\n",
       "    \n",
       "    The given statement (which doesn't require quote marks) is run via the\n",
       "    python profiler in a manner similar to the profile.run() function.\n",
       "    Namespaces are internally managed to work correctly; profile.run\n",
       "    cannot be used in IPython because it makes certain assumptions about\n",
       "    namespaces which do not hold under IPython.\n",
       "    \n",
       "    Options:\n",
       "    \n",
       "    -l <limit>\n",
       "      you can place restrictions on what or how much of the\n",
       "      profile gets printed. The limit value can be:\n",
       "    \n",
       "         * A string: only information for function names containing this string\n",
       "           is printed.\n",
       "    \n",
       "         * An integer: only these many lines are printed.\n",
       "    \n",
       "         * A float (between 0 and 1): this fraction of the report is printed\n",
       "           (for example, use a limit of 0.4 to see the topmost 40% only).\n",
       "    \n",
       "      You can combine several limits with repeated use of the option. For\n",
       "      example, ``-l __init__ -l 5`` will print only the topmost 5 lines of\n",
       "      information about class constructors.\n",
       "    \n",
       "    -r\n",
       "      return the pstats.Stats object generated by the profiling. This\n",
       "      object has all the information about the profile in it, and you can\n",
       "      later use it for further analysis or in other functions.\n",
       "    \n",
       "    -s <key>\n",
       "      sort profile by given key. You can provide more than one key\n",
       "      by using the option several times: '-s key1 -s key2 -s key3...'. The\n",
       "      default sorting key is 'time'.\n",
       "    \n",
       "      The following is copied verbatim from the profile documentation\n",
       "      referenced below:\n",
       "    \n",
       "      When more than one key is provided, additional keys are used as\n",
       "      secondary criteria when the there is equality in all keys selected\n",
       "      before them.\n",
       "    \n",
       "      Abbreviations can be used for any key names, as long as the\n",
       "      abbreviation is unambiguous.  The following are the keys currently\n",
       "      defined:\n",
       "    \n",
       "      ============  =====================\n",
       "      Valid Arg     Meaning\n",
       "      ============  =====================\n",
       "      \"calls\"       call count\n",
       "      \"cumulative\"  cumulative time\n",
       "      \"file\"        file name\n",
       "      \"module\"      file name\n",
       "      \"pcalls\"      primitive call count\n",
       "      \"line\"        line number\n",
       "      \"name\"        function name\n",
       "      \"nfl\"         name/file/line\n",
       "      \"stdname\"     standard name\n",
       "      \"time\"        internal time\n",
       "      ============  =====================\n",
       "    \n",
       "      Note that all sorts on statistics are in descending order (placing\n",
       "      most time consuming items first), where as name, file, and line number\n",
       "      searches are in ascending order (i.e., alphabetical). The subtle\n",
       "      distinction between \"nfl\" and \"stdname\" is that the standard name is a\n",
       "      sort of the name as printed, which means that the embedded line\n",
       "      numbers get compared in an odd way.  For example, lines 3, 20, and 40\n",
       "      would (if the file names were the same) appear in the string order\n",
       "      \"20\" \"3\" and \"40\".  In contrast, \"nfl\" does a numeric compare of the\n",
       "      line numbers.  In fact, sort_stats(\"nfl\") is the same as\n",
       "      sort_stats(\"name\", \"file\", \"line\").\n",
       "    \n",
       "    -T <filename>\n",
       "      save profile results as shown on screen to a text\n",
       "      file. The profile is still shown on screen.\n",
       "    \n",
       "    -D <filename>\n",
       "      save (via dump_stats) profile statistics to given\n",
       "      filename. This data is in a format understood by the pstats module, and\n",
       "      is generated by a call to the dump_stats() method of profile\n",
       "      objects. The profile is still shown on screen.\n",
       "    \n",
       "    -q\n",
       "      suppress output to the pager.  Best used with -T and/or -D above.\n",
       "    \n",
       "    If you want to run complete programs under the profiler's control, use\n",
       "    ``%run -p [prof_opts] filename.py [args to program]`` where prof_opts\n",
       "    contains profiler specific options as described here.\n",
       "    \n",
       "    You can read the complete documentation for the profile module with::\n",
       "    \n",
       "      In [1]: import profile; profile.help()\n",
       "    \n",
       "    .. versionchanged:: 7.3\n",
       "        User variables are no longer expanded,\n",
       "        the magic line is always left unmodified.\n",
       "%%pypy:\n",
       "    %%pypy script magic\n",
       "    \n",
       "    Run cells with pypy in a subprocess.\n",
       "    \n",
       "    This is a shortcut for `%%script pypy`\n",
       "%%python:\n",
       "    %%python script magic\n",
       "    \n",
       "    Run cells with python in a subprocess.\n",
       "    \n",
       "    This is a shortcut for `%%script python`\n",
       "%%python2:\n",
       "    %%python2 script magic\n",
       "    \n",
       "    Run cells with python2 in a subprocess.\n",
       "    \n",
       "    This is a shortcut for `%%script python2`\n",
       "%%python3:\n",
       "    %%python3 script magic\n",
       "    \n",
       "    Run cells with python3 in a subprocess.\n",
       "    \n",
       "    This is a shortcut for `%%script python3`\n",
       "%%ruby:\n",
       "    %%ruby script magic\n",
       "    \n",
       "    Run cells with ruby in a subprocess.\n",
       "    \n",
       "    This is a shortcut for `%%script ruby`\n",
       "%%script:\n",
       "    ::\n",
       "    \n",
       "      %shebang [--no-raise-error] [--proc PROC] [--bg] [--err ERR] [--out OUT]\n",
       "    \n",
       "    Run a cell via a shell command\n",
       "    \n",
       "    The `%%script` line is like the #! line of script,\n",
       "    specifying a program (bash, perl, ruby, etc.) with which to run.\n",
       "    \n",
       "    The rest of the cell is run by that program.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    ::\n",
       "    \n",
       "        In [1]: %%script bash\n",
       "           ...: for i in 1 2 3; do\n",
       "           ...:   echo $i\n",
       "           ...: done\n",
       "        1\n",
       "        2\n",
       "        3\n",
       "    \n",
       "    optional arguments:\n",
       "      --no-raise-error  Whether you should raise an error message in addition to a stream on stderr if you get a nonzero exit code.\n",
       "      --proc PROC       The variable in which to store Popen instance. This is used only when --bg option is given.\n",
       "      --bg              Whether to run the script in the background. If given, the only way to see the output of the command is with --out/err.\n",
       "      --err ERR         The variable in which to store stderr from the script. If the script is backgrounded, this will be the stderr *pipe*, instead of the stderr text itself and will not be autoclosed.\n",
       "      --out OUT         The variable in which to store stdout from the script. If the script is backgrounded, this will be the stdout *pipe*, instead of the stderr text itself and will not be auto closed.\n",
       "%%sh:\n",
       "    %%sh script magic\n",
       "    \n",
       "    Run cells with sh in a subprocess.\n",
       "    \n",
       "    This is a shortcut for `%%script sh`\n",
       "%%svg:\n",
       "    Render the cell as an SVG literal\n",
       "%%sx:\n",
       "    Shell execute - run shell command and capture output (!! is short-hand).\n",
       "    \n",
       "    %sx command\n",
       "    \n",
       "    IPython will run the given command using commands.getoutput(), and\n",
       "    return the result formatted as a list (split on '\\n').  Since the\n",
       "    output is _returned_, it will be stored in ipython's regular output\n",
       "    cache Out[N] and in the '_N' automatic variables.\n",
       "    \n",
       "    Notes:\n",
       "    \n",
       "    1) If an input line begins with '!!', then %sx is automatically\n",
       "    invoked.  That is, while::\n",
       "    \n",
       "      !ls\n",
       "    \n",
       "    causes ipython to simply issue system('ls'), typing::\n",
       "    \n",
       "      !!ls\n",
       "    \n",
       "    is a shorthand equivalent to::\n",
       "    \n",
       "      %sx ls\n",
       "    \n",
       "    2) %sx differs from %sc in that %sx automatically splits into a list,\n",
       "    like '%sc -l'.  The reason for this is to make it as easy as possible\n",
       "    to process line-oriented shell output via further python commands.\n",
       "    %sc is meant to provide much finer control, but requires more\n",
       "    typing.\n",
       "    \n",
       "    3) Just like %sc -l, this is a list with special attributes:\n",
       "    ::\n",
       "    \n",
       "      .l (or .list) : value as list.\n",
       "      .n (or .nlstr): value as newline-separated string.\n",
       "      .s (or .spstr): value as whitespace-separated string.\n",
       "    \n",
       "    This is very useful when trying to use such lists as arguments to\n",
       "    system commands.\n",
       "%%system:\n",
       "    Shell execute - run shell command and capture output (!! is short-hand).\n",
       "    \n",
       "    %sx command\n",
       "    \n",
       "    IPython will run the given command using commands.getoutput(), and\n",
       "    return the result formatted as a list (split on '\\n').  Since the\n",
       "    output is _returned_, it will be stored in ipython's regular output\n",
       "    cache Out[N] and in the '_N' automatic variables.\n",
       "    \n",
       "    Notes:\n",
       "    \n",
       "    1) If an input line begins with '!!', then %sx is automatically\n",
       "    invoked.  That is, while::\n",
       "    \n",
       "      !ls\n",
       "    \n",
       "    causes ipython to simply issue system('ls'), typing::\n",
       "    \n",
       "      !!ls\n",
       "    \n",
       "    is a shorthand equivalent to::\n",
       "    \n",
       "      %sx ls\n",
       "    \n",
       "    2) %sx differs from %sc in that %sx automatically splits into a list,\n",
       "    like '%sc -l'.  The reason for this is to make it as easy as possible\n",
       "    to process line-oriented shell output via further python commands.\n",
       "    %sc is meant to provide much finer control, but requires more\n",
       "    typing.\n",
       "    \n",
       "    3) Just like %sc -l, this is a list with special attributes:\n",
       "    ::\n",
       "    \n",
       "      .l (or .list) : value as list.\n",
       "      .n (or .nlstr): value as newline-separated string.\n",
       "      .s (or .spstr): value as whitespace-separated string.\n",
       "    \n",
       "    This is very useful when trying to use such lists as arguments to\n",
       "    system commands.\n",
       "%%time:\n",
       "    Time execution of a Python statement or expression.\n",
       "    \n",
       "    The CPU and wall clock times are printed, and the value of the\n",
       "    expression (if any) is returned.  Note that under Win32, system time\n",
       "    is always reported as 0, since it can not be measured.\n",
       "    \n",
       "    This function can be used both as a line and cell magic:\n",
       "    \n",
       "    - In line mode you can time a single-line statement (though multiple\n",
       "      ones can be chained with using semicolons).\n",
       "    \n",
       "    - In cell mode, you can time the cell body (a directly\n",
       "      following statement raises an error).\n",
       "    \n",
       "    This function provides very basic timing functionality.  Use the timeit\n",
       "    magic for more control over the measurement.\n",
       "    \n",
       "    .. versionchanged:: 7.3\n",
       "        User variables are no longer expanded,\n",
       "        the magic line is always left unmodified.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    ::\n",
       "    \n",
       "      In [1]: %time 2**128\n",
       "      CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s\n",
       "      Wall time: 0.00\n",
       "      Out[1]: 340282366920938463463374607431768211456L\n",
       "    \n",
       "      In [2]: n = 1000000\n",
       "    \n",
       "      In [3]: %time sum(range(n))\n",
       "      CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s\n",
       "      Wall time: 1.37\n",
       "      Out[3]: 499999500000L\n",
       "    \n",
       "      In [4]: %time print 'hello world'\n",
       "      hello world\n",
       "      CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s\n",
       "      Wall time: 0.00\n",
       "    \n",
       "      Note that the time needed by Python to compile the given expression\n",
       "      will be reported if it is more than 0.1s.  In this example, the\n",
       "      actual exponentiation is done by Python at compilation time, so while\n",
       "      the expression can take a noticeable amount of time to compute, that\n",
       "      time is purely due to the compilation:\n",
       "    \n",
       "      In [5]: %time 3**9999;\n",
       "      CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s\n",
       "      Wall time: 0.00 s\n",
       "    \n",
       "      In [6]: %time 3**999999;\n",
       "      CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s\n",
       "      Wall time: 0.00 s\n",
       "      Compiler : 0.78 s\n",
       "%%timeit:\n",
       "    Time execution of a Python statement or expression\n",
       "    \n",
       "    Usage, in line mode:\n",
       "      %timeit [-n<N> -r<R> [-t|-c] -q -p<P> -o] statement\n",
       "    or in cell mode:\n",
       "      %%timeit [-n<N> -r<R> [-t|-c] -q -p<P> -o] setup_code\n",
       "      code\n",
       "      code...\n",
       "    \n",
       "    Time execution of a Python statement or expression using the timeit\n",
       "    module.  This function can be used both as a line and cell magic:\n",
       "    \n",
       "    - In line mode you can time a single-line statement (though multiple\n",
       "      ones can be chained with using semicolons).\n",
       "    \n",
       "    - In cell mode, the statement in the first line is used as setup code\n",
       "      (executed but not timed) and the body of the cell is timed.  The cell\n",
       "      body has access to any variables created in the setup code.\n",
       "    \n",
       "    Options:\n",
       "    -n<N>: execute the given statement <N> times in a loop. If <N> is not\n",
       "    provided, <N> is determined so as to get sufficient accuracy.\n",
       "    \n",
       "    -r<R>: number of repeats <R>, each consisting of <N> loops, and take the\n",
       "    best result.\n",
       "    Default: 7\n",
       "    \n",
       "    -t: use time.time to measure the time, which is the default on Unix.\n",
       "    This function measures wall time.\n",
       "    \n",
       "    -c: use time.clock to measure the time, which is the default on\n",
       "    Windows and measures wall time. On Unix, resource.getrusage is used\n",
       "    instead and returns the CPU user time.\n",
       "    \n",
       "    -p<P>: use a precision of <P> digits to display the timing result.\n",
       "    Default: 3\n",
       "    \n",
       "    -q: Quiet, do not print result.\n",
       "    \n",
       "    -o: return a TimeitResult that can be stored in a variable to inspect\n",
       "        the result in more details.\n",
       "    \n",
       "    .. versionchanged:: 7.3\n",
       "        User variables are no longer expanded,\n",
       "        the magic line is always left unmodified.\n",
       "    \n",
       "    Examples\n",
       "    --------\n",
       "    ::\n",
       "    \n",
       "      In [1]: %timeit pass\n",
       "      8.26 ns ± 0.12 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)\n",
       "    \n",
       "      In [2]: u = None\n",
       "    \n",
       "      In [3]: %timeit u is None\n",
       "      29.9 ns ± 0.643 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n",
       "    \n",
       "      In [4]: %timeit -r 4 u == None\n",
       "    \n",
       "      In [5]: import time\n",
       "    \n",
       "      In [6]: %timeit -n1 time.sleep(2)\n",
       "    \n",
       "    \n",
       "    The times reported by %timeit will be slightly higher than those\n",
       "    reported by the timeit.py script when variables are accessed. This is\n",
       "    due to the fact that %timeit executes the statement in the namespace\n",
       "    of the shell, compared with timeit.py, which uses a single setup\n",
       "    statement to import function or create variables. Generally, the bias\n",
       "    does not matter as long as results from timeit.py are not mixed with\n",
       "    those from %timeit.\n",
       "%%writefile:\n",
       "    ::\n",
       "    \n",
       "      %writefile [-a] filename\n",
       "    \n",
       "    Write the contents of the cell to a file.\n",
       "    \n",
       "    The file will be overwritten unless the -a (--append) flag is specified.\n",
       "    \n",
       "    positional arguments:\n",
       "      filename      file to write\n",
       "    \n",
       "    optional arguments:\n",
       "      -a, --append  Append contents of the cell to an existing file. The file will be created if it does not exist.\n",
       "\n",
       "Summary of magic functions (from %lsmagic):\n",
       "Available line magics:\n",
       "%alias  %alias_magic  %autoawait  %autocall  %automagic  %autosave  %bookmark  %cat  %cd  %clear  %colors  %conda  %config  %connect_info  %cp  %debug  %dhist  %dirs  %doctest_mode  %ed  %edit  %env  %gui  %hist  %history  %killbgscripts  %ldir  %less  %lf  %lk  %ll  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %lx  %macro  %magic  %man  %matplotlib  %mkdir  %more  %mv  %notebook  %page  %pastebin  %pdb  %pdef  %pdoc  %pfile  %pinfo  %pinfo2  %pip  %popd  %pprint  %precision  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %rep  %rerun  %reset  %reset_selective  %rm  %rmdir  %run  %save  %sc  %set_env  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode\n",
       "\n",
       "Available cell magics:\n",
       "%%!  %%HTML  %%SVG  %%bash  %%capture  %%debug  %%file  %%html  %%javascript  %%js  %%latex  %%markdown  %%perl  %%prun  %%pypy  %%python  %%python2  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile\n",
       "\n",
       "Automagic is ON, % prefix IS NOT needed for line magics."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%magic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.2360679774997896, -7.81975583743945e-11)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# The last line in a cell dumps all output to the page. Here we get the answer (1.236)!\n",
    "newton_raphson_plot(function_name, x0=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.2360679775000651, -9.171621755329502e-07)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "newton_raphson_plot(function_name, x0=4)\n",
    "## For higher quality inline plots, uncomment below. \n",
    "#from IPython.display import set_matplotlib_formats\n",
    "#set_matplotlib_formats('pdf', 'svg')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, how is this done? Let's start by defining a *function*, or *subroutine*, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunc(x):\n",
    "#    print('I love Python')\n",
    "    return x**2+2*x-4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfunc(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "a = myfunc(4)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The word *def* takes the place of *function* in Matlab. The colon, \":\", ends the line. All other lines are indented a single level. [Standard](https://www.python.org/dev/peps/pep-0008/) formating defined this as 4 spaces. \n",
    "\n",
    "* Most editors will move to four spaces is you use the *Tab* key. \n",
    "* [Standards](https://www.python.org/dev/peps/pep-0008/) for formatting are considered a big deal: \n",
    "    * You won't remember them (all).\n",
    "    * A good editor (Spyder, PyCharm, Atom) will remember them.\n",
    "        * Spyder comes as part of Scientific Python distributions\n",
    "    * They substantially enhance readability.\n",
    "    * Many editors will make this happen for you automatically on save. \n",
    "    * `autopep8` is an awesome tool to just *prettify* your code. p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "function_name = 'myfunc'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plots are done similarly to Matlab. \n",
    "* We optioned here, for our sanity, to control the *name space*\n",
    "* The name *ylabel* **can still be used as a variable**!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ylabel = 4\n",
    "ylabel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function linspace in module numpy:\n",
      "\n",
      "linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)\n",
      "    Return evenly spaced numbers over a specified interval.\n",
      "    \n",
      "    Returns `num` evenly spaced samples, calculated over the\n",
      "    interval [`start`, `stop`].\n",
      "    \n",
      "    The endpoint of the interval can optionally be excluded.\n",
      "    \n",
      "    .. versionchanged:: 1.16.0\n",
      "        Non-scalar `start` and `stop` are now supported.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    start : array_like\n",
      "        The starting value of the sequence.\n",
      "    stop : array_like\n",
      "        The end value of the sequence, unless `endpoint` is set to False.\n",
      "        In that case, the sequence consists of all but the last of ``num + 1``\n",
      "        evenly spaced samples, so that `stop` is excluded.  Note that the step\n",
      "        size changes when `endpoint` is False.\n",
      "    num : int, optional\n",
      "        Number of samples to generate. Default is 50. Must be non-negative.\n",
      "    endpoint : bool, optional\n",
      "        If True, `stop` is the last sample. Otherwise, it is not included.\n",
      "        Default is True.\n",
      "    retstep : bool, optional\n",
      "        If True, return (`samples`, `step`), where `step` is the spacing\n",
      "        between samples.\n",
      "    dtype : dtype, optional\n",
      "        The type of the output array.  If `dtype` is not given, infer the data\n",
      "        type from the other input arguments.\n",
      "    \n",
      "        .. versionadded:: 1.9.0\n",
      "    \n",
      "    axis : int, optional\n",
      "        The axis in the result to store the samples.  Relevant only if start\n",
      "        or stop are array-like.  By default (0), the samples will be along a\n",
      "        new axis inserted at the beginning. Use -1 to get an axis at the end.\n",
      "    \n",
      "        .. versionadded:: 1.16.0\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    samples : ndarray\n",
      "        There are `num` equally spaced samples in the closed interval\n",
      "        ``[start, stop]`` or the half-open interval ``[start, stop)``\n",
      "        (depending on whether `endpoint` is True or False).\n",
      "    step : float, optional\n",
      "        Only returned if `retstep` is True\n",
      "    \n",
      "        Size of spacing between samples.\n",
      "    \n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    arange : Similar to `linspace`, but uses a step size (instead of the\n",
      "             number of samples).\n",
      "    geomspace : Similar to `linspace`, but with numbers spaced evenly on a log\n",
      "                scale (a geometric progression).\n",
      "    logspace : Similar to `geomspace`, but with the end points specified as\n",
      "               logarithms.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.linspace(2.0, 3.0, num=5)\n",
      "    array([2.  , 2.25, 2.5 , 2.75, 3.  ])\n",
      "    >>> np.linspace(2.0, 3.0, num=5, endpoint=False)\n",
      "    array([2. ,  2.2,  2.4,  2.6,  2.8])\n",
      "    >>> np.linspace(2.0, 3.0, num=5, retstep=True)\n",
      "    (array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)\n",
      "    \n",
      "    Graphical illustration:\n",
      "    \n",
      "    >>> import matplotlib.pyplot as plt\n",
      "    >>> N = 8\n",
      "    >>> y = np.zeros(N)\n",
      "    >>> x1 = np.linspace(0, 10, N, endpoint=True)\n",
      "    >>> x2 = np.linspace(0, 10, N, endpoint=False)\n",
      "    >>> plt.plot(x1, y, 'o')\n",
      "    [<matplotlib.lines.Line2D object at 0x...>]\n",
      "    >>> plt.plot(x2, y + 0.5, 'o')\n",
      "    [<matplotlib.lines.Line2D object at 0x...>]\n",
      "    >>> plt.ylim([-0.5, 1])\n",
      "    (-0.5, 1)\n",
      "    >>> plt.show()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.linspace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(start = -6, stop= 4, num = 200)\n",
    "#x = np.linspace(start=-6, stop=10,num=200)\n",
    "plt.plot(x, myfunc(x))\n",
    "plt.grid(True)\n",
    "plt.ylabel('$f(x)$')\n",
    "plt.xlabel('$x$')\n",
    "plt.title('$f(x)$ versus $x$')\n",
    "plt.text(0.1,0.1,'$\\\\pi = \\\\frac{\\\\alpha^2}{\\\\beta}$')\n",
    "#plt.show()\n",
    "# To save a plot\n",
    "plt.savefig('myplot.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make it more of a qualitative chart. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['text.usetex'] = False\n",
    "with plt.xkcd():\n",
    "    plt.plot(x,myfunc(x))\n",
    "    plt.grid(True)\n",
    "    plt.ylabel('f(x)')\n",
    "    plt.xlabel('x')\n",
    "    plt.title('f(x) versus x')\n",
    "    plt.text(0.1, 0.1, 'pi = a^2/b')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def newton_raphson(function, x0 = 0, dx = 1e-10, eps = 1e-10, count = 0):\n",
    "    deltax = 2*eps\n",
    "    x = x0\n",
    "    # loop until it converges, but no more than 50 times\n",
    "    while abs(deltax) > eps and count < 50: \n",
    "        count += 1 # I can add 1 to the variable *count*. Neat Python shortcut. \n",
    "        # This is a comment\n",
    "        # The next line is \"Matlab style\" and *bad*\n",
    "        #f = eval(function + '('+ str(x) + ')')\n",
    "        f = globals()[function](x)  #We explain later. \n",
    "        #f2 = eval(function + '('+ str(x+dx) + ')')\n",
    "        f2 = globals()[function](x+dx)\n",
    "        # Calculate the slope (estimation of derivative. )\n",
    "        dfdx = (f2-f)/dx\n",
    "        # Straight line approximation of delta x to intercept y=0. \n",
    "        deltax = -f/dfdx\n",
    "        # New estimate of x. \n",
    "        x = x + deltax\n",
    "    return x, deltax, count                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.2360679774997898, -2.7585905568420595e-13, 5)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "newton_raphson(function_name, x0=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "(x_soln, final_delta_x, num_steps) = newton_raphson(function_name, x0=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2360679774997898\n",
      "-2.7585905568420595e-13\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "print(x_soln)\n",
    "print(final_delta_x)\n",
    "print(num_steps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outputs and unpacking of results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.2360679774997898, -2.7585905568420595e-13, 5)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = newton_raphson(function_name, x0=2)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2360679774997898"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2360679774997898"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1, a2, a3 = a\n",
    "a1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "a, b = b, a\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.2 µs ± 123 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit #just clocking this\n",
    "newton_raphson(function_name, x0=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# less efficient- using the eval statement\n",
    "def newton_raphson_eval(function, x0 = 0, dx = 1e-10, eps = 1e-10):\n",
    "    deltax = 2*eps\n",
    "    count = 0\n",
    "    x = x0\n",
    "    while abs(deltax) > eps and count < 50:\n",
    "        count += 1\n",
    "        f = eval(function + '('+ str(x) + ')')\n",
    "        #f = globals()[function](x)\n",
    "        f2 = eval(function + '('+ str(x+dx) + ')')\n",
    "        #f2 = globals()[function](x+dx)\n",
    "        dfdx = (f2-f)/dx\n",
    "        deltax = -f/dfdx\n",
    "        x = x + deltax\n",
    "    return x, deltax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "76.4 µs ± 3.77 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "newton_raphson_eval(function_name, x0=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the neat things about Python is that a function itself can be assigned to a variable. When we to that, the variable acts just like the function. In the following the  polynomial function ``myfunc`` defined above is assigned to the variable ``function`` to perform the search. It runs faster yet. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def newton_raphson_variable(function, x0 = 0, dx = 1e-10, eps = 1e-10, count = 0):\n",
    "    deltax = 2*eps\n",
    "    x = x0\n",
    "    # loop until it converges, but no more than 50 times\n",
    "    while abs(deltax) > eps and count < 50: \n",
    "        count += 1  \n",
    "        f = function(x)  # Note that function is a variable containing the actual function\n",
    "        # It acts like the function itself. \n",
    "        f2 = function(x+dx)\n",
    "        dfdx = (f2-f)/dx # Calculate the slope (estimation of derivative. )\n",
    "        deltax = -f/dfdx # Straight line approximation of delta x to intercept y=0. \n",
    "        x = x + deltax # New estimate of x.\n",
    "    return x, deltax, count "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.73 µs ± 135 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "newton_raphson_variable(myfunc, x0=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"other_plotting\"></a>\n",
    "## Other plotting\n",
    "\n",
    "[Matplotlib](https://matplotlib.org/) is really designed to make great print graphics. In the past decade or so the opinion has developed that web-based viewing (or computer screen viewing) of data needs more appropriate visualization tools than something designed with the expectation of printing to a page. \n",
    "\n",
    "1. Jake VanderPlas on [The Python Visualization Landscape](https://www.youtube.com/watch?v=FytuB8nFHPQ)\n",
    "1. [Altair](https://altair-viz.github.io/)\n",
    "2. [Plotly](https://plot.ly/)\n",
    "3. [Bokeh](https://plot.ly/)\n",
    "4. [Vega](https://vega.github.io/vega/)\n",
    "5. [Mayavi](https://docs.enthought.com/mayavi/mayavi/)\n",
    "8. [datashader](https://github.com/pyviz/datashader)\n",
    "\n",
    "More comprehensive information can be found at [VisPy](http://vispy.org/).\n",
    "\n",
    "There is so much more. If you need it, it's out there. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"optimization\"></a>\n",
    "# Optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.optimize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "996 µs ± 31.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "scipy.optimize.broyden1(globals()[function_name], 2, f_tol=1e-14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "930 µs ± 25.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "scipy.optimize.broyden2(globals()[function_name], 2, f_tol=1e-14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "52 µs ± 2.27 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "scipy.optimize.root(globals()[function_name], 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55.6 µs ± 2.85 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "scipy.optimize.fsolve(globals()[function_name], 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "My code is faster. How? Well, the other codes are optimized for very large problems. Mine is optimized for small problems. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"formatoutput\"></a>\n",
    "# Formatted printing\n",
    "[Formatted printing](https://mkaz.tech/code/python-string-format.html) can be performed using the *.format* operator. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n",
      "3.14\n",
      "3.1416\n",
      "    3.14    \n",
      "What if you just want to insert some stuff simply?\n"
     ]
    }
   ],
   "source": [
    "print(np.pi)\n",
    "print('{:.2f}'.format(np.pi))\n",
    "print('{:.4f}'.format(np.pi))\n",
    "print('{:^12.2f}'.format(np.pi))\n",
    "print('What if {} just {} to {} some stuff {}?'.format('you', 'want', 'insert', 'simply'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"aplotting\"></a>\n",
    "\n",
    "# A little more advanced plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sdof_resp(x0=1, v0=0.1, m=1, c=0.25, k=10, tmax=10):\n",
    "    t = np.linspace(0, tmax, 200)\n",
    "    omega = np.sqrt(k / m)\n",
    "    zeta = c / 2 / np.sqrt(m * k)\n",
    "    if zeta < 1:\n",
    "        omega_d = omega * np.sqrt(1 - zeta**2)\n",
    "        X0 = np.sqrt(x0**2 * omega**2 + v0**2 + 2 * x0 * v0 * zeta *\n",
    "                     omega) / omega_d\n",
    "        Phi0 = np.arctan2(x0 * omega_d, (v0 + zeta * omega * x0))\n",
    "        x = X0 * np.exp(-zeta * omega * t) * np.sin(omega_d * t + Phi0)\n",
    "        \n",
    "        expdecay = X0 * np.exp(-zeta * omega * t)\n",
    "        plt.plot(t, expdecay,'--', label = 'Decay Envelope')\n",
    "        plt.plot(t, -expdecay, '--')\n",
    "        plt.text(tmax/3, X0 * np.exp(-zeta * omega * tmax/3) + X0*0.03, 'Decay Envelope, $X_0e^{-\\zeta\\omega_nt}$')\n",
    "\n",
    "    else:\n",
    "    \n",
    "        C1 = (x0 * omega * (zeta + np.sqrt(zeta**2 - 1)) + v0\n",
    "              ) / 2 / omega / np.sqrt(zeta**2 - 1)\n",
    "        C2 = (-x0 * omega * (zeta - np.sqrt(zeta**2 - 1)) - v0\n",
    "              ) / 2 / omega / np.sqrt(zeta**2 - 1)\n",
    "        x = C1 * np.exp(\n",
    "            (-zeta + np.sqrt(zeta**2 - 1)) * omega * t) + C2 * np.exp(\n",
    "                (-zeta - np.sqrt(zeta**2 - 1)) * omega * t)\n",
    "        x_label = C1 * np.exp(\n",
    "            (-zeta + np.sqrt(zeta**2 - 1)) * omega * tmax/3) + C2 * np.exp(\n",
    "                (-zeta - np.sqrt(zeta**2 - 1)) * omega * tmax/3)\n",
    "        plt.axis([0, tmax, -np.abs(C1+C2)*1.1, np.abs(C1+C2)*1.1])\n",
    "        plt.text(tmax/3, x_label + x[0]*0.03, 'Overdamped response')\n",
    "        \n",
    "\n",
    "    plt.plot(t, np.real(x), label = 'Response')\n",
    "    plt.xlabel('$t$ (sec)')\n",
    "    plt.ylabel('$x(t)$ (m)')\n",
    "    plt.grid(True)\n",
    "    plt.title('x versus time. $\\\\zeta = ${:.2f}'.format(zeta))\n",
    "    plt.legend(bbox_to_anchor=(1.1, 1.05))\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sdof_resp(1,0.1,1,0.25,10,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sdof_resp()  # arguments aren't necessary to use the defaults."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from ipywidgets import interact\n",
    "interact(sdof_resp, x0 = (0,2,0.1), v0 = (0,2,.1), m = (0,2,0.1), k = (0,100,1), c = (-1,5,.1));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib also handles subplots and all of the niceties Matlab has. Further, multiple high-end 3-D rendering packages exist to replace codes such as Tecplot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"excel\"></a>\n",
    "\n",
    "# Manipulating Excel Spreadsheets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function read_excel in module pandas.io.excel._base:\n",
      "\n",
      "read_excel(io, sheet_name=0, header=0, names=None, index_col=None, usecols=None, squeeze=False, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skiprows=None, nrows=None, na_values=None, keep_default_na=True, na_filter=True, verbose=False, parse_dates=False, date_parser=None, thousands=None, comment=None, skipfooter=0, convert_float=True, mangle_dupe_cols=True)\n",
      "    Read an Excel file into a pandas DataFrame.\n",
      "    \n",
      "    Supports `xls`, `xlsx`, `xlsm`, `xlsb`, `odf`, `ods` and `odt` file extensions\n",
      "    read from a local filesystem or URL. Supports an option to read\n",
      "    a single sheet or a list of sheets.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    io : str, bytes, ExcelFile, xlrd.Book, path object, or file-like object\n",
      "        Any valid string path is acceptable. The string could be a URL. Valid\n",
      "        URL schemes include http, ftp, s3, and file. For file URLs, a host is\n",
      "        expected. A local file could be: ``file://localhost/path/to/table.xlsx``.\n",
      "    \n",
      "        If you want to pass in a path object, pandas accepts any ``os.PathLike``.\n",
      "    \n",
      "        By file-like object, we refer to objects with a ``read()`` method,\n",
      "        such as a file handler (e.g. via builtin ``open`` function)\n",
      "        or ``StringIO``.\n",
      "    sheet_name : str, int, list, or None, default 0\n",
      "        Strings are used for sheet names. Integers are used in zero-indexed\n",
      "        sheet positions. Lists of strings/integers are used to request\n",
      "        multiple sheets. Specify None to get all sheets.\n",
      "    \n",
      "        Available cases:\n",
      "    \n",
      "        * Defaults to ``0``: 1st sheet as a `DataFrame`\n",
      "        * ``1``: 2nd sheet as a `DataFrame`\n",
      "        * ``\"Sheet1\"``: Load sheet with name \"Sheet1\"\n",
      "        * ``[0, 1, \"Sheet5\"]``: Load first, second and sheet named \"Sheet5\"\n",
      "          as a dict of `DataFrame`\n",
      "        * None: All sheets.\n",
      "    \n",
      "    header : int, list of int, default 0\n",
      "        Row (0-indexed) to use for the column labels of the parsed\n",
      "        DataFrame. If a list of integers is passed those row positions will\n",
      "        be combined into a ``MultiIndex``. Use None if there is no header.\n",
      "    names : array-like, default None\n",
      "        List of column names to use. If file contains no header row,\n",
      "        then you should explicitly pass header=None.\n",
      "    index_col : int, list of int, default None\n",
      "        Column (0-indexed) to use as the row labels of the DataFrame.\n",
      "        Pass None if there is no such column.  If a list is passed,\n",
      "        those columns will be combined into a ``MultiIndex``.  If a\n",
      "        subset of data is selected with ``usecols``, index_col\n",
      "        is based on the subset.\n",
      "    usecols : int, str, list-like, or callable default None\n",
      "        * If None, then parse all columns.\n",
      "        * If str, then indicates comma separated list of Excel column letters\n",
      "          and column ranges (e.g. \"A:E\" or \"A,C,E:F\"). Ranges are inclusive of\n",
      "          both sides.\n",
      "        * If list of int, then indicates list of column numbers to be parsed.\n",
      "        * If list of string, then indicates list of column names to be parsed.\n",
      "    \n",
      "          .. versionadded:: 0.24.0\n",
      "    \n",
      "        * If callable, then evaluate each column name against it and parse the\n",
      "          column if the callable returns ``True``.\n",
      "    \n",
      "        Returns a subset of the columns according to behavior above.\n",
      "    \n",
      "          .. versionadded:: 0.24.0\n",
      "    \n",
      "    squeeze : bool, default False\n",
      "        If the parsed data only contains one column then return a Series.\n",
      "    dtype : Type name or dict of column -> type, default None\n",
      "        Data type for data or columns. E.g. {'a': np.float64, 'b': np.int32}\n",
      "        Use `object` to preserve data as stored in Excel and not interpret dtype.\n",
      "        If converters are specified, they will be applied INSTEAD\n",
      "        of dtype conversion.\n",
      "    engine : str, default None\n",
      "        If io is not a buffer or path, this must be set to identify io.\n",
      "        Supported engines: \"xlrd\", \"openpyxl\", \"odf\", \"pyxlsb\", default \"xlrd\".\n",
      "        Engine compatibility :\n",
      "        - \"xlrd\" supports most old/new Excel file formats.\n",
      "        - \"openpyxl\" supports newer Excel file formats.\n",
      "        - \"odf\" supports OpenDocument file formats (.odf, .ods, .odt).\n",
      "        - \"pyxlsb\" supports Binary Excel files.\n",
      "    converters : dict, default None\n",
      "        Dict of functions for converting values in certain columns. Keys can\n",
      "        either be integers or column labels, values are functions that take one\n",
      "        input argument, the Excel cell content, and return the transformed\n",
      "        content.\n",
      "    true_values : list, default None\n",
      "        Values to consider as True.\n",
      "    false_values : list, default None\n",
      "        Values to consider as False.\n",
      "    skiprows : list-like\n",
      "        Rows to skip at the beginning (0-indexed).\n",
      "    nrows : int, default None\n",
      "        Number of rows to parse.\n",
      "    \n",
      "        .. versionadded:: 0.23.0\n",
      "    \n",
      "    na_values : scalar, str, list-like, or dict, default None\n",
      "        Additional strings to recognize as NA/NaN. If dict passed, specific\n",
      "        per-column NA values. By default the following values are interpreted\n",
      "        as NaN: '', '#N/A', '#N/A N/A', '#NA', '-1.#IND', '-1.#QNAN', '-NaN', '-nan',\n",
      "        '1.#IND', '1.#QNAN', '<NA>', 'N/A', 'NA', 'NULL', 'NaN', 'n/a',\n",
      "        'nan', 'null'.\n",
      "    keep_default_na : bool, default True\n",
      "        Whether or not to include the default NaN values when parsing the data.\n",
      "        Depending on whether `na_values` is passed in, the behavior is as follows:\n",
      "    \n",
      "        * If `keep_default_na` is True, and `na_values` are specified, `na_values`\n",
      "          is appended to the default NaN values used for parsing.\n",
      "        * If `keep_default_na` is True, and `na_values` are not specified, only\n",
      "          the default NaN values are used for parsing.\n",
      "        * If `keep_default_na` is False, and `na_values` are specified, only\n",
      "          the NaN values specified `na_values` are used for parsing.\n",
      "        * If `keep_default_na` is False, and `na_values` are not specified, no\n",
      "          strings will be parsed as NaN.\n",
      "    \n",
      "        Note that if `na_filter` is passed in as False, the `keep_default_na` and\n",
      "        `na_values` parameters will be ignored.\n",
      "    na_filter : bool, default True\n",
      "        Detect missing value markers (empty strings and the value of na_values). In\n",
      "        data without any NAs, passing na_filter=False can improve the performance\n",
      "        of reading a large file.\n",
      "    verbose : bool, default False\n",
      "        Indicate number of NA values placed in non-numeric columns.\n",
      "    parse_dates : bool, list-like, or dict, default False\n",
      "        The behavior is as follows:\n",
      "    \n",
      "        * bool. If True -> try parsing the index.\n",
      "        * list of int or names. e.g. If [1, 2, 3] -> try parsing columns 1, 2, 3\n",
      "          each as a separate date column.\n",
      "        * list of lists. e.g.  If [[1, 3]] -> combine columns 1 and 3 and parse as\n",
      "          a single date column.\n",
      "        * dict, e.g. {'foo' : [1, 3]} -> parse columns 1, 3 as date and call\n",
      "          result 'foo'\n",
      "    \n",
      "        If a column or index contains an unparseable date, the entire column or\n",
      "        index will be returned unaltered as an object data type. If you don`t want to\n",
      "        parse some cells as date just change their type in Excel to \"Text\".\n",
      "        For non-standard datetime parsing, use ``pd.to_datetime`` after ``pd.read_excel``.\n",
      "    \n",
      "        Note: A fast-path exists for iso8601-formatted dates.\n",
      "    date_parser : function, optional\n",
      "        Function to use for converting a sequence of string columns to an array of\n",
      "        datetime instances. The default uses ``dateutil.parser.parser`` to do the\n",
      "        conversion. Pandas will try to call `date_parser` in three different ways,\n",
      "        advancing to the next if an exception occurs: 1) Pass one or more arrays\n",
      "        (as defined by `parse_dates`) as arguments; 2) concatenate (row-wise) the\n",
      "        string values from the columns defined by `parse_dates` into a single array\n",
      "        and pass that; and 3) call `date_parser` once for each row using one or\n",
      "        more strings (corresponding to the columns defined by `parse_dates`) as\n",
      "        arguments.\n",
      "    thousands : str, default None\n",
      "        Thousands separator for parsing string columns to numeric.  Note that\n",
      "        this parameter is only necessary for columns stored as TEXT in Excel,\n",
      "        any numeric columns will automatically be parsed, regardless of display\n",
      "        format.\n",
      "    comment : str, default None\n",
      "        Comments out remainder of line. Pass a character or characters to this\n",
      "        argument to indicate comments in the input file. Any data between the\n",
      "        comment string and the end of the current line is ignored.\n",
      "    skipfooter : int, default 0\n",
      "        Rows at the end to skip (0-indexed).\n",
      "    convert_float : bool, default True\n",
      "        Convert integral floats to int (i.e., 1.0 --> 1). If False, all numeric\n",
      "        data will be read in as floats: Excel stores all numbers as floats\n",
      "        internally.\n",
      "    mangle_dupe_cols : bool, default True\n",
      "        Duplicate columns will be specified as 'X', 'X.1', ...'X.N', rather than\n",
      "        'X'...'X'. Passing in False will cause data to be overwritten if there\n",
      "        are duplicate names in the columns.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    DataFrame or dict of DataFrames\n",
      "        DataFrame from the passed in Excel file. See notes in sheet_name\n",
      "        argument for more information on when a dict of DataFrames is returned.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    DataFrame.to_excel : Write DataFrame to an Excel file.\n",
      "    DataFrame.to_csv : Write DataFrame to a comma-separated values (csv) file.\n",
      "    read_csv : Read a comma-separated values (csv) file into DataFrame.\n",
      "    read_fwf : Read a table of fixed-width formatted lines into DataFrame.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    The file can be read using the file name as string or an open file object:\n",
      "    \n",
      "    >>> pd.read_excel('tmp.xlsx', index_col=0)  # doctest: +SKIP\n",
      "           Name  Value\n",
      "    0   string1      1\n",
      "    1   string2      2\n",
      "    2  #Comment      3\n",
      "    \n",
      "    >>> pd.read_excel(open('tmp.xlsx', 'rb'),\n",
      "    ...               sheet_name='Sheet3')  # doctest: +SKIP\n",
      "       Unnamed: 0      Name  Value\n",
      "    0           0   string1      1\n",
      "    1           1   string2      2\n",
      "    2           2  #Comment      3\n",
      "    \n",
      "    Index and header can be specified via the `index_col` and `header` arguments\n",
      "    \n",
      "    >>> pd.read_excel('tmp.xlsx', index_col=None, header=None)  # doctest: +SKIP\n",
      "         0         1      2\n",
      "    0  NaN      Name  Value\n",
      "    1  0.0   string1      1\n",
      "    2  1.0   string2      2\n",
      "    3  2.0  #Comment      3\n",
      "    \n",
      "    Column types are inferred but can be explicitly specified\n",
      "    \n",
      "    >>> pd.read_excel('tmp.xlsx', index_col=0,\n",
      "    ...               dtype={'Name': str, 'Value': float})  # doctest: +SKIP\n",
      "           Name  Value\n",
      "    0   string1    1.0\n",
      "    1   string2    2.0\n",
      "    2  #Comment    3.0\n",
      "    \n",
      "    True, False, and NA values, and thousands separators have defaults,\n",
      "    but can be explicitly specified, too. Supply the values you would like\n",
      "    as strings or lists of strings!\n",
      "    \n",
      "    >>> pd.read_excel('tmp.xlsx', index_col=0,\n",
      "    ...               na_values=['string1', 'string2'])  # doctest: +SKIP\n",
      "           Name  Value\n",
      "    0       NaN      1\n",
      "    1       NaN      2\n",
      "    2  #Comment      3\n",
      "    \n",
      "    Comment lines in the excel input file can be skipped using the `comment` kwarg\n",
      "    \n",
      "    >>> pd.read_excel('tmp.xlsx', index_col=0, comment='#')  # doctest: +SKIP\n",
      "          Name  Value\n",
      "    0  string1    1.0\n",
      "    1  string2    2.0\n",
      "    2     None    NaN\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(pd.read_excel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_excel('Financial_Sample.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Segment</th>\n",
       "      <th>Country</th>\n",
       "      <th>Product</th>\n",
       "      <th>Discount Band</th>\n",
       "      <th>Units Sold</th>\n",
       "      <th>Manufacturing Price</th>\n",
       "      <th>Sale Price</th>\n",
       "      <th>Gross Sales</th>\n",
       "      <th>Discounts</th>\n",
       "      <th>Sales</th>\n",
       "      <th>COGS</th>\n",
       "      <th>Profit</th>\n",
       "      <th>Date</th>\n",
       "      <th>Month Number</th>\n",
       "      <th>Month Name</th>\n",
       "      <th>Year</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Government</td>\n",
       "      <td>Canada</td>\n",
       "      <td>Carretera</td>\n",
       "      <td>None</td>\n",
       "      <td>1618.5</td>\n",
       "      <td>3</td>\n",
       "      <td>20</td>\n",
       "      <td>32370.0</td>\n",
       "      <td>0.00</td>\n",
       "      <td>32370.00</td>\n",
       "      <td>16185.0</td>\n",
       "      <td>16185.00</td>\n",
       "      <td>2014-01-01</td>\n",
       "      <td>1</td>\n",
       "      <td>January</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Government</td>\n",
       "      <td>Germany</td>\n",
       "      <td>Carretera</td>\n",
       "      <td>None</td>\n",
       "      <td>1321.0</td>\n",
       "      <td>3</td>\n",
       "      <td>20</td>\n",
       "      <td>26420.0</td>\n",
       "      <td>0.00</td>\n",
       "      <td>26420.00</td>\n",
       "      <td>13210.0</td>\n",
       "      <td>13210.00</td>\n",
       "      <td>2014-01-01</td>\n",
       "      <td>1</td>\n",
       "      <td>January</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Midmarket</td>\n",
       "      <td>France</td>\n",
       "      <td>Carretera</td>\n",
       "      <td>None</td>\n",
       "      <td>2178.0</td>\n",
       "      <td>3</td>\n",
       "      <td>15</td>\n",
       "      <td>32670.0</td>\n",
       "      <td>0.00</td>\n",
       "      <td>32670.00</td>\n",
       "      <td>21780.0</td>\n",
       "      <td>10890.00</td>\n",
       "      <td>2014-06-01</td>\n",
       "      <td>6</td>\n",
       "      <td>June</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Midmarket</td>\n",
       "      <td>Germany</td>\n",
       "      <td>Carretera</td>\n",
       "      <td>None</td>\n",
       "      <td>888.0</td>\n",
       "      <td>3</td>\n",
       "      <td>15</td>\n",
       "      <td>13320.0</td>\n",
       "      <td>0.00</td>\n",
       "      <td>13320.00</td>\n",
       "      <td>8880.0</td>\n",
       "      <td>4440.00</td>\n",
       "      <td>2014-06-01</td>\n",
       "      <td>6</td>\n",
       "      <td>June</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Midmarket</td>\n",
       "      <td>Mexico</td>\n",
       "      <td>Carretera</td>\n",
       "      <td>None</td>\n",
       "      <td>2470.0</td>\n",
       "      <td>3</td>\n",
       "      <td>15</td>\n",
       "      <td>37050.0</td>\n",
       "      <td>0.00</td>\n",
       "      <td>37050.00</td>\n",
       "      <td>24700.0</td>\n",
       "      <td>12350.00</td>\n",
       "      <td>2014-06-01</td>\n",
       "      <td>6</td>\n",
       "      <td>June</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>695</th>\n",
       "      <td>Small Business</td>\n",
       "      <td>France</td>\n",
       "      <td>Amarilla</td>\n",
       "      <td>High</td>\n",
       "      <td>2475.0</td>\n",
       "      <td>260</td>\n",
       "      <td>300</td>\n",
       "      <td>742500.0</td>\n",
       "      <td>111375.00</td>\n",
       "      <td>631125.00</td>\n",
       "      <td>618750.0</td>\n",
       "      <td>12375.00</td>\n",
       "      <td>2014-03-01</td>\n",
       "      <td>3</td>\n",
       "      <td>March</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>696</th>\n",
       "      <td>Small Business</td>\n",
       "      <td>Mexico</td>\n",
       "      <td>Amarilla</td>\n",
       "      <td>High</td>\n",
       "      <td>546.0</td>\n",
       "      <td>260</td>\n",
       "      <td>300</td>\n",
       "      <td>163800.0</td>\n",
       "      <td>24570.00</td>\n",
       "      <td>139230.00</td>\n",
       "      <td>136500.0</td>\n",
       "      <td>2730.00</td>\n",
       "      <td>2014-10-01</td>\n",
       "      <td>10</td>\n",
       "      <td>October</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>697</th>\n",
       "      <td>Government</td>\n",
       "      <td>Mexico</td>\n",
       "      <td>Montana</td>\n",
       "      <td>High</td>\n",
       "      <td>1368.0</td>\n",
       "      <td>5</td>\n",
       "      <td>7</td>\n",
       "      <td>9576.0</td>\n",
       "      <td>1436.40</td>\n",
       "      <td>8139.60</td>\n",
       "      <td>6840.0</td>\n",
       "      <td>1299.60</td>\n",
       "      <td>2014-02-01</td>\n",
       "      <td>2</td>\n",
       "      <td>February</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>698</th>\n",
       "      <td>Government</td>\n",
       "      <td>Canada</td>\n",
       "      <td>Paseo</td>\n",
       "      <td>High</td>\n",
       "      <td>723.0</td>\n",
       "      <td>10</td>\n",
       "      <td>7</td>\n",
       "      <td>5061.0</td>\n",
       "      <td>759.15</td>\n",
       "      <td>4301.85</td>\n",
       "      <td>3615.0</td>\n",
       "      <td>686.85</td>\n",
       "      <td>2014-04-01</td>\n",
       "      <td>4</td>\n",
       "      <td>April</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>699</th>\n",
       "      <td>Channel Partners</td>\n",
       "      <td>United States of America</td>\n",
       "      <td>VTT</td>\n",
       "      <td>High</td>\n",
       "      <td>1806.0</td>\n",
       "      <td>250</td>\n",
       "      <td>12</td>\n",
       "      <td>21672.0</td>\n",
       "      <td>3250.80</td>\n",
       "      <td>18421.20</td>\n",
       "      <td>5418.0</td>\n",
       "      <td>13003.20</td>\n",
       "      <td>2014-05-01</td>\n",
       "      <td>5</td>\n",
       "      <td>May</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>700 rows × 16 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "              Segment                   Country    Product Discount Band  \\\n",
       "0          Government                    Canada  Carretera          None   \n",
       "1          Government                   Germany  Carretera          None   \n",
       "2           Midmarket                    France  Carretera          None   \n",
       "3           Midmarket                   Germany  Carretera          None   \n",
       "4           Midmarket                    Mexico  Carretera          None   \n",
       "..                ...                       ...        ...           ...   \n",
       "695    Small Business                    France   Amarilla          High   \n",
       "696    Small Business                    Mexico   Amarilla          High   \n",
       "697        Government                    Mexico    Montana          High   \n",
       "698        Government                    Canada      Paseo          High   \n",
       "699  Channel Partners  United States of America        VTT          High   \n",
       "\n",
       "     Units Sold  Manufacturing Price  Sale Price  Gross Sales  Discounts  \\\n",
       "0        1618.5                    3          20      32370.0       0.00   \n",
       "1        1321.0                    3          20      26420.0       0.00   \n",
       "2        2178.0                    3          15      32670.0       0.00   \n",
       "3         888.0                    3          15      13320.0       0.00   \n",
       "4        2470.0                    3          15      37050.0       0.00   \n",
       "..          ...                  ...         ...          ...        ...   \n",
       "695      2475.0                  260         300     742500.0  111375.00   \n",
       "696       546.0                  260         300     163800.0   24570.00   \n",
       "697      1368.0                    5           7       9576.0    1436.40   \n",
       "698       723.0                   10           7       5061.0     759.15   \n",
       "699      1806.0                  250          12      21672.0    3250.80   \n",
       "\n",
       "         Sales      COGS    Profit       Date  Month Number Month Name  Year  \n",
       "0     32370.00   16185.0  16185.00 2014-01-01             1    January  2014  \n",
       "1     26420.00   13210.0  13210.00 2014-01-01             1    January  2014  \n",
       "2     32670.00   21780.0  10890.00 2014-06-01             6       June  2014  \n",
       "3     13320.00    8880.0   4440.00 2014-06-01             6       June  2014  \n",
       "4     37050.00   24700.0  12350.00 2014-06-01             6       June  2014  \n",
       "..         ...       ...       ...        ...           ...        ...   ...  \n",
       "695  631125.00  618750.0  12375.00 2014-03-01             3      March  2014  \n",
       "696  139230.00  136500.0   2730.00 2014-10-01            10    October  2014  \n",
       "697    8139.60    6840.0   1299.60 2014-02-01             2   February  2014  \n",
       "698    4301.85    3615.0    686.85 2014-04-01             4      April  2014  \n",
       "699   18421.20    5418.0  13003.20 2014-05-01             5        May  2014  \n",
       "\n",
       "[700 rows x 16 columns]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f9e60abed90>]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEFCAYAAAAPCDf9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAvNUlEQVR4nO3df3SU9Z3o8fdnJgkECRD5mRB+GEELwZXKr6CtxdZtxdtdUWsRu9qurkjL3dOec/deae+ue29v68Gzu93edt0KVY/13AaK9ef2oK3tomIlsRmKRUgpEJgQQcA4KAKSZOZ7/5gfPjPzTGaSzI9nnufzOoeTzDMzme9DMp/5Pt/v5/v5ijEGpZRS3uArdQOUUkoVjwZ9pZTyEA36SinlIRr0lVLKQzToK6WUh1SUugHZTJgwwcycObPUzVBKqbISCATeMcZMTD3u+KA/c+ZM2tvbS90MpZQqKyIStDuuwztKKeUhGvSVUspDNOgrpZSHaNBXSikP0aCvlFIeokFfKaU8xJNBPxAM8eC2AwSCoVI3RSmlisrxefr5FgiG+NLDrfT2R6iq8PHTv2lmwYzaUjdLKaWKwnM9/dbOHnr7I0QM9PVHaO3sKXWTlFKqaDwX9Jsbx1NV4cMvUFnho7lxfKmbpJRSReO54Z0FM2r56d8009rZQ3PjeB3aUUp5iueCPkQDvwZ7pZQXeW54RymlvEyDvlJKeYgGfaWU8hAN+kop5SEa9JVSykM8GfS1DINSyqs8l7KpZRi8KxAM6foM5XmeC/p2ZRg0ALhfIBhi1Y9b6euPUFnhY9Pd+mGvvMlzwztahsGbntrZTW9/BAP09kd4amd3qZukVEl4rqevZRi8yWS5rZRXeC7og5Zh8KKbr2jg5+1H6AsbKv3CzVc0lLpJSpWEJ4O+8p4FM2rZtHqpXuEpz9OgrzxDr/CU8uBErlJKeZkGfaWU8hAN+kop5SE5B30R8YvI70XkF7HbF4rIiyKyP/a11vLYb4rIARHZJyKfsxxfICK7Y/f9QEQkv6czdFqaQSnlBYOZyP060AGMid1eB/zGGLNeRNbFbt8rInOBW4EmoB74tYhcYowJAz8CVgOtwFbgOuD5vJzJMKSWZrjv802EzvZqlodSynVy6umLSAPwX4CHLYdvAH4S+/4nwArL8c3GmPPGmEPAAWCxiNQBY4wxO4wxBnjc8pySspZm6O2LcN+zb/Ivv9rHlx5u1Z6/UspVch3e+T7wP4CI5dhkY8wxgNjXSbHjU4Ejlsd1x45NjX2fejyNiKwWkXYRaT958mSOTcyN3TCOtTSDzydEjEmqzaOUUm6RdXhHRD4PnDDGBERkWQ4/026c3gxwPP2gMRuBjQALFy7M24r5TBU2raUZakdV8e1f7EkU5tLaPEopN8llTP8q4C9F5HpgJDBGRP4fcFxE6owxx2JDNydij+8Gplme3wAcjR1vsDleNANV2LQu3Ll0So2u3FRKuVLW4R1jzDeNMQ3GmJlEJ2j/0xjzV8BzwJdjD/sy8Gzs++eAW0VkhIhcBMwGXo8NAZ0WkeZY1s4dlucURa4VNhfMqGXtNbM04CulXGc4ZRjWA1tE5C6gC7gFwBizR0S2AHuBfmBtLHMH4KvAY0A10aydombu5FJh026jDd18QynlFhJNpHGuhQsXmvb29qK8lt2YP8CqjTsS1Rk3rV6qgV8p5XgiEjDGLEw9rgXXLOzG/N86dY7ecPSDsTdseHJntwZ9pVTZ0jIMFs2N46nw+xDA74+O+aemHDlmCbFSypFa2rq4/ZE2Wtq6St0UW9rTTxUf7op9vemKBp4IdCdSOG/SzTeUUhm0tHXxrad3A7B9/zsA3LZkeimblEZ7+hatnT30RwwGCEdMIqVz093N/N3nLtXNtJVSA3r+zWMD3nYC7elbxFM6Uxdm6eYbSqlcLJ9Xl+jhx287jQZ9C900XSk1HPGhnOffPMbyeXWOG9oBTdlUSilXypSyqWP6FlpTXynldjq8E5OpGJtSSrmJ9vRj7BZmqdLTqy+l8kt7+jGZMndU6ejVl1L5p0E/RjN3nGegUthKqaHRoG+h+fjOoldfSuWfBn3lWHr1pVT+eT7oa618Z0n9fejVl1L55emgrxOFzqK/D1UsXu7seTro60Shs+jvQxWD1zsXns7Tz3XPXFV4gWCIo6fOUeET/X2ogiqHNTmFXJ/i6Z6+ThQ6g7XnVeH3sXLxNG6+okF/H6ognJ4VVugrEc8FfZ0odB5rzyscjjB1XLX+TlTBOL2zV+hhTk8Ffa+P5TmV03teyn2c3Nkr9PvBU0FfJwqdyek9L6WKqdDvB08Ffe1ROpeTe15KFVsh3w+eCvrao1RKeZ2ngj5oj1Ip5W2eztNXSimv0aCvlFIe4umgr7syKaW8xnNj+nGas6+U8iLP9vRTc/af3NmtvX6llOt5tqdvzdn3+4SfB7rpD2uvvxC8XMZWKafxbNC35uwfPXWOTa936UrdAtBhNKWcxbPDOxAN/GuvmcVNVzRoieUCKYcytkp5iWd7+la6UrdwtPSFUs4ixphSt2FACxcuNO3t7aVuhhoGHdNXqvhEJGCMWZh6XHv6quC09IVSzuHpMX2llPKarEFfREaKyOsi8oaI7BGR/x07fqGIvCgi+2Nfay3P+aaIHBCRfSLyOcvxBSKyO3bfD0RECnNaSiml7OTS0z8PfNoYczkwH7hORJqBdcBvjDGzgd/EbiMic4FbgSbgOuDfRcQf+1k/AlYDs2P/rsvfqWTX0tbF7Y+00dLWNeDj1m/tYNk/bWP91o4itcw9tLSFstK/B+fJOqZvojO9H8RuVsb+GeAGYFns+E+Al4B7Y8c3G2POA4dE5ACwWEQOA2OMMTsARORxYAXwfH5OZWAtbV186+ndAGzf/w4Aty2Znva49Vs7eOiVToDE13XXzylGE8teIBhi1Y9bE5k6m+7WnHwv0zUazpTTmL6I+EVkF3ACeNEY0wZMNsYcA4h9nRR7+FTgiOXp3bFjU2Pfpx63e73VItIuIu0nT54cxOlk9vybxwa8HffCnrcHvK0y2/DyQXr7Ixigtz/CUzu7sz5HuZcT12jkerXvZjll7xhjwsB8ERkHPC0i8wZ4uN04vRnguN3rbQQ2QjRlM5c2ZrN8Xl2ihx+/HWdNKZw/bRyHe84m7ruuaUo+Xt71AsEQv/njiaRjzk4GVoXmtDUauV7tu92gUjaNMadE5CWiY/HHRaTOGHNMROqIXgVAtAc/zfK0BuBo7HiDzfGiuG3JdF548xivH36XxTMvBOD2R9poqhvDYzsO09sfocInIJL4dLphfr0O7eSotbMH65oPv8DNVzQM8AzlFoFgiCd3diPATVc0JIZwnLbo0e5qX4O+DRGZCPTFAn41cC3wAPAc8GVgfezrs7GnPAe0iMj3gHqiE7avG2PCInI6NgncBtwB/DDfJ5TJ+q0dvBL7dH9l/zuJ7629/76wAQyGaNCaPbmmWM0re/FeXW9/BJ8I375hXsnf5KrwAsEQqzbuoDcc/cB/ItCdNJfjpDUaA13te0kuPf064CexDBwfsMUY8wsR2QFsEZG7gC7gFgBjzB4R2QLsBfqBtbHhIYCvAo8B1UQncIsyiQsDj80LIEKipx8OO+NytJw4rVeniqO1syfWWYoqdcHC9Vs7eGHP21zXNCXtKj3eq3/+zWMsn1fnyV4+eKgMgzUrx45P4DsrLuPSKTUauHKk5RW8yfp7B5J6+lUlyNqKB/px1ZXs6n4vcXzN1Y2eHp71fBmG6eMvSLrtAyKW2xED2/ad4NIpOqSTi/VbO9i4vRNjYESlpuN5hV0a5qbVS23H9IthoM7cC3ve9nTQz8QzQT91Eidi85i9x95n1cYd9IUNlX5h0+qlGshstLR1Jb3RzvfpHgRuF+/dv3XqXFoa5tprZhX1d2+90hho2FYz7+x5JuinTuJU+KA/NfIbk7hM7Q0bntzZrYHMxqO/PZR2TOc/3Mvau6/w+6jwCeGIKcm8V+qVxnVNU5JSrOc3jOXUuT7bMX0V5ZmgnzqJ09Vzhi3tR3j3bF/iMVPHVfPWqQ8Tt7UwULpAMMTx984lHasfN1I/HF3MusgqHI5w6+Lp1I+rLspcTuq8UeqCr9mTa1hzdWPGyVuVzjNBv6WtKxHwgbRxQB8wa3INu7rfSywmuUnzzJMEgiG+uOE1wilXSGuvmV2aBqmCSA20qYusijVubzd/YLfga8GMWg32g+CJoJ+6Em/WpNFpj6mq9DGvfixCdCXpzUWekCoHG14+mBbwPzt3smdT39woU72cUqTj2pVxWHvNLE0NHiZPBP3USdxzfeGk21Nrq/mLy+r49i/2JP7YdTVpuuPvf5h0WwTu+dTFJWqNKgS7QBtfYFXsAJupjIOTFnyVI08E/dPn+pJuh1NmcI+GzvHwq4foj0QncTUbJV0gGGLSmJHAR3nQ93yyUf+PXMZJ9XJ0wV9heCLoHzj5QdLtUMqHgIFEwI/f3n/8dBFaVh6Ssjd80FQ/lpWLpuuwTpmzW1zntECrvfr880TQn1Y7io63PwriI6t8nE/L10zmhDKwTmG95Bfgs01TNOCXuYFq3Rcj0FoTK/Rvqbg8sUfud268DF8s/9InsGRm+iVrzQh/0u0RFf60x3hV/JLfL5T8kl8NnXUXq1LWuo8nVmzf/w7fenq3p2vbl4InevoLZtTyxJork+qFvNhxHGvZofP9yTWIxo2qLGYTHc1pl/xq8FJ79vd9vqlkY/da4ri0PBH0IfmSNRAMsWhGLa8f/mjfzt6UXMSVi/SP0ErHVstTfBilutKf1LMPne0t2Qe5ljguLc8E/fglbe2oKr79iz182Jd5TH/WpNHa81BlraWti0df7eTAyTOJYxV+QSzlE0r1Qa4ljkvLE0E/EAxxa6yQmk+iFTUHcudVFxWnYQ6lJZPLm3UxolVT3Rg+2zTFEb/X25Zo9lepeCLob3j5YGKjh2wBv8Ivni6v3NLWxX3PvknEmLSsDuVs8Q/rX2WoPKlptgo8EvRTV5LaiZdfMBHj2YVZgWCI+559M7FmobfEuyCp3ASCIZ7a2c0T7Ufoj5hEplrcrEmjufOqizTgK8AjQf+iCRfwhmVHnUy8npLY2tlD2HIp5BPx7P9FufjG5t/z7K6jWC9gBfjzuZP5sC+sY+YqjSeCfs+Z3qyPqfQLSxrHs3xenSd7tuu3dvDMrrfwCRgDPp9ubu5kLW1dPLhtf1IpcIgG/MoKH2s+dbH+7pQtTwT91BQxO/0Rw28PvMPvDr/LpVNqPPWGSd1ybtHMWtYtn+Op/4NykmmiFmDVkukFqxCrE/zu4ImgPxCfwKWTa9h3/DQR481x7JbXk1dEHnn3rKfOv9ykLm6KWzG/nvtvvKwgrzlQ2QZVXjxRhiHTmwTgLy+v5/alMxNZPREDtaOqitSy0mtp6+L9D/uTjk2/cFSJWqNykbqY6cILqlhzdSPfv/XjBXvNUpZtUPnliZ5+6vDOxNFVnPwgOs7/wp63uWBERSJ7xweEzmafA3ALuw/Ee5frLkROVorFTU4quayGxxNBv6vnTNLteMAH+LAvggFGVHrzDzr1A3HN1VojvxwUe3GT1l9yD08E/S3tRwa8f179WCCa+VCs/T+dQpfEO0dLWxc/+10Xk8aMLHr2TS6TtFp/yR08EfRHVfl592xfxvv/4dndGANVHtkMPfUNrkviSy85I+c9tv3xOD+758qSbUCuwd29PDGR+7VrZg94fzgSncDt7XP/BFX8Df4vv9rHlx5uJRAMZX+SKrjUuZX+SPE28tFJWm/xRNC/bcl07r/xMmZNGj3g4yK4P3NH3+DOlJqRU+Ej73NL1k1UrHSTHG/xxPAORAP/pVNquOWh1zIWXfOJ+zN3NAvDmeLDa4Ua048X0gtHDCMq07dH1Ela7/BM0IdotU27gF/pFyKWOuNupm9w5yrU3EpaIb2+9AWIOknrHZ4K+pmqbS67dBLzp43zTBDUN3hpFHMzcOtrhc72ErHsDerzaSE9L/NE0I+/ATJV2/zT26f58R0LS9Cy4vjG5t/z0p9OsuySiQVdtanSxf/2xl9QxTO7jgIk1kXkO/AHgiEeeL6DP759OrHKevv+d1hzdSNVFT56+yP4RAvpeZ3rg35qcar4ylurt06dLWqbiukbm3+fCDbxrxr4iyO1kJ1VvjcDDwRDfHHDa4RtdgHdc+x9HdJTCa4P+o++mvyms5vDHVHhL05jSuDXHceTbr/0p5Mlaom3BIIhNm63D/iQn83ArestonshZH4tHdJTca4P+ohkfcjtzTOK0JDia2nr4oPz4aRjyy6ZWKLWeEtrZw8mpYexYn49PWd68zKmn7qg6r7PN+H3kRT4p9ZWs3bZLF14p5K4Puhf+7FJHDjxQcb7J9RUUVNdSSAYclVPKJ6xYTVnSo0O7RRJc+N4RlT6ON8XQQRWf7KRddcPv5BdIBhiw8sH+UP3Kc7H6kb19UcIne1lyz1X8sDzHXS9e5YV86fm5fWU+7g+6NdUVybdTh3T7zndyz//ch+VfmHT6qWuCfypWx9W+ITvFKjWukpXiNTYQDDErRt30Bf+6Pca3ykr/hpb1lw57NdR7pZ1Ra6ITBORbSLSISJ7ROTrseMXisiLIrI/9rXW8pxvisgBEdknIp+zHF8gIrtj9/1AJIexl2FqbhxPlV8QoMov1I8bmXS/if3rDRue3Nld6OYUTbyn6SMa8DVjI/9a2rq4/ZE2Wtq6bO9fMKOWtdfMytv/e2tnT1LAB5gxfpTWylGDkktPvx/4b8aYnSJSAwRE5EXgK8BvjDHrRWQdsA64V0TmArcCTUA98GsRucQYEwZ+BKwGWoGtwHXA8/k+qTQS7d9HgKPv2efqQ7TX5AbxNMGvLJ1JTXWlZmzkWSAY4qGXD/Li3ugkeSFTMK1XCs2N46n0S1LgX3217oWrBidr0DfGHAOOxb4/LSIdwFTgBmBZ7GE/AV4C7o0d32yMOQ8cEpEDwGIROQyMMcbsABCRx4EVFDjot3b20B+Ojn2Gw8Y2ewfcU2HTmia4ff873H/jZRoU8ig+gfphX3KqTCFSMO0qX25evZQNLx/k+PsfsnKRVkdVgzeoMX0RmQl8HGgDJsc+EDDGHBORSbGHTSXak4/rjh3ri32fetzudVYTvSJg+vTh/VE3N46nwhftHWUK+AB3Xjmz7IOjXZpgvoOR18UL1qXKRwqm3etYC+PF0y43unghoSq8nKtsisho4EngG8aY9wd6qM0xM8Dx9IPGbDTGLDTGLJw4cfgphpFML2SxwwXVJu3SBPMdjLzOWpGywgeXN4zl/hsvG9YHq131S618qQolp56+iFQSDfg/NcY8FTt8XETqYr38OuBE7Hg3MM3y9AbgaOx4g83xgnpyZzf94WwhH0ZUlHeV6UAwxNFT5xJjvvE0Qe3lD51drZx8ZeUEgiGe3NnNO6fP89K+E/RHTNIwjhbGU4WSNejHMmweATqMMd+z3PUc8GVgfezrs5bjLSLyPaITubOB140xYRE5LSLNRIeH7gB+mLczydT+HB83a3JNQdtRSNbx3wq/j1VLpnGzx7Z9zDdr+Y7Uidrhrm4NBEOs2riD3pTOiHUYJx+vo5SdXHr6VwG3A7tFZFfs2LeIBvstInIX0AXcAmCM2SMiW4C9RDN/1sYydwC+CjwGVBOdwC145s5NVzTwRKDbdhzWasyI8l2yYB3/DYcjTB1XrcFiCKw9+9SdrIY7NxLv2cfXiaSmXlrz7ZUqpFyyd14lc4f5Mxme813guzbH24F5g2ngcC2YUcumu5v5q4dbOdeXOfDvOTbQNIVzBYIh3jp1jgq/j3BYN0YZqtSspxXz65PuH87cSGrPvtIv+H3RLRHjt29ZqFdnqjjKt3s7SKNHVHCuL/OuWOU44RnfDSliDBU+4dbF07lJA8eg2WU99Zzp5f4bL8tL/fvURVX9YcNtS6Ynshv0d6aKyfVBP9P4aaqunjNFalF+rN/awYZXOhNZSf0RQ70O6wxJpqynoexklbqgCkgsqkr09GNrQvR3pUrB9UH/yZ3dtgG/yvImBHhm11tlU6DKrk67T3Q3pFxkCsqpxdGG0rNvaeviH57ZTdhE/77itZwWzKhl0+qliTF9DfiqlFwf9HPN3pl+4aiCtiNf7IYiBLS2Tg4yrXIdbnpkIBjiqZ3dbGrrIj5rFK/lpJk4ymlcH/Sb6sfaHu9NqVR47/Ly6OU/tbM7bXP3e67WfPxcZFrlCkMPyvEPkniZYyu31HJS7uL6oL9t34msj7l44gVl0QsLBEM80X4kcVsE7slTnXa3sg7nxFe59vUPP8sp/nOPnjpHb396wK/0iytqOSn3cX3Q39UVyvqYqjJZjfvQywcTVygCrFo8XQN+BvEhlyfajyStds3XatrEYjifJNJl/X4fn7pkIpNqRui4vXIsVwf9QDDEyQ8yp2nGZVu45QQtbV2JUr4Afh/crD1JW3ZDLvHhnKHUt49/gBii/+dJi+EihpWLpzF1XLWWS1BlwdVB325TlLHVFZztDSflTV80cXQxmzVogWCIf/7lH5OONdWP1QCTIj7k8lbKkMtwVrsGgiFW/bg10TH4efsR/tdfzksaJtJFVaqcuDrop06kLZ5Zy73L5/DUzm42v95F2EQrJa751MUlaV8uAsEQKzfuSCsat3KRTtxapdYfqvAJ4YjB7/fxhQUNQwrMgWCI7//6T0lXgn1hQ+hsrxZDU2XL1UH/pisa+Fn7EfrDhgq/sOLjDayK7THq88HlU8eyctF0R79po5vAJAf8WZNGa7YOyZO0qfWHbl08nfphDLlYh4isKv2S+JlO/rtRKhNXB32I7pYF0aXvj77amZgIDUfgje732Hd8D5dOqXHkG7ilrYunf/9W2vE7r7qoBK1xltSc+/s+35Q05DLYidTURVvxDxFDdNOJyxrG0jR1rA7lqLLn6qD/90/vTkqlO3AyvdRCb19yvrZTWEv7xs2aNJo7r7rI07381HH7eM79cIZc7BZtpaZ33vcXTY77G1FqKFwd9I+EzmZ9jAFHli/41xf3pR278eNTPR/w7cbt45O0Qx1ysVu0tfaaWTpur1zJ1UH/2jmTeWbXwJtzjR7hd9wbOlOqqRM/nIppuOP2LW1d/Ox3XUweM5J7PnVxUu0du0VbOm6v3MjVQf/7t36c9sPv0n3qw4yPuaDKef8FrTb79a6YX++5AJS6XWFqcB7MuP03Nv/e0gF4j237TrDZUhBNe/XKK5wX8fLoG5t/P2DABxxXICW+1228CqgAN8yv5/u3frzUTSuqTNsVDiU4t7R1pV3x9YWNbk2oPMnVQf+lP53M+pgV86cWoSW5SR2zvs3De91m2q4w1+BszcZJ/VnwUeqlUl7j6qC/7JKJtmP6E0dXccGICq5rmuKo2jVP7uxOlA7w+l63y+fVJXr48du5Ss3G+crSmUk/a86UGr5z42We/b9V3ubqoH/70pk898bRtFLEH59ey+XTxjmqpxcIhvh5oDuRYur3eaMnmlrXJh6I41lKQ9muMDUbp6a6Mm9bHypV7lwd9O22wQP41d7jvLj3OCMqP9pIo9SiK2+jqz8FuGXhNEe0q5Ds6trEd5sCctquMBAM8cDzHXS9e5YV86ey7vo5ttk4C2bUarBXCpcH/dPn+tLqnMcZ4LyDFmbZZaa41fqtHbyw520m1oygL6WuTa6/j3j65R+630v8juNbSK67fo5m4yiVgauD/q87jg94v5MWZnklbdCaOnm45yw+IXE1luvkanL6ZbIX9rzNuuvnaDaOUhm4OugjA+djjhlZ4ajA4OZAFQiGeHJnd1qwnlQzgs/MmZw2pp+JXfql1XVNU/LRXKVcy9VBf179GA6c+CDj/Z/+2KQitsa7MlWsBBLj8NmeP1D65YwLR3G+P5zTz1LK61wd9A+9k15gzWrUiNKdfupqUzcaaB/Z+KKzgYK03ZaHqemXKzy4cE2p4XB10J88ZiTwXsb7Dxw/XbzGWGRabeomGfeR9Qm3LJyWtYTC+q0dbNzemZRuq+mXSg2fq4P+sksn8au9mSdz3z3bV8TWfCTTalM3iF/BVFf6h7yPbEtbVyITJ8665aGmXyo1dK4O+qGzvQhkTNt894PzxWxOwnBWmzpVS1sXj/72UNIcSqVfkFjp40yTtPEhoNPn+thz7H2Wz6tL+1AUgVWLp3u2JIVS+eTqoN/cOB6/D/rT5w8B+OB8f3EbFDOc1aZOZLfhC8DcujF8tmlKxt693RDO9v3vsGJ+fdLj7vlko07QKpUnrg76+94+nTHgQ/Fz9K1ZKLmsNnW6+Pn8as/btvevXGR/joFgiA0vH8w49NZzplfH7ZUqEFcH/Ud/e8j2uACfnD2Bx+9aUrS22G3JV85DFdbz8fuS10PMmngBd36iMWPA/9LDrXxok74ZFw/0GuyVyj/XBv2Wtq6MOfoG+Pq1lxS1LRtfOZiooBnfkq/cgr71SsVa1Ewihs/Oncy5vnDWnnn8eamunj0BA9qzV6rAXBv0H321c8D7N7x8kI13LCx4O1LHu61ZKOUiXudm77H3Ccfy5e/7fFNSrSDr9oMDsdYY8vmEuXVjMg4DKaXyz7VBP1sJhj3H3i9KMx7ctj/p9uQxI3jwSwvKppdvV+emrz9C6GzvkGoFeaXGkFJO5dqgf+3HJg1YgqG6wlfwNqzf2sFbKds1/lnDuLIJdJnq3Fjz5YdyLm6uMaSU07k26NdUVw6Yo3/tnMkFff1AMMTG7ekLjO751MUFfd18sqtz89m5k3MeylFKOU/W7q6IPCoiJ0TkTcuxC0XkRRHZH/taa7nvmyJyQET2icjnLMcXiMju2H0/EMky/jJMzY3j8fkyv8TBLHV5huvJnd1pO3bdc3VjWQXL1EVjK+bXs/GOhWV1DkqpZLn09B8D/g143HJsHfAbY8x6EVkXu32viMwFbgWagHrg1yJyiTEmDPwIWA20AluB64Dn83UiqV7c8zbh1Khrka0Y23BEJz6PJG4L0YDv1AVGLW1d0YlvEe686qLEpOpAi8i8UDBOKTfKGvSNMa+IyMyUwzcAy2Lf/wR4Cbg3dnyzMeY8cEhEDgCLReQwMMYYswNARB4HVlDAoP9ChgVDcbWjKgvyuoFgiPuefTPxgSNEg6dTA/76rR1JdW7imUbWwJ8a7P/1xX2c/KAXcG/BOKXcaqizmZONMccAYl/jhemnAkcsj+uOHZsa+z71uC0RWS0i7SLSfvLkySE1MNtmGpdMrhnSz83mqZ3d9FuuMPw+ceTWhy1tXdzwb6+mFTYD+7H8+HO+9fTuRMDP9nillPPkeyLXbhDdDHDcljFmI7ARYOHChZnHaAYQ71k/+ttD9IaTf0ShAnFLWxebX+9Kep1v3zDPcWPgmWrlxKWO5Wcrt+CGgnFKecVQg/5xEakzxhwTkTrgROx4NzDN8rgG4GjseIPN8YJad/0cWjt72NWdXFP/7k9clPdAHAiG+Idn38T6+bJy0TRHDXtkC94N40bytWtmJ9qcuomJ3bz4ivn1jjpHpdTAhhr0nwO+DKyPfX3WcrxFRL5HdCJ3NvC6MSYsIqdFpBloA+4Afjislufgjkfa0gI+5D9zJxAM8e3/2JM0cez3CTc7ZFgnLXinRG9rGmZLWxe3P9JGU90YHttxOFE6AqKXa38+d3J0EtyYjPV1lFLOlTXoi8gmopO2E0SkG/hHosF+i4jcBXQBtwAYY/aIyBZgL9APrI1l7gB8lWgmUDXRCdyCTeJCNNC9YqlZb3Xi/Q9tjw/1db644TXCKeVkPv2xSY4Y1mlp6+K+Z99MmmfIVCsndUcv6zqHePmINZqjr1RZyyV7Z1WGuz6T4fHfBb5rc7wdmDeo1g1Da2dPxvuW5rHuzQPPd6QF/Cq/sKbEi7Di9XJ2v/Ve0nqBePC2W2Blt3mJD/D7fXxhQYNuYqKUC7h2RW5z4/iMK3JrqvOXrtn17tmk26NH+PnJnUtKGhwzTdT6fcLKRdMyBu/UHb1Wf7KRmupKrZGjlIu4NugD+Hxiu0CrdlRVXn7++q0dnEnZfeuvlswoSYCMb0xy/P0P09oEUBHLJBpoDN5tO3oppdK5Nui3dvZgTHrA9xHdO3e47nikLWnOYMzICm5bXJpFWC1tXfz9M7vTyj7ExSdqAR7cdmDAnrtuXqKUu7k26Dc3jqfCJ0k5+j6gqnL4texb2rrSJolHVflLEvDjK4BTA/6sSaOpGzuS5fPquHRKTVL2jht27lJKDY1rg/6CGbXMnzaO1w+HEsfqx43k/666YtjB7me/60o7Nv3CUcP6mUPV2tljO4QVr6ET357QmnpZrjt3KaWGz7VBH+CtU+eSbnefGn6q5vqtHfwhJfdfgHuXl6a2TnPjeEZU+ujti4BA44QLuHbOZLbtO8HPftfF5DEj6e2PpKVeltPOXUqp/HFt0A8EQxy1CfLD6eG2tHWl1aqZNWk0D9z8ZwXvNWeqamndiap2VBUv7TvBhlc6LVlL71HpFyRiNPVSKeXeoN/a2WObrnn6XN+Qf6bdvrvFCvjWRVNAWuAHWPXjVttNx+fWjeGzTVM09VIpNeQqm46XKS1zqHvj3vFIGwdPJpdvaBg3sihBNHXRlF1Vy9bOHvpsAj7AykXTWXvNLA34Sin39vQzpWWOv2DwOfqp6ZlxX7tm9qB/Vq6swzmpi6aa6sbwP5/ejYHEUE1z43gqK3yJnr4AF0+8QOvjKKWSuDboZ+rp95wZfI7+64ffTbrtE/jOissKFkxTh3Puv/Ey7r/xMh59tZNz/RF+/OqhRMbOz9uPsGn1UhbMqGXT3c08tbM76cNAKaWsXBv0t+07YXt8sD39QDDElDEjOdzzUbmFT8yakPeAHy973Nw43nY4Z/m8Og6cTK8O2hc2icnp+D+llMrEtUH/jSMh2+OD6enHK1RGjImmOvqF5sbxPH7Xkjy1MiqeS9/bH6GqwsdXls5MGs6prvTbrg3A0iallMqFK4N+S1sXJ07bB/dcd3kKBEP8/dO7iU+N+gS+fu0lrL1mVp5a+dG4/chKP739ESImunCqprqSNVc38syutzj5wXl+3XEcf0oN/MUza5k1uUaHcZRSg+LKoG+XWgkwv2FszsMyD718kKRcGENee9SplTArfB8tnKodVcUP/3N/8gYmGWrgK6XUYLgy6J/60D4X/9QgcvRTN1ppnDR62D1qa0ZO6rh9U/3YRC59a2eP7Spauxr4Sik1GK4M+uOqq3jHZnjnuqYpOf+MlYum80b3Rz3xO6+6aFhtSs3IWTG/Pu31rL33qgofff0R/D7hloXTuEmHcZRSeeDKoH/txyZx4MQHSceq/DKoKpj5qC0/UM++50wv9994WdbSCrqKVimVT64M+nY7Y4mIzSMHNpza8uu3diTq9Nj17OOBPtPP1/RLpVQhuLIMQ3PjePwpMf58f4SWNvu0x3wLBENs3J48mdxzppc1Vzcyc/wo1lytq2SVUqXhyqC/YEYtf3F5fdpxu5o1+RQIhnhw24HoqtiUam9NdWN4bMdhut49y2M7DhMI2q8jUEqpQnLl8E4gGOKZXUfTjueaoz/U14wvsKrwCZWxiViAG+bXU1NdmZSLr5uYKKVKwZU9/Q0vH0w75hdsh1TWb+1g2T9tY/3WjmG9ZjzNMmKgN2wYVeknvp7qhT1vUzuqiqoKH37RTUyUUqXjyp6+Xfnk1BWtkDzZGv+aa4ZPIBjiyZ3dCHDTFQ00N45HBOLJ9dY1AX39EUJnezUjRylVcq4M+tUV6Rcwdj3rZ3a9lXY7l6AfCIZYtXFHYtP1JwLdbLq7mYmjR/D2++eTHmvdnlAzcpRSpebK4Z1r50xOO7bEJuinbmae6+bmrZ099IU/mqmNj9GvmD816XE+gVVLpvPTv2nWYK+UcgRX9vQDXemZMW2dPWnF0u5dPocvbniNcAT8vsybmweCIR56+SAn3v+QlYumc/pcX9JWjNaePESvGKZfOIp7l8/RYK+UchRXBv29R9PH9FsP9aQdWzCjli33XDngOHsgGGLlhteI70RoLc0Qd+eVMxPPXXf9nEGt/FVKqWJyZdA3qUnygO0u6WRe+RovoVBd6SfD1rMJQ913Vymlis2VQX/mhAvYe+x00rGJNSNyfn5q2WNLUo6tQub/K6VUPrky6M+fXpsW9NcOYhPztJW7Aotm1NLbH2Hlomiu/6O/PQTG6MbjSqmy4sqgf/MVDfy8/Qi94eg2h/cMstbN8nl1SdsVYmDZpZOSJoI10CulypErg/6CGbVsWr10yAuhblsyna6eM2zc3okxMKJSV9AqpdxBbCc9HWThwoWmvb29JK8dCIZ0Ba1SqiyJSMAYszD1uCt7+vmiK2iVUm7jyhW5Siml7GnQV0opDyl60BeR60Rkn4gcEJF1xX59pZTysqIGfRHxAw8Cy4G5wCoRmVvMNiillJcVu6e/GDhgjOk0xvQCm4EbitwGpZTyrGIH/anAEcvt7tixJCKyWkTaRaT95MmTRWucUkq5XbFTNtO3r7Ipa2OM2QhsBBCRkyISHMJrTQDeyfqo8uCWc3HLeYB7zsUt5wHuOZd8nccMu4PFDvrdwDTL7QYgfQdzC2PMxKG8kIi02y1MKEduORe3nAe451zcch7gnnMp9HkUe3jnd8BsEblIRKqAW4HnitwGpZTyrKL29I0x/SLyX4FfAn7gUWPMnmK2QSmlvKzoZRiMMVuBrUV4qY1FeI1iccu5uOU8wD3n4pbzAPecS0HPw/EF15RSSuWPlmFQSikP0aCvlFIeUvZBP1stH4n6Qez+P4jIFaVoZy5yOJcvxc7hDyLymohcXop2ZpNrfSURWSQiYRH5QjHbNxi5nIuILBORXSKyR0ReLnYbc5HD39ZYEfkPEXkjdh5/XYp2ZiMij4rICRF5M8P95fR+z3YuhXm/G2PK9h/RDKCDQCNQBbwBzE15zPXA80QXhjUDbaVu9zDO5UqgNvb9cieeSy7nYXncfxKd1P9Cqds9jN/JOGAvMD12e1Kp2z3E8/gW8EDs+4nAu0BVqdtucy5XA1cAb2a4vyze7zmeS0He7+Xe08+lls8NwOMmqhUYJyJ1xW5oDrKeizHmNWNMKHazlejiNqfJtb7S3wJPAieK2bhByuVcbgOeMsZ0ARhjnHg+uZyHAWpERIDRRIN+f3GbmZ0x5hWibcukXN7vWc+lUO/3cg/6udTyyanejwMMtp13Ee3ROE3W8xCRqcCNwENFbNdQ5PI7uQSoFZGXRCQgIncUrXW5y+U8/g2YQ3SF/G7g68aYSHGal1fl8n4frLy938t9u8RcavnkVO/HAXJup4hcQ/SP4BMFbdHQ5HIe3wfuNcaEox1Lx8rlXCqABcBngGpgh4i0GmP+VOjGDUIu5/E5YBfwaeBi4EUR2W6Meb/Abcu3cnm/5yzf7/dyD/q51PIZdL2fEsmpnSLyZ8DDwHJjTE+R2jYYuZzHQmBzLOBPAK4XkX5jzDNFaWHucv37escYcwY4IyKvAJcDTgr6uZzHXwPrTXQA+YCIHAI+BrxenCbmTbm833NSiPd7uQ/v5FLL5zngjtisfjPwnjHmWLEbmoOs5yIi04GngNsd1pO0ynoexpiLjDEzjTEzgZ8DX3NgwIfc/r6eBT4pIhUiMgpYAnQUuZ3Z5HIeXUSvVhCRycClQGdRW5kf5fJ+z6pQ7/ey7umbDLV8RGRN7P6HiGaHXA8cAM4S7dE4To7nch8wHvj3WC+53zisqmCO51EWcjkXY0yHiLwA/AGIAA8bY2xT8Eolx9/J/wEeE5HdRIdI7jXGOK5MsYhsApYBE0SkG/hHoBLK6/0OOZ1LQd7vWoZBKaU8pNyHd5RSSg2CBn2llPIQDfpKKeUhGvSVUspDNOgrpZSDZCvEZvP4L4rI3lihvJasj9fsHaWUcg4RuRr4gGgNoXlZHjsb2AJ82hgTEpFJ2eo/aU9fKaUcxK4Qm4hcLCIvxOo7bReRj8Xuuht4MF6YLZeCfxr0lVLK+TYCf2uMWQD8HfDvseOXAJeIyG9FpFVErsv2g8p6Ra5SSrmdiIwmWlv/CUuBwhGxrxXAbKIrexuA7SIyzxhzKtPP06CvlFLO5gNOGWPm29zXDbQaY/qAQyKyj+iHwO8G+mFKKaUcKlbe+pCI3AKJLSHjWyc+A1wTOz6B6HDPgIXyNOgrpZSDxAqx7QAuFZFuEbkL+BJwl4i8Aezho53Pfgn0iMheYBvw37OVYNaUTaWU8hDt6SullIdo0FdKKQ/RoK+UUh6iQV8ppTxEg75SSnmIBn2llPIQDfpKKeUh/x8Hr4u0emryLgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(df['Gross Sales'],df['Units Sold'],'.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Gross Sales</th>\n",
       "      <th>Units Sold</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>32370.0</td>\n",
       "      <td>1618.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>32670.0</td>\n",
       "      <td>2178.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Gross Sales  Units Sold\n",
       "0      32370.0      1618.5\n",
       "2      32670.0      2178.0"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[['Gross Sales','Units Sold']].iloc[[0,2],[0,1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f9e6029c880>]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(df['Gross Sales'],df['Units Sold']**2,'.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"cross-language\"></a>\n",
    "# Using other Languages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python can call other languages. That's how it does anything. Python itself is written in C, while the numerical algorithms used for Scientific Python are a mixture of [Fortran](https://docs.scipy.org/doc/numpy/f2py/), [C](https://docs.python.org/3.7/extending/extending.html), and JavaScript (`%%javascript`), and [Cython](https://cython.readthedocs.io/en/latest/) which is Python with a little help to make it compilable to run like C (i.e. *fast*). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this short course, I am using [Jupyter](http://www.jupyter.org) which allows me to intersperse notes with code. By using [Jupyter magics](https://ipython.readthedocs.io/en/stable/interactive/magics.html), I can use these languages ([and many others](https://github.com/jupyter/jupyter/wiki/Jupyter-kernels)) within the notebook. The following are a few examples. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the `fortranmagic` package we can create functions using Fortran. It is compiled Fortran. All of the compiling happens behind the scenes. \n",
    "\n",
    "The following examples are gleaned from the f2py project and [Matthias Bussonier's Cross-Language Integration page](https://matthiasbussonnier.com/posts/23-Cross-Language-Integration.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "new Promise(function(resolve, reject) {\n",
       "\tvar script = document.createElement(\"script\");\n",
       "\tscript.onload = resolve;\n",
       "\tscript.onerror = reject;\n",
       "\tscript.src = \"https://raw.github.com/marijnh/CodeMirror/master/mode/fortran/fortran.js\";\n",
       "\tdocument.head.appendChild(script);\n",
       "}).then(() => {\n",
       "IPython.config.cell_magic_highlight['magic_fortran'] = {'reg':[/^%%fortran/]};\n",
       "});"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# This loads the extension so that it knows what Fortran is. \n",
    "%load_ext fortranmagic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following cell is declared to be all Fortran by the first line `%%fortran`. The code is written as a subroutine. This defines the function `f1` which is now an available function for our python code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%fortran\n",
    "\n",
    "subroutine f1(x, y, z)\n",
    "    real, intent(in) :: x,y\n",
    "    real, intent(out) :: z\n",
    "\n",
    "    z = sin(x+y)\n",
    "\n",
    "end subroutine f1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0998334214091301"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1(.05, .05)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I need a quick single-argument function- why not the classic Fibonacci sequence? (from Bussonier's page)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n):\n",
    "    \"\"\"\n",
    "    A simple definition of fibonacci manually unrolled\n",
    "    \"\"\"\n",
    "    if n<2:\n",
    "        return 1\n",
    "    x,y = 1,1\n",
    "    for i in range(n-2):\n",
    "        x,y = y,x+y\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "X = np.arange(1,30)\n",
    "Y = np.array([fib(x) for x in X])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot the sequence. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cffi_magic\n",
    "# rm -rf *.o *.c *.so Cargo.* src target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cffi int cfib(int);\n",
    "\n",
    "int cfib(int n)\n",
    "{\n",
    "    int res=0;\n",
    "    if (n <= 2){  \n",
    "        res = 1;\n",
    "    } else {\n",
    "        res = cfib(n-1)+cfib(n-2);\n",
    "    }\n",
    "    return res;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cfib(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"compiling\"></a>\n",
    "# Compiling Python Code\n",
    "\n",
    "This simple notebook is an update of the notebook by Jake Vanderplas at https://jakevdp.github.io/blog/2013/06/15/numba-vs-cython-take-2/ to run on Python 3.5. It compares usage of cython and numba illustrating the ability to vastly increase speed of computation with some simple tricks. \n",
    "\n",
    "A very pithy description of this is that `X` contains $1000$ points in 3D space. The Euclidian distance between any two points can be calculated (vector length). This can be represented by a 1000 $\\times$ 1000 array containing all possible pairs. Calculating this in Python is slow. This can be easily sped up by \"precompiling\" the code. \n",
    "\n",
    "For more details on how to migrate to compiled code see [Hans Lantangen's tutorial](http://hplgit.github.io/primer.html/doc/pub/cython/cython-solarized.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.random.random((1000, 3))\n",
    "D = np.empty((1000, 1000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pure python version\n",
    "\n",
    "def pairwise_python(X, D):\n",
    "    M = X.shape[0]\n",
    "    N = X.shape[1]\n",
    "    for i in range(M):\n",
    "        for j in range(M):\n",
    "            d = 0.0\n",
    "            for k in range(N):\n",
    "                tmp = X[i, k] - X[j, k]\n",
    "                d += tmp * tmp\n",
    "            D[i, j] = np.sqrt(d)\n",
    "    return D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "# numba version\n",
    "\n",
    "import numpy as np\n",
    "from numba import double\n",
    "\n",
    "from numba import jit\n",
    "\n",
    "# The next line is the only \"change to the code\"\n",
    "@jit     # (arg_types=[double[:,:], double[:,:]])\n",
    "def pairwise_numba(X, D):\n",
    "    M = X.shape[0]\n",
    "    N = X.shape[1]\n",
    "    for i in range(M):\n",
    "        for j in range(M):\n",
    "            d = 0.0\n",
    "            for k in range(N):\n",
    "                tmp = X[i, k] - X[j, k]\n",
    "                d += tmp * tmp\n",
    "            D[i, j] = np.sqrt(d)\n",
    "    return D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We are going to load the Cython extension for Jupyter. \n",
    "\n",
    "- This allows us to put a few things into Python code. \n",
    "\n",
    "- Cython then turns it into C code, compiles it, and runs it in the background. \n",
    "\n",
    "The following won't work unless you have installed a C compiler:\n",
    "\n",
    "1. [Windows](https://github.com/cython/cython/wiki/InstallingOnWindows)\n",
    "  1. A quick way may be to [install MinGW](https://osdn.net/projects/mingw/downloads/68260/mingw-get-setup.exe/)\n",
    "2. Mac: Install the Apple Developer Tools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext Cython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "# The above declares that this cell is Cython code.\n",
    "\n",
    "# Load some cheats that help cython\n",
    "cimport cython\n",
    "\n",
    "# Load the sqrt function, but with cimport, also import knowledge of the variable \n",
    "# type used (it's a floating point)\n",
    "from libc.math cimport sqrt\n",
    "\n",
    "# Tell cython not to check if my indices called ae actually inside the array\n",
    "# This is a good move if you are ABSOLUTELY sure of it. It's a bad move otherwise. \n",
    "@cython.boundscheck(False)\n",
    "\n",
    "# This disallows use of negative indices. \n",
    "@cython.wraparound(False)\n",
    "def pairwise_cython(double[:, ::1] X, double[:, ::1] D):\n",
    "    cdef int M = X.shape[0]\n",
    "    cdef int N = X.shape[1]\n",
    "    cdef double tmp, d\n",
    "    for i in range(M):\n",
    "        for j in range(M):\n",
    "            d = 0.0\n",
    "            for k in range(N):\n",
    "                tmp = X[i, k] - X[j, k]\n",
    "                d += tmp * tmp\n",
    "            D[i, j] = sqrt(d)\n",
    "    return D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1 s ± 42.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%timeit pairwise_python(X, D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.11 ms ± 153 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit pairwise_numba(X, D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.49 ms ± 52.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit pairwise_cython(X, D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, the right way to code this up in Python is the following. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30.3 ms ± 636 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "def pairwise_numpy(X):\n",
    "    return np.sqrt(((X[:, None, :] - X) ** 2).sum(-1))\n",
    "%timeit pairwise_numpy(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is slower than compiled, but almost 10 times faster than looped Python. Just like Matlab- a few tricks can go a long ways. \n",
    "\n",
    "Frankly, `numba` is so easy it's the obvious choice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"parallel\"></a>\n",
    "# Parallel Processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modern computers almost always have multiple cores. Each core is *like* a separate CPU- it kind of acts like a separate computer. This allows them to do many things at the same time better than if processes have to share a single core. \n",
    "\n",
    "Most people will never need this- unless you desperately do. \n",
    "\n",
    "To speed up operations, programs can be written to use more than one core. [High Powered Computing](https://en.wikipedia.org/wiki/High-performance_technical_computing) can use multiple machines simultaneously. An explanation of this can be found in [An introduction to parallel programming using Python's multiprocessing module](https://sebastianraschka.com/Articles/2014_multiprocessing.html)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "import multiprocessing as mp\n",
    "import random\n",
    "import string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "import timeit\n",
    "widths = np.linspace(1.0, 1.2, 100)\n",
    "mu_vec = np.array([0,0])\n",
    "cov_mat = np.array([[1,0],[0,1]])\n",
    "widths = np.arange(0.1, 1.3, 0.1)\n",
    "point_x = np.array([[0],[0]])\n",
    "results = []\n",
    "\n",
    "n = 10000 # Add a zero to really test the value. \n",
    "x_2Dgauss = np.random.multivariate_normal(mu_vec, cov_mat, n)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "@jit(forceobj=True)\n",
    "def jit_parzen_estimation(x_samples, point_x, h):\n",
    "    k_n = 0\n",
    "    for row in x_samples:\n",
    "        x_i = (point_x - row[:,np.newaxis]) / (h)\n",
    "        for row in x_i:\n",
    "            if np.abs(row) > (1/2):\n",
    "                break\n",
    "        else: # \"completion-else\"*\n",
    "            k_n += 1\n",
    "    return (h, (k_n / 10000) / (h**3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "@jit(forceobj=True)\n",
    "def jit_serial(samples, x, widths):\n",
    "    return [jit_parzen_estimation(samples, x, w) for w in widths]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "574 ms ± 17.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "jit_serial(x_2Dgauss, point_x, widths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "@jit(parallel=True, forceobj=True)\n",
    "def jit_parzen_estimation(x_samples, point_x, h):\n",
    "    k_n = 0\n",
    "    for row in x_samples:\n",
    "        x_i = (point_x - row[:,np.newaxis]) / (h)\n",
    "        for row in x_i:\n",
    "            if np.abs(row) > (1/2):\n",
    "                break\n",
    "        else: # \"completion-else\"*\n",
    "            k_n += 1\n",
    "    return (h, (k_n / 10000) / (h**3))\n",
    "\n",
    "@jit(parallel=True)\n",
    "def jit_parallel(samples, x, widths):\n",
    "    return [jit_parzen_estimation(samples, x, w) for w in widths]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.3 ns ± 0.351 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "jit_parallel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"other_parallel\"></a>\n",
    "## Other parallel processing\n",
    "\n",
    "1. A relatively comprehensive list of parallel, cluster, and cloud computing tools [is available](https://wiki.python.org/moin/ParallelProcessing).\n",
    "\n",
    "2. Not listed and useful: [Dask](https://dask.org/)\n",
    "\n",
    "3. [IPyParallel](https://ipyparallel.readthedocs.io/)\n",
    "\n",
    "3. More notes are available at [Parallel Python: Analyzing Large Datasets](https://github.com/pydata/parallel-tutorial)\n",
    "\n",
    "4. You can [parallelize while compiling with Numba]()https://numba.pydata.org/numba-doc/dev/user/parallel.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"mycode\"></a>\n",
    "\n",
    "# Your own package\n",
    "\n",
    "\n",
    "Files containing functions are *modules*. Can can have as many functions as you want in a module (or objects... but I'm not covering object-oriented Python today).\n",
    "\n",
    "To load a module you can type:\n",
    "- `import module_name` # do not include the `.py`\n",
    "- `from \"module_name\" import \"function_name\"`\n",
    "- `from \"module_name\" import *` # sloppy practice, but sometimes obviously ok\n",
    "\n",
    "as long as either:\n",
    "1. The module is in your path.\n",
    "2. The module is in your current working directory. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are two simple modules. I could import them now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "ename": "ImportError",
     "evalue": "cannot import name 'add' from 'mycode' (unknown location)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mImportError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-106-4b49ecdf1411>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mmycode\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0madd\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mImportError\u001b[0m: cannot import name 'add' from 'mycode' (unknown location)"
     ]
    }
   ],
   "source": [
    "from mycode import add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "add(3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is ok, but requires you to move around directories. \n",
    "\n",
    "OK for a single project, but what if you have multiple projects that you want to pull together?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%cd ..\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What we typically want to do is be able to run the code, regardless of the current directory. \n",
    "\n",
    "If we edit it, it takes on the new definition. \n",
    "\n",
    "Spyder allows you to do this with a single module at a time. \n",
    "\n",
    "I've created a package template for you. \n",
    "\n",
    "We do this by installing it as a *package*.\n",
    "\n",
    "This will allow you to put all your modules in  `mycode\\mycode` and they will be accessible on your next `ipython` session (ipython is the enhanced environment- it is much better for interactive work). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating your first module\n",
    "1. move the top-level `mycode` folder to your Documents folder.\n",
    "2. Run the Anaconda Prompt\n",
    "3. type: `cd Documents\\mycode` and hit enter (use '/' instead of '\\' on mac or linux)\n",
    "4. type `dir` (use `ls` on Mac or Unix). You should see many things, one is a file names `setup.py` (this means you are ok so far). \n",
    "5. type `pip install -e .`. This command means install this package (`.`) in editable form `-e`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inside the lower level `mycode` folder is a file `__init__.py` with instructions. \n",
    "```\n",
    "# Uncomment the next line to import all functions in the mymath.py\n",
    "# file when importing mycode.\n",
    "\n",
    "# from .mymath import *\n",
    "\n",
    "# All functions in mystrings.py will be imported with mycode\n",
    "from .mystrings import *\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mymath must be explicitely imported to use it. \n",
    "import mycode.mymath\n",
    "mycode.mymath.add(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# The functions in mystrings are automatically imported\n",
    "mycode.concatenate('Hi ', 'there!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a *very* sophisticated template, see [Alex Ioannides' resource](https://github.com/AlexIoannides/py-package-template)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"other\"></a>\n",
    "## Other resources\n",
    "\n",
    "1. [Numpy for Matlab users](https://numpy.org/doc/stable/user/numpy-for-matlab-users.html)\n",
    "2. [SciPy - Introduction](https://www.tutorialspoint.com/scipy/scipy_introduction.htm)\n",
    "3. [SciPy Lecture Notes](https://scipy-lectures.org/index.html)\n",
    "4. [SciPy tutorial](https://www.guru99.com/scipy-tutorial.html)\n",
    "5. [SciPy Cookbook](https://scipy-cookbook.readthedocs.io/)\n",
    "5. [matplotlib tutorial](https://matplotlib.org/tutorials/)\n",
    "6. [Python Plotting With Matplotlib](https://realpython.com/python-matplotlib-guide/#pylab-what-is-it-and-should-i-use-it)\n",
    "7. [Pandas Cookbook](https://github.com/jvns/pandas-cookbook)\n",
    "8. [Lorena Barba's Numerical Python MOOC](https://github.com/numerical-mooc/numerical-mooc)\n",
    "9. [SciPy Cookbook](https://scipy-cookbook.readthedocs.io/)\n",
    "10. [Full set of notes for a Scientific Python Course](https://github.com/scipy-lectures/scipy-lecture-notes)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8.5"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 0,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "notify_time": "5",
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "440px",
    "width": "351px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "widgets": {
   "state": {
    "08fc4d14933342cc8d1204fb294b85b3": {
     "views": [
      {
       "cell_index": 43
      }
     ]
    }
   },
   "version": "1.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}