Tutorial010_IntroNumpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Intro to NumPy\n",
    "\n",
    "-  [based on this numpy quickstart guide](https://docs.scipy.org/doc/numpy/user/quickstart.html)\n",
    "\n",
    "-  [full list of routines](https://docs.scipy.org/doc/numpy-dev/reference/routines.html#routines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy and other stuff for this tutorial\n",
    "import numpy as np\n",
    "from numpy import pi\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import norm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## initialize array and a few basic operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(10,)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# set up an array and figure out shape...    \n",
    "my_array = np.arange(10)    # the interval includes `start` but excludes `stop`, overal interval [start...stop-1]\n",
    "print(my_array)\n",
    "my_array.shape     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "cannot reshape array of size 100 into shape (2,2,26)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-563593bda49c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# reshape array\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mmy_array\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mmy_array\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmy_array\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m26\u001b[0m\u001b[0;34m)\u001b[0m   \u001b[0;31m# why is (2,5) and (5,2) ok but (2,6) not ok?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mmy_array\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_array\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: cannot reshape array of size 100 into shape (2,2,26)"
     ]
    }
   ],
   "source": [
    "# reshape array\n",
    "my_array = np.arange(100)\n",
    "my_array = my_array.reshape(2,2,25)   # why is (2,5) and (5,2) ok but (2,6) not ok? \n",
    "my_array.shape   \n",
    "print(my_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
      " 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41]\n",
      "[[[ 0  1  2  3  4  5  6]\n",
      "  [ 7  8  9 10 11 12 13]\n",
      "  [14 15 16 17 18 19 20]]\n",
      "\n",
      " [[21 22 23 24 25 26 27]\n",
      "  [28 29 30 31 32 33 34]\n",
      "  [35 36 37 38 39 40 41]]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(2, 3, 7)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# neat trick...can also reshape with 'shape' and use a -1 which means 'whatever works' \n",
    "my_array = np.arange(42)\n",
    "print(my_array)\n",
    "my_array.shape = 2,3,7\n",
    "print(my_array)\n",
    "my_array.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## data types (and remember - strong typed language)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dims of data:  3\n",
      "Size of each element (bytes):  8\n",
      "Total number of elements in array:  42\n",
      "Name of data type:  int64\n"
     ]
    }
   ],
   "source": [
    "print('Dims of data: ', my_array.ndim)              # number of dims\n",
    "print('Size of each element (bytes): ', my_array.itemsize)          # size of each element in bytes\n",
    "print('Total number of elements in array: ', my_array.size)         # total number of elements in array\n",
    "print('Name of data type: ', my_array.dtype.name)   # name of data type (float, int32, int64 etc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'float64'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# will infer data type based on input values...here we have 1 float so the whole thing is float\n",
    "float_array = np.array([1.2,2,3])  \n",
    "float_array.dtype.name             # or np.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'int32'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_array = np.array([[1,2,3], [6,7,8]], dtype = 'int32')   # complex, float32, float64, int32, uint32 (unsigned int32), etc\n",
    "int_array.dtype\n",
    "print(int_array.shape)\n",
    "int_array\n",
    "int_array.dtype.name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "what happens if you initialize with floating point numbers but you declare an int data type?\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [6, 7, 8]], dtype=int32)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_array = np.array([[1.1,2.7,3.4], [6.9,7.5,8.2]], dtype = 'int32')   # complex, float32, float64, int32, uint32 (unsigned int32), etc\n",
    "int_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Allocate arrays of zeros, ones or rand to reserve the memory before filling up later "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "handy when you know what size you need, but you're not ready to fill it up yet...saves you from dynamically resizing the matrix during analysis, which is very slow\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data type: float64\n",
      "Data type: int32\n",
      "[[0 0 0 0]\n",
      " [0 0 0 0]\n",
      " [0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "# note the () around the dims because you specify as a tuple...default type is float64\n",
    "zero_array = np.zeros( (3,4) )   \n",
    "print('Data type:', zero_array.dtype)\n",
    "\n",
    "# explicilty declare data type\n",
    "zero_array = np.zeros( (3,4), dtype=np.int32)   # \n",
    "print('Data type:', zero_array.dtype)\n",
    "print(zero_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[10., 10., 10., 10.],\n",
       "        [10., 10., 10., 10.],\n",
       "        [10., 10., 10., 10.],\n",
       "        [10., 10., 10., 10.]],\n",
       "\n",
       "       [[10., 10., 10., 10.],\n",
       "        [10., 10., 10., 10.],\n",
       "        [10., 10., 10., 10.],\n",
       "        [10., 10., 10., 10.]],\n",
       "\n",
       "       [[10., 10., 10., 10.],\n",
       "        [10., 10., 10., 10.],\n",
       "        [10., 10., 10., 10.],\n",
       "        [10., 10., 10., 10.]],\n",
       "\n",
       "       [[10., 10., 10., 10.],\n",
       "        [10., 10., 10., 10.],\n",
       "        [10., 10., 10., 10.],\n",
       "        [10., 10., 10., 10.]]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ones\n",
    "# note the 3D output below...4, 4x4 squares of floating point 1s...\n",
    "np.ones( (4,4,4), dtype=np.float64 ) * 10     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1.e-45, 0.e+00],\n",
       "        [1.e-45, 0.e+00]],\n",
       "\n",
       "       [[1.e-45, 0.e+00],\n",
       "        [0.e+00, 0.e+00]]], dtype=float32)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# and empty...not really 'empty' but initialized with varible output determined by current state of memory\n",
    "np.empty( (2,2,2), dtype = np.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Can also create sequences of numbers using arange..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "seq_array = np.arange(10)    # 0-9...remember - counting starts at 0! \n",
    "print(seq_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  5 10 15 20 25 30]\n"
     ]
    }
   ],
   "source": [
    "# can specify start, stop and step\n",
    "seq_array = np.arange(0,30,5)     # start, stop (stop at < X), step size\n",
    "print(seq_array)\n",
    "# note that 30 is not in there..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.      0.56788 1.13576 1.70364 2.27152 2.8394  3.40728 3.97516 4.54304\n",
      " 5.11092 5.6788  6.24668 6.81456 7.38244 7.95032 8.5182  9.08608 9.65396]\n"
     ]
    }
   ],
   "source": [
    "seq_array = np.arange(0,10,.56788)    # decimal input is ok too (and again - stop is NOT included)\n",
    "print(seq_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "Because of machine precision issues, sometimes hard to predict how many elements will end up in an array when initialized using arange...so often better to specify a sequence based on start point, stop point, and the exact number of elements that you want (or the number of steps between start and stop). linspace (linear spacing) is the function to do this, and note that unlike arange that ends < stop point, linspace will always end exactly at the specified stop point. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.   2.5  5.   7.5 10.  12.5 15.  17.5 20. ]\n"
     ]
    }
   ],
   "source": [
    "# start, stop, number of linearly spaced steps between start and stop...note that start AND stop included!\n",
    "lin_array = np.linspace(0,20,9) \n",
    "print(lin_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common use of linspace in this class...eval a function over an interval. quick intro to basic plotting here too..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "  alpha: float (0.0 transparent through 1.0 opaque) \n",
      "  animated: bool \n",
      "  antialiased or aa: bool \n",
      "  clip_box: a `.Bbox` instance \n",
      "  clip_on: bool \n",
      "  clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "  color or c: any matplotlib color \n",
      "  contains: a callable function \n",
      "  dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "  dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "  dashes: sequence of on/off ink in points \n",
      "  drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "  figure: a `.Figure` instance \n",
      "  fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "  gid: an id string \n",
      "  label: object \n",
      "  linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "  linewidth or lw: float value in points \n",
      "  marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "  markeredgecolor or mec: any matplotlib color \n",
      "  markeredgewidth or mew: float value in points \n",
      "  markerfacecolor or mfc: any matplotlib color \n",
      "  markerfacecoloralt or mfcalt: any matplotlib color \n",
      "  markersize or ms: float \n",
      "  markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "  path_effects: `.AbstractPathEffect` \n",
      "  picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "  pickradius: float distance in points\n",
      "  rasterized: bool or None \n",
      "  sketch_params: (scale: float, length: float, randomness: float) \n",
      "  snap: bool or None \n",
      "  solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "  solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "  transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "  url: a url string \n",
      "  visible: bool \n",
      "  xdata: 1D array \n",
      "  ydata: 1D array \n",
      "  zorder: float \n"
     ]
    }
   ],
   "source": [
    "lin_array = np.linspace(0, 2*pi, 360)\n",
    "sin_wave = np.sin(lin_array)\n",
    "\n",
    "# plotting\n",
    "\n",
    "h = plt.plot(lin_array*180/pi, sin_wave, 'k-', linewidth = 4)    # specify x,y data...convert rad to deg for x-axis\n",
    "\n",
    "# label each axis and give it a title\n",
    "plt.xlabel('angle (deg)')\n",
    "plt.ylabel('Amplitude')\n",
    "plt.title('Sin Wave')\n",
    "plt.grid(1)\n",
    "plt.show()\n",
    "\n",
    "# figure out all settings to tweak...\n",
    "plt.setp(h) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## initializing arrays with random numbers...use np.random.rand and np.random.randn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 1. 0. 1. 1. 0. 0. 0. 1. 0. 0. 0. 1. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "rand_array = np.random.rand(1,16)   # drawn from uniform over [0,1]\n",
    "np.round(rand_array)\n",
    "print(np.round(rand_array))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5.47013863 4.51228546 4.59673513 4.47575356 5.88186256 5.85662267]\n",
      " [4.71135236 5.17334687 4.23160569 5.94606782 4.15223401 3.43355071]]\n"
     ]
    }
   ],
   "source": [
    "rand_array = np.random.randn(2,6)  # drawn from normal with mean 0 and variance 1\n",
    "print(rand_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## use randn to generate draws from a normal distribtion with mean = mu and variance = sig and then plot..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEYCAYAAAB2qXBEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl4FFXW+PHvyUISSAIkgMoaFURRBAEFdAZBQEUF3HjFccYVUUYQ3BB0dBzUGcBBX7dh4EVB/bkDo4iiiIiMjoAgm2yCggOC7CRsCVnO74+qYJNUJx06vSXn8zz9pOveW9Wn0kmfrltV94qqYowxxhyvuEgHYIwxJrZZIjHGGBMUSyTGGGOCYonEGGNMUCyRGGOMCYolEmOMMUGxRGKMMSYolkiMMcYExRJJFBGRVSLSNYKv31JElorIfhG5OwKvP0VEngj36warIu+biGwSkR4Vrass5cUajhiqO3H8JCKnRjqWymKJJEy8/kFF5GYR+bJ4WVXPVNV5Fd1OJRoOzFPVNFV9LkSvUeUE8r5FC99YLWlEhjqaqeoPkY6lslgiMb6aAasCaSgiCSGOJerZ78AYhyWSKOL7DVFEHhSRn91upnUi0l1EXgOaAh+IyAERGe62PUNE5onIPrfrok8Zr+HZVkTmAt2AF9xtn+YnvgdFZAVwUEQSRGSEiPzgxrlaRK7yWOd+EVkhItki8raIJLt154jIt+66bwPJgcTqs90H3O0eFJGXROQEEZnlbm+OiNT18zsYISJTS5Q9KyLP+dR77pOf34Hv+1bm78N1rlu3V0QmF/8+POJsKCLTRGSniGz0190oIreIyAc+yxtE5B2f5c0i0tYn/h7+/pZcbb3eL4/XfVhExvss1xWRfH/tK0JEBojIJyIy3v09fS8irURkqIj8V0R2icjVbtsnReR/fdZt7P5NlPv5JiKJ7vqb3NjVfSyvhH04RURmurFmi8inPvv2nvs8TkQedd+jrSLSW0SO+PvbjVqqao8wPIBNQI8SZTcDX5ZsA7QENgMN3fIs4FSv7QCJwAbgIaAGcBGwH2jpEUOZbYF5wIBy9mEZ0ARIccv6AQ1xvpRcBxwETiqxziK3TQawBrjTff2fgHvcuK4F8oEnAox1E7AAOAFoBOwAvgXOAZKAucCf/exHM+AQkO4uxwPbgE7l7ZOf38HR9yTA38d37voZwFc+++y7nThgCfCou/+nAD8Cl3jszynAPnedk9zf688+dXuBOI/XOPq8vPfLz+/xLeAOn+VuwHce7Wa68Xk9ZvrZ9nPAbqC7+/5Mc/drqPu3MRT41m37IXCLz7qXA4sC/L8c4/4dNQFqAXOA6cAplbAPXwJ3ufEnAxf47Ntf3OejgPk4f8N1gK+BzZH+vKroI+IBVJeH+w96oMQf4CG8E0lznA/GHkCix3Z8E8lvgV+KPyjcsjeBxzxiKLMtgSWSW8vZz2VA3xLr/N5neSzwT6ALsBUQn7r/8OuHanmxbgJu8KmbBoz3WR4CvFdGnF8CN7rPewI/BLJPXr+Dku9JAL+PO32WLyt+bY79kO8I/LfEtkYCk/28zmagHdAfmIiTDE4HbgFmeMXqFbe/98vPa64COvos3wO8Xkn/L18A9/ssP47PBzZOglnhPv8ZaO9T9xAwKYDXSAMOAy18ygbhnCesjH3YBtwN1PDYt6uB+jhfjpr71P0F+KgyXj+cD+vaCq8rVbVO8QP4o1cjVd0ADAMeA3aIyFsi0tDPNhvifIMp8in7CecbTjBt/dnsuyAiN4rIMrf7aR9wFlCvxDq/+Dw/BKS6sfys7n+PTywViXW7z/PDHsupZezHG8D17vPfucuB7tMxvwNfAf4+fNf/CWdfS2oGNCzejruth3COwLx8AXTFSdBf4HwpuNB9fOEvXj+83q9jiEgN4FRgpU9xG5zEWRnOxjkKKNbKY3mtiNTH+Z34nttrAwTSNdUF+FFV1/uU1eXY/Q/GDUBfYKvb9Zrhlp/txtcd2OD+vxfL4NjfaUywRBKlVPUNVf0NzgeK4hyC4z73tRVoUqI/uCnOt7SSKtLWb2jFT0SkGfB/wGAg002O3wESwHa2AY1ExLdt00qOtSzvAl1FpDFwFW4iCXCfPCfxqcDvo4nP86Y4+1rSZmCj7xcPda6mu8zP/hQnkt+6z7+g/EQSzGRErXC+CBwC55JW9/VLfYC7560O+HnM8mjfDKc773uf4rYcm6TOdpfPBNaraq67bgJOF9uKAPahPk63X/HrCs7fwsySDSu6DwCqOldVu+P8rtoAN7v7loDTTVkPn/deROKBXgHGHlUskUQhce7nuEhEkoBcnG/XhW71dpx+72ILcfrhh7snDrsCvXH6r0uqSNtA1ML5MNrpxn0LzjfwQHwNFAB3i3PC+mrgvBDGegxV3YnzrX0yzgf2GrcqmH0KdN273BPCGThHGW97tFkE5IhzYj9FROJF5CwROdfPa3+B8wGaoqpbgH8DlwKZwFI/65T8W6qI1kADETlVRFJwup6a4XSNHUNVe6lqqp9HL49ttwFWFh+Niki6u+0VJdosx0nSNd2/oTicrrj6vm3FuT9pisfrfAe0E5G27j78Def9K/V+VHQfRORqEWnhJqc0nCOdZW7cK9wj8TXA+SLS3N3H5yh9lBcTLJFEpyRgNLAL5zC7Ac4HDjh/7H9yuzvuV9UjQB+cbzK7gH/g9P2vLbnRirQNhKquBsbhJIXtOB8uXwW47hGcfuKbcb4VXodzkjMksfrxBs55qKPdWkHuU6DrvgHMxvlW+iNQ6iZMVS3ESZxtgY04v4NJQG0/r/09zjm4f7vLOe62v3K35eWYv6VA9tFHa+ATYBbORRHb3dd7uILb8VKyi+xsnC6g4qOfOJwEvQxnf1cAa4FPgf8CW1R1r8/6TfB4H1R1MfAk8JEb+4nAZaqaXwn78Buc5L7f3f5oVZ3r7tsK9/U/wznvtxRY7O7PIXdfYooc20VtjDHlc7tzJqnqtEjHUhb3XM5y4OxKShAhIyJ3Aperau9Ix1JRdkOVMeZ4tMbpmolq7pHtGZGOw4uIdMI5V7gZ58T7KJyj8JhjicQYUyHuzXINgPXltTVlOgfnHphEnAsLblbVBZEN6fhY15Yxxpig2Ml2Y4wxQakWXVv16tXTrKysSIdhjDExZcmSJbtUtX557apFIsnKymLx4sWRDsMYY2KKiPxUfivr2jLGGBMkSyTGGGOCYonEGGNMUCyRGGOMCYolEmOMMUGxRGKMMSYolkiMMcYExRKJMcaYoFgiMcYYE5RqcWe7MeGWNeLDgNptGn15iCMxJvTsiMQYY0xQ7IjEmBhgRzgmmtkRiTHGmKBYIjHGGBMUSyTGGGOCYonEGGNMUCyRGGOMCYolEmOMMUGxRGKMMSYolkiMMcYExRKJMcaYoFgiMcYYExRLJMYYY4JiicQYY0xQLJEYY4wJiiUSY4wxQbFEYowxJiiWSIwxxgTFEokxxpigWCIxxhgTFEskxhhjgmKJxBhjTFAskRhjjAmKJRJjjDFBsURijDEmKJZIjDHGBCWkiURELhWRdSKyQURGeNQnicjbbv1CEclyy3uKyBIRWen+vMhnnfZu+QYReU5EJJT7YIwxpmwJodqwiMQDLwI9gS3ANyIyQ1VX+zS7Ddirqs1FpD8wBrgO2AX0VtWtInIW8AnQyF1nPDAQWAB8BFwKzArVfhhTUdu3byd/92aIS0Di4iEuzv1Zcjk+0qEaUylClkiA84ANqvojgIi8BfQFfBNJX+Ax9/lU4AUREVVd6tNmFZAsIklABpCuql+723wVuBJLJCYKfP/999xxxx3Mmzcv4HXqTqzDtddey5gxY8jIyAhdcMaEUCi7thoBm32Wt/DrUUWpNqpaAGQDmSXaXAMsVdU8t/2WcrZpTFipKhMmTOCcc86pUBIB2LdvH5MmTWLhwoWhCc6YMAjlEYnXuQutSBsROROnu+viCmyzeN2BOF1gNG3atLxYjTkuO3bs4LbbbmPmzJnHvY1hw4bRq1evSozKmPAK5RHJFqCJz3JjYKu/NiKSANQG9rjLjYF/ATeq6g8+7RuXs00AVHWiqnZQ1Q7169cPcleMKW3mzJm0bt06qCTSrl07Ro8eXYlRGRN+oUwk3wAtRORkEakB9AdmlGgzA7jJfX4tMFdVVUTqAB8CI1X1q+LGqroN2C8indyrtW4E3g/hPhhTysGDB7nzzjvp3bs3O3bsOO7tSI0U3nrrLZKSkioxOmPCL2RdW6paICKDca64igdeVtVVIjIKWKyqM4CXgNdEZAPOkUh/d/XBQHPgERF5xC27WFV3AIOAKUAKzkl2O9FugpY14sOA2r17TQNuuOEG1q9fX3bD+EQS0jLRwkLQQrSoEIp8fhYcIe2cy2jevHklRG9MZIXyHAmq+hHOJbq+ZY/6PM8F+nms9wTwhJ9tLgbOqtxIjSlf9sJpnD/uNQoKCspsd84557C93UAS6zUps52q5+k9T0VHDhNXIyXg9saEU0gTiTFVicQnlJlERIQHH3yQv/zlL5z26Kflb0+Ek0d+VG67vJ/XsGPqKDIuHkStM7pUKGZjwsGGSDEmQGnte9OzZ0/PuqZNmzJv3jz+9re/UaNGjUp7zcLcA+yc8RRFufvZNWMs2QumVtq2jakslkiMCZBIHFOmTCl14+Dvf/97VqxYQZculXu0oKrsmfUchTm/ntDf98UrHN64tIy1jAk/SyTGVEDDhg2ZMGECAHXq1OHNN9/ktddeo3bt2pX+WgeWzeLQ9/8pUars+nAchQf3VvrrGXO8LJEYU0HXXnst48aNY8WKFfTv37/8FY5DUd5B9s6b4l13cB+7Zj6NalFIXtuYirJEYsxxuPfee2nSpOyrsoIRl1SLE/o/SVxyqmd97qal5CyaHrLXN6Yi7KotU6UFen9INEo6qQX1rhzJjrf+hNdIQPvmv0Zy47NIanR6+IMzxocdkRjjQ4sKIx3CMVKatSG98/94VxYVsvODpyjKPRDeoIwpwRKJMa78vdvYOnEghzYsinQox6jzm9+R1KiVZ11h9nZ2f/xChW5uNKayWSIxBtCCfHa9P5qC7O3snDaKvZ+/jBaWfQd7uEhcPPX63E9cUi3P+kPrvuTA8k/CHJUxv7JEYgywd97LHNn+w9HlnEXT2f7GCApyjn9QxsqUkN6AzMuG+q3f+9lEjuzcFL6AjPFhicRUewfXfcX+JR+UKs/bupZfXr2PoiO5EYiqtJqnnU9au8s967TgCLtmjOXQoUNhjsoYSySmmsvf9wu7Zz3ntz69Uz/iaiSHMaKy1e12G4n1szzr8nf9l3vuuSe8ARmDJRJTjTnnRcageQc961NO60xa+95hjqpsklCD+n0fRBK95zCZOHEi77zzTpijMtWdJRJTbe2dN5kjv3jPKxJf+wTq9RqKM39adEnMbEJGz0F+62+//XY2btwYxohMdWeJxFRLeb9sYP+SkhN2uuISqN9nuN+7yqNBrbO6U6tVV8+6nJwcrr/+egoLo+ueGFN1WSIx1Y6qsvfzl/zW1+12C0kNW4YxoooTETIu/iMJdU/yrF+4cCGvvvpqmKMy1VW5Q6SIyN+Byaq6KgzxGFOuYIc9OfzDIvL+u9KzLqVFJ9La9wlq++ESl1STen0e5JfX7oei0ve8PPLII1x33XXUrFkzAtGZ6iSQI5K1wEQRWSgid4pI5Y+XbUyYaFEhez+f7FkXl1SLzEuHROV5EX+STmxO3a43e9YVFRXx/fffhzcgUy2Ve0SiqpOASSLSErgFWCEiXwH/p6qfhzpAYyrTgRWzKdizxbMuvfN1xNcs+3tSNA4CmdahDwe++4z8Hc4J9rS0NB588EGGDRtGrVred8MbU5kCOkciIvHA6e5jF7AcuFdE3gphbMZUqqK8Q+z79+uedfHpDUhvf0WYI6ocInHU7XorxMUzePBgNmzYwMMPP2xJxIRNIOdIngZ6A3OBv6pq8Yh2Y0RkXSiDM6Yy5SyaTtGhfZ51dS+8CUmovLnWwy3l5HNodMcknn/+5kiHYqqhQOYj+Q74k6p6jb1wXiXHY0xIFOzfRc6if3nW1TixBTXP+G2YI6p8Cen1Ix2CqaYC6dq6oWQSEZHPAFQ1OyRRGVPJ9v37dbQgz7OubrdbEbEr4Y05Xn6PSEQkGagJ1BORukDxpSzpQMMwxGZMpTiycxMHV87xrEtp3pHkpq3DHJExVUtZXVt3AMNwksa3PuU5wIuhDMqYyuRc7usx8ZPE+b101hgTOL+JRFWfBZ4VkSGq+nwYYzKm0hzeuJTcjUs861LbXEJiZpMwRxRZ+fn5iAgJCYGcHjUmMH47hkXkIvfpzyJydclHmOIzJiiJ9ZuRevbFUOIciNRIoc5vfhehqMJPVXnvvfdo3bo1kyd735BpzPEq6wzjhe7P3h6P2Lzg3lQ7CakZZPa6m5NueY6UUzocLU/veA3xtepGMLLw+frrr/ntb3/LVVddxbp163j00Uc5eNB76HxjjkdZXVt/dn/eEr5wjAmNGvWzaNDvMQ5vWsb+b94j/dwrIx1SyOXk5HDrrbcybdq0Y8p/+eUXnn76aR555JEIRWaqmnKveRSRoSKSLo5JIvKtiFwcjuCMqWwpWW1p0O8x4hKjZ9bDUElNTWXTpk2edWPHjmX79u3hDchUWYFcPH+rquYAFwMNcMbbGh3SqIwxQYuLi+Opp57yrDtw4ACjRo0Kc0SmqgokkRTfP3IZznDyy33KjDFRrFu3bvTq1cuzbsKECaxbZ6McmeAFkkiWiMhsnETyiYikAUWhDcsYU1nGjBnjOTR+YWEhDz30UAQiMlVNIInkNmAEcK47VEoNnO4tY0wMaN26NTfffLNn3fTp01mwYEF4AzJVTrmJRFWLgO1AKxHpApwJ1Alk4yJyqYisE5ENIjLCoz5JRN526xeKSJZbnikin4vIARF5ocQ689xtLnMfDQKJxVR9hYeyKTzoPbpvdTdq1CiSk70vMHjyySfDHI2pagK5amsM8BXwJ+AB93F/AOvF4wyl0gtoBVwvIq1KNLsN2KuqzYFngDFueS7wSBmvc4OqtnUfO8qLxVQP2f95i5//eRt75kygIGdnpMOJKo0bN+aee+7xrJs5cybLly8Pc0SmKgmka+tKoKWqXqaqvd1HIJNanwdsUNUfVfUI8BbQt0SbvsAr7vOpQHcREVU9qKpf4iQUY8pVeHAvB5Z/ghbksX/JB/w84XZ2z3qO/L1bIx1a1Bg+fDjp6emedaNH24WY5vgFkkh+BBKPY9uNgM0+y1vcMs82qloAZAOZAWx7stut9YjE0gTbJmRyFr+PFhz5taCogAMrZrN10h+tu8tVp04dBg8e7Fn3zjvvsH79+jBHZKqKQBLJIWCZiEwQkeeKHwGs5/UBX3II1kDalHSDqrYGfus+/uD54iIDRWSxiCzeudO6OaqywtwD7P/Wey71mi0vIL5WQKf0qoWhQ4eSkpJSqryoqIixY8dGICJTFQSSSGYAjwP/AZb4PMqzBfAdWrUxULKf4WgbEUkAagN7ytqoqv7s/twPvIGfWRpVdaKqdlDVDvXr28xxVdn+b2eiRw571tXu3C/M0US3Bg0acPvtt3vWvfLKK2zZsiXMEZmqIJCrtl4B3gEWqOorxY8Atv0N0EJEThaRGkB/nKTkawZwk/v8WmCuqvo9IhGRBBGp5z5PxBk88rsAYjFVVNGRw+xfXPLPypHSohM16meFN6AYcP/995OYWLq3Oj8/n3HjxkUgIhPrArlqqzewDPjYXW4rIt7/uT7ccx6DgU+ANcA7qrpKREaJSPHJ+peATBHZANyLc79K8etuAp4GbhaRLe4VX0k4N0WucGP6Gfi/QHfWVD0Hln1M0eEcz7ranexoxEuTJk248cYbPesmTpyIdQWbigqka+sxnO6jfQCqugw4OZCNq+pHqnqaqp6qqk+6ZY+q6gz3ea6q9lPV5qp6nqr+6LNulqpmqGqqqjZW1dXu1VztVfVsVT1TVYeqamEF99lUEVqQT843//KsS27WlqSGLcMcUex48MEHiYsr/e9/6NAhnn322QhEZGJZIImkQFWzS5SVd0LcmJA78N0cCg94n1Kr3fl/whxNbGnRogX9+nkfsb3wwgtkZ5f8lzfGv0ASyXci8jsgXkRaiMjzOCfejYkYLSokZ8FUz7qkhqeT1LR1mCOKPSNHjvQsz87OZvz48WGOxsSyQBLJEJxhUfKAN4EcYFgogzKmPAfXzKcg23s+jfTzr/McpNAcq02bNlx++eWedS+88AIFBQVhjsjEqkCu2jqkqg+r6rnu5bQPq6rdcW4iRrWInK/f9axLbHDyMVPqmrKVHP03OTmZwYMH89VXX5GQ4HcCVWOO4fcvRUQ+oIxzIQEOk2JMpTu8fgH5u//rWVe70//Y0UgFnH/++XTt2pUlS5Zw1113MWzYME444YRIh2ViTFlfOf7u/rwaOBH4f+7y9cCmEMZkjF+qSvbX73jWJWQ0ombL88McUezKGuGMBpB/2u+o3eZO3tRU3nxmcal2m0Z7d38ZU8xvIlHVLwBE5HFV7eJT9YGIzA95ZMZ4+PTTTznyywbPutodr0Xi4sMcUexLrNsw0iGYGBfIyfb6InJK8YKInAzYmCMmIvzNnRGfXp9aZ3YLczTGGCi7a6vYPcA8ESm+WTALGBiyiIzx48svv2T+fO+D4fTzrkbi7eSwMZFQ7n+eqn4sIi2A092itaqaF9qwjCntr3/9q2d5XK06pJ59cZijiU7F5z2MCaeAvsK5icOmUDMRs3TpUmbNmuVZl37ulcQlJoU5ImNMsUDOkRgTcW+88YZneVxSLdLaXhbmaKqflStXsnLlykiHYaKUJRITE8aOHctHH31E165djylPa9+HuKSakQmqGsj7eS19+vTh7LPP5sEHH4x0OCZKSRnTfzgNRKYBLwOzVLUoLFFVsg4dOujixaWvjzex6aQbnyZn4TQOb1pKoztfIj7Fex5yc3xUldyflpP99Tvk/XfFMXXLly/n7LPPjlBkJtxEZImqljtURCBHJOOB3wHrRWS0iJxe3grGhFJSw5bUv+ohGt35siWREND8PHa9P7pUEgF46qmnIhCRiXaBjLU1R1VvANrh3NH+qYj8R0RucWcpNCYi4lPSIh1ClRRXI5m0c7zvZn/zzTf56aefwhyRiXYBnSMRkUzgZmAAsBR4FiexfBqyyIwxEZPWvjeSUKNUeWFhIU8//XQEIjLRLJCpdqcD/wZqAr1VtY+qvq2qQ4DUUAdojAm/+Fp1qNW6h2fdpEmT2L17d5gjMtEskPtIJqnqR74FIpKkqnmBnIQxJlB2M110ST/3Kg4s+xhKXGNz6NAhXnzxRR599NEIRWaiTSBdW094lH1d2YEYY6JLYt2TqNnyAs+6559/nkOHDoU5IhOt/CYSETlRRNoDKSJyjoi0cx9dcbq5jAkJVWX/8k8oyrMPqkhL73iNZ/muXbuYPHlymKMx0aqsI5JLcOYkaQw8DYxzH/cCD5WxnjFByf1xMXs+fp4t429h7xdTKDywN9IhVVtJJzane/funnXjxo2z6XgNUEYiUdVXVLUbcLOqdvN59FHV6WGM0VQz2QunAaB5B8lZMJUt/7yF3R8/T/6enyMcWfU0fPhwz/KNGzcyderUMEdjolFZXVu/d59mici9JR9his9UM3lb15G3+btjCwsLOLD8E3L/a2M9RULPnj1p27atZ93YsWMpb3QMU/WV1bVVy/2ZCqR5PIypdDnu0UhJcbXqkHrWRWGOxgCIiN+jkqVLlzJnzpwwR2SiTVlT7U5wf/4lfOGY6ix/9xYOfe99QWB6+z6eN8iZ8OjXrx8PPfQQmzZtKlU3duxYevbsGf6gTNTwm0hE5LmyVlTVuys/HFOd5XzzL6B0N4nUSCH1HBsqPpISEhK47777GDJkSKm6OXPmsGTJEtq3bx+ByEw0KKtra0k5D2MqzbZt2zjw3WeedWltLiU+2QZRiLRbb72VzMxMz7qxY8eGORoTTcrq2nolnIGY6u25556DQo9LSeMSSOvQN/wBmVJq1qzJkCFDeOyxx0rVTZ06lR9++IFTTz01/IGZiCvrqq3/dX9+ICIzSj7CF6Kp6nJychg/frxnXa1WXUlIrxfmiIw/gwcPpmbN0vcjFxUVMW7cuAhEZKJBWV1br7k//86vNyP6PoypFBMnTiQ7O9uzLr3j1WGOxpQlMzOTAQMGeNZNnjyZHTt2hDkiEw3KuiFxifvzC5yxtfYCe4Cv3TJjgpaXl8czzzzjWZfS/Dxq1Gsa5ohMee655x7i4+NLlefm5jJ79uwIRGQiLZBh5C8HfgCeA14ANohIr1AHZqqH119/na1bt3rW+RvnyURWVlYW/fv3P7qcmJjILbfcwurVq/n9739fxpqmqgpkGPlxQDdV3QAgIqcCHwKzQhmYqfoKCwsZPXq0Z11Sw9NJatQqzBGZQD3wwAPMmDGDO+64g2HDhtGoUaNIh2QiKJBEsqM4ibh+BKwj1ATtnXfeYf369Z516Z2uRUTCHJEJVJs2bdi2bRu1atUqv7Gp8sq6IbH4LOcqEfkIeAfnbrF+wDdhiM1UYUVFRTz55JOedYmZTUhpfl6YIzIVZUnEFCvrHElv95EMbAcuBLoCO4G6gWxcRC4VkXUiskFERnjUJ4nI2279QhHJcsszReRzETkgIi+UWKe9iKx013lO7GtrTHrvvfdYtWqVZ1165/9BJJA514wx0aCsGxJvCWbDIhIPvAj0BLYA34jIDFVd7dPsNmCvqjYXkf7AGOA6IBd4BDjLffgaDwwEFgAfAZdi52tiiqryxBNeE29CQp2TqHVGlzBHZIwJRrnnSEQkGecD/0ycoxMAVPXWclY9D9igqj+623kL6Av4JpK+wGPu86nACyIiqnoQ+FJEmpeI5SQgXVW/dpdfBa7EEklM+eijj1i6dKlnXe3O/ZC40peWGmOiVyD9B68BJ+LMmPgFzoyJ+wNYrxGw2Wd5i1vm2UZVC4BswHswn1/bbylnmwCIyEARWSwii3fu3BlAuCYcVJXHH3/csy4+vT61zuwW5oiMMcEKJJE0V9VHgIPu+FuXA60DWM/r3EXJoV0DaXP6Cl4VAAAePUlEQVRc7VV1oqp2UNUO9evXL2OTJpz27t3rd3rW2p36IfGJYY7IhMqqVau47777KCwsjHQoJsQCSST57s99InIWUBvICmC9LUATn+XGQMk7z462EZEEd9t7ytlm43K2aaJYRkYG33zzDR999BGdO3c+Wn7SSSeR2rpHBCMzlWXp0qVcc801nHXWWTz99NNMm+Y9WZmpOgJJJBNFpC7Oye8ZOOc4xgSw3jdACxE5WURqAP3d9X3NAG5yn18LzNUy5u1U1W3AfhHp5F6tdSPwfgCxmCgiIvTq1YuvvvqKzz77jG7dujF8+HCbuCrGLV26lN69e9OuXTumT59+tPyJJ56gqKgogpGZUCv3ZLuqTnKffgGcEuiGVbVARAYDnwDxwMuqukpERgGLVXUG8BLwmohswDkSOTrugohsAtKBGiJyJXCxe8XXIGAKkIJzkt1OtMcoEeGiiy7ioosuoqioiP99yN7KWLZy5UpmzpzpWT5jxgyuvPLKCERlwkHKOABwGohk4lxZdQHO+Yh/A4+r6u6QR1dJOnTooIsXL450GKYcWSM+jHQIxsOm0ZcH1K6goICWLVvy448/lqpr164dixcvttEKYoyILFHVDuW1C6Rr6y2cIVGuwel+2gW8HVx4xpiqJiEhgZEjR3rWffvtt8yaZUecVVUgiSRDVR9X1Y3u4wmgTqgDM8bEnhtvvJGmTb2H/n/88ccprwfExKZAEsnnItJfROLcx//gjP5rjDHHqFGjBg8++KBn3YIFC/jss8/CHJEJB7/nSERkP845EQFqAcWXXcQBB1Q1PSwRVgI7RxIagZ7TCLSP3c6RRKdA379iubm5nHLKKWzbtq1UXZcuXfjiC5sXL1YEfY5EVdNUNd39GaeqCe4jLpaSiImsPXMm8Ne//pWcnJxIh2LCJDk5meHDh3vWzZ8/n/nz54c5IhNqAQ2xKiJ9ROTv7uOKUAdlqob8vVvZ/+2HPPzwwzRr1ow///nP7NlT1v2mpqoYOHAgDRo08KzzN0SOiV2BTLU7GhiKcyPiamCoW2ZMmbK/fhfU6RHdt28fo0aNolmzZvzlL3+JcGQm1GrWrMl9993nWTdnzhy+/vrrMEdkQimQI5LLgJ6q+rKqvowzbPtloQ3LxLqC7B0cXDW3VPmBAwfYtWtXBCIy4TZo0CAyMjI86+yopGoJdPYg38t9a4ciEFO1ZC94B4pKD9aXmJjot//cVC1paWncc889nnWzZs3CLoCpOgK5s/16YDTwOc4VXF2Akar6VujDqxx21VZo+LvKKn/3Fra+9Mej3Vq+UttcQualQ0IdmokAr6u7srOzadasGdnZ2aXqrrjiCj744INwhGaOU6Xc2e4OjPgl0AmY7j46x1ISMeG394spnkkEiSO9U7+wx2Mip3bt2tx9992edTNnzrRLgauIMhOJOxLve6q6TVVnqOr7qvpLmGIzMSh3yyoOr1/gWVfrrO4k1jkxzBGZSBs2bBipqamedffff7+NDFwFBHKOZIGInBvySEzMU1X2fv6yZ50kJFHntzeEOSITDTIyMhg2bJhn3eLFi3n7bRu6L9YFkki64SSTH0RkhYisFJEVoQ7MxJ5D677iyNZ1nnVp515JQlq9MEdkosXw4cP93lcycuRIcnNzwxyRqUyBJJJeOPOQXAT0Bq5wfxpzlBbms++LVzzr4mrWpnbHa8IckYkmaWlpfu8f+umnn/jHP/4R5ohMZfKbSEQkWUSGAQ/g3Dvys6r+VPwIW4QmJuxf9jEF+0qPrQRQ54LriUuqGeaITLQZMGAAp59++jFliYmJDBs2jJtuusnPWiYWlHVE8grQAViJc1QyLiwRmZhTlHeQ7K/e9KxLqNuQ1DaXhjkiE40SEhIYO3bs0eVrr72W1atX88wzz5CZmRnByEywyppqt5WqtgYQkZeAReEJycSa7AVTKTrsPShj3QtvRuLLndHZVBNXXHEFw4YNo1+/fpx//vmRDsdUkrL+w/OLn7jzr4chHBNrCnJ2sn/x+551SY3OIOW0zmGOyEQzEeGZZ56JdBimkpWVSNqISPHXTAFS3GXBucXEhpI37Pv362jBEc+6Ol1vtTm6jakG/CYSVY0PZyAm9hzZ8SMHv/Oe8a7maeeT3PiMMEdkjImEQAdtNKaUvfOm4EyiWUJcPHUutKtwjKku7CyoOS6ffvopuRu/9axLa3spiRmNwhyRiRWVPUWziTw7IjHHZfbs2Z7lUiOF2udfH+ZoTFWTu/k7pk2bFukwTIDsiMQcl6eeeorXfs5g7+eTOfLL+qPltTteS3ytOmWsaYx/+bu3sPeLKRxev4A7PsmkR48e1K5tUyBFOzsiMcctuenZnHjjOOr1foCE2icQn5pB2rl9Ix2WiUGFh7LZ8+l4tr70x6OjR+/evZvRo21W71hgRyQmKCJx1Gp1ITVPO5/8vT8Tl5gc6ZBMDNr1wd/J3bS0VPkzzzzDoEGDaNq0aQSiMoGyIxJTKSQhkRr1syIdholRtS/4nWd5Xl4eI0eODHM0pqIskRhjIi658RnUPM17yJQ33niDDz8M7EovExmWSIwxUaFO15shzvs+6IEDB7Jv377wBmQCZonEGBMVEus2JO0c73tHtm7dyj333BPmiEyg7GS7KZOq8sknn3DJJZfYuFkm5Or89vccWr+AwpwdpeqmTJnCRweakXLqsTN/242LkWdHJKZMU6ZMoVevXlx++eVs3rw50uGYKi4uqSaZve72W7/74xcoyj0QxohMIOyIxPjl250wa9YszjzzTMaNG8eAAQPs6MSUEujQJ+VJyWpLattLObDs41J1hQd2s2fuJOpdNqxSXstUDjsiMZ5UlTvvvJPs7OyjZfv372fgwIH07NmTXbt2RTA6U9XV7Xor8en1PesOrpzD4R8WhzkiU5aQJhIRuVRE1onIBhEZ4VGfJCJvu/ULRSTLp26kW75ORC7xKd8kIitFZJmI2F9TiLzxxht88MEHnnU7d+4kPd2mozGh43RxDfVbv/vj562LK4qELJGISDzwIs58762A60WkVYlmtwF7VbU58Awwxl23FdAfOBO4FPiHu71i3VS1rap2CFX81dn27du5+27vfur4+HgmT55MjRo1whyVqW5SstqS2uZSzzqni+ulMEdk/AnlEcl5wAZV/VFVjwBvASUHYuoLvOI+nwp0F6fzvS/wlqrmqepGYIO7PRMGd911F3v27PGsGzFiBO3atQtzRKa6qtutrC6uTzn845IwR2S8hDKRNAJ8L/PZ4pZ5tlHVAiAbyCxnXQVmi8gSERno78VFZKCILBaRxTt37gxqR6qTd9991+/w3a1ateKRRx4Jc0SmOotLqknmpWVdxfX8MefxTGSE8qotr8t6Sk6n569NWeteoKpbRaQB8KmIrFXV+aUaq04EJgJ06NDBYxo/U9KuXbu46667vCsljj3tb6Pln+eENyhT7aWcfA6pbS7lwHKPq7j27+K+++5j0qRJEYjMFAvlEckWoInPcmNgq782IpIA1Ab2lLWuqhb/3AH8C+vyqjR33303/o7e0s+9kqSGLcMckTGOut1uJT7Nu4vrpZde4uOPSycZEz6hTCTfAC1E5GQRqYFz8nxGiTYzgOLJva8F5qqquuX93au6TgZaAItEpJaIpAGISC3gYuC7EO5DtfH+++/z5ptvetYlZDSi9m9uCHNExvzKuYpriN/6O+64gyNHjoQxIuMrZInEPecxGPgEWAO8o6qrRGSUiPRxm70EZIrIBuBeYIS77irgHWA18DFwl6oWAicAX4rIcmAR8KGq2leRIP3www/ceuutfmqFzF5DiUtMCmtMxpSUcnI7UttcUqq8RYsWvP7663YlYQSJcwBQtXXo0EEXL7ZbTrzs27ePzp07s3btWs/6tPZ9yOjh95oGY8KqKO8QW1+6i8L9OwEh7dy+/DLvdWrWrBnp0KokEVkSyG0Wdmd7NVZQUMB1113nN4kk1DmROl1uDHNUxvjnXMU1mISMRpxww1gyLhpgSSQK2Fhb1diwYcOYPXu2d6XEkXnZMOJq2NS5JrqknNKehs1eROLt4yta2BFJNfXiiy/y4osv+q3P6DGQ5CZnhTEiYwJnSSS6WCKphmbPns3Qof7HMUprdzlp7a4IY0TGmFhmiaSaWbNmDf369aOwsNCz/uKLL6Zudzu5bqoGVaWoqCjSYVR5lkiqmYMHD5KSkuJZd/rpp/P2228jfubNNiaW5OXlcfPNNzNy5MhIh1LlWUdjNdOhQwe++eYbevfuzfLly4+WZ2ZmMnPmTOrUqRPB6IypHLt27eLqq6/m3//+N+DcazJgwIAIR1V12RFJNdSkSRO+/PJL+vZ1BmNOTExk+vTpnHrqqRGOzJjgrVu3jk6dOh1NIgCDBg1i7ty5EYyqarMjkmoqNTWV6dOnM3LkSFq2bEmXLl0iHZIxQVu0aBGXXHIJ+/btO6a8oKCAnpf14cQ//J3EzCZ+1v7VptGXhyrEKskSSTUWFxfHmDFjIh2GMZXmlFNOITMzs1QiASjKO8iOqaM48Q9/J75m7QhEV3VZIqlGskZ8GOkQjAmpevXqMXPmTDp37uyZTAr2bWPHu4/R4No/E1/LzgdWFjtHUgWpKgcPHox0GMZExOmnn87UqVNJSPD+nnzkl/X88tp95O/eEubIqi5LJFVMQUEBgwYNonv37hw6dCjS4RgTEd27d2f8+PF+6wuyt/PL/3uA3C2rwhhV1WWJpAo5ePAgV111FRMmTGDhwoX079+fgoKCSIdlTEQMGDCA+++/3299Ue5+tr/1Jw6uKTXBqqkgSyRVxI4dO7jooouYOXPm0bIPPviAwYMHUx2mCjDGy5gxY/jDH/7gv0FhPrtmjCV74VT7PwmCJZIqYMOGDZx//vksWrSoVN2ECRP429/+FoGojIm8uLg4pkyZwkMPPVRmu33zprDn0/FokffQQaZslkhi3KJFizj//PP54Ycf/LZ5++23yc3NDWNUxkSPuLg4nnzySTIuGQzi/yPvwNKP2Dn9CYqOHA5jdFWDJZIYNnPmTLp27crOnTv9tunWrRvz588nOdnmFTHVW1rbS2lwzaNIov//hcM/fMP2N0bwyy+/hDGy2GeJJAYVFBQwduxY+vbty+HD/r89XX/99cyaNYvate3mK2MAUk7twIk3jCE+NcNvmyPbf6BTp06sXLkyjJHFNpuzPcYsWrSIO+64g2XLlpXZbvjw4fztb38jLu7X7wp2Q6IxjoKcHex49zHyd/3Xb5uEhAS++uorzjvvvDBGFl1szvYqJjs7myFDhtCpU6cyk4iI8PzzzzNmzJhjkogx5lcJ6Q048YaxJDc722+b9u3b06FDuZ+hBjsiiXqqyrRp0xg6dChbt24ts60k1KDeFfdTs+X5YYrOmNimhfns/vh5Dn537MjAcXFxLF68mHPOOSdCkUWHQI9IbKytKLZp0yYGDx7Mhx+W3yUVl5xG/WseIblxqzBEZkzVIPGJZF52DwnpJ5D9nzePlg8ZMqTaJ5GKsEQShfLz83n22Wf585//HNAwJ0lNziKz11AS654UhuiMqVpEhDq/vYGEuieyZ/Z44pJqMmrUqEiHFVMskUSZnJwcunTpcszshf5kZGQgnW6k1lndEZEwRGdM1ZV6VneSm7ahIGc76enpAa0zb948mjdvTuPGjUMcXXSzs7FRJj09nRYtWpTb7qabbmLt2rWktu5hScSYSpKQXo/kxmcG1HbHjh1cddVVZGVlcdVVVzF79myKiopCHGF0skQShZ599lnS0tI861q0aMHcuXOZMmUK9evXD3NkxphiDzzwAPv27aOwsJD33nuPSy65hJYtWzJu3Dh2794d6fDCyq7ailIvvvgigwcPPrpco0YNRo4cyYgRI465S93uDTGm8pU31e68efPo1q2b3/qkpCSuu+46Bg0aRMeOHQPuNQj0/zlcUwHbfSRRJD8/n//85z8MHz484Klt77zzzqM3Ql144YUsX76cxx57zIY6MSbCjhw5wh//+Mcy2+Tl5fHqq6/SuXNn2rVrx4QJE9i2bVuYIgw/OyIJAVVl7dq1zJkzh08//ZR58+axf/9+wJkKdPPmzeUmhKwRH3Jkx48c2f6jnUw3Jooc/nEJO959DKj4Z2erVq3o3r073bt358ILL6ROnWOn+43VIxK7aquSbNu2jc8++4w5c+YwZ84cfv75Z892u3bt4t133y17jgRXjQanUKPBKZUdqjEmCCmntKfhbf9g/9IPkQ3zycnJCXjd1atXs3r1ap5//nni4uJo37790cRywQUXhDDq0LIjkgrKy8tj/fr1rFmzhtWrV7NmzRpWrFjBmjVrAt5Gx44dWbBgQZlt7NyHMdHvuz9dyJtvvsn48eNZunRpcBuLTyD9vGuo26X8L5l2RBJDNm7cyFdffXVM0tiwYQOFhcFNfrNw4UIWL15s4/gYE+NSU1O5/fbbGTBgAIsWLWL8+PHHP/9PYQHxNcsfqVsL81m7di0NGzYkLS0tKrq9LZGUYdq0aTzwwAMh2fb8+fMtkRhTRYgIHTt2pGPHjjz99NNMmTKFf/7zn6xfv75C20lu1qbcNvm7NnPGGVc57ZOTOfHEEznhhBOO/vR93rZtW0499dTj2qeKsERShjPOOKPStpWSksKFF15Ijx49uPLKK8Py5hpjwi8jI4N7772XYcOGMXfuXKZNm8akt2dQsLfsQVfjatUhsV7Tcrefv3vz0ee5ubls2rSJTZs2ebYdNWoUjzzySIXiPx4hTSQicinwLBAPTFLV0SXqk4BXgfbAbuA6Vd3k1o0EbgMKgbtV9ZNAtlmZWrU6/gEQ4+Li6NChAz179qRHjx507tyZpKSkSozOGBPN4uLi6NGjBz169GBW7SsoyNlJ7k8ryP1pGbk/LafwwJ5j2ic3bRNQN1X+7i0Bx3DiiSdWOO7jEbJEIiLxwItAT2AL8I2IzFDV1T7NbgP2qmpzEekPjAGuE5FWQH/gTKAhMEdETnPXKW+blaZZs2ZIQhJakBdQ+4S6DUnOaktKVluSmp7N9uRU/l8B/L+PD8LHc4DwnSQzxkSXhPT6pLbuTmrr7qgqBXu2kPvTcg7/tJy8n1YE1K0Fxx6RlOeEE0443nArJJRHJOcBG1T1RwAReQvoC/h+6PcFHnOfTwVeECcl9wXeUtU8YKOIbHC3RwDbrDRxcXEkZjbmyPYfji2vWYfEzMYk1mtKYmYT51GvKQllTN9pjDHFROToZ0dauyvQokIIcJyu/D2BH5FUhUTSCPBNnVuAjv7aqGqBiGQDmW75ghLrNnKfl7dNAERkIDDQXTwgIutKNKkH7ApoT0ooOrSPvEP7yNv8XYXXlcBubA/Uce9DFLF9iA62D8ehkv+foZL3oVOnTsFuolkgjUKZSLw6+0retOKvjb9yryFdPG+EUdWJwES/wYksDuT66Ghm+xAdbB+ig+1D5IRyrK0tQBOf5cZAycsWjrYRkQSgNrCnjHUD2aYxxpgwCmUi+QZoISIni0gNnJPnM0q0mQHc5D6/Fpirzq32M4D+IpIkIicDLYBFAW7TGGNMGIWsa8s95zEY+ATnUt2XVXWViIwCFqvqDOAl4DX3ZPoenMSA2+4dnJPoBcBdqloI4LXN4wzRb7dXDLF9iA62D9HB9iFCqsVYW8YYY0LH5iMxxhgTFEskxhhjglLtEomIDBGRdSKySkTG+pSPFJENbt0lkYwxECJyv4ioiNRzl0VEnnP3YYWItIt0jP6IyFMistaN818iUsenLmbeBxG51I1zg4iMiHQ8gRKRJiLyuYiscf8PhrrlGSLyqYisd3/WjXSsZRGReBFZKiIz3eWTRWShG//b7gU5UU1E6ojIVPf/YY2IdI619wGqWSIRkW44d8KfrapnAn93y32HZLkU+Ic7xEtUEpEmOMPE/NenuBfO1W0tcG7EHB+B0AL1KXCWqp4NfA+MhNh6H3yGAOoFtAKud+OPBQXAfap6BtAJuMuNfQTwmaq2AD5zl6PZUMB3IqAxwDNu/HtxhmCKds8CH6vq6UAbnP2JtfeheiUSYBAw2h16BVXd4ZYfHZJFVTcCvkOyRKNngOEcezNmX+BVdSwA6ojISRGJrhyqOltVC9zFBTj3A0FsvQ9HhwBS1SNA8XA9UU9Vt6nqt+7z/TgfXo1w4n/FbfYKcGVkIiyfiDQGLgcmucsCXIQz1BJEefwAIpIOdMG5ehVVPaKq+4ih96FYdUskpwG/dQ9/vxCRc91yr+FcGpVaOwqISB/gZ1VdXqIqZvahhFuBWe7zWNqHWIrVLxHJAs4BFgInqOo2cJIN0CBykZXrf3G+TBUPUJUJ7PP5ghIL78cpwE5gsttFN0lEahFb7wNQBecjEZE5gNfYyQ/j7G9dnMP5c4F3ROQUAhvOJWzK2YeHgIu9VvMoi8p9UNX33TYP43SzvF68mkf7aL0+PZZi9SQiqcA0YJiq5gQyhHk0EJErgB2qukREuhYXezSN9vcjAWgHDFHVhSLyLDHQjeWlyiUSVe3hr05EBgHT3bvnF4lIEc4gaVE19Iq/fRCR1sDJwHL3n74x8K2InEeM7EMxEbkJuALorr/ezBRV+1COWIq1FBFJxEkir6vqdLd4u4icpKrb3G7RHf63EFEXAH1E5DIgGUjHOUKpIyIJ7lFJLLwfW4AtqrrQXZ6Kk0hi5X04qrp1bb2H04+KOPOb1MAZadPfkCxRRVVXqmoDVc1S1SycP8R2qvoLzj7c6F691QnILj48jjbiTE72INBHVQ/5VMXE++CK2eF63PMJLwFrVPVpnyrfIYtuAt4Pd2yBUNWRqtrY/R/ojzO00g3A5zhDLUEUx1/M/b/dLCIt3aLuOKN5xMT74KvKHZGU42XgZRH5DjgC3OR+G/Y7JEsM+Qi4DOcE9SHglsiGU6YXgCTgU/fIaoGq3lnW0DjRxt8QQBEOK1AXAH8AVorIMrfsIWA0TnfvbThXBPaLUHzH60HgLRF5AliKexI7yg0BXne/jPyI838bR4y9DzZEijHGmKBUt64tY4wxlcwSiTHGmKBYIjHGGBMUSyTGGGOCYonEGGNMUCyRmCpJRApFZJmIfCciH/iOMBzkdrPcy8crjYh0FZGvS5QliMj2ioyXJiJ9yhuFWEQeE5H7Pcorfb9M9WGJxFRVh1W1raqehTON812RDqgM84HG7rhXxXoA3wV6U6l7R/cMVR0dgviMKZMlElMdfI07gJ+IpIrIZyLyrYisFJG+bnmWOx/E/7lzdMwWkRS3rr2ILHePGo4mJBFJFpHJ7naWutMUICI3i8h77pHQRhEZLCL3um0WiEiGb3CqWgS8C1znU9wfeNPd3u0i8o0bwzQRqemWTxGRp0Xkc2CM+7ovuHW93cFJl4rIHBE5wWfbbURkrjjzXdxe8pclzjwfT7mvuUJE7gju12+qOkskpkoTZ96Q7vw6fEkucJWqtgO6AePk19EKWwAvunPV7AOuccsnA3eraucSm78LQFVbA9cDr4hIslt3FvA7nOHmnwQOqeo5OEntRo9Q38RJHohIEs4oBdPcuumqeq6qFs9X4TvPxmlAD1W9r8T2vgQ6ua/5Fs5IucXOxhmCvTPwqIg0LLHubThD7JyLM7jp7e6QNcZ4qm5DpJjqI8Ud/iMLWIIzmRY4o8T+VUS64AxB3ggo/ra+UVWLhwxZAmSJSG2gjqp+4Za/hjOZFcBvgOcBVHWtiPyE88EO8Lk718d+EckGPnDLV+J8kB9DVb9xj5ZaAmfgDBuz160+yx32ow6QijMsS7F3/Qwj0xh42z3HUgPY6FP3vqoeBg67RzPnAct86i8GzhaR4nGrauMkWd9tGHOUHZGYquqwqrYFmuF8kBZ3Sd0A1Afau/XbcUaQBcjzWb8Q54uW4H848rLGXffdVpHPchH+v8C9hXNUcrRbyzUFGOwe+fzFJ16Ag3629TzwgrvOHSXWKbk/JZcFZ2jztu7jZFWd7ed1jLFEYqo2Vc0G7gbud4dOr40zl0W+e06jWTnr7wOyReQ3btENPtXzi5fd0aSbAuuCCPdN4Pc4I1T7jiScBmxz47/Ba0UPtYGf3ec3lajr657fyQS64oxk7OsTYJD7eojIaeJMuGSMJ+vaMlWeqi4VkeU43/RfBz4QkcU43TlrA9jELTijRh/i2G6lfwD/FJGVOKMV36yqeXKcE0Sp6mr3NZaoqu+RxiM4Mxj+hNM1lhbA5h4D3hWRn3GmM/Y9x7EI+BAn8T2uqltLXDE2CadL8Fv3/NFOYmC6VxM5NvqvMcaYoFjXljHGmKBYIjHGGBMUSyTGGGOCYonEGGNMUCyRGGOMCYolEmOMMUGxRGKMMSYo/x+U3NHRfOlbCgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# shift the mean and scale the variance for a N(mu,var)\n",
    "samples = 1000\n",
    "mu = 4\n",
    "sig = 20\n",
    "\n",
    "# generate the array of rand numbers \n",
    "rand_array = (sig * np.random.randn(samples,1)) + mu   # drawn from normal with mean mu and variance sig\n",
    "rand_array\n",
    "\n",
    "# plot\n",
    "num_bins = 30\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# generate the histogram\n",
    "n, bins, patches = ax.hist(rand_array, num_bins, density=1)\n",
    "\n",
    "# generate a pdf evaled at 'bins' to draw a smooth function - this works because we used randn to generate the data\n",
    "y = norm.pdf(bins, mu, sig)\n",
    "ax.plot(bins, y, 'k--', linewidth = 6)\n",
    "ax.set_xlabel('Random Variable')\n",
    "ax.set_ylabel('Probability density')\n",
    "ax.set_title('Histo of random variable with $\\mu=mu$, $\\sigma=sig$')\n",
    "\n",
    "# show the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple elementwise arithmetic operations like + and - work on corresponding elements of arrays. More on linear algebra in separate tutorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.00000000e+00 8.93507819e-07 7.14773412e-06 2.41217554e-05\n",
      " 5.71713644e-05 1.11647430e-04 1.92894258e-04 3.06247954e-04\n",
      " 4.57034788e-04 6.50569566e-04 8.92153998e-04 1.18707508e-03\n",
      " 1.54060346e-03 1.95799185e-03 2.44447338e-03 3.00526004e-03\n",
      " 3.64554105e-03 4.37048126e-03 5.18521963e-03 6.09486758e-03\n",
      " 7.10450746e-03 8.21919102e-03 9.44393780e-03 1.07837336e-02\n",
      " 1.22435291e-02 1.38282382e-02 1.55427363e-02 1.73918593e-02\n",
      " 1.93804018e-02 2.15131157e-02 2.37947088e-02 2.62298430e-02\n",
      " 2.88231336e-02 3.15791472e-02 3.45024005e-02 3.75973591e-02\n",
      " 4.08684361e-02 4.43199904e-02 4.79563258e-02 5.17816895e-02\n",
      " 5.58002707e-02 6.00161994e-02 6.44335453e-02 6.90563163e-02\n",
      " 7.38884574e-02 7.89338494e-02 8.41963080e-02 8.96795821e-02\n",
      " 9.53873531e-02 1.01323234e-01 1.07490767e-01 1.13893424e-01\n",
      " 1.20534606e-01 1.27417638e-01 1.34545773e-01 1.41922190e-01\n",
      " 1.49549989e-01 1.57432195e-01 1.65571754e-01 1.73971536e-01\n",
      " 1.82634326e-01 1.91562834e-01 2.00759685e-01 2.10227422e-01\n",
      " 2.19968508e-01 2.29985319e-01 2.40280148e-01 2.50855202e-01\n",
      " 2.61712604e-01 2.72854388e-01 2.84282503e-01 2.95998809e-01\n",
      " 3.08005078e-01 3.20302994e-01 3.32894151e-01 3.45780053e-01\n",
      " 3.58962113e-01 3.72441656e-01 3.86219913e-01 4.00298025e-01\n",
      " 4.14677040e-01 4.29357915e-01 4.44341514e-01 4.59628609e-01\n",
      " 4.75219878e-01 4.91115906e-01 5.07317185e-01 5.23824114e-01\n",
      " 5.40636997e-01 5.57756045e-01 5.75181376e-01 5.92913013e-01\n",
      " 6.10950886e-01 6.29294830e-01 6.47944588e-01 6.66899808e-01\n",
      " 6.86160045e-01 7.05724760e-01 7.25593321e-01 7.45765004e-01\n",
      " 7.66238990e-01 7.87014370e-01 8.08090141e-01 8.29465207e-01\n",
      " 8.51138383e-01 8.73108391e-01 8.95373862e-01 9.17933337e-01\n",
      " 9.40785267e-01 9.63928013e-01 9.87359848e-01 1.01107895e+00\n",
      " 1.03508343e+00 1.05937128e+00 1.08394042e+00 1.10878870e+00\n",
      " 1.13391387e+00 1.15931357e+00 1.18498541e+00 1.21092687e+00\n",
      " 1.23713537e+00 1.26360825e+00 1.29034275e+00 1.31733605e+00\n",
      " 1.34458524e+00 1.37208733e+00 1.39983926e+00 1.42783790e+00\n",
      " 1.45608002e+00 1.48456234e+00 1.51328149e+00 1.54223404e+00\n",
      " 1.57141648e+00 1.60082523e+00 1.63045665e+00 1.66030702e+00\n",
      " 1.69037255e+00 1.72064940e+00 1.75113366e+00 1.78182134e+00\n",
      " 1.81270842e+00 1.84379078e+00 1.87506428e+00 1.90652468e+00\n",
      " 1.93816773e+00 1.96998908e+00 2.00198434e+00 2.03414909e+00\n",
      " 2.06647882e+00 2.09896900e+00 2.13161504e+00 2.16441229e+00\n",
      " 2.19735607e+00 2.23044165e+00 2.26366426e+00 2.29701908e+00\n",
      " 2.33050126e+00 2.36410590e+00 2.39782806e+00 2.43166279e+00\n",
      " 2.46560508e+00 2.49964988e+00 2.53379215e+00 2.56802677e+00\n",
      " 2.60234862e+00 2.63675255e+00 2.67123338e+00 2.70578592e+00\n",
      " 2.74040493e+00 2.77508518e+00 2.80982141e+00 2.84460833e+00\n",
      " 2.87944065e+00 2.91431306e+00 2.94922025e+00 2.98415687e+00\n",
      " 3.01911759e+00 3.05409707e+00 3.08908994e+00 3.12409086e+00\n",
      " 3.15909445e+00 3.19409536e+00 3.22908824e+00 3.26406771e+00\n",
      " 3.29902844e+00 3.33396506e+00 3.36887225e+00 3.40374466e+00\n",
      " 3.43857698e+00 3.47336390e+00 3.50810012e+00 3.54278037e+00\n",
      " 3.57739939e+00 3.61195193e+00 3.64643276e+00 3.68083669e+00\n",
      " 3.71515854e+00 3.74939316e+00 3.78353542e+00 3.81758023e+00\n",
      " 3.85152252e+00 3.88535724e+00 3.91907941e+00 3.95268405e+00\n",
      " 3.98616623e+00 4.01952105e+00 4.05274366e+00 4.08582924e+00\n",
      " 4.11877302e+00 4.15157027e+00 4.18421630e+00 4.21670648e+00\n",
      " 4.24903622e+00 4.28120096e+00 4.31319623e+00 4.34501758e+00\n",
      " 4.37666062e+00 4.40812103e+00 4.43939453e+00 4.47047689e+00\n",
      " 4.50136397e+00 4.53205165e+00 4.56253591e+00 4.59281276e+00\n",
      " 4.62287829e+00 4.65272866e+00 4.68236007e+00 4.71176882e+00\n",
      " 4.74095126e+00 4.76990381e+00 4.79862297e+00 4.82710528e+00\n",
      " 4.85534741e+00 4.88334604e+00 4.91109798e+00 4.93860007e+00\n",
      " 4.96584926e+00 4.99284256e+00 5.01957706e+00 5.04604993e+00\n",
      " 5.07225844e+00 5.09819990e+00 5.12387173e+00 5.14927144e+00\n",
      " 5.17439660e+00 5.19924488e+00 5.22381403e+00 5.24810188e+00\n",
      " 5.27210635e+00 5.29582546e+00 5.31925729e+00 5.34240004e+00\n",
      " 5.36525197e+00 5.38781145e+00 5.41007692e+00 5.43204692e+00\n",
      " 5.45372010e+00 5.47509517e+00 5.49617094e+00 5.51694632e+00\n",
      " 5.53742030e+00 5.55759199e+00 5.57746055e+00 5.59702526e+00\n",
      " 5.61628550e+00 5.63524072e+00 5.65389048e+00 5.67223442e+00\n",
      " 5.69027229e+00 5.70800393e+00 5.72542926e+00 5.74254831e+00\n",
      " 5.75936119e+00 5.77586812e+00 5.79206940e+00 5.80796543e+00\n",
      " 5.82355670e+00 5.83884379e+00 5.85382739e+00 5.86850827e+00\n",
      " 5.88288728e+00 5.89696539e+00 5.91074365e+00 5.92422319e+00\n",
      " 5.93740525e+00 5.95029116e+00 5.96288231e+00 5.97518023e+00\n",
      " 5.98718650e+00 5.99890280e+00 6.01033092e+00 6.02147270e+00\n",
      " 6.03233010e+00 6.04290516e+00 6.05319999e+00 6.06321680e+00\n",
      " 6.07295788e+00 6.08242562e+00 6.09162247e+00 6.10055098e+00\n",
      " 6.10921377e+00 6.11761355e+00 6.12575311e+00 6.13363532e+00\n",
      " 6.14126312e+00 6.14863953e+00 6.15576767e+00 6.16265070e+00\n",
      " 6.16929188e+00 6.17569454e+00 6.18186207e+00 6.18779795e+00\n",
      " 6.19350573e+00 6.19898900e+00 6.20425146e+00 6.20929685e+00\n",
      " 6.21412899e+00 6.21875176e+00 6.22316911e+00 6.22738504e+00\n",
      " 6.23140362e+00 6.23522898e+00 6.23886532e+00 6.24231687e+00\n",
      " 6.24558795e+00 6.24868291e+00 6.25160616e+00 6.25436217e+00\n",
      " 6.25695546e+00 6.25939060e+00 6.26167219e+00 6.26380491e+00\n",
      " 6.26579345e+00 6.26764257e+00 6.26935707e+00 6.27094178e+00\n",
      " 6.27240157e+00 6.27374137e+00 6.27496612e+00 6.27608080e+00\n",
      " 6.27709044e+00 6.27800009e+00 6.27881483e+00 6.27953977e+00\n",
      " 6.28018005e+00 6.28074083e+00 6.28122732e+00 6.28164470e+00\n",
      " 6.28199823e+00 6.28229315e+00 6.28253474e+00 6.28272827e+00\n",
      " 6.28287906e+00 6.28299241e+00 6.28307366e+00 6.28312814e+00\n",
      " 6.28316119e+00 6.28317816e+00 6.28318441e+00 6.28318531e+00]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0,2*pi,360)\n",
    "y = np.sin(x)\n",
    "\n",
    "print(x-y)\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.plot(x, x, 'k--')\n",
    "plt.title('X')\n",
    "plt.ylabel('Amplitude')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.plot(x, y, 'k--')\n",
    "plt.title('Y')\n",
    "plt.xlabel('angle')\n",
    "plt.ylabel('Amplitude')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.plot(x, x-y, 'k--')\n",
    "plt.title('X-Y')\n",
    "plt.xlabel('angle')\n",
    "plt.ylabel('Amplitude')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some operations that can modify an existing array\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]]\n",
      "[[4. 4. 4. 4. 4. 4. 4. 4. 4. 4.]]\n",
      "[[8. 8. 8. 8. 8. 8. 8. 8. 8. 8.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.ones( (1,10) )\n",
    "print(x)\n",
    "\n",
    "# then some C style stuff...\n",
    "x += 3\n",
    "print(x)\n",
    "\n",
    "# note that it builds...so the x+=3 modifies x\n",
    "x *= 2\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "when dealing with muliple arrays of different data types, resulting array will take the form of the highest precision input array (upcasting)!\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x data type:  int32\n",
      "y data type:  float64\n",
      "[[  0.           0.29656063   0.31385601  -1.51221879   4.87122517\n",
      "    1.16970109 -10.68193294  -6.31355237  -0.67702145 -14.66486399]]\n",
      "z data type:  float64\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(10, dtype='int32')\n",
    "print('x data type: ', x.dtype)\n",
    "\n",
    "y = np.random.randn(1,10)\n",
    "print('y data type: ', y.dtype)\n",
    "\n",
    "# now multiply the int32 array with the float64 array and answer should be the higher precision of the two (float64)\n",
    "z = x * y \n",
    "print(z)\n",
    "print('z data type: ', z.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unary operations implemented as methods of the ndarray class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2 3 4]\n",
      " [5 6 7 8 9]]\n",
      "[ 5  7  9 11 13]\n",
      "[10 35]\n",
      "[ 5  7  9 11 13]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(10).reshape(2,5)   # 2 x 5 matrix\n",
    "\n",
    "print(x)\n",
    "\n",
    "x.sum()                          # sum of all elements\n",
    "print(x.sum(axis=0))             # sum of each column (across 1st dim)\n",
    "print(x.sum(axis=1))             # sum of each row (across 2nd dim)\n",
    "print(x.sum(0))                  # don't need the axis arg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other common operations..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0011628520728125258\n",
      "[0.00116285 0.21047013 0.03711967]\n",
      "[0.80879328 0.99536736 0.80001653 0.92234271 0.9866257  0.89608682\n",
      " 0.82130154 0.91025083 0.91978013 0.80722131 0.85130986 0.89915135]\n",
      "[[3.46874681e-01 2.80549911e-01 2.90212716e-02]\n",
      " [7.54919135e-01 1.79211504e-01 1.78381282e-01]\n",
      " [7.51734434e-02 6.01399976e-02 3.72502414e-03]\n",
      " [8.61832004e-01 7.94904466e-01 6.25083028e-01]\n",
      " [9.78504356e-01 7.01520047e-01 6.92137708e-01]\n",
      " [8.96086824e-01 2.15452577e-01 1.22870686e-01]\n",
      " [1.36581034e-01 1.12174214e-01 7.89119691e-02]\n",
      " [6.51438711e-02 3.60254002e-02 3.27921506e-02]\n",
      " [9.19780129e-01 3.02621888e-01 2.73130359e-01]\n",
      " [3.12469843e-02 2.52232315e-02 3.74468240e-03]\n",
      " [1.16285207e-03 2.44745624e-04 2.08354362e-04]\n",
      " [8.99151354e-01 6.42870061e-01 2.38631244e-02]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.random.rand(12,3)  \n",
    "print(x.min())           # min of entire matrix\n",
    "print(x.min(axis=0))          # min across 1st dim\n",
    "print(x.max(1))          # max across 2nd dim\n",
    "print(x.cumprod(1))      # cumulative product across 2nd dim\n",
    "y = x.cumsum(0)          # cumulative sum across 1st dim\n",
    "\n",
    "r,c = y.shape\n",
    "plt.plot(np.arange(r), y, 'r-', linewidth = 4)    \n",
    "plt.xlabel('count')\n",
    "plt.ylabel('cumulative sum')\n",
    "plt.title('Cumulative sum down columns')\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Universal functions...sin, exp, corrcoef, etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.00000000e+00 1.36389534e+00 1.86021050e+00 2.53713244e+00\n",
      " 3.46038312e+00 4.71960041e+00 6.43704102e+00 8.77945026e+00\n",
      " 1.19742513e+01 1.63316256e+01 2.22746281e+01 3.03802615e+01\n",
      " 4.14354971e+01 5.65136815e+01 7.70787469e+01 1.05127344e+02\n",
      " 1.43382695e+02 1.95558989e+02 2.66721994e+02 3.63780886e+02\n",
      " 4.96159055e+02 6.76709025e+02 9.22960286e+02 1.25882124e+03\n",
      " 1.71690042e+03 2.34167248e+03 3.19379619e+03 4.35600375e+03\n",
      " 5.94113322e+03 8.10308393e+03]\n",
      "[0.         0.55708601 0.7878386  0.96490128 1.11417203 1.2456822\n",
      " 1.36457648 1.47391105 1.57567719 1.67125804 1.76166066 1.84764529\n",
      " 1.92980256 2.00860219 2.084425   2.15758486 2.22834406 2.29692448\n",
      " 2.36351579 2.42828164 2.4913644  2.55288883 2.61296502 2.67169067\n",
      " 2.72915296 2.78543007 2.84059246 2.89470384 2.94782211 3.        ]\n",
      "[ 2.          2.62068966  3.24137931  3.86206897  4.48275862  5.10344828\n",
      "  5.72413793  6.34482759  6.96551724  7.5862069   8.20689655  8.82758621\n",
      "  9.44827586 10.06896552 10.68965517 11.31034483 11.93103448 12.55172414\n",
      " 13.17241379 13.79310345 14.4137931  15.03448276 15.65517241 16.27586207\n",
      " 16.89655172 17.51724138 18.13793103 18.75862069 19.37931034 20.        ]\n",
      "[[1.         0.74150421]\n",
      " [0.74150421 1.        ]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "N = 30\n",
    "x = np.linspace(0,9,N)\n",
    "\n",
    "print(np.exp(x))\n",
    "print(np.sqrt(x))\n",
    "print(np.add(x, x+2))                 # add two same-sized arrays\n",
    "y = x + np.random.randn(1,len(x))*3   # make a second vector x + some randn noise \n",
    "print(np.corrcoef(x, y))              # correlation matrix\n",
    "\n",
    "plt.scatter(x, y, s=50, c='green', alpha=1, label=\"X vs Y\")  # note alpha or transparency\n",
    "plt.xlabel(\"X\")\n",
    "plt.ylabel(\"Y\")\n",
    "plt.legend(loc=2)   # 1-4 for each corner of the plot\n",
    "plt.show()\n",
    "\n",
    "# all, any, apply_along_axis, argmax, argmin, argsort, average, ...\n",
    "# bincount, ceil, clip, conj, corrcoef, cov, cross, cumprod, cumsum, ...\n",
    "# diff, dot, floor, inner, inv, lexsort, max, maximum, mean, median, ...\n",
    "# min, minimum, nonzero, outer, prod, re, round, sort, std, sum, trace, ...\n",
    "# transpose, var, vdot, vectorize, where"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set logic...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]\n",
      "[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15. 16. 17.\n",
      " 18. 19. 20.]\n",
      "[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15. 16. 17.\n",
      " 18. 19. 20.]\n",
      "[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15. 16. 17.\n",
      " 18. 19.]\n",
      "[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15. 16. 17.\n",
      " 18. 19. 20.]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(20)\n",
    "y = np.linspace(0, 20, 21)\n",
    "print(x)\n",
    "print(y)\n",
    "\n",
    "z = np.union1d(x,y)\n",
    "print(z)\n",
    "\n",
    "z = np.intersect1d(x,y)\n",
    "print(z)\n",
    "\n",
    "z = np.unique([np.append(x,y)])\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shape manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  4.   4.   0.  -3.   0.  -8.   8.  -6.]\n",
      " [ -1.  -4.   5.  10.   2.   4.  -5. -10.]\n",
      " [  2.   6.  -1.   4.  -3.   4.   8.   1.]\n",
      " [ -6.   2.  10.   3.  -4.   2.  -3.   4.]\n",
      " [  5.   2.   1.  -4.   6.  -3.  -3.   1.]\n",
      " [  7.  -1.  -3.  -6.  -2.   3.  -5.   1.]]\n",
      "Shape of x:  (6, 8) \n",
      "Shape of flattened x: (48,)\n",
      "[[  4.   0.  -1.   2.   2.  -3.  -6.  -4.   5.   6.   7.  -2.]\n",
      " [  4.  -8.  -4.   4.   6.   4.   2.   2.   2.  -3.  -1.   3.]\n",
      " [  0.   8.   5.  -5.  -1.   8.  10.  -3.   1.  -3.  -3.  -5.]\n",
      " [ -3.  -6.  10. -10.   4.   1.   3.   4.  -4.   1.  -6.   1.]]\n",
      "Reshaped x:  (12, 4) \n",
      "Reshaped x transposed:  (4, 12)\n"
     ]
    }
   ],
   "source": [
    "x = np.round(np.random.randn(6,8)*5)   # generate some random data from N(0,5), then round \n",
    "print(x)\n",
    "\n",
    "# flatten the array\n",
    "y = x.ravel()   \n",
    "print('Shape of x: ', x.shape, '\\nShape of flattened x:', y.shape)  # newline example + multiple outputs...\n",
    "\n",
    "# reshape\n",
    "x = x.reshape(12,4)   # 48 element array reshaped from a 6x8 to a 12x4\n",
    "\n",
    "# transpose - swap row/column\n",
    "print(x.T)\n",
    "print('Reshaped x: ', x.shape, '\\nReshaped x transposed: ', x.T.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concatenating arrays (stacking)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of z after vert stacking x,y:  (10, 6)\n",
      "shape of z after horizontal stacking x,y:  (5, 12)\n",
      "shape of z after vertical concat x,y:  (10, 6)\n",
      "shape of z after horizontal concat x,y:  (5, 12)\n"
     ]
    }
   ],
   "source": [
    "# use floor and ceil to make two 5x6 arrays of rand numbers\n",
    "x = np.floor(np.random.rand(5,6)*10)\n",
    "y = np.ceil(np.random.rand(5,6)*2)\n",
    "\n",
    "# vertical stacking of arrays...will make a 10x6\n",
    "z = np.vstack((x,y))\n",
    "print('shape of z after vert stacking x,y: ', z.shape)\n",
    "\n",
    "# horizontal stacking of arrays...will make a 5x12\n",
    "z = np.hstack((x,y))\n",
    "print('shape of z after horizontal stacking x,y: ', z.shape)\n",
    "\n",
    "# concatenate allows stacking along specified dim\n",
    "z = np.concatenate((x,y),axis=0)   # vstack - stack rows on top of each other\n",
    "print('shape of z after vertical concat x,y: ', z.shape)\n",
    "\n",
    "z = np.concatenate((x,y),axis=1)   # hstack - stack columns next to each other\n",
    "print('shape of z after horizontal concat x,y: ', z.shape)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References and reasignments (copies)...this is important because failure to understand this can have unintended consequences "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12,)\n",
      "True\n",
      "(3, 4)\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(12)\n",
    "print(x.shape)\n",
    "\n",
    "y = x                   # creates another name to refer to x\n",
    "\n",
    "print(y is x)           # y and x are the same object, so true\n",
    "\n",
    "y.shape = 3,4    # because y is another name for x, this changes shape of x\n",
    "print(x.shape)   # now x is a different size...  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if you want to make a new object that looks at the same data but that is not simply a reference to the same object (i.e. create a new 'view' of the data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "Shape of x:  (10,)  Shape of y:  (2, 5)\n",
      "1000.0\n"
     ]
    }
   ],
   "source": [
    "x = np.linspace(0,9,10)\n",
    "\n",
    "y = x.view()\n",
    "\n",
    "print(y is x)        # no...\n",
    "\n",
    "print(y.base is x)   # yes, because looking at the same data. \n",
    "\n",
    "# so you can change the shape of y and not affect x\n",
    "y.shape = 2,5\n",
    "print('Shape of x: ', x.shape, ' Shape of y: ', y.shape)\n",
    "\n",
    "# but since the data is shared, changing data in y changes data in x\n",
    "y[0,0] = 1000\n",
    "print(x[0,])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deep copy - make a complete copy of an array and its data...not just a view"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "changing the copy will NOT change the original...and this is often a very desirable feature!\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "[1000.    1.    2.    3.    4.    5.    6.    7.    8.    9.]\n"
     ]
    }
   ],
   "source": [
    "z = x.copy()\n",
    "print(z is x)       # not the same\n",
    "print(z.base is x)  # does not share the same data\n",
    "\n",
    "z[0] = -999         # since z is an independent copy, changing the data in z does not change x\n",
    "\n",
    "print(x)"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}