mp573_lecture_031.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MP/BME 573 lecture 31: Monte-Carlo Methods (1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "## MP 573 lecture 31\n",
    "##\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import display, Image\n",
    "import matplotlib.image as mpimg\n",
    "from os.path import dirname, join as pjoin\n",
    "import scipy.io as sio\n",
    "from scipy import signal, ndimage, misc\n",
    "from skimage.data import shepp_logan_phantom\n",
    "import scipy.stats as stats\n",
    "from matplotlib.image import NonUniformImage\n",
    "\n",
    "font = {'weight' : 'normal',\n",
    "        'size'   : 12}\n",
    "\n",
    "np.set_printoptions(precision=3)\n",
    "np.set_printoptions(suppress=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Warm-up problem: Casino's advantage\n",
    "\n",
    "Let us revisit a problem we know how to solve, but this time let us solve it using Monte-Carlo methods. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers of hands:\n",
      "[11, 10001]\n",
      "Mean earnings:\n",
      "[  -0.42 -186.4 ]\n",
      "Variance of earnings:\n",
      "[  11.304 9795.56 ]\n",
      "P(losing money):\n",
      "[0.54 0.94]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtMAAAFUCAYAAADmqbDMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3debgkZXn///eHRVCGEZURAwgjIIKooA5qEhcUV9RExfh1RUwUTX6YxbiQCDquoCYmMXEjoiCi4oIaJcYliggxmnEBHQIoy4gCZnAZGfbl/v1RdbRpTvfp06e7T5/h/bquus7pp56uuqu66u6na3kqVYUkSZKk+dtssQOQJEmSliob05IkSdKQbExLkiRJQ7IxLUmSJA3JxrQkSZI0JBvTkiRJ0pBsTM9DkouTHLnYcWjTlOTuSf4zyVVJFtRnZZKXJvlJkpuTrB5RiPOZfyV57qTn2zH/05K8b7Hmr+lgztY4bUo5e5KSHNB+R+y8iDGM9DvqNt+YTnJ8ki/3GNe9svcH/mHA6T60ff/KhUe5tCTZvV2vlya5vv17fJLdhpjWkUkuHkOY0+hvgbsC+wG/M+xEkuwI/CNwNLAT8Hc96j01yeeTXN4rsSR5eJLPJFnX1rFhokVlzh49c/bQpi5nt/UOSvK9JNe1PyhfNkudPZN8IcnVSa5I8p4k23TV2TbJvyb5efuD4fNJdu+qc1j7g+IXbUwPHXY9LGW3+cb0fFTV+qq6arHjmE2S2y12DABJ7g+sAXYGngXsATyTJkF8O8l+ixjetLsn8K2q+mFVXb6A6exGs2//W1VdVlUbe9RbBnwL+NM+01oGnAO8ElhITNLEmbPnZs5ekKnL2UlWAZ8B/oOmkb8aeHOSl3TUWQb8J3Aj8HvAM4DHA8d1Te5E4EDg6cBDgQBfSnL7jjp3AL4CvGKQBd1kVdVtegCOB77cY1wBz+14fTFwZMfrPwS+C1wN/IpmI78/sLJ9b+dwWvueAC8HLgSuBy4A/rJrvncBPg5cBfwMeANwQmecwGk0G/4bgMuA9W35s4FvAhuAK4BTgT073jcT27OBL7Sxnws8giZ5/ns733OAh81zXQY4Czgb2KJr3BbA94HvAem17oHnNptlARw6y3pc3TG917Tr7zrgp8A/d0znd4CPtp/LNe36WtUx/oB2egcB32jrfBvYpx3OaNfNt4B7d8X4QOCLwEZgPXAKsOsc62Zb4L1t/Wtpvrwe27WtdQ7H95nWQW2s1wH/B7wL2KYdt3qWaa0c4LO7xbbeo87FdGz/A0zvz2iS8ZXAJcAru+oMuq0+A/hs+3lcCDyvazq70nxxXAP8GHhp+3m/b659dTFzj8Nww2x5o2u7M2cPvi7N2b3XzZLM2cCHgf/qKnsbcFHH68Pa9XfHjrInttO8R/t6z/Z15zLfqV2GQ2eZ78x2+tABYp/5LB8DnN5+bucAj+uq9ybgf9vxlwDv6Yr5UJofBL8PfKet9z/AA7um80iabfza9u8ju9cfzVmGC9vlW0+zr91+4H1pPjvepjgwZGIG7kaTWF8J3APYmybZ3RfYHPiD9v37t3Xv3L7v/2s34sNoftW+pP2A/6RjPv8GnN9+4PsAH6BJtN2J+cp247o3cN+2/AXAk4Ddab4k/g34IXC7rg3+AuAp7Q7zKeBS4MvAU9uyT7Yb75Zdy98vYezbvc66xj+vHX+/XuueWybm2wPHtHHcrR2WteNOoElKz2uX9SHAX7XjQvPl9D2aX9P3BU4Gfgls37Uzfxd4VLsOv0Gzo51O82t8b5oE/c2O+O5Nk5BfB+zVTvvj7ee1dZ918/F2/T2une4/0Ww/e3VsT/8FnNT+f8ce07kfTfL4h3Y6T6BpQJ7Yjl8GPK1dtvu309p8gP1gHI3pnwEvaj+fP2/LHtlRZ9Bt9UKaBvUe7fZwI3DPjs/6OzQJ9ME0R2K+BPyatjFNn311sfOPw/wHzNnmbHM2vT43YB3wmq6yA9v6O3d8Fl/pqrMlcNPMNGm2y+u7YwG+TseBio7ylcy/MX0WzRHxewIfpPkhtV1HvSOBh7XTPpDmR+QJHeMPBW5uP/+HtZ/vF2n2lS3aOjvS/Nj8QLstPKbdZn6z/tr1/2vgycAuNN8jf4mN6cEHmuRwY7uzdQ/9EvP96fMLkiYh3Go8TZJ5a1fZPwAXtv/fs33fgV0b+SXcOjGfD2w2x/LduZ3e73dt8H/ZUWf/tuyvO8pmlu8+HWX/CRzdZ17PaN8z6xE/4AHt+D/qWPc9E3P9dme6uKvOHu10nt5jPjOJ494dZVvRHA16Tfv6gLbOUzrq/FFbdnBH2VPbsmUdMX+0a35b0fwifkqPeGbiPair/DvA+7s+01slqa73nEhzWrGz7A9pEsquXcu28zz2g3E0pt/RVXbuHNtPr231ZR11tqDZN1/cvn50W6fzSN4KmsbPTGO6777qsLQGzNlgzp6pY86+dfn1wGFdZfu09fdvX38R+PAs710PvKL9/2+BS2ep83Hg1FnKZ7bT+TSmn9ZRdre27HF93vdUmiPHm7WvD23f84COOg9py+7Vvn4jzQ+MLTrqPKlz/QF/RbNvbjlX7L0Gr5lufJPml0j30M/ZNKcBfpDkU0n+Isnd+70hyXKa69JO7xr1NWBlkjvQ/HIC+O+ZkVV1A80ppm7frqqbu+axXxvPRUmupPkFDM2p8E5ndfw/c63X2bOU3bUjjgOr6m9mXbh29n3GjdID2r9f7DF+H+DnVXXOTEFVXUfzOe/TVXe+62F/4KlJNs4MwM+BrWm+VGcz85l2f+6nzxLPXPaZZTpfo1n397519UX1va7XPwV2mHkxj231N9OpqhtpjnjPTOfewBVVdX5HnfXAeR3vn/e+qqlnzv7tMnWXmbMb5uxbqwnWGURnbr+c5sh453fE05Kc3t4Qu5HmLMDtaBrenbF0bhM/bf92fkd8q/3umHFGVxwfo/kBvK698fZ5Sbadz4LYmG5cU1U/6h76vaGqbqI5XfMomlPMBwPnJ3nSAPPr3hBnS2iDbKy3uLGmTexfbN/7x8CD+O0RjO6bXW6YZV6zlc1nG5lpwNynx/h9uurdzK2Xfct5zK+f2dZfZimf73rYjOZIQ/eX+J7AfLtimy2eQfR6z6gS3Khc3/W6aNfjPLfVntNhgHW4wH1V08mc3bvMnN24rebsy7hlYxN+27C8vFedJFvSnBXprLN9ks1nmdaobkbvzu3w2++IB9McBT+d5oj0A2gusYJb7hs3t/v2jO7Pf7bP7Bavq+qnNJeI/DHNpUhHAefN56CLjekFqMa3qurNVfVwml+bL2hHz2wkm3fU/zXwE5obRzo9nObmgJmL8AF+d2Zkki1obqCYy940p7hfXVVfrar/pblhYFJHH84CfgC8oo35N9rXr6Q5gvD9tvj/aK5n6vSArtfX07EOW99p/z62RxxraZLAb371J9mK5otq7dyL0dcammvgLpjly/yXfeKB5nPu9LAh4lnLrbefR9Akh3NuXX1qjWpbXQusSPKbI0xJtqf5ovyNOfZV3UaYs2/FnN07HliaOftMmuu8Oz0eWFdVP+mo87vtmZcZj6FpE57ZUWdLmh+fACTZjubelO4ju+PwUJqzjkdW1Tfbs4/D9Eu9Fnhw14+CW3XfV1XXVdV/VNUraa6rvwPNPQoDsTE9pCS/l+SoJA9OskuSA2l22JmdYx3Nr/iDktw1yR3b8qOBlyZ5UZJ7JnkxTTc3bwaoqh/S9FzwziSPaJPLe4HlzP0rdh3N9UQvbfsNPZDmpomR/Ppt+5I8utf4ai4+OpTm9OTn0/RRfPckD6O543xnmruAZ+L5MrBXksPbeF9Ecw1fp4uAuyX53STbJ7lDewTqJOBdSZ7bvnf/JH/RvucrNHd0fzjJ7ye5D83NDVsD717gangzzRfgh5I8KMk9kjwyyT+lR5+sVXUBzS/sdyV5XJK9kvwTzdGgt81z/m8DHpDk7e10Hg/8M3BSVf14jvfeQpI7t6eYZ06P79K+3qWjzrKOOrej+Sz2S7LHPOPuNqpt9T9pGgQzn8d+NNvGb07pDbCv6jbAnH1r5uxNL2fTXM//oCRvaud3CE0PR8d01PkwTc8xH06yb5JHAu8ETq6qi9p1cD5NF3vvbrfr/dr3/ZTm5tCZmO7Wjpv5IbRHG1P30fH5Oo/mQMmfJNmtXY4/G2I676b5wXpskr3bfexNnRXaebyoXRe7As+h6c1l8O+IYS+23lQGhr8zfB+aZHM5TTJcR7PT3K6j/itpNrybuGU3S6+gSTg30PRUMFs3S5+guUHi/4DX0+zYn+2ocxqz31H7dJo7wa+luev5ETQNi0Orx00CNAmzgAM6ymZuBnh01/IfP8A6nbkz97J2GS+juXt491nqvrpdRxuBj9DcOV8d47ek2YF/0cazuqP8DW1M19McPfrHjvd1d7P0NWbvZmnnjrJb3YDEb29m2KOj7L40SeaX7bR/BBxLe/d/j3WynN92s3QdXd0s9ftMZ5lWZzdL62mSxTb9lq3HdA5t63UPx88yre7htDmmfYt9py37cte0572ttuU/mtkOOup9sZ3OT4C/6FyXDLCvOiydAXM2mLNnyszZXTm7rfdEmoMMM9v5y2aZ1r1o8ubVNNeQv7czprbOtjSXwvyirfcfneu1rbO6R0yr+yzHrMtLx3bfvn4DzT0yV9Hsu8/q/Lzb9XFj1zRm2zcOpDm7ch3NmZhHccsbEJ9G0zPLL9vl/AEdvfUMMsz0Hakplub0xLk0Hbr/9WLHI0nqzZwt3bZsMXcVTVqSh9Pcifxdml+Gf0VzdOL4xYtKkjQbc7Z022ZjejptTtNX5x40p9x+QPOwi+/3fZckaTGYs6XbMC/zkCRJkoY0kd48kmyV5Lgk65JcmeS7SZ7QjluZpNLRoXqSoyYRlyRJkrQQk7rMYwuaR6s+gubpTgcBH0ty344629Utn1AjSZIkTbVFu8wjydnA62i6i7mI5pnoAzemt99++1q5cuWYopOkwXz729++oqpWLHYcmypzvaRp0C/XL8oNiEl2oHlCWeeThNYlKeBLwCuq6op+01i5ciVr1qwZY5SSNLck6xY7hk2ZuV7SNOiX6yf+BMQ0z38/CTihqs6leQrP/jRPYHogTbdCJ/V472FJ1iRZs379+kmFLEmSJM1qoo3pJJsBJ9I8/ehwgKraWFVrqurGqvpZW/7Y3PKZ8bR1j62qVVW1asUKz6pKkiRpcU3sMo8kAY4DdgAOqqobelSduYg7EwlMkiRJGtIkr5l+N7A38OiqumamMMmDgV8BPwTuBLwDOK2qNkwwNkmSJGneJtXP9K7Ai4H9gMs7+pN+DrAb8B/AlTRPjboOeNYk4pIkSZIWYiJHpqtqHf0v2/jIJOKQJEmSRmnivXlIkiRJmwob05IkSdKQbExLkiRJQ7IxLUmSJA3JxrQkSZI0pEn2My1NnZVHnDqR+Vx8zBMnMh9J0i1NKs+Duf62yiPTkiRJ0pBsTEuSJElDsjEtSZIkDcnGtCRJkjQkG9OSJEnSkGxMS5IkSUOyMS1JkiQNyca0JGlWSbZKclySdUmuTPLdJE/oGH9gknOTXJ3kq0l27TOtlW2dq9v3PHoySyFJ42VjWpLUyxbAJcAjgDsCRwEfaxvG2wOntGV3BtYAJ/eZ1keA7wJ3AV4NfCLJijHGLkkTYWNakjSrqrqqqlZX1cVVdXNVfQ64CHgg8DRgbVV9vKquBVYD+ybZq3s6SfYEHgC8tqquqapPAt8HDp7YwkjSmNiYliQNJMkOwJ7AWmAf4KyZcVV1FXBBW95tH+DCqrqyo+ysHnUlaUmxMS1JmlOSLYGTgBOq6lxgGbChq9oGYNtZ3j6fuiQ5LMmaJGvWr1+/sMAlacxsTEuS+kqyGXAicD1weFu8EVjeVXU5cCW3Np+6VNWxVbWqqlatWOFl1ZKmm41pSVJPSQIcB+wAHFxVN7Sj1gL7dtTbBti9Le+2FtgtSeeR6H171JWkJcXGtCSpn3cDewNPrqprOso/BdwnycFJtgZeA5zdXgJyC1V1PvA94LVJtk7yVOB+wCfHH74kjZeNaUnSrNp+o18M7AdcnmRjOzynqtbT9MbxJuCXwIOBZ3a89z1J3tMxuWcCq9q6xwBPb6chSUvaFosdgCRpOlXVOiB9xn8ZuFVXeO24l3S9vhg4YIThSdJU8Mi0JEmSNCQb05IkSdKQbExLkiRJQ7IxLUmSJA3JGxClCVh5xKkTm9fFxzxxYvOSJOm2ziPTkiRJ0pBsTEuSJElDsjEtSZIkDcnGtCRJkjQkG9OSJEnSkGxMS5IkSUOyMS1JkiQNyca0JEmSNCQb05IkSdKQbExLkiRJQ7IxLUmSJA3JxrQkSZI0JBvTkiRJ0pBsTEuSJElD2mKxA5AkSdNh5RGnTmxeFx/zxInNSxonj0xLkiRJQ5pIYzrJVkmOS7IuyZVJvpvkCR3jD0xybpKrk3w1ya6TiEuS1F+Sw5OsSXJdkuM7yp+TZGPHcHWSSvLAHtM5Lcm1HfXPm9hCSNIYTerI9BbAJcAjgDsCRwEfS7IyyfbAKW3ZnYE1wMkTikuS1N+lwBuB93cWVtVJVbVsZgD+DLgQ+E6faR3e8Z57jS9kSZqciVwzXVVXAas7ij6X5CLggcBdgLVV9XGAJKuBK5LsVVXnTiI+SdLsquoUgCSrgJ37VH0+8MGqqokEJklTYlGumU6yA7AnsBbYBzhrZlzb8L6gLZckTbn20ryHAx+co+rRSa5IcmaSA8YfmSSN38Qb00m2BE4CTmiPPC8DNnRV2wBsO8t7D2uv3Vuzfv368QcrSRrEIcDXq+qiPnVeBewG7AQcC3w2ye6zVTTXS1pKJtqYTrIZcCJwPXB4W7wRWN5VdTlwZff7q+rYqlpVVatWrFgx1lglSQM7BDihX4Wq+mZVXVlV11XVCcCZwEE96prrJS0ZE2tMJwlwHLADcHBV3dCOWgvs21FvG2D3tlySNMWS/D6wI/CJeb61gIw+IkmarEkemX43sDfw5Kq6pqP8U8B9khycZGvgNcDZ3nwoSYsvyRZtbt4c2DzJ1kk6b15/PvDJqrrV2cSOaWyX5HEz703yHJprrL8w3uglafwm1c/0rsCLgf2Ayzv6GX1OVa0HDgbeBPwSeDDwzEnEJUma05HANcARwHPb/48EaBvZz2CWSzyS/G2Sz7cvt6TpXm89cAXwUuApVWVf05KWvEl1jbeOPqfzqurLwF6TiEWSNLiqWs0tuzbtHHctsF2PcW/u+H89sP8YwpOkRefjxCVJkqQh2ZiWJEmShmRjWpIkSRqSjWlJkiRpSDamJUmSpCHZmJYkSZKGZGNakiRJGpKNaUmSJGlIAzWmk7wsyX7t/w9J8uMkFyb53fGGJ0kalrlbksZv0CPTfwVc1P5/NPB2msd//+M4gpIkjYS5W5LGbNDHid+xqjYk2RbYF3h0Vd2U5O/HGJskaWHM3ZI0ZoM2pi9J8nvAPsDpbTJeDtw0vtAkSQtk7pakMRu0Mf0K4BPA9cDBbdmTgG+NIyhJ0kiYuyVpzAZqTFfVvwM7dhV/vB0kSVPI3K1ptvKIUxc7BGkkBj0yTZK9gacDO1TV4cDuwO2As8cUmyRpgczdkjReg3aN90fA6cBOwCFt8TKaO8MlSVPI3C1J4zdo13ivBx5TVS/htzeunEVzd7gkaTqZuyVpzAZtTN+VJgEDVMffmr26JGkKmLslacwGbUx/G3heV9kz8Y5wSZpm5m5JGrNBb0D8c+CLSf4E2CbJF4A9gceOLTJJ0kKZuyVpzAbtGu/cJHvR9E/6OeAS4HNVtXGcwUmShmfulqTxG7Q3j52ArarqY1X1tqr6KLBlku7+SyVJU2IUuTvJ4UnWJLkuyfEd5SuTVJKNHcNRfaazMslXk1yd5Nwkj17QwknSlBj0mulPAzt3le0MfGq04UiSRmgUuftS4I3A+3uM366qlrXDG/pM5yPAd4G7AK8GPpFkxTzikKSpNGhjes+q+n5nQft6r9GHJEkakQXn7qo6pao+Dfx82CCS7Ak8AHhtVV1TVZ8Evs9vH3EuSUvWoI3p9Un26CxoXw+dXCVJYzeJ3L0uyU+SfCDJ9j3q7ANcWFVXdpSd1ZZL0pI2aGP6/cAnkzwpyb2TPBn4BPC+8YUmSVqgcebuK4D9gV2BBwLbAif1qLsM2NBVtqF9z60kOay9TnvN+vXrRxCqJI3PoF3jHQPcAPwdcHeaO8Lfh4+k1RisPOLUxQ5hSZvU+rv4mCdOZD5akLHl7rZHkDXty58lORy4LMnyqvp1V/WNwPKusuXAlcyiqo4FjgVYtWqVD5iRNNUG7RrvZuBt7SBJWgImnLtnGr2ZZdxaYLck23Zc6rEv8OEJxCVJYzXokWmS3Ism+S3rLK+qXnd4S5IW2UJzd5ItaL4rNgc2T7I1cCPNpR2/An4I3Al4B3BaVXVfzkFVnZ/ke8BrkxwJPAG4H96AKGkTMFBjOsnfAq+huWHk6o5RRe/ukiRJi2hEuftI4LUdr58LvA44D3gzcFfg18CXgGd1zPs9AFX1krbomcDxwC+BHwNPryoviJa05A16ZPovgQdV1dnjDEaSNFILzt1VtRpY3WP0R/q87yVdry8GDhg2DkmaVoP25nENcO44A5EkjZy5W5LGbNDG9FHAPyf5nSSbdQ7jDE6StCDmbkkas0Ev8zi+/fvCjrLQXHe3+SgDkiSNzPHtX3O3JI3JoI3pe4w1CknSOJi7JWnMBu1neh1Ae2pwh6q6bKxRSZIWzNwtSeM30HVzSbZL8mHgWuBHbdkfJHnjOIOTJA3P3C1J4zfoTSjvATYAuwLXt2XfAP7fOIKSJI2EuVuSxmzQa6YPBHasqhuSFEBVrU9y1/GFJklaIHO3JI3ZoEemNwDbdxYk2QXw+jtJml7mbkkas0Eb0+8DPpnkkcBmSX4XOIHmFKIkaTqZuyVpzAa9zOMtNDewvBPYEng/8F7gn8YUlyRp4czdkjRmczamk2wOPB94d1X94/hDkiQtlLlbkiZjzss8quom4O1Vdd0E4pEkjYC5W5ImY9Brpj+b5MkLmVGSw5OsSXJdkuM7ylcmqSQbO4ajFjIvSRIwgtwtSepv0GumtwY+keQbwCVAzYyoqkMGnMalwBuBxwG3n2X8dlV144DTkiTNbRS5W5LUx6CN6R+0w9Cq6hSAJKuAnRcyLUnSQBacuyVJ/Q3UmK6q1407EGBd+1CBLwGvqKorJjBPSdpkTSh3S9Jt2kCN6SSP6jWuqr6ywBiuAPYHvgfchaYLp5NoLgfpjuMw4DCAXXbZZYGzlaRN25hztySJwS/zOK7r9QrgdsBPgN0WEkBVbQTWtC9/luRw4LIky6vq1111jwWOBVi1alUhSepnbLlbktQY9DKPe3S+bvsvPRK4cgwxzTSSM4ZpS9JtxoRzt3Sbt/KIUycyn4uPeeJE5qPBDNo13i20/Ze+CXjloO9JskWSrYHNgc2TbN2WPTjJvZJsluQuwDuA06pqwzCxSZJmN0zuliT1N1RjuvUY4OZ51D8SuAY4Anhu+/+RNKca/4PmSMkPgOuAZy0gLklSb/PK3X2eEfCQJF9K8osk65N8PMnv9JnOaUmu7XiewHkLWwxJmg6D3oB4i/5JgTvQ9F/6Z4POqKpWA6t7jP7IoNORJA1mFLmb3s8IuBPNPSxfAG4E/gX4APD4PtM6vKreN495S9LUG/QGxOd2vb4KOL/7BkFJ0lRZcO7u9YyAqvp8Z70k/wJ8bfhQJWlpGrQx/d/AzVV1w0xBki2TbFVV140nNEnSAk0ydz8cWDtHnaOTHAOcB7y6qk4bcQySNHGDXjP9JeCBXWUPpDm9J0maThPJ3UnuB7wGeEWfaq+iuUdmJ5rLQz6bZPce0zusvU57zfr160cZqiSN3KCN6fsC3+wq+xaw72jDkSSN0Nhzd5I9gM8Df1FVX+9Vr6q+WVVXVtV1VXUCcCZwUI+6x1bVqqpatWLFilGFKkljMWhjegOwQ1fZDjTX30mSptNYc3eSXYEvA2+oqhPn+fbC5wlI2gQM2pj+JPDhJPdJcock9wU+CHxsfKFJkhZowbm7zzMCdgK+Aryzqt4zxzS2S/K4jvc+h+Yaay8VlLTkDdqYfjXwvzSnB6+kuanlPOBvxxSXJGnhRpG7ez0j4IU010C/tqPv6I0zb0ryt0lmevzYkqZ7vfXAFcBLgadUlX1NS1ryBn2c+LXA/5fkcGB74IqqqjneJklaRKPI3XM8I+B1fd735o7/1wP7z2e+krRUDPrQlkOA71XV2TRHFkiyL3C/Ia6TkyRNgLl707HyiFMXOwRJPQx6mccbgEu6yi6hOW0nSZpO5m5JGrNBG9PLge4nZm0AthttOJKkETJ3S9KYDdqYPgc4uKvsqTQ3tkiSppO5W5LGbNDHib8K+Pck/w+4ANgDOJAeHe5LkqaCuVuSxmygI9NVdQZwH+B/gG1oulm6T1WdOcbYJEkLYO6WpPEb9Mg0VfXjJG+leXrWz6rq5vGFJUkaBXO3JI3XQEemkyxP8kGazvp/AlyT5IQkdxxrdJKkoZm7JWn8Br0B8R00pwjvC9yh4+87xhSXJGnhzN2SNGaDXubxeGC3qrq6fX1+khfQ3NAiSZpO5m5JGrNBj0xfC6zoKtseuG604UiSRsjcLUljNuiR6fcBX0rydmAdsCvwV8Cx4wpMkrRg5m5JGrNBG9NvAi4Fng3s2P7/VuD9Y4pLkrRw5m5JGrOBGtNVVTTJ1wQsSUuEuVuSxm/Qa6YlSZIkdbExLUmSJA3JxrQkSZI0pJ6N6ST/3fH/aycTjiRpIczdkjRZ/Y5M75lk6/b/v55EMJKkBTN3S9IE9evN4zM0T8u6GLh9ktNnq1RVDx9HYJKkoZi7JWmCejamq+oFSR4KrAT2B46bVFCSpOGYuyVpsvr2M11VZwBnJLldVZ0woZgkSQswytyd5HDgUOC+wEeq6tCOcQcC7wR2Ab4JHFpV63pMZyXwAeDBwI+Bw6vqywuJTZKmwUC9eVTV+5M8Msn7k3yh/fuocQcnSRreiHL3pcAb6XrwS5LtgVOAo4A7A2uAk/tM5yPAd4G7AK8GPpFkxTxjkaSpM1BjOvc+OA0AABqwSURBVMkLaZLk5TTJ8zLgw0leNMbYJEkLMIrcXVWnVNWngZ93jXoasLaqPl5V1wKrgX2T7DVLHHsCDwBeW1XXVNUnge8DBw+xWJI0VQZ6nDjwSuAxVXXWTEGSk4FPAv86jsAkSQs2zty9D/Cb6VbVVUkuaMvPnaXuhVV1ZUfZWW25JC1pgz605S7AOV1l59Gc2pMkTadx5u5lwIausg3AtgusS5LDkqxJsmb9+vULDlSSxmnQxvQZwNuT3AEgyTbA24D/GldgkqQFG2fu3ggs7ypbDly5wLpU1bFVtaqqVq1Y4WXVkqbboI3plwD3AzYk+RnwK2Bf4MXjCkyStGDjzN1r22kBv2mo796Wz1Z3tySdR6L37VFXkpaUga6ZrqrLgEck2RnYEbi0qn4y1sgkSQsyitydZAua74rNgc3bpyveCHwKeFuSg4FTgdcAZ1dV9/XSVNX5Sb4HvDbJkcATaBr53oAoackb9AZEANokbCNakpaQBebuI4HXdrx+LvC6qlrdNqT/BfgQTT/Tz5yplOQ97bxf0hY9Ezge+CVNP9NPryoviJa05M2rMS1Jum2pqtU03d7NNu7LwK26wmvHvaTr9cXAASMNTpKmwKDXTEuSJEnqMmdjOslmSR6V5HaTCEiStHDmbkmajDkb01V1M/CZqrp+AvFIkkbA3C1JkzHoZR6nJ3nIWCORJI2auVuSxmzQGxDXAZ9P8hngEqBmRlTVa8YRmCRpwczdkjRmgx6Zvj3waZpEvDNw945hIEkObx8Pe12S47vGHZjk3CRXJ/lqkl0Hna4kqacF525JUn+DPrTlBSOY16XAG4HH0SR4AJJsD5wCvBD4LPAG4GTAU5OStAAjyt2SpD4G7mc6yd7A04EdqurwJPcCtqqqswd5f1Wd0k5nFc0RkhlPA9ZW1cfb8auBK5LsNduTtCRJg1to7pYk9TfQZR5J/gg4HdgJOKQt3hZ4+whi2Ac4a+ZFVV0FXNCWS5KGNObcLUli8GumXw88pn2i1U1t2VnAviOIYRmwoatsA03Cv4Ukh7XXXa9Zv96n0ErSHMaZuyVJDN6Yviu/PXpcHX9r9urzshFY3lW2HLiyu2JVHVtVq6pq1YoVK0Ywa0napI0zd0uSGLwx/W3geV1lzwS+NYIY1tJxlCTJNsDubbkkaXjjzN2SJAa/AfHPgS8m+RNgmyRfAPYEHjvojJJs0c5vc2DzJFsDNwKfAt6W5GDgVOA1wNnefChJC7bg3C1J6m/QrvHOTbIX8CTgczSd/3+uqjbOY15HAq/teP1c4HVVtbptSP8L8CHgmzRHTiRJCzCi3C1J6mPgrvGq6uokZwIXAZfONxlX1WpgdY9xXwb2ms/0JElzW2juliT1N2jXeLsk+TpwMc2lGBcnOcMnFUrS9DJ3S9L4DXoD4gk0N7JsV1V3Be4E/E9bLkmaTuZuSRqzQS/zeCDw2Kq6AaCqNiZ5FfDzsUUmSVooc7ckjdmgR6b/G3hQV9kq4BujDUeSNELmbkkas55HppO8vuPlBcC/JzmV5m7wuwMHAR8eb3iSpPkwd0vSZPW7zOPuXa9Paf/eFbiOpn/orccRlCRpaOZuSZqgno3pqnrBJAORJC3cJHN3ku5u9m4PvKuqXjpL3UOB44BrOoqfVFWnjS1ASZqAgfuZTnIHYA9gWWd5Vf3XqIOSJI3GOHN3Vf1mmkm2AX4GfLzPW75RVQ9d6HwlaZoM1JhOcgjNEwqv55ZHFQrYZQxxSZIWaMK5++nA/wFfH/F0JWmqDXpk+q3AwVX1pXEGI0kaqUnm7ucDH6yq6lPn/kmuAH4BnAgcXVU3dldKchhwGMAuu3i8RtJ0G7RrvOuB08YYhyRp9CaSu5PsAjyC/g+DOR24D82NkAcDzwJeMVvFqjq2qlZV1aoVK1aMOlxJGqlBG9NHAW9Psv04g5EkjdSkcvchwBlVdVGvClV1YVVdVFU3V9X3gdfTXBoiSUvaoI3p84E/AH6W5KZ2uDnJTWOMTZK0MJPK3Ycw/0eUF5ARxyFJEzfoNdMnAh8ETuaWN7FIkqbX2HN3kt8DdqJ/Lx4keQLwnar6WZK9aI6a932PJC0Fgzam7wK8Zo4bSyRJ02USufv5wClVdWVnYXsd9TnAvavqx8CBwPFJltF0ofch4M1jjEuSJmLQxvQHgOfRHOGQJC0NY8/dVfXiHuU/pqNv66p6OfDyccUhSYtl0Mb0g4DDk7ya5ojCb1TVw0celabSyiNOXewQJM2PuVuSxmzQxvS/toMkaekwd0vSmA3UmK6q+d6lLUlaZOZuSRq/QR8n/se9xlXV+0cXjiRpVMzdkjR+g17m8byu13cDdgfOBEzIkjSdzN2SNGaDXubxyO6y9ojH3iOPSJI0EuZuSRq/QZ+AOJvjgT8ZURySpMk4HnO3JI3MoNdMdze67wA8F/jVyCOSJI2EuVuSxm/Qa6ZvBLqfoPVT4EWjDUeSNELmbkkas0Eb0/foen1VVV0x6mAkSSNl7pakMRv0BsR14w5EkjRa5m5JGr++jekkX+XWpwg7VVUdONqQJEkLYe6WpMmZ68j0h3qU7wT8Oc3NLJKk6WLulqQJ6duYrqrjOl8nuQvwNzQ3r5wMvH58oUmShmHulqTJGaif6STLk7wB+BGwA/CAqjqsqn4y1ugkSUMzd0vS+PVtTCe5fZK/AS6keWLWQ6vqeVV1wUSikyTNm7lbkiZnrmumLwI2B94KrAF2SLJDZ4Wq+sqYYpMkDcfcLUkTMldj+lqaO8L/tMf4AnYbaUSSpIUyd0vShMx1A+LKCcUhSRoRc7ckTc5ANyBKkiRJujUb05KkoSU5Lcm1STa2w3k96iXJW5L8vB3emiSTjleSRs3GtCRpoQ6vqmXtcK8edQ4DngLsC9wPeBLw4kkFKEnjYmNakjQJzwf+vqp+UlU/Bf4eOHRxQ5KkhbMxLUlaqKOTXJHkzCQH9KizD3BWx+uz2jJJWtLm6hpPkqR+XgWcA1wPPBP4bJL9ZnlAzDJgQ8frDcCyJKmq6qyY5DCay0LYZZddxhb4Qq084tTFDkHaZExyf7r4mCeOdHoemZYkDa2qvllVV1bVdVV1AnAmcNAsVTcCyzteLwc2djek22keW1WrqmrVihUrxhO4JI2IjWlJ0igVMFsvHWtpbj6csW9bJklLmo1pSdJQkmyX5HFJtk6yRZLnAA8HvjBL9Q8CL0uyU5Idgb8Gjp9guJI0FlNzzXSS04CHADe2RT/t08WSJGnxbQm8EdgLuAk4F3hKVZ2X5GHA56tqWVv3vTSPMP9++/p9bZkkLWlT05huHV5V71vsICRJc6uq9cD+PcZ9neamw5nXBbyyHSRpk+FlHpIkSdKQpq0xPUhfpZIkSdJUmKbG9KtorqfbCTiWpq/S3TsrJDksyZoka9avX78YMUqSJEm/MTWN6UH6KrXvUUmSJE2TqWlMz6JXX6WSJEnSVJiKxvQ8+yqVJEmSpsK0dI3Xs6/SRY1KkiTpNmzlEacudghTbyoa0/36KpUkSZKm1VRc5iFJkiQtRTamJUmSpCHZmJYkSZKGZGNakiRJGpKNaUmSJGlIU9Gbh6SlZ5LdJV18zBMnNi9JkubDI9OSJEnSkGxMS5IkSUOyMS1JkiQNyca0JEmSNCQb05IkSdKQ7M1DkrRJmWRPM9JicBufLh6ZliRJkoZkY1qSNJQkWyU5Lsm6JFcm+W6SJ/Soe2iSm5Js7BgOmHDIkjRyXuYhSRrWFsAlwCOAHwMHAR9Lct+quniW+t+oqodOMD5JGjsb00uc103ptmBS27lPWpyfqroKWN1R9LkkFwEPBC5ejJgkadK8zEOSNBJJdgD2BNb2qHL/JFckOT/JUUk8oCNpyTORSZIWLMmWwEnACVV17ixVTgfuA6wD9gFOBm4Ejp5lWocBhwHssssu4wpZkkbCI9OSpAVJshlwInA9cPhsdarqwqq6qKpurqrvA68Hnt6j7rFVtaqqVq1YsWJscUvSKHhkWpI0tCQBjgN2AA6qqhsGfGsBGVtgkjQhHpmWJC3Eu4G9gSdX1TW9KiV5QntNNUn2Ao4CPjOZECVpfGxMS5KGkmRX4MXAfsDlHf1HPyfJLu3/Mxc9HwicneQq4N+BU4A3L07kkjQ6XuYhSRpKVa2j/6Uayzrqvhx4+diDkqQJ88i0JEmSNCQb05IkSdKQbExLkiRJQ7IxLUmSJA3JxrQkSZI0JBvTkiRJ0pBsTEuSJElDsjEtSZIkDcnGtCRJkjQkG9OSJEnSkGxMS5IkSUOyMS1JkiQNyca0JEmSNCQb05IkSdKQtljsACZt5RGnLnYIkiRJ2kR4ZFqSJEkako1pSZIkaUg2piVJkqQh2ZiWJEmShmRjWpIkSRqSjWlJkiRpSFPTmE5y5ySfSnJVknVJnr3YMUmS+hs0d6fxliQ/b4e3Jsmk45WkUZumfqbfCVwP7ADsB5ya5KyqWru4YUmS+hg0dx8GPAXYFyjgS8CFwHsmGKskjdxUHJlOsg1wMHBUVW2sqjOAfwOet7iRSZJ6mWfufj7w91X1k6r6KfD3wKETC1aSxmQqGtPAnsBNVXV+R9lZwD6LFI8kaW7zyd37tOPmqidJS8q0XOaxDNjQVbYB2LazIMlhNKcKATYmOW8Csc3YHrhigvMbhDENZtpimrZ4wJgAyFvmrDJbTLuOJZilYaDc3aPuBmBZklRVdVYcU66fxm181Db1ZdzUlw82/WWciuUbINfPpmeun5bG9EZgeVfZcuDKzoKqOhY4dlJBdUqypqpWLca8ezGmwUxbTNMWDxjToKYxpkU2UO7uUXc5sLG7IQ3jyfW3hc9uU1/GTX35YNNfxk11+ablMo/zgS2S3LOjbF/Amw8laXrNJ3evbcfNVU+SlpSpaExX1VXAKcDrk2yT5PeBPwROXNzIJEm9zDN3fxB4WZKdkuwI/DVw/MSClaQxmYrGdOvPgNsD/wd8BPjTKesWb1EuL5mDMQ1m2mKatnjAmAY1jTEttllzd5KHJdnYUe+9wGeB7wM/AE5tyybltvDZberLuKkvH2z6y7hJLl9muVxNkiRJ0gCm6ci0JEmStKTYmJYkSZKGZGO6leTwJGuSXJfk+FnGH5jk3CRXJ/lqkp79DSZZ2da5un3Po0cU48au4aYk/9yj7qHt+M76B4wijq75nJbk2o559OwPNo23JPl5O7w1SUYYy1ZJjkuyLsmVSb6b5Al96o9tHSW5c5JPJbmqjefZPeqNdZ208xh4vUxqu2nnNdC2M4l11M5n6vYvDS/JPdvt60Nd5c9u94Wrknw6yZ07xg203y62JB9KclmSXyc5P8kLu8b3/L5q88H72/denuRlk1+C3gbJV0t5+WZkAW2OpbKMnZbKvjW0qnJorht/GvAU4N3A8V3jtqd5wMAfAVsDbwP+u8+0vgG8neamnIOBXwErRhzvNjT9tj68x/hDgTMmsN5OA144YN0XA+cBOwM7AecALxnxOlkNrKT5ofgkmv5uV056HdHciHUyzYMqHtpuP/tMep3Md71MaruZz7YziXXUY50t+v7lsKDP8IvA14EPdZTt0277D2/3zQ8DH+0YP9B+u9hDuxxbtf/vBVwOPLB93ff7Cji6XS93AvZu3/v4xV6mjvj65qulvnwdcQ7d5lgqy9i1TEti3xp6+RY7gGkbgDfOsmEfBvxXx+ttgGuAvWZ5/57AdcC2HWVfH/WXP/B84ELam0hnGT+RL3vm15j+L+Cwjtd/Qp8fJSOK72zg4Emuo3b7uB7Ys6PsROCYaVgn/dbLpLab+Ww7i7TdTMX+5TD05/dM4GM0jbLOxvSbgQ93vN693Ve3nc9+O00DcC/gMuAZ7eu+31fAT4HHdox/Ax0/KKZx6MxXm9ryMUSbYwku45Lct+YzeJnHYPYBzpp5UU3fqhe05bPVvbCqOp8AdlaPugvxfOCD1W6VPdw/yRXtacCjkozriZdHt/M5c45T3bdYj4xnvfxGkh1oftz062JxHOtoT+Cmqjq/o6zXsk50ncBA62VS2w0Mtu1MfB0xXfuX5iHJcuD1NP1Yd+vO5RfQfskzv/120SV5V5KrgXNpGtP/3o7q+X2V5E7Ajkx+fxraLPlqk1q+Hja1ZVxS+9YwbEwPZhnNKYlOG2iOZiyk7lCS7AI8AjihT7XTgfsAd6W51ORZwCtGFUOHVwG70Zx+Pxb4bJLde9TtXjcbgGVjuv51S+Ak4ISqOrdHtXGto4VsL2NbJzDQepnUdgODbzuTXkfTtH9p/t4AHFdVl8wyrt++OfbcPUpV9Wc0sT2M5sE517Wj5lpGuPX+NJXL2CNfbTLL18emtoxLat8axm2iMZ3mRqfqMZwxwCQ2Asu7ypbTXMe1kLrDxngIzSnmi3pNr6ourKqLqurmqvo+zZGap/eLYZiYquqbVXVlVV1XVScAZwIH9Zhk97pZDmyc4+jfvOJp621GcwrpeuDwXtMbxTrqYSHby7zWyXwMsl7GuE5mm9eg287E1lFrIvuX5m+uHJBkP+DRwD/0mES/fXOo3D1q8/kuqKqbquoMmvsJ/rQtnmsZ4db708SWcQR5fKqXD8be5piKZZynqdi3xuk2cVqyqg5Y4CTW0pz2BSDJNjTX2s12mnwtsFuSbTsu9diX5kaXUcV4CHDMPOoDFDCvI3lDrrd+81lLsy6+1b7el/6XYMw7nvZo5XHADsBBVXXDoNNniHXUw/nAFknuWVU/bMt6LeuC1smgFrBeRrVOFjKviayjDhPZvzR/c+WAJH9Jc+Paj9sTF8uAzZPcu6oewG+3pZn6uwFb0eyzNzP4fjs2Q+bdLWi+k6DP91VV/TLJZTTL9aW2ykSXcQR5fKqXD8bb5piWZZyn+XwnLk2LfdH2tAw0yWhrmrtkT2z/36Idt4LmlMTBbflb6N+bx38Df9fWfSoj7M0D+D3gKjpucOxR7wnADu3/e9E8vve1I15n2wGPm1lXwHPa2O7Vo/5LgP+lOa2/I82ONOobM9/Trv9lA9Qd2zoCPkpz9/I2wO/TuzePsa+T+ayXSWw38912JrWO2nlNzf7lMNTndwfgbh3D3wGfmMm/NNdo/prm0ohtgA9xy948BtpvF3kZ70pzg+UyYPN2P7oK+MN2fN/vK5ofil+j6QliL5rrraeqJ4h++WpTWL42zqHbHEtlGbuWd+r3rQUt32IHMC0DzV3f1TWs7hj/aJobPa6h6YVgZce49wDv6Xi9sq1zDU2XXo8eYZzvBU6cpXwXmlMpu7Sv/w74WZtkL6Q5Db3liNfZCuB/aE7V/KpNfo/pGP8wmtPxM68DvBX4RTu8lR69JQwZz67t53Ztuy5mhudMeh0BdwY+3U77x8CzF2OdzLVeFmO7mWvbWYx11DGvqdm/HEbyea6mozePtuzZ7T55FfAZ4M4d42bdb6dpaPedr7X7za+B7wMv6qrT7/tqK+D97Xt/BrxssZepK/a+eXypL1/Xtjlsm2NJLGPX8k79vrWQIe1CSpIkSZqn28QNiJIkSdI42JiWJEmShmRjWpIkSRqSjWlJkiRpSDamJUmSpCHZmJYkSZKGZGNaUyXJw5KcN+F5PifJF0c0rQOS/GTAuscneeN83ydJS5l5XpsaG9OaU5KLk1yTZGPH8C/jmFdVfb2q7jWOafeZ50lV9dhJzlOSpol5XhreFosdgJaMJ1fVlxcygSRbVNWNowpIDderpBExz08p1+t088i0FiTJ7km+kuTnSa5IclKS7TrGX5zkVUnOBq5KskVb9vIkZyfZkOTkJFu39W9xGqxf3Xb8K5NcluTSJC9MUkn2aMcdlOScJFcm+WmSl/dYhkOTnNHxupK8JMkPk/wyyTuTpMd7b9+exvtlknOA/bvG753ktCS/SrI2yR8MuF6PSHJBG/s5SZ7aFe+ZSf4hyS+A1Un2SPK1dh1dkeTkQeYjSXMxz5vn1Z+NaS1UgKOBHYG9gbsDq7vqPAt4IrBdxy/rZwCPB+4B3A84tM88Zq2b5PHAy4BHA3sAj+h633HAi6tqW+A+wFfmsVxPokmY+7bzf1yPeq8Fdm+HxwHPnxmRZEvgs8AXgbsCLwVOSjLI6c0LgIcBdwReB3woye90jH8wcGE73TcBb2jncydgZ+CfB1lISRqAed48rz5sTGtQn25/dc8MLwKoqh9V1Zeq6rqqWg+8nVsnu3dU1SVVdU1X2aVV9QuaRLRfn3n3qvsM4ANVtbaqrqZJRp1uAO6dZHlV/bKqvjOP5T2mqn5VVT8GvtonvmcAb6qqX1TVJcA7OsY9BFjWTuv6qvoK8DmaL52+qurj7TLfXFUnAz8EHtRR5dKq+uequrFdrzcAuwI7VtW1VXXGbNOVpD7M87Mzz6svG9Ma1FOqaruO4V8Bktw1yUfb02u/Bj4EbN/13ktmmd7lHf9fTZOMeulVd8euaXfP52DgIGBde2rsd/vMY9j4umNY1z2uqm7uGr/TXDNPckiS7818qdEccelcr93L+kqao0ffak8z/vFc85CkLub52Znn1ZeNaS3U0UAB96uq5cBzaXb2TjWmeV9Gc6prxt1vMdOq/6mqP6Q5RfZp4GNjiqFzvrt0/H8pcPckm3WN/2m/CSbZFfhX4HDgLlW1HfADbrleb7FOq+ryqnpRVe0IvBh418w1hZK0QOZ587z6sDGthdoW2Aj8KslOwCsmOO+PAS9ob/64A/CamRFJbpemX9E7VtUNwK+Bm8YUw98kuVOSnWmul5vxTeAq4JVJtkxyAPBk4KNzTHMbmiS6HiDJC2iOWPSU5I/a+QP8sn3/OJZX0m2Ped48rz5sTGtQn80t+x/9VFv+OuABwAbgVOCUSQVUVZ+nuXbtq8CPgG+0o65r/z4PuLg9LfkSmqMpo/Y6mlN6F9HcGHJiR3zXA38APAG4AngXcEhVndtvglV1DvD3NMvzM+C+wJlzxLE/8M0kG4F/A/6iqi4aZoEk3WaZ52dnnldfqRrXmRlpspLsTXOabCv745SkTY95XtPII9Na0pI8tT3VdyfgLcBnTbCStOkwz2va2ZjWUvdimmvOLqC5duxPFzccSdKImec11bzMQ5IkSRqSR6YlSZKkIdmYliRJkoZkY1qSJEkako1pSZIkaUg2piVJkqQh2ZiWJEmShvT/AzGHeIy+j/EoAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "# Bernuilli distribution with parameter p\n",
    "p = 0.49;\n",
    "\n",
    "# Number of hands\n",
    "Nh = [11,10001]\n",
    "\n",
    "# Number of trials\n",
    "N = 100; # Set to 2000 here for speed, used 8000 for the lecture notes\n",
    "fig = plt.figure(figsize=(12,5))\n",
    "plt.rc('font', **font)\n",
    "fig.subplots_adjust(hspace=0.3,wspace=0.3)\n",
    "\n",
    "\n",
    "# Means and Variances\n",
    "mymean = np.zeros(np.size(Nh))\n",
    "myvar = np.zeros(np.size(Nh))\n",
    "myPloss = np.zeros(np.size(Nh))\n",
    "\n",
    "\n",
    "\n",
    "for k in range(np.size(Nh)):\n",
    "    # Generate and show some data\n",
    "    x = stats.bernoulli.rvs(p, size=[N,Nh[k]])*2 - 1 # Outcome in dollars of each individual hand\n",
    "    y = np.sum(x,axis=1) # Outcome in dollars after Nh hands\n",
    "    plt.subplot(1,2,k+1)\n",
    "    plt.title('Histogram: Outcome of of ' + str(Nh[k]) + ' hands')\n",
    "    _ = plt.hist(y)#, bins=np.arange(-np.sqrt(Nh[k]),+np.sqrt(Nh[k]),np.sqrt(Nh[k])/50))\n",
    "    plt.xlabel('Earnings in dollars')\n",
    "    plt.ylabel('Number of occurences');\n",
    "    mymean[k] = np.mean(y)\n",
    "    myvar[k] = np.var(y)\n",
    "    myPloss[k] = np.sum(y<0)/N\n",
    "\n",
    "    \n",
    "print('Numbers of hands:')    \n",
    "print(Nh)\n",
    "\n",
    "print('Mean earnings:')    \n",
    "print(mymean)\n",
    "\n",
    "print('Variance of earnings:')    \n",
    "print(myvar)\n",
    "\n",
    "print('P(losing money):')    \n",
    "print(myPloss)\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Particle dynamics\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let us define a function that can tell whether a point is inside the convex hull of a set of points\n",
    "# https://stackoverflow.com/questions/16750618/whats-an-efficient-way-to-find-if-a-point-lies-in-the-convex-hull-of-a-point-cl\n",
    "\n",
    "import numpy as np\n",
    "from scipy.optimize import linprog\n",
    "\n",
    "def in_hull(points, x):\n",
    "    n_points = len(points)\n",
    "    n_dim = len(x)\n",
    "    c = np.zeros(n_points)\n",
    "    A = np.r_[points.T,np.ones((1,n_points))]\n",
    "    b = np.r_[x, np.ones(1)]\n",
    "    lp = linprog(c, A_eq=A, b_eq=b)\n",
    "    return lp.success\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Heterogeneous tissue model')"
      ]
     },
     "execution_count": 68,
     "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": [
    "# Let us create a simple heterogeneous tissue model with three different regions\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from scipy.spatial import ConvexHull\n",
    "\n",
    "tolerance = 0.0000001\n",
    "\n",
    "x = np.linspace(0,30,201)\n",
    "Y,X = np.meshgrid(x,x)\n",
    "\n",
    "points1 = np.array([(10,5), (15, 10), (20, 5), (20, 26), (15,27), (8,12)])\n",
    "hull1 = ConvexHull(points1)\n",
    "\n",
    "points2 = np.random.randn(200,2)*1.5 + 15\n",
    "hull2 = ConvexHull(points2)\n",
    "\n",
    "\n",
    "grid_points = np.zeros((201*201,2))\n",
    "\n",
    "grid_points[:,0] = X.flatten()\n",
    "grid_points[:,1] = Y.flatten()\n",
    "\n",
    "a = np.shape(grid_points)\n",
    "\n",
    "# get array of boolean values indicating in hull if True\n",
    "in_hull1 = np.all(np.add(np.dot(grid_points, hull1.equations[:,:-1].T),\n",
    "                        hull1.equations[:,-1]) <= tolerance, axis=1)\n",
    "\n",
    "myim1 = 1.0*np.reshape(in_hull1,(201,201))\n",
    "\n",
    "# get array of boolean values indicating in hull if True\n",
    "in_hull2 = np.all(np.add(np.dot(grid_points, hull2.equations[:,:-1].T),\n",
    "                        hull2.equations[:,-1]) <= tolerance, axis=1)\n",
    "\n",
    "myim2 = 1.0*np.reshape(in_hull2,(201,201))\n",
    "\n",
    "fig = plt.figure()\n",
    "plt.imshow(myim1.T + myim2.T, extent = [x[0], x[-1], x[0], x[-1]]);\n",
    "plt.title('Heterogeneous tissue model')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support. ' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option);\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width / mpl.ratio, fig.canvas.height / mpl.ratio);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"432\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support. ' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option);\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width / mpl.ratio, fig.canvas.height / mpl.ratio);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"432\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "# Simulate some particles moving in this 2D space, starting from the left\n",
    "N = 100000;\n",
    "px0 = np.zeros(N)\n",
    "py0 = 10 + 10*np.random.rand(N)\n",
    "\n",
    "# Parameters for steps along each dimension\n",
    "dxmean = 0.1\n",
    "dxstd = 0.5\n",
    "dymean = 0.0\n",
    "dystd = 0.5\n",
    "Nsteps = 181\n",
    "\n",
    "# Speed factors for motion in each of our 3 regions\n",
    "#speed_factors = [1,1,1]# Homogeneous tissue\n",
    "speed_factors = [1,0.8,0.6] # Heterogeneous tissue\n",
    "\n",
    "\n",
    "# Initialize position\n",
    "px = px0;\n",
    "py = py0;\n",
    "\n",
    "cur_points = np.zeros((N,2))\n",
    "\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.gca()\n",
    "fig.show()\n",
    "\n",
    "for k in range(Nsteps):\n",
    "    cur_points[:,0] = px\n",
    "    cur_points[:,1] = py\n",
    "    \n",
    "    # Adjust the step \n",
    "    factor = np.ones((N))*speed_factors[0]\n",
    "    in_hull1 = np.all(np.add(np.dot(cur_points, hull1.equations[:,:-1].T),\n",
    "                        hull1.equations[:,-1]) <= tolerance, axis=1)\n",
    "    in_hull2 = np.all(np.add(np.dot(cur_points, hull2.equations[:,:-1].T),\n",
    "                        hull2.equations[:,-1]) <= tolerance, axis=1)\n",
    "    factor[in_hull1] = speed_factors[1]\n",
    "    factor[in_hull2] = speed_factors[2]  \n",
    "    \n",
    "    dx = stats.norm.rvs(dxmean, dxstd, size=(N))*factor\n",
    "    dy = stats.norm.rvs(dymean, dystd, size=(N))*factor\n",
    "    \n",
    "    px = px + dx\n",
    "    py = py + dy\n",
    "\n",
    "    if (k%10) == 0:\n",
    "        # Show histogram of particle locations\n",
    "        xedges = np.linspace(0,30,31)\n",
    "        H, xedges, yedges = np.histogram2d(px, py, bins=(xedges, xedges))\n",
    "        # Histogram does not follow Cartesian convention \n",
    "        # therefore transpose H for visualization purposes.\n",
    "        H = H.T\n",
    "        plt.imshow(H, interpolation='bicubic')\n",
    "        ax.set_title(k)\n",
    "        fig.canvas.draw()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "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": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "plt.imshow(H, interpolation='bicubic');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}