Coffee Shop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Coffee\n",
    "This workbook contains a simulation of a shop. It is based on events generated by tasks and is in some respects quite similar to how a GUI or computer game works, except neither of those can be run inside a Jupyter workbook!\n",
    "\n",
    "The goal is for you to extend the simulation, from its inital state as a cake shop, to a proper coffee (and cake) shop, by adding new classes. The purpose is to learn about object oriented programming, with the added bonus of learning how a simulation may work.\n",
    "\n",
    "A lot of code has been provided. You will need to read and understand some of it, but remember that lab time is limited. You may want to skip ahead to the questions during the lab, and come back to satisfy your curiosity as homework."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Marking and submission\n",
    "\n",
    "These lab exercises are marked, and contribute to your final grade. This lab exercise has 26 marks to earn, equivalent to 12% of your final grade. Most of the time where you have to add code is indicated by\n",
    "\n",
    "`# **************************************************************** 2 marks`\n",
    "\n",
    "with instructions above the code block. Occasionally a markdown block will request that you return to an early block and edit it. There will be no indicator in such cases.\n",
    "\n",
    "Please submit your completed workbook to the auto marker before 2021-11-14 20:00 GMT. The workbook you submit must be an .ipynb file, which is saved into the directory you're running Jupyter; alternatively you can download it from the menu above using `File -> Download As -> Notebook (.ipynb)`. Remember to save your work regularly (`Save and checkpoint` in the `File` menu, the icon of a floppy disk, or `Ctrl-S`). It is wise to verify it runs to completion with _Restart & Run All_ before submission.\n",
    "\n",
    "You must comply with the universities plagiarism guidelines: http://www.bath.ac.uk/library/help/infoguides/plagiarism.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from collections import defaultdict, deque\n",
    "\n",
    "import numpy\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helper Functions\n",
    "You can, and probably should, ignore the below block. It's used by the customer arrival times simulation to arrange for a burst of customers at lunch time and at the end of the working day."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def consume_area(x, y, start, area):\n",
    "    start = start % x[-1]\n",
    "    \n",
    "    segment = numpy.searchsorted(x, start)\n",
    "    t = (start - x[segment]) / (x[segment+1] - x[segment])\n",
    "    \n",
    "    travel = 0.0\n",
    "    while True:\n",
    "        delta = x[segment+1] - start\n",
    "        segment_area = 0.5 * ((1-t) * y[segment] + (t+1) * y[segment+1]) * delta\n",
    "        if segment_area > area:\n",
    "            break\n",
    "        \n",
    "        area -= segment_area\n",
    "        travel += delta\n",
    "        segment = (segment + 1) % (x.shape[0] - 1)\n",
    "        \n",
    "        start = x[segment]\n",
    "        t = 0.0\n",
    "    \n",
    "    height = (1-t) * y[segment] + t * y[segment+1]\n",
    "    grad = (y[segment+1] - y[segment]) / (x[segment+1] - x[segment])\n",
    "    \n",
    "    srt = numpy.sqrt(4*height*height + 8*grad*area)\n",
    "    tra = 4 * area / (2 * height + srt)\n",
    "\n",
    "    return travel + tra\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task Interface\n",
    "The below can be considered to be an _interface_, a specification for an object kind that we need to comply with for multiple other objects. It is not actually necesary - the below code could be deleted, none of the tasks would inherit from a base class, and everything would work just fine due to _duck typing_. However, from an understandability point of view this is strongly prefered, as it makes it clear how everything is to work. In other words, the below is a form, of documentation. It also ensures that the correct errors are thrown if a Task is not implimented completely."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Task:\n",
    "    def time(self):\n",
    "        raise NotImplementedError\n",
    "\n",
    "    def depends(self):\n",
    "        raise NotImplementedError\n",
    "\n",
    "    def __call__(self, timeline):\n",
    "        raise NotImplementedError\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Timeline\n",
    "The timeline is the most complex peice of code in the simulation, as it manages everything, in particular time. It actually has multiple independent capabilities:\n",
    " * It manages tasks, which is to it say queues them up and makes sure that they are only run when all dependencies for each task are avaliable (as in not being used by another task).\n",
    " * It handles queues (of customers), pairing off the item from the front of the queue with the object that has offered to process the queue item.\n",
    " * It manages time, specifically looping through it and starting/ending tasks at the required moments, interleaving their execution as required. It is not real time, and will jump through as fast as possible. For instance when the shop is closed and nothing is hapenning is will skip through this time period in a single step, but could take hundreds of steps in a single minute during lunchtime when there is a lot of activity.\n",
    " * Because it is a centralised object that every part of the simulation has access to it also includes an event recording system, so statistics can be recorded and visualised after a simulation has run.\n",
    "\n",
    "You would be advised to read the interface and doc strings, but to ignore the actual code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Timeline:\n",
    "    def __init__(self, **extra):\n",
    "        for k, v in extra.items():\n",
    "            setattr(self, k, v)\n",
    "       \n",
    "        self.running = []\n",
    "        self.waiting = []\n",
    "        \n",
    "        self.queue = defaultdict(lambda: {'sink' : deque(), 'source' : deque()})\n",
    "        \n",
    "        self.now = 0.0\n",
    "    \n",
    "    \n",
    "    def time(self):\n",
    "        return self.now\n",
    "    \n",
    "    \n",
    "    def __start(self):\n",
    "        reservation = set()\n",
    "        for _, task in self.running:\n",
    "            for dep in task.depends():\n",
    "                reservation.add(id(dep))\n",
    "        \n",
    "        # Loop queue and move over tasks\n",
    "        old_waiting = self.waiting\n",
    "        self.waiting = list()\n",
    "        \n",
    "        for task in old_waiting:\n",
    "            can_run = True\n",
    "            for dep in task.depends():\n",
    "                if id(dep) in reservation:\n",
    "                    can_run = False\n",
    "                    break\n",
    "            \n",
    "            if can_run:\n",
    "                for dep in task.depends():\n",
    "                    reservation.add(id(dep))\n",
    "                self.running.append([task.time(), task])\n",
    "            else:\n",
    "                self.waiting.append(task)\n",
    "\n",
    "        self.running.sort()\n",
    "    \n",
    "    \n",
    "    def simulate(self, time = 60 * 60):\n",
    "        self.__start()\n",
    "        self.events = defaultdict(list)\n",
    "        self.now = 0.0\n",
    "        \n",
    "        while len(self.running)!=0:\n",
    "            step = self.running[0][0] # self.running sorted so soonest to finish is first\n",
    "            if step > time:\n",
    "                for task in self.running:\n",
    "                    task[0] -= time\n",
    "                self.now = 0.0\n",
    "                return self.events\n",
    "            \n",
    "            time -= step\n",
    "            self.now += step\n",
    "            for task in self.running:\n",
    "                task[0] -= step\n",
    "            \n",
    "            while (len(self.running) > 0) and (self.running[0][0] < 0.1): \n",
    "                task = self.running.pop(0) \n",
    "                task[1](self) \n",
    "                \n",
    "            qlc = list(self.queue.values()) \n",
    "            for q in qlc:\n",
    "                while len(q['source'])>0 and len(q['sink'])>0:\n",
    "                    obj = q['source'].popleft()\n",
    "                    callback = q['sink'].popleft()\n",
    "                    callback(self, obj) \n",
    "            \n",
    "            self.__start()\n",
    "\n",
    "            \n",
    "    def enqueue(self, task):\n",
    "        self.waiting.append(task)\n",
    "    \n",
    "    \n",
    "    def drop(self, dependency):\n",
    "        self.running = [pair for pair in self.running if dependency not in pair[1].depends()]\n",
    "        self.waiting = [task for task in self.waiting if dependency not in task.depends()]\n",
    "    \n",
    "    \n",
    "    def join_queue(self, name, obj):\n",
    "        self.queue[name]['source'].append(obj)\n",
    "    \n",
    "    \n",
    "    def watch_queue(self, name, callback):\n",
    "        self.queue[name]['sink'].append(callback)\n",
    "    \n",
    "    \n",
    "    def record(self, event, *extra):\n",
    "        self.events[event].append((self.now,) + extra)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Menu\n",
    "A shop that sells food needs a menu - for now just cake.\n",
    "\n",
    "Each cake needs to come with a price, how it is prepared (for now just `'grab'`, in the sense the cashier picks it up and hands it to a customer) and extra meta data. For `'grab'` this is a tuple of two values - the minimum and maximum time it takes to grab the item and hand it to the customer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "cake_menu = {}\n",
    "\n",
    "cake_menu['Banoffee Pie'] = (3.80, 'grab', (20.0, 30.0))\n",
    "cake_menu['Butterfly Cake'] = (1.00, 'grab', (5.0, 15.0))\n",
    "cake_menu['Caterpillar Cake'] = (20.00, 'grab', (60.0, 90.0))\n",
    "cake_menu['Lava Cake'] = (4.20, 'grab', (80.0, 120.0))\n",
    "cake_menu['Tiramisu'] = (3.50, 'grab', (15.0, 25.0))\n",
    "\n",
    "\n",
    "full_menu = cake_menu.copy()                                          \n",
    "full_menu['Espresso'] = (2.00, 'barista', (10.0, 20.0))\n",
    "full_menu['Flat White'] = (2.80, 'barista', (40.0, 90.0))\n",
    "full_menu['Americano'] = (2.40, 'barista', (20.0, 30.0))\n",
    "full_menu['Latte'] = (3.20, 'barista', (60.0, 120.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Customer and Cashier Tasks\n",
    "These are the tasks needed for a basic cake shop simulation, just a customer choosing what to buy and a cashier serving the customer by handing them their cake. Note the use of random number generation in both to generate some vaguely plausible variability in how long these tasks take."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ChoosePurchase(Task):\n",
    "    def __init__(self, timeline, customer):\n",
    "        self.customer = customer\n",
    "        if numpy.random.rand() < 0.2:\n",
    "            self.delay = 2.0 \n",
    "        \n",
    "        else:\n",
    "            self.delay = len(timeline.menu) + numpy.random.exponential(30.0)\n",
    "\n",
    "\n",
    "    def time(self):\n",
    "        return self.delay\n",
    "\n",
    "\n",
    "    def depends(self):\n",
    "        yield self.customer\n",
    "\n",
    "\n",
    "    def __call__(self, timeline):\n",
    "        buy = 1 + numpy.random.poisson(0.5)\n",
    "        options = list(timeline.menu.keys())\n",
    "        buy = numpy.random.choice(options, size=buy)\n",
    "        self.customer.go_buy(timeline, list(buy))\n",
    "        \n",
    "class ServeCustomer(Task):\n",
    "    def __init__(self, timeline, cashier, customer):\n",
    "        self.cashier = cashier\n",
    "        self.customer = customer\n",
    "        \n",
    "        req = customer.to_buy()\n",
    "        self.delay = len(req) * 3.0\n",
    "        \n",
    "        self.delay += numpy.random.uniform(1.0, 40.0)\n",
    "        \n",
    "        self.grabbing = []\n",
    "        for r in req:\n",
    "            targ = timeline.menu[r]\n",
    "            if targ[1]=='grab':\n",
    "                self.delay += numpy.random.uniform(targ[2][0], targ[2][1])\n",
    "                self.grabbing.append(r)\n",
    "    \n",
    "    \n",
    "    def time(self):\n",
    "        return self.delay\n",
    "\n",
    "\n",
    "    def depends(self):\n",
    "        yield self.cashier\n",
    "        yield self.customer\n",
    "\n",
    "\n",
    "    def __call__(self, timeline):\n",
    "        self.cashier.after_customer(timeline)\n",
    "        for name in self.grabbing:\n",
    "            self.customer.receive_item(timeline, name)\n",
    "            timeline.record('purchased',name)\n",
    "            timeline.record(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Customers\n",
    "The customer object is reasonably straight forward, because all of the clever stuff is in the code of the tasks they are involved in. Every method here is called from a task to either set the next action of the customer going or get some information from the customer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Customer:\n",
    "    def __init__(self, timeline):\n",
    "        timeline.record('arrive')\n",
    "        self.enter = timeline.time()\n",
    "        \n",
    "        task = ChoosePurchase(timeline, self)\n",
    "        timeline.enqueue(task)\n",
    "\n",
    "\n",
    "    def go_buy(self, timeline, buy):\n",
    "        self.buy = buy \n",
    "        timeline.join_queue('tills', self)\n",
    "    \n",
    "    \n",
    "    def to_buy(self):\n",
    "        return self.buy[:] # [:] makes a copy of the list.\n",
    "    \n",
    "    \n",
    "    def receive_item(self, timeline, name):\n",
    "        i = self.buy.index(name)\n",
    "        \n",
    "        del self.buy[i]\n",
    "        \n",
    "        if len(self.buy)==0:\n",
    "            self.leave(timeline)\n",
    "        \n",
    "        \n",
    "    def leave(self, timeline):\n",
    "        timeline.record('leave', timeline.time() - self.enter)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Customer Generation\n",
    "As the simulation is driven entirely by the actions of customers we need some code to generate them. The below task does something sneaky - it waits until the next customer arrives, adds that customer, then generates a new copy of the exact same task which then waits until the following customer arrives, and so on. It is the equivalent of an infinite loop made with events, and hence will create customers forever.\n",
    "\n",
    "To give the customers realistic arrival times a Poisson process is used. Mathematically this is quite fiddly, but the idea is simple: We assume all customers arrive independently, and that the average number of customers arriving during a time period can be represented by the area under a density graph. Given these assumptions there is only one solution.\n",
    "\n",
    "The density graph was generated using the footfall data set for Micklegate in York, on Monday 2016-10-10 (Note that York is a northern city with Viking heritage - 'gate' in this context means 'road'). It was scaled by 0.05 on the assumption that 5% of people going past a coffee shop go in, and zeroed outside of 7am - 9pm to simulate opening hours. The end result is not unreasonable - you get a lunch surge, and the total customer count matches up with a smaller independent coffee shop.\n",
    "\n",
    "Footfall data (Open government license) obtained from:\n",
    "https://data.gov.uk/dataset/footfall/resource/3db574a2-05ed-4ea4-83a4-5c0e59345c30\n",
    "\n",
    "It is not necessary to understand the below code - it's corner-case weirdness required by the simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GenerateCustomer(Task):\n",
    "    density = numpy.array([[0.0,0.0], [5.99,0.0], [6.01,1.2], [6.5,1.2],\n",
    "                           [7.5,3.4], [8.5,14.0], [9.5,14.8], [10.5,17.3],\n",
    "                           [11.5,22.2], [12.5,34.1], [13.5,21.9], [14.5,21.4],\n",
    "                           [15.5,27.5], [16.5,27.3], [17.5,21.9], [18.5,8.6],\n",
    "                           [19.5,6.2], [20.5,4.0], [20.99,4.0], [21.01,0.0], [24.0,0.0]])\n",
    "    \n",
    "    \n",
    "    def __init__(self, now):\n",
    "        consume = numpy.random.standard_exponential()\n",
    "        \n",
    "        passed = consume_area(self.density[:,0], self.density[:,1], now, consume)\n",
    "        \n",
    "        self.delay = passed\n",
    "        self.then = (now + self.delay) % 24.0\n",
    "    \n",
    "    \n",
    "    def time(self):\n",
    "        return self.delay * 60.0 * 60.0\n",
    "    \n",
    "    \n",
    "    def depends(self):\n",
    "        return []\n",
    "    \n",
    "    \n",
    "    def __call__(self, timeline):\n",
    "        Customer(timeline)\n",
    "        timeline.enqueue(GenerateCustomer(self.then))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing Customer Generation\n",
    "The below code demonstrates the simplest simulation possible, where customers enter the shop, but, as there are no cashiers, queue up without ever being served. A histogram is plotted to show how many arrived during each hour of the day the simulation is run for.\n",
    "\n",
    "Note that the use of random number generation means you get a different result every time you run this code - you may want to run it several times to see how the graph changes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total customers = 263\n"
     ]
    }
   ],
   "source": [
    "# Create a timeline\n",
    "timeline = Timeline(menu=cake_menu)\n",
    "timeline.enqueue(GenerateCustomer(0.0)) \n",
    "\n",
    "# Simulate for 24 hours\n",
    "events = timeline.simulate(24.0 * 60.0 * 60.0)\n",
    "\n",
    "plt.figure(figsize=(16,4))\n",
    "plt.hist(numpy.array(events['arrive']) / (60*60)) \n",
    "plt.show()\n",
    "\n",
    "print('Total customers = {}'.format(len(events['arrive'])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cashier\n",
    "The Cashiers job is to stand there, watch the queue of customers and serve each in turn.\n",
    "\n",
    "This introduces the idea of a callback - it passes one of it's methods into the `watch_queue()` method. This is then stored (it is just a variable, like any other), and then ultimately called as function when there is a customer to serve. Note this subtlety - it is not `Cashier.handle_customer` that is passed, but the `handle_customer()` method that belongs to this particular object, so when it's called it runs on this object. The technical term for this is a _closure_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cashier:\n",
    "    def __init__(self, timeline):\n",
    "        timeline.watch_queue('tills', self.handle_customer)\n",
    "    \n",
    "    \n",
    "    def handle_customer(self, timeline, customer):\n",
    "        task = ServeCustomer(timeline, self, customer)\n",
    "        timeline.enqueue(task)\n",
    "    \n",
    "    \n",
    "    def after_customer(self, timeline):\n",
    "        timeline.watch_queue('tills', self.handle_customer)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Just a Cake Shop\n",
    "This is the end of the provided code - a shop with one cashier and a menu containing only cake. Customers queue up and select cake, queue, buy cake, and then leave. It's a good life, but that doesn't mean it can't be improved.\n",
    "\n",
    "The below simulation prints a scatter plot of waiting time for each customer during the day. You should be able to perceive more delays around lunchtime when lots of customers arrive at the same time, for instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA54AAAD7CAYAAAACXkuTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAA1HklEQVR4nO3df4wc533f8c/3jmt5Kac6EaZdcSOKROpQiXyxrr7aSq9FIzoOjSi2L3RjR7VTAUmrNk1aS1CuOSZCJCUKeAjjqPmjCKrUho1aFShH9Fkq3dKGqcSNECo5+iifWYkxUFm0l6pFRzzHMdfW8vj0j9057u3Nz92Z3ZnZ9wsgSM7+enZn5pnnO8/zfB9zzgkAAAAAgKyMDbsAAAAAAIByI/AEAAAAAGSKwBMAAAAAkCkCTwAAAABApgg8AQAAAACZIvAEAAAAAGQqMvA0s9ea2V+a2bNmdtrMHmhv32Zmnzezr7b/vjb74gIAAAAAisai1vE0M5N0tXPu78ysIunPJX1Y0n5JrzjnFsxsXtK1zrlfz7zEAAAAAIBC2RL1BNeKTP+u/d9K+4+T9F5JP9He/glJfyopNPB8/etf73bt2tVbSQEAAAAAuXby5MlvOee2d2+PDDwlyczGJZ2U9A8k/Wfn3DNm9kbn3EuS5Jx7yczeEPU+u3bt0tLSUsKiAwAAAACKwMxe9NseK7mQc27NOXezpB+U9DYze3OCD77TzJbMbOn8+fNxXwYAAAAAKIlEWW2dc6tqDal9l6Rvmtl1ktT+++WA1zzsnJt2zk1v376pxxUAAAAAUHJxstpuN7OJ9r+rkn5S0vOSnpB0R/tpd0j6TEZlBAAAAAAUWJw5ntdJ+kR7nueYpMecc//DzP5C0mNm9kuSzkr6uQzLCQAAAAAoqDhZbb8sacpn+99IekcWhQIAAAAAlEesrLYAACwu13Xo2BmdW21ox0RVc/v2aHaqNuxiAQCAAiDwBABEWlyu68CRFTWaa5Kk+mpDB46sSBLBJwAAiJQoqy0AYDQdOnZmPej0NJprOnTszJBKBAAAioTAEwAQ6dxqI9F2AACATgSeAIBIOyaqibYDAAB0IvAEAESa27dH1cr4hm3Vyrjm9u0ZUokAAECRkFwIABDJSyBEVlsAANALAk8AQCyzUzUCTQAA0BOG2gIAAAAAMkXgCQAAAADIFIEnAAAAACBTBJ4AAAAAgEwReAIAAAAAMkXgCQAAAADIFIEnAAAAACBTBJ4AAAAAgExtGXYBAAD5trhc16FjZ3RutaEdE1XN7duj2anasIsFAAAKhMATABBocbmuA0dW1GiuSZLqqw0dOLIiSQSfAAAgNgJPAMAmXi9nfbWx6bFGc02Hjp0h8AQAALEReAIANuju5fRzzicgBQAACEJyIQDABoeOnQkNOiVpx0R1QKUBAABlQOAJANggqjezWhnX3L49AyoNAAAoAwJPAMAGYb2ZtYmqDu6fZH4nAABIhMATALDB3L49qlbGN2wzSR+6Zaeent9L0AkAABIj8AQAbDA7VdP73lqTdWxzkh4/Wdficn1YxQIAAAVG4AkA2OSp58/LdW3zllEBAABIKjLwNLPrzewpM3vOzE6b2Yfb2+83s7qZnWr/+ensiwsAGISgBEMsowIAAHoRZx3PS5Lucc59ycx+QNJJM/t8+7GHnHO/n13xAABpWlyu69CxMzq32tCOiarm9u3xnbO5Y6Kquk+QyTIqAACgF5E9ns65l5xzX2r/+zuSnpNEZgkAKJjF5boOHFlRfbUhJ6m+2tCBIyu+8zb9EgyxjAoAAOhVojmeZrZL0pSkZ9qbftXMvmxmHzOza9MuHAAgPYeOnVGjubZhW/e8zcXlumYWjuvuw6d01ZYxXbu1IhPLqAAAgP7EGWorSTKz10l6XNJdzrm/NbM/kvQ7aiU7/B1JH5H0iz6vu1PSnZK0c+fONMoMAOhB1LxNr0fUC05XG01VK+N66AM3E3ACAIC+xOrxNLOKWkHnI865I5LknPumc27NOXdZ0h9Lepvfa51zDzvnpp1z09u3b0+r3ACAhILmZ3rb4/SIAgAA9CJOVluT9FFJzznn/qBj+3UdT/tZSV9Jv3gAgLREzdskky0AAMhKnKG2M5J+QdKKmZ1qb/sNSbeb2c1qDbX9mqR/k0H5AAAp8YbLBmW1JZMtAADISmTg6Zz7c0nm89Bn0y8OACBL3cGnN4x2dqqmuX17NszxlDZnso27HAsAAECn2MmFAADF151AyFtSRYruEY3zWgAAAD/mnBvYh01PT7ulpaWBfR4AYKOZheO+w2lNrXkTknTt1orue/dNm4LJoNdOVCu6+qot9IICAACZ2Unn3HT3dno8AWCEBCUK6rwFeeFiU3N/8qykjT2ZQa9dbTS12mhKohcUAAD4i7WcCgCgHOImCmquuU3LqMR9LUuwAACAbgSeADBC/JZUCdLdw9nPawEAwGhjqC0AjJDOBEJ+8zU7dfdw+iUfuvjqJV242Ix8LQAAGG0EngAwYmanapqdqgUmC5KkyrhtWEal+7WeexdX9MkTZzc979Ybt6dXYAAAUHgMtQWAEXXrjdt9F2m++jXjOvTP3xIrOdBTz59PtB0AAIwmejwBYAQtLtf1+Mn6hmy2JumDt+zUg7OTsd8nqMc0ahgvAAAYLQSeADACFpfrm+ZmNpprG57jlLynctxMaz7rQY+bX18qAAAYVQSeAFByi8t1HTiysh5ohvVGJs1G6xd0hm0HAACjicATAEru0LEzm3o3g0Rlo+3uOb12a8U3q22NrLYAAKADgScAlFzcXsxqZdw3k63Hr+e0MmaqjJuaa1d6OKPeBwAAjB4CTwAoKa93Ms6g12u3VnTfu28KzWTr13PavOw0Ua3o6qu2rPeCzu3bEysjLgAAGB0EngBQQt29k1G2vmZLZLAY1HP67UZTp+77qcRlBAAAo4PAEwBKKMm8Tqk1bHZm4Xhor+WOiapvYqIdE9VNcz/p9QQAAJ3Ghl0AAED6kmanNbWCT9f++8CRFS0u1zc8Z27fHlUr4xu2VSvjuvXG7TpwZCXy9QAAYHQReAJACQVlp52oVjYFjyZtmgfaaK7p0LEzG7bNTtV0cP/kesbacTM1mmt69Jmvb+pdbTTXdM9jz2r3/FHNLBwnCAUAYMQReAJACQX1Tt7/npvWg0dTa9mToORDfr2ms1O19ff21uoMW8uTHlAAACAxxxMASsmbXxk077Jz/uXMwvHAuZt+ks4fla70gHZ/NgAAGA0EngBQUrNTtVhB3ty+PZsy4IatxZl0/qhnzTkdOLKyXjYAADA6GGoLACOuc+6mN/z24P7JwOAwqCfUYnyW39xRAABQfvR4AgBi945K/j2klTGTTGquBc0YvaLXHlMAAFBcBJ4AgET85o9efPWSLlxsxnp9UI8pAAAoLwJPAEBi3T2ku+ePxnpd2NxRAABQXpFzPM3sejN7ysyeM7PTZvbh9vZtZvZ5M/tq++9rsy8uACCPonox48wdBQAA5RUnudAlSfc4535E0i2SfsXMflTSvKQvOOfeJOkL7f8DAEZQWC/muJleWLhNT8/vJegEAGBERQaezrmXnHNfav/7O5Kek1ST9F5Jn2g/7ROSZjMqIwAg52anapr5oW2+j93+9usHXBoAAJA3iZZTMbNdkqYkPSPpjc65l6RWcCrpDamXDgCQyOJyXTMLx7V7/qhmFo5rcbk+sM9+5F//uD50y06NW2thlXEzfeiWnXpwdnJgZQAAAPlkzkWnvpckM3udpD+T9LvOuSNmtuqcm+h4/IJzbtM8TzO7U9KdkrRz5863vvjii6kUHACw0eJyfdMyJ9XKOPMqAQDAwJjZSefcdPf2WD2eZlaR9LikR5xzR9qbv2lm17Ufv07Sy36vdc497Jybds5Nb9++vbfSAwAiHTp2ZkPQKUmN5poOHTszpBL1bpg9twAAIH1xstqapI9Kes459wcdDz0h6Y72v++Q9Jn0iwcAiOvcaiPR9rzyem7rqw05SfXVhg4cWSH4BACgwOL0eM5I+gVJe83sVPvPT0takPROM/uqpHe2/w8AGJKgJU2iljrJmzL13AIAgJYtUU9wzv25Wkuw+XlHusUBAPRqbt8e3zmeYUud5FFZem4BAMAVibLaAgDya3aqpoP7J1WbqMok1SaqhUwsVJaeWwAAcEVkjycAoDhmp2qFCzS7laXnFgAAXEHgCQDIFS9wPnTsjM6tNrRjoqq5fXsKH1ADADDKCDwBALlThp5bAABwBXM8AQAAAACZIvAEAAAAAGSKwBMAAAAAkCkCTwAAAABApkguBAAlsbhcJxMsAADIJQJPACiBxeX6hrUv66sNHTiyIkkEnwAAYOgYagsAJXDo2Jn1oNPTaK7p0LEzQyoRAADAFQSeAFAC51YbibYDAAAMEoEnAJTAjolqou0AAACDROAJACUwt2+PqpXxDduqlXHN7dszpBIBAABcQXIhACgBL4EQWW0BAEAeEXgCQEnMTtUINAEAQC4x1BYAAAAAkCkCTwAAAABApgg8AQAAAACZIvAEAAAAAGSKwBMAAAAAkCmy2gJAgS0u11lCBQAA5B6BJwAU1OJyXQeOrKjRXJMk1VcbOnBkRZJKEXwSVAMAUB4MtQWAgjp07Mx60OlpNNd06NiZIZUoPV5QXV9tyOlKUL24XB920QAAQA8IPAGgoM6tNhJtL5IyB9UAAIwiAk8AKKgdE9VE24ukzEE1AACjKDLwNLOPmdnLZvaVjm33m1ndzE61//x0tsUEAHSb27dH1cr4hm3Vyrjm9u0ZUonSU+agGgCAURSnx/Pjkt7ls/0h59zN7T+fTbdYAIAos1M1Hdw/qdpEVSapNlHVwf2TpUjAU+agGgCAURSZ1dY590Uz2zWAsgAAYurO+PrQB24uRcDp8b4LWW0BACiHfpZT+VUz+5eSliTd45y7kFKZAAAhyr6Mimd2qlaq7wMAwCjrNbnQH0n6IUk3S3pJ0keCnmhmd5rZkpktnT9/vsePAwB4ipTxdXG5rpmF49o9f1QzC8dZDgUAgBHVU+DpnPumc27NOXdZ0h9LelvIcx92zk0756a3b9/eazkBAG1FyfjKWpwAAMDTU+BpZtd1/PdnJX0l6LkAgHQVJeNrkXpmAQBAtuIsp/KopL+QtMfMvmFmvyTp98xsxcy+LOlWSXdnXE4AQFtRMr4WpWcWAABkL05W29t9Nn80g7IAAGIoSsbXHRNV1X2CzLz1zAIAgOz1k9UWADAkRcj4Ordvz4bsu9LmntnuZWHyGEADAID+EXgCQE55QVl9taFxM605p9pEVbfeuF1PPX8+98FaVM/sqCwLAwAAJHPODezDpqen3dLS0sA+DwCKqjsoC1OtjOvg/snCBWszC8d9h+LWJqp6en7vEEoEAAD6ZWYnnXPT3dt7XccTAJAhv4ywQYqaKZbkQwAAjA6G2gJADiUNvooYrJF8CEXF3GQASI4eTwDIoYmtlUTPL2KwVpRlYYBO3jD4+mpDTq25yXOfelZTv/057Z4/qpmF41pcrg+7mACQO/R4AkDO3Lu4ogsXm7GfX9RgrSjLwgCd/IbBNy+79XOWJFkA4I/AEwByZHG5rkdOnI18nklyaiXiKXKwVoRlYYBOcYa1N5pruv+J0xzbANCBobYAkCOHjp1RnFzjXtD59PxeGrfAAMUd1r7aaDLkFgA6EHgCQI4kSRJUxIRCQNH5zU0OUsRs0wCQFQJPAMiRJEmCiphQCCi62amaDu6fVG2iKpM0UQ1OBMbNIQC4gjmeAJAjc/v26MCRlU3JS8bHTGuXrwzCLWpCoV6wdAXypntu8tRvf843IRg3hwDgCno8ASBHuntTahNV/acP3KyP/NxbNvSsvLYyGtW339IVB46sMHcOuXLfu29iaSAAiECPJwDkjF+m18Xlur5/6fL6/y9cbI7Ekg1+S1c0mms6dOxMqb83ioWlgQAgGoEnABTAqAZgQXPkmDuHvGFpIAAINxpjtQCg4EY1AAuaI8fcOQAAioUeTwDIgXsXV/ToM1/XmnMaN9Ptb79eD85Orj++Y6Kquk+QWfYAzC/ZEnPnAAAoHno8AWDI7l1c0SdPnNWaa2WtXXNOnzxxVvcurqw/x2/twFEIwPySLR3cP8mQRgzc4nJdMwvHtXv+qGYWjpPgCgASoscTAIbs0We+Hrjd6/Wcnapp6cVXNvSKvu+tozGnjLlzGDYvu7LX8+5lV5bKndwLANJE4AkAQ+b1dIZtX1yu6/GT9Q29oo+frGv6hm2FbPiyNieKpJfkXhzjALARgScADEBYI3TczDf4HDdb/3eZstrSe4SiSZrci2McADZjjicAZMxrhNZXG3K60gj15ojd/vbrfV/Xub3oWW0758fd89izgUE0kEdJsisvLtc5xgHAB4EnAGQsrLdSkh6cndSHbtm53sM5bqYP3bJzU1ZbP0XIatsdeAcNLS5KEI3REze5l3esc4wDwGYMtQWAjMXprXxwdnJDoNmtyMuK+AXefooQRGM0ecNjo+ZsRh3rHOMARhmBJwBkLI01OOM2fPMoTi9PZdwKEURjdMXJrhx2rBflRhEAZCUy8DSzj0n6GUkvO+fe3N62TdJhSbskfU3S+51zF7IrJgAUV1q9lUVdViQo8O509Wu2FPK7AZ2CjvVxM9afBTDy4szx/Likd3Vtm5f0BefcmyR9of1/AICP2amaDu6fVG2iKpNUm6iOVCPUb35ct283mgMqDZCdoLmgH3n/W3o63zuTcs0sHF9PSAYARRTZ4+mc+6KZ7era/F5JP9H+9yck/amkX0+zYABQJkXtrUxD5zDhoJ5P5r6hDOIMiY+7vqffkix3Hz6lpRdfCZ0PDgB51esczzc6516SJOfcS2b2hhTLBAClNMoLynuBd3djWmLuG8ol7CZTkvU9/RIVOUmPnDir6Ru2jUzdAaA8Ml9OxczuNLMlM1s6f/581h8HALkUtZbnqBj1YccYbVFLK3UKSlTk2u8DAEXTa4/nN83sunZv53WSXg56onPuYUkPS9L09LT/wlYAUHJhDc5RC7pGedgxRlucpZU8YUm5WA8UQBH12uP5hKQ72v++Q9Jn0ikOAJRTkgYngHIKmsvst31u3x5ZwvcBgDyLDDzN7FFJfyFpj5l9w8x+SdKCpHea2VclvbP9fwBAgCQNTgDlFJTh+eKrlzYNu5+dqumDt+zcFHwyJxpAUcXJant7wEPvSLksAFBaaa3lCaC4vCHm9z9xWqsdSwhduNj0TTL04Oykpm/YNrJJyQCUizk3uGmX09PTbmlpaWCfBwB5MspZbfvFb4dhyeLYm1k47jt/szZR1dPze/t6bwAYNjM76Zyb7t7ea3IhAEBMnQ3Xa6oVTWyt6NxqYz0zJQFUuCRLUABpyurYY843gFGU+XIqADDKupdRWW00deFic6SXVEkqyRIUKLbF5bpmFo5r9/xRzSwcH/q5kdWxx5xvAKOIwBMAMuTXcO1EABWN3qHRkMe1brM69pIkGQKAsiDwBIAMxWmgEkCFo3doNOSxZzurY292qqaD+yc1Ua1s2O4lGSL4BFBGBJ4AkKE4DVQCqHB+vUNkBC6fPPZsZ3nszU7VdPVVm1NtDDvYBoCsEHgCQIaChtR5CKCieb1DtYmqTK3Mnwf3T45kYqG8zYFMUx57trM+9vIYbANAVlhOBQAy1p3V1kxavdhkWRAk0p1hVWrduChLEJ7k+5VleZ2gZVWqlTFtu/qqwn8/AKMpaDkVAk8AAApgFNZ+jBNQlikAX1yua+5Tz6p5ObwtVtTvB2A0sY4nAAAFNgrDMmenapHBVVgSojwGZmHB9OxUTQ88eVoXLjZD3yPP3w8A4mKOJwAABZDHOZDDUKQAPM4SMasRQacnj98PAJIg8AQAlEaZk++Q3bdlUAF4GsdSnCVi4pZ7zKyUxzWA0UHgCQAohTi9S0VW1uy+SQO8QQTgaR1LcXpnozJfe9acK+VxDWB0kFwIAAaoLNk482gUku+UTa+JgrI+j9I6loLeZ6Ja0dVXbVkv/603btdTz5/3/f+YmdZ82moc1wDyiuRCADBk3Y3s+mpDdx8+paUXX9GDs5NDLl3xFWnuH1p6TRQUJwlRUp3BbNAt+aTH0ty+PZsC68qY6buvXtJqozW3s77a0OMn64HB9u75o6mUBQCGjcATAAbEr5HtJD1y4qymb9hGz2efdkxUfXuXRi35TpHk5WaBX8+rn6THkndOd/bOXnz10qYstp3zPrt7cjmuAZQFczwBYECCGtNO2pBsBL0h+U7x5CVTr99NoW69HkuzUzU9Pb9XLyzcpqfn9wYuneLN3eyeV3rrjds5rgGUAoEnAAzINdVK4GMMm+tfWZPvlFlebhaEnX9pH0vjZoGP+Q07fur58xzXAEqBobZIDUlTgHAh7U2GzcUQp47x5v55z7378CkdOnaG+iin/IaiDmNfBQ1nzSKBj1+ioDDnVhuZzGkFgEEj8EQq/JKmHDiyIklcLIG2sIXiGTYXLkkdU5b6KCrQLsvNPr+gapDfbXG5ru9+/9Km7Vn1vNYCgtzxgOy13JQCUBYMtUUq4iySDYy6oAbkRLVSyIBhkJLUMWWoj6LWkSzzmqWD/G7eZ3kZZj3Xbq1kNpw1aHjx7W+/PhfDjgEgK/R4IhV5yUwI5Jnf0grVyrjuf89NQyxVMSSpY8pQH0UtM9LrMiRFkPS7dfaOXlOtyKw1uiBOT2lQUqELF5vrNyrS/j3DhhdP37AtsKe3LD3cAEYXgSdSQbp3IFpe5rMVUZI6pgz1UVTwXIbgOkiS79Y9rLqz5zLOEOuw3yvLIdpBczaDtvsNH7/r8Ck98ORp3ffum6hDABQCQ21H1OJyXTMLx7V7/qhmFo73PYQpL5kJgTwIO7+6l1agwRhPkjqmDPVR1DIjeVmGJAtJvtsDT54OXQYlaoh11O+VlyHaYT2zZRliDaD8CDxHUND8mXsXV3oORlnGAGgp89y7YUpSx5ShPooKnssQXAeJ+90Wl+uBa2J2CuvV9PusJK8flLAy5CU4BoAoDLUdQUHzZx45cVZePr1ehhiR7h1IPj8N8SWpY4peH0UNyy7zsO243y1usBXWq9n5WX7Ds6NePyhBw8c9eQiOASBKX4GnmX1N0nckrUm65JybTqNQyFbQBao7iXuZG8skaUBWgs6vsEYjkhuFc7g7AOtOdlP04DpMnO8WJ9iK0wvcufarX/KvPPQi+yUm65SH4BgAoqTR43mrc+5bKbwPBiTqzmmnMt5FLcsaf8inoPPL1Dr2OMb653cOz33qWT3w5OnY2UyLYBTrqiQ3FALPNZPklPg4yHMvsleG+584vWnpl7wExwAQxZzPYsWxX9zq8ZyOG3hOT0+7paWlnj8P6fC7qxukNlHV0/N7B1CqwZlZOO7bWCnjd8XgLS7XdffhU5tGEEgcY2kJOoc7VSvjhZvX2W3U6qqgHseg/Zj0+WUxCr39AIrNzE76jYTtt8fTSfqcmTlJ/8U593Cf74cBiDOnRWr10JTxLipDIdFrwy3qdd7jQbfzyjiCYBji/I5lmCpQ5iVT/CSdH91vD2XQ+VyEwO6737+0nrzsgSdPSypvL7h0ZV/VVxsaN9Oac6rldN8ACNZv4DnjnDtnZm+Q9Hkze94598XOJ5jZnZLulKSdO3f2+XFIi1dR3/PYs1oL6PXuvS883xgKOdp6Hb4Y9bo4IwmYh5WOuNMFih6glWE90iR6CbR7necadD4vvfiKHj9Zz+3w5sXluuY+9ayal69coS9cbGruT56VlI8y9sMv6Je0YV95bZa87RsA0fpaTsU5d67998uSPi3pbT7Pedg5N+2cm96+fXs/H4cUeRfdoKDTU8ZlIOb27ZH5bHeKnyURxRXWq9LL6+46fEr3Lq4ErrPnYR5WeoLO4W5FD9DKvGSKn6D9dU21kuq601Lw+fzoM1/vqX4YlEPHzmwIOj3NNZebMvYqaCmqsLVa87RvAETrOfA0s6vN7Ae8f0v6KUlfSatgyFZUI9lTxkp9dqrGUMgULS7XU28UZqnX4Ythj3/yxNnQHrgiriOZZ2HnsKcMUwXKsB5pEn6BdmXM9N1XL6W+Lm7Q+Rx0MzYv14awcnTXQUWrm4NuBkSt1ZqXfQMgWj9Dbd8o6dNm5r3Pf3fO/a9USoXMJamo4z63CPNiPLURG8KWlTxm3Yw6DnsdvpgkG3SnsiaCGbagc9jjlO/hd3HryzIvmdLNb87mxVcvbQo80pi/G3Q+e/MH/Z6fB2H1UOd0kTzWzVF6DSDzsm8AROu5x9M593+dc29p/7nJOfe7aRYM2UpSUcd5btAQmbzeYR21IWxZCbpDfc9jzw5l38c5Dnvd936v61YZ3zgAlGMqO1H7o5bjxuiw68s894TNTtX09PxevbBwm56e36vVgN6u+mqjr7IH1QO3v/36XF8b5vbtUWXMf6B553SRsKkBu3K436XgtsZEtRJ4rqe1b/J8TgBlksY6niggv8WoK2MmWWuuiCdupZ40G+Gw5Xm9tiIJG642jLvrcY7DXve99/hdh08FPufq12zR1Vdt4ZgagCKta9jdu3nx1UtDqy+L1hMW1sMXVvaoHuWwemD6hm25vTZE1UNenRzVe5jH/e7XLqlWxnX/e26SdCUTf9pZbYt2TgBF1tc6nkmxjme+BGWP6+WCu3v+qO+cK5P0wsJt6RYcuRG1nuK4mT7y/rcM7OI9iOPw3sUVffLEWd/HON6zl2a9NQhJ1k0exPEz7LVBk07JiPP7dZd9FNb3DKt7awFDlIOem6epAMOYsjPscwIoo6zW8USBBc0d6qWSH7W0/1kq0lxZvzvUnQbd8zmI4/DB2Ul9+kt1fffVzd95zEy754/mfr8VVVDPxMH9k7ltIMZN5CYNpr4c5Nqg3XXZrTduT7xUSZx1p7vLXrQROL0Iq3vrq43Y86jylpinu13iDYHtPIaeev58qtfHUVsvFximvpZTKRPG9/en3zmTZfv9e/0+w577lZSXdXPcghe3GGRm5EHN3f3dn530nXO05lwh9ltR9boUzjDFbbwOanhwUHCbdtDrV5c9cuKs7/67/4nToe/lzfsMmrfbXfZRCCQ6Mx77uRzzffJ8c9jvGPIyiKdZzw7qnABA4CmpeI39POon7X/Zfv9+vk8RG9azUzV95P1vCUx4IQ2uwTeo5Se6P8cv8M77fiuiIgYUQY3XamVs/bgZN9P73ppu9tqgm1+DujnjV5cFTexZbTR17+JK5HvGLfuoBBJeQB5nTdsgF1+9lNtrbZzRAmnUsyQbBAaHobYajWE5g9Br2v+y/f79fJ8iNqyl1r5/4MnTgXOKBtng6+U4DBveHPRY5+fsnj/q+755329FU8Qh/UGJ3C5dduvLdqw5p8dP1jV9w7ZU6rywZCmSdNWWsfXHrt1a0X3vvinVc0ZKfuw/cuLspu/v9xkH909GTkUISlLjBRJFms4QR69LPUnShYvN3CbSiXsM9VvPkmwQGBwCTxW3sV8WZfv9+/k+RWtYdzbgwtKU5fnOcVQjPU62w4mtFd+ge2JrJcuij5yogCKPBrk2pSfo5tf9T5zW9y9d3vDY95pxB2VeEScLaNJgyFsKpPOGT6/zecMCiTJmMI2aax8lrzd64x5DaVwfR2m93Lwo2w0gxEPgqeI19pMowoldtt+/n+9TpIZ13GydE9VK7o65TlHDm+P0Xn8/4DcYYNLwkZBWz8Sg68XuRm2/PeS99jZ2Lzsj9RZ0xBnVEVSXjZl8E3N1l7vfkTBBgUTZRthIm8+La6oVfffVSxuWRoviXbPy1GaIE1Dn9fqIcGW8AYR4CDxVrMZ+kKAlBrpP7LsOn9IDT56OHFo1yItPGX7/Tv18nyIN+Ykz/8Zbgy1PjZluvfRQdz527+KKLgb0Gn3bp6GP/vTbM5GHBk8/N6ey6G1MOrokzjkTVJdJ0t2HT/mOkOj8/lmNhCnbCBuPXzZYvzVuTf5zbU2tuswv6/DSi6/oqefPZ7KGZpTuYeG3/dh1qWe1xeCV8QYQ4iHwVLEa+36CGiKvrYz5BgZRczoG3TAr0u8fJ4Dq9/sMc8hPkgAxrKFmUugNkEE29KO+U1QQEPbY4nJdjwSs6dn5PORHHho8YTenoo7XfnobX1sZ8x0SnvQ4DRpafk1149DyoLps6cVX9MiJsxsCoO6bc0HnZb9LFl1Trfj2/HaXvei8395vSZvu315qBaOPPvP19XnHnkZzbcPzvcezrsf9RtR8r3lZ0zds04Ozk6l/HnrT603lst4AQjQCz7Yij+8PaoiE9UaFNbTC5gdlFRwW4fdPEpAX4ft0S3rDIahh2L3o9szC8aE19ON8p7l9ezT3qWfVvHylwVUZM9+gWdrYQD507Exh57aOqqCGTX21oZmF4wO56RXWGxh1vIaVP+n7S8lHlywu1/V337vk+9h32xlSo36/B2cnNX3DttDrSdAwy34Dn6CVn0JWhCoUv0Cge07sJwNulnUHnZ6gOq7fejwsaMnDDSKE66eTomxTrBAfgWcJ9HqHKOkdp9VGc/1OcV7G43deuK6pVmQmrV5sZtJrWvYLYdT3i1oMXvJvxA7qzqZfIyb2PutudLb/H9V7HfYd8j63dVSFDUMdZL3md3Mqzk2aoPKbtCHoC7v51c8NxEPHzmy4SdOpueb6noPZ+XhnWcfaQzw79VL/rgZk3g7aXiR+gcDdh09p6cVXNvQSTgT0+poln5eepB7vvl53zkPtPveyuG7kecrHIKX1O/TTJirbFCvER+BZAkENkYlqZVMGw+7XJXm/bsMOurovsp0X0n4bkH4VcxoXQu99hzFXJkrY9/Nr0Dx+sq73vbW2Yb7NrTdu16FjZ3T34VPrv9sg7mwG3XkNOva7k5h0J+HobECHNZDDgoD733NTj98GWYpKWDLMei1OHTO3b4/vHMnurLBB+h2NEVXfefVFGg3bzrKmtWRRmXtagtZO/eSJszr65ZfWb8o21/znpFe3jMnJNrxH0JxQT9zfLex67ek899LaT53X3M7vksZNpiIGsmlOpeq1TeT9bo3mWu7aQcje2LALgP4FLX58/3tu0sH9k5rwmbsSdmfJ7/2CDHM8flRym14XlvYq5vpqa4kQr2IOWhrDSRsWaI/zvtLmIWNpL+IdtIB8kKAL+jXVSuCdzaeeP6+n5/fqhYXbNLdvjx4/Wd/0u9164/bMF+cOKt94wPi5OElMvKGXYb+f37likj54y04uoDk1O1XTwf2TqoU0YIdVr4XdDPTMTtUCAwEv6Ety3qdVRs811Ypv/dlvOeL8NnEEXS+L2tPSub/DbhhfuNhc3x9BWYUbzcvr54apNW3ig7fsDGwPJPnd4iSjk66ce2nsp+5rbvd502sbofu90zzOsxaVxT0O75gLqofCzkm/dpC3X7lmjgZ6PEsgbD7PoWNn9O1GUxMJhqH6vZ/funPScO8Sx2kc9tKADKqYr9oypmpl3PfiGeeuYdiFN+1ell7uavrNdZRa87b87k5L8ZY/eOr587EWfe9H0H72Lmphw3nCei297UG/X5ESY+EKrydtZuH4QHq/wqYE3Hrj9vVRA9dUK6qM24YeeL/Gdi3gmPWCvu6hlncdPpVaj0JYj3G1Mi6zeEsQpfG5vQSMZTpn4y5pFZfXa979e3jzcfsZqRP3Wuyde0n2U1DPY5xgt9ce+qJOvel35FbUMRd1Thb1d8uLIvaydyPwLAm/VOrdw1qqlXE99IGbe5p/41fZDPsucZwhwb00IIMq4G83mnroAzevX4C7RVWecYaoefqtXKLuavq99+xUTQ88eXrTDYbmmltvbHSLu/xB1smWwhId3Xrj9vVsjeNmet9bN5bFr0HrN7wsaP8WMZEUWgYxzyhqSkBnopfVRlOVMdO1WyuhNwmDyu0X9KU5tLDztUGByN2HT/m+rt9e5DQDxrKcs3F7EZPwO07S+L3iXK+7z704nxt2kzXOMed3syboPOm8LoeNOsizfocwhx1zcW5GkM22d3lYCiwNBJ4llfZdpTzeJY6zuPStN25P/L5BFfM17WQxs1M17Z4/6nvhCas8oy68nUt0JKlcksxH7Z772P3eQQk2+uk5HESveFBD3EuA5AXNa87p8ZOtoVCdc1O756oG7ScujuUyiHotaXDQvOy09TVbtPxbPxX4nKByBwV9nrR6FqISF2VVD5QlYExLP/XRRLWiq6/a0tNN1F741dGVMdPrXrulr4SAYW2dqGtukh76uL3LeZ8r3O/NtqBjzqRN2ZP9lHmOddbK0ltM4FlSWdxVGsRFP0lPX/eddz9PPX8+8fuHDTn1skb2UnlGDVHrHB4dt3IJClKD1tnz3ivovcN6Dr0ssUmWPxhUr3hQQzzot+xcl85LlHRw/+T6+wxqCCaGL+t6rZc6N85r/ModVhf6vXcWw7bIVjk4YYGVN2pjoit7rHQlB4Qk3ZVyD3XQMdVdR6eVhT6srfPQB24OHM2StIc+zg2kIhzn/d5s6zdwLFP9MOhhr2XpLSbwLKki3lXqZRhBkh7IuO8fNuTUC9B6qTyjhqh5jyepXMLmo0ZlI/R777DvFdVAT7v3KGml7le+oEZF1DDaMl0cMVxxs4R3v6YXcUaBRI2sWHrxFT31/Pme5/PlcXRMWYXtby+4enp+r29dKmn9+uen+xiMUx9HXWO9P2kOGQxr68Q5FuP20Ic17q39/Dwc53H2Uz832/q9NpalfhjGsNcituv9EHiWVBEbzv0MI4hzQiZ5/6Ahp97Fp9fKM06Fn6RyCZuPmmQ5tu6EDvc/cXp9LtprK/GTX6fVe5RWpZ6k0d/5W5bl4ojhixMMduqnnu6+udV98ynOyIrO0QDdmbc7PyOqHJwr2fN+46heS7/94bdmrMc7TpIuRRL3GpvmkMGotk7UsRg2TWNm4fh6/R80isgL7vNgEMFQGtfGMtQPwxj2WsR2vR8Cz5LKW8M5zl24foYRBCWI8ZbESLoOZ5zgL6vKM0nlElXOoGytQY1Rz/cvXVnn7cLF5sAnsKdVqcdNHCRtDuzLcHHE8EUNMfSy2no9jJ1JwPpNnBNW7wbVh0E3rIo4l2gUzE7VeppXG3ZdPbh/UksvvrLhJkTYUiRJE+6kPWTwqi1j63X8mCnROeTXVvJyA3QGcJUxi5VxepgGFQxxbRzOsNe8tet7ReBZYFHBXF4qh7h34foZRhB2pz9q3mPn0LPOxmHWF5m4c2HCKpeoINXvse5EOn5Dj4Y9gT2tSj1Oo0LKXwMC5RJVF/fTUxF2HQj73F6GABdtLpGnDEsQhOmlJyRsPr+kDUFnkO5kdWGfFeezvTWx4+4fv4Q/XmqGJOdQ93ni1xvcvOzWEzLl9TgKOp+TnueINqxhr3lp1/eDwLOgipRWOW4gk8bcgdkp/7X5Gs01fS8kqY/fkgdxljXoVdy5MFHizmFJcqHMwwT2NCt1v9/SW5curw0I5F+awUyvN3v6uQ4kHQIsFW8ukVSsa2WveukJCbveHjp2JtZUDa+HPozfNTzs2Euyf6IS/vR6wzRsCsup+4KzTQ9b0LJn42ZDKE25lWXY6zAQeBZUHnql4goLZLobb1G9cf18Xnd1fO3Wiu57903rwarfHc6oZQ16leb+CwtSe7k7locJ7FlX6mW4a4jhSTuY6fVmTz/1iF+wErX0RBEbVUW6VvYjaZ0WFqxGLcsjadPyWt3CEu50j1DqFnf/xLkZ2ssN0zxcA3vhF3SGbU9D2UcTBCnLsNdhIPAsqDz0SsUVti5md+Ote1mLND+v29bXbImc75TV75nn/ZeHO3lU6siztIOZXhu6/dYjfkMM/coxbtZ3vTwsea5rhy0oWI26hnYurxU0XDcq4Y732b2siR23nN5zksrDNbAXtYjh02kbhdEEYbiB3Zv46SqRK0GVaR7vyM3t26NqZXzDtqiFm9P+PD+dF7ZB/5553n+zUzUd3D+p2kRVptZFaxiNztmpmp6e36sXFm7T0/N7qeCRG2kHM0F1ZFRDN249srhc18zCce2eP6qZheNaXK4nKsdH3v+Wwp5/ea5r88rvODBJH7plp77WUR/3etx26mf/RF3rew0W83INTCqN/ZFE2A04IEhfPZ5m9i5JfyhpXNJ/dc4tpFIqRCrSHbmg3qu4Czf3+3ljAfMeOi9sg/49877/uJMHBEt7KF6vPfxx6pEkvRJlHGmQ97o2j+IeB2kcL/3sn6iM0f0cu0W8Bg76/GU0AXphrsex32Y2LumvJb1T0jck/ZWk251z/yfoNdPT025paamnz8NmRR9bHzSsK+11sfwy31Ur45vuYA769yz6/gNGVdw6ZVBlCatHBlXP5hl1bb6xf4qJugVhzOykc2560/Y+As8fl3S/c25f+/8HJMk5dzDoNQSe6DTIxhsXNgBpKkqdEjSHziS9sHDboIsDoCTydAMO+RMUePYz1LYm6esd//+GpLf7fPCdku6UpJ07d/bxcSibQQ4LKeKwGQD5VZQ6pagZOgHkWxmH5iN7/QSefgsDbbqx6px7WNLDUqvHs4/PQwkVpfEGAEXEHEcAWaENh6T6CTy/Ien6jv//oKRz/RUHAACkhV4JAEBe9BN4/pWkN5nZbkl1ST8v6V+kUioAAJAKeiUAAHnQc+DpnLtkZr8q6Zhay6l8zDl3OrWSAQAAAABKoa91PJ1zn5X02ZTKAgAAAAAoobFhFwAAAAAAUG4EngAAAACATBF4AgAAAAAyZc4NbmlNMzsv6cWBfSD68XpJ3xp2IZAK9mV5sC/Lg31ZHuzLcmA/lgf7cvhucM5t79440MATxWFmS8656WGXA/1jX5YH+7I82Jflwb4sB/ZjebAv84uhtgAAAACATBF4AgAAAAAyReCJIA8PuwBIDfuyPNiX5cG+LA/2ZTmwH8uDfZlTzPEEAAAAAGSKHk8AAAAAQKYIPLGBmd1tZqfN7Ctm9qiZvXbYZUI8ZvYxM3vZzL7SsW2bmX3ezL7a/vvaYZYR8QTsy0Nm9ryZfdnMPm1mE0MsImLy25cdj/2amTkze/0wyoZkgvalmf17MzvTvnb+3rDKh/gC6tibzeyEmZ0ysyUze9swy4h4zOx6M3vKzJ5rn4Mfbm+n/ZNDBJ5YZ2Y1Sf9B0rRz7s2SxiX9/HBLhQQ+LuldXdvmJX3BOfcmSV9o/x/593Ft3pefl/Rm59yPSfprSQcGXSj05OPavC9lZtdLeqeks4MuEHr2cXXtSzO7VdJ7Jf2Yc+4mSb8/hHIhuY9r83n5e5IecM7dLOm32v9H/l2SdI9z7kck3SLpV8zsR0X7J5cIPNFti6SqmW2RtFXSuSGXBzE5574o6ZWuze+V9In2vz8haXaQZUJv/Palc+5zzrlL7f+ekPSDAy8YEgs4LyXpIUn/URKJFgoiYF/+sqQF59z32895eeAFQ2IB+9JJ+nvtf18j2j+F4Jx7yTn3pfa/vyPpOUk10f7JJQJPrHPO1dW6W3tW0kuSvu2c+9xwS4U+vdE595LUqpwlvWHI5UE6flHS/xx2IdAbM3uPpLpz7tlhlwV9+2FJ/9TMnjGzPzOzfzTsAqFnd0k6ZGZfV6stxKiSgjGzXZKmJD0j2j+5ROCJde3x7++VtFvSDklXm9mHhlsqAJ3M7DfVGlr0yLDLguTMbKuk31RrKB+Kb4uka9Ua4jcn6TEzs+EWCT36ZUl3O+eul3S3pI8OuTxIwMxeJ+lxSXc55/522OWBPwJPdPpJSS84584755qSjkj6x0MuE/rzTTO7TpLafzMMrMDM7A5JPyPpg461sIrqh9S6ufesmX1NrSHTXzKzvz/UUqFX35B0xLX8paTLkkgWVUx3qNXukaRPSSK5UEGYWUWtoPMR55y3D2n/5BCBJzqdlXSLmW1t37F9h1pj5VFcT6h1MVX7788MsSzog5m9S9KvS3qPc+7isMuD3jjnVpxzb3DO7XLO7VIrcPmHzrn/N+SioTeLkvZKkpn9sKTXSPrWMAuEnp2T9M/a/94r6atDLAtiardXPyrpOefcH3Q8RPsnh4yb5uhkZg9I+oBaQ/mWJf0rL2kC8s3MHpX0E2rdbf+mpPvUahQ9JmmnWjcWfs4555foBDkSsC8PSLpK0t+0n3bCOfdvh1JAxOa3L51zH+14/GtqZRInWMm5gPPyv0n6mKSbJb0q6decc8eHVETEFLAvz0j6Q7WGT39P0r9zzp0cVhkRj5n9E0n/W9KKWiMOJOk31JrnSfsnZwg8AQAAAACZYqgtAAAAACBTBJ4AAAAAgEwReAIAAAAAMkXgCQAAAADIFIEnAAAAACBTBJ4AAAAAgEwReAIAAAAAMkXgCQAAAADI1P8H21ehH7Ha6/8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1152x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "timeline = Timeline(menu=cake_menu)\n",
    "timeline.enqueue(GenerateCustomer(0.0))\n",
    "\n",
    "Cashier(timeline)\n",
    "events = timeline.simulate(24.0 * 60.0 * 60.0)\n",
    "\n",
    "data = numpy.array(events['leave'])\n",
    "data[:,0] /= 60 * 60\n",
    "data[:,1] /= 60\n",
    "\n",
    "plt.figure(figsize=(16,4))\n",
    "plt.scatter(data[:,0], data[:,1])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Two Cashiers\n",
    "\n",
    "Run a simulation with one cashier and then two cashiers, and plot a histogram of average waiting times for both (in minutes). Bin count of the histogram is up to you!\n",
    "\n",
    "Hints:\n",
    " * You may want to investigate the `plt.axis()` method to make the two histograms have consistant scales.\n",
    " * Remember that you will get a different set of customers with each run, so some differences will be down to random chance.\n",
    "\n",
    "__(2 mark)__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total customers = 228\n",
      "Total customers = 244\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 1 cashier\n",
    "timeline = Timeline(menu=cake_menu)\n",
    "timeline.enqueue(GenerateCustomer(0.0))\n",
    "Cashier(timeline)\n",
    "events = timeline.simulate(24.0 * 60.0 * 60.0)\n",
    "data = numpy.array(events['leave'])\n",
    "data[:,0] /= 60 * 60 \n",
    "data[:,1] /= 60 \n",
    "plt.figure(figsize=(8,4))\n",
    "plt.hist(data[:,1],bins=20) \n",
    "print('Total customers = {}'.format(len(events['leave'])))\n",
    "plt.axis([0, 30, 0, 90])\n",
    "plt.xlabel('Average Waiting Times (min)')\n",
    "plt.ylabel('Customer Count')\n",
    "plt.title('Histogram of Average Waiting Times at Cake Shop with One Cashier')\n",
    "\n",
    "# 2 cashiers\n",
    "Cashier(timeline)\n",
    "Cashier(timeline)\n",
    "events2 = timeline.simulate(24.0 * 60.0 * 60.0)\n",
    "data2 = numpy.array(events2['leave'])\n",
    "data2[:,0] /= 60 * 60 \n",
    "data2[:,1] /= 60\n",
    "plt.figure(figsize=(8,4))\n",
    "plt.hist(data2[:,1],bins=20) \n",
    "print('Total customers = {}'.format(len(events2['leave'])))\n",
    "plt.axis([0, 30, 0, 90])\n",
    "plt.xlabel('Average Waiting Times (min)')\n",
    "plt.ylabel('Customer Count')\n",
    "plt.title('Histogram of Average Waiting Times at Cake Shop with Two Cashier')\n",
    "plt.show() # eliminate output array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Purchase Statistics\n",
    "\n",
    "Modify the ServeCustomer(Task) (above) to record each item purchased and when, then run a 24 hours simulation below and print out how many of every item in the menu was sold, and the takings of the cake shop. You should use the `record` method of the `Timeline` object, with the name of the event for each purchase matching the name from the menu.\n",
    "\n",
    "__(4 marks)__\n",
    " * 2 for modification of ServeCustomer(Task).\n",
    " * 2 for extracting statistics and takings from a simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of Banoffee Pie sold: 93\n",
      "number of Butterfly Cake sold: 71\n",
      "number of Caterpillar Cake sold: 55\n",
      "number of Lava Cake sold: 62\n",
      "number of Tiramisu sold: 78\n",
      "\n",
      "takings of the cake shop is: 2057.8\n"
     ]
    }
   ],
   "source": [
    "timeline = Timeline(menu=cake_menu)\n",
    "timeline.enqueue(GenerateCustomer(0.0))\n",
    "Cashier(timeline)\n",
    "events = timeline.simulate(24.0 * 60.0 * 60.0) # simulate returns a dict\n",
    "pc=numpy.array(events['purchased'])\n",
    "\n",
    "pc.reshape((len(pc)*2,1))\n",
    "num_BP = str(pc.tolist()).count('Banoffee Pie')\n",
    "num_BC = str(pc.tolist()).count('Butterfly Cake')\n",
    "num_CC = str(pc.tolist()).count('Caterpillar Cake')\n",
    "num_LC = str(pc.tolist()).count('Lava Cake')\n",
    "num_TM = str(pc.tolist()).count('Tiramisu')\n",
    "num=[num_BP,num_BC,num_CC,num_LC,num_TM]\n",
    "print(f'number of Banoffee Pie sold: {num_BP}\\nnumber of Butterfly Cake sold: {num_BC}\\nnumber of Caterpillar Cake sold: {num_CC}\\nnumber of Lava Cake sold: {num_LC}\\nnumber of Tiramisu sold: {num_TM}')\n",
    "print()\n",
    "cost=[3.80,1.00,20.00,4.20,3.50]\n",
    "takings=numpy.dot(num,cost)\n",
    "print(f'takings of the cake shop is: {takings}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Coffee Shop\n",
    "It is madness to not sell coffee. Your task is to modify the system so that the shop serves coffee. This requires that you complete the following tasks:\n",
    " * Modify the ServeCustomer(Task) (above) to respond to 'barista' menu item requests by adding them to a `brew` queue in the Timeline object as tuples of `(customer, menu item)`.\n",
    " * Adding a `Brew(Task)` class (please ignore the fact that a coffee machine does not use brewing to make coffee!).\n",
    " * Adding a `Barista` class as a staff member that watches the `brew` queue and makes each coffee as the requests arrive.\n",
    " * Run a simulation to verify it is working, with one `Barista` and two `Cashier`s.\n",
    " * Print out a scatter plot of how long it takes to serve the customers ($x$ axis should be time of day, $y$ axis how long it took to be served). Also print out how many people enter the shop (event `'arrive'`) and how many leave (event `'leave'`) to verify that all customers are served.\n",
    " \n",
    "Notes:\n",
    " * Brewing does not depend on the customer!\n",
    " * Pay attention to the calling pattern of the callback given to `timeline.watch_queue()`\n",
    "\n",
    "__(15 marks)__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Brew(Task):\n",
    "    \n",
    "    def __init__(self, timeline, barista, customer_coffee):\n",
    "        self.customer = customer_coffee[0]\n",
    "        self.coffee = customer_coffee[1]\n",
    "        self.barista = barista\n",
    "        '''\n",
    "        if numpy.random.rand() < 0.2:\n",
    "            self.delay = 2.0 # They are a regular and already know.\n",
    "        \n",
    "        else:\n",
    "            self.delay = len(timeline.menu) + numpy.random.exponential(30.0)\n",
    "        '''\n",
    "        targ=timeline.menu[self.coffee]\n",
    "        self.delay = numpy.random.uniform(targ[2][0],targ[2][1])\n",
    "\n",
    "    def time(self):\n",
    "        return self.delay\n",
    "\n",
    "\n",
    "    def depends(self):\n",
    "        yield self.barista\n",
    "\n",
    "\n",
    "    def __call__(self, timeline):\n",
    "        self.barista.after_customer(timeline)\n",
    "        self.customer.receive_item(timeline, self.coffee)\n",
    "        timeline.record(self.coffee)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Barista: \n",
    "    def __init__(self, timeline):\n",
    "        timeline.watch_queue('brew',self.handle_customer)\n",
    "    \n",
    "    \n",
    "    def handle_customer(self, timeline, customer): # same mtd as defined in other classes, so 3 inputs, 1 positional\n",
    "        task = Brew(timeline, self, customer) \n",
    "        timeline.enqueue(task)\n",
    "    \n",
    "    \n",
    "    def after_customer(self, timeline):\n",
    "        timeline.watch_queue('brew', self.handle_customer)\n",
    "\n",
    "class ServeCustomer(Task):\n",
    "    def __init__(self, timeline, cashier, customer):\n",
    "        self.cashier = cashier\n",
    "        self.customer = customer\n",
    "        self.Barista=Barista\n",
    "        \n",
    "        req = customer.to_buy()\n",
    "        self.delay = len(req) * 3.0\n",
    "        \n",
    "        self.delay += numpy.random.uniform(1.0, 40.0)\n",
    "        \n",
    "        self.grabbing = []\n",
    "        self.brewwing=[]\n",
    "        for r in req:\n",
    "            targ = timeline.menu[r]\n",
    "            if targ[1]=='grab':\n",
    "                self.delay += numpy.random.uniform(targ[2][0], targ[2][1])\n",
    "                self.grabbing.append(r)\n",
    "            elif targ[1]=='barista':\n",
    "                timeline.join_queue('brew',(self.customer, r))\n",
    "                self.brewwing.append(r)\n",
    "                timeline.record('brew',r)\n",
    "    \n",
    "    \n",
    "    def time(self):\n",
    "        return self.delay\n",
    "\n",
    "\n",
    "    def depends(self):\n",
    "        yield self.cashier\n",
    "        yield self.customer\n",
    "\n",
    "\n",
    "    def __call__(self, timeline):\n",
    "        self.cashier.after_customer(timeline)\n",
    "        for name in self.grabbing:\n",
    "            self.customer.receive_item(timeline, name)\n",
    "            timeline.record(name)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "customer arrived: 269\n",
      "customer left: 269\n"
     ]
    }
   ],
   "source": [
    "full_menu = cake_menu.copy()\n",
    "full_menu['Espresso'] = (2.00, 'barista', (10.0, 20.0))\n",
    "full_menu['Flat White'] = (2.80, 'barista', (40.0, 90.0))\n",
    "full_menu['Americano'] = (2.40, 'barista', (20.0, 30.0))\n",
    "full_menu['Latte'] = (3.20, 'barista', (60.0, 120.0))\n",
    "\n",
    "timeline = Timeline(menu=full_menu)\n",
    "timeline.enqueue(GenerateCustomer(0.0))\n",
    "Cashier(timeline)\n",
    "Cashier(timeline)\n",
    "Barista(timeline)\n",
    "events = timeline.simulate(24.0 * 60.0 * 60.0)\n",
    "data = numpy.array(events['leave'])\n",
    "data[:,0] /= 60 * 60 \n",
    "data[:,1] /= 60 \n",
    "\n",
    "plt.figure(figsize=(16,4))\n",
    "plt.scatter(data[:,0],data[:,1])\n",
    "plt.xlabel('Time (o\\'clock)')\n",
    "plt.ylabel('Service Waiting Time (min)')                          \n",
    "plt.show()\n",
    "\n",
    "\n",
    "customer_arrive=len(events['arrive'])\n",
    "customer_leave=len(events['leave'])\n",
    "print('customer arrived:',customer_arrive)\n",
    "print('customer left:',customer_leave)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Everyone wants Coffee\n",
    "\n",
    "The current purchasing pattern of a customer expressed in `ChoosePurchase(Task)` is not very realistic. You task is to modify it to obey the following rules:\n",
    " * Everyone who enters a coffee shop has a 70% chance of buying for themselves, a 30% chance of buying for a group of 2-4 people (including the customer). All group sizes (2, 3 or 4) have equal probability within their 30% bracket.\n",
    " * Coffee is always bought for every person (all members of the group).\n",
    " * There is a 50:50 chance of cake being bought; if it is then everyone in the group gets one piece of cake.\n",
    " * Which particular coffee/cake is selected independently for each person within a group.\n",
    " * The probability of each coffee is proporitional to it's price - customers prefer expensive coffee.\n",
    " * The probability of cake is inversly proportional to it's price - customers prefer cheap cake.\n",
    "\n",
    "Rerun the simulation and output:\n",
    " * A scatter plot of the time of day vs waiting time.\n",
    " * The sales quantities and takings.\n",
    "\n",
    "Hints:\n",
    " * Make sure you're recording the sale of coffee, otherwise the takings will be wrong!\n",
    " * You may want to look at the help for [`numpy.random.choice`](https://docs.scipy.org/doc/numpy-1.14.0/reference/generated/numpy.random.choice.html), paying particulat attention to the `p` keyword argument.\n",
    "\n",
    "__(5 marks)__\n",
    " * 4 marks for the modification of `ChoosePurchase(Task)`\n",
    " * 1 mark for graph and generating sales quantities and takings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ChoosePurchase(Task):\n",
    "    def __init__(self, timeline, customer):\n",
    "        self.customer = customer\n",
    "        \n",
    "        if numpy.random.rand() < 0.2:\n",
    "            self.delay = 2.0 \n",
    "        \n",
    "        else:\n",
    "            self.delay = len(timeline.menu) + numpy.random.exponential(30.0)\n",
    "\n",
    "\n",
    "    def time(self):\n",
    "        return self.delay\n",
    "\n",
    "\n",
    "    def depends(self):\n",
    "        yield self.customer\n",
    "\n",
    "\n",
    "    def __call__(self, timeline):\n",
    "        # cake list\n",
    "        cake_list=numpy.array(list(cake_menu.values())),numpy.array(list(cake_menu.keys()))\n",
    "        cake_list=numpy.array([numpy.array(cake_list[0][:,0]),numpy.array(cake_list[1][:])]).transpose()\n",
    "        cake_list=cake_list[numpy.argsort(cake_list[:,0]),:]     # price low to high\n",
    "        \n",
    "        # coffee list\n",
    "        full_list=numpy.array(list(full_menu.values())),numpy.array(list(full_menu.keys()))\n",
    "        full_list=numpy.array([numpy.array(full_list[0][:,0]),numpy.array(full_list[1][:])]).transpose()\n",
    "        full_list=full_list[numpy.argsort(full_list[:,0]),:]\n",
    "        coffee_list=[]\n",
    "        for x in full_list:\n",
    "            if x not in cake_list:\n",
    "                coffee_list.append(x)\n",
    "        coffee_list.reverse()\n",
    "        coffee_list=numpy.array(coffee_list)                    # price high to low\n",
    "        \n",
    "        group_size=numpy.random.choice([1,2,3,4],size=1,p=[0.7,0.1,0.1,0.1])\n",
    "        X=numpy.random.choice([1,0],size=1,p=[0.5,0.5])\n",
    "        if X==1:\n",
    "            cake_options=list(cake_list[:,1])\n",
    "            cake_prob0=list(numpy.divide(list(cake_list[:,0]),sum(list(cake_list[:,0]))))\n",
    "            scale=1/sum([1/_ for _ in cake_prob0])\n",
    "            cake_prob=[scale/_ for _ in cake_prob0]                                             # x/price\n",
    "            cake_buy=numpy.random.choice(cake_options,size=group_size,p=cake_prob)\n",
    "        \n",
    "        coffee_options=list(coffee_list[:,1])\n",
    "        coffee_prob=list(numpy.divide(list(coffee_list[:,0]),sum(list(coffee_list[:,0]))))\n",
    "        coffee_buy=numpy.random.choice(coffee_options,size=group_size,p=coffee_prob)\n",
    "        if X==1:\n",
    "            self.customer.go_buy(timeline, list(cake_buy)+list(coffee_buy))\n",
    "        else:\n",
    "            self.customer.go_buy(timeline, list(coffee_buy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-17-d8f7700cc705>:22: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  cake_list=numpy.array(list(cake_menu.values())),numpy.array(list(cake_menu.keys()))\n",
      "<ipython-input-17-d8f7700cc705>:27: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  full_list=numpy.array(list(full_menu.values())),numpy.array(list(full_menu.keys()))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "timeline = Timeline(menu=full_menu)\n",
    "timeline.enqueue(GenerateCustomer(0.0))\n",
    "Cashier(timeline)\n",
    "Cashier(timeline)\n",
    "Barista(timeline)\n",
    "events = timeline.simulate(24.0 * 60.0 * 60.0)\n",
    "data = numpy.array(events['leave'])\n",
    "data[:,0] /= 60 * 60\n",
    "data[:,1] /= 60 \n",
    "plt.figure(figsize=(16,4))\n",
    "plt.scatter(data[:,0],data[:,1])\n",
    "plt.xlabel('Time (o\\'clock)')\n",
    "plt.ylabel('Service Waiting Time (min)')                           \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of Espresso sold: 99\n",
      "number of Lava Cake sold: 23\n",
      "number of Flat White sold: 111\n",
      "number of Butterfly Cake sold: 114\n",
      "number of Latte sold: 118\n",
      "number of Americano sold: 89\n",
      "number of Banoffee Pie sold: 23\n",
      "number of Tiramisu sold: 30\n",
      "number of Caterpillar Cake sold: 5\n",
      "takings of the cake shop is: 1603.0\n"
     ]
    }
   ],
   "source": [
    "for r in events.keys():\n",
    "    if r in full_menu.keys():\n",
    "        num=len(events[r])\n",
    "        print(f'number of {r} sold: {num}')\n",
    "\n",
    "takings=0\n",
    "for r in events:\n",
    "    if r in full_menu:\n",
    "        num=len(events[r])\n",
    "        takings+=num*full_menu[r][0]\n",
    "print(f'takings of the cake shop is: {takings}')"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}