hw7.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q1. Median Maintenance using a Heap\n",
    "\n",
    "\n",
    "### Part 1\n",
    "\n",
    "Implement a \"dominant heap\" class `BinaryHeap`, which can handle both the min heap and the max heap cases, by having the constructor explicitly pass the \"comparison\" operator in. Replace min and del_min by dominant and del_dominant methods. Change the classmethod to also take in the operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from operator import gt, lt\n",
    "\n",
    "class BinaryHeap:\n",
    "    \"\"\"\n",
    "    A BinaryHeap contains both max heap and min heap.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    storage : list\n",
    "        the storing list\n",
    "    upto: int\n",
    "        index of the last element in this heap\n",
    "    cmp: operator\n",
    "        the operator used to compare two elements \n",
    "        \n",
    "    Methods\n",
    "    -------\n",
    "    @classmethod\n",
    "    heapify_slow(cls, iterable, operator)\n",
    "        build the binary heap from the iterable\n",
    "        for a max heap, operator is gt\n",
    "        for a min heap, operator is lt\n",
    "        \n",
    "    dominant()\n",
    "        return the dominant(smallest/largest) element of the heap\n",
    "    \n",
    "    del_dominant()\n",
    "        remove the dominant(smallest/largest) element of the heap and return it\n",
    "              \n",
    "    Examples\n",
    "    --------\n",
    "    >>> data = list(range(10))\n",
    "    >>> my_min_heap = BinaryHeap.heapify_slow(data, lt)\n",
    "    >>> my_min_heap.dominant()\n",
    "    0\n",
    "    >>> my_min_heap.del_dominant()\n",
    "    0\n",
    "    >>> my_min_heap.dominant()\n",
    "    1\n",
    "    >>> my_min_heap.insert(0)\n",
    "    >>> my_min_heap.dominant()\n",
    "    0\n",
    "    >>> my_max_heap = BinaryHeap.heapify_slow(data, gt)\n",
    "    >>> my_max_heap.dominant()\n",
    "    9\n",
    "    >>> my_max_heap.del_dominant()\n",
    "    9\n",
    "    >>> my_max_heap.dominant()\n",
    "    8\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, operator):\n",
    "        self.storage=[None]\n",
    "        self.upto=0\n",
    "        self.cmp = operator\n",
    "        \n",
    "    @classmethod\n",
    "    def heapify_slow(cls, it, operator):\n",
    "        inst = cls(operator)\n",
    "        for i in it:\n",
    "            inst.insert(i)\n",
    "        return inst\n",
    "            \n",
    "    def insert(self, value):\n",
    "        self.storage.append(value)\n",
    "        self.upto += 1\n",
    "        self.sift_up(self.upto)\n",
    "\n",
    "    def sift_up(self, i):\n",
    "        parent = i // 2\n",
    "        if parent > 0 and self.cmp(self.storage[i], self.storage[parent]):\n",
    "            self.storage[i], self.storage[parent] = self.storage[parent], self.storage[i]\n",
    "            self.sift_up(parent)\n",
    "     \n",
    "    def _dom_child(self, i):\n",
    "        if 2*i + 1 > self.upto:\n",
    "            return 2*i\n",
    "        else:\n",
    "            if self.cmp(self.storage[2*i], self.storage[2*i+1]):\n",
    "                return 2*i\n",
    "            else:\n",
    "                return 2*i + 1\n",
    "    \n",
    "    def sift_down(self, i):\n",
    "        if 2*i <= self.upto:\n",
    "            child = self._dom_child(i)\n",
    "            if not self.cmp(self.storage[i], self.storage[child]):\n",
    "                self.storage[child], self.storage[i] = self.storage[i], self.storage[child]\n",
    "                self.sift_down(child)\n",
    "        \n",
    "    def dominant(self):\n",
    "        return self.storage[1]\n",
    "    \n",
    "    def del_dominant(self):\n",
    "        dom_val = self.storage[1]\n",
    "        self.storage[1], self.storage[self.upto] = self.storage[self.upto], self.storage[1]\n",
    "        self.storage.pop()\n",
    "        self.upto -= 1\n",
    "        self.sift_down(1)\n",
    "        return dom_val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finding tests in NoName\n",
      "Trying:\n",
      "    data = list(range(10))\n",
      "Expecting nothing\n",
      "ok\n",
      "Trying:\n",
      "    my_min_heap = BinaryHeap.heapify_slow(data, lt)\n",
      "Expecting nothing\n",
      "ok\n",
      "Trying:\n",
      "    my_min_heap.dominant()\n",
      "Expecting:\n",
      "    0\n",
      "ok\n",
      "Trying:\n",
      "    my_min_heap.del_dominant()\n",
      "Expecting:\n",
      "    0\n",
      "ok\n",
      "Trying:\n",
      "    my_min_heap.dominant()\n",
      "Expecting:\n",
      "    1\n",
      "ok\n",
      "Trying:\n",
      "    my_min_heap.insert(0)\n",
      "Expecting nothing\n",
      "ok\n",
      "Trying:\n",
      "    my_min_heap.dominant()\n",
      "Expecting:\n",
      "    0\n",
      "ok\n",
      "Trying:\n",
      "    my_max_heap = BinaryHeap.heapify_slow(data, gt)\n",
      "Expecting nothing\n",
      "ok\n",
      "Trying:\n",
      "    my_max_heap.dominant()\n",
      "Expecting:\n",
      "    9\n",
      "ok\n",
      "Trying:\n",
      "    my_max_heap.del_dominant()\n",
      "Expecting:\n",
      "    9\n",
      "ok\n",
      "Trying:\n",
      "    my_max_heap.dominant()\n",
      "Expecting:\n",
      "    8\n",
      "ok\n"
     ]
    }
   ],
   "source": [
    "#test part\n",
    "from doctest import run_docstring_examples as dtest\n",
    "dtest(BinaryHeap, globals(), verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data = [1,8,5,9,23,2,45,6,7,99,-5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[None, -5, 1, 2, 7, 6, 5, 45, 9, 8, 99, 23]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-5"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from operator import gt, lt\n",
    "bh = BinaryHeap.heapify_slow(data, lt)\n",
    "print(bh.storage)\n",
    "bh.dominant()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[None, 99, 45, 23, 7, 9, 2, 5, 1, 6, 8, -5]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "99"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bh = BinaryHeap.heapify_slow(data, gt)\n",
    "print(bh.storage)\n",
    "bh.dominant()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Median maintenance is a very cool algorithm to find an online median.\n",
    "We create two arrays to test our implementation, using np.median to test our answer..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "150 441.0\n",
      "151 446.0\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "l = [random.randint(1,1000) for _ in range(150)]\n",
    "print(len(l), np.median(l))\n",
    "l2 = l + [random.randint(1,1000)]\n",
    "print(len(l2), np.median(l2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will implement def online_median(iterator) which is a generator yielding successive values of your online median.\n",
    "\n",
    "The algorithm is as follows:\n",
    "\n",
    "We'll use 2 heaps, a max heap for the lower half of the data, and a min-heap for the upper half. We take the first 2values in our data and assign the smaller value to the max heap, while the larger value goes to the min-heap. Then, as we \"insert\" subsequent values in one of the two heaps, the following holds: if we keep the number of elements in both heaps equal (for the even case) or at-most differing by one, the median is respectively the average of the two dominants or the dominant in the heap with one extra item.\n",
    "\n",
    "What then is our strategy for this balanced insertion? Quite simple really: if a new value is not as dominant as the dominant value, add it to that heap. If it is more dominant, add it to the other. If two items in a row get added to the same heap, the heaps will be out of balance by more than one. In this case, take the dominant element from the larger heap and simply add it to the smaller one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#your code here\n",
    "def online_median(iterator):\n",
    "    \"\"\"\n",
    "    The online_demian algorithm to find an online median\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    iterator : iterator\n",
    "        an iterator of a sequence input\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    a generator that generates median for the input sequence\n",
    "        \n",
    "    Examples\n",
    "    --------\n",
    "    >>> iterator = iter([])\n",
    "    >>> list(online_median(iterator))\n",
    "    []\n",
    "    >>> iterator = iter([0])\n",
    "    >>> list(online_median(iterator))\n",
    "    [0]\n",
    "    >>> iterator = iter([0,1])\n",
    "    >>> list(online_median(iterator))\n",
    "    [0, 0.5]\n",
    "    >>> iterator = iter([1,2,3,4,5,6,7,8])\n",
    "    >>> list(online_median(iterator))\n",
    "    [1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5]\n",
    "    \"\"\"\n",
    "    #for first num and second num\n",
    "    first_num = next(iterator);\n",
    "    yield first_num\n",
    "    second_num = next(iterator)\n",
    "    yield (second_num + first_num)/2.0\n",
    "    \n",
    "    #take the first 2 values in our data\n",
    "    #to assign the max heap amd min-heap\n",
    "    max_heap = BinaryHeap(gt)\n",
    "    min_heap = BinaryHeap(lt)\n",
    "    max_heap.insert(min(first_num, second_num))\n",
    "    min_heap.insert(max(first_num, second_num))\n",
    "    \n",
    "    #insert new num into heap\n",
    "    for i in iterator:\n",
    "        if i <= max_heap.dominant():\n",
    "            max_heap.insert(i)\n",
    "        else:\n",
    "            min_heap.insert(i)\n",
    "        #re-balance the heap\n",
    "        if len(max_heap.storage) + 1 < len(min_heap.storage):\n",
    "            max_heap.insert(min_heap.dominant())\n",
    "            min_heap.del_dominant()\n",
    "        elif len(min_heap.storage) + 1 < len(max_heap.storage):\n",
    "            min_heap.insert(max_heap.dominant())\n",
    "            max_heap.del_dominant()\n",
    "        #return the median num\n",
    "        if len(max_heap.storage) < len(min_heap.storage):\n",
    "            next_median = min_heap.dominant()\n",
    "        elif len(min_heap.storage) < len(max_heap.storage):\n",
    "            next_median = max_heap.dominant()\n",
    "        else:\n",
    "            next_median = (max_heap.dominant() + min_heap.dominant()) / 2.0\n",
    "        yield next_median"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finding tests in NoName\n",
      "Trying:\n",
      "    iterator = iter([])\n",
      "Expecting nothing\n",
      "ok\n",
      "Trying:\n",
      "    list(online_median(iterator))\n",
      "Expecting:\n",
      "    []\n",
      "ok\n",
      "Trying:\n",
      "    iterator = iter([0])\n",
      "Expecting nothing\n",
      "ok\n",
      "Trying:\n",
      "    list(online_median(iterator))\n",
      "Expecting:\n",
      "    [0]\n",
      "ok\n",
      "Trying:\n",
      "    iterator = iter([0,1])\n",
      "Expecting nothing\n",
      "ok\n",
      "Trying:\n",
      "    list(online_median(iterator))\n",
      "Expecting:\n",
      "    [0, 0.5]\n",
      "ok\n",
      "Trying:\n",
      "    iterator = iter([1,2,3,4,5,6,7,8])\n",
      "Expecting nothing\n",
      "ok\n",
      "Trying:\n",
      "    list(online_median(iterator))\n",
      "Expecting:\n",
      "    [1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5]\n",
      "ok\n"
     ]
    }
   ],
   "source": [
    "from doctest import run_docstring_examples as dtest\n",
    "dtest(online_median, globals(), verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do your answers match?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "441.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x10ef15a58>]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEACAYAAABfxaZOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xl8VfWZx/HPA2jdERdAwR0VcMNScddYLa0bOK2lWrUu\ndWrHUrUzUwUdK9Y6aFtntFqstdoyLlXEBdyBYqwrbiBLUCkIspi4oAgKCskzfzwnvTcxIdvdkvN9\nv168uL+Tc899cpM853d/q7k7IiKSDp2KHYCIiBSOkr6ISIoo6YuIpIiSvohIiijpi4ikiJK+iEiK\nNCvpm1lXM7vPzOaa2RwzO9DMupnZJDN708yeNLOuWeePNLN5yfmD8xe+iIi0RHNr+jcAj7l7P2A/\n4A1gBDDF3fcEpgIjAcysPzAM6AccC4wxM8t14CIi0nJNJn0z2wI43N3/DODu69x9BTAUGJucNhY4\nKXk8BLgnOW8hMA8YlOvARUSk5ZpT098F+MDM/mxmr5nZH81sE6CHu1cBuHsl0D05vxewOOv5S5Nj\nIiJSZM1J+l2ArwK/d/evAp8STTv112/Qeg4iIiWuSzPOWQIsdvdXkvL9RNKvMrMe7l5lZj2B95Kv\nLwV2yHp+7+RYHWamm4SISCu4e6v7SZus6SdNOIvNbI/k0NHAHGAicFZy7ExgQvJ4InCKmW1oZrsA\nfYCXGrl2yf+74oorih6D4lSc7TnO9hBje4qzrZpT0we4ALjLzDYAFgBnA52BcWZ2DrCIGLGDu1eY\n2TigAlgLnO+5iFRERNqsWUnf3V8HDmjgS8c0cv5oYHQb4hIRkTzQjNwmlJWVFTuEZlGcuaU4c6c9\nxAjtJ862smK1vJiZWn1ERFrIzPB8duSKiEjHoaQvIpIiSvoiIimipC8ikiJK+iIiKaKkLyKSIkr6\nIiIpoqQvIpIiSvoiIimipC8ikiJK+iIiKaKkLyKSIkr6IiIpoqQvIpIiSvoiIimipN9GVVV1y++9\nB9nbBKxYAWvWZMpr1sDHH2fK7l++hohIvijpt8Hnn8Muu0BlZebY4MEwZUqmfOGFcNNNmfLNN8NP\nf5opP/UUHNPgppMiIrmnpN8Gc+bA6tUwY0aU16yB2bPh1Vcz57z6atPligr47LPCxCwi6aak3wbT\np9f9f/ZsqK7OlFevhrlzM+Xac998M5Pkp0+HmhqYNatwcYtIeinpt8H06TBwYN3kn12ePRv69oV3\n3oFVqyLRv/029O8PM2c2/BwRkXxS0m+D6dPhnHPqJv1TToGlS2HlyigfcEAmyc+aBXvuCQceGF/7\n9FNYtAi+/30lfREpDCX9VqqujkQ+bBi8+y588kkmye+1F7z+epT33z/+TZ/+5fLMmdCvHwwapKQv\nIoWhpN9K//gHbLNN/Nt7b3jttajJDxjQeJJvrLzfftEpvG5dsb8rEenolPRbacaMSNgQif6++6BH\nD+jaNY6/+mq06e+3X5RnzMg8Z999Y8TOK69EefPNoVev6OAVEcknJf1Wqq2lQ/x/992R/GvLEyZA\nz56wxRaZJD97djzebDPYYQd48MG6z1ETj4jkm5J+K02fXjdhf/xx5iawzz7Rxl9b3nRT2HFH2H77\nuAlAPHfFivgkUFtW0heRfGtW0jezhWb2uplNN7OXkmPdzGySmb1pZk+aWdes80ea2Twzm2tmg/MV\nfLG4163p7703dOqUKW+ySYzSqS1Dpi0/u7z77lHrry23NemvXg0ffNC2a4hIx9almefVAGXu/lHW\nsRHAFHf/tZldAowERphZf2AY0A/oDUwxs93ds1ekad+WLYvE36tXlDfZBIYPh4MPzpxz7rnw9a9n\nyt/7Xoz4qXXssdC5c6Zc2+7vDmati+uPf4TnnoNx41r3fBHp+Kw5udjM3ga+5u4fZh17AzjS3avM\nrCdQ7u59zWwE4O5+bXLe48Aod59W75rt9j7wyCPwu9/BpEm5ve7228MLL8BOO7Xu+T/4QST9+fNz\nG5eIlA4zw91bWTVsfpu+A5PN7GUzOzc51sPdqwDcvRLonhzvBSzOeu7S5FiHkT1yJ5fa2sQzYwYs\nWBB9BSIiDWlu0j/U3b8KHAf8xMwOJ24E2dpntb0Vstvzc6ktSX/Nmpg7sP/+MTFMRKQhzWrTd/d3\nk//fN7OHgEFAlZn1yGreeS85fSmwQ9bTeyfHvmTUqFH/fFxWVkZZWVlL4y+K6dPh6qtzf90BA+D/\n/q91z509OzqGDzoo4jviiNzGJiLFUV5eTnl5ec6u12SbvpltAnRy91VmtikwCbgSOBpY7u7XJh25\n3dy9tiP3LuBAollnMvCljtz22qb/8cfQu3c0oWR3xObC/Plw1FGxQFtL3XorPPssHHooPP88/OUv\nuY1NREpDW9v0m1PT7wE8aGaenH+Xu08ys1eAcWZ2DrCIGLGDu1eY2TigAlgLnN8us3sjZsyICVa5\nTvgQG7KsWAEffghbb93yuGqHhY4Zk/vYRKRjaDLpu/vbwIAGji8HGtzzyd1HA6PbHF0JylcnLsRY\n/9pJWi3dTWv69Fj8bZ994K23Ylevr3wlP3GKSPulGbktlK9O3Fqt6cytrs4s9rbRRrDbbrGAm4hI\nfUr6LVSKSX/ePOjePRZ7a+01RCQdlPTXY906eO+9THnNmkiwe+2Vv9ccMCCz525jqqrgiy8y5Rkz\nMusA1V5DSV9EGqKkvx433QQnnpgpP/98rLOz0Ub5e83+/WP9nIqKhr9eXQ1lZZA12pUHH4Qjj8yU\njzwyZg2vXZu/OEWkfVLSX49x42LN+0WLojx+PHz72/l9zQ02gIsuanwewP33x9o8t9wCy5fHxuvl\n5bFtY62BA6FPH7jjjvzGKiLtT7PW3snLC5f4OP3Fi2PZ4xNPjCGaF10UC6w9+2wk1Hz65JPojH3+\n+ZhwVaumJppuRo+GBx6I+QLz58eng0svrXuNp5+GH/4Q3ngDujR3WT0RKXmFWnsndR54AIYMiU3L\nx4+HZ56B7bbLf8KHWHN/+HD47/+ue3zChPgkcNxxMHIk3HgjPPlknFvfkUfGTeqee/Ifr4i0H6rp\nN+KwwyKxDh4cyf6QQ2KJg/o16nz56KO4wbzySkzaco9mm1/8Ak46Kc4577z4RHDxxQ1fY8oU+OlP\nY4mGfEwmE5HCa2tNX0m/AUuXxiSnykrYcMNoJrn99tjDdo89ChfHf/1XjB764x/h0UfjJjRjRkzi\ngqbX3nePm9VFF8V6/iLS/ql5Jw8eeCDa8jfcMMqnnx5r2hQy4UMk6/HjYy2eq66Km0CnrJ9YU5ut\nmMHll8OvfhX9ASIiSvoNuO8+OPnkTPmoo+Dvfy98HNtsEztwnXxyrMnzne+0/BrHHhvLMUyYkPv4\nRKT9UfNOPe++G6NhKitLY+2aqqpo07/1VjjttNZdY8KEaBqaNClG/IhI+6XmnRx74AE44YTSSPgA\nPXrEujqnntr6a9SOQho4MMb5i0h6qaZfT1kZ/OxnMHRosSPJvWnT4tNCWRlcfz1stlmxIxKRltLo\nnRyqrIR+/aKJJ59LLRTTypVw4YUxeev00+Eb34ADD4zx/yIdzZIlMXR56lTYdNNYsvzrX4du3Yod\nWesp6efQH/4Qk7DuuqvYkeTfM8/E+jxTpsTeukccEZuv7JBsdDllSqzaecABxY1TGuYON9wQczU2\n3rjY0RTXJ5/AlVfGrna11q6Fl1+G99+PJH/MMbBqFUyeDM89B337xjpa2SPg+vSJOS+dO8f6Vzfe\nCP/5n7D55s2LY8KEWKSxNQMuWkJJP4fOOy+WXjj//GJHUlgffACXXRZDVG+8MYZ37rkn9OwZNwcp\nPc88EzfqP/0p5pGk1bJlMUN9//1jQmUts1iyZMCAusOcITYYeuGFWMIk2913R0XnqqvgX/4Fttoq\nVrN99NGYoLk+118Pv/1t3DB+8hP4+c+bHlLdWm1N+rh7Uf7FS5eWY45xf+KJYkdRHEuWuHfr5v7x\nx+6PPOK+//7uvXu7v/pqsSOThnznO+5Dh7rvs497TU2xoymOigr3nXZyv/rq3LwHn3/uftpp7l26\nuI8ZE9f81a/cd97Zfe7cOGfVKvcf/ch98uQoV1e7//u/u/fr575wofvixfEzGTWq7fE0Jsmdrc69\nquln2XXXWMsme5GzNDn1VBg0CB5/HM44I2Ymv/GGNlkvNe+8EzXbt9+O/pibb47O+TR57rlY8fbX\nv4Yzz8zddWtq4n3dbbfMsb/8BUaMiJnxV18dtf4XXoiFDydNir+TCRPikwHEnJrKyvi0nA+q6efI\nF1+4b7hh3O3T6oUX3Lfd1r1nT/c1a9w/+MB9yy3dKyuLHZlku/hi95/9LB6PGeN+0knFjactqqvd\nTznF/cEHm/+cl16K39Mnn8xfXPU9/rj7Zpu5X3ZZfAKYPdt9hx3iE9fq1YWLw73tNX0l/cT8+fFR\nMc1qatwHDar70fTcc92vvLJ4MUldq1a5b7NN/L66u69c6b7VVu4LFmTOue4692efzZQfesh97NhM\necaMuj/TDz5wP++8SMCNufLKeF6uXXed+157uXfvHk2MTVm1yn333d3Hjct9LE2pn9xXry5O05qS\nfo5Mnux+1FHFjqL4li93X7s2U54503277dL9CaiU3HKL+5AhdY/9x39Eu7K7+4cfum+8sfvRR0e5\nutp9zz3r/gy/+133zp3dFy2K8tVXRyZ49NGGX3PhQvdOndyHDcvt9/L663EDW7DA/Ze/jD619d14\n3OPm9IMf5DaO9qatSV8zchPz50ebftp161Z305V99om5C/fdV7yYJLjD734X8yyyDR8e7c6rVsVo\nnqFDYc6c+Dd5cswu79s3ZmMvXhzDcc88E37/+xjaOGZMLO73u981/Lq//z2cfXZca8mS1sW+ZAkc\nfDAsXBjlNWtiouBvfxvLjIwcCZ9+2ngMAA8/HH1uN97YuhgkqCM3ccklsOWW8csndU2cGCt1TpuW\nv2Fo0rQpU2K2+MyZX/45fPvb0Zl73XWxZ/LDD8dwxsWLY8G+rbeOjsejjoLPPosbx4EHRkfo2LHw\nxBOw886x9Wbfvpnrfvop7LQTvPRSZhZ3/c19mlJTE/tSrFgRkx7Ly2NI4+LFsSVp7fcyf37sWTF1\nalQ2slVVxfDLcePg8MNb9vodjTpyc+Tkk93vuafYUZSmdevcd901OnqleE44wf3WWxv+Wnl5NOsc\ndliUKyvdt9gi2spXr46f4S67uG+6qfu8eXHOkCHxnAceiPLll7v/27/Vve7NN8fQUHf3t96KDtTP\nPmtZ3P/zP+6HHBKDJY46Kjo/e/WKvoT6br89hjxmt5/X1Lgff7z7pZe27HU7KtSmnxv77x+jAqRh\n119fd5TICy+477df3Q7D9Zk/3/0b33D/13+Nzkdpvpoa9xtvdO/Ro/GEW1PjfvDB7hMmZI796Efu\nV12VKY8ZE5WbWk8/7b733nFDcHdftiw6hf/61yg/95z79tvHDaXWkCHuZ5wRP8Ply92//333E0+M\nTtjPP3e/5JKIY/r0iOmWW+p2PL/zTowOmzSp8e/jO9+JG9z777t/+mm04w8cqH6lWkr6OVBTE7Wi\nhmoeEj77zH3HHd3//vfobBs0KGqFPXq4/+IXmc7ftWvdx4+PSV7u8d6OHRt/+L/9rfvZZ7v36VP3\nBjtvnvtTT2XK778fQ/ia6tRLg8pK9+OOcz/ggKhpr0/996u6+sujSxo6J9srr7jvsYf7EUfEz/ah\nh+p+/ZNP3M88M0bQ7LCD+wUXxMie7t2jEnDiie5/+EP8vA891H3AgJhEtb7XrG/Nmuic3n579759\n3U891f2jj9b/nDRR0s+BDz9079o1vTMbm+vuu92/9jX3O++Mmld1ddQOBw92P+gg97/9LWp5ffvG\nLMbHHnP/3vdiSN7rr2euM25cJImrr87UBHfayf2HP4yaaq9ekXiOPrp5w/g6qkceiVrxZZdF00ih\nrFoVnyyWLWv8nIkT3adMyZRffDE+IdT+DS1YEE1Da9a0Po6nnmrZ+P20UNLPgZdfjuYdWb+aGvcD\nD4x24Kefzhyvro7mn223jfbb6uqoIfbq5T58eMNNEu+8E0l94ED3OXOiBnnWWXGzmDw5PjH88pcx\n1HDOnMJ9j6Xiuuvik1X2+yzi3vak3+zRO2bWCXgFWOLuQ8ysG3AvsBOwEBjm7iuSc0cC5wDrgAvd\nfVID1/Pmvna+3XtvDEkcP77YkZS+V1+N92n06MK83h13wKWXxnaVu+xSmNcstltvjREyzzyjnc7k\nywq5c9aFQEVWeQQwxd33BKYCI5OA+gPDgH7AscAYs9Ie6LdgQd21NqRxAwcWLuFDrAF0ySWx7v+7\n78axL76ACy6IGxDE+PXRo2OoYnt3770wapS2tpT8aVbSN7PewHHAn7IODwXGJo/HAiclj4cA97j7\nOndfCMwDBuUk2jxZsEATs0rZ8OExOWjw4Fgf/YwzYs7A8cdDRUXUiu+4A378Y3jssWJH23qPPRY3\ns8cfT++if5J/XZo+BYD/BX4OdM061sPdqwDcvdLMuifHewEvZJ23NDlWsubPh2HDih2FrM+ll8Ym\nGXvsEStMPv10TNQ57LBY3fCZZ2DRIjjxxJiYdNBBxY64ZaZNg7POiolw++5b7GikI2sy6ZvZ8UCV\nu88ws7L1nNriBvpRo0b983FZWRllRVofVjX90mcWs0f33jtmn260EfzgBzGLer/9Yrnb7baDX/4y\ndpRqb0n/+uujWae9xS35V15eTnl5ec6u12RHrpn9N3A60Sm7MbA58CDwNaDM3avMrCfwlLv3M7MR\nRO/ytcnznwCucPdp9a5bEh25X3wR26GtWqV9YjuCZcvixlBV1X5+nmvXQo8eMHs2bL99saORUpf3\njlx3v9Tdd3T3XYFTgKnufgbwMHBWctqZwITk8UTgFDPb0Mx2AfoAL7U2wHx75x3o1av9JAhZv+23\nj09tzz9f7Eia7/nnI2YlfCmEtqyyeQ3wDTN7Ezg6KePuFcA4YqTPY8D5JVGlb4RW1+x4jj8+Nn1v\nLx59NGIWKYTUr7J5880wYwbcckuxI5FcefnlWDq4oqLpc0tB//6x0uUBBxQ7EmkPCjlOv0NSJ27H\nM3AgLF8en+JK3fz5EevAgcWORNIi9UlfzTsdT6dO0Vzy6KOZY6tXx5rwpaa2aadT6v8SpVBS/6um\nmn7HdMIJddv177oLhgyJDT1KyaOPRqwihZLqNn136No1RvBsuWVRQ5EcW7kyRsMsWxZDck86KSY+\nTZtWOm3nK1fGyLGlSyNGkeZQm34bfPhh7AerhN/xbL557Mk6eXLsx/rUUzHjtZRG9UyZEpOxlPCl\nkFKd9NWe37GdcEI0nzz9dOy5euaZpZX01bQjxZDqpK/VNTu22s7chx+O5HrIIfD229HkU2w1NRqf\nL8WR+qSvmn7HtdtusRjb7bdH0t9gA/jmN0tjJc7XXoNu3VTpkMJLddJX807Hd/zxsO22sNdemfLE\niZmvu8cGLbkc1fPBB9GM9PHHUf7ss6jVL10a5XXrYilo1fKlGFKb9D/8MP4QDzus2JFIPv34x3Dd\ndbFKJ0SNf8aM2KwEYnXLsjL4xS/Wf52FC+Gaa+LfwoVf/vpnn8E998TSzrvtFiuC7rQTHHVUjCIa\nPToWgjvssNgc5cUX4dxzc/iNijRTc9fT73Auvxy++13o16/YkUg+7bZb3SaULbeMNv5jjoE5c+C2\n22LZhmHD4lPfOefUff4nn0RyfuopOPnkuHkccEDcKG67DbbYIrY3vPhiOPBAOO00uPvuGJHz0UfR\niXzQQdCzZ4wi+tvfYk8AbZIixZLKcfrTp8Oxx8baLFttVZQQpMieeAJOPx2efDKWQHjzTTjiCLjz\nztiaEeLYSSdFgr/+evjKV+L455/DRRdBeXkk+pdeiq0a99yzWN+NpElbx+mnLum7w+GHx5htfbxO\nt5qaussf/P3vUZufOjWacM45J7ZibOz35Lbb4NlnY9OWLbYoSMgiSvotdeed8Uc6bZrWO5Evu/vu\n2Kd2o41g/HjtZCWlR0m/BT75JNrwH3ggPpaLNGTixGi33267Ykci8mVK+k2oqYn2127dYN68qMHd\nfnveX1ZEJC+09k4TXn01RmvU1ERH3DXXFDsiEZHi6fA1/csug+pqJXsR6RhU02/CQw/FsDsREeng\nSf+tt2IrukGDih2JiEhp6NBJf8IEGDpUQzNFRGp16HSoph0Rkbo6bEduRUXMvF22LDN9XkSkvVNH\nbgNqauC88+Cqq5TwRUSydcikf/vtsHZtJH4REclo9807s2fD66/HkrYAVVWxH+rkybDffm2+vIhI\nSUn1Mgzr1sHXvhbLK7z8MvTvH8vlbrcd/OY3OQpURKSEtDXpt+tNVG64IbbC++EPoynn8stjqds5\nc4odmYhIaWqyTd/MvmJm08xsupnNMrMrkuPdzGySmb1pZk+aWdes54w0s3lmNtfMBrcmsAUL6u5b\n+u678OmnmfKiRbEF3c03w/nnx8YW3/423HQTbLppa15RRKTjazLpu/vnwFHuvj8wADjWzAYBI4Ap\n7r4nMBUYCWBm/YFhQD/gWGCMmbX4o8jgwfDMM5ny8OHwpz9lymPHwhlnQJ8+0LlzdN7+/OexB6qI\niDSsWaN33P2z5OFXiCYhB4YCY5PjY4HaaVBDgHvcfZ27LwTmAS1aCGHlSpg/Pzpoa73+OsycmSnP\nnFl3Tfy994YrrmjJq4iIpE+zkr6ZdTKz6UAlMNndXwZ6uHsVgLtXAt2T03sBi7OevjQ51myzZ8f/\ntUl+1aq4CdRP+vvu25KriohIszpy3b0G2N/MtgAeNLO9iNp+ndNa+uKjRo365+OysjLKysoAmDUL\n9tgjk+TnzIHdd49ZttXVsGYNLFkS54iIdGTl5eWUl5fn7HotHrJpZpcDnwHnAmXuXmVmPYGn3L2f\nmY0A3N2vTc5/ArjC3afVu06jQzaHD49ROb/5DaxYEe31zz8PTz8NTzwRx370I5g+veXfsIhIe5b3\nZRjMbJvakTlmtjHwDWAuMBE4KzntTGBC8ngicIqZbWhmuwB9gJdaEtTMmbFuzrbbxiieWbNiwtW+\n+8bX1LQjItI6zWne2Q4Ya2adiJvEve7+mJm9CIwzs3OARcSIHdy9wszGARXAWuD8lszCco+kvs8+\n8a82yQ8ZAh99FI9XrFDSFxFpjSaTvrvPAr7awPHlwDGNPGc0MLo1AS1ZAhtvHLX8+jX7jz6Cu+6K\npH/88a25uohIupXcgmvZTTf77htt+BtsAN27Z24Cs2appi8i0holmfT32Sce77svvPRSJsH36QOV\nlbETVo8exYtRRKS9Krm1d2bOhGOPjcd9+sR6+LU3gc6dY1G1rl2h5XN8RUSk5Gr62U03XbrAXnvV\nbcrZd1817YiItFZJLa38+eew5Zbw8ceZHa+eey4S/5ZbRvmNN6KNf7fdChywiEgJ6FBLK8+dC7vu\nWneLw0MPrXtO376FjUlEpCMpqeYdjcoREcmvkkr6mmkrIpJfJZf0a0fqiIhI7pVc0ldNX0Qkf0om\n6b//PqxeDTvsUOxIREQ6rpJJ+rUraWrSlYhI/pRM0lfTjohI/inpi4ikSMkkfY3RFxHJv5JYhqG6\nGrbYIlbQ3HzzooQjItIu5H27xEJYuBC23loJX0Qk30oi6c+dG0smi4hIfpVM0u/Xr9hRiIh0fEr6\nIiIpoqQvIpIiRR+94w7dusE//gHbbFOUUERE2o12P3qnsjJ2wlLCFxHJv6InfY3cEREpnJJI+mrP\nFxEpjKIn/YoKJX0RkUIpetJXTV9EpHCU9EVEUqTJpG9mvc1sqpnNMbNZZnZBcrybmU0yszfN7Ekz\n65r1nJFmNs/M5prZ4Mau/cknsHIl9O6dm29GRETWrzk1/XXAv7v7XsDBwE/MrC8wApji7nsCU4GR\nAGbWHxgG9AOOBcaYNbwf1vLlMVRTu2WJiBRGk0nf3SvdfUbyeBUwF+gNDAXGJqeNBU5KHg8B7nH3\nde6+EJgHDGro2itXwmabtSl+ERFpgRa16ZvZzsAA4EWgh7tXQdwYgO7Jab2AxVlPW5oc+5JVq7Sc\nsohIIXVp7olmthkwHrjQ3VeZWf31G1q8nsOYMaOoqoJRo6CsrIyysrKWXkJEpEMrLy+nvLw8Z9dr\n1to7ZtYFeAR43N1vSI7NBcrcvcrMegJPuXs/MxsBuLtfm5z3BHCFu0+rd02//37njjvgwQdz9v2I\niHRohVp753agojbhJyYCZyWPzwQmZB0/xcw2NLNdgD7ASw1dVM07IiKF1WTzjpkdCpwGzDKz6UQz\nzqXAtcA4MzsHWESM2MHdK8xsHFABrAXO90Y+TqgjV0SksJpM+u7+HNC5kS8f08hzRgOjm7q2avoi\nIoVV1Bm5q1appi8iUkhFTfpq3hERKayi1/TVvCMiUjiq6YuIpIhq+iIiKaKavohIihS9pq+kLyJS\nOEVP+mreEREpHDXviIikiGr6IiIp0qxVNvPywmZu5qxdC50bW+RBRETqKNQqm3mx8cZK+CIihVTU\npK+mHRGRwipq0lcnrohIYammLyKSIqrpi4ikiJK+iEiKqHlHRCRFVNMXEUkR1fRFRFJENX0RkRRR\n0hcRSRE174iIpIhq+iIiKaKavohIiqimLyKSIkr6IiIpouYdEZEUaTLpm9ltZlZlZjOzjnUzs0lm\n9qaZPWlmXbO+NtLM5pnZXDMbvL5rq6YvIlJYzanp/xn4Zr1jI4Ap7r4nMBUYCWBm/YFhQD/gWGCM\nmTW6rZdq+iIihdVk0nf3Z4GP6h0eCoxNHo8FTkoeDwHucfd17r4QmAcMauzaqumLiBRWa9v0u7t7\nFYC7VwLdk+O9gMVZ5y1NjjVoo41a+eoiItIquerI9dY8qfGGHxERyYcurXxelZn1cPcqM+sJvJcc\nXwrskHVe7+RYg0aNGvXPx2VlZZSVlbUyHBGRjqm8vJzy8vKcXc/cm66km9nOwMPuvk9SvhZY7u7X\nmtklQDd3H5F05N4FHEg060wGdvcGXsTMGjosIiLrYWa4e6vbSZqs6ZvZ3UAZsLWZvQNcAVwD3Gdm\n5wCLiBGpeEMjAAAF6klEQVQ7uHuFmY0DKoC1wPnK7CIipaNZNf28vLBq+iIiLdbWmn5RZ+SKiEhh\nKemLiKSIkr6ISIoo6YuIpIiSvohIiijpi4ikiJK+iEiKKOmLiKSIkr6ISIoo6YuIpIiSvohIiijp\ni4ikiJK+iEiKKOmLiKSIkr6ISIoo6YuIpIiSvohIiijpi4ikiJK+iEiKKOmLiKSIkr6ISIoo6YuI\npIiSvohIiijpi4ikiJK+iEiKKOmLiKSIkr6ISIoo6YuIpEjekr6ZfcvM3jCzt8zskny9joiINF9e\nkr6ZdQJuAr4J7AWcamZ98/Fa+VZeXl7sEJpFceaW4syd9hAjtJ842ypfNf1BwDx3X+Tua4F7gKF5\neq28ai+/CIoztxRn7rSHGKH9xNlW+Ur6vYDFWeUlyTERESkideSKiKSIuXvuL2p2EDDK3b+VlEcA\n7u7XZp2T+xcWEUkBd7fWPjdfSb8z8CZwNPAu8BJwqrvPzfmLiYhIs3XJx0XdvdrMhgOTiCak25Tw\nRUSKLy81fRERKU1F6cgt1YlbZtbbzKaa2Rwzm2VmFyTHu5nZJDN708yeNLOuJRBrJzN7zcwmlnCM\nXc3sPjObm7ynB5ZonD8zs9lmNtPM7jKzDUshTjO7zcyqzGxm1rFG4zKzkWY2L3m/Bxc5zl8nccww\ns/vNbItSjDPra/9hZjVmtlWpxmlmP01imWVm17Q6Tncv6D/iRvMPYCdgA2AG0LfQcTQSW09gQPJ4\nM6Jfoi9wLXBxcvwS4JoSiPVnwJ3AxKRcijH+BTg7edwF6FpqcQLbAwuADZPyvcCZpRAncBgwAJiZ\ndazBuID+wPTkfd45+RuzIsZ5DNApeXwNMLoU40yO9waeAN4GtkqO9SulOIEyorm8S1LeprVxFqOm\nX7ITt9y90t1nJI9XAXOJX4ihwNjktLHAScWJMJhZb+A44E9Zh0stxi2Aw939zwDuvs7dV1BicSY6\nA5uaWRdgY2ApJRCnuz8LfFTvcGNxDQHuSd7nhcA84m+tKHG6+xR3r0mKLxJ/RyUXZ+J/gZ/XOzaU\n0orz34gb/LrknA9aG2cxkn67mLhlZjsTd9sXgR7uXgVxYwC6Fy8yIPNLmt0hU2ox7gJ8YGZ/Tpqh\n/mhmm1Bicbr7MuA64B0i2a9w9ymUWJxZujcSV/2/q6WUzt/VOcBjyeOSitPMhgCL3X1WvS+VVJzA\nHsARZvaimT1lZgOT4y2OU5OzGmBmmwHjgQuTGn/93u6i9X6b2fFAVfKJZH1jdYvdQ98F+Crwe3f/\nKvApMIISei8BzGxLora0E9HUs6mZndZAXMV+PxtTqnEBYGaXAWvd/a/FjqU+M9sYuBS4otixNEMX\noJu7HwRcDNzX2gsVI+kvBXbMKvdOjpWE5CP+eOAOd5+QHK4ysx7J13sC7xUrPuBQYIiZLQD+Cnzd\nzO4AKksoRohPcIvd/ZWkfD9xEyil9xKi7XmBuy9392rgQeAQSi/OWo3FtRTYIeu8ov9dmdlZRDPk\n97MOl1KcuxHt4K+b2dtJLK+ZWXdKL08tBh4AcPeXgWoz25pWxFmMpP8y0MfMdjKzDYFTgIlFiKMx\ntwMV7n5D1rGJwFnJ4zOBCfWfVCjufqm77+juuxLv3VR3PwN4mBKJESBpglhsZnskh44G5lBC72Xi\nHeAgM9vIzIyIs4LSidOo+4musbgmAqckI492AfoQkyILpU6cZvYtoglyiLt/nnVeycTp7rPdvae7\n7+ruuxAVlf3d/b0kzu+VQpyJh4CvAyR/Uxu6+4etirMQvdEN9E5/ixgZMw8YUYwYGonrUKCaGFE0\nHXgtiXUrYEoS8yRgy2LHmsR7JJnROyUXI7AfcZOfQdRSupZonFcQnfYzic7RDUohTuBuYBnwOXFz\nOhvo1lhcwEhi9MZcYHCR45wHLEr+hl4DxpRinPW+voBk9E6pxUk079wBzAJeAY5sbZyanCUikiLq\nyBURSRElfRGRFFHSFxFJESV9EZEUUdIXEUkRJX0RkRRR0hcRSRElfRGRFPl/VPzq7+a5x6IAAAAA\nSUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10bec4ac8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "medians = list(online_median(iter(l)))\n",
    "print(medians[-1])\n",
    "plt.plot(medians)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "446"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(online_median(iter(l2)))[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, lets repeat the analysis we did last time on the randomly generated data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from random import normalvariate, random\n",
    "from itertools import count\n",
    "def make_data(m, stop=None):\n",
    "    for _ in count():\n",
    "        if stop and _ > stop:\n",
    "            break\n",
    "        yield 1.0e09 + normalvariate(0, m*random() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[999999999.9400473,\n",
       " 999999999.9388748,\n",
       " 999999999.9254589,\n",
       " 999999999.9388748,\n",
       " 999999999.9400473,\n",
       " 999999999.9412198,\n",
       " 999999999.9446139,\n",
       " 999999999.948008,\n",
       " 999999999.9543717,\n",
       " 999999999.948008]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = online_median(make_data(5, 100))\n",
    "print(type(g))\n",
    "out = list(g)\n",
    "out[-10:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x10f40b9e8>]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAEGCAYAAABrQF4qAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10eed7f60>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q2\n",
    "\n",
    "### Simulating a flight check-in counter\n",
    "\n",
    "It is your job to simulate a flight-checkin counter. There are m agents handling n passengers. The passengers arrive in line with in-between time given by an exponential distribution for INTER_ARRIVAL_TIME. Each passenger, once he or she gets to a counter, is processed in a time drawn from an exponential distribution with PROCESSING_TIME. \n",
    "\n",
    "Clearly, in the usual case of 3-4 agents and 200+ customers on a flight, the customer waits much longer. We have been hired by the airlines customer-relations group to see how many extra agents must we hire to reduce waiting times by how much.\n",
    "\n",
    "We start by representing each customer by a co-routine, which starts with the `inline` event. The state changes to the `atcounter` event, and then `ptime` seconds later, to the `leaves` event. Notice how this customer \"process\" is stopped at the yield, until the customer can be handled."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import collections, random\n",
    "Event = collections.namedtuple('Event', 'time cid action agent')\n",
    "def customer_process(idee, start, ptime):\n",
    "    t, agent = yield Event(start, idee, \"inline\", None)\n",
    "    t, agent = yield Event(t, idee, \"atcounter\", agent)\n",
    "    yield Event(t+ptime, idee, \"leaves\", agent)            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following function simply implements the draw from the exponential distribution for a given customer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def duration(arr_time, service_time):\n",
    "    return random.expovariate(1./arr_time), random.expovariate(1./service_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is out main simulation class. you will be filling in parts of this class.\n",
    "\n",
    "The constructor sets up the simulation. Three queues are created, one for agents that become free, one priority queue for events so that they can be processed in the order recieved, and a backlog for queue for those customers waiting in line because no agent was available.\n",
    "\n",
    "We set up all the customers in the constructor, with two dictionaries, one to hold the co-routines, and one to hold time metadata which we shall use to figure the average waiting time.\n",
    "\n",
    "The `run` method is where all the action happens and is the one you will edit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import queue\n",
    "import logging\n",
    "\n",
    "logger = logging.getLogger()\n",
    "logger.addHandler(logging.StreamHandler())\n",
    "\n",
    "class Simulator:\n",
    "    def __init__(self, n_agents, n_customers, INTER_ARRIVAL_TIME =1., PROCESSING_TIME=3., DEBUG=False ): \n",
    "        #queues\n",
    "        self.free_agents = queue.Queue()\n",
    "        self.backlog = queue.Queue()\n",
    "        self.events=queue.PriorityQueue()\n",
    "        #save the arguments\n",
    "        self.n_customers = n_customers\n",
    "        self.n_agents = n_agents\n",
    "        self.intertime=INTER_ARRIVAL_TIME\n",
    "        self.proctime=PROCESSING_TIME\n",
    "        #dictionaries to hold customer process\n",
    "        self.customers={}\n",
    "        self.customer_meta={}\n",
    "        self.logger = logging.getLogger(\"sim\")\n",
    "        if DEBUG:\n",
    "            self.logger.setLevel(logging.DEBUG)\n",
    "        else:\n",
    "            self.logger.setLevel(logging.WARNING)\n",
    "        #on the free_agents queue, we put all the agents, and thee time\n",
    "        #they got free\n",
    "        for i in range(n_agents):\n",
    "            self.free_agents.put((i,0))\n",
    "        #this tracks when each customer came in.          \n",
    "        time_when_came=0.\n",
    "        for j in range(n_customers):\n",
    "            interarrtime, proctime = duration(self.intertime, self.proctime)\n",
    "            time_when_came += interarrtime\n",
    "            intuple = (j, time_when_came, proctime)\n",
    "            c = customer_process(*intuple)\n",
    "            self.logger.debug(\"Customer {}, arrived {}, will take {} at counter\".format(*intuple))\n",
    "            #add each customer to dictionaries\n",
    "            self.customers[j]=c\n",
    "            self.customer_meta[j]={'cid':j, 'start':time_when_came, 'finish':None}\n",
    "        self.logger.debug(\"========ending init==============\\n\\n\")\n",
    "        self.max_time_when_came=time_when_came  \n",
    "\n",
    "    def run(self, end_time):\n",
    "        #we prime each customer co-routine at the start\n",
    "        #and put that event in the events priority queue\n",
    "        #Since an event is a tuple, the ordering will be by start time\n",
    "        for cid, proc in sorted(self.customers.items()):\n",
    "            first_event = next(proc)#prime\n",
    "            self.events.put(first_event)#customer in line\n",
    "\n",
    "        #start at time 0\n",
    "        sim_time = 0\n",
    "        while sim_time < end_time:\n",
    "            #we are done if no events and no backlog\n",
    "            if self.events.empty() and self.backlog.empty(): \n",
    "                self.logger.debug('*** end of events and backlog***') \n",
    "                break\n",
    "            #if we have agents available and a backlog\n",
    "            #take customer from backlog queue. This is equivalent\n",
    "            #to taking customers from line\n",
    "            if not self.backlog.empty() and not self.free_agents.empty():\n",
    "                current_event = self.backlog.get() #get event from backlog\n",
    "                #the sim time from this branch will be false\n",
    "                #as we get the old time the person in the line showed up\n",
    "            else: #get current event in all other cases\n",
    "                #his ensures that leave events are processed thus\n",
    "                #freeing up agents\n",
    "                current_event = self.events.get() #get event from events\n",
    "            \n",
    "            sim_time, cid, action, agent = current_event\n",
    "            #get the current customer process\n",
    "            cproc = self.customers[cid]\n",
    "                \n",
    "            if action=='leaves':\n",
    "                self.logger.debug(\">>>Customer {} leaves, agent {} free at {}\".format(cid, agent, sim_time))\n",
    "                #an agent gets free. Put the time they got free on q\n",
    "                #also update the metadata\n",
    "                self.free_agents.put((agent, sim_time))\n",
    "                self.customer_meta[cid]['finish']=sim_time\n",
    "                continue #this \"contine\" helps to skip meaningless process\n",
    "            elif action=='atcounter':\n",
    "                self.logger.debug(\"Customer {} atcounter Agent {} at {}\".format(cid, agent, sim_time))\n",
    "                next_time = sim_time#processing time already in coroutine\n",
    "            elif action=='inline':#the agent is None to start\n",
    "                self.logger.debug('----------------------------------------------')\n",
    "                self.logger.debug(\"Customer {}, arrived in line @ {}.\".format(cid, sim_time))\n",
    "                if self.free_agents.empty():\n",
    "                    self.logger.debug(\"NO agents available, putting {} inline on backlog at {}\".format(cid, sim_time))\n",
    "                    self.backlog.put(current_event) #put current_event into backlog\n",
    "                    continue #skip cproc.send, because this customer hasn't been served\n",
    "                else:\n",
    "                    self.logger.debug(\"{} agents available to serve.\".format(self.free_agents.qsize()))\n",
    "                    #handle both situations\n",
    "                    #of getting from backlog or regular. The time in\n",
    "                    #next_time which you will send in message to co-routine\n",
    "                    #below are different\n",
    "                    agent, agent_time = self.free_agents.get() #get the time of free agent\n",
    "                    next_time = max(sim_time, agent_time) #update next_time when both agent and customer are available\n",
    "                    self.logger.debug(\"Customer {} inline to be served by Agent {} at {}\".format(cid, agent, next_time))\n",
    "            #drive the co-routine by sending in time and agent, and getting\n",
    "            #next event out. The event is put into the priority queue.\n",
    "            try:\n",
    "                next_event = cproc.send((next_time, agent)) \n",
    "            except StopIteration:\n",
    "                del self.customers[cid] \n",
    "            else:\n",
    "                self.events.put(next_event)\n",
    "                \n",
    "    def compute_ptimes(self):\n",
    "        ptimes=[]\n",
    "        for j in range(self.n_customers):\n",
    "            #print(j,self.customer_meta[j] )\n",
    "            if self.customer_meta[j]['finish']!=None:\n",
    "                ptimes.append(self.customer_meta[j]['finish'] - self.customer_meta[j]['start'])\n",
    "        return ptimes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def sim_main(num_agents, num_customers, extratime=20., seed=None, debug=False):\n",
    "    if seed is not None:\n",
    "        random.seed(seed)\n",
    "    sim = Simulator(num_agents, num_customers, DEBUG=debug)\n",
    "    sim.run(sim.max_time_when_came+extratime)\n",
    "    return sim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Start small to test this out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Customer 0, arrived 0.8052515134493627, will take 2.088251346795036 at counter\n",
      "Customer 1, arrived 3.184616827794563, will take 3.4086874411441452 at counter\n",
      "Customer 2, arrived 3.3064717183754, will take 1.8388531321895265 at counter\n",
      "Customer 3, arrived 4.231490681925958, will take 2.1783539674775207 at counter\n",
      "Customer 4, arrived 4.26061838450436, will take 1.3727588070037664 at counter\n",
      "Customer 5, arrived 4.622403432976379, will take 0.48305679717336825 at counter\n",
      "========ending init==============\n",
      "\n",
      "\n",
      "----------------------------------------------\n",
      "Customer 0, arrived in line @ 0.8052515134493627.\n",
      "2 agents available to serve.\n",
      "Customer 0 inline to be served by Agent 0 at 0.8052515134493627\n",
      "Customer 0 atcounter Agent 0 at 0.8052515134493627\n",
      ">>>Customer 0 leaves, agent 0 free at 2.8935028602443986\n",
      "----------------------------------------------\n",
      "Customer 1, arrived in line @ 3.184616827794563.\n",
      "2 agents available to serve.\n",
      "Customer 1 inline to be served by Agent 1 at 3.184616827794563\n",
      "Customer 1 atcounter Agent 1 at 3.184616827794563\n",
      "----------------------------------------------\n",
      "Customer 2, arrived in line @ 3.3064717183754.\n",
      "1 agents available to serve.\n",
      "Customer 2 inline to be served by Agent 0 at 3.3064717183754\n",
      "Customer 2 atcounter Agent 0 at 3.3064717183754\n",
      "----------------------------------------------\n",
      "Customer 3, arrived in line @ 4.231490681925958.\n",
      "NO agents available, putting 3 inline on backlog at 4.231490681925958\n",
      "----------------------------------------------\n",
      "Customer 4, arrived in line @ 4.26061838450436.\n",
      "NO agents available, putting 4 inline on backlog at 4.26061838450436\n",
      "----------------------------------------------\n",
      "Customer 5, arrived in line @ 4.622403432976379.\n",
      "NO agents available, putting 5 inline on backlog at 4.622403432976379\n",
      ">>>Customer 2 leaves, agent 0 free at 5.1453248505649265\n",
      "----------------------------------------------\n",
      "Customer 3, arrived in line @ 4.231490681925958.\n",
      "1 agents available to serve.\n",
      "Customer 3 inline to be served by Agent 0 at 5.1453248505649265\n",
      "Customer 3 atcounter Agent 0 at 5.1453248505649265\n",
      ">>>Customer 1 leaves, agent 1 free at 6.593304268938708\n",
      "----------------------------------------------\n",
      "Customer 4, arrived in line @ 4.26061838450436.\n",
      "1 agents available to serve.\n",
      "Customer 4 inline to be served by Agent 1 at 6.593304268938708\n",
      "Customer 4 atcounter Agent 1 at 6.593304268938708\n",
      ">>>Customer 3 leaves, agent 0 free at 7.323678818042447\n",
      "----------------------------------------------\n",
      "Customer 5, arrived in line @ 4.622403432976379.\n",
      "1 agents available to serve.\n",
      "Customer 5 inline to be served by Agent 0 at 7.323678818042447\n",
      "Customer 5 atcounter Agent 0 at 7.323678818042447\n",
      ">>>Customer 5 leaves, agent 0 free at 7.806735615215816\n",
      ">>>Customer 4 leaves, agent 1 free at 7.966063075942474\n",
      "*** end of events and backlog***\n"
     ]
    }
   ],
   "source": [
    "sim=sim_main(2,6, debug=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now lets try it with some larger numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEACAYAAACj0I2EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nNYhtAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10ee84e48>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "sim=sim_main(3,100)\n",
    "plt.hist(sim.compute_ptimes(), bins=20);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEACAYAAACj0I2EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSWqEhS5JjbDQJakR/wuIgdIbhBT6ngAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10f4c6668>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sim2=sim_main(4,100)\n",
    "plt.hist(sim2.compute_ptimes(), bins=20);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "extra time needed below as with 400 passengers a long time is taken to process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEACAYAAABI5zaHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n6VgYHAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10f8d4cc0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sim2=sim_main(2,400, extratime=100)\n",
    "plt.hist(sim2.compute_ptimes(), bins=20);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a proper statistical analysis, you would want to draw this multiple times and look at the distribution of the averages as well. But you should know what this distribution is :-)."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}