06_PlottingWithPython.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting and Fitting with Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import numpy as np\n",
    "from astropy.table import QTable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "t = np.linspace(0,2,100)               # 100 points linearly spaced between 0.0 and 2.0\n",
    "s = np.cos(2*np.pi*t) * np.exp(-t)     # s if a function of t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.plot(t,s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple plotting - with *style*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The default style of `matplotlib` is a bit lacking in style. Some would term it ugly. The new version of `matplotlib` has added some new styles that you can use in place of the default. Changing the style will effect all of the rest of the plots on the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.style.available"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.style.use('ggplot')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.plot(t,s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.xlabel('time (s)')\n",
    "plt.ylabel('voltage (mV)')\n",
    "plt.title('This is a title')\n",
    "\n",
    "plt.ylim(-1.5,1.5)\n",
    "\n",
    "plt.plot(t, s, color='b', marker='None', linestyle='--');   # adding the ';' at then suppresses the Out[] line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mask1 = np.where((s>-0.4) & (s<0))\n",
    "\n",
    "plt.plot(t, s, color='b', marker='None', linestyle='--')\n",
    "\n",
    "plt.plot(t[mask1],s[mask1],color=\"g\",marker=\"o\",linestyle=\"None\",markersize=8);"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "  Colors                 Markers                Linestyles\n",
    "                                       \n",
    "'b'     blue         's'        square          '-'   Solid line\n",
    "'g'     green        'o'        circle          '--'  Dashed \n",
    "'r'     red          '^'        triangle        ':'   Dotted \n",
    "'c'     cyan         '+'        plus            '-.'  Dash Dot \n",
    "'m'     magenta      '.'        dot             \n",
    "'y'     yellow       '*'        star \n",
    "'k'     black        'D'        diamond         size in pts (72 pt = 1 in)\n",
    "'w'     white        'x'        cross   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### In addition, you can specify colors in many different ways:\n",
    "\n",
    "- Grayscale intensities: `color = '0.8'`\n",
    "- RGB triplets: `color = (0.3, 0.1, 0.9)`\n",
    "- Hex strings: `color = '#7ff00'`\n",
    "- [HTML color names](http://www.w3schools.com/html/html_colornames.asp): `color = 'Chartreuse'`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### matplotlib will work with Astropy units"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from astropy import units as u\n",
    "\n",
    "from astropy.visualization import quantity_support\n",
    "quantity_support()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "v = 10 * u.m / u.s\n",
    "t2 = np.linspace(0,10,1000) * u.s\n",
    "y = v * t2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.plot(t2,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Histogram of \"h\" with 20 bins\n",
    "\n",
    "np.random.seed(42)\n",
    "h = np.random.randn(500)\n",
    "\n",
    "plt.hist(h, bins=20, facecolor='MediumOrchid');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mask2 = np.where(h>0.0)\n",
    "\n",
    "np.random.seed(42)\n",
    "j = np.random.normal(2.0,1.0,300)  # normal dist, ave = 2.0, std = 1.0\n",
    "\n",
    "plt.hist(h[mask2], bins=20, facecolor='#b20010', histtype='stepfilled')\n",
    "plt.hist(j,        bins=20, facecolor='#0200b0', histtype='stepfilled', alpha = 0.30);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## You have better control of the plot with the `object oriented` interface.\n",
    "\n",
    "While most ``plt`` functions translate directly to ``ax`` methods (such as ``plt.plot()`` → ``ax.plot()``, ``plt.legend()`` → ``ax.legend()``, etc.), this is not the case for all commands.\n",
    "In particular, functions to set limits, labels, and titles are slightly modified.\n",
    "For transitioning between matlab-style functions and object-oriented methods, make the following changes:\n",
    "\n",
    "- ``plt.xlabel()``  → ``ax.set_xlabel()``\n",
    "- ``plt.ylabel()`` → ``ax.set_ylabel()``\n",
    "- ``plt.xlim()``  → ``ax.set_xlim()``\n",
    "- ``plt.ylim()`` → ``ax.set_ylim()``\n",
    "- ``plt.title()`` → ``ax.set_title()``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots(1,1)                    # One window\n",
    "fig.set_size_inches(11,8.5)                   # (width,height) - letter paper landscape\n",
    "\n",
    "fig.tight_layout()                          # Make better use of space on plot\n",
    "\n",
    "ax.set_xlim(0.0,1.5)\n",
    "\n",
    "ax.spines['bottom'].set_position('zero')    # Move the bottom axis line to x = 0\n",
    "\n",
    "ax.set_xlabel(\"This is X\")\n",
    "ax.set_ylabel(\"This is Y\")\n",
    "\n",
    "ax.plot(t, s, color='b', marker='None', linestyle='--')\n",
    "\n",
    "ax.text(0.8, 0.6, 'Bad Wolf', color='green', fontsize=36)            # You can place text on the plot\n",
    "\n",
    "ax.vlines(0.4, -0.4, 0.8, color='m', linewidth=3)                    # vlines(x, ymin, ymax)\n",
    "ax.hlines(0.8,  0.2, 0.6, color='y', linewidth=5)                    # hlines(y, xmin, xmax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fig.savefig('fig1.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "!ls *.png"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "!display fig1.png"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subplots\n",
    "- `subplot(rows,columns)`\n",
    "- Access each subplot like a matrix. `[x,y]`\n",
    "- For example: `subplot(2,2)` makes four panels with the coordinates:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    " [0,0] [0,1]\n",
    " [1,0] [1,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(2,2)                                               # 2 rows 2 columns\n",
    "fig.set_size_inches(11,8.5)                                               # width, height\n",
    "\n",
    "fig.tight_layout()                                                        # Make better use of space on plot\n",
    "\n",
    "ax[0,0].plot(t, s, color='b', marker='None', linestyle='--')              # Plot at [0,0]\n",
    "\n",
    "ax[0,1].hist(h, bins=20, facecolor='MediumOrchid')                        # Plot at [0,1]\n",
    "\n",
    "ax[1,0].hist(j,bins=20, facecolor='HotPink', histtype='stepfilled')       # Plot at [1,0]\n",
    "\n",
    "ax[1,1].set_xscale('log')                                                 # Plot at [1,1] - x-axis set to log\n",
    "ax[1,1].plot(t, s, color='r', marker='None', linestyle='--'); "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## An Astronomical Example - Color Magnitude Diagrams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "T = QTable.read('M15_Bright.csv', format='ascii.csv')\n",
    "T[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1,2)                 # 1 row, 2 colums\n",
    "fig.set_size_inches(15,5)\n",
    "\n",
    "fig.tight_layout()\n",
    "\n",
    "# The plot for [0,0]\n",
    "\n",
    "ax[0].set_xlim(-40,140)\n",
    "ax[0].set_ylim(-120,120)\n",
    "\n",
    "ax[0].set_aspect('equal')                    # Force intervals in x = intervals in y\n",
    "ax[0].invert_xaxis()                         # RA increases to the left!\n",
    "\n",
    "ax[0].set_xlabel(\"$\\Delta$RA [sec]\")\n",
    "ax[0].set_ylabel(\"$\\Delta$Dec [sec]\")\n",
    "\n",
    "ax[0].plot(T['RA'], T['Dec'],color=\"g\",marker=\"o\",linestyle=\"None\",markersize=5);\n",
    "\n",
    "# The plot for [0,1]\n",
    "\n",
    "BV = T['Bmag'] - T['Vmag']\n",
    "V = T['Vmag']\n",
    "\n",
    "ax[1].set_xlim(-0.25,1.5)\n",
    "ax[1].set_ylim(12,19)\n",
    "\n",
    "ax[1].set_aspect(1/6)         # Make 1 unit in X = 6 units in Y\n",
    "ax[1].invert_yaxis()          # Magnitudes increase to smaller values\n",
    "\n",
    "ax[1].set_xlabel(\"B-V\")\n",
    "ax[1].set_ylabel(\"V\")\n",
    "\n",
    "ax[1].plot(BV,V,color=\"b\",marker=\"o\",linestyle=\"None\",markersize=5);\n",
    "\n",
    "# overplotting\n",
    "\n",
    "maskC = np.where((V < 16.25) & (BV < 0.55))     \n",
    "\n",
    "ax[0].plot(T['RA'][maskC], T['Dec'][maskC],color=\"r\",marker=\"o\",linestyle=\"None\",markersize=4, alpha=0.5)\n",
    "ax[1].plot(BV[maskC], V[maskC],color=\"r\",marker=\"o\",linestyle=\"None\",markersize=4, alpha=0.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Curve Fitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "D1 = QTable.read('data1.csv', format='ascii.csv')\n",
    "D1[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.plot(D1['x'],D1['y'],marker=\"o\",linestyle=\"None\",markersize=5);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 1-D fit y = ax + b\n",
    "\n",
    "Fit1 = np.polyfit(D1['x'],D1['y'],1)\n",
    "\n",
    "Fit1       # The coefficients of the fit (a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Yfit = np.polyval(Fit1,D1['x'])   # The polynomial of Fit1 applied to the points D1['x']\n",
    "\n",
    "plt.plot(D1['x'], D1['y'], marker=\"o\", linestyle=\"None\", markersize=5)\n",
    "\n",
    "plt.plot(D1['x'], Yfit, linewidth=4, color='c', linestyle='--')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "D2 = QTable.read('data2.csv', format='ascii.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.plot(D2['x'],D2['y'],marker=\"o\",linestyle=\"None\",markersize=5);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 2-D fit y = ax**2 + bx + c\n",
    "\n",
    "Fit2 = np.polyfit(D2['x'],D2['y'],2)\n",
    "\n",
    "Fit2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Yfit = np.polyval(Fit2,D2['x'])\n",
    "\n",
    "plt.plot(D2['x'], D2['y'], marker=\"o\", linestyle=\"None\", markersize=5)\n",
    "\n",
    "plt.plot(D2['x'], Yfit, linewidth=3, color='y', linestyle='--');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Be careful, very high-order fits may be garbage\n",
    "\n",
    "Fit3 = np.polyfit(D1['x'],D1['y'],20)\n",
    "\n",
    "xx = np.linspace(0,10,200)\n",
    "\n",
    "Yfit = np.polyval(Fit3,xx)\n",
    "\n",
    "plt.plot(D1['x'], D1['y'], marker=\"o\", linestyle=\"None\", markersize=8)\n",
    "plt.plot(xx, Yfit, linewidth=3, color='m', linestyle='--');\n",
    "\n",
    "plt.ylim(-20,120)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fitting a specific function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "D3 = QTable.read('data3.csv', format='ascii.csv')\n",
    "\n",
    "plt.plot(D3['x'],D3['y'],marker=\"o\",linestyle=\"None\",markersize=5);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from scipy.optimize import curve_fit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\Large f(x) = a \\sin(bx) $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def ringo(x,a,b):\n",
    "    return a*np.sin(b*x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Aguess = 75\n",
    "Bguess = 1.0/5.0\n",
    "\n",
    "fitpars, error = curve_fit(ringo,D3['x'],D3['y'],p0=[Aguess,Bguess])\n",
    "\n",
    "# Function to fit = ringo\n",
    "# X points to fit = D3['x']\n",
    "# Y points to fit = D3['y']\n",
    "# Initial guess at values for a,b = [Aguess,Bguess]\n",
    "\n",
    "print(fitpars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Z = np.linspace(0,100,1000)\n",
    "\n",
    "plt.plot(Z, ringo(Z, *fitpars), 'r-')\n",
    "plt.plot(Z, ringo(Z,Aguess,Bguess), 'g--')\n",
    "\n",
    "plt.plot(D3['x'],D3['y'],marker=\"o\",linestyle=\"None\",markersize=5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bad initial guesses can lead to very bad fits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Aguess = 35\n",
    "Bguess = 1.0\n",
    "\n",
    "fitpars, error = curve_fit(ringo,D3['x'],D3['y'],p0=[Aguess,Bguess])\n",
    "\n",
    "print(fitpars)\n",
    "\n",
    "plt.plot(Z, ringo(Z, *fitpars), 'r-')\n",
    "plt.plot(Z, ringo(Z,Aguess,Bguess), 'g--')\n",
    "\n",
    "plt.plot(D3['x'],D3['y'],marker=\"o\",linestyle=\"None\",markersize=5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Interactive Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from ipywidgets import interact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def PlotSin(f):\n",
    "    x = np.linspace(0,1,100)\n",
    "    y = np.sin(2.0 * np.pi * x * f)\n",
    "    plt.ylim(-1.1,1.1)\n",
    "    plt.xlim(0,1)\n",
    "    plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "PlotSin(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "interact(PlotSin, f=(1,10,0.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def PlotSinA(f,a):\n",
    "    x = np.linspace(0,1,100)\n",
    "    y = a * np.sin(2.0 * np.pi * x * f)\n",
    "    plt.xlim(0,1)\n",
    "    plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "interact(PlotSinA, f = (1,10,0.5), a = (1,10,0.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting Extras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding Legends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "theta = np.linspace(0.0,2*np.pi,300)\n",
    "\n",
    "y1 = abs(np.sin(theta))\n",
    "y2 = -abs(np.cos(theta))\n",
    "\n",
    "plt.plot(theta, y1, color=\"b\", label=\"|Sin|\")\n",
    "plt.plot(theta, y2, color=\"r\", label=\"-|Cos|\")\n",
    "\n",
    "plt.legend(loc=0,shadow=True);"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Legend loc codes:\n",
    "\n",
    "0   best                6   center left\n",
    "1   upper right         7   center right\n",
    "2   upper left          8   lower center\n",
    "3   lower left          9   upper center\n",
    "4   lower right         10  center"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Polar Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.polar(theta,theta/5.0,label=\"spiral\")\n",
    "plt.polar(theta,np.cos(4*theta),label=\"flower\")\n",
    "\n",
    "plt.legend(loc=2, frameon=False);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Everyone likes Pie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.axis('equal')\n",
    "\n",
    "labels = ('John', 'Paul' ,'George' ,'Ringo')     # Name of slices\n",
    "sizes = [0.3, 0.15, 0.45, 0.10]                  # Size of slices\n",
    "colors = ['r', 'g', 'b', 'c']                    # Color of Slices\n",
    "explode = (0, 0, 0.1, 0)                         # Offset slide 3\n",
    "\n",
    "plt.pie(sizes,explode=explode,labels=labels,colors=colors,shadow=True);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pseudo 3D plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "ax = plt.axes(projection='3d')\n",
    "xx = np.cos(3*theta)\n",
    "yy = np.sin(2*theta)\n",
    "\n",
    "ax.plot(theta,xx,yy);\n",
    "ax.view_init(azim = -140,elev = 15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}