Skip to content

Instantly share code, notes, and snippets.

@Bojne

Bojne/Pre Class Work 2.1 .ipynb

Last active January 19, 2021 05:34
Show Gist options
  • Save Bojne/2326426b58ff1c9bb0855d79324da7d8 to your computer and use it in GitHub Desktop.
Save Bojne/2326426b58ff1c9bb0855d79324da7d8 to your computer and use it in GitHub Desktop.
Download ZIP
Display the source blob
Display the rendered blob
Raw
Pre Class Work 2.1 .ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"> build a schedule-based simulation of an M/D/1 queue"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"import heapq\n",
"import numpy as np\n",
"import scipy.stats as sts\n",
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import heapq\n",
"\n",
"class Event:\n",
" '''\n",
" Store the properties of one event in the Schedule class defined below. Each\n",
" event has a time at which it needs to run, a function to call when running\n",
" the event, along with the arguments and keyword arguments to pass to that\n",
" function.\n",
" '''\n",
" def __init__(self, timestamp, function, *args, **kwargs):\n",
" self.timestamp = timestamp\n",
" self.function = function\n",
" self.args = args\n",
" self.kwargs = kwargs\n",
"\n",
" def __lt__(self, other):\n",
" '''\n",
" This overloads the less-than operator in Python. We need it so the\n",
" priority queue knows how to compare two events. We want events with\n",
" earlier (smaller) times to go first.\n",
" '''\n",
" return self.timestamp < other.timestamp\n",
"\n",
" def run(self, schedule):\n",
" '''\n",
" Run an event by calling the function with its arguments and keyword\n",
" arguments. The first argument to any event function is always the\n",
" schedule in which events are being tracked. The schedule object can be\n",
" used to add new events to the priority queue.\n",
" '''\n",
" self.function(schedule, *self.args, **self.kwargs)\n",
"\n",
"\n",
"class Schedule:\n",
" '''\n",
" Implement an event schedule using a priority queue. You can add events and\n",
" run the next event.\n",
" \n",
" The `now` attribute contains the time at which the last event was run.\n",
" '''\n",
" \n",
" def __init__(self):\n",
" self.now = 0 # Keep track of the current simulation time\n",
" self.priority_queue = [] # The priority queue of events to run\n",
" \n",
" def add_event_at(self, timestamp, function, *args, **kwargs):\n",
" # Add an event to the schedule at a particular point in time.\n",
" heapq.heappush(\n",
" self.priority_queue,\n",
" Event(timestamp, function, *args, **kwargs))\n",
" \n",
" def add_event_after(self, interval, function, *args, **kwargs):\n",
" # Add an event to the schedule after a specified time interval.\n",
" self.add_event_at(self.now + interval, function, *args, **kwargs)\n",
" \n",
" def next_event_time(self):\n",
" return self.priority_queue[0].timestamp\n",
"\n",
" def run_next_event(self):\n",
" # Get the next event from the priority queue and run it.\n",
" event = heapq.heappop(self.priority_queue)\n",
" self.now = event.timestamp\n",
" event.run(self)\n",
" \n",
" def __repr__(self):\n",
" return (\n",
" f'Schedule() at time {self.now} ' +\n",
" f'with {len(self.priority_queue)} events in the queue')\n",
" \n",
" def print_events(self):\n",
" print(repr(self))\n",
" for event in sorted(self.priority_queue):\n",
" print(f' {event.timestamp}: {event.function.__name__}')"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"\"\"\"\n",
"class Customer:\n",
" def __init__(self):\n",
"\n",
" \n",
"class Cashier:\n",
" def __init__(self):\n",
"\"\"\"\n",
"\n",
"class Queue:\n",
" def __init__(self, service_rate):\n",
" self.ppl_queue = 0 # numbers of people in the queue\n",
" self.ppl_served = 0 # if people is being served(1) or not(0)\n",
" self.service_time = 1/ service_rate # constant service time \n",
" \n",
" def add_customer(self, schedule):\n",
" self.ppl_queue += 1\n",
" if self.ppl_served < 1: \n",
" schedule.add_event_after(0, self.serve_customer)\n",
" # if the ppl_served is 0, then serve the customer immediately \n",
" \n",
" def serve_customer(self, schedule):\n",
" self.ppl_queue -= 1\n",
" self.ppl_served += 1\n",
" schedule.add_event_after(self.service_time, self.serve_finished)\n",
" # add a event \"serve_finished\" after service_time\n",
" \n",
" def serve_finished(self, schedule):\n",
" self.ppl_served -= 1\n",
" if self.ppl_queue > 0:\n",
" schedule.add_event_after(0, self.serve_customer)\n",
" # if the there's people in the queue, serve it immediately \n",
" \n",
"\n",
"class GroceryStore:\n",
" def __init__(self, service_rate, arrival_rate):\n",
" self.queue = Queue(service_rate)\n",
" self.arrival_dist = sts.expon(scale=1/arrival_rate) \n",
" # the distribution of arrival rate \n",
" \n",
" def add_customer(self, schedule):\n",
" self.queue.add_customer(schedule)\n",
" arrival_interval = self.arrival_dist.rvs()\n",
" schedule.add_event_after(arrival_interval, self.add_customer)\n",
" # add a event that pushing customer into the queue \n",
" \n",
" def run(self, schedule):\n",
" schedule.add_event_after(self.arrival_dist.rvs(), self.add_customer)\n",
" def text(schedule):\n",
" print(111)\n",
" \n",
"def run_sim(arrival_rate, service_rate, run_until):\n",
" schedule = Schedule()\n",
" grocery_store = GroceryStore(arrival_rate, service_rate)\n",
" grocery_store.run(schedule)\n",
" \n",
" while schedule.next_event_time() < run_until:\n",
" schedule.run_next_event()\n",
" return grocery_store"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n"
]
}
],
"source": [
"gs = run_sim(arrival_rate = 1, service_rate = 0.9, run_until = 100)\n",
"print(gs.queue.ppl_queue)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Run the simulation "
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Text(0.5, 0.98, 'Histogram for customers in queue. Trials = 1000. Units of Time = 100')"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"trials = 1000\n",
"queue_size = []\n",
"\n",
"for i in range(trials):\n",
" gs = run_sim(arrival_rate = 0.8, service_rate = 0.7, run_until = 100)\n",
" queue_size.append(gs.queue.ppl_queue)\n",
"\n",
" \n",
"plt.hist(queue_size,bins=[i for i in range(0,max(queue_size)+1,1)])\n",
"plt.xlabel('Numbers of Customers in Queue')\n",
"plt.ylabel('Frequency')\n",
"plt.xticks([i for i in range(0,max(queue_size)+1,1)])\n",
"plt.suptitle('Histogram for customers in queue. Trials = 1000. Units of Time = 100')"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Text(0.5, 0.98, 'Histogram for customers in queue. Trials = 1000. Units of Time = 100')"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"trials = 1000\n",
"queue_size = []\n",
"\n",
"for i in range(trials):\n",
" gs = run_sim(arrival_rate = 0.8, service_rate = 0.75, run_until = 100)\n",
" queue_size.append(gs.queue.ppl_queue)\n",
"\n",
" \n",
"plt.hist(queue_size,bins=[i for i in range(0,max(queue_size)+1,1)])\n",
"plt.xlabel('Numbers of Customers in Queue')\n",
"plt.ylabel('Frequency')\n",
"plt.xticks([i for i in range(0,max(queue_size)+1,1)])\n",
"plt.suptitle('Histogram for customers in queue. Trials = 1000. Units of Time = 100')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Reflection \n",
"In this pre class work, I used a `Queue` objects that models the behavior of the queue, a `GroceryStore` object that _inputs_ customer into the queue, and a `run_sim` function that runs the simulation. The object oriented implementation seems to work nicely, and produce the same result as we run the simulation in function-based programming. I comment on the most imporant part of the code, namely the key function and the variables. For the outcome, I make the simulation clear and the result was well annotated. I examined different arrival rate and service rate to show the difference in the plot"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.4"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment