code/chap04mine.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modeling and Simulation in Python\n",
    "\n",
    "Chapter 4\n",
    "\n",
    "Copyright 2017 Allen Downey\n",
    "\n",
    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Configure Jupyter so figures appear in the notebook\n",
    "%matplotlib inline\n",
    "\n",
    "# Configure Jupyter to display the assigned value after an assignment\n",
    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign' \n",
    "\n",
    "# import functions from the modsim library\n",
    "from modsim import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Returning values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a simple function that returns a value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_five(x):\n",
    "    return x + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here's how we call it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = add_five(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you run a function on the last line of a cell, Jupyter displays the result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_five(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But that can be a bad habit, because usually if you call a function and don't assign the result in a variable, the result gets discarded.\n",
    "\n",
    "In the following example, Jupyter shows the second result, but the first result just disappears."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_five(3)\n",
    "add_five(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you call a function that returns a variable, it is generally a good idea to assign the result to a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 10\n"
     ]
    }
   ],
   "source": [
    "y1 = add_five(3)\n",
    "y2 = add_five(5)\n",
    "\n",
    "print(y1, y2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Write a function called `make_state` that creates a `State` object with the state variables `olin=10` and `wellesley=2`, and then returns the new `State` object.\n",
    "\n",
    "Write a line of code that calls `make_state` and assigns the result to a variable named `init`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_state():\n",
    "    state = State(olin = 10, wellesley = 2)\n",
    "    return state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         10\n",
       "wellesley     2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "init = make_state()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running simulations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the code from the previous notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def step(state, p1, p2):\n",
    "    \"\"\"Simulate one minute of time.\n",
    "    \n",
    "    state: bikeshare State object\n",
    "    p1: probability of an Olin->Wellesley customer arrival\n",
    "    p2: probability of a Wellesley->Olin customer arrival\n",
    "    \"\"\"\n",
    "    if flip(p1):\n",
    "        bike_to_wellesley(state)\n",
    "    \n",
    "    if flip(p2):\n",
    "        bike_to_olin(state)\n",
    "        \n",
    "def bike_to_wellesley(state):\n",
    "    \"\"\"Move one bike from Olin to Wellesley.\n",
    "    \n",
    "    state: bikeshare State object\n",
    "    \"\"\"\n",
    "    if state.olin == 0:\n",
    "        state.olin_empty += 1\n",
    "        return\n",
    "    state.olin -= 1\n",
    "    state.wellesley += 1\n",
    "    \n",
    "def bike_to_olin(state):\n",
    "    \"\"\"Move one bike from Wellesley to Olin.\n",
    "    \n",
    "    state: bikeshare State object\n",
    "    \"\"\"\n",
    "    if state.wellesley == 0:\n",
    "        state.wellesley_empty += 1\n",
    "        return\n",
    "    state.wellesley -= 1\n",
    "    state.olin += 1\n",
    "    \n",
    "def decorate_bikeshare():\n",
    "    \"\"\"Add a title and label the axes.\"\"\"\n",
    "    decorate(title='Olin-Wellesley Bikeshare',\n",
    "             xlabel='Time step (min)', \n",
    "             ylabel='Number of bikes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a modified version of `run_simulation` that creates a `State` object, runs the simulation, and returns the `State` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_simulation(p1, p2, num_steps):\n",
    "    \"\"\"Simulate the given number of time steps.\n",
    "    \n",
    "    p1: probability of an Olin->Wellesley customer arrival\n",
    "    p2: probability of a Wellesley->Olin customer arrival\n",
    "    num_steps: number of time steps\n",
    "    \"\"\"\n",
    "    state = State(olin=10, wellesley=2, \n",
    "                  olin_empty=0, wellesley_empty=0)\n",
    "                    \n",
    "    for i in range(num_steps):\n",
    "        step(state, p1, p2)\n",
    "        \n",
    "    return state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now `run_simulation` doesn't plot anything:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>olin_empty</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley_empty</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin                2\n",
       "wellesley          10\n",
       "olin_empty          0\n",
       "wellesley_empty     0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state = run_simulation(0.4, 0.2, 60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But after the simulation, we can read the metrics from the `State` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state.olin_empty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can run simulations with different values for the parameters.  When `p1` is small, we probably don't run out of bikes at Olin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state = run_simulation(0.2, 0.2, 60)\n",
    "state.olin_empty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When `p1` is large, we probably do."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state = run_simulation(0.6, 0.2, 60)\n",
    "state.olin_empty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More for loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`linspace` creates a NumPy array of equally spaced numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.  , 0.25, 0.5 , 0.75, 1.  ])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1_array = linspace(0, 1, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use an array in a `for` loop, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "0.25\n",
      "0.5\n",
      "0.75\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "for p1 in p1_array:\n",
    "    print(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will come in handy in the next section.\n",
    "\n",
    "`linspace` is defined in `modsim.py`.  You can get the documentation using `help`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function linspace in module modsim:\n",
      "\n",
      "linspace(start, stop, num=50, **options)\n",
      "    Returns an array of evenly-spaced values in the interval [start, stop].\n",
      "    \n",
      "    start: first value\n",
      "    stop: last value\n",
      "    num: number of values\n",
      "    \n",
      "    Also accepts the same keyword arguments as np.linspace.  See\n",
      "    https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html\n",
      "    \n",
      "    returns: array or Quantity\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(linspace)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`linspace` is based on a NumPy function with the same name.  [Click here](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html) to read more about how to use it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** \n",
    "Use `linspace` to make an array of 10 equally spaced numbers from 1 to 10 (including both)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array = linspace(1,10,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** The `modsim` library provides a related function called `linrange`.  You can view the documentation by running the following cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function linrange in module modsim:\n",
      "\n",
      "linrange(start=0, stop=None, step=1, **options)\n",
      "    Returns an array of evenly-spaced values in the interval [start, stop].\n",
      "    \n",
      "    This function works best if the space between start and stop\n",
      "    is divisible by step; otherwise the results might be surprising.\n",
      "    \n",
      "    By default, the last value in the array is `stop-step`\n",
      "    (at least approximately).\n",
      "    If you provide the keyword argument `endpoint=True`,\n",
      "    the last value in the array is `stop`.\n",
      "    \n",
      "    start: first value\n",
      "    stop: last value\n",
      "    step: space between values\n",
      "    \n",
      "    Also accepts the same keyword arguments as np.linspace.  See\n",
      "    https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html\n",
      "    \n",
      "    returns: array or Quantity\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(linrange)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `linrange` to make an array of numbers from 1 to 11 with a step size of 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 3., 5., 7., 9.])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1 = linrange(1,11,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sweeping parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`p1_array` contains a range of values for `p1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p2 = 0.2\n",
    "num_steps = 60\n",
    "p1_array = linspace(0, 1, 11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following loop runs a simulation for each value of `p1` in `p1_array`; after each simulation, it prints the number of unhappy customers at the Olin station:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0 0\n",
      "0.1 0\n",
      "0.2 0\n",
      "0.30000000000000004 0\n",
      "0.4 2\n",
      "0.5 15\n",
      "0.6000000000000001 20\n",
      "0.7000000000000001 16\n",
      "0.8 15\n",
      "0.9 33\n",
      "1.0 39\n"
     ]
    }
   ],
   "source": [
    "for p1 in p1_array:\n",
    "    state = run_simulation(p1, p2, num_steps)\n",
    "    print(p1, state.olin_empty)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can do the same thing, but storing the results in a `SweepSeries` instead of printing them.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "sweep = SweepSeries()\n",
    "\n",
    "for p1 in p1_array:\n",
    "    state = run_simulation(p1, p2, num_steps)\n",
    "    sweep[p1] = state.olin_empty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And then we can plot the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving figure to file figs/chap02-fig02.pdf\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(sweep, label='Olin')\n",
    "\n",
    "decorate(title='Olin-Wellesley Bikeshare',\n",
    "         xlabel='Arrival rate at Olin (p1 in customers/min)', \n",
    "         ylabel='Number of unhappy customers')\n",
    "\n",
    "savefig('figs/chap02-fig02.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "**Exercise:** Wrap this code in a function named `sweep_p1` that takes an array called `p1_array` as a parameter.  It should create a new `SweepSeries`, run a simulation for each value of `p1` in `p1_array`, store the results in the `SweepSeries`, and return the `SweepSeries`.\n",
    "\n",
    "Use your function to plot the number of unhappy customers at Olin as a function of `p1`.  Label the axes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sweep_p1(p1_array):\n",
    "    sweep1 = SweepSeries()\n",
    "    for i in p1_array:\n",
    "        state = run_simulation(i, p2, num_steps)\n",
    "        sweep1[i] = state.olin_empty\n",
    "    return sweep1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sweep = sweep_p1(p1_array)\n",
    "plot(sweep, label = 'olin')\n",
    "decorate(title = 'Unhappy Olin Customers', xlabel = 'Customer Arrival Rate at Olin', ylabel = 'Number of Unhappy Customers')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Write a function called `sweep_p2` that runs simulations with `p1=0.5` and a range of values for `p2`.  It should store the results in a `SweepSeries` and return the `SweepSeries`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sweep_p2():\n",
    "    p1 = 0.5\n",
    "    p2_array = linspace(0,1,11)\n",
    "    sweep = SweepSeries()\n",
    "    for i in p2_array:\n",
    "        state = run_simulation(p1, i, num_steps)\n",
    "        sweep[i]=state.wellesley_empty\n",
    "    return sweep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sweep2 = sweep_p2()\n",
    "plot (sweep2, label = 'wellesley')\n",
    "decorate(title = 'Unhappy Wellesley Customers', xlabel = 'Customer Arrival Rate at Wellesley', ylabel = 'Number of Unhappy Customers')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optional exercises\n",
    "\n",
    "The following two exercises are a little more challenging.  If you are comfortable with what you have learned so far, you should give them a try.  If you feel like you have your hands full, you might want to skip them for now.\n",
    "\n",
    "**Exercise:** Because our simulations are random, the results vary from one run to another, and the results of a parameter sweep tend to be noisy.  We can get a clearer picture of the relationship between a parameter and a metric by running multiple simulations with the same parameter and taking the average of the results.\n",
    "\n",
    "Write a function called `run_multiple_simulations` that takes as parameters `p1`, `p2`, `num_steps`, and `num_runs`.\n",
    "\n",
    "`num_runs` specifies how many times it should call `run_simulation`.\n",
    "\n",
    "After each run, it should store the total number of unhappy customers (at Olin or Wellesley) in a `TimeSeries`.  At the end, it should return the `TimeSeries`.\n",
    "\n",
    "Test your function with parameters\n",
    "\n",
    "```\n",
    "p1 = 0.3\n",
    "p2 = 0.3\n",
    "num_steps = 60\n",
    "num_runs = 10\n",
    "```\n",
    "\n",
    "Display the resulting `TimeSeries` and use the `mean` function provided by the `TimeSeries` object to compute the average number of unhappy customers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_multiple_simulations(p1, p2, num_steps, num_runs):\n",
    "    series = TimeSeries()\n",
    "   \n",
    "    #Fills the series with the total number of unhappy people corresponding to which run happened, then spits out the series\n",
    "    \n",
    "    for i in range (num_runs):\n",
    "        state = run_simulation(p1, p2, num_steps)\n",
    "        series[i] = (state.olin_empty + state.wellesley_empty)\n",
    "    return series\n",
    "\n",
    "def meancalc(seriesa):\n",
    "    \n",
    "    #calculates the mean of a series/array\n",
    "    \n",
    "    sum = 0\n",
    "    for i in seriesa:\n",
    "        sum+=i\n",
    "    mean = sum/10\n",
    "    return mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    1\n",
      "1    0\n",
      "2    7\n",
      "3    0\n",
      "4    0\n",
      "5    0\n",
      "6    3\n",
      "7    1\n",
      "8    0\n",
      "9    2\n",
      "dtype: int64 1.4\n"
     ]
    }
   ],
   "source": [
    "seriesa = run_multiple_simulations(.3,.3,60,10)\n",
    "#fills seriesa with 10 runs of 60 steps\n",
    "mean = meancalc(seriesa)\n",
    "#calculates the mean of that series\n",
    "print (seriesa,mean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:**  Continuting the previous exercise, use `run_multiple_simulations` to run simulations with a range of values for `p1` and\n",
    "\n",
    "```\n",
    "p2 = 0.3\n",
    "num_steps = 60\n",
    "num_runs = 20\n",
    "```\n",
    "\n",
    "Store the results in a `SweepSeries`, then plot the average number of unhappy customers as a function of `p1`.  Label the axes.\n",
    "\n",
    "What value of `p1` minimizes the average number of unhappy customers?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def p1check(p2, num_steps, num_runs):\n",
    "    p1Array = linspace(0,1,11) #makes an array of p1 values\n",
    "    series = SweepSeries() \n",
    "    for p1 in p1Array: #runs through p1s\n",
    "        outputSeries = run_multiple_simulations(p1,p2,num_steps,num_runs)#runs multiple simulations with each p1 value\n",
    "        mean = meancalc(outputSeries)#calculates the mean of the series\n",
    "        series[p1] = mean #fills series with p1 corresponding to mean\n",
    "    return series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "series = p1check(.3,60,20)\n",
    "plot (series, label = 'Total')\n",
    "decorate(title = 'Unhappy Customers in Bikeshare', xlabel = 'Customer Arrival Rate at Olin', ylabel = 'Number of Unhappy Customers')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}