diff --git a/code/Chap12MNeal.ipynb b/code/Chap12MNeal.ipynb
new file mode 100644
index 00000000..95aad810
--- /dev/null
+++ b/code/Chap12MNeal.ipynb
@@ -0,0 +1,2001 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 12\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": 1,
+   "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.py module\n",
+    "from modsim import *\n",
+    "\n",
+    "# import functions from the pandas.py module\n",
+    "from pandas import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Code\n",
+    "\n",
+    "Here's the code from the previous notebook that we'll need."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_system(beta, gamma):\n",
+    "    \"\"\"Make a system object for the SIR model.\n",
+    "    \n",
+    "    beta: contact rate in days\n",
+    "    gamma: recovery rate in days\n",
+    "    \n",
+    "    returns: System object\n",
+    "    \"\"\"\n",
+    "    init = State(S=89, I=1, R=0)\n",
+    "    init /= sum(init)\n",
+    "\n",
+    "    t0 = 0\n",
+    "    t_end = 7 * 14\n",
+    "\n",
+    "    return System(init=init, t0=t0, t_end=t_end,\n",
+    "                  beta=beta, gamma=gamma)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_func(state, t, system):\n",
+    "    \"\"\"Update the SIR model.\n",
+    "    \n",
+    "    state: State with variables S, I, R\n",
+    "    t: time step\n",
+    "    system: System with beta and gamma\n",
+    "    \n",
+    "    returns: State object\n",
+    "    \"\"\"\n",
+    "    s, i, r = state\n",
+    "\n",
+    "    infected = system.beta * i * s    \n",
+    "    recovered = system.gamma * i\n",
+    "    \n",
+    "    s -= infected\n",
+    "    i += infected - recovered\n",
+    "    r += recovered\n",
+    "    \n",
+    "    return State(S=s, I=i, R=r)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_results(S, I, R):\n",
+    "    \"\"\"Plot the results of a SIR model.\n",
+    "    \n",
+    "    S: TimeSeries\n",
+    "    I: TimeSeries\n",
+    "    R: TimeSeries\n",
+    "    \"\"\"\n",
+    "    plot(S, '--', color='blue', label='Susceptible')\n",
+    "    plot(I, '-', color='red', label='Infected')\n",
+    "    plot(R, ':', color='green', label='Recovered')\n",
+    "    decorate(xlabel='Time (days)',\n",
+    "             ylabel='Fraction of population')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(system, update_func):\n",
+    "    \"\"\"Runs a simulation of the system.\n",
+    "        \n",
+    "    system: System object\n",
+    "    update_func: function that updates state\n",
+    "    \n",
+    "    returns: TimeFrame\n",
+    "    \"\"\"\n",
+    "    frame = TimeFrame(columns=system.init.index)\n",
+    "    frame.row[system.t0] = system.init\n",
+    "    \n",
+    "    for t in linrange(system.t0, system.t_end):\n",
+    "        frame.row[t+1] = update_func(frame.row[t], t, system)\n",
+    "    \n",
+    "    return frame"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Metrics"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Given the results, we can compute metrics that quantify whatever we are interested in, like the total number of sick students, for example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def calc_total_infected(results):\n",
+    "    \"\"\"Fraction of population infected during the simulation.\n",
+    "    \n",
+    "    results: DataFrame with columns S, I, R\n",
+    "    \n",
+    "    returns: fraction of population\n",
+    "    \"\"\"\n",
+    "    return get_first_value(results.S) - get_last_value(results.S)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's an example.|"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.333 0.25 0.46716293183605073\n"
+     ]
+    }
+   ],
+   "source": [
+    "beta = 0.333\n",
+    "gamma = 0.25\n",
+    "system = make_system(beta, gamma)\n",
+    "\n",
+    "results = run_simulation(system, update_func)\n",
+    "print(beta, gamma, calc_total_infected(results))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** Write functions that take a `TimeFrame` object as a parameter and compute the other metrics mentioned in the book:\n",
+    "\n",
+    "1.  The fraction of students who are sick at the peak of the outbreak.\n",
+    "\n",
+    "2.  The day the outbreak peaks.\n",
+    "\n",
+    "3.  The fraction of students who are sick at the end of the semester.\n",
+    "\n",
+    "Note: Not all of these functions require the `System` object, but when you write a set of related functons, it is often convenient if they all take the same parameters.\n",
+    "\n",
+    "Hint:  If you have a `TimeSeries` called `I`, you can compute the largest value of the series like this:\n",
+    "\n",
+    "    I.max()\n",
+    "\n",
+    "And the index of the largest value like this:\n",
+    "\n",
+    "    I.idxmax()\n",
+    "\n",
+    "You can read about these functions in the `Series` [documentation](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def calc_sick_at_peak(results):\n",
+    "   \"\"\"fraction of students sick at the peak\n",
+    "   results: DataFrame with columns S, I, R\n",
+    "    \n",
+    "   returns: fraction of population\n",
+    "   \"\"\"    \n",
+    "   return max(results.I)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def calc_peak_day(results):\n",
+    "    \"\"\"days until infection peak\n",
+    "    results: DataFrame with columns S,I,R\n",
+    "    returns: day of peak infections\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    return id(max(results.I))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.333 0.25 0.043536202687592354 202743576\n"
+     ]
+    }
+   ],
+   "source": [
+    "beta = 0.333\n",
+    "gamma = 0.25\n",
+    "system = make_system(beta, gamma)\n",
+    "\n",
+    "results = run_simulation(system, update_func)\n",
+    "print(beta, gamma, calc_sick_at_peak(results), calc_peak_day(results))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### What if?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can use this model to evaluate \"what if\" scenarios.  For example, this function models the effect of immunization by moving some fraction of the population from S to R before the simulation starts."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def add_immunization(system, fraction):\n",
+    "    \"\"\"Immunize a fraction of the population.\n",
+    "    \n",
+    "    Moves the given fraction from S to R.\n",
+    "    \n",
+    "    system: System object\n",
+    "    fraction: number from 0 to 1\n",
+    "    \"\"\"\n",
+    "    system.init.S -= fraction\n",
+    "    system.init.R += fraction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's start again with the system we used in the previous sections."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "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>init</th>\n",
+       "      <td>S    0.988889\n",
+       "I    0.011111\n",
+       "R    0.000000\n",
+       "dtyp...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t0</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>98</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>beta</th>\n",
+       "      <td>0.333333</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>gamma</th>\n",
+       "      <td>0.25</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "init     S    0.988889\n",
+       "I    0.011111\n",
+       "R    0.000000\n",
+       "dtyp...\n",
+       "t0                                                       0\n",
+       "t_end                                                   98\n",
+       "beta                                              0.333333\n",
+       "gamma                                                 0.25\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tc = 3      # time between contacts in days \n",
+    "tr = 4      # recovery time in days\n",
+    "\n",
+    "beta = 1 / tc      # contact rate in per day\n",
+    "gamma = 1 / tr     # recovery rate in per day\n",
+    "\n",
+    "system = make_system(beta, gamma)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And run the model without immunization."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.468320811028781"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results = run_simulation(system, update_func)\n",
+    "calc_total_infected(results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now with 10% immunization."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.30650802853979753"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "system2 = make_system(beta, gamma)\n",
+    "add_immunization(system2, 0.1)\n",
+    "results2 = run_simulation(system2, update_func)\n",
+    "calc_total_infected(results2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "10% immunization leads to a drop in infections of 16 percentage points.\n",
+    "\n",
+    "Here's what the time series looks like for S, with and without immunization."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file figs/chap12-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(results.S, '-', label='No immunization')\n",
+    "plot(results2.S, 'g--', label='10% immunization')\n",
+    "\n",
+    "decorate(xlabel='Time (days)',\n",
+    "         ylabel='Fraction susceptible')\n",
+    "\n",
+    "savefig('figs/chap12-fig02.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can sweep through a range of values for the fraction of the population who are immunized."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0 0.468320811028781\n",
+      "0.1 0.30650802853979753\n",
+      "0.2 0.16136545700638427\n",
+      "0.30000000000000004 0.0728155898425179\n",
+      "0.4 0.03552021675299155\n",
+      "0.5 0.019688715782459176\n",
+      "0.6000000000000001 0.011622057998337987\n",
+      "0.7000000000000001 0.006838737800619332\n",
+      "0.8 0.003696496253713877\n",
+      "0.9 0.0014815326722661948\n",
+      "1.0 -0.00016121210941239666\n"
+     ]
+    }
+   ],
+   "source": [
+    "immunize_array = linspace(0, 1, 11)\n",
+    "for fraction in immunize_array:\n",
+    "    system = make_system(beta, gamma)\n",
+    "    add_immunization(system, fraction)\n",
+    "    results = run_simulation(system, update_func)\n",
+    "    print(fraction, calc_total_infected(results))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This function does the same thing and stores the results in a `Sweep` object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sweep_immunity(immunize_array):\n",
+    "    \"\"\"Sweeps a range of values for immunity.\n",
+    "    \n",
+    "    immunize_array: array of fraction immunized\n",
+    "    \n",
+    "    returns: Sweep object\n",
+    "    \"\"\"\n",
+    "    sweep = SweepSeries()\n",
+    "    \n",
+    "    for fraction in immunize_array:\n",
+    "        system = make_system(beta, gamma)\n",
+    "        add_immunization(system, fraction)\n",
+    "        results = run_simulation(system, update_func)\n",
+    "        sweep[fraction] = calc_total_infected(results)\n",
+    "        \n",
+    "    return sweep"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's how we run it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "scrolled": true
+   },
+   "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>0.00</th>\n",
+       "      <td>0.468321</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.05</th>\n",
+       "      <td>0.387288</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.10</th>\n",
+       "      <td>0.306508</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.15</th>\n",
+       "      <td>0.229234</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.20</th>\n",
+       "      <td>0.161365</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.25</th>\n",
+       "      <td>0.108791</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.30</th>\n",
+       "      <td>0.072816</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.35</th>\n",
+       "      <td>0.049938</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.40</th>\n",
+       "      <td>0.035520</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.45</th>\n",
+       "      <td>0.026121</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.50</th>\n",
+       "      <td>0.019689</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.55</th>\n",
+       "      <td>0.015072</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.60</th>\n",
+       "      <td>0.011622</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.65</th>\n",
+       "      <td>0.008956</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.70</th>\n",
+       "      <td>0.006839</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.75</th>\n",
+       "      <td>0.005119</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.80</th>\n",
+       "      <td>0.003696</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.85</th>\n",
+       "      <td>0.002500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.90</th>\n",
+       "      <td>0.001482</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.95</th>\n",
+       "      <td>0.000603</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1.00</th>\n",
+       "      <td>-0.000161</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "0.00    0.468321\n",
+       "0.05    0.387288\n",
+       "0.10    0.306508\n",
+       "0.15    0.229234\n",
+       "0.20    0.161365\n",
+       "0.25    0.108791\n",
+       "0.30    0.072816\n",
+       "0.35    0.049938\n",
+       "0.40    0.035520\n",
+       "0.45    0.026121\n",
+       "0.50    0.019689\n",
+       "0.55    0.015072\n",
+       "0.60    0.011622\n",
+       "0.65    0.008956\n",
+       "0.70    0.006839\n",
+       "0.75    0.005119\n",
+       "0.80    0.003696\n",
+       "0.85    0.002500\n",
+       "0.90    0.001482\n",
+       "0.95    0.000603\n",
+       "1.00   -0.000161\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "immunize_array = linspace(0, 1, 21)\n",
+    "infected_sweep = sweep_immunity(immunize_array)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And here's what the results look like."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file figs/chap05-fig03.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(infected_sweep)\n",
+    "\n",
+    "decorate(xlabel='Fraction immunized',\n",
+    "         ylabel='Total fraction infected',\n",
+    "         title='Fraction infected vs. immunization rate',\n",
+    "         legend=False)\n",
+    "\n",
+    "savefig('figs/chap05-fig03.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If 40% of the population is immunized, less than 4% of the population gets sick."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Logistic function"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To model the effect of a hand-washing campaign, I'll use a [generalized logistic function](https://en.wikipedia.org/wiki/Generalised_logistic_function) (GLF), which is a convenient function for modeling curves that have a generally sigmoid shape.  The parameters of the GLF correspond to various features of the curve in a way that makes it easy to find a function that has the shape you want, based on data or background information about the scenario."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def logistic(x, A=0, B=1, C=1, M=0, K=1, Q=1, nu=1):\n",
+    "    \"\"\"Computes the generalize logistic function.\n",
+    "    \n",
+    "    A: controls the lower bound\n",
+    "    B: controls the steepness of the transition \n",
+    "    C: not all that useful, AFAIK\n",
+    "    M: controls the location of the transition\n",
+    "    K: controls the upper bound\n",
+    "    Q: shift the transition left or right\n",
+    "    nu: affects the symmetry of the transition\n",
+    "    \n",
+    "    returns: float or array\n",
+    "    \"\"\"\n",
+    "    exponent = -B * (x - M)\n",
+    "    denom = C + Q * exp(exponent)\n",
+    "    return A + (K-A) / denom ** (1/nu)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following array represents the range of possible spending."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([   0.,   60.,  120.,  180.,  240.,  300.,  360.,  420.,  480.,\n",
+       "        540.,  600.,  660.,  720.,  780.,  840.,  900.,  960., 1020.,\n",
+       "       1080., 1140., 1200.])"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "spending = linspace(0, 1200, 21)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`compute_factor` computes the reduction in `beta` for a given level of campaign spending.\n",
+    "\n",
+    "`M` is chosen so the transition happens around \\$500.\n",
+    "\n",
+    "`K` is the maximum reduction in `beta`, 20%.\n",
+    "\n",
+    "`B` is chosen by trial and error to yield a curve that seems feasible."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_factor(spending):\n",
+    "    \"\"\"Reduction factor as a function of spending.\n",
+    "    \n",
+    "    spending: dollars from 0 to 1200\n",
+    "    \n",
+    "    returns: fractional reduction in beta\n",
+    "    \"\"\"\n",
+    "    return logistic(spending, M=500, K=0.2, B=0.01)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's what it looks like."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file figs/chap05-fig04.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "percent_reduction = compute_factor(spending) * 100\n",
+    "\n",
+    "plot(spending, percent_reduction)\n",
+    "\n",
+    "decorate(xlabel='Hand-washing campaign spending (USD)',\n",
+    "         ylabel='Percent reduction in infection rate',\n",
+    "         title='Effect of hand washing on infection rate',\n",
+    "         legend=False)\n",
+    "\n",
+    "savefig('figs/chap05-fig04.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** Modify the parameters `M`, `K`, and `B`, and see what effect they have on the shape of the curve.  Read about the [generalized logistic function on Wikipedia](https://en.wikipedia.org/wiki/Generalised_logistic_function).  Modify the other parameters and see what effect they have."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_factor(spending):\n",
+    "    \"\"\"Reduction factor as a function of spending.\n",
+    "    \n",
+    "    spending: dollars from 0 to 1200\n",
+    "    \n",
+    "    returns: fractional reduction in beta\n",
+    "    \"\"\"\n",
+    "    return logistic(spending, M=700, K=0.2, B=0.01)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's what it looks like."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 106,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file figs/chap12-figEx01d.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "percent_reduction = compute_factor(spending) * 100\n",
+    "\n",
+    "plot(spending, percent_reduction)\n",
+    "\n",
+    "decorate(xlabel='Hand-washing campaign spending (USD)',\n",
+    "         ylabel='Percent reduction in infection rate',\n",
+    "         title='M=700, K=0.2, B=0.01',\n",
+    "         legend=False)\n",
+    "\n",
+    "savefig('figs/chap12-figEx01d.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Hand washing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can model the effect of a hand-washing campaign by modifying `beta`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 107,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def add_hand_washing(system, spending):\n",
+    "    \"\"\"Modifies system to model the effect of hand washing.\n",
+    "    \n",
+    "    system: System object\n",
+    "    spending: campaign spending in USD\n",
+    "    \"\"\"\n",
+    "    factor = compute_factor(spending)\n",
+    "    system.beta *= (1 - factor)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's start with the same values of `beta` and `gamma` we've been using."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 108,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.3333333333333333, 0.25)"
+      ]
+     },
+     "execution_count": 108,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tc = 3      # time between contacts in days \n",
+    "tr = 4      # recovery time in days\n",
+    "\n",
+    "beta = 1 / tc      # contact rate in per day\n",
+    "gamma = 1 / tr     # recovery rate in per day\n",
+    "\n",
+    "beta, gamma"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can sweep different levels of campaign spending."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 109,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0 0.33327259658703995 0.4681100560261888\n",
+      "100.0 0.33316849178955765 0.4677485845062037\n",
+      "200.0 0.3328871432717143 0.4667702312363652\n",
+      "300.0 0.3321342526691939 0.46414165040064037\n",
+      "400.0 0.33017160845482885 0.4572170063132055\n",
+      "500.0 0.32538647186519215 0.4398872029120663\n",
+      "600.0 0.3154039052420003 0.40163064627138245\n",
+      "700.0 0.3 0.3370342594898199\n",
+      "800.0 0.28459609475799963 0.26731703056804546\n",
+      "900.0 0.2746135281348078 0.22184699045990752\n",
+      "1000.0 0.26982839154517113 0.20079159841614402\n",
+      "1100.0 0.2678657473308061 0.1923921833925878\n",
+      "1200.0 0.26711285672828566 0.18921320781833872\n"
+     ]
+    }
+   ],
+   "source": [
+    "spending_array = linspace(0, 1200, 13)\n",
+    "\n",
+    "for spending in spending_array:\n",
+    "    system = make_system(beta, gamma)\n",
+    "    add_hand_washing(system, spending)\n",
+    "    results = run_simulation(system, update_func)\n",
+    "    print(spending, system.beta, calc_total_infected(results))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's a function that sweeps a range of spending and stores the results in a `SweepSeries`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 110,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sweep_hand_washing(spending_array):\n",
+    "    \"\"\"Run simulations with a range of spending.\n",
+    "    \n",
+    "    spending_array: array of dollars from 0 to 1200\n",
+    "    \n",
+    "    returns: Sweep object\n",
+    "    \"\"\"\n",
+    "    sweep = SweepSeries()\n",
+    "    \n",
+    "    for spending in spending_array:\n",
+    "        system = make_system(beta, gamma)\n",
+    "        add_hand_washing(system, spending)\n",
+    "        results = run_simulation(system, update_func)\n",
+    "        sweep[spending] = calc_total_infected(results)\n",
+    "        \n",
+    "    return sweep"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's how we run it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 111,
+   "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>0.000000</th>\n",
+       "      <td>0.468110</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>63.157895</th>\n",
+       "      <td>0.467925</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>126.315789</th>\n",
+       "      <td>0.467577</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>189.473684</th>\n",
+       "      <td>0.466924</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>252.631579</th>\n",
+       "      <td>0.465705</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>315.789474</th>\n",
+       "      <td>0.463438</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>378.947368</th>\n",
+       "      <td>0.459264</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>442.105263</th>\n",
+       "      <td>0.451714</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>505.263158</th>\n",
+       "      <td>0.438499</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>568.421053</th>\n",
+       "      <td>0.416642</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>631.578947</th>\n",
+       "      <td>0.383747</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>694.736842</th>\n",
+       "      <td>0.340880</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>757.894737</th>\n",
+       "      <td>0.294901</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>821.052632</th>\n",
+       "      <td>0.255272</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>884.210526</th>\n",
+       "      <td>0.227110</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>947.368421</th>\n",
+       "      <td>0.209589</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1010.526316</th>\n",
+       "      <td>0.199488</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1073.684211</th>\n",
+       "      <td>0.193889</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1136.842105</th>\n",
+       "      <td>0.190848</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1200.000000</th>\n",
+       "      <td>0.189213</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "0.000000       0.468110\n",
+       "63.157895      0.467925\n",
+       "126.315789     0.467577\n",
+       "189.473684     0.466924\n",
+       "252.631579     0.465705\n",
+       "315.789474     0.463438\n",
+       "378.947368     0.459264\n",
+       "442.105263     0.451714\n",
+       "505.263158     0.438499\n",
+       "568.421053     0.416642\n",
+       "631.578947     0.383747\n",
+       "694.736842     0.340880\n",
+       "757.894737     0.294901\n",
+       "821.052632     0.255272\n",
+       "884.210526     0.227110\n",
+       "947.368421     0.209589\n",
+       "1010.526316    0.199488\n",
+       "1073.684211    0.193889\n",
+       "1136.842105    0.190848\n",
+       "1200.000000    0.189213\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 111,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "spending_array = linspace(0, 1200, 20)\n",
+    "infected_sweep = sweep_hand_washing(spending_array)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And here's what it looks like."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 112,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file figs/chap05-fig05.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(infected_sweep)\n",
+    "\n",
+    "decorate(xlabel='Hand-washing campaign spending (USD)',\n",
+    "         ylabel='Total fraction infected',\n",
+    "         title='Effect of hand washing on total infections',\n",
+    "         legend=False)\n",
+    "\n",
+    "savefig('figs/chap05-fig05.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's put it all together to make some public health spending decisions."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Optimization"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Suppose we have \\$1200 to spend on any combination of vaccines and a hand-washing campaign."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 113,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "12"
+      ]
+     },
+     "execution_count": 113,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "num_students = 90\n",
+    "budget = 1200\n",
+    "price_per_dose = 100\n",
+    "max_doses = int(budget / price_per_dose)\n",
+    "dose_array = linrange(max_doses, endpoint=True)\n",
+    "max_doses"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can sweep through a range of doses from, 0 to `max_doses`, model the effects of immunization and the hand-washing campaign, and run simulations.\n",
+    "\n",
+    "For each scenario, we compute the fraction of students who get sick."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 114,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0 0.9888888888888889 0.26711285672828566 0.18921320781833872\n",
+      "1.0 0.9777777777777779 0.2678657473308061 0.18921320781833872\n",
+      "2.0 0.9666666666666667 0.26982839154517113 0.18921320781833872\n",
+      "3.0 0.9555555555555556 0.2746135281348078 0.18921320781833872\n",
+      "4.0 0.9444444444444445 0.28459609475799963 0.18921320781833872\n",
+      "5.0 0.9333333333333333 0.3 0.18921320781833872\n",
+      "6.0 0.9222222222222223 0.3154039052420003 0.18921320781833872\n",
+      "7.0 0.9111111111111112 0.32538647186519215 0.18921320781833872\n",
+      "8.0 0.9 0.33017160845482885 0.18921320781833872\n",
+      "9.0 0.888888888888889 0.3321342526691939 0.18921320781833872\n",
+      "10.0 0.8777777777777778 0.3328871432717143 0.18921320781833872\n",
+      "11.0 0.8666666666666667 0.33316849178955765 0.18921320781833872\n",
+      "12.0 0.8555555555555556 0.33327259658703995 0.18921320781833872\n"
+     ]
+    }
+   ],
+   "source": [
+    "for doses in dose_array:\n",
+    "    fraction = doses / num_students\n",
+    "    spending = budget - doses * price_per_dose\n",
+    "    \n",
+    "    system = make_system(beta, gamma)\n",
+    "    add_immunization(system, fraction)\n",
+    "    add_hand_washing(system, spending)\n",
+    "    \n",
+    "    results, run_simulation(system, update_func)\n",
+    "    print(doses, system.init.S, system.beta, calc_total_infected(results))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following function wraps that loop and stores the results in a `Sweep` object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 115,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sweep_doses(dose_array):\n",
+    "    \"\"\"Runs simulations with different doses and campaign spending.\n",
+    "    \n",
+    "    dose_array: range of values for number of vaccinations\n",
+    "    \n",
+    "    return: Sweep object with total number of infections \n",
+    "    \"\"\"\n",
+    "    sweep = SweepSeries()\n",
+    "    \n",
+    "    for doses in dose_array:\n",
+    "        fraction = doses / num_students\n",
+    "        spending = budget - doses * price_per_dose\n",
+    "        \n",
+    "        system = make_system(beta, gamma)\n",
+    "        add_immunization(system, fraction)\n",
+    "        add_hand_washing(system, spending)\n",
+    "        \n",
+    "        results = run_simulation(system, update_func)\n",
+    "        sweep[doses] = calc_total_infected(results)\n",
+    "\n",
+    "    return sweep"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can compute the number of infected students for each possible allocation of the budget."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 116,
+   "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>0</th>\n",
+       "      <td>0.189213</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.178696</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0.173206</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0.178367</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0.203327</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>0.249700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>0.293692</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>0.313633</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>0.313140</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>0.302323</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>0.287325</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>0.270874</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>0.254080</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "0     0.189213\n",
+       "1     0.178696\n",
+       "2     0.173206\n",
+       "3     0.178367\n",
+       "4     0.203327\n",
+       "5     0.249700\n",
+       "6     0.293692\n",
+       "7     0.313633\n",
+       "8     0.313140\n",
+       "9     0.302323\n",
+       "10    0.287325\n",
+       "11    0.270874\n",
+       "12    0.254080\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 116,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "infected_sweep = sweep_doses(dose_array)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And plot the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 118,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file figs/chap12-fig06.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(infected_sweep)\n",
+    "\n",
+    "decorate(xlabel='Doses of vaccine',\n",
+    "         ylabel='Total fraction infected',\n",
+    "         title='Total infections vs. doses',\n",
+    "         legend=False)\n",
+    "\n",
+    "savefig('figs/chap12-fig06.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercises\n",
+    "\n",
+    "**Exercise:** Suppose the price of the vaccine drops to $50 per dose.  How does that affect the optimal allocation of the spending?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 119,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0 0.9888888888888889 0.26711285672828566 0.18921320781833872\n",
+      "1.0 0.9777777777777779 0.2673991295087062 0.18921320781833872\n",
+      "2.0 0.9666666666666667 0.2678657473308061 0.18921320781833872\n",
+      "3.0 0.9555555555555556 0.26862081538342375 0.18921320781833872\n",
+      "4.0 0.9444444444444445 0.26982839154517113 0.18921320781833872\n",
+      "5.0 0.9333333333333333 0.2717238786680829 0.18921320781833872\n",
+      "6.0 0.9222222222222223 0.2746135281348078 0.18921320781833872\n",
+      "7.0 0.9111111111111112 0.27882836825375706 0.18921320781833872\n",
+      "8.0 0.9 0.28459609475799963 0.18921320781833872\n",
+      "9.0 0.888888888888889 0.291836044586543 0.18921320781833872\n",
+      "10.0 0.8777777777777778 0.3 0.18921320781833872\n",
+      "11.0 0.8666666666666667 0.308163955413457 0.18921320781833872\n",
+      "12.0 0.8555555555555556 0.3154039052420003 0.18921320781833872\n",
+      "Saving figure to file figs/chap12-figEx02.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "price_per_dose = 50\n",
+    "\n",
+    "for doses in dose_array:\n",
+    "    fraction = doses / num_students\n",
+    "    spending = budget - doses * price_per_dose\n",
+    "    \n",
+    "    system = make_system(beta, gamma)\n",
+    "    add_immunization(system, fraction)\n",
+    "    add_hand_washing(system, spending)\n",
+    "    \n",
+    "    results, run_simulation(system, update_func)\n",
+    "    print(doses, system.init.S, system.beta, calc_total_infected(results))\n",
+    "    \n",
+    "infected_sweep = sweep_doses(dose_array)\n",
+    "\n",
+    "plot(infected_sweep)\n",
+    "\n",
+    "decorate(xlabel='Doses of vaccine',\n",
+    "         ylabel='Total fraction infected',\n",
+    "         title='Total infections vs. doses',\n",
+    "         legend=False)\n",
+    "\n",
+    "savefig('figs/chap12-figEx02.pdf')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "At $50/dose, the optimal strategy is to provide 6 doses and spend the rest ($900) on the campaign. Now there are 14 infected students rather than the 17 when doses are $100 ea. There is still no herd immunity effect. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** Suppose we have the option to quarantine infected students.  For example, a student who feels ill might be moved to an infirmary, or a private dorm room, until they are no longer infectious.\n",
+    "\n",
+    "How might you incorporate the effect of quarantine in the SIR model?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This would move individuals from I to R in less than 4 days, in other words gamma would increase. Some assumptions would have to be made as to how efficiently diagnosis could be done and whether there are facilities to quarantine all infected students. If one assumes a sick student is diagnosed and quarantined 1 day after becoming infectious on average, the the effective recovery time is 1 day and gamma is 1 day^-1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 122,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0 0.9888888888888889 0.26711285672828566 0.18921320781833872\n",
+      "1.0 0.9777777777777779 0.2678657473308061 0.18921320781833872\n",
+      "2.0 0.9666666666666667 0.26982839154517113 0.18921320781833872\n",
+      "3.0 0.9555555555555556 0.2746135281348078 0.18921320781833872\n",
+      "4.0 0.9444444444444445 0.28459609475799963 0.18921320781833872\n",
+      "5.0 0.9333333333333333 0.3 0.18921320781833872\n",
+      "6.0 0.9222222222222223 0.3154039052420003 0.18921320781833872\n",
+      "7.0 0.9111111111111112 0.32538647186519215 0.18921320781833872\n",
+      "8.0 0.9 0.33017160845482885 0.18921320781833872\n",
+      "9.0 0.888888888888889 0.3321342526691939 0.18921320781833872\n",
+      "10.0 0.8777777777777778 0.3328871432717143 0.18921320781833872\n",
+      "11.0 0.8666666666666667 0.33316849178955765 0.18921320781833872\n",
+      "12.0 0.8555555555555556 0.33327259658703995 0.18921320781833872\n",
+      "Saving figure to file figs/chap12-figEx03a.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "gamma = 1.00\n",
+    "price_per_dose = 100\n",
+    "\n",
+    "for doses in dose_array:\n",
+    "    fraction = doses / num_students\n",
+    "    spending = budget - doses * price_per_dose\n",
+    "    \n",
+    "    system = make_system(beta, gamma)\n",
+    "    add_immunization(system, fraction)\n",
+    "    add_hand_washing(system, spending)\n",
+    "    \n",
+    "    results, run_simulation(system, update_func)\n",
+    "    print(doses, system.init.S, system.beta, calc_total_infected(results))\n",
+    "    \n",
+    "infected_sweep = sweep_doses(dose_array)\n",
+    "\n",
+    "plot(infected_sweep)\n",
+    "\n",
+    "decorate(xlabel='Doses of vaccine',\n",
+    "         ylabel='Total fraction infected',\n",
+    "         title='Total infections vs. doses',\n",
+    "         legend=False)\n",
+    "\n",
+    "savefig('figs/chap12-figEx03a.pdf')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 121,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0 0.9888888888888889 0.26711285672828566 0.18921320781833872\n",
+      "1.0 0.9777777777777779 0.2678657473308061 0.18921320781833872\n",
+      "2.0 0.9666666666666667 0.26982839154517113 0.18921320781833872\n",
+      "3.0 0.9555555555555556 0.2746135281348078 0.18921320781833872\n",
+      "4.0 0.9444444444444445 0.28459609475799963 0.18921320781833872\n",
+      "5.0 0.9333333333333333 0.3 0.18921320781833872\n",
+      "6.0 0.9222222222222223 0.3154039052420003 0.18921320781833872\n",
+      "7.0 0.9111111111111112 0.32538647186519215 0.18921320781833872\n",
+      "8.0 0.9 0.33017160845482885 0.18921320781833872\n",
+      "9.0 0.888888888888889 0.3321342526691939 0.18921320781833872\n",
+      "10.0 0.8777777777777778 0.3328871432717143 0.18921320781833872\n",
+      "11.0 0.8666666666666667 0.33316849178955765 0.18921320781833872\n",
+      "12.0 0.8555555555555556 0.33327259658703995 0.18921320781833872\n",
+      "Saving figure to file figs/chap12-figEx03.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "gamma = 0.50\n",
+    "price_per_dose = 100\n",
+    "\n",
+    "for doses in dose_array:\n",
+    "    fraction = doses / num_students\n",
+    "    spending = budget - doses * price_per_dose\n",
+    "    \n",
+    "    system = make_system(beta, gamma)\n",
+    "    add_immunization(system, fraction)\n",
+    "    add_hand_washing(system, spending)\n",
+    "    \n",
+    "    results, run_simulation(system, update_func)\n",
+    "    print(doses, system.init.S, system.beta, calc_total_infected(results))\n",
+    "    \n",
+    "infected_sweep = sweep_doses(dose_array)\n",
+    "\n",
+    "plot(infected_sweep)\n",
+    "\n",
+    "decorate(xlabel='Doses of vaccine',\n",
+    "         ylabel='Total fraction infected',\n",
+    "         title='Total infections vs. doses',\n",
+    "         legend=False)\n",
+    "\n",
+    "savefig('figs/chap12-figEx03b.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For quarantines within 1 day, the infection does not spread at all (assuming patient zero is quarantined). Strictly speaking the model breaks down here as total fraction infected is always well below 1. In this case there is no benefit to vaccination or campaign. A better model may be to assume the quarantine does not go into effect for a few days, so that gamma changes from 0.25 to on a certain day, maybe the day when I+R = 4.\n",
+    "\n",
+    "For quarntines within 2 days, gamma is 0.5. This data also suggests the infection does not spread beyond patient zero. \n",
+    "\n",
+    "This is all assuming the $1200 is spent anyway. The model should be run again with different gamma and no spending."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 123,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.333 1.0 0.005444246402198316\n"
+     ]
+    }
+   ],
+   "source": [
+    "beta = 0.333\n",
+    "gamma = 1.0\n",
+    "system = make_system(beta, gamma)\n",
+    "\n",
+    "results = run_simulation(system, update_func)\n",
+    "print(beta, gamma, calc_total_infected(results))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 124,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.333 0.5 0.02084488550513308\n"
+     ]
+    }
+   ],
+   "source": [
+    "beta = 0.333\n",
+    "gamma = 0.5\n",
+    "system = make_system(beta, gamma)\n",
+    "\n",
+    "results = run_simulation(system, update_func)\n",
+    "print(beta, gamma, calc_total_infected(results))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 127,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.333 0.33 0.13792154260074818\n"
+     ]
+    }
+   ],
+   "source": [
+    "beta = 0.333\n",
+    "gamma = 0.33\n",
+    "system = make_system(beta, gamma)\n",
+    "\n",
+    "results = run_simulation(system, update_func)\n",
+    "print(beta, gamma, calc_total_infected(results))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "1-d quarantine model suggests no additional infections. 2-d quarantine model suggest 1 additional infection. 3-d still quite effective, 12 additional infections as compared to 46 with no quarantine.\n",
+    "\n",
+    "So what about 3-d and spending? Figure Ex03c below shows the best use of the $1200 is 2 vaccinations and $1000 on hte hand wshing campaign. Now there are only 3 additional infectios."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 129,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0 0.9888888888888889 0.2668457438715574 0.13792154260074818\n",
+      "1.0 0.9777777777777779 0.2675978815834753 0.13792154260074818\n",
+      "2.0 0.9666666666666667 0.269558563153626 0.13792154260074818\n",
+      "3.0 0.9555555555555556 0.27433891460667303 0.13792154260074818\n",
+      "4.0 0.9444444444444445 0.2843114986632417 0.13792154260074818\n",
+      "5.0 0.9333333333333333 0.2997 0.13792154260074818\n",
+      "6.0 0.9222222222222223 0.3150885013367583 0.13792154260074818\n",
+      "7.0 0.9111111111111112 0.325061085393327 0.13792154260074818\n",
+      "8.0 0.9 0.32984143684637407 0.13792154260074818\n",
+      "9.0 0.888888888888889 0.33180211841652474 0.13792154260074818\n",
+      "10.0 0.8777777777777778 0.33255425612844264 0.13792154260074818\n",
+      "11.0 0.8666666666666667 0.33283532329776816 0.13792154260074818\n",
+      "12.0 0.8555555555555556 0.33293932399045295 0.13792154260074818\n",
+      "Saving figure to file figs/chap12-figEx03c.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "gamma = 0.333\n",
+    "\n",
+    "\n",
+    "for doses in dose_array:\n",
+    "    fraction = doses / num_students\n",
+    "    spending = budget - doses * price_per_dose\n",
+    "    \n",
+    "    system = make_system(beta, gamma)\n",
+    "    add_immunization(system, fraction)\n",
+    "    add_hand_washing(system, spending)\n",
+    "    \n",
+    "    results, run_simulation(system, update_func)\n",
+    "    print(doses, system.init.S, system.beta, calc_total_infected(results))\n",
+    "    \n",
+    "infected_sweep = sweep_doses(dose_array)\n",
+    "\n",
+    "plot(infected_sweep)\n",
+    "\n",
+    "decorate(xlabel='Doses of vaccine',\n",
+    "         ylabel='Total fraction infected',\n",
+    "         title='Total infections vs. doses',\n",
+    "         legend=False)\n",
+    "\n",
+    "savefig('figs/chap12-figEx03c.pdf')"
+   ]
+  },
+  {
+   "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap01mneal.ipynb b/code/chap01mneal.ipynb
new file mode 100644
index 00000000..ad79fb35
--- /dev/null
+++ b/code/chap01mneal.ipynb
@@ -0,0 +1,564 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 1\n",
+    "\n",
+    "Copyright 2017 Allen Downey\n",
+    "\n",
+    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Jupyter\n",
+    "\n",
+    "Welcome to Modeling and Simulation, welcome to Python, and welcome to Jupyter.\n",
+    "\n",
+    "This is a Jupyter notebook, which is a development environment where you can write and run Python code.  Each notebook is divided into cells.  Each cell contains either text (like this cell) or Python code (like the cell below this one).\n",
+    "\n",
+    "### Selecting and running cells\n",
+    "\n",
+    "To select a cell, click in the left margin next to the cell.  You should see a blue frame surrounding the selected cell.\n",
+    "\n",
+    "To edit a code cell, click inside the cell.  You should see a green frame around the selected cell, and you should see a cursor inside the cell.\n",
+    "\n",
+    "To edit a text cell, triple-click inside the cell.  Again, you should see a green frame around the selected cell, and you should see a cursor inside the cell.\n",
+    "\n",
+    "To run a cell, hold down SHIFT and press ENTER.  \n",
+    "\n",
+    "* If you run a text cell, Jupyter typesets the text and displays the result.\n",
+    "\n",
+    "* If you run a code cell, it runs the Python code in the cell and displays the result, if any.\n",
+    "\n",
+    "To try it out, edit this cell, change some of the text, and then press SHIFT-ENTER to run it. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Adding and removing cells\n",
+    "\n",
+    "You can add and remove cells from a notebook using the buttons in the toolbar and the items in the menu, both of which you should see at the top of this notebook.\n",
+    "\n",
+    "Try the following exercises:\n",
+    "\n",
+    "1.  From the Insert menu select \"Insert cell below\" to add a cell below this one.  By default, you get a code cell, as you can see in the pulldown menu that says \"Code\".\n",
+    "\n",
+    "2.  In the new cell, add a print statement like `print('Hello')`, and run it.\n",
+    "\n",
+    "3.  Add another cell, select the new cell, and then click on the pulldown menu that says \"Code\" and select \"Markdown\".  This makes the new cell a text cell.\n",
+    "\n",
+    "4.  In the new cell, type some text, and then run it.\n",
+    "\n",
+    "5.  Use the arrow buttons in the toolbar to move cells up and down.\n",
+    "\n",
+    "6.  Use the cut, copy, and paste buttons to delete, add, and move cells.\n",
+    "\n",
+    "7.  As you make changes, Jupyter saves your notebook automatically, but if you want to make sure, you can press the save button, which looks like a floppy disk from the 1990s.\n",
+    "\n",
+    "8.  Finally, when you are done with a notebook, select \"Close and Halt\" from the File menu."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hi there!\n"
+     ]
+    }
+   ],
+   "source": [
+    "print ('Hi there!')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When code is written, code is run"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Using the notebooks\n",
+    "\n",
+    "The notebooks for each chapter contain the code from the chapter along with addition examples, explanatory text, and exercises.  I recommend you \n",
+    "\n",
+    "1. Read the chapter first to understand the concepts and vocabulary, \n",
+    "2. Run the notebook to review what you learned and see it in action, and then\n",
+    "3. Attempt the exercises.\n",
+    "\n",
+    "If you try to work through the notebooks without reading the book, you're gonna have a bad time.  The notebooks contain some explanatory text, but it is probably not enough to make sense if you have not read the book.  If you are working through a notebook and you get stuck, you might want to re-read (or read!) the corresponding section of the book."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Importing modsim\n",
+    "\n",
+    "The following cell imports `modsim`, which is a collection of functions we will use throughout the book.  Whenever you start the notebook, you will have to run the following cell.  It does two things:\n",
+    "\n",
+    "1.  It uses a Jupyter \"magic command\" to specify whether figures should appear in the notebook, or pop up in a new window.\n",
+    "\n",
+    "2.  It imports everything defined in `modsim`.\n",
+    "\n",
+    "Select the following cell and press SHIFT-ENTER to run it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "If this cell runs successfully, it produces no output other than this message.\n"
+     ]
+    }
+   ],
+   "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 *\n",
+    "\n",
+    "print('If this cell runs successfully, it produces no output other than this message.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The first time you run this on a new installation of Python, it might produce a warning message in pink.  That's probably ok, but if you get a message that says `modsim.py depends on Python 3.6 features`, that means you have an older version of Python, and some features in `modsim.py` won't work correctly.\n",
+    "\n",
+    "If you need a newer version of Python, I recommend installing Anaconda.  You'll find more information in the preface of the book."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The penny myth\n",
+    "\n",
+    "The following cells contain code from the beginning of Chapter 1.\n",
+    "\n",
+    "`modsim` defines `UNITS`, which contains variables representing pretty much every unit you've ever heard of.  It uses [Pint](https://pint.readthedocs.io/en/latest/), which is a Python library that provides tools for computing with units.\n",
+    "\n",
+    "The following lines create new variables named `meter` and `second`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "meter"
+      ],
+      "text/latex": [
+       "$meter$"
+      ],
+      "text/plain": [
+       "<Unit('meter')>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "meter = UNITS.meter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "second"
+      ],
+      "text/latex": [
+       "$second$"
+      ],
+      "text/plain": [
+       "<Unit('second')>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "second = UNITS.second"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To find out what other units are defined, type `UNITS.` (including the period) in the next cell and then press TAB.  You should see a pop-up menu with a list of units."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "SyntaxError",
+     "evalue": "invalid syntax (<ipython-input-4-becb8d4ff127>, line 1)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-4-becb8d4ff127>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    UNITS.\u001b[0m\n\u001b[1;37m          ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
+     ]
+    }
+   ],
+   "source": [
+    "UNITS."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create a variable named `a` and give it the value of acceleration due to gravity."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = 9.8 * meter / second**2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true
+   },
+   "source": [
+    "Create `t` and give it the value 4 seconds."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t = 4 * second"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true
+   },
+   "source": [
+    "Compute the distance a penny would fall after `t` seconds with constant acceleration `a`.  Notice that the units of the result are correct."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a * t**2 / 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise**: Compute the velocity of the penny after `t` seconds.  Check that the units of the result are correct."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t * a"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise**: Why would it be nonsensical to add `a` and `t`? It's like adding apples and oranges. What happens if you try? You get orples and apanges."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a + t"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The error messages you get from Python are big and scary, but if you read them carefully, they contain a lot of useful information.\n",
+    "\n",
+    "1.  Start from the bottom and read up.\n",
+    "2.  The last line usually tells you what type of error happened, and sometimes additional information.\n",
+    "3.  The previous lines are a \"traceback\" of what was happening when the error occurred.  The first section of the traceback shows the code you wrote.  The following sections are often from Python libraries.\n",
+    "\n",
+    "In this example, you should get a `DimensionalityError`, which is defined by Pint to indicate that you have violated a rules of dimensional analysis: you cannot add quantities with different dimensions."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true
+   },
+   "source": [
+    "## Falling pennies\n",
+    "\n",
+    "Now let's solve the falling penny problem.\n",
+    "\n",
+    "Set `h` to the height of the Empire State Building:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "h = 381 * meter"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Compute the time it would take a penny to fall, assuming constant acceleration.\n",
+    "\n",
+    "$ a t^2 / 2 = h $\n",
+    "\n",
+    "$ t = \\sqrt{2 h / a}$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t = sqrt(2 * h / a)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true
+   },
+   "source": [
+    "Given `t`, we can compute the velocity of the penny when it lands.\n",
+    "\n",
+    "$v = a t$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "v = a * t\n",
+    "v"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true
+   },
+   "source": [
+    "We can convert from one set of units to another like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mile = UNITS.mile\n",
+    "hour= UNITS.hour"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "v.to(mile/hour)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "foot = UNITS.foot\n",
+    "pole_height = 10 * foot"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** Suppose you bring a 10 foot pole to the top of the Empire State Building and use it to drop the penny from `h` plus 10 feet.\n",
+    "\n",
+    "Define a variable named `foot` that contains the unit `foot` provided by `UNITS`.  Define a variable named `pole_height` and give it the value 10 feet.\n",
+    "\n",
+    "What happens if you add `h`, which is in units of meters, to `pole_height`, which is in units of feet?  What happens if you write the addition the other way around?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pole_height + h"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** In reality, air resistance limits the velocity of the penny.  At about 18 meters per second, the force of air resistance equals the force of gravity and the penny stops accelerating.\n",
+    "\n",
+    "As a simplification, let's assume that the acceleration of the penny is `a` until the penny reaches 18 meters per second, and then 0 afterwards.  What is the total time for the penny to fall 381 meters?\n",
+    "\n",
+    "You can break this question into three parts:\n",
+    "\n",
+    "1. How long until the penny reaches 18 meters per second with constant acceleration `a`.\n",
+    "2. How far would the penny fall during that time?\n",
+    "3. How long to fall the remaining distance with constant velocity 18 m/s?\n",
+    "\n",
+    "Suggestion: Assign each intermediate result to a variable with a meaningful name.  And assign units to all quantities!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "v_terminal = 18*meter/second"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t_terminal = v_terminal / a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "h_term = a * t_terminal**2 / 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t_rem = ( h - h_term ) / v_terminal"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t_total = t_terminal + t_rem"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Restart and run all\n",
+    "\n",
+    "When you change the contents of a cell, you have to run it again for those changes to have an effect.  If you forget to do that, the results can be confusing, because the code you are looking at is not the code you ran.\n",
+    "\n",
+    "If you ever lose track of which cells have run, and in what order, you should go to the Kernel menu and select \"Restart & Run All\".  Restarting the kernel means that all of your variables get deleted, and running all the cells means all of your code will run again, in the right order.\n",
+    "\n",
+    "**Exercise:**  Select \"Restart & Run All\" now and confirm that it does what you want."
+   ]
+  }
+ ],
+ "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/code/chap02mneal.ipynb b/code/chap02mneal.ipynb
new file mode 100644
index 00000000..968a7dbe
--- /dev/null
+++ b/code/chap02mneal.ipynb
@@ -0,0 +1,2790 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 2\n",
+    "\n",
+    "Copyright 2017 Allen Downey\n",
+    "\n",
+    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Done\n"
+     ]
+    }
+   ],
+   "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 *\n",
+    "\n",
+    "# set the random number generator\n",
+    "np.random.seed(7)\n",
+    "print ('Done')\n",
+    "\n",
+    "# If this cell runs successfully, it prinds 'Done'."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Modeling a bikeshare system"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We'll start with a `State` object that represents the number of bikes at each station.\n",
+    "\n",
+    "When you display a `State` object, it lists the state variables and their values:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "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": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare = State(olin=10, wellesley=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can access the state variables using dot notation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare.olin"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "ename": "AttributeError",
+     "evalue": "'State' object has no attribute 'wellesly'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-7-5608cc64548c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mbikeshare\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwellesly\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;32m~\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\pandas\\core\\generic.py\u001b[0m in \u001b[0;36m__getattr__\u001b[1;34m(self, name)\u001b[0m\n\u001b[0;32m   4370\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_info_axis\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_can_hold_identifiers_and_holds_name\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   4371\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 4372\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mobject\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__getattribute__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   4373\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   4374\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__setattr__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;31mAttributeError\u001b[0m: 'State' object has no attribute 'wellesly'"
+     ]
+    }
+   ],
+   "source": [
+    "bikeshare.wellesly"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** What happens if you spell the name of a state variable wrong?  Edit the previous cell, change the spelling of `wellesley`, and run the cell again.\n",
+    "\n",
+    "The error message uses the word \"attribute\", which is another name for what we are calling a state variable. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** Add a third attribute called `babson` with initial value 0, and display the state of `bikeshare` again."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "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",
+       "    <tr>\n",
+       "      <th>babson</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         10\n",
+       "wellesley     2\n",
+       "babson        0\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare = State(olin=10, wellesley=2,babson=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Updating\n",
+    "\n",
+    "We can use the update operators `+=` and `-=` to change state variables."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bikeshare.olin -= 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If we display `bikeshare`, we should see the change."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "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>9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>babson</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         9\n",
+       "wellesley    2\n",
+       "babson       0\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Of course, if we subtract a bike from `olin`, we should add it to `wellesley`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "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>9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>babson</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         9\n",
+       "wellesley    3\n",
+       "babson       0\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare.wellesley += 1\n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Functions\n",
+    "\n",
+    "We can take the code we've written so far and encapsulate it in a function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def bike_to_wellesley():\n",
+    "    bikeshare.olin -= 1\n",
+    "    bikeshare.wellesley += 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When you define a function, it doesn't run the statements inside the function, yet.  When you call the function, it runs the statements inside."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "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>8</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>babson</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         8\n",
+       "wellesley    4\n",
+       "babson       0\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bike_to_wellesley()\n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "One common error is to omit the parentheses, which has the effect of looking up the function, but not calling it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.bike_to_wellesley()>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bike_to_wellesley"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The output indicates that `bike_to_wellesley` is a function defined in a \"namespace\" called `__main__`, but you don't have to understand what that means."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** Define a function called `bike_to_olin` that moves a bike from Wellesley to Olin.  Call the new function and display `bikeshare`  to confirm that it works."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def bike_to_olin():\n",
+    "    bikeshare.olin += 1\n",
+    "    bikeshare.wellesley -= 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "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>9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>babson</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         9\n",
+       "wellesley    3\n",
+       "babson       0\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bike_to_olin()\n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parameters"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Before we go on, let's start with a new state object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "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": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare = State(olin=10, wellesley=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since we have two very similar functions, it would be better to define a new function, `move_bike`, that takes a parameter `n`, which indicates how many bikes are moving, and in which direction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def move_bike(n):\n",
+    "    bikeshare.olin -= n\n",
+    "    bikeshare.wellesley += n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can use `move_bike` to write simpler versions of the other functions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def bike_to_wellesley():\n",
+    "    move_bike(1)\n",
+    "    \n",
+    "def bike_to_olin():\n",
+    "    move_bike(-1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When we define these functions, we replace the old definitions with the new ones.\n",
+    "\n",
+    "Now we can test them."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "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>9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         9\n",
+       "wellesley    3\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bike_to_wellesley()\n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "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": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bike_to_olin()\n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "At this point, `move_bike` is complicated enough that we should add some documentation.  The text in triple-quotation marks is in English, not Python.  It doesn't do anything when the program runs, but it helps people understand what this function does and how to use it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def move_bike(n):\n",
+    "    \"\"\"Move bikes.\n",
+    "    \n",
+    "    n: number of bikes: positive moves from Olin to Wellesley;\n",
+    "                        negative moves from Wellesley to Olin\n",
+    "    \"\"\"\n",
+    "    bikeshare.olin -= n\n",
+    "    bikeshare.wellesley += n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** The following function definitions start with print statements so they display messages when they run.  Call each of these functions (with appropriate arguments) and confirm that they do what you expect.\n",
+    "\n",
+    "Adding print statements to functions is a useful debugging technique.  Keep it in mind!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def move_bike_debug(n):\n",
+    "    print('Running move_bike_debug with argument', n)\n",
+    "    bikeshare.olin -= n\n",
+    "    bikeshare.wellesley += n\n",
+    "    \n",
+    "def bike_to_wellesley_debug():\n",
+    "    print('Running bike_to_wellesley_debug')\n",
+    "    move_bike_debug(1)\n",
+    "    \n",
+    "def bike_to_olin_debug():\n",
+    "    print('Running bike_to_olin_debug')\n",
+    "    move_bike_debug(-1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running move_bike_debug with argument 1\n"
+     ]
+    },
+    {
+     "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>9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         9\n",
+       "wellesley    3\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "move_bike_debug(1)\n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running bike_to_wellesley_debug\n",
+      "Running move_bike_debug with argument 1\n"
+     ]
+    },
+    {
+     "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>8</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         8\n",
+       "wellesley    4\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bike_to_wellesley_debug()\n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running bike_to_olin_debug\n",
+      "Running move_bike_debug with argument -1\n"
+     ]
+    },
+    {
+     "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>9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         9\n",
+       "wellesley    3\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bike_to_olin_debug()\n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Conditionals"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`modsim.py` provides `flip`, which takes a probability and returns either `True` or `False`, which are special values defined by Python.\n",
+    "\n",
+    "The Python function `help` looks up a function and displays its documentation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Help on function flip in module modsim:\n",
+      "\n",
+      "flip(p=0.5)\n",
+      "    Flips a coin with the given probability.\n",
+      "    \n",
+      "    p: float 0-1\n",
+      "    \n",
+      "    returns: boolean (True or False)\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "help(flip)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the following example, the probability is 0.7 or 70%.  If you run this cell several times, you should get `True` about 70% of the time and `False` about 30%."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "flip(0.7)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the following example, we use `flip` as part of an if statement.  If the result from `flip` is `True`, we print `heads`; otherwise we do nothing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "heads\n"
+     ]
+    }
+   ],
+   "source": [
+    "if flip(0.7):\n",
+    "    print('heads')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "With an else clause, we can print heads or tails depending on whether `flip` returns `True` or `False`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tails\n"
+     ]
+    }
+   ],
+   "source": [
+    "if flip(0.7):\n",
+    "    print('heads')\n",
+    "else:\n",
+    "    print('tails')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step\n",
+    "\n",
+    "Now let's get back to the bikeshare state.  Again let's start with a new `State` object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "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": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare = State(olin=10, wellesley=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Suppose that in any given minute, there is a 50% chance that a student picks up a bike at Olin and rides to Wellesley.  We can simulate that like this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "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": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "if flip(0.5):\n",
+    "    bike_to_wellesley()\n",
+    "    print('Moving a bike to Wellesley')\n",
+    "\n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And maybe at the same time, there is also a 40% chance that a student at Wellesley rides to Olin."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "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": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "if flip(0.4):\n",
+    "    bike_to_olin()\n",
+    "    print('Moving a bike to Olin')\n",
+    "\n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can wrap that code in a function called `step` that simulates one time step.  In any given minute, a student might ride from Olin to Wellesley, from Wellesley to Olin, or both, or neither, depending on the results of `flip`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def step():\n",
+    "    if flip(0.5):\n",
+    "        bike_to_wellesley()\n",
+    "        print('Moving a bike to Wellesley')\n",
+    "        \n",
+    "    if flip(0.4):\n",
+    "        bike_to_olin()\n",
+    "        print('Moving a bike to Olin')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since this function takes no parameters, we would call it like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Moving a bike to Olin\n"
+     ]
+    },
+    {
+     "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>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         11\n",
+       "wellesley     1\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step()\n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "But it would be better to generalize this function so it takes the probabilities `p1` and `p2` as parameters:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def step(p1, p2):\n",
+    "    if flip(p1):\n",
+    "        bike_to_wellesley()\n",
+    "        print('Moving a bike to Wellesley')\n",
+    "        \n",
+    "    if flip(p2):\n",
+    "        bike_to_olin()\n",
+    "        print('Moving a bike to Olin')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can call it like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Moving a bike to Wellesley\n"
+     ]
+    },
+    {
+     "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": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step(0.5, 0.4)\n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** At the beginning of `step`, add a print statement that displays the values of `p1` and `p2`.  Call it again with values `0.3`, and `0.2`, and confirm that the values of the parameters are what you expect. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def step(p1,p2):\n",
+    "    print('p1=',p1,' and p2=',p2)\n",
+    "    if flip(p1):\n",
+    "        bike_to_wellesley()\n",
+    "        print ('Moving a bike to Wellesley')\n",
+    "          \n",
+    "    if flip(p2):\n",
+    "        bike_to_olin()\n",
+    "        print ('Moving a bike to Olin')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "p1= 0.3  and p2= 0.2\n",
+      "Moving a bike to Olin\n"
+     ]
+    },
+    {
+     "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>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         11\n",
+       "wellesley     1\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step(.3,.2)\n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## For loop"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Before we go on, I'll redefine `step` without the print statements."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def step(p1, p2):\n",
+    "    if flip(p1):\n",
+    "        bike_to_wellesley()\n",
+    "    \n",
+    "    if flip(p2):\n",
+    "        bike_to_olin()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And let's start again with a new `State` object:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "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": 53,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare = State(olin=10, wellesley=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can use a `for` loop to move 4 bikes from Olin to Wellesley."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "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>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         6\n",
+       "wellesley    6\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "for i in range(4):\n",
+    "    bike_to_wellesley()\n",
+    "    \n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Or we can simulate 4 random time steps."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "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>5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>7</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         5\n",
+       "wellesley    7\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "for i in range(4):\n",
+    "    step(0.3, 0.2)\n",
+    "    \n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If each step corresponds to a minute, we can simulate an entire hour like this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "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>14</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         -2\n",
+       "wellesley    14\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "for i in range(60):\n",
+    "    step(0.3, 0.2)\n",
+    "\n",
+    "bikeshare"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After 60 minutes, you might see that the number of bike at Olin is negative.  We'll fix that problem soon.\n",
+    "\n",
+    "But first, we want to plot the results."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## TimeSeries\n",
+    "\n",
+    "`modsim.py` provides an object called a `TimeSeries` that can contain a sequence of values changing over time.\n",
+    "\n",
+    "We can create a new, empty `TimeSeries` like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "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",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "Series([], dtype: float64)"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results = TimeSeries()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And we can add a value to the `TimeSeries` like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "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>0</th>\n",
+       "      <td>-2</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "0   -2\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 58,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results[0] = bikeshare.olin\n",
+    "results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `0` in brackets is an `index` that indicates that this value is associated with time step 0.\n",
+    "\n",
+    "Now we'll use a for loop to save the results of the simulation.  I'll start one more time with a new `State` object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "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": 59,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare = State(olin=10, wellesley=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's a for loop that runs 10 steps and stores the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 87,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for i in range(10):\n",
+    "    step(0.3, 0.2)\n",
+    "    results[i] = bikeshare.olin"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can display the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 88,
+   "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>0</th>\n",
+       "      <td>-4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>-4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>-4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>-4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>-4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>-5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>-5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>-6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>-6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>-6</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "0   -4\n",
+       "1   -4\n",
+       "2   -4\n",
+       "3   -4\n",
+       "4   -4\n",
+       "5   -5\n",
+       "6   -5\n",
+       "7   -6\n",
+       "8   -6\n",
+       "9   -6\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 88,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A `TimeSeries` is a specialized version of a Pandas `Series`, so we can use any of the functions provided by `Series`, including several that compute summary statistics:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "8.0"
+      ]
+     },
+     "execution_count": 62,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results.mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "count    10.000000\n",
+       "mean      8.000000\n",
+       "std       1.247219\n",
+       "min       6.000000\n",
+       "25%       7.000000\n",
+       "50%       8.000000\n",
+       "75%       9.000000\n",
+       "max      10.000000\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results.describe()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can read the documentation of `Series` [here](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plotting\n",
+    "\n",
+    "We can also plot the results like this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap02-fig01.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(results, label='Olin')\n",
+    "\n",
+    "decorate(title='Olin-Wellesley Bikeshare',\n",
+    "         xlabel='Time step (min)', \n",
+    "         ylabel='Number of bikes')\n",
+    "\n",
+    "savefig('chap02-fig01.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`decorate`, which is defined in the `modsim` library, adds a title and labels the axes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Help on function decorate in module modsim:\n",
+      "\n",
+      "decorate(**options)\n",
+      "    Decorate the current axes.\n",
+      "    \n",
+      "    Call decorate with keyword arguments like\n",
+      "    \n",
+      "    decorate(title='Title',\n",
+      "             xlabel='x',\n",
+      "             ylabel='y')\n",
+      "    \n",
+      "    The keyword arguments can be any of the axis properties\n",
+      "    \n",
+      "    https://matplotlib.org/api/axes_api.html\n",
+      "    \n",
+      "    In addition, you can use `legend=False` to suppress the legend.\n",
+      "    \n",
+      "    And you can use `loc` to indicate the location of the legend\n",
+      "    (the default value is 'best')\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "help(decorate)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`savefig()` saves a figure in a file."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Help on function savefig in module modsim:\n",
+      "\n",
+      "savefig(filename, **options)\n",
+      "    Save the current figure.\n",
+      "    \n",
+      "    Keyword arguments are passed along to plt.savefig\n",
+      "    \n",
+      "    https://matplotlib.org/api/_as_gen/matplotlib.pyplot.savefig.html\n",
+      "    \n",
+      "    filename: string\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "help(savefig)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The suffix of the filename indicates the format you want.  This example saves the current figure in a PDF file named `chap01-fig01.pdf`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** Wrap the code from this section in a function named `run_simulation` that takes three parameters, named `p1`, `p2`, and `num_steps`.\n",
+    "\n",
+    "It should:\n",
+    "\n",
+    "1. Create a `TimeSeries` object to hold the results.\n",
+    "2. Use a for loop to run `step` the number of times specified by `num_steps`, passing along the specified values of `p1` and `p2`.\n",
+    "3. After each step, it should save the number of bikes at Olin in the `TimeSeries`.\n",
+    "4. After the for loop, it should plot the results and\n",
+    "5. Decorate the axes.\n",
+    "\n",
+    "To test your function:\n",
+    "\n",
+    "1. Create a `State` object with the initial state of the system.\n",
+    "2. Call `run_simulation` with appropriate parameters.\n",
+    "3. Save the resulting figure."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "bikeshare=State(olin=10,wellesley=2)\n",
+    "for i in range (10):\n",
+    "    step(.4,.3)\n",
+    "    results[i]=bikeshare.olin\n",
+    "plot (results,label='Olin')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 142,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(p1,p2,num_steps):\n",
+    "    results=TimeSeries()\n",
+    "    for i in range(num_steps):\n",
+    "        step(p1,p2)\n",
+    "        results[i]=bikeshare.olin\n",
+    "    plot(results,label='Olin')\n",
+    "    decorate(title='Olin-Wellesley Bikeshare',\n",
+    "         xlabel='Time step (min)', \n",
+    "         ylabel='Number of bikes')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 143,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file Chap01_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": [
+    "bikeshare=State(olin=10,wellesley=2)\n",
+    "run_simulation(0.4,0.3,60)\n",
+    "savefig('Chap01_Fig02.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** Modify your solution to the previous exercise so it creates two `TimeSeries` objects, keeps track of the number of bikes at Wellesley and at Olin, and plots both series at the end."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 145,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(p1,p2,num_steps):\n",
+    "    Oresults=TimeSeries()\n",
+    "    Wresults=TimeSeries()\n",
+    "    for i in range(num_steps):\n",
+    "        step(p1,p2)\n",
+    "        Oresults[i]=bikeshare.olin\n",
+    "        Wresults[i]=bikeshare.wellesley\n",
+    "    plot(Oresults,label='Olin')\n",
+    "    plot(Wresults,label='Wellesley')\n",
+    "    decorate(title='Olin-Wellesley Bikeshare',\n",
+    "         xlabel='Time step (min)', \n",
+    "         ylabel='Number of bikes')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 146,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file Chap01_Fig02a.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "bikeshare=State(olin=10,wellesley=2)\n",
+    "run_simulation(0.4,0.3,60)\n",
+    "savefig('Chap01_Fig02a.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Congratulations on completing the first notebook!  When you did the exercises, you didn't have to write much new code; mostly, you just copied and modified the examples.  If you didn't understand everything you did completely I encourage you to take a break for now and come back to this notebook one more time before you start Chapter 2.  We are covering a lot of topics quickly; you might need to reread the book and review the code to solidify your knowledge. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Opening the hood\n",
+    "\n",
+    "The functions in `modsim.py` are built on top of several widely-used Python libraries, especially NumPy, SciPy, and Pandas.  These libraries are powerful but can be hard to use.  The intent of `modsim.py` is to give you the power of these libraries while making it easy to get started.\n",
+    "\n",
+    "In the future, you might want to use these libraries directly, rather than using `modsim.py`.  So at the end of each chapter we will open the hood and let you see how `modsim.py` works.\n",
+    "\n",
+    "You don't need to know anything in these sections, so if you are already feeling overwhelmed, you might want to skip them.  But if you are curious, read on."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Pandas\n",
+    "\n",
+    "This chapter introduced two objects, `State` and `TimeSeries`.  Both are based on the `Series` object defined by Pandas, which is a library primarily used for data science.\n",
+    "\n",
+    "You can read the documentation of the `Series` object [here](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html)\n",
+    "\n",
+    "The primary differences between `TimeSeries` and `Series` are:\n",
+    "\n",
+    "1. I made it easier to create a new, empty `Series` while avoiding a [confusing inconsistency](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html).\n",
+    "\n",
+    "2. I provide a function so the `Series` looks good when displayed in Jupyter.\n",
+    "\n",
+    "3. I provide a function called `set` that we'll use later.\n",
+    "\n",
+    "`State` has all of those capabilities; in addition, it provides an easier way to initialize state variables, and it provides functions called `T` and `dt`, which will help us avoid a confusing error later."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Pyplot\n",
+    "\n",
+    "The `plot` function in `modsim.py` is based on the `plot` function in Pyplot, which is part of Matplotlib.  You can read the documentation of `plot` [here](https://matplotlib.org/api/_as_gen/matplotlib.pyplot.plot.html).\n",
+    "\n",
+    "`decorate` provides a convenient way to call the `pyplot` functions `title`, `xlabel`, and `ylabel`, and `legend`.  It also avoids an annoying warning message if you try to make a legend when you don't have any labelled lines."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "help(decorate)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### NumPy\n",
+    "\n",
+    "The `flip` function in `modsim.py` uses NumPy's `random` function to generate a random number between 0 and 1.\n",
+    "\n",
+    "You can get the source code for `flip` by running the following cell."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 147,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "def flip(p=0.5):\n",
+      "    \"\"\"Flips a coin with the given probability.\n",
+      "\n",
+      "    p: float 0-1\n",
+      "\n",
+      "    returns: boolean (True or False)\n",
+      "    \"\"\"\n",
+      "    return np.random.random() < p\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "source_code(flip)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can also get the source code for `source_code`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "source_code(source_code)"
+   ]
+  },
+  {
+   "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap03mneal.ipynb b/code/chap03mneal.ipynb
new file mode 100644
index 00000000..47d2dcf2
--- /dev/null
+++ b/code/chap03mneal.ipynb
@@ -0,0 +1,1254 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 3\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": 1,
+   "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 *\n",
+    "\n",
+    "# set the random number generator\n",
+    "np.random.seed(7)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## More than one State object\n",
+    "\n",
+    "Here's the code from the previous chapter, with two changes:\n",
+    "\n",
+    "1. I've added DocStrings that explain what each function does, and what parameters it takes.\n",
+    "\n",
+    "2. I've added a parameter named `state` to the functions so they work with whatever `State` object we give them, instead of always using `bikeshare`.  That makes it possible to work with more than one `State` object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "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",
+    "    move_bike(state, 1)\n",
+    "    \n",
+    "def bike_to_olin(state):\n",
+    "    \"\"\"Move one bike from Wellesley to Olin.\n",
+    "    \n",
+    "    state: bikeshare State object\n",
+    "    \"\"\"\n",
+    "    move_bike(state, -1)\n",
+    "    \n",
+    "def move_bike(state, n):\n",
+    "    \"\"\"Move a bike.\n",
+    "    \n",
+    "    state: bikeshare State object\n",
+    "    n: +1 to move from Olin to Wellesley or\n",
+    "       -1 to move from Wellesley to Olin\n",
+    "    \"\"\"\n",
+    "    state.olin -= n\n",
+    "    state.wellesley += n\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": [
+    "And here's `run_simulation`, which is a solution to the exercise at the end of the previous notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(state, p1, p2, num_steps):\n",
+    "    \"\"\"Simulate the given number of time steps.\n",
+    "    \n",
+    "    state: State object\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",
+    "    results = TimeSeries()    \n",
+    "    for i in range(num_steps):\n",
+    "        step(state, p1, p2)\n",
+    "        results[i] = state.olin\n",
+    "        \n",
+    "    plot(results, label='Olin')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can create more than one `State` object:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "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": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare1 = State(olin=10, wellesley=2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "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",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin          2\n",
+       "wellesley    10\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare2 = State(olin=2, wellesley=10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Whenever we call a function, we indicate which `State` object to work with:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bike_to_olin(bikeshare1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bike_to_wellesley(bikeshare2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And you can confirm that the different objects are getting updated independently:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "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>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         11\n",
+       "wellesley     1\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare1"
+   ]
+  },
+  {
+   "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>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin          1\n",
+       "wellesley    11\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Negative bikes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the code we have so far, the number of bikes at one of the locations can go negative, and the number of bikes at the other location can exceed the actual number of bikes in the system.\n",
+    "\n",
+    "If you run this simulation a few times, it happens often."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "bikeshare = State(olin=10, wellesley=2)\n",
+    "run_simulation(bikeshare, 0.4, 0.2, 60)\n",
+    "decorate_bikeshare()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can fix this problem using the `return` statement to exit the function early if the update would cause negative bikes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def move_bike(state, n):\n",
+    "    \"\"\"Move a bike.\n",
+    "    \n",
+    "    state: bikeshare State object\n",
+    "    n: +1 to move from Olin to Wellesley or\n",
+    "       -1 to move from Wellesley to Olin\n",
+    "    \"\"\"\n",
+    "    # make sure the number of bikes won't go negative\n",
+    "    olin_temp = state.olin - n\n",
+    "    if olin_temp < 0:\n",
+    "        return\n",
+    "    \n",
+    "    wellesley_temp = state.wellesley + n\n",
+    "    if wellesley_temp < 0:\n",
+    "        return\n",
+    "    \n",
+    "    # update the state\n",
+    "    state.olin = olin_temp\n",
+    "    state.wellesley = wellesley_temp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now if you run the simulation again, it should behave."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      ":(\n",
+      ":(\n",
+      ":(\n",
+      ":(\n",
+      ":(\n",
+      ":(\n",
+      ":(\n",
+      ":(\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "bikeshare = State(olin=10, wellesley=2)\n",
+    "run_simulation(bikeshare, 0.4, 0.2, 60)\n",
+    "decorate_bikeshare()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The variables `olin` and `wellesley` are created inside `move_bike`, so they are local.  When the function ends, they go away.\n",
+    "\n",
+    "If you try to access a local variable from outside its function, you get an error:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'olin' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-15-a24b140b855c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;31m# NameError: name 'olin' is not defined\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0molin\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m: name 'olin' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "# If you remove the # from the last line in this cell and run it, you'll get\n",
+    "# NameError: name 'olin' is not defined\n",
+    "\n",
+    "olin"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** Add print statements in `move_bike` so it prints a message each time a customer arrives and doesn't find a bike.  Run the simulation again to confirm that it works as you expect.  Then remove the print statements before you go on."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Comparison operators"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `if` statements in the previous section used the comparison operator `<`.  The other comparison operators are listed in the book.\n",
+    "\n",
+    "It is easy to confuse the comparison operator `==` with the assignment operator `=`.\n",
+    "\n",
+    "Remember that `=` creates a variable or gives an existing variable a new value."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "5"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x = 5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Whereas `==` compared two values and returns `True` if they are equal."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x == 5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can use `==` in an `if` statement."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "yes, x is 5\n"
+     ]
+    }
+   ],
+   "source": [
+    "if x == 5:\n",
+    "    print('yes, x is 5')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "But if you use `=` in an `if` statement, you get an error."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "SyntaxError",
+     "evalue": "invalid syntax (<ipython-input-22-b6cb9d74a9e7>, line 4)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-22-b6cb9d74a9e7>\"\u001b[1;36m, line \u001b[1;32m4\u001b[0m\n\u001b[1;33m    if x = 5:\u001b[0m\n\u001b[1;37m         ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
+     ]
+    }
+   ],
+   "source": [
+    "# If you remove the # from the if statement and run it, you'll get\n",
+    "# SyntaxError: invalid syntax\n",
+    "\n",
+    "if x = 5:\n",
+    "   print('yes, x is 5')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** Add an `else` clause to the `if` statement above, and print an appropriate message.\n",
+    "\n",
+    "Replace the `==` operator with one or two of the other comparison operators, and confirm they do what you expect."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "yes, x is 5\n"
+     ]
+    }
+   ],
+   "source": [
+    "if x == 5:\n",
+    "    print('yes, x is 5')\n",
+    "else:\n",
+    "    print('No, x is not 5')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "yes, x is 5\n"
+     ]
+    }
+   ],
+   "source": [
+    "if x != 5:\n",
+    "    print('no, x is not 5')\n",
+    "else:\n",
+    "    print('yes, x is 5')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Metrics"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we have a working simulation, we'll use it to evaluate alternative designs and see how good or bad they are.  The metric we'll use is the number of customers who arrive and find no bikes available, which might indicate a design problem."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First we'll make a new `State` object that creates and initializes additional state variables to keep track of the metrics."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "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",
+       "    <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               10\n",
+       "wellesley           2\n",
+       "olin_empty          0\n",
+       "wellesley_empty     0\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare = State(olin=10, wellesley=2, \n",
+    "                  olin_empty=0, wellesley_empty=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next we need a version of `move_bike` that updates the metrics."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def move_bike(state, n):\n",
+    "    \"\"\"Move a bike.\n",
+    "    \n",
+    "    state: bikeshare State object\n",
+    "    n: +1 to move from Olin to Wellesley or\n",
+    "       -1 to move from Wellesley to Olin\n",
+    "    \"\"\"\n",
+    "    olin_temp = state.olin - n\n",
+    "    if olin_temp < 0:\n",
+    "        state.olin_empty += 1\n",
+    "        return\n",
+    "    \n",
+    "    wellesley_temp = state.wellesley + n\n",
+    "    if wellesley_temp < 0:\n",
+    "        state.wellesley_empty += 1\n",
+    "        return\n",
+    "    \n",
+    "    state.olin = olin_temp\n",
+    "    state.wellesley = wellesley_temp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now when we run a simulation, it keeps track of unhappy customers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap02-fig01.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "run_simulation(bikeshare, 0.4, 0.2, 60)\n",
+    "decorate_bikeshare()\n",
+    "savefig('chap02-fig01.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After the simulation, we can print the number of unhappy customers at each location."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare.olin_empty"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare.wellesley_empty"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercises\n",
+    "\n",
+    "**Exercise:** As another metric, we might be interested in the time until the first customer arrives and doesn't find a bike.  To make that work, we have to add a \"clock\" to keep track of how many time steps have elapsed:\n",
+    "\n",
+    "1. Create a new `State` object with an additional state variable, `clock`, initialized to 0. \n",
+    "\n",
+    "2. Write a modified version of `step` that adds one to the clock each time it is invoked.\n",
+    "\n",
+    "Test your code by running the simulation and check the value of `clock` at the end."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "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",
+       "    <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",
+       "    <tr>\n",
+       "      <th>clock</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin               10\n",
+       "wellesley           2\n",
+       "olin_empty          0\n",
+       "wellesley_empty     0\n",
+       "clock               0\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare = State(olin=10, wellesley=2, \n",
+    "                  olin_empty=0, wellesley_empty=0,\n",
+    "                  clock=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "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",
+    "    state.clock += 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "clock is at  60  steps\n",
+      "Saving figure to file chap02-fig01a.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "bikeshare = State(olin=10,wellesley=2,clock=0,olin_empty=0,wellesley_empty=0, t_first_empty=-1)\n",
+    "run_simulation(bikeshare, 0.4, 0.2, 60)\n",
+    "decorate_bikeshare()\n",
+    "print('clock is at ',bikeshare.clock, ' steps')\n",
+    "savefig('chap02-fig01a.pdf')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** Continuing the previous exercise, let's record the time when the first customer arrives and doesn't find a bike.\n",
+    "\n",
+    "1. Create a new `State` object with an additional state variable, `t_first_empty`, initialized to -1 as a special value to indicate that it has not been set. \n",
+    "\n",
+    "2. Write a modified version of `step` that checks whether`olin_empty` and `wellesley_empty` are 0.  If not, it should set `t_first_value` to `clock` (but only if `t_first_value` has not already been set).\n",
+    "\n",
+    "Test your code by running the simulation and printing the values of `olin_empty`, `wellesley_empty`, and `t_first_empty` at the end."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "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",
+       "    <tr>\n",
+       "      <th>clock</th>\n",
+       "      <td>0</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",
+       "    <tr>\n",
+       "      <th>t_first_empty</th>\n",
+       "      <td>-1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin               10\n",
+       "wellesley           2\n",
+       "clock               0\n",
+       "olin_empty          0\n",
+       "wellesley_empty     0\n",
+       "t_first_empty      -1\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bikeshare = State(olin=10,wellesley=2,clock=0,olin_empty=0,wellesley_empty=0,t_first_empty=-1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "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",
+    "    state.clock += 1\n",
+    "    if flip(p1):\n",
+    "        bike_to_wellesley(state)\n",
+    "    if state.olin_empty != 0 and state.t_first_empty == -1:\n",
+    "            state.t_first_empty = state.clock\n",
+    "    \n",
+    "    if flip(p2):\n",
+    "        bike_to_olin(state)\n",
+    "    if state.wellesley_empty != 0 and state.t_first_empty == -1:\n",
+    "            state.t_first_empty = state.clock"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1 0 60\n",
+      "Saving figure to file chap02-fig01b.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "bikeshare = State(olin=10,wellesley=2,clock=0,olin_empty=0,wellesley_empty=0,t_first_empty=-1)\n",
+    "run_simulation(bikeshare, 0.4, 0.2, 60)\n",
+    "decorate_bikeshare()\n",
+    "print(bikeshare.olin_empty,bikeshare.wellesley_empty,bikeshare.t_first_empty)\n",
+    "savefig('chap02-fig01b.pdf')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  }
+ ],
+ "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap04mneal.ipynb b/code/chap04mneal.ipynb
new file mode 100644
index 00000000..da4b7404
--- /dev/null
+++ b/code/chap04mneal.ipynb
@@ -0,0 +1,1147 @@
+{
+ "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": 1,
+   "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": 2,
+   "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": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "8"
+      ]
+     },
+     "execution_count": 3,
+     "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": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10"
+      ]
+     },
+     "execution_count": 4,
+     "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": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10"
+      ]
+     },
+     "execution_count": 5,
+     "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": 6,
+   "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": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_state():\n",
+    "    state=State(olin=10, wellesley=2)\n",
+    "    return state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "10 2\n"
+     ]
+    }
+   ],
+   "source": [
+    "init = make_state()\n",
+    "print(init.olin, init.wellesley)"
+   ]
+  },
+  {
+   "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": 25,
+   "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",
+    "    move_bike(state, 1)\n",
+    "    \n",
+    "def bike_to_olin(state):\n",
+    "    \"\"\"Move one bike from Wellesley to Olin.\n",
+    "    \n",
+    "    state: bikeshare State object\n",
+    "    \"\"\"\n",
+    "    move_bike(state, -1)\n",
+    "    \n",
+    "def move_bike(state, n):\n",
+    "    \"\"\"Move a bike.\n",
+    "    \n",
+    "    state: bikeshare State object\n",
+    "    n: +1 to move from Olin to Wellesley or\n",
+    "       -1 to move from Wellesley to Olin\n",
+    "    \"\"\"\n",
+    "    olin_temp = state.olin - n\n",
+    "    if olin_temp < 0:\n",
+    "        state.olin_empty += 1\n",
+    "        return\n",
+    "    \n",
+    "    wellesley_temp = state.wellesley + n\n",
+    "    if wellesley_temp < 0:\n",
+    "        state.wellesley_empty += 1\n",
+    "        return\n",
+    "    \n",
+    "    state.olin = olin_temp\n",
+    "    state.wellesley = wellesley_temp\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": 26,
+   "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": 82,
+   "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>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>olin_empty</th>\n",
+       "      <td>3</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                1\n",
+       "wellesley          11\n",
+       "olin_empty          3\n",
+       "wellesley_empty     0\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 82,
+     "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": 83,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3"
+      ]
+     },
+     "execution_count": 83,
+     "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": 81,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 81,
+     "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": 80,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "18"
+      ]
+     },
+     "execution_count": 80,
+     "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": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.  , 0.25, 0.5 , 0.75, 1.  ])"
+      ]
+     },
+     "execution_count": 31,
+     "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": 32,
+   "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": 33,
+   "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": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mn_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": 35,
+   "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` (at least approximately).\n",
+      "    If you provide the keyword argument `endpoint=False`, the last value\n",
+      "    in the array is `stop-step`.\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": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 1.,  3.,  5.,  7.,  9., 11.])"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mn_array=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": 37,
+   "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": 37,
+     "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": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0 0\n",
+      "0.1 0\n",
+      "0.2 0\n",
+      "0.30000000000000004 1\n",
+      "0.4 1\n",
+      "0.5 12\n",
+      "0.6000000000000001 17\n",
+      "0.7000000000000001 22\n",
+      "0.8 27\n",
+      "0.9 34\n",
+      "1.0 35\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": 43,
+   "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": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap02-fig02.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xd4HNXV+PHvqsuSJbn3Xo47tnGhhA6hBQIBQgiQAAktdFLJ700BQggJ8AZSCBACBEh4Qwm9FwOmuGEbG8xxt9xkWy6S1dv+/rij1WqtMrK0RfL5PI8fa2Znds6uVnP23rlzbiAYDGKMMcYkmqR4B2CMMcY0xRKUMcaYhGQJyhhjTEKyBGWMMSYhWYIyxhiTkCxBGWOMSUgp8Q7AdH0i0g34EfBtYDiwE3gTuE1VV4Vttx64U1X/LCK/Br6mqjP243h9gO3AGar6fNj6W4BfAJep6oNh628Efgr0V9UW77uIiPERIFtVz25rjBHPeTTwLtBdVUva81xNPPcjwHfDVlUBq4DfqOqT3jbDgXXAZFVdHv4aOziWX7Ofv1NzYLIWlIkqLzm9C5wL/BwQ4CwgHVggIoc2s+udwIn7c0xV3QF8AcyOeOg4YBNwQsT6w4A5rSWnTuwlYID3bzzwF+AxEalPFBu9x76MT3jGNM1aUCbafg30AqararG3bgPwiYg8hDtRjlfV6vCdvJZEe1oTc4BD6hdEJBuYBdwI/EpEAmEJ6VDglnYcK9FVqmpB2PJ9InIpcB6wUFVrgYKmdzUmfixBmagRkSTgUuCXYckp3C9wLZoTcd/yw/f9NV53kNcF9jQuudwC9ADeB76vqtuaOfx7wHdEJElV64CjgM3AI8DdwDTgU697ayDwjnfcVOBW4CIgE/gEuFZV1cfrne0998G4VsmDuK6yOhFJAf4XOAfIBRYBN6rq/CaepztwF3A2EPRiu05Vt4jIT4CrgWH1CVZEjgReBfq1oYuwMOx4wwnr4ouIZSTwIfCMql7trfsRcA3ui8cS4Eeq+on32ETgz8BMoBx43ou91HvKZBH5PfA93PnnSeAaVa3y9r8BuBLXFVwCvAxcqaol3mdiNq7n5xDc7+XRluIxnZt18ZloGgvk4U7y+1DVLcBKXAumNXnAFbjuwTNwJ6r/aWH7OUA2MNFbPh54W1X3Agtp6OY7DNgUdi3sFuBUXJfkbECB90Qkt6XgRKQv8DrwGjAZuBa4CviJt8k1wEnAaV5MK4GnRSTQxNM9gOsKPRGXWIPA616SewIYBBwetv23gef9JCcRCYjICd7rfqKVbfvjrhW+7MWPiFwOXAf8AJfkXwHeEZER3m7/wr1nU7zXehzws7CnnQr0xCWYC4GLvX+IyHm4FveNwBjcl4SvA5eH7X8S7svJIcArPuIxnZi1oEw09fT+39XCNjuB3j6eKxnX4lgEICKPE9aFF0lVt4vIClySWYY7Uf7Oe/gdb/kO3Im+vvWUCdwAHKeqH3rbXisiJ+JOpi0NGrgKWKCqt3rLq0TkJuBe77jDgTJgvaru8AZmTCPiS6LXYvkWMFhVN3vrLsS1eE5S1ZdE5D1vm7lei+9sGg+EiHSGiNQnrzQgFXgM+KyFffKAN3BfLi4L6w79OfAzVX3ZW/6t18K9CjcQZjjwArBBVdeKyOm4gRn1dgNXqGqN9x69DxzkPbYFuEhV61vTG7zXOiFs/3Lgdq9VjIi0Fo/pxCxBmWiqT0w5LWyTR1h3UytWhv1cjDvRIiKvAkeEPTZBVfNx3XyzReQFYBJeIvL+v1ZEknEtiXu89aNwgzfeEJHwARMZuBZNSyYCR4clAnDJJ1NEeuGS29eBLSLyEe4k/oiq1oo0eur6k7FGrO/mxfASLrn8TkSuw7Wygrhk0pw38VpAuPdsPG4QygPAJc3s8z+4ZPZKWDLIBoYCD4rI/WHbpgOV3s8/xQ3CuFJEXgeeUtXnwrbd4CWnentwXamo6nsiMkNEfgOMw72nAvwzbPt1bYzHdGKWoEw0rQZ2AF8BFkc+6A0HF5rpAmxCVcRyfffY9/FOcp4t3v9zcN/4jwFWhA0U+BD32T8c1x1Xn7jq/x5OwA1TD9fUNbRwKcAzNN3tWKSqO8VlnJOBU4AfAteJyKwmnqca17qKHFVYn/CfwSWBo3EDHf4TOcgkQqmqrg5bXiEi6cATXpJryvvAo8AjIvKEqi7DtWLBtdYif5/lAKr6NxF5CTgT1x33HxF5VFUv9barbeJYAQARuQi4D3gYd03tVuDmpo7jaTUe07nZNSgTNd435b8BPxKRnk1scguQj7tu057jbFbV1WH/6r+hz8G1Fk4A3g7bvgL4GHehfr3X2gKXUGuAvvXPBazBXReJTCSRVgDjwuPwjv1LoM4bNXeGqj6nqpfhrs/1A45s4nlSgayw59kK/MHbB2/AyYu4a3En08q1pGYkRfwf6QVVfQKXvO/3Rj0W4Ub7DYp4nVcDJ4pIjoj8GQiq6p9U9VTvsfN9xnQV8AdV/YGqPoTrghxDwxeRRlqLx+cxTQKzFpSJtttwF/o/9K4XLMKdmK/BdXmd3Mq3//2mqttEZC3uek3kSfId4CbCTu7eSLG/AveISCXuhtYbcIngV60c7i+4bsN7vZ+HAPfjBi/UiUgecKuI7PKe91RcC2AJbhRhfQzqdUn+U0SuwrVAb8Ndbwu/T+kx4Clgq6p+1Eps6d6AB3Ane/Fez6uqWiQiPVrY9xrcNbzLcV82fg/8UkS2AgtwAzSuBo5S1WLv+s9AEalvSZ7hbefHTuAYEZngxXkDrstzWQv7NBuPz2OaBGYtKBNVqlqJa8E8AvwGd5J9DqgDZvg4ubbXHFz333sR69/GXdd5J2L9T3BD2h/GfYOfjkuia1o6iKrWD5efASzFJZD/A673Nrkbdy3lYdwot8uBs1R15b7PxndxIw2fw510c4ETVHVP2Dav4QZd/KuluDxfw7XCtuKG9f8Ld83qO63t6MV3J3C7l+Tu8ZZ/j7sZ+pvA2WGDSr6Be18/AuYBFbik4cd1uG7NhcBbuGtJt+N+B81pLR7TiQVsRl1jOh+v1bMVmKqqVgHCdEmWoIzpRLzSUafgBkfkqepxcQ7JmKixa1DGdC61uOHhO4DT4xyLMVFlLShjjDEJqVO1oLx7N2bi+t6bup/CGGNM55KMq6a/wBtUFdKpEhQuOX0Q7yCMMcZ0uCOAueErOluC2grwxBNP0L9//9a2NcYYk+AKCgo4//zzwTu/h+tsCaoWoH///gwePDjesRhjjOk4+1y2sRt1jTHGJCRLUMYYYxKSJShjjDEJyRKUMcaYhGQJyhhjTEKyBGWMMabNgsEgO4vKqa6JXs2EzjbM3BhjTAJ4d9FGvli3i349u3HWMWNISmpyXsl2sRaUMcaYNinYWcoX63YBsGN3OYGOz02AJShjjDFt9MnyhqIPo4fkEYhShrIEFUP//ve/Of300znllFM49dRT+fGPf8yWLVsAOPbYY1m2bBnLli3j2muvjXOkxhjTtI3b9rJpewkASYEAsyZEr+ycXYOKkTvuuIMvv/yS+++/nwEDBlBXV8cLL7zAueeey1NPPRXabvLkydx7771xjNQYY5oWDAYbtZ7GDe9JXvf0qB2vyyaoxbqd+V8UUF1TF7VjpKYkMWtCf6ZJ3xa3Kygo4Mknn2TOnDnk5uYCkJSUxBlnnMHy5cu5//77Q9vOmzePW2+9lZdeeomf/exnZGdno6oUFBQgItxxxx1kZWVF7TUZY0xz1m8tZtuuMgCSkwLMnNAvqsfrsl18S1buiGpyAqiuqWPJyh2tbrd06VJGjhwZSk7hDjvsMBYtWtTsvsuXL+ehhx7ilVdeYfPmzbz22mvtitkYY/ZHMBhk3ucFoeVJI3vTvVtaVI8Z0xaUiJwBPKaq3b3lm4DvenE8Dtysqh0yxe/UsX1i0oKaOraPr21ramqaXF9VVdXiBcYjjjiCtDT3IRg7dixFRUVtD9QYY9pp9aY9FO4pByA1OYmDx7fcc9QRYpagRGQMcCcQ8JZPAb4JHIwrs/468AXwn4443jTp22rXW6xMnTqVDRs2sGPHDvr0aZzQ5s2bx7Rp03j//feb3DcjIyP0cyAQIBjskPxtjDG+1dU1bj1NGdObbhmpUT9uTLr4RKQbroV0Y9jqM4F/qWqpqlYADwMXxCKeWOvXrx8XXnghN954I9u2bQutf+aZZ3jjjTe49NJL4xidMca0TDfsZs9eNxt7Wmoy08bG5st/rFpQ93v/PgtbNwR4O2x5E9BlZyH84Q9/yFNPPcWVV15JVVUVVVVVTJ48mSeffJJBgwbFOzxjjGlSbW0dC1Y0tJ6mju1DRnpsUsd+HUVEDgN2q+oKH9v+AKhR1X+IyPCwh5KA8P6qAE3MqNiVnHPOOZxzzjlNPvbOO++Efn7ppZcA+N3vftdom8hlY4yJti/W7aK4tAqAjLQUpo7xd929I/jq4hORE0VEvZ9vwrV8ForIJT52vwiYKSJLgFeATO/nTcDAsO0GeuuMMcYkgJraOhauaLgsMX1cX9JSk2N2fL8tqFuAO0QkCbgOOAvYAjwD/KOlHVV1Vv3PXgtquapOFZHTgF+JyANADS6RPdLG+I0xxkTJstWFlFZUA5CVkcqU0b1jeny/gyRGq+o/gGlAFvC6qi4B9rutp6ovAs8C84HlwCLgn/v7fMYYYzpOVXUtn+r20PKM8f1ISY7trbN+W1C7RWQccB7wtqrWisiRwNZW9mtEVdcD2WHLvwV+25bnMMYYE31LV+2gvNLdv5mTlcaEET1jHoPfBHUbsAyoAo4VkcOBV4HLohWYMcaY+KiorGFxWJWcmeP7kxzj1hP4T1ALgAFAhaqWiEgeMFVVV0UvNGOMMfGweOV2qqrdoOq87unIsB5xicNvgnoXGKGqJQCqugfYE7WojDHGxEVZRTWfrSoMLc+e2D8qs+X64bfNpsCh0QzEGGNM/C36cjvVta6Gae+8TEYPzotbLG25Ufc1ESnEDS8P3WCrqtM7PCpjjDExV1JWxfI1jVtP0Zot1w+/CepB758xxpguasGKbdTWufZHv57dGD4gJ67x+EpQqvoogIikAsOANd56K61tjDFdwJ69laxYtyu0fMikAXFtPYH/UkeZIvJ3oBxYCgigIjIymsEZY4yJjQVfFFDnTeczqE82g/tmt7JH9PkdJPG/QA9gIu5eqDW4+Zv+EqW4jDHGxMjOonJWbmwYmJ0IrSfwn6BOBy5SVQWCqloN/AiYHbXIjDHGxMT8zwtCk6EO65/DgN5ZcY7I8ZugaoB07+f6tJoFlHZ4RMYYY2Jm+64y1mwuCi0fMmlAHKNpzG+Cehp4WkRmQmj69oeA/0YrMGOMMdH3yecNJVVHDc6jT4/MOEbTmN8EdRNuNtw5QC6uLt9O4OfRCcsYY0y0bSksIb9gLwCBQIDZE/vHOaLG/A4zrwSuBa4VkT7ATlWti2pkxhhjoiYYDPLJsoap3GVoHj1zMuIY0b58JSgRycJNKDgCr9UlIgCo6o1Ris0YY0yUbNy2ly2FJQAkBQLMnJBYrSfwX0niP8AY4GPAWk7GGNOJBYNB5n3e0HqaMKInudnpLewRH34T1BHAUK+KuTHGmE5s/dZitu0qAyA5KcCM8f3iHFHT/A6SWAHEr6StMcaYDhEMBvlkeUPrafLo3mR3S4tjRM3z24K6GnhHRJ4jYh4oVb2lw6MyxhgTFas27mFnUTkAqSlJTJe+cY6oeX4T1C+BVGA0UBu23orFGmNMJ1FXF2R+2LWng8b0oVtGahwjapnfBHUMMNiuQRljTOf15YZd7CmpBCA9NZmpY/vEOaKW+b0GtRKI78Qgxhhj9lttbR0LvtgWWp4mfclIa8uctbHnN7qngQ9F5GFcBYnwGXXvjUZgxhhjOs7n63ayt6wKgMz0FA4a0zvOEbXOb4I6AViNG24eLghYgjLGmARWXVPHwhXbQ8sHj+tLakpyHCPyx2+po2OiHYgxxpjoWLa6kLKKagCyM1OZNCrxW0/gvwWFiJwLXAIMAbYBj6vqQ9EKzBhjTPtVVtfyqTa0nmaM70dKst/hB/Hld8r3K3Gz6r4D3Ay8CfxGRK6LYmzGGGPaaenKHVRU1QCQk5XG+OE94xyRf35bUNcBp6rq4voVIvIq8AxwTzQCM8YY0z4VlTUsWbUjtDxrYn+SO0nrCfwPM++Hmw8q3DKg86RiY4w5wHyq26mqdrUVeuZkMHZIjzhH1DZ+E9RiXLmjcFcBSzo2HGOMMR2htLyaz1YXhpZnTexPUlIgjhG1nd8uvh8Db4nIZcAGYBjQGzgpWoEZY4zZf4u+3EZNrZsdqU9eJqMG5cY5orbzO8x8kYiMAU4H+gL5wCtW+sgYYxJPcWkVy9fuDC0fMmkAgUDnaj2B/xl1F6vqNOAfEes3qOqwqERmjDFmvyxcUUBdnSv4M6BXFkP7d49zRPun2QQlIsOBu4AAMFFEno3YJBf/17CMMcbEwO69FXy5fndoefak/p2y9QQtJBhVXQ+8BSzFlTRaGvHvTeDk6IdojDHGr/mfb6Mu6FpPg/t2Z3Dfztl6gla6+FT1PgARWaaqkS0oY4wxCWRnUTmrNzUMDThkUv84RtN+frvoXhGR8wFEZIyIvCEi/xaRzv3qjTGmC/lkeQFBr/U0YkAO/XtlxTmi9vGboP4C/Mj7+UHctO9VwN+iEZQxxpi22barjHVbikLLsycNiGM0HcPvfVDHAVNFpCfwFdx9UIW4orGtEpGrgStx17LWAJfi5pW6C3cvVQpwp6pawjPGmP3wyfKtoZ/HDMmjd15mHKPpGH5bUDlAMW5eqJWquhmXVGpb21FEDsa1vg5T1UnAKuBW4HJgLDAJmAlcLyKz2vwKjDHmALd5Rwkbt+0FIBAIMGti17j64jdBfQg8AvwK+I937ekRYE5rO6rqImCMqhaJSAYwCNd6OhN4WFVrVHU38CRwQVtfgDHGHMiCwSCfLGtoPY0b1oMe3TPiGFHH8ZugLsZdd3oGuA0YCJQDl/nZWVWrReQMYBNwJPAwbl6pjWGbbQIG+4zHGGMMkL9tL1t3lgKQlBRg5oSu0XoC/6WOCoFrw1Z9CnynLQdS1eeA50TkUuB1oAZ3TapeAB9dhsYYY5xgMMi85QWh5YkjepGTlRbHiDqW71JHNE4mIao6vZV9RwP9VXWut+ofuNF/7+NaYvUG4lpRxhhjfFi7uYjtu8sASElO4uDx/eIcUcfyO4rvjxHLvXDdfv/0se8A4N8iMtVriZ0PLAeeBS4RkReBbOBbwBU+4zHGmJiqrK5FN+wiKRAgNzudnKw0undLi9sUFnV1QeZ93tB6mjy6N9mZqXGJJVr8dvE9GrlORJ4Gngf+0Mq+H4jIbcAcEakBtgBn4K4/jcKVTUoD7lfV99oWvjHGRF8wGOTluevYUljSaH1SUoCcbmnkZKeRm5VObnYaudnpoQSWEsXZa1dt3M2u4goAUlOSmC59o3asePHbgmpKETDCz4ZeyaT7mnjo+nYc3xhjYuLL9bv3SU7gWjF7SirZU1IJ7N3n8ezMVC9hpZFTn8Cy0snJTiMjbf9Pv7URraepY/qQmd6e03li8nsN6tqIVWm4YeIfdXhExhiTQCoqa/ho2ZbQcv9eWQSAotIqyiqqW9y3pLyakvJqNu/Y97GMtJR9Eldudho52elkZaS0WIH8y/W7KC6tAiA9LZmpXbD1BP5bUGdGLNfiuuZ+07HhGGNMYvlk+VbKK2sA1yL6+pEjSU1JBqC6ppbi0ir27K2kqLSK4hL3f1FJJSVl1aGq4k2pqKqhYlcN23aV7fNYanISOVkuWYW6DbPc/90yUljwRUPrabr0JT01uYNfdWLwew3qGAARCahqUERyVLU4uqEZY0x8bdtVxufrdoWWj5g6KJScAFJTkumVm0mv3H3LCtXWBdlbWkVRaSXFJe7/opKGJFY/HXtTqmvr2FlcwU7vGlO4QCAQKgjbLSOVKaN7t+clJjS/XXwTgadx9z4tAH4hIqcCZ6jqyijGZ4wxcVFXF+S9TzeFksHQ/t0ZOSjX9/7JSQHyuqeT1z19n8eCwSClFTUuWYUlr6KSSopKK6msav6W0GBYq+zgcX0bJcyuxm8X333AE8Bib/kmYJe3/rgoxGWMMXH1xbqdoXuMkpMCHDl1cIfNTBsIBMjOTCU7M5WBffZ9vKKqhuKSKvaUVFLsdRkWlVRRXFpJSbm77tWvZzcmjuzVIfEkKr8J6iBVPbJ+QVVrROQO4CfRCcsYY+KnrKKaj8Oqgx88rl+TLaFoyUhLIaNnCn17dtvnsZraOsoqasjOTI3bPVix4neQfoGIHBqxbjpQ0NTGxhjTmX28bGuomy0nK43p4xJnlFyKN4Ciqycn8N+C+h3wmoj8E8jHFXW9ALghWoEZY0w8bC0sZcX6hoERR04bHNUbbk3zfL3rqvowcA7QHTgWyALOVlU/pY6MMaZTqKsL8t7ihpKgIwbmMnxAThwjOrD5vvVYVd8A3ohiLMYYE1fLVhdSuKcccF1pR0wdFOeIDmzWbjXGGKC0vJp5YTfAzhjfr0tNXdEZWYIyxhjgw8+2UFXtBkbkdU9n2tgmxn+bmLIEZYw54G3avpeV+btDy0dNG0yyDYyIO7+VJBYCjwJPqmoTZQ+NMaZzqq2t4/3Fm0PLY4bkMaRf9zhGZOr5/YpwD3AysF5EXhaR80Rk3+JTxhjTySxdVdhoXqXDD7KBEYnC7zDzx1T1FGAY8BLwPWCjiDwsIsdGM0BjjImWkrIqFqxoGBgxa0L/LjcrbWfWpk5Wb8r2OcB7uCoSJwN3i8hqETmq48Mzxpjo+WDpFqprXFXxXjkZTBljAyMSid9rUCOAbwHnASOBF3B1+F5X1VoRuRT4NzAwWoEaY0xHyi8oZs2mPaHlo6YPJvkAKB/Umfi9UXcV8C5wN/C0qkbOffw2cFJHBmaMMdESOTBi3LAeDOyTHceITFP8Jqhhqrq5uQdVdS1wVseEZIwx0bV45Q72lFQCkJ6azGFTrPMnEflNUFtF5Ce4Lr7+wEbgEVX9a9QiM8aYKCgqqWThim2h5dmT+tMtwwZGJCK/CeoPuAERdwGbgOHAjSLSQ1Vvi1JsxhjT4eYu2Ryabr1PXiaTRnbdKdM7O78J6iJgqqpurF8hIm8AHwOWoIwxncK6LUWs21ocWj5q+uADYl6lzsrvMPMKoCxi3U6gsmPDMcaY6KiuqeODJQ2X0ieM6EX/XllxjMi0xm8L6n+B50XkZ8AaYBBwC/CciEyp30hVP+v4EI0xpv0WfbmN4tIqwE2pfujkAXGOyLTGb4L6vff/+xHrTwKu8X4OAskdEZQxxnSkPXsrWazbQ8uHTh5AZrrv6fBMnPj6DamqlfU1xnRKwWCQ9xdvorYuCEC/nt2YMKJnnKMyfvj+CiEiQ4Bv4IaZ5wPPqIZ9JTHGmAS0ZnMR+dv2AhAIBDhq+mACARsY0Rn4ahmJyCmAAmfjhphfCKwUkcOjF5oxxrRPdU0tc8MGRkwa2Yu+PbrFMSLTFn5bUHcC31XVp+pXiMi3gXuBg6MRmDHGtNf8L7ZRUl4NQGZ6CrMn9Y9zRKYt/F5bGgL8N2Ld/+EKxxpjTMLZWVTO0pUN86seftBAMtJsYERn4jdBPQ/cELHuIuDVDo3GGGM6gBsYsZm6oBsYMbB3NjK0R5yjMm3l9+vEQODbInI5DfdBTcBdh/q0fiNVnd7xIRpjTNuszN/N5h1u0oWkQICjpg+ygRGdkN8E9aj3zxhjElpldS0ffrY1tDxlTG965WbGMSKzv/zeB9VkchKRbqoaWQLJGGPiZv7yAsoq3MCI7MxUZk2wgRGdld8ZdScDv8V19dW3k9OAYUD36IRmjDFts2N3OZ+tKQwtH37QQNJSrcBNZ+V3kMQDQDHwEbAd+CeQBfwmSnEZY0ybBINB3lu8iaA3MGJIv+6MHpwX56hMe/hNUFOAS4A/Aemq+kfcDLrfilZgxhjTFivW76JgZykASUkBjpxmAyM6O7+DJAqBamAtMB5AVT8VkeF+dhaRC4Af4wrKlgHXqupCEbkJ+K4Xx+PAzaoabNMrMMYc8Coqa/h4WcPAiGlj+9Kje0YcIzIdwW+CWoSbTffnwCYROQcoB0pa21FEBDcj73RV3eqVTXpWRK4AvomrRFELvA58Afynza/CGHNA+2T5VsorawDo3i2NGeP7xjki0xH8dvFdi7vvqSfwU+Ah4FngFz72rQS+r6r1X28W4grOngP8S1VLVbUCeBi4oA2xG2MM23aV8fm6XaHlI6YOIjXFBkZ0BX6HmW8CTvQWN4tIT9y1qFIf+64H1gOISAC4G3gBGIBrNdXbBAz2G7gxxtTVBXnv04aBEcP65zBiYE6cozIdpS3TbZwEjABSw9ahqvf63D8LeARX1+8kXFde+PWmAK6rzxhjfPl83U6273a3YibbwIgux+99UH/G1d5bClSFPRTEVTRvbf+hwIvACuAYVS0XkXzcfVX1BuJaUcYY06qyimo+Wd4wMOLg8f3IzU6PY0Smo/ltQV0AHKyq2tYDiEh3YA7wqKreHPbQ88CvROQBoAaXAB9p6/MbYw5MHy/bSmWV63TJzU5nutjAiK7Gb4LaCazbz2Ncjas4caaInBm2/jjcQIv5uKoUz+NuADbGmBZtLSxlxfqGgRFHTh1ESrLfMV+ms2gxQYlI/dXGfwD/EJH/B+wO30ZVi1t6DlW9Hbi9mYd/6/0zxhhf6upcxYh6owblMmyADYzoilprQe3BXWeqv+p4XthjAe8xG89pjImZZasLKdxTDkBqchJfmToozhGZaGktQY2ISRTGGONDSXk1874oCC3PmNCP7t3S4hiRiaYWE5Sqbghf9oaKW4vJGBMXHy7dQlW1GxjRo3sGU8f0iXNEJpr8DjP/OvBXXAWIetbFZ4yJmY3b9rJqY8Ml8COnDSLZBkZ0aX5H8d0GPIgr6FodvXCMMWZftbV1fLBkc2h5zJAeDOlnU9F1dX4T1DDgVlW1Sg/GmJhbuqqQXcUVAKSlJnP4QQNb2cN0BX7bx28DJ0QzEGOMaUpJWRULwgZGzJrQj+zM1Bb2MF2F3xZUKfCCiCwAtoU/oKrf6PA9OYBmAAAdDUlEQVSojDEG17X31oJ8qmvrAOiVm8mU0TYw4kDhN0GtxF2HMsaYmKirC/Lm/Hw2bW+Ydu6oaYNISrJisAcKv9Nt3Nz6VsYY0zGCwSAfLNnM6k17QusOmTSAgX2y4xiViTW/w8yfbe4x6+IzxnS0RV9uZ9mawtDyQaP7cPA4KwZ7oPHbxbc0YrkXcBauRp8xxnSYz9fubDSNxpghPfjK1IE2z9MBaL+7+LxpMu7r8IiMMQesNZv2MOfThkKwQ/p15/iZQyw5HaDacxv2GmBKRwVijDmwbd5RwhvzNoSmb+/boxsnHzrcqkUcwPxegzo9YlUacC6wrMMjMsYccAr3lPPyh+uorXPJKS87na99ZQRpqVZJ7UDm9xrUPRHLtbih55d1bDjGmANNUUklL3ywNlQEtltGKqcdMZJuGXYz7oHO7zUom3bDGNPhyiqqefGDtZRVuBKfaanJnH7ESHKz0+McmUkE1rlrjImLqupaXpq7jj0llQAkJwU49fAR9M7LjHNkJlFYgjLGxFxtbR2vfrye7bvLAAgEAnx19jAG2Y24JkyLCcqboNAYYzpMMBjkrQUb2bhtb2jd0dMHM2pwXhyjMomotRbUOgARsRtyjTHtFgwGmbtkS6OJB2dP7M/Ekb3iGJVJVK0NkkgVke8C54rIf3Gz6Daiqi9EJTJjTJez6MvtLF29I7Q8eVRvZozvF8eITCJrLUH9Bvh/QDpwbxOPBwFLUMaYVn2xrnEJo9GD8zhi6iCrEmGa1WKCUtW7gLtE5EtVHRejmIwxXcy6LUW8u6ihhNHgvt05YdZQmzrDtMjvfVDjRCQHOBUYAhQAL6vqzmgGZ4zp/LbsKOH1TxpKGPXpkckph1kJI9M6X58QEZkMKPBL4Bjg58BKEZkexdiMMZ3czqJyXv5oHTXejLi52emc9pWRVsLI+OK31NEfgTu9Lj8ARORH3vojoxGYMaZzKy6t4sUP1lJZ1VDC6HQrYWTawG8bexouGYX7IzC1Y8MxxnQF5ZU1vPDBGkrKG0oYnfYVK2Fk2sZvgtoFTIxYNxHY1rHhGGM6u+qaWl6au5Y9extKGJ1y2HD69LASRqZt2lLN/BURuQfYAAwHrgV+H6W4jDGdUG1tHa9+tJ5tuxpKGJ0wexiD+3aPc2SmM/I7iu9PIlIBXAj0BfKBn6rqE9EMzhjTeQSDQd5euJH8sBJGR00bxGgrYWT2k98WFKr6IPBgFGMxxnRSwWCQuUu3sDK/oYTRrIn9mTSqdxyjMp2d3YhgjGm3xbqDpasaShhNGtmLmVbCyLSTJShjTLusWLeLj5ZtCS2PGpzHkdMGWwkj025+b9S1UsPGmH24EkYbQ8uD+mRbCSPTYfy2oJaJiA3DMcaEbC0s5fVPNlBXX8IoL5NTDh9BipUwMh3E7yepEBgWzUCMMZ3HzqJyXvpwbaiEUU5WGqcdMZJ0K2FkOpDfUXz5wHwRWQZswU2zAYCqfiMagRljEtPessYljDLTUzj9iFFWwsh0OL8JaoH3b7+JSAB4BFimqneKSDJwF3CSF8edqvq39hzDGBNdFZU1vPD+2lAJo9SUJE47YiR53a2Ekel4fm/Uvbn+ZxFJU9WqthxERMYDfwFmA8u81ZcDY4FJQHfgYxH5VFXnt+W5jelq9uyt5PN1O6muqSM3K4287unkZKWRk5VOakr8ru9U19Ty4ty17N5bAdSXMBpB3x7d4haT6dp8JSgRSQJuAq4E8kRkCvB34JuqWujjKa7yts8PW3cm8ICq1gC7ReRJ4ALAEpQ5IAWDQZav2cmHn20JXduJlJ2ZSk5WOrnZaeRmu8SVm51OblYaGem+77tvs9q6IK99vKFRCaPjZw1lSD8bO2Wix+8n+lbgKOAS4P+A7cBuXKvo3NZ2VtWrAUTkq2GrhwAbw5Y3AVN8xmNMl1JSVsXbCzeyMaxMUJPblVdTUl7Nlia+FqanJZPrJa/6JJaXnU5OdjpZGSn7fV9SMBjk3YX5bCgoDq07cuogxgzpsV/PZ4xffhPUBcAsVd0mIkFVLRGRi4B17Th2EmGDLYAAUNuO5zOm0wkGg6zauIf3Fm8KDToA6JWTgQzrSXFZFUUllRSVVFJSVh0a0t2UyqpatleVsX132T6PpSQnNbS2stPIzUonx/u/e1YayS3ct/TRsq18uaGhhNHM8f2YPNpKGJno85ug0oAS7+f6T3IdUNOOY+cDA8OWB+JaUcYcECoqa5jz6SZWb9oTWhcIBJg2tg+zJ/bfZ0r02rogJaGEVUVRqfu/uKSSotKqZrsFAWpq69hVXMGu4op9HksKBMjulhrqKszx/s/NTie/YC+LdXto24kjezFrYv8OePXGtM5vgnoNeEhErgGCIpIO/AF4qx3Hfh64REReBLKBbwFXtOP5jOk01m8t5p2FGymrqA6ty8lK4/iZQxnYJ7vJfZKTAl4LaN8Rc8FgkNKKGpeswpOX939FVfPfJeuCQYpLqygurWrU5x5p1KBcjrISRiaG/CaoG4B/0jBBYQkwB/h2O459HzAKWIprod2vqu+14/mMSXjVNbXMXbqFz9fubLR+4sheHD5lIGn7eaNrIBAgOzOV7MxUBvbZ9/GKqhqKm0hcRSWVoSHjLRnYO5sTZg+zEkYmpvwOM98DnC4ifXEVJbao6ua2HkxVLwr7uQa4vq3PYUxntaWwhLfm51Nc2nCXRreMVI6dMYThA3KieuyMtBQyeqbQt+e+Q8JrausoLnXJqrikij0llRSVup9Lyqvp3yuLkw4dZiWMTMz5HpcqItNx3XADgQ0i8qiqroxaZMZ0EbW1dcz7vIDFK3cQDBvkMGpwHkdPH0xmFIeH+5GSnETPnAx65mTENQ5jIvmtZn4h8AEuOW0ERgCLROTUKMZmTKdXuKec/7y9ik91eyg5pacmc8KsoZx0yLC4JydjEpnfv47/B5ykqh/UrxCR44F7gJejEZgxnVldXZDFK7cz7/MC6uoaWk1D+nXnuBlDyO6WFsfojOkc/CaoPOCTiHXv4262NcaE2bO3krcX5LN1Z2loXUpyEodNGcDkUb1tFJwxPvm96vkQcLuIpEKj0kePRSswYzobV6qokP97Uxslp349u3HuCWOZMrqPJSdj2qDFFpSI7MZVe0gCcoArRKQA6O0tr416hMZ0AiXl1byzMJ/8goZSRUmBALMm9me69LXh2cbsh9a6+M6ISRTGdGKrNu5mzqeNSxX1zMng+FlDrdK3Me3QYoKKvHFWRLLx3y1oTJdWUVnDe4s3s2pjQ526QCDAQWN6c8ikAXbfkDHt5He6jW/iKpf3DFsdwHX/2RzP5oCzoaCYdxZspDSiVNFxM4cyqJlSRcaYtvE7iu9u4GbckPLmK1Ia08VV19Ty4dItLI8oVTRhRE++ctCg/S5VZIzZl98ElQ7cp6o2HYY5YG0tLOWtBfkUlVSG1mWmp3DsjCGMGJgbx8iM6Zr8dpL/FfiliNj0meaAU1tbx8fLtvLsnNWNktOoQbmc91Wx5GRMlPhtQS0D/g38j4jUrwsAQVW1Pg3TZe0sKufN+fkU7ikPrUtLTebIaYOQoT3sviZjoshvgvoj7sbcd7BZb80BoK4uyJKVO5j3+VZqw0oVDe7bneNmDqG7lSoyJur8JqhMVb0zqpEYkyCKSlypoi2FjUsVHTp5AFNGW6kiY2LFb4K6T0RuAW7x5nEypssJBoN8sW4Xc5duprqmYbBq3x7dOH7WUJuOwpgY85ugvgZMAX4mIqW4+58AUNWeze5lTCdRWl7NOws3sqGgOLQuKRBgxoR+HDyuH8lWqsiYmPOboK6LahTGxNHqjXuY8+kmKqoaOgfyuqdzwqxh9GtiBlpjTGz4nfL9vda3MqZzqaiq4YPFm9H83Y3WHzS6D4dOsVJFxsSb31JH9VXN92FdfKYz2rhtL28vyKekvKFUUXZmKsfNHMqQfna7nzGJwG8XX2RV897AVcBTHRuOMdFVXVPLR59tZdmawkbrxw3rwRHTBpNupYqMSRj73cUnInOAj4D7OjgmY6KiYGcpb83PZ09EqaKjpw9m1OC8OEZmjGmK3xZUc/v27ahAjImW2to6FqzYxqIvtxMMNvRUjxiQwzEzhtAtIzWO0RljmuP3GtTdEavSgJOB1zo8ImM60M6ict6an8+OiFJFRxw0iHHDrVSRMYnMbwuqR8RyLXA/8LeODceYjlFXF2Tpqh18srxxqaJBfbI5buZQcrKsVJExic7vNaiLox2IMR2luLSKt+bns6WwJLQuOSnAoZMHcNCYPtZqMqaTaDFBici1rT2Bqt7bceEYs/+CwSAr1u/igyWNSxX1ycvk+FlD6ZWbGcfojDFt1VoL6sxm1qcBhwJVgCUoE3dlFdW8u3Aj67Y2LlV08Li+zBjfj2S76daYTqfFBKWqx0SuE5FJwBOAAudHKS5jfFuzyZUqKq8MK1WUnc7xs4bSv1dWHCMzxrRHm4aZi8j1wG3AI8CPVLW85T2MiZ6KqhrmLtnMlxsalyqaMro3h04eSGqKtZqM6cz8DjMfAPwTmAx8U1VfjmpUxrTCShUZ0/W1mqBE5CzgAWAuMFlVd0Q9KmOaUVNbx8fLtrJ0VeOPoQztwRHTBpGR1p57z40xiaS1UXwPA9+h4Z6nAV5rKkRVP4teeMY02LarjLfm57N7b0VoXUZaCkcfPJjRVqrImC6nta+b3/X+v8L7FykIWHVNE1W1dUEWrdjGwhXbqAsrVTR8QA7HHDyErEwrVWRMV9TaKD67ymzialdxBW/Nz2f77rLQutSUJL5y0CAmjOhpN90a04VZh71JSMFgkM9WFfLx8q3U1DbcdDuwdxbHzRxKbnZ6HKMzxsSCJSiTcPaWVfH2gnw2bW9cqmj2pAFMHdOHpCRrNRlzIIh7ghKRU4HbgXTgM+B7qlrc8l6mKwoGg+iG3by/ZDNV1bWh9b3zMjnBShUZc8CJ6zUmEekDPAycpaoCrAV+F8+YTHyUVVTz6sfreWtBfig5BQIBDh7Xj3OOHWPJyZgDULxbUF8FFqjqKm/5PmCpiFylqsEW9tsvJeXVvL0gn8I9VgAj0VTX1DW61mSliowx8U5QQ4CNYcubgBygO9Dh3XyrN+5m47a9Hf20poNNGtWbw6cMIDXF7mAw5kAW7wSVhLuXKlJtE+vabUi/7mRnpjYqj2MSR05WGkdNH8yw/jnxDsUYkwDinaDygdlhy4OA3apaGo2D9crN5DunTKCiqqb1jU3MZaan2H1NxpiQeCeoN4C7RGSMdx3qCuD5aB4wKSlAtwyrPGCMMYkurqP4VHU7cDHwtIiswFVL/2E8YzLGGJMY4t2CQlVfAV6JdxzGGGMSi9XaM8YYk5AsQRljjElIlqCMMcYkpLhfg2qjZICCgoJ4x2GMMaYDhJ3P97kzv7MlqAEA559/frzjMMYY07EGAGvCV3S2BLUAOALYSpSqTRhjjImpZFxyWhD5QCAY7PCarMYYY0y72SAJY4wxCckSlDHGmIRkCcoYY0xCsgRljDEmIVmCMsYYk5A62zBz30TkVOB2IB34DPieqha3dZuuwuf7cQHwY9wkkmXAtaq6MNaxxkJbfvcicgbwmKp2j2GIMeXz8zEZ+BOQi7vN43JVXRTrWGPB5/txJnAzUAfsAi5V1TWRz9VViEgAeARYpqp3NvF4h59Pu2QLSkT6AA8DZ6mqAGuB37V1m67C5/shwB+Ak1R1KvAb4NlYxxoLbfndi8gY4E6gy86k6PPz0Q03f9vvVXUacCvwRKxjjQWf70cm8DjwDe/v5UXg3ljHGisiMh54Gzi7mcejcj7tkgkK+CqwwJsEEeA+4HzvG0Bbtukq/LzWSuD7qrrVW14I9BeRtBjGGSu+fvfeSflx4MYYxxdrfv9e1njT4wC8AHwzhjHGkp/3Ixn3pSXXW84GKmIXYsxdBfwdeKqZx6NyPu2qXXxDgI1hy5uAHKA7UNyGbbqKVl+rqq4H1kOoKX838IKqVsUy0Bjx+7u/3/v3WexCiws/78dYoEBEHgIOAvYAP4llkDHk5++lRESuAD4SkZ24hHV4rAONFVW9GkBEvtrMJlE5n3bVFlQS7jpKpNo2btNV+H6tIpIF/AcYDXw/ynHFS6vvh4j8AKhR1X/ELKr48fP5SAVOAR5Q1Rm4a1GviEh6DOKLNT+fj8nAL4EJqjoQuA14pov2wPgRlfNpV01Q+cDAsOVBwG5VLW3jNl2Fr9cqIkOBj3AfqmNUdU/sQowpP+/HRcBMEVmCm/E5U0SWiEj4fl2Fn/djC7BCVecBqOrzuFbDyJhFGTt+3o8TgQ/DBkX8BZgE9IpNiAknKufTrpqg3gAO8S5wA1wBPL8f23QVrb5WEekOzAGeVdVvqWp5bEOMqVbfD1WdpaqTvAvgpwDlqjpVVbfEONZY8PO38CowQkQOBhCRI3HfmNfFLMrY8fN+fAocJSL9vOUzgHWqWhijGBNNVM6nXbZYrIicghvymIYr4f4d3Le9v3snnSa3UdVd8Yk4ulp7P0TkJtzIvWURux6nqjtjGmwM+Pl8hG07HFiuqtmxjjNWfP69HIkb6ZmFG1RznarOjU/E0eXz/bgKuBqowg0zv1pVP49PxLEhIo/g/hbuFJEZRPl82mUTlDHGmM6tq3bxGWOM6eQsQRljjElIlqCMMcYkJEtQxhhjEpIlKGOMMQnJEpRJWN7w7mg874hoPK9pmr3fZn911Vp8BywR+RtwGTC5LfdkiMj5wFWqelg7jn0RcH3kfUT7+Vy/x91PcX17nyvieX8AnACc2cI238MVxxwLlAPzgN+q6kfe48NxN6j2wNUb+wIYpKpF+xHP6cAJqnpNG/a5AThKVc9o5vF2/y47ip/3OxGIyB8AVdW/t2GfvwFFqvrTVrbrBTwHHK+qle2L9MBiCaoLEZFs4FzcnC3X4O7m9kVVnyCxpk/oiytIGo3nbbZemoj8CVfG5lpcZY0k4EJc3bmLVfW/4duraj6uknWbedU7/gD4SiTe7/dXwA9x1cSblGC/yxbf7wTyNeCutuygqr7+vlR1p4g8B/wC+J/9iO2AZQmqa/k2sBh30lsgIjep6m6vZXOpt8044BjcCe514Bu4Mjbv4For03FVza9V1ecgVBjzY6A/rtVwL3Aw0AdX6fsyVV3aUmAiMsd73hNx31SPFpErgSuBYbjKBA+r6k9F5EbgfCAoIqNU9TQRmRB23G3ALar6r2aOdRbwM2AU7uT4X+By4HTg50CSiCxV1YMi9pvhvU9jVDW8MvP9IlLt/f9SxD7DaWhN5QHLcUVEf4T7+3oG15qpayLUy4G59ZU6vPdoHu5kORSXIL+vqtu87V8GduAqrA9o6rV7z3MRXkvW+/l8XHXpbwCFuDmd7m9m34uBm7znXwpcoarLvdieU9U/NnGM+rmADgf2Am/hWqCnEPF+e6WS7gSmAduBP6rqX8Ne/5u4OYfGeq//ZuDPwHhgLvBNVd0rIhnAb4FzcIVsnwduVNXSZj7vB+OSQ09gNfALVX3NO+5YoFhVC7xKCTuAWd4+n+G+rPwOOMRb/qaqbvK23aOq13s/l+Dq8c0AVgLXqOqHXhwPA6tF5O6uWq0mGuwaVNdyOa70yArcfE7fC3vsMNwkcyNoKGc0BpccQt1L3on0cVyyq3c+rkZfCfAQrqz+KNwf+xrcicKP2bgTzddF5DBcBehzVTUXOBW4QURmqurduBbAX73klI07cb2G+0Z+IfC/InJE5AFEZBjwGHCDqvYEZgKnAWeo6jNerC9FJifPabgCoBubeOwJ3Nw/rU2pkAVMwb0/J3qxntjMtt/HVY4PdzFwAe7LQAXwaNhj56nq2bgE3RbHA5/gCpneDtwjInmRG3lTKdwDXIJ7ra/jEmxrfolr7fYFpuJO7GdHvt9eInsbN7lfH+BbwC9E5Lyw5/oBLpEOwU3r8R/gPNzndDSuiC/A73GJYAYg3rHDJwwM/7xvBR4ETlfVHrgE/6ewyuNfp3GL9ArcHGB9cN3MbwM/9Y5RC9zQzPvwXdwUJL1xXxTvrn/AS0oLvNdifLIE1UV43/6HAE97q+4DrhKR+t9xoaq+pqrFqlpf3+oZVS1r4trJo8DXRKS790d8HvBP77Hv4Von4L7l76JxFeOWvKSqe7zjLQGmquoKr4++G27emKae61TcN9w7VbVaVRcA/6DpLsytwERVnSsiubiTTKHPGAcABU094F072I1LHK25XVXLVXUxrhUyOnIDEemPO7HOj3joL6q62KsCfRPwVe/9oR2FagtU9X5VrcH9btNxn5VI5+Omtp/rfVG5A/hO2GeoOUW4RHEWrsU6TVUfa2K704Gtqnq393v8lIaEWO9hVV3nndAX41pta7zlj3EFawO45P5jVd3mfZ5+BlwUNv1H6POOS/TVwPe8v5OHgbFhfwen0ThBPa+qi7yCyR8D73rLZcC7uKTXlJdUdb6qVgBPsu/v/RPgyGb2NU2wLr6u43Lct958EQH35aMP7o8P3HQJkZo84amqishnuAvb673nesd7eCzu2+sQYAXuj9/vNYbw49UCN4nI2bgE8ikNs5RGGgaMFpHwa1LJ3j6RqoFLvIEO5biTXKbPGLcBRzf1gLgpvvvSTAJr4nnC40luYpshQIWq7o5Yvzrs5024uPsC7SnYG4pHVau9z0dTMfXDDfio37YK1+WIt09zbgHqcNfHngDmishlqqoR2/UFNkSsW0/jZBn+OmtpfB2yjobPdSbwhoiEFxOtxn1WIOyz5nUJHotL+HOAMuCPInI7rhdgoKqGF0n2E0NTWvu9b8W1Zo1P1oLqAkQkB9fKORnXxTIV1830Z1z/OTQ9mVhLlYIfxU3pfR7wuKrWiUgqbjTSH1S1r6oehet28yv8eDfirneNUdXxuG6t5pLIFmChqubV/8O1Pr7VxLbfwrUEZqjqKK9LzO/ouueAWd71rkgX4U5cH/l8rtY0d6IbFPbzMNwJcmsHHbM1m4HB9Qsikioid3ot0Vpcd1e98HmPJgN/836Pw3HXlv7SxPPn05BA6o2k8YndT/XqnbgK4rPCPg/9cNe16udnCj2PiPQAklX1dNy1wotx3ZKH41rnr9BYtCpoJ9M1J0SNGmtBdQ3nAxtV9Z3wlSJyP+5607P78ZxP4q5XVAFHeevScd9cy7znnw5cV7/cRrnec1eLSDfcCKdcGk6Cld4yuBPI3d7F78dx37hfB/4F/LqJ560FKr2EegUuWTf1vI2o6iIR+TPwgjeVwntABi5J3wFcoqpVrbQm/NoIpIlIL208nclV3oivrbgL889r7CaOfAI3K+xjwCLcQI+vAT/GXfQ/U0QewA2tvxio8fa7Hjeh40W45FROw0k+8vf4R2+Y/J9xAwquxSUL31S1VkQeB+7wWsoluIEXJ+O+uETqg2ttnayq74nIZi++3bhux7+15fjtMIDG06KbVlgLqmu4HHeybkRVl+NONHfvs0crvK6nN4EN3qALvEESlwF/FZEiXF/+/cAwbyBDW9yFS2wFwFrctZ03cSctcBfHTxeRud71h5NwrZgduFbMf3EXwSM9iuv6W4trERwL/DvseV8CxohIkycKVf0hLundgvtmvxb3LfsUVX26qX32h6pux434OzTioQ9xAxM24d6f7xEj3hecG3DXG3cBX8UNLgni5gorwrWCXsQNRKl3A+5cko/7/eTRcP9a6P32PlMn4Sb3K8T9Dn+vqg/sR7jX496jpbjf01jgZFXdp4WiqitxfyMPikiJd9xrgVW4kXnv7cfx98chuM+48cnmgzImTkTkJ8B4Vb3YW55D2FBu03V4Ixi/wHVpx6pF3OlZC8qY+PkLcLR38jJd26XAfZac2sYSlDFx4g0lvwHXnWi6KBHpjRtN6/d+QeOxLj5jjDEJyVpQxhhjEpIlKGOMMQnJEpQxxpiEZAnKGGNMQrIEZYwxJiH9f/vnLtlJnhWTAAAAAElFTkSuQmCC\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('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": 45,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sweep_p1(p1_array,p2,num_steps):\n",
+    "    sweep=SweepSeries()\n",
+    "    for p1 in p1_array:\n",
+    "        state=run_simulation(p1,p2,num_steps)\n",
+    "        sweep[p1]=state.olin_empty\n",
+    "    return sweep"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap04-fig_ex_1\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xl8VOX1+PHPZCWQhLAEQgj7ctgXUVDElaK49Fv129ZabWtt7aLWttZvt1+/VmtXa/1Wu1i1VmvdWuuGiltRFkURVAQUjkDYAgkESICErDPz++O5GSYhyw1kJtt5v155JXPvnXvPhDBnnuc+z3kC4XAYY4wxpqNJaO8AjDHGmMZYgjLGGNMhWYIyxhjTIVmCMsYY0yFZgjLGGNMhWYIyxhjTISW1dwCmexGRnsCNwOeB4cA+4FXgF6q6Meq4rcDtqvpHEbkZuFBVTzyG62UDe4CLVPXZqO0/A/4X+Jqq3he1/QbgB0COqjY7B6NBjA8C6ar66dbG2OCcZwKvAxmqWnY852rk3A8CX4raVA1sBH6uqo97xwwHtgCTVXVd9Gts41hu5hj/TU33YS0oEzdecnoduBT4MSDAfwOpwEoROaWJp94OnHss11TVYuAjYFaDXXOBAmBeg+2zgcUtJadO7HlgkPc1HvgT8A8RqUsUO7x9G9onPGOOsBaUiaebgX7ACap60Nu2DXhbRO7HvVGOV9Wa6Cd5LYnjaU0sBk6ueyAi6cBM4AbgpyISiEpIpwA/O45rdXRVqloU9fhuEbkauAxYpapBoKjxpxoTX5agTFyISAJwNXBTVHKK9r+4Fs25uE/50c+9Ga87yOsC+zcuufwM6AMsBb6qqrubuPwS4IsikqCqIeAMYCfwIHAHMB14z+veygVe866bDNwKXAmkAW8D16uq+ni9s7xzz8C1Su7DdZWFRCQJ+D/gM0Bv4F3gBlV9p5HzZAC/Az4NhL3Yvq2qu0Tk+8B1wLC6BCsipwMvAgNb0UW4N+p6w4nq4msQy0jgTeBJVb3O23Yj8C3cB4/VwI2q+ra3byLwR+AkoAJ41ou93DtloojcBnwF9170OPAtVa32nv9d4Ju4ruAy4AXgm6pa5v1NzML1Ap2M+3f5e3PxmM7HuvhMvIwFsnBv8kdR1V3Ax7gWTEuygG/gugcvwr1R/aSZ4xcD6cBE7/EngEWqeghYxZFuvtlAQdS9sJ8BF+C6JGcBCiwRkd7NBSciA4CXgZeAycD1wLXA971DvgXMBz7pxfQx8G8RCTRyuntxXaHn4hJrGHjZS3KPAIOBU6OO/zzwrJ/kJCIBEZnnve5HWjg2B3ev8AUvfkTk68C3gWtwSX4h8JqIjPCe9ijudzbFe61zgR9GnXYa0BeXYL4AfNn7QkQuw7W4bwDG4D4kfAr4etTz5+M+nJwMLPQRj+lkrAVl4qWv931/M8fsA/r7OFcirsXxLoCIPExUF15DqrpHRNbjksxa3Bvlr73dr3mPf4N7o69rPaUB3wXmquqb3rHXi8i5uDfT5gYNXAusVNVbvccbReRHwF3edYcDh4GtqlrsDcyYToMPjF6L5XNAnqru9LZ9Adfima+qz4vIEu+YN7wW36epPxCioYtEpC55pQDJwD+ANc08Jwt4Bffh4mtR3aE/Bn6oqi94j3/ptXCvxQ2EGQ4sALapar6I/BduYEadEuAbqlrr/Y6WAlO9fbuAK1W1rjW9zXutE6KeXwH8ymsVIyItxWM6GUtQJl7qElNmM8dkEdXd1IKPo34+iHujRUReBE6L2jdBVbfjuvlmicgCYBJeIvK+Xy8iibiWxJ3e9lG4wRuviEj0gIkeuBZNcyYCZ0YlAnDJJ01E+uGS26eAXSKyHPcm/qCqBkXqnbruzVgbbO/pxfA8Lrn8WkS+jWtlhXHJpCmv4rWAcL+z8bhBKPcCVzXxnJ/gktnCqGSQDgwF7hORe6KOTQWqvJ9/gBuE8U0ReRl4QlWfiTp2m5ec6pTiulJR1SUicqKI/BwYh/udCvBQ1PFbWhmP6WQsQZl42QQUA3OA9xvu9IaDC010ATaiusHjuu6xr+K9yXl2ed8X4z7xnwWsjxoo8Cbu/8GpuO64usRV939jHm6YerTG7qFFSwKepPFuxwOquk9cxjkPOB/4HvBtEZnZyHlqcK2rhqMK6xL+k7gkcCZuoMO/Gg4yaaBcVTdFPV4vIqnAI16Sa8xS4O/AgyLyiKquxbViwbXWGv57VgCo6l9E5HngYlx33L9E5O+qerV3XLCRawUARORK4G7gAdw9tVuBWxq7jqfFeEznY/egTFx4n5T/AtwoIn0bOeRnwHbcfZvjuc5OVd0U9VX3CX0xrrUwD1gUdXwl8BbuRv1Wr7UFLqHWAgPqzgVsxt0XaZhIGloPjIuOw7v2TUDIGzV3kao+o6pfw92fGwic3sh5koFeUecpBH7rPQdvwMlzuHtx59HCvaQmJDT43tACVX0El7zv8UY9HsCN9hvc4HVeB5wrIpki8kcgrKp/UNULvH2X+4zpWuC3qnqNqt6P64Icw5EPIvW0FI/Pa5oOxlpQJp5+gbvR/6Z3v+Bd3Bvzt3BdXue18On/mKnqbhHJx92vafgm+RrwI6Le3L2RYn8G7hSRKtyE1u/iEsFPW7jcn3Ddhnd5Pw8B7sENXgiJSBZwq4js9857Aa4FsBo3irAuBvW6JB8SkWtxLdBf4O63Rc9T+gfwBFCoqstbiC3VG/AA7s1evNfzoqoeEJE+zTz3W7h7eF/Hfdi4DbhJRAqBlbgBGtcBZ6jqQe/+T66I1LUkL/KO82MfcJaITPDi/C6uy3NtM89pMh6f1zQdjLWgTNyoahWuBfMg8HPcm+wzQAg40ceb6/FajOv+W9Jg+yLcfZ3XGmz/Pm5I+wO4T/An4JLo5uYuoqp1w+VPBD7AJZB/At/xDrkDdy/lAdwot68D/62qHx99Nr6EG2n4DO5NtzcwT1VLo455CTfo4tHm4vJciGuFFeKG9T+Ku2f1xZae6MV3O/ArL8nd6T2+DTcZ+rPAp6MGlVyC+70uB1YAlbik4ce3cd2aq4D/4O4l/Qr3b9CUluIxnUzAVtQ1pnPzWj2FwDRVtQoQpsuwBGVMJ+WVjjofNzgiS1XntnNIxrQp3/egvDkWw3A3iunCtcqM6SyCuOHhxcB/tXMsxrS5FltQ3oTFP+BmclfhSrcswE0UzI91gMYYY7onPy2oO3D1zibi5qhsxpVx+RNuWGu78+ZxnITrh29sboUxxpiOKRFXQX+lN5Aqwk+C+hQgqnpIRMKqWuMVZCyMQaDH6iRgWXsHYYwx5pidBrwRvcFPgqrFDfE8xJFJcr2A8iaf0YCI/A5Xublu9ruq6qVefbIveXE8DNyiqmGvqsBDuHteIVz9r+aGIBcCPPLII+Tk5DRzmDHGmI6kqKiIyy+/HBpp9PhJUP/GVVr+HwARGYObZ/B0K2KYDXwuOsmIyPm4eQozcN1yL+PmLvwL1324TFXPE5FpwAsiMkZVDzdx/iBATk4OeXl5rQjLGGNMB3HU7Rk/E3V/hJukuBg3SXANbpb3j/1c0bs/NB34voisFZEnRWQorj7Xo6pa7pWbeQC4wltG4ELc+jmo6mrcbPv5fq5njDGma2ixBeXdtLoeV7olG9hXV0HYp7oF4H4CfIgre/8srgDnoqjjCoA83HILCd5S3Q33GWOM6SaaTFAicn0z+wBQ1btauoCqbsFNJqx77u241VP3Ur9CcwDXxEvg6MrNdfuMMcZ0E821oC5u4blh3AJszRKRKcBUVf1H1OYAsI2owpjezwW4llVARPqq6v4G+4wxxnQTTSYoVT2rja4RAu4SkTe81tQ3cfexngV+KiL34kYKXolbtK1WRF4AvoZbiG0Krorx4jaKxxhjTCfgq9SRiFyMq/eVi2v53K+qDSs/N0pV14nIt4DnvFVLC4DLVHW7iEwG3sGt1vksR1bLvAb4q4isw7XUvuCt92KMMaaDKKuoISEAPXskx+T8fkod3Ygb2PBXYAdubtLVwA9U9W8xiaqVRGQ4sGXRokU2zNwYY2KssrqWN1bvZMO2ElJTEvns3LH0Tk89pnMVFBQwd+5cgBGqujV6n58W1DXAXFX9sG6DiPwbt0Bah0hQxhhj4mPH7kMsWrmdsgq3tmhVdZCD5dXHnKCa4ydBJQMNi8JuwNXnM8YY0w3U1AZ5c00h6zbvrbd9/PC+5A1Ij8k1mxtmnun9eC/wgIjcoKq7RKQ/bmXLO2ISUTf02GOP8dhjj1FbW0sgEGDChAl897vfJTc3l7PPPps777wTgPvuu4+77mpx4KQxxrSpwr3l/Gfldg6UHanlmpaaxBkn5DE6Lytm122uBVWKG6BQV3/vMyISws1TCuBG3v08ZpF1E7/5zW/YsGED99xzD4MGDSIUCrFgwQIuvfRSnnjiichxkydPtuRkjImr2mCIFR8WsfrjYqLHK4zI7c1ZM/JiNjiiTnMJakRMr9xO3tc9vPNRETW1rSmG0TrJSQnMnJDDdBnQ7HFFRUU8/vjjLF68mN69ewOQkJDARRddxLp167jnnnsix65YsYJbb72V559/nh/+8Iekp6ejqhQVFSEi/OY3v6FXr14xe03GmO5l34EKXnl7G/sOVka2pSQncvr0wcjQPgQCgWae3TaarMWnqtvqvnCj9/YDJd5XOZ00ga3+uDimyQmgpjbE6o+LWzzugw8+YOTIkZHkFG327Nm8++67TT533bp13H///SxcuJCdO3fy0ksvHVfMxhhTp6omyHPL8uslpyEDM/j8OcK4YX3jkpzAxyAJEbkUuAfIaLBrLzAwFkHF0rSx2XFpQU0bm+3r2Nra2ka3V1dXN/tHcNppp5GSkgLA2LFjOXDApokZY9rG22sLI6P0khMTmD01l0kj+8UtMdXxM4rvVlyh13JgLnA78Bvg9RjGFTPTZUCLXW/xMm3aNLZt20ZxcTHZ2fUT2ooVK5g+fTpLly5t9Lk9evSI/BwIBGhpPpsxxvixe/9h1uXvizw++6QhjBnSPoO2/Sy3kauqfwRewa2suxpXlujqWAbWHQwcOJAvfOEL3HDDDezevTuy/cknn+SVV17h6qvtV2yMiZ9QKMzid3dEPvAOzcmI6Si9lvhpQe0SkUxV3SkiI0QkABQB/vqwTLO+973v8cQTT/DNb36T6upqqqurmTx5Mo8//jiDBw9u7/CMMd3Imk3FFJdWAJCUmMAZ0/Pi3q0XzU+po7uAE4BPAX/HTdqtBM5V1akxj9AHK3VkjDHH59Dhah59eUPk/vwpkwcxY1zshxk0V+rITxffjcALuPWYrgUEOA3r4jPGmC5j6fs7I8mpX2YPpo1t/3v1flbUrcZVjgA3effcmEZkjDEmrvJ3HmDLriMjgc+cMYTEhPbr2qvTXKmjpzl6Zdt6VPWSNo/IGGNM3FTXBFn6/pH1YCeO7Meg/h1j0n9zLajVcYvCGGNMu1jxYVFkzlNaahKnTBrUzhEd0dyKurfEMxBjjDHxtafkMGs2HalOPmdqLj1Sfa1jGxfNdfE9oqqXN9fVZ118xhjTObk5TwWROU9DBmYwdmjHWkWpuVS5zvtuXX3GGNPFrMvfy56SwwAkJgTafc5TY5rr4vuV9926+owxpouoDYZYs2kvKz8simw7cfxAsjLafkXc4+WnWGwe8AMglyNrQ6UAE1R1ZAxjM8YY00ZCoTAbtu3nnahBEQBZGamc0EHqkzbk527YA0Airnr5IOBd4IvAn2MYlzHGmDYQDofJ33mAFR8WsT9q+QyA3umpnHfKcBIT/dRsiD8/CeoUXOtpKPA7Vf2OiCzAVtM1xpgObWdxGW+tLaRoX3m97WmpScyckMOEEX07bHICfwnqgKoeFJGNwEQAVX1NRCS2oRljjDkWZRU1vL5qB9uKDtbbnpKcyAkygKlj+pOclNhO0fnnJ0GtE5EbgDuBgyIyC1cstvGV9owxxrSbsooanlm8idKyqsi2xIQAk0f3Z8a4gaR1oHlOLfET6Y3AE8DTwC3AG972m2IVlDHGmNY7XFnDs0s2R5JTIBBAhmYxc+IgMnultHN0reenWOxaYJz3cIuILAMyVFVjGpkxxhjf6pJTySE3ECIhEODck4cxqh0XHDxefoaZ5+PWgfqHquar6q7Yh2WMMcavyqpaFizLZ9/BI8npnFmdOzmBv/WgvoNrQa0RkWUicrWIZMY4LmOMMT5UVtfy7LLN7PVWwg0EAnxi5lBGD+ncyQl8JChVXaCql+HmQN0LXAxsF5HHYx2cMcaYplXVBHluWT7FJUeS09yThnS4mnrHyvcAeFU9BGwBNgOHgRGxCsoYY0zzqmuCPL8sn937D0e2nTUjj3HD+rZjVG3Lzz2oKcDngctwCe1hYK6qro9xbMYYYxpRUxvk+Te2UBg1AffME/KYMKJfO0bV9vwMM38LN8T8auA/qho6lguJyEW4gRYZ3uMfAV/yYngYuEVVwyKSDTwEDANCwNdUdfmxXNMYY7qCYDDEnpIKdu0tY1dxOYX7yqmuCUb2nz59MJNG9W/HCGPDT4LK8br3jpmIjAFuxys2KyLnA58FZgBB4GXgI+BfwJ+AZap6nohMA14QkTGqerjRkxtjTBcTDIYo3FfOrr3l7Coup2hfObXBxtsGc6bmMmV0dpwjjA8/Caq3iPySY6xmLiI9cS2kG4BHvc0XA4+qarl3zAPAFSLyFHAhcC2Aqq72SizNB57y/aqMMaaTKjlUyXPL8jlYXt3scelpyZw0IYeJI7tWt160eFQzv8f7WhO1bQiwKOpxAZAH9AcSVLW4kX3GGNOlVVTV8sIbWxpNTpm9UhicnU5u/3Rys3uR2Sulwy0w2NZiWs1cRK4BalX1byIyPGpXAvWXkQ/guvoabo/eZ4wxXVYwGOLF5VsiZYqSEhMYN6wPudnp5PbvRXrPzleq6Hj5GWZ+QFUPAvWqmQN+qplfCZwkIquBhUCa93MBLunVyfW27QECItK3kX3GGNMlhcNhFq3awa69blReIBBg3syhnDnDzWnqjskJ/CWoumrmtXjVzEVkKj6qmavqTFWdpKrTgPOBCu/np4HLRaSXiKTiEtkzqloLvAB8DSJD3CcAi1v/0owxpnNY+dFuPt5eEnl8yuRBnb5MUVvwk6BuxCWMoRypZr4K+P2xXlRVn8MNengHWIe7r/WQt/sa4FQRWQc8AnxBVQ8c67WMMaYj0237eeejosjjiSP7MX1s1xyV11qBcLjhLZ/miUguHayauXd/a8uiRYvIy7PxFMaYzmFXcRnPLt1MMOTeh4cMzODCOSNJTOjagx+iFRQUMHfuXIARqro1el+rV66yaubGGHP8Sg9VsXD51khy6pfZg/mnDO9WyaklHXcxemOM6aIqq2p5/o18Kqvdrfy01CQumDOS1OSOvwx7PFmCMsaYOAoGQyxcvrXecPILTh3RKVe8jbVWJygRsRRvjDGtFA6H2bijhMdeUXbtLYts/8TMoeT069WOkXVcLSYoERkpIvd6P18IHBKRXSJycsyjM8aYLmDH7kP8a9HHvPz2tkjLCWD25FxG23DyJvkZJPFnYKeIBIDfAj8DSoC7gJkxjM0YYzq1PfsPs3xtIQV76tfbTk1JZOaEHKaM7noVyNuSnwQ1DbgAGA6MxlUbL8MlK2OMMQ2UHKpkxboiNhWU1tuelJjAlNH9OWHcAHqktHoQdbfj9zfUC1dl/B1VPSQiQ3BJyhhjjCcUCrPiw0Le12JCUXNMEwIBxo/oy0kTckhPS27HCDsXPwnqMWAFrpL5dSIyEVeq6KFmn2WMMd1IbTDEqyu2sXln/cI3o/KyOHliDn0ye7RTZJ2XnwR1A7AMVzR2kVe14de4ZTiMMabbO1xZw8LlWymKWoI9t386s6cMshF6x6HFUXyqGgaeARCRq4AiYIm33RhjurXSQ1U89fqmeslp2thsLj5zlCWn4+RnmPkI4ENcl95duMES60TknNiGZowxHVvRvnKefH1jZOh4IBDgtKmDmTN1cJdfTDAe/EzU/RPwIG5V2xpV3QB8BdfNZ4wx3dLmglKeWbKZiipXrigpMYH5Jw9jqlUibzN+EtQs3Eq6YbzVblX1UWBULAMzxpiOas2mYl56exu1wRAAPVKSuOiMUbaGUxvzM0iiGLeS7gd1G0RkHO5elDHGdHmVVbWUllVRWlZFwe4yNmzbH9nXOz2VT84ZSVZGajtG2DX5SVC/AxaKyO+BZBG5Gvge8IeYRmaMMXEWDIXZXnSQvaUVHCirouRQFQfKqiNVxxvK6deL82cPp2cPm9sUCy0mKFW9T0T2AV8FtgOfBX6uqg/HOjhjjImnN1bvZO3mvb6OHTW4N5+YOYzkJFsUIlZaTFAi0lNVn8It0R69/QxVXRKzyIwxJo5KDlayLn9fo/uSEhPIykild3oqWemp5PTryfBBmTZSL8b8dPEtFJH5qloJICLpuDp8XwZsarQxpktY8WERYa88UXafNCaO6EdWhktIvdKSLRm1Az8Jqgh4UUTOB84E7gF24Ub3GWNMp7en5HC9wq5nnjCEgX17tmNEBvwNM/887t7TBlxdvt8Cp6jqB80+yxhjOom31xVGfh41uLclpw6iyQQlIpkikgmkA98GlgNrcUkqw9tnjDGd2s7iMrYXufWaAoEAsyYNaueITJ3muvhK8Sbmeuo6YHd7P4cBW/7dGNNphcNh3lp7pPUkQ/vQ16qOdxjNJagRcYvCGGPawdbCg5EirwkJAWZOzGnniEy05hLUfm9xQuvKM8Z0OeFwmBUfHimIM2lkPzJ7pbRjRKah5hLUTiCTo7v6wLr4jDGd3MYdpewtrQAgOSmBE8cPbOeITEPNJaiJ3nfr6jPGdCnBUP3W09Qx2VauqANqchSfqu7wvm/DDYyYCMwDxgC7vO3GGNPprN+yjwPeGk6pKYlMsyUyOiQ/pY5mAM8DtUABMASoFJELVFVjHJ8xxrSp2mCIlR/tjjyeIQPpkeKnZoGJNz//Kn8AblPV/6vbICI/Bv4CnBWrwIwxJhbWbNpLeWUNAL16JDN5dP92jsg0xU8liXG4pd6j3QbMaPtwjDEmdqpqgry3YU/k8UkTBlo18g7MTwvqdeAi4MmobecA78QkImOMaaUDZVVs3FFK/s4DHK6sISkpgZSkRJKTEkhJSiApKZGU5AQOlR9Z2ymzVwrjh/dt58hNc5pMUCLyNG4oeR/gnyLyOrANyAHmAi/5vYiIXAd80zvfZuBqYB9uMcT5Xhy3q+pfvOPHAPcD/YEy4IuquqG1L84Y03UdOlzNxh2lbNpRyp6Sw61+/qyJOSQmWuupI2uuBbU66ufFUT/vAFb6vYA3yOJGYKqqHhCR24FbcUvIjwUmARnAWyLynqq+AzwC/F5VHxWR84B/i8hkVW04H8sY042UV9SwqcAlpUKvAsSxyO6TxtihfdowMhMLTSYoVb2lLS6gqu+KyBhVrRGRHsBgYAtwMXCvqtYCJSLyOHCFiOzE3fd63Hv+iyJyNzAdeK8tYjLGdD66bT+LVu4gFD76c2pCQoBhAzMYPSSLQf3TCQZDVNeGqKkNUlMboqY2RHWN+zkhEGDM0Cxb36kTiMvYSi85XQT8FagCbgIuwbXG6hQAU3DD2HepaqjBvjwsQRnTLR2urGHxewX1klNCIEDewHTG5PVhxOBMGyreBcXtX1RVnwGeEZGrgZdx86oaVksP4kYWNlZaKRiPOI0xHc+7G/ZQU+s+s2b2SuEEGcDIwb2t+kMXF/M7hCIyWkTmRG36GzAMV+svN2p7Lq6ltB0YJCKBRvYZY7qZg+XVrNu8N/L4tGmDmTSqvyWnbsBXC8qraH4BrvttN/CCqu5t/lkRg4DHRGSa95zLgXXAU8BVIvIcblHEzwHfUNUCEdkEXAo8LiLnAiHcYonGmG5m5UdFBEOuUyWnXy+GD7IFFroLP6WOJgOv4Kqab8UVj71DROapaov3hFR1mYj8AlgsIrXALty8qh3AKNxovhTgHlVd4j3tMuA+EfkJUAl8psE9KWNMN7D/YCUbtpVEHp88KccGN3QjflpQv8fNUfpd3QYRudHbfrqfi6jq3cDdjez6ThPHbwTO9HNuY0zXteLDIsLewIghAzPIG5DRzhGZePJzD2o6LhlF+z0wre3DMcYYZ8/+w2wuKI08PmXSoHaMxrQHPwlqP0fWhqozEXcvyhhjYuLtdYWRn0flZTGgb892jMa0Bz9dfHcCC0XkTlypo+HA9biCscYY0+Z2FpexffchAAKBALMm5rRzRKY9tJigVPUPIlIJfAEYgBsG/gNVfSTWwRljup9wOMxba4+0nsYN60PfzB7tGJFpL76GmavqfcB9MY7FGGPYWniQIq/OXmJCgJMmWOupu/IzzHwscAswGkiM3qeqJ8QoLmNMNxQKhXk7qvU0aWR/MnultGNEpj35aUH9FSgH7gFqYhuOMaY727ijhH0HKwFITkpgxvgB7RyRaU9+EtRUIFdVj722vTHGtCAYDLHiw6LI46ljsq2cUTfnZ5j5JtwihcYYEzMfbd3PwfJqAHqkJDFdrPXU3flpQS0EXhORh2kw90lV74pJVMaYbqGmNsTWwgNs2lHK1sKDke0njBtAanJiM8803YGfBDUHyAdmN9geBixBGWNapTYYYnvRITbuKGVr4YHIMhp10tOSmTK6fztFZzoSP/OgzopHIMaYrq1gzyE2bN1P/q6DVNc0vrxbdlYac08aSlJizFcCMp2ALUFpjImpuom37+meRvf3yejBmKFZjMnLoo9NyDVRLEEZY2ImFAqz+L0CPtqyr9723umpjM7LYsyQLPr17mFLaJhGWYIyxsREMBjilXe216tIPiwnk1kTc8juk2ZJybTIEpQxps3V1AZZuHwrO7yCr+Bq6p194lASEiwxGX+aTFAi8j5upF6TrNSRMaahyqpannsjn937D0e2TR2TzZypudZqMq3SXAuqbpHCE4HzcUPKtwB5wLeB52MbmjGmsyk7XM2CZfns98oVAZw8aRAzxg2w5GRarckEpap/BxCRHwDzVDW/bp+ILAQWAd+LeYTGmE6h5FAlC5bmc+iwqwYRCAQ4ffpgJo+yOU3m2Pi5BzUYKGqwrRSwvzrFGq82AAAgAElEQVRjDDW1QbbsOsiy1TupqKoFICEQ4BMzhzJ2aJ92js50Zn4S1H+Ax0XkJmAnMAz4OfBsLAMzxnRctcEQWwsPRkoU1QaPVINITkxg/uzhDMvJbMcITVfgJ0F9FbgXWAEkA1XAY8C3YhiXMaaDCQZDbN99iE07SsnfdXSJIoDUlEQuPHUkg/r3aocITVfjp9RRCfAZEUkF+gL7VLU65pEZYzqEUCjMig+LWLd5L1VNlCjql9mD0UOyGD+iH+lptkSGaRu+5kGJyLlEragrIoBVMzemq6upDfLSW9vYVnTwqH1ZGamMycti9JAs+vVOa4foTFfnZ8n3PwNfAD6g/oq6Vs3cmC7scGUNz72RT3FJRWRbZq8Ur0RRH/pnWYkiE1t+WlCXAKep6upYB2OM8a+6Jsje0gqKSyqoDYWYOLIfPVLapjjM/oOVPP9GfmQBQYATxw9k1sQcS0ombvz8NQeBj2IdiDGmaRVVtZFkVFx6mOKSCkrLquods2lHKRefOZqU41zob2dxGQuXb6Gq2t1vSggEOOOEPCaO7Hdc5zWmtfwkqNuBv4jIL4F69fJV9eiOaWNMm9l/sJKX39rKvqjKDE0pLq3gxbe2cuGpI0g8xvWUPt5ewqKV2wmGXJWz5KQE5p88nGGDbMi4iT8/f8U/A64EPgZKvK9S77sxJoaWr9nVZHJKCATon5XGqMG9I9t27D7Ea6t2EA43W0bzKOFwmPc27OGVFdsiyalnj2QuPnO0JSfTbvy0oCbFPApjzFFKD1WxrehINfCBfXuSnZVGdh/3vW/vHpGVZ1et383b6woB0O0l9ExL5tQpub6uEwyGWPbBLtZt3hvZ1jezBxfOGUlmr5Q2fEXGtE5z1cwzVPUQ1lIypl2s3bw30hIaPiiTC+eMbPLYGeMGUHa4mnX5bmHA93UP6T2SmTo2u9lrFO0r5/VVO+q10gZnp3Pe7OFtNuDCmGPV3F/gTiAT153XsL8g4G3zdTdWRK4A/sd7zmHgelVdJSI/Ar7kxfEwcIuqhkUkG3gIV1YpBHxNVZf7flXGdHI1tUHWb90feTx5dPOlL11h1jzKK2vZsusAAG+s2UXPtCTGDDm6Hl5VTZC31xayLn9fve7AsUP7MPfEIcd8D8uYttTcX+Fvve/jgJENvkZ431skblbvb4H5qjoNV8fvKRE5H/gsMAPXjXgW8BnvaX8ClqnqBOAK4AkR6dmK12VMp7ZhawnVXtWGrIxUhg7MaPE5CQkBzj15GIP6uTJD4XCY/7yznZ3FZfWO21xQymMvb6jXQktOTOC0qYOZN3OoJSfTYTTXgroRuBVYparHc5e0CviqqhZ6j1cBObhk9KiqlgOIyAPAFSLyFHAhcC2Aqq4WkY3AfOCp44jDmE4hHA6zZtOR+0FTRvf3PfcoKTGBC04dwZOvb6LkUCXBUJiFb27hkrNGk5qSxNL3C8jfeaDec4blZHLGCXl2v8l0OM0lqN0i8hqQ5iWNo6jqJS1dQFW3AlsBRCQA3AEsAAYBL0cdWoBbDLE/kKCqxY3sM6bL27H7ECWH3D2hlORExg3r26rn90hN4pOnjeTJ1zZSXllDVU2QZ5fmUxsMRVpl4EbpnTYtl9F5WTb51nRIzSWoi4CLgVNxZY6Oi4j0Ah4EhuBaQ/+i/r2tAG5ScAKN3/NqvEqlMV3M2qjW0/hhfY9p4m1mrxQunDOSp5dsoromyOHKmnr7J47sxymTB9lACNOhNbei7kfARyISUNWfH89FRGQo8BywHjhLVStEZDsQPQ42F9dS2gMERKSvqu5vsM+YLu1AWRVbo4aWtzQ4ojnZfdI475ThPPdGPiFvblNWRipnzxhCbnb6ccdqTKy1eDe0DZJTBrAYeEpVP6eqdZUnnwUuF5Fe3lIeVwLPqGot8ALwNe/5U4AJ3jmM6dKiBy4My8kkKyP1uM43ZGAGn5wzkuGDMjl50iA+N08sOZlOIx7t++tww8UvFpGLo7bPxQ16eAdIwSWsh7x91wB/FZF1uO6+L6hq/Tu7xnQxNbVBPtpyZGj5lDHH3nqKNmRgBkN8jAI0pqOJeYJS1V8Bv2pi9y+9r4bP2Q18MpZxGdPRbNgWNbQ83d/QcmO6Mt8JSkQG4QY47FbVbbELyZjuJxwO1xscMWWM/6HlxnRVfhYs7Ac8ApyDm9OUIiLLgUsaDAU3xhyjgj1l7PfKDSUnJbR6aLkxXZGfKeN3AAeBQaqahmtFFQG/j2VgxnQnazYe+aw3fvixDS03pqvxk6DOAa7y7guhqruArwDnxTIwY7qLthxabkxX4idBhYEeDbalAi2voGaMaVH00PKhORn0yWj4382Y7snPIImngH+JyPeB7cBw4NdYXTxjjltNbZD1UUPLp45ufnkMY7oTPy2oHwCFwJu4e09LgM3AD2MYlzHdgm4roSp6aHmODS03pk6LLSiv2vjlInIV0Ac3zLx160kbY46y70AFKz/aHXk8eZQNLTcmmp9h5j1wZYhGAMneNgBU9YYYxmZMl7Vj9yFefGtrZGJuakoi40bY0HJjovm5B/UAMAdYClTHNhxjur4NW/fz2qodhLyBESnJicw/eTipNrTcmHr8JKgLgDF1w8yNMccmHA6zav1uVnxYFNmWnpbMhXNG0j8rrR0jM6Zj8pOgCoDyWAdiTFcWDIVZ8t6OesVg+/VO45NzRpDe01ayNaYxTSYob5kLgCeBBSJyC1ASfYyqrolhbMZ0CdU1QV56eyvboybjDhmYwfxTrFvPmOY014JajZukWzes6MwG+8OA/e8yphllFTU8/0Y+e0srItvGDevLWTPySEz0M8vDmO6ruRV17X+PMcfhcGUNT762kUOHj4wtmjkhh5MmDLTh5Mb44GeY+XbcYoILgNe9FW+NMc0Ih8MsWrkjkpwSAgHOnJHHhBH92jkyYzoPP4MkPocrDPtrYKSIvIJLVi+oamksgzOms1q3eR/big5GHp83ezgjcnu3Y0TGdD5+KkksB5YD/ysiOcC1wD24Zdpt+JExDew/WMmba3ZFHk8bm23JyZhj4KeLLxc4y/s6G1fu6FVgUWxDM6bzCQZDvLJiG7XBEAD9s9I4ZdKgdo7KmM7J7zyoCuBvwGeB91Q1FNOojOmk3v6wKDJiLykxgXkzh9poPWOOkZ8EdRnwCeB87+s1EXkNeM2qSxhzxI7dh3hf90Qez54yiH69rUKEMcfKzz2ofwL/BBCRkbhW1B9wXX02D8oYoLKqlkUrt0ceD83JYPIoWxnXmOPh5x5UMq5Y7DzvaxzwOvBcbEMzpnMIh8O8/l4BZRU1AKSlJvGJk4baXCdjjpOfLr5SoBhYCPwUWKSqVTGNyphOZMPWEjYXHJlxcfaJQ+jZI7kdIzKma/CToE6xmnvGNK70UBVLVxdEHk8a2c+GlBvTRlocXmTJyZjGBUNhXn1nGzW1blBrVkYqp04d3M5RGdN12PhXY45ByFs+Y/f+w4ArZXTOzGEkJ9l/KWPaip8uPmNMlLrJuJt3HohsO3nSIAb07dmOURnT9fj6uCciPb3viSLyeRGZH9uwjOmYqmuCPPfGlnrJadywvkwbm92OURnTNbWYoETkClw1CYDfAncAfxORH8UyMGNirbKqlgNlVYTDYd/HP7t0MwV7jiw8OG1sNnNPGkJCgg0pN6at+eni+x/g0yKSCFwFXADsBJYBv4phbMbEzL4DFTy9eDOV1bUM6NOTqWP6Mzovq8myRGWHq1mwLJ/9Bysj206eNIgZ4wbYfCdjYsRPF98QVX0NOAWoVdU3VXUrYGNpTacUDIZ49Z3tVFa7pc32lBzm1Xe289DC9axav5uKqvpLnpUcquTJ1zdFklMgEODME/I4cbwtPGhMLPlpQe0SkXNxNfleBRCRS4H81lxIRALAg8BaVb3da5H9DpjvxXG7qv7FO3YMcD/QHygDvqiqG1pzPWOa8s5Hu+stwV6nvLKGt9cVsmr9bmRYH6aM7k8wFOa5ZfmRpJWQEGDezKGMGdIn3mEb0+34SVDfBx4HDgLzRORsXPK4xO9FRGQ88CdgFrDW2/x1YCwwCcgA3hKR91T1HeAR4Peq+qiInAf8W0Qmq6q/mwWmyysuqSB/Zyljh/WhT0YP388r2lfOe1EFXWdNzCEQCLB2017KK12potpgiA/z9/Fh/j4SEwIEQ+7PLjkxgfmzhzMsJ7NtX4wxplF+ElQIGKiq1QAisgMYpKqHmn9aPdcCfwW2R227GLjXW0K+REQeB64QkZ24en+PA6jqiyJyNzAdeK8V1zRdVGV1Lc8s3URVdZAPNu3lU6ePYqCPId41tUH+8872yKCIvAHpkW666WOz2VRQygcb97Kn5HDkOXXJKTUlkU/OGUlOv16xeVHGmKP4SVCPAJEV11T16L6RFqjqdQAick7U5iHAjqjHBcAUb/uuBmtOFQB5WIIywPot+6mqDgJu2PeCZZv51OmjGNCn+SS1fE0hpWWujGRKciJzowq6JiYmIMP6MnZoHwr3lfPBxr3k7zxAOBymV49k/uv0kbZ0hjFx5idBvQF8UUQeVdXDLR7tXwIQ3WUXAIKNbI/eZ7q5UCjM2s17622rqg6yYGk+F50xiv5ZjSeRHbsP1XveaVMHk9Ez5ajjAoEAuf3Tye2fzsHyanbvL2fIgAx6pNqcdmPizc8ovnHAvcAhESkRkf11X8d57e1AbtTjXFxLaTswyBtU0XCf6ebydx3gYHk14LrdUlPckmSV1W6O0r4DRzfwK6vrr9U0Irc344a3PMghs1cKY4b0seRkTDvx8z/vazG69rPAVSLyHJAOfA74hqoWiMgm4FLgcW8EYYgjgytMN7Zm45FW0ORR/RmZ25tnlm6muiZIRVUtzy7N5+IzRtEn88jAiWXv76y3VtNZM/JseLgxnYCfauZLVHUJrgWTBLwJvO9tOx53A5uBD4CVwP1R57wM+IaIrAN+AXymwT0p0w3t2X+YXXvLAFecddKo/gzo25P/Om0kKcmuJXW4soZnlmym9JC717S5oBTdXhI5x5kn5NlaTcZ0En5W1O2PG1F3BlCFGyq+VETOUdV3W3MxVb0y6uda4DtNHLcROLM15zZd35pNxZGfxwzJIj3NJZqcfr24cM4InluWT01tiPLKGp5Zson5pwxn8XtHeoZlaB9G5WXFPW5jzLHxcw/qj8B6IAuoUdUPgduA38cyMGOilVfU8PGOI6vWThlTvzhrbv90LpwzkiSvVFFZRQ3/fm1jZIJteloyp023tZqM6Uz8JKizgRtVtZwjo+tuBybHLCpjGli3eS8hb07SoH69Gp33NDg7nQtOHRFJUtHmnjSUHik22MGYzsRPgjpE1DwozyDgeEfxGeNLbTDEuvx9kcdTxzS9tMWQgRmcN3s4iVHVxSeP6s+QgRkxjdEY0/b8JKj7gedF5DNAoojMA/4JPBTTyIzxbNxeWq+rbuTg5usUD8vJ5PxTR9A3swejBvdm9pSGn6+MMZ2Bnz6PXwOVwC3e8X8G/u5tNyamwuEwH0QNjpgyJtvX2kvDcjKtZp4xnVyLCcob3n2H92VMXO0sLotUHk9OTGDCiL7tHJExJl78DDPPBb4LjKBBl6Cq+q5obsyx+CBqYu644X1toIMx3Yif/+3/wlVyeN37bkxclB6qYmvhwcjjKWP6t2M0xph485OgpgLZqlrZ4pHGtKG1m/ZGlsYYlpPZqnWfjDGdn59RfG/jCsYaEzfVNUHWbzsyk2Ha2KaHlhtjuiY/LagfAq+LyOtAafQOVb0qJlGZbm/9lv1U17gVVvpm9iBvQHo7R2SMiTc/CepOYBOuWKytyWRiLhSqP7R86phsqz5uTDfk9x5Uf1WtinUwxgBs2LY/suZTj5Qkxg5tee0mY0zX4+ce1LvA+FgHYgzAgbIqlq3eGXk8aVQ/kpP8/JkaY7oaPy2od4AlIvIssI+o5dhV9YZYBWa6n1AozKvvbKem1s1myMpIZca4Ae0clTGmvfhJUNnAU97PtpiOiZlV63dTtK8ccAsSnjNzGMlJie0clTGmvfgpdfTleARiurfCveWsXL878njWpBwGNLKkhjGm+/BT6igB+B/gKmAIsBt4GLhZVW1Unzlu1TVBXn1nW2RSbm7/dKaPta49Y7o7P118PwEuBW4CtgKjgP+Huxd1U8wiM93G0vcLIqP2UpMTmTdrqK+K5caYrs1PgroSmKuqW7zHK0RkBbAUS1DmOG3cUcKGbSWRx2eckEdGz5R2jMgY01H4Gb/bGzdJN1oBYIXRzHEpO1zN4veO/GmNG9bH5jwZYyL8JKg3gV+KSCKAiCQBvwDeimVgpmurG1JeVe1uY2b2SuH06XntHJUxpiPx08V3A/Ay8FURKQRygZ3AhbEMzHRtqz8uZmdxGQCBQIB5M4eRkmxDyo0xR/gZZr5JRMYBp+PmRG3HTd61McCmURt3lLBxRynhULjR/WFg++5DkccnjhvAoP694hSdMaaz8DPMfL+q9gUWRW0LADtw96eMifhoyz5eW7XD9/ED+/bkxAk5MYzIGNNZNZqgRGQ48CQQADJF5L0Gh2QAu2IbmulsNhWU8vq7DcfTNC01JZF5M4eRaEPKjTGNaDRBqepWEbkJ16V3N27JjWhVwJIYx2Y6kR27D/HqiiOTbbOz0pg5semWUSAQYECfNHr2SI5XiMaYTqbJLj5VfQFARNap6qr4hWQ6m6J95Sx8cwtB755TVkYqnzxtpCUfY8xx8TPMfIuI/D8AEZklIh+LyNsiIjGOzbSTulaQH3tLK3jujXxqgq4CeXpaMp86fZQlJ2PMcfMzzPwvQLo3MOJPwEvAIVzX39kxjM3E2eHKGlat382GbSX0Tk9hwvB+jBmaRY+Uxv9MSg9VsWBZfmQuU1pqEp86Y5RVgjDGtAk/CepkYAyQA0wDzgVKgf0xjMvEUXVNkNUfF/P+x3siazEVl1SwpKSAN9fsYtTg3owf0ZfB2emRpdfLKmpYsGwzhytrAEhJTuS/ThtFnwwrMGKMaRt+ElQP3NSV+cAaVd0nIv1wAyVMJxYMhliXv49V63dTUVXb6DG1wRC6vQTdXkLv9FTGD+/LiNxMXn57W6TAa1JiAhfOGUF2n7R4hm+M6eL8JKgXgYXAOOA2ERkJPAQsiGVgInIB8CsgFVgDfEVVD8bymt1FOBzm4+0lrPiwKJJk6vTL7MHMiTkcrqrloy37KC6piOw7UFbF2+sKeXtdYWRbQiDAeacMJ7d/etziN8Z0D34S1NeAa4BHVfV+ERkPvAb8MlZBiUg28ABwqqpuFJHfAL/24mhzwWCIjTtK2X+wMhan71DCuCHhe0sr6m3P6JnCrIk5jB3aJ7LUxeRR/dlTcpj1W/bz8fYSqmrqL/8VCASYN2sowwZlxit8Y0w34qfUUSVwR9Tj9cR+mY1zgJWqutF7fDfwgYhcq6r+h5j59NHW/Sx5z/8E066kR0oSJ44fwKRR/UlKPHpQ54A+PRnQpyenTs1lc0EpH23Zz87iMhICAc44IY8xQ6z6uDEmNvyUOirBffA+ilcCKRaG4Eop1SkAMnEVLNq8m687VjJITkxg6thspssAUn0UaU1KTECG9UWG9aWsogbCYdJttJ4xJob8dPFd1OBxf+Ba4Im2DycigcaTYkyWmB83rC9pqUmUHOwe4z6SkxIYldf7mOcqpafZHCdjTOz56eI7qqSRiCwGluO63mJhOzAr6vFgoERVy2NxsYSEACNyezMiNxZnN8YYcyz8VJJoTBIwoC0DaeAV4GQRGeM9/gbwbAyvZ4wxpoPxcw/qjgabUoDzcBUlYkJV94jIl4F/i0gKsBn4YqyuZ4wxpuPxcw+q4TCtIHAPrgRSzKjqQtz8K2OMMd2Qn3tQX45HIMYYY0y0Zu9BichsEbkq6nGKiLwqInNiH5oxxpjurMkEJSKn4wYrDIza3APIB14WkVNjHJsxxphurLkuvp8C31bV++s2eLXwvi4iCtwMzItteL4lAhQVFbV3HMYYY1oh6n37qIoBzSWoqbilNRrzF+D/HV9YbWoQwOWXX97ecRhjjDk2g3AjtiP8jOJrTEcrubASOA0oJEbVJowxxsREIi45rWy4o7kE9T5uDajnG9l3PvBxm4TWBlS1CnijveMwxhhzTDY3trG5BHU78HcRuRpYqKpBEUnEJad7gevbPkZjjDHGCYTDTa9e4Q0x/x2uesR+oB9QAfxQVe+LS4TGGGO6pWYTFICIpAGzgWzcPZ7lqloTh9iMMcZ0Yy0mKGOMMaY9HGs1c2OMMSamjnWYeaclIhcAvwJSgTXAV7wJyK06pivw+bu4Avgf3AKSh4HrVXVVvGONtdb8m4vIRcA/VDUjjiHGhc+/icnAH4DeuGkdX1fVd+Mda6z5/F1cDNwChHD36a9W1UZHpHV2IhIAHgTWqurtjexv8/fNbtWCEpFs4AHgv1VVcGWbft3aY7oCn78LAX4LzFfVacDPgafiHWustebf3Fuj7HYgEL8I48Pn30RPXAm021R1OnAr8Ei8Y401n7+LNOBh4BLv/8dzwF3xjjUeRGQ8sAj4dBP7Y/K+2a0SFHAOsFJVN3qP7wYu9z4ZtOaYrsDP66wCvqqqhd7jVUCOt0ZXV+Lr39x7c34YuCHO8cWL3/8fm73lcAAWAJ+NY4zx4ud3kYj7oNLbe5wOVMYvxLi6Fvgr8EQT+2PyvtnduviGADuiHhcAmUAGcLAVx3QFLb5OVd0KbIVI8/4OYIGqVscz0Djw+29+j/e1Jn6hxZWf38NYoEhE7seVQysFvh/PIOPEz/+PMhH5BrBcRPbhElaXLKKtqtcBiMg5TRwSk/fN7taCSsDdS2ko2MpjugLfr1NEegH/AkYDX41xXO2hxd+FiFwD1Krq3+IWVfz5+ZtIxpusr6on4u5FLRSR1DjEF09+/iYmAzcBE1Q1F/gF8GQX7G3xIybvm90tQW0HcqMeDwZKVLW8lcd0Bb5ep4gMBZbj/tDOUtXS+IUYN35+F1cCJ4nIatxKz2kislpEop/X2fn5PewC1qvqCgBVfRbXchgZtyjjw8/v4lzgzahBEX8CJuEKGnQ3MXnf7G4J6hXgZO9GN8A3gGeP4ZiuoMXXKSIZwGLgKVX9nKpWxDfEuGnxd6GqM1V1kncz/HygQlWnqequOMcaS37+9l8ERojIDIisGxcGtsQtyvjw87t4DzhDROrWzLsI2KKqe+MUY0cSk/fNbjdRV0TOxw2FTMEVKPwi7tPfX703n0aPUdX97RNx7LT0uxCRH+FG7q1t8NS5qrovrsHGmJ+/i6hjhwPrVDU93nHGms//H6fjRnf2wg2k+baqdrlizT5/F9cC1wHVuGHm16nqh+0TceyJyIO4v/3bReREYvy+2e0SlDHGmM6hu3XxGWOM6SQsQRljjOmQLEEZY4zpkCxBGWOM6ZAsQZlOTURGtHcMXZ2IZIlIVgzOmxY1RNuYo3S3UkemHYjIubiK6NNxtcs+AG5W1SXHed4LgZ8BJxx3kB2IiLwIPKeqfz6OcywGnlHV37dBSB/jaq2tboNzRVsC/BJ4prGdXgHSnwKfAvoCe4CngZ/VTRgXkZuBaap6kYj8GJisqpe1cZymnVgLysSUiFwF/ANXEmcQkIOrfr1QROYc5+n70wX/hlX1vONJTjGQHaPzDmhqh5ecVgBZwFm4QqxnAwOBlSLSp+FzVPWXlpy6FmtBmZjxqn/fAVzplcSp81eva2cc8IY3+a9UVb/jPe9M3Kf/LG9Jg3uB83CTQt/CzVIfAfwFSBaRUu/Y0cD/4Qp2HsSV//+FqtZ61ygGZgIzcAVfr8ctCXCy9/izqlogIonAD3B1BzOB14BrVbXYi+1eYANwGnB5VGXvutf938APgVG4FuPTuDWTaryWzVZcmRwFbm54Plzx1WeAD4FHgUGqWuud+w6gr6pe2dx1mvk3GQ6sAx4DPuO9zn/ilok4DZcANgPfUdVFIlK3ztNyEfmyqv5TRK4GbsQlmBXANaqa38i1UnETes/DlcEpBH6iqo+LyNPAUOAxEfmpqt7W4Ok/xZVUuiJq2xZvfbLFuBp4321wvZs50pq6GVfYthcwF1eK58eq2mhrzXRMXe7Tp+lQZuMWL3uh4Q5V/YWq/tXHOa4B8nBvZmNw1ZG/qaorcYlqrZecUnDlVjbi3gznApfiuhbrfAO3VEY2brb7Itwb9ABcrcG6N7xvA1cA83BVmouBx6POM8Z7TbneOSJEZBiuxfhdVe0LnAR8ElcGp84sYDyu66q58y3CLd9wjnfuBO81PeTzOk3p5b2mAbjlQ27ztk3EJeSX8NY1UtUZ3nNme8npEly36mW4ZLYE1xpu7MPu94ATcR8KMoA7gXtEJElVL8YljcsaSU54r+XxhhtVNYxbNO9iH6/zs7jk3we3TMTd3bSQa6dlCcrEUjawv7lP9D4cwLW0Pofr7jlPVW9t5LjTcEU6f6CqlV4Bz58BV0Ud86yqvuvVFHwLeN17fBh4HdcqA7gauEVVN3vHfh9Xc21M1LkeUdUKVa1qEEchMFFV3xCR3t7vYC/1C2k+r6qlqnqgufOpagiXQD7vbToLl0hf93md5jyiqtVeMc//Bb6Ca6EOwS2h0dR5rgZ+r6rvecuu/BqX1M5q5Ni/4JJw3fnKvWN7+YhvEFDUxL5CXFdxS1aq6gve39/D3nO6XHmqrswSlImlQqCfiCQ33CEivX0u0XA/7hP+t3DrzawSkZMbOW4AUNggGW7FveHWia4fGMS9cdYJceT/wzBcN2SpiJQCO4EaYLi3/6CqljURbw1wlYjswhUT/R6QRv0VeBsWmG3ufH8HPuV1l16OW2o+7PM6zYmOIRdX2HM3rkvxxGbOMwy4Kep3U4L74DCskWMzca2dvd7553rb/cS4G9dqbiqGppJXw3PUqfu7SPTxPNNBWIIysbQcqMBV/27oNtyyFeCSRfQqvdHLFYzHLVVuS8YAAAJzSURBVJI4HfcJ+E3cp+GGtgO5DVb7HUn9Nym/hSd3AZ9W1ay6L1wXWt2ow+bO8zlcIjlRVUep6qdxrcBoDZ/f5PlUdQPwEa7r7hLgoVZcpznR13wc928xQFVPibpGY3YBNzT43czAJbaG7sFVOR/odRXe3or4nga+1MiqxgHc0iddcYUB04ANkjAxo6rVIvID4F4RCePeBFOBr+MqQ8/3Dv0Y+IaI5OA+6V4XdZrL+P/t3TFLW1EYxvH/5FYySunk9C7iB+iYwQ6VtmunDi526NZJErJZP4CIFAoNSnHo7uKilFL8AK3v4iS6FIrNYhzE4bni7cUhDQYO4fktGUJODhy4T95z35sD7Yh4if4telC9grakHlX3Zo5QpbNetRs/ATqoY/B/9YFeRPxEF+T3qBlhlGeuWihwh1XluAIs8G8AjzOfD0BmZk7ge1ro+JDrqtGk2xjnirtjzftANyIOUWPHa9SMMo/u/zXHvQSuI+Ix2g6kNvawNm5TD63pl4jooKCbQ23ps2j71qacKyibqMz8iLrlVtFzLKfAc+BZ7TmoLXQxOgZ+AF9rQ6yhbrdfaEvuKfCmeu8ABdoFuq+xBAQKlW/oV3hvjGmvA/vAIdrCelHNd5TDGvtoy+0EBWYbdczNjzGPW7uoeqxXNg/5PcvAu4gYoGaNHWAmIm4PIfwE7EXE28zcBjZQBfMX3Z97lZnNcAI1myyi9fmO1ut3bY6fgc2IWGt+MDP/oKr1DK3FADWNnKOqcaqOe7H7+bgNMzMrkisoMzMrkgPKzMyK5IAyM7MiOaDMzKxIDigzMyuSA8rMzIrkgDIzsyI5oMzMrEg3B+iHFAe9PQoAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "p1_array=linrange(0,1,0.025)\n",
+    "sweep=sweep_p1(p1_array,0.2,600)\n",
+    "plot(sweep,label='Olin')\n",
+    "\n",
+    "decorate(title='Olin-Wellesley Bikeshare', xlabel='Customer arrival rate at Olin', ylabel='Customers who find no bikes available')\n",
+    "\n",
+    "savefig('chap04-fig_ex_1')"
+   ]
+  },
+  {
+   "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": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sweep_p2(p2_array,num_steps):\n",
+    "    sweep=SweepSeries()\n",
+    "    for p2 in p2_array:\n",
+    "        state=run_simulation(0.5,p2,num_steps)\n",
+    "        sweep[p2]=state.olin_empty\n",
+    "    return sweep"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap04-fig_ex_2\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xl8XHXV+PHPZE+zNGmTNkn39bR0o+wgIKUimwsgCIj48KC4gai4+/jIpqiI/NwVlQdUQJBFdgEttGyyFChdaE/3pGmaNGuzrzO/P743ySTNcttkJtt5v155ZebOnXvPZJkz3+WebyAUCmGMMcYMNzFDHYAxxhjTE0tQxhhjhiVLUMYYY4YlS1DGGGOGJUtQxhhjhiVLUMYYY4aluKEOwIwtIjIO+DrwCWAmUA78C/ihqm4L2283cJuq/lpEbgA+pKrHHMb5soH9wHmq+ljY9puA/wU+q6p/DNt+HfAtIEdV+7wGo1uMdwOpqnrhocbY7ZinAS8AaapaO5Bj9XDsu4H/CtvUDGwDfqCq93v7zAR2AUtUdWP4axzkWG7gMH+nZuywFpSJGi85vQBcDHwXEOBjQCLwpoic2MtTbwPOPJxzqmop8B5wfLeHVgKFwBndtp8ErO4vOY1gTwK53tdC4DfAX0WkPVHs8R7bMjThGdPJWlAmmm4AJgJHqWq1ty0feE1E7sS9US5U1ZbwJ3ktiYG0JlYDJ7TfEZFU4DjgOuB6EQmEJaQTgZsGcK7hrklVi8Pu/05ErgIuBdaqahtQ3PNTjYkuS1AmKkQkBrgK+H5Ycgr3v7gWzZm4T/nhz70BrzvI6wJ7CJdcbgIygReBz6hqSS+nXwN8SkRiVDUIvB/YC9wN3A4sB972urfygOe988YDNwNXAMnAa8C1qqo+Xu/x3rGPxrVK/ojrKguKSBzw/4CLgPHAW8B1qvpGD8dJA34GXAiEvNi+rKpFIvJN4BpgRnuCFZFTgX8Ckw+hi7As7HwzCevi6xbLbOAV4GFVvcbb9nXgS7gPHuuAr6vqa95ji4BfA8cCDcBjXux13iFjReRW4NO496L7gS+parP3/K8CX8B1BdcCTwFfUNVa72/ieFwv0Am438uf+4rHjDzWxWeiZT6QgXuTP4iqFgFbcS2Y/mQAn8d1D56He6P6Xh/7rwZSgUXe/Q8Aq1S1BlhLZzffSUBh2FjYTcC5uC7J4wEF1ojI+L6CE5FJwLPAM8AS4FrgauCb3i5fAs4CPuzFtBV4SEQCPRzuD7iu0DNxiTUEPOsluXuBKcD7wvb/BPCYn+QkIgEROcN73ff2s28ObqzwKS9+RORzwJeBL+KS/NPA8yIyy3vafbif2VLvta4Evh122COBCbgEcznw394XInIprsV9HTAP9yHho8Dnwp5/Fu7DyQnA0z7iMSOMtaBMtEzwvlf0sU85kOXjWLG4FsdbACJyD2FdeN2p6n4R2YxLMhtwb5Q/9h5+3rv/E9wbfXvrKRn4KrBSVV/x9r1WRM7EvZn2NWngauBNVb3Zu79NRL4D/NI770ygHtitqqXexIzldPvA6LVYLgGmqupeb9vluBbPWar6pIis8fZ52WvxXUjXiRDdnSci7ckrAYgH/gqs7+M5GcBzuA8Xnw3rDv0u8G1Vfcq7f4vXwr0aNxFmJvA4kK+qO0XkI7iJGe0qgc+raqv3M3oRWOY9VgRcoartrel877UeEfb8BuBHXqsYEekvHjPCWIIy0dKemNL72CeDsO6mfmwNu12Ne6NFRP4JnBL22BGqWoDr5jteRB4HFuMlIu/7tSISi2tJ/MLbPgc3eeM5EQmfMJGEa9H0ZRFwWlgiAJd8kkVkIi65fRQoEpFXcW/id6tqm0iXQ7e/GWu37eO8GJ7EJZcfi8iXca2sEC6Z9OZfeC0g3M9sIW4Syh+AK3t5zvdwyezpsGSQCkwH/igid4Ttmwg0ebe/hZuE8QUReRZ4UFUfDds330tO7apwXamo6hoROUZEfgAswP1MBfhL2P67DjEeM8JYgjLRsh0oBU4G3un+oDcdXOilC7AHzd3ut3ePfQbvTc5T5H1fjfvEvwLYHDZR4BXc/8H7cN1x7Ymr/X/jDNw09XA9jaGFiwMepuduxwOqWi4u45wNnAN8DfiyiBzXw3FacK2r7rMK2xP+w7gkcBpuosPfu08y6aZOVbeH3d8sIonAvV6S68mLwJ+Bu0XkXlXdgGvFgmutdf99NgCo6u9F5EngfFx33N9F5M+qepW3X1sP5woAiMgVwO+Au3BjajcDN/Z0Hk+/8ZiRx8agTFR4n5R/D3xdRCb0sMtNQAFu3GYg59mrqtvDvto/oa/GtRbOAFaF7d8I/Ac3UL/ba22BS6itwKT2YwE7cOMi3RNJd5uBBeFxeOf+PhD0Zs2dp6qPqupnceNzk4FTezhOPJASdpx9wE+95+BNOHkCNxZ3Nv2MJfUiptv37h5X1XtxyfsOb9bjAdxsvyndXuc1wJkiki4ivwZCqvorVT3Xe+wynzFdDfxUVb+oqnfiuiDn0flBpIv+4vF5TjPMWAvKRNMPcQP9r3jjBW/h3pi/hOvyOrufT/+HTVVLRGQnbrym+5vk88B3CHtz92aK/Rb4hYg04S5o/SouEVzfz+l+g+s2/KV3expwB27yQlBEMoCbRaTCO+65uBbAOtwswvYY1OuS/IuIXI1rgf4QN94Wfp3SX4EHgX2q+mo/sSV6Ex7AvdmL93r+qaoHRCSzj+d+CTeG9znch41bge+LyD7gTdwEjWuA96tqtTf+kyci7S3J87z9/CgHVojIEV6cX8V1eW7o4zm9xuPznGaYsRaUiRpVbcK1YO4GfoB7k30UCALH+HhzHajVuO6/Nd22r8KN6zzfbfs3cVPa78J9gj8Kl0R39HUSVW2fLn8M8C4ugTwAfMXb5XbcWMpduFlunwM+pqpbDz4a/4Wbafgo7k13PHCGqlaF7fMMbtLFfX3F5fkQrhW2Dzet/z7cmNWn+nuiF99twI+8JPcL7/6tuIuhPw5cGDap5ALcz/VV4HWgEZc0/PgyrltzLfBv3FjSj3C/g970F48ZYQK2oq4xI5vX6tkHHKmqVgHCjBqWoIwZobzSUefgJkdkqOrKIQ7JmEHlewzKu8ZiBm6gmFFcq8yYkaINNz28FPjIEMdizKDrtwXlXbD4K9yV3E240i2P4y4U3BnpAI0xxoxNflpQt+PqnS3CXaOyA1fG5Te4aa1DzruO41hcP3xP11YYY4wZnmJxFfTf9CZSdfCToD4KiKrWiEhIVVu8goz7IhDo4ToWeGmogzDGGHPYTgFeDt/gJ0G14qZ41tB5kVwKUNfrM6JvH8C9995LTk5Of/saY4wZJoqLi7nsssugh0aPnwT1EK7S8jcARGQe7jqDfwxmkAPUBpCTk8PUqVOHOhZjjDGH7qDhGT8X6n4Hd5HiatxFgutxV3l/dzAjM8YYY8L124LyBq2uxZVuyQbK2ysIG2OMMZHSa4ISkWv7eAwAVf1lBGIyxhhj+mxBnd/Pc0O4BdiMMcaYQddrglLVFdEMxBhjjAnnq9SRiJyPq/eVB+QDd6pq98rPI1pdQwshIDU5fqhDMcYYg49ZfN5Fub/DLbH9V1yCekBEelseesTZX1nPPf/czF+ffo+i0tr+n2CMMSbi/LSgvgisVNVN7RtE5CHcAmn/F6nAoqmiupGWNjcx8fVNxZx/2twhjsgYY4yf66Dige5FYbfg6vONClMnpRETcEUy9pbWUlndOMQRGWOM6TVBiUi6iKTjyvnfJSJ53vYs3MqVt0cnxMhLTY5nZl56x/2NO8uHMBpjjBkaf/vb3/jIRz7COeecw7nnnss3vvENioqKADj99NPZsGEDGzZs4Npre70KaVD11cVXhZtK3l5/7yIRCeKSWgBXo+8HkQ0vehbNnsjOvQcA2JJfwYlLcomL9dPANMaYke8nP/kJW7Zs4Y477iA3N5dgMMjjjz/OxRdfzIMPPtix35IlS/jlL6NzhVFfCWpWVCIYJqZPTiM9JYHqumaamtvYvqeKBTMnDHVYxphR6h3dzxvvFdPSGrnCPPFxMRx3RA7LZVKf+xUXF3P//fezevVqxo8fD0BMTAznnXceGzdu5I477ujY9/XXX+fmm2/mySef5Nvf/japqamoKsXFxYgIP/nJT0hJSRmU+HttIqhqfvsXsAeoACq9rzpGWQILBAIsnp3Vcd+6+YwxkbRua2lEkxNAS2uQdVtL+93v3XffZfbs2R3JKdxJJ53EW2+91etzN27cyJ133snTTz/N3r17eeaZZwYUczg/08wvxiWnKjoTVAnwwKBFMUwsmJlJTIzr0Swur6O0smGIIzLGjFZHzs8mPi6ywwjxcTEcOT/b176tra09bm9ubiYQCPT4GMApp5xCQkIC8fHxzJ8/nwMHDhxWrD3xM838ZuB7uFbTSuA24CfAC4MWxTAxLimeOVMy2LanEoBNO8s47ehpQxyVMWY0Wi6T+u16i5YjjzyS/Px8SktLyc7umtBef/11li9fzosvvtjjc5OSkjpuBwIBQqHQoMXlJ33nqeqvgedwK+uuA64Arhq0KIaRJXMmdtzWgkqaW2wFeWPM6DZ58mQuv/xyrrvuOkpKSjq2P/zwwzz33HNcddXQvN37aUEViUi6qu4VkVkiEgCKAX/txhEmNyuFCelJ7uLd1iBbCypZPCer/ycaY8wI9rWvfY0HH3yQL3zhCzQ3N9Pc3MySJUu4//77mTJlypDEFOivOSYivwSOAj4K/Bl30W4jcKaqLot4hD6IyExg16pVqwZlRd13t5Xy0rq9AGRlJHPxB+b32QdrjDHm8BQWFrJy5UqAWaq6O/wxP118Xweewi3HezUgwCmM0i4+AJmR2XENVFlVAyUV9UMckTHGjD1+VtRtBn7k3a0CzoxoRMNAUkIc86dn8N6uCgA27ignZ+LgzOs3xhjjT18r6v4DV0miV6p6waBHNEwsmp3VkaC2F1Zx8rI8khJ9rU5ijDFmEPT1jrsualEMQ5Myk8nOTKa0soHWtiCaX8kyn9cTGGOMGbi+VtS9MZqBDDftlSVeeGsPABt2lrF0XpZNljDGmCjpq4vvXlW9rK+uvtHcxQcwf3oGr6wvormljaqaJvaW1jJ1UtpQh2WMMWNCX118G73vA+7qE5FPAt/AJbp64FpVXSsibwHJQLO3672q+lMRGQf8CViOm2n4LVV9dKBxHKr4uFhkeiYbdpQBsGlnuSUoY4yJkr66+H7kfR9QV5+ICPBT4ChV3Sci5wCPiMhCYA6Qraot3Z52A1CrqgtFZDrwHxFZq6qFA4nlcCyaPbEjQe0oPEB9YwvjkuKjHYYxxow5/U5LE5GpwLeAPDrXhkoAjlDV2T7O0QR8RlX3effXAjnAyUAt8IyITAL+DXxXVRuA84FPAKhqgYj8C/g4Q7BIYlZGMrkTU9hXXkcwFOLdbWWcsDjHxqKMMSbC/FyoexewCHehbjZQAJwE3OfnBKq6W1WfAvDKJN0OPA4k4grOXgQcC0yn83qrabglPtoVAgMvEXGYFofV53trSwlPvLyTyhpbFt4YYyLJT4I6ETgPuAmoV9WvABcCpx/KiUQkBfg7MBfXonpcVS9X1QpVbQRuwbWc2uMKn5gRwCXIITFnagYTxyd33C8oruFvzymvri+ipdWKyRpjTCT4SVAHVLUa2IZrSaGqz+NKHvnijSO9iksyK1S1SkQ+LCKnhu0WANrHogpwXYrt8nCtqCERFxvD+afNYcmczmnmwWCIt3U/9z6zha0FlYNaYt4YY4y/BLVRRK4DWoFqETleRJZ59/slImnAauARVb3EG2MC12V3m4gki0gscB2diyA+BnzWe/5U4CzgSZ+vKSKSEuJ4/1FT+fjK+eSGlT2qbWjhudfz+cfqHZQfsAUOjTFmsPip3fN14EHgH8CNwMve9u/7PMc1wAzgfBE5P2z7SmA28LYXxwu4bkSA64HficgmIBb4hqru8Hm+iMrOTOaCFXPZWlDJK+v3Ud/oGn1FZbU88K+tLJ4zkeMW5ZCUYGWRjDFmIPpdbqM7EckD0lRVIxPSoRvs5Tb8am5p4833Snh3WynBsJ9jcmIcJy3JY8HMzEOa7Vdd10z5gQamTkolPi42EiEbY8yw0tdyG36mme/ErQP1V1XdqapFEYlyBEqIj+V9y/JYOGsCL76zl8L9NQA0NLWyam0BG3eW8f7lU5k0YVyvxwiFQuwpqWHD9jJ2F9cQCoWYkZPOh0/xM4PfGGNGLz/9UF8BLgXWi8g7wF+AB7yJEwaYkJ7ER0+dzY69B3h53V5qG1y3X0lFPQ8+v40jZk3ghMW5JIdVQ29uaWNLfgXrt5dRVdPU5Xj5xdVU1zWTnpIQ1ddhjDHDiZ/1oB4HHvcmO5yHS1Y/FZFnVPWSSAc4UgQCAeZOzWBGThpvbdnPO7qftmCIUCjEpp3lbC+s4oRFueRlp7BxRzlb8itoaQ32erwdhVUsl0lRfAXGGDO8+B7JV9UaEdkF7ACOBGZFLKoRLD4ulhMW57JgxgRefncvu/e5hmZTcxtr3ul5pnxCfCwLZ04gMSGWNzYVA24NKktQxpixzM8Y1FJc2aFLcdPS7wFWqurmCMc2omWkJfKhk2ezq+gAL63bS3Vd80H7TEhPYsncLGR6JgnxsTQ2t7J2cwnBYIiSinoO1DYxPjVxCKI3xpih56cF9R/cFPOrgH+rau/9UuYgs/LGM21yGuu2lrJ2cwltwRCz8tJZMieLqZNSu8zyS0qIY/rktI5W147CAxy1wFpRxpixyU+CylHVmohHMorFxcZwzMLJLJ2bRTAY6nPp+LnTMjoS1LbCSktQxpgxy0+CGi8it3D41cyNJyG+/2ubZuWNJzYmQFswRGllA1U1TWSkWTefMWbsiXg1c3NoEuNjmZ6T3nF/e2HVEEZjjDFDJ2rVzI1/c6eO77i9wxKUMWaMiko1c3No2rv5AEqrGmztKWPMmBTxaubm0CXExzIjt7Obb0fhgSGMxhhjhoafBPV13NIX0+msZr4W+HkE4xrz5k7N6Li9bY918xljxh4/pY42AAu8u7tE5CWGWTXz0WhWXjpxsTG0tgUpP9BARXUjE9KThjosY4yJGj8tqC5UtciSU+TFx3Xt5rPZfMaYseaQE5SJnvDZfNutm88YM8ZYghrGZuamEx/rfkUV1Y22pLwxZkw55AQlIrbUa5TEx8UyMy+sm89aUcaYMaTfBCUis0XkD97tDwE1IlIkIidEPDrDnPDZfIVVhMKWljfGmNHMTwvqt0CsiASAn+IqStwI/DKSgRlnRk468XHu11RV00T5Abto1xgzNvhJUEfiroOaCcwFfgP8gc6p5yaC4uNimJnbOVnCrokyxowVfsegUoAPAW94S29MBWojFpXpYt60zm6+HdbNZ4wZI/wst/E34HUgF7hGRBbhFjD8SyQDM52m56QRHxdDS2uQqtomyqoayc5MHuqwjDEmovy0oK4D/gf4mKreA9QBPwa+E8nATKe42Bhm54V381UOYTTGGBMd/SYoVQ0BjwKIyJVAMbDG226iZG5YN9926+YzxowBfqaZzwI24br0fombLLFRRD4Y2dBMuOmT0zpW5K2ua+bxl3ZSU998yMcJBkNU1zVbgjPGDHt+xqB+A9wN3ApUqOoWEfk0rpvvOT8nEZFPAt8AQkA9cK2qrhWR7wD/5cVxD3CjqoZEJBuXEGcAQeCzqvrqIb2yUSY2NoZFsybyztb9AOwpqeFvzymnLJvCgpmZBAKBPp/fFgyh+RWs3VxCdV0zC2Zk8oHjZkQjdGOMOSx+xqCOB37mdemFAFT1PmCOnxOIiOCunzpLVY8EfgA8IiLnAB8HjgYWAyuAi7yn/QZ4SVWPAD4JPCgi43y/qlHqhMU5HCWTOpJRc0sbq9YW8PQru6hraOnxOcFgiC35Fdz37BaeX7uH6jrX6tqSX0lZlZVOMsYMX34SVCneSrrtRGQBbizKjybgM6q6z7u/FsjBJaP7VLVOVRuBu4BPikgcbkr7HwFUdR1uNd+zfJ5v1IqNjeGkpXlccNpcMlITO7bv2lfNfc9tYWtBZUfXXTAYYmtBJfc9t4V/v1HAgdqmg473ju6PWuzGGHOo/HTx/Qx4WkR+DsSLyFXA14Bf+TmBqu4GdgN41ShuBx7HTVt/NmzXQtz1VVlAjKqW9vCYAXKzUrj4DOG1Dft4d7v7MTU1t/Hc6/ns2HuA2XnpvLVlPxXVXatOJCbEItMzWb+9DHAX/Z64JJfUcQlRfw3GGNMfPwsW/lFEyoHPAAW4brkfeFPOfRORFNxY1jRca+jveF2GngDQhmvVdR/Bb3/MeOLjYjhl+RRmTUnv0nW3o7CKHd3WjkqMj2XZ/GyWzcsmMT6WsqpGispqCYZCvLu9jPctzRuKl2CMMX3qN0GJyDhVfQR4pNv296vqGj8nEZHpwBPAZmCFqjaISAEQ/s6Yh2sp7QcCIjJBVSu6PWa6mTopjUvOEF5ZX8SmneVdHkuIj2XZ3CyWzc8mKaHzV71csikqc4VANu0s55iFk0mMtyL1xpjhxc8Y1NMi0rHWuIikisjv6No91ysRSQNWA4+o6iWq2j4y/xhwmYikiEgicAXwqKq2Ak/h6v8hIkuBI7xjmB4kxMey4uhpfPjk2aSnJJAQH8vRCybxqbMXcvzi3C7JCdw6UxlpbgyruaWN97olNmOMGQ78jEEVA//0Zt2dBtwBFOFm9/lxDW66+Pkicn7Y9pW4VtkbQAIuYbWXT/oi8CcR2Yjr7rtcVQ/4PN+YNSM3nctzFgL0Oe08EAiwfP4kXnhrDwDvbitl6bxsYmP6nqpujDHR5CdBfQI3w24LMB74X+DXfitJqOqPgB/18vAt3lf355QAH/ZzfNNVf9dDtZMZmby2cR8NTa3UNrSwfU8lMmNChKMzxhj/eu3iE5F0EUkHUoEvA68CG3DFY9O8x8wIFRcbw7J52R3339laatUljDHDSl8tqCoOnmUHUOLdDgE2sj6CLZ49kbWbS2htC1JW1UDh/lqmTU4b6rCMMQboO0HNiloUZkgkJcaxcOYENuxw10W9s3W/JShjzLDR1yy+ClXNByr7+DIj3JHzszvGrQqKa6z8kTFm2OgrQe31vldxcGJq32ZGuPGpicye0rnW1LqtpX3sbYwx0dNXgmqvvzcLmN3tq32bGQWWz++cLLF1TyW1vRSeNcaYaOo1QanqHu97Pm5ixCLgDGAeUORtN6NAzsQU8rJSAFdkdv02a0UZY4aenwULjwZ24S7Q/TSunt5mbxkNM0osl0kdtzftLKe5xUofGmOGlp9SR78CblXVaap6oqpOBf4P+H1kQzPRNDM3vWMJj6aWNt7bZeWPjDFDy0+CWoBb6j3crbiFBs0oEQgEODJsLOrdbWW0Be3CXWPM0PGToF4Azuu27YO4GnpmFFkwcwLJie7SuJr6ZnbttfKHxpih0+uFuiLyD1y1iEzgARF5AcjHrYa7EngmKhGaqImLjWHx7Im8ubkEgI07y5k7LWOIozLGjFV9VZJYF3Z7ddjtPcCbEYnGDLlFsyeydst+QqEQhftrqKxpJDMtqf8nGmPMIOs1QanqjdEMxAwPqeMSmJmbzq4i1723aWc5Jy+bMsRRGWPGIj9jUGaMWTxnYsftLbsraW0LDmE0xpixyhKUOcj0yWmkpyQA0NjcyvbCqiGOyBgzFlmCMgcJBAIsmt3Zitq0w66JMsZEn58VdfEWJzwXmIYre/SUqpZFMjAztBbOnMDrm4oJBkPsK6+jrKqBrIzkoQ7LGDOG+Cl1tARQ4PvACuA7gIrIURGOzQyhcUnxzAmrcr5xp7WijDHR5aeL7+fAbaq6UFXPVtUFwI+87WYUWzwnq+O25ldYfT5jTFT5SVDLOTgZ/Rw4cvDDMcNJXlYKGWmuPl9La5Bte2yyhDEmevwkqAo614Zqtwg3FmVGsUAgwJLZna2ojTvKCIWsPp8xJjr8TJL4BfC0iPwCV+poJnAtrmCsGeVkRib/2biP1rYgpVUN7K9sYPKEcUMdljFmDOi3BaWqvwJuBD4M3AR8APiWqnavcG5GoaTEOOaF1ePbuMMmbxpjosPXNHNV/SPwxwjHYoapRbMnsnl3BQDb9lTxvmV5JCX4+tMxxpjD1u+7jIjMx7Wg5gKx4Y+pqk01HwMmTxhHdkYypVUNtLYF0d2VLAtbO8oYYyLBz8fgPwF1uCXfWyIbjhmO2itLrH67EHDXRC2dl0UgEBjiyIwxo5mfBLUMyFPVuoGcSEQCwN3ABlW9zdtWBhSG7fZTVb1XRLKBvwAzgCDwWVV9dSDnNwMzf3omr6wvoqU1SGVNI0VldUzJTh3qsIwxo5ifBLUdt0jhjsM9iYgsBH4DHA9s8LYJUKGqPV1P9RvgJVU9W0SOBJ4SkXmqWn+4MZiBSYiPRaZndlSU2Lij3BKUMSai/CSop4HnReQeul37dAgz+a7GdRUWhG07CWgTkZeA8cBDwA+BAPAh7zmo6joR2QacBTzi83wmAhbPyepIUDv2VlHfmMe4pPghjsoYM1r5SVAnAztxCSVcCPCVoFT1GgAR+WC3c/8b+DYQDzwFVAP3AzGqWhq2byEw1c+5TORkZSSTMzGF4vI6gsEQr28q5rSjptpYlDEmIvpNUKq6IhIn9qaudxCR23EXAP8dl/zCBQArBDcMLJ4zkeJyNxy5aWc5wWCIFUdPIybGkpQxZnAN2XpQInK5iCwN2xTAzRLcDwREZELYY3l0nUxhhsj8aZnMmdp54e7m3RU8+9pu2mzVXWPMIBvKBQsXAzeJSKyIJAPXAA+oaiuuu++zAF4SOwJYPVSBmk4xMQHOPH4GR8zq/PywY+8Bnnh5Fy2t1sg1xgyeoUxQN+IK0W4A1gOv4iZSAHwReJ+IbATuBS5X1QNDEqU5SExMgBVHT+PIsIt1C/fX8OiaHTQ2tQ5hZMaY0SSq9WpU9Yqw2/XAlb3sV4Kr/WeGqUAgwPuWupJHr23cB0BJRT3/WL2dj5w6h5Rkm91njBmYXhOUiLzDwZMVurBSR2NbIBDgmIWTSYyPZc07boiwvLqRh1/YxkdPncP41MSDnhMMhmhsbqWpuY30lATLO/kAAAAgAElEQVRiY4eyEW+MGc76akG1L1J4DHAObkr5Ltx07y8DT0Y2NDNSLJmbRUJ8DKve3EMwFKK6rplHXtjO7CnjaWhq7fLV2NzWsabUuKR4Ljljvl1LZYzpUa8JSlX/DCAi3wLOUNWd7Y+JyNPAKuBrEY/QjAgyYwIJ8bE8+1o+rW1B6hpb2NDP0hz1jS1ofiXLZVKUojTGjCR++lemAMXdtlUBWT3sa8awWXnj+fAps0mIj+1zv/i4zj+7gpKaSIdljBmh/EyS+Ddwv4h8H9iLK+D6A+CxSAZmRqYp2alctHIeOwoPEB8bQ3JSHMmJ7mtcUhyJCXE0NLZw91PvAVBUWktLaxvxcX0nNWPM2OMnQX0G+APwOq4kURPwN+BLEYzLjGCZaUkcszCp18dTxyUwMT2J8upG2oIhikrrmJGbHsUIjTEjgZ9SR5XARSKSCEwAylW1OeKRmVFtem465dWNAOQXV1uCMsYcxNd1UCJyJmEr6rqVMg6pmrkxXUyfnMY7uh+AgmIbhzLGHMzPku+/BS4H3qXrirq+q5kb011eVgrxsTG0tAWpqm3iQG1Tj9dNGWPGLj8tqAuAU1R1XaSDMWNHbGwMUyelsmtfNeBaUUvmWoIyxnTyM828DXgv0oGYsWd6Tue4U0Fx9RBGYowZjvy0oG4Dfi8it+CWwuigqvauYg7btMlpHbcLS2tpawta6SNjTAc/7wY3AVcAW4FK76vK+27MYctIS+wYd2ppDVJUVjfEERljhhM/LajFEY/CjFnTJ6exobYJcFUlwltVxpixrdcWlIi0v1NU9vFlzIBMz+lMSDbd3BgTrq8W1F4gHded133ZjYC3zerTmAGZOimV2JgAbcEQ5QcaqG1oIdXWkjLG0HeC+qn3fQGuvJExgy4+LpbcrFQK97vW057iGhaGLSdvjBm7+kpQXwduBtaqqtWhMREzPSetI0EVlFRbgjLGAH0nqBIReR5IFpFHetpBVS+ITFhmLJmRk8ar693tgpIagsEQMTGBoQ3KGDPk+kpQ5wHnA+/DlTkyJiImpCeRmhxPbUMLTc1t7K+sJ2diylCHZYwZYn2tqPse8J6IBFT1B1GMyYwxgUCA6TlpvLerAnCz+SxBGWP6vVDXkpOJhumTO4c5863skTEGf5UkjIm4qZNTCQTcuNP+ygYamlqHOCJjzFCzBGWGhaSEOHImjAMgFAqxp8Qu2jVmrPOdoEQkV0SOE5EZkQzIjF1dq0pYN58xY12/CUpEJorIM7jKEmuAnSLykohkRzw6M6Z0WX6jpJZQqHsBE2PMWOKnWOztQDWQq6olIpIH/AL4OXCZ3xOJSAC4G9igqreJSCzwM+AsL47bVPX33r7zgDuBLKAW+JSqbvH9qsyINCkzmeTEOBqaWqlvbKGsqpHszOShDssYM0T8dPF9ELhSVUsAVLUI+DRwtt+TiMhCYBVwYdjmzwHzcdXSjwW+IiLHeY/dC/xeVY8Argce8hKcGcUCgUCXauYFJdbNZ8xY5idBhYCkbtsSgcZDOM/VwJ+AB8O2nQ/cpaqtqloJ3A98UkSm4Or/3Q+gqv8EUoHlh3A+M0JZdXNjTDs/XXyPAH8XkW8CBcBM4Mfedl9U9RoAEflg2OZpwJ6w+4XAUm97kaoGuz02FXjb7znNyDQ9rAW1r6yO5pY2EuKtaL4xY5GfFtS3gH3AK0AxbqLEDuDbg3Du8FHwANDWw/bwx8woNy4pnuwMN+4UDIUo3F87xBEZY4aKn0oSdap6GW5tqDxgnKpepaoDfeco8I7XLg/XUioAcruNObU/ZsaA8Nl8L75TyNaCysOa0RcKhWwmoDEjWL9dfCKSBFwBzALivW0AqOp1Azj3Y8CVIvIEbozpEuDzqlooItuBi4H7ReRMIAhsGMC5zAgyb1oG7+h+gqEQtQ0tPPd6Ppt2lnPq8ilMHN//rL6yqgbWby9je2EVKUnxfGzFXJIS/fRmG2OGEz//tXcBJwMvAs2DeO7fAXNwldITgDtUdY332KXAH0Xke7jJGBd1G5Myo1hWRjIfPGEGL76zl/rGFgD2ltbywL+2smRuFsceMZmkhK5/um3BEDv3VrFhezlFZZ2N++aWNrbtqWLJ3KyovgZjzMD5SVDnAvPap5kPhKpeEXa7FfhKL/ttA04b6PnMyDV3agbTJqfx5nvFrN9WRjAUIhgK8e62UrYWVHLSkjwWzMykoamV93ZVsHFHGbUNLT0eq7SqPsrRG2MGg58EVQjURToQY7pLjI/l5GVTWDhzAi+t29sxYaKhqZVVawt4S0uoqWumLdh1nCkmECBn4jiKytyfbWllQ9RjN8YMXK8JSkSWejcfBh4XkRuByvB9VHV9BGMzBoCJ45P56Klz2F5YxSvvFnW0lKpqmrrsNy4pnsWzJ3LE7InExQb402MbASivbqStLUhsrNVGNmYk6asFtQ433bt9Nt1p3R4PAXaBiomKQCDAvGmZzMxNZ+3m/azbur+j5ZQzMYWlc7OYM2V8lySUnpJAdV0zwWCIiuomK5tkzAjT14q69nHTDDvxcbGcuCSXI2ZNIL+4mpwJKUzylunoLjsjmeo6N6+ntKreEpQxI4yfaeYFuCnhjwMveJMbjBlS41MTWTq374L62Znj2LH3AOCNQ82KRmTGmMHiZ5LEJbjCsD8GZovIc7hk9ZSqVkUyOGMGor0iBbhro4wxI0u/CUpVXwVeBf5XRHJwhV/vwF27lBDZ8Iw5fOFdemVVDQSDIWJirCi+MSOFny6+PGCF93U6kAn8C7d8hjHD1rikeMYlxVPf2EJLW5ADtU1kpncvzG+MGa78XgfVAPwf8HHgbavqYEaK7Ixk8ovdtPTSqgZLUMaMIH5m6l0K3AecAzwA3CEil4rI5IhGZswgCO/mK7VxKGNGFD9jUA/gEhMiMhvXivoVrqvProMyw1r4RAmrKGHMyOJnDCoeVyz2DO9rAfAC8ERkQzNm4LIzO6+RKq2qJxQKEQj4myixtaCStzaXIDMncJRMilSIxphe+BmDqgJKgaeB64FVqtrU91OMGR7SxsWTmBBLU3MbTc1t1NS3kJ7S/+TTtmCINW8X0tTSxqvri5idN56MtMQoRGyMaecnQZ1oNffMSBUIBMjOGEfh/hoASivrfSWo4vI6mlo6F3HeWlDJcYtyIhanMeZgflbUteRkRrQu41A+J0rk76vucn9LfoWtzmtMlFm9PTPqdb9g14/uCaq6rpl9ZbbqjDHRZAnKjHpZhziTr7a+mfLqxoO2b8mvGNS4jDF985WgRGSc9z1WRD4hImdFNixjBk9GaiLx3jIcdY0tHcvI9ya/uKbjdmpyfMft7YUHaG2za9SNiZZ+E5SIfBJXTQLgp8DtwP+JyHciGZgxgyUmJsDEQ2hF7Q7r3ls+fxIZqW72XnNLGzu96ujGmMjz04L6BnChiMQCVwIfA04CvhjJwIwZTH4nSrS1BTtm/AFMz01jwcwJHfetm8+Y6PGToKap6vPAiUCrqr6iqruB8RGNzJhB5LfkUVFZHS2trhtvfGoiGamJzJ+e2fH4npJa6hr67iI0xgwOPwmqSETOBD6Dq2KOiFwM7IxkYMYMpuyMsIoSlfW97pdf3Nm9NyMnjUAgQHpKAlOyUwEIhUJoQWXkAjXGdPCToL4J3I9bbuN6ETkduNPbbsyIMCE9sWMtqOq6Zhqbe14YOn9fZ/fejJz0jtsLZnR28+luuybKmGjwk6CCwGRVnaGqW4H/ALmq+lxkQzNm8MTGxjAxbKmN8gMHTyM/UNtEZY3bHhcbw5RJqR2PzZk6njhvJmB5dSNlVQc/3xgzuPwkqHvD76hqg6rW9LazMcNVl3GoHrr5CsKml0/JTu1ISAAJ8bHMmdI57GqTJYyJPD8J6mXgU+3XQhkzUnUdhzp4okSX8afctIMelxmdkyW2FlTSFrRuPmMiyU+x2AXAh3ELFVYDHf+Vqjqh12f5ICI/Ay4C2j+Oqqpe7F1j9V9efPcAN6qqvRuYAcnqY6p5a1uQwv21HffDx5/aTZ2URmpyPLUNLTQ0tVJQXM2sPJvMakyk+ElQn43g+U8CLlHVV9s3iMg5uEURjwbagGeB94C/RzAOMwZkZSQRCAQIhUJU1jTR0hokPs51Iuwtre2oEpGRlsj41IOX1oiJCTB/eiZv634ANL/SEpQxEeRnRd01ACIyB5gJrAHGqWp1X8/rj4gkAsuBb3rH3gp8FTgfuE9V67z97gI+iSUoM0DxcbFkpCZSWdNIKBSi/EADORNTACjoZfZedzKjM0HtKjpAY3MrSQl+PucZYw6Vn1JHWSLyb2AL8BggwC4ROXqA584Dnge+BywFXvOOPx3YE7ZfITB1gOcyBuj9gt3w8aeZub0nqInjk5nkrdLbFgyxfU9VBKI0xoC/SRK/BjYDGUCLqm4CbgV+PpATq+ouVT1HVTd640u3AXO8mMLHmwK4rj5jBqynyuZVNU1U1bpFouNjY8jLSunzGOGTJTTfLto1JlL8JKjTga97XW7tieM2YMlATiwiS0Xk8m6bA0A+rnXVLo/OYrXGDEh4Tb72taHCW09TJ6USG9v3v8W8aRnEBNxFv/vK66iqaYpApMYYPwmqBsjtti2Xzpl3hysI/FJEZnn3vwCsx3XzXSYiKd441RXAowM8lzFA1wRVfqCBtmCo2/Ty3rv32o1Liu+yn9o1UcZEhJ8EdSfwpIhcBMSKyBnAA8BfBnJiVd0IfAl4QkQ24yZHXKqqTwCPAG8AG4G3BnouY9olJcaRnpIAuDGk0sp69oZNL5/exwSJcF26+QoqrfSRMRHgZ/rRj4FG4EZv/98Cf/a2D4iq3oO7zqn79luAWwZ6fGN6kp2RTHVdMwDvbC3tuOB2QnpSR/Lqz6zcdBITYmlqbqO6rpm3dT9HySQCXtefMWbg/EwzD+IWKbw98uEYE3nZmePY4S08GL4AoZ/uvXaxsTHMn5bJhh1lAPxnwz72V9Rz+rHTSYyPHdyAjRmj+k1QIpKHuz5pFt26BFX1ggjFZUzEhM/kC++amz754PJGfTl+cQ77K+spqXB1/XbsPUDZga2cdcLMLtPZjTGHx88Y1N+B44FNwLvdvowZccInSrSLj+t/enl3SQlxXHDaXJbOzerYdqC2iYee38qmneU2LmXMAPkZg1oGZKuqrS9gRoWU5HjGJcVT39i5Mu70yWn9Ti/vSWxsDKcun0puVgrPr91DS2uQtmCIF97aw76yWt5/1FTi46zLz5jD4ec/8jVcwVhjRo3urSi/s/d6M29aJh//wPwua05tya/koVXbOtaYMsYcGj8tqG8DL4jIC0CXui6qemVEojImwrIykg9a3n2gMtOSuHDlfNa8XdixXlR5dSN///dWzjlpFtMOcYzLmLHOTwvqF8B2XDWHA92+jBmRwicxTByfTOo4f9PL+xMfF8PKY6dx+jHTOhY8bGkN8u83CmhusYpdxhwKv2NQWapq9VzMqDEzN53sjGQqqhs59ojJg3rsQCDAEbMmMilzHI+/tJP6xhbqGltYu7mEk5bm9X8AYwzgrwX1FrAw0oEYE01xsTF8/APzueq8JcydmhGRc2RlJHPS0s4qYeu2ldp4lDGHwE8L6g1gjYg8BpTTdUXd6yIVmDGRFggEiIuNbOUHmZ7Jph3l7CuvIxgM8fK6Ij508iyrOGGMD35aUNm42nhtuCU3MsO+jDF9CAQCnLJ8SkdCyi+uZve+Aa31acyY4afU0X9HIxBjRqtJmeNYNGsCG3eWA/DSur1Mm5zWMYnCGNMzP6WOYoBvAFcC04ASXIHXG1TVpiUZ48MJi3PZVljVUVx23dZSjlk4uJMzjBlt/HyE+x7wKeD7wArgf4ALgOsjGJcxo0pSYhwnLOqcMPHW5hJq65uHMCJjhj8/CeoK4EOq+oCqvq6q9wEfAT4d0ciMGWUWzZ7YUai2pS3IK+uLhjgiY4Y3PwlqPAcvuV4IJPWwrzGmFzExAU49ckrH/W17qijcXzOEERkzvPlJUK8At4hILICIxAE/BP4TycCMGY3yslOZP71zAuxL7+wlGLSq58b0xE+Cug435lQmIu8BZcDZuOXajTGH6KSlecTHuX+98urGjkUPjTFd9ZugVHU7rpr5hcBNwDm48kflkQ3NmNEpNTmeYxfmdNx/Y1Nxl6U/jDGOn2nmFao6AVgVti0A7MGNTxljDtGyeVm8t6ucqtommlra+NcbBSydm0VuVgpJCX4KvBgz+vX4nyAiM4GHgQCQLiJvd9slDbApSMYcptjYGE45cgpPvLwTgD0lNewpqSEQCJCdkcyUSalMzU4lNyuFhHhb8NCMTT0mKFXdLSLfx5U5+h1uyY1wTcCaCMdmzKg2IzedI2ZN4L1dFR3bQqEQ+yvr2V9Zzzu6n5hAgOzMZGZPGc+R87IPa9XfqpomtuRXkJeVMuCFGY2Jpl77ElT1KQAR2aiqa6MXkjFjx4qjpzFvWiYFJTXs3V9LaVUDoVDnrL5gKERJRT0lFfXk76vhnJNmkpTovwtwT0kN//zP7o61qI5ZOJnjF+VYsVozIvj5S98lIv+jqj8UkeOBvwIVwH+pqkY2PGNGt0AgwLTJaR2r7Ta1tFFUWsve0lr27q+l7EBjR8IqKqvloee3ce7Js8hM6/8yxI07ynjxnb0EwxLe2s0lVNU08YHjplstQDPs+UlQvwdSvYkRvwGeAWpwXX+nRzA2Y8acxPhYZuWNZ1aem3/U2NTKxp3lvL6pmFAoRFVtEw89v42zT5zJ1Ek9LyEfDIZ4ZX0R724r7dgWExPouN5qe2EVNfXNnPu+WYxLio/8izLmMPn5CHUCcD6QAxwJ3Iiry3d0BOMyxuBq+B2zcDJnnTCjo8XT1NzG4y/u5L1dB1/p0dzSxtOv7uqSnCZljuNTZy9k6dysjm0lFfU8uGobZVUNkX8RxhwmPwkqCbdI4VnAelUtx60LZUvAGxMlc6ZmcMFpc0nxWjzBUIjn1+7hlfVFHV2ANfXNPLJ6e5f1puZMGc/5p80hdVwCpy6fyqlha1PV1Dfz8AvbyLf1qcww5aeL75/A07iLdW8VkdnAX4DHIxmYiJwL/AhIBNYDn1ZV+08yY9akCeO4aOU8nnplF6Vey+cd3c+B2iaWzcvm2dfyu1zwe5RM4sQluV0mRCydm834lESefT2f5pY2WlqDPPnKLk5elsfSuVk2ecIMK34S1GeBLwL3qeqdIrIQeB64JVJBiUg2cBfwPlXdJiI/AX7sxWHMmJU6LoELVszludfy2eW1fHbuPcDOvQc69okJBFhx9DQWzprQ4zFm5KbzsRVzeeqVXVTXNRMKhXhp3V6KyuoYn5IQlddhRo+87FRm5KRF5MNNIHxK63AhIpcBn1DVc737M4F3gQxVPShg7/Fdq1atYurUqdEM1ZghEQyGeHVDEeu2lnbZnpgQyzknzWJKdmq/x6hvbOGpV3ZRUlEfqTDNGHHh6fPImZhyWM8tLCxk5cqVALNUdXf4Y35KHVXixqAO4pVAioRpuFJK7QqBdFwFC+vmM2NeTEyAk5dNITMtiTVvFxIMhchITfQ9BR1gXFI85582l1VvFrBtT1WEIzajWaQuWfDTxXdet/tZwNXAg4MfTocYek6KtsS8MWEWzZ5IblYK+yvrmZ03/pDLIsXFxvDB42ewYOYEyqsaIxSlGc3yslM6FuIcbP0mKFU9qKSRiKwGXsVdCxUJBcDxYfenAJWqWheh8xkzYk1IT2JC+uGvHxoIBJiRk84MK4NkhpnDbZfFAZMGM5BungNOEJF53v3PA49F8HzGGGOGGT9jULd325SAW7DwmYhEBKjqfhH5b+AhEUkAdgCfitT5jDHGDD9+xqAyu91vA+7AlUCKGFV9Gnf9lTHGmDHIzxjUf0cjEGOMMSZcn2NQInKSiFwZdj9BRP4lIidHPjRjjDFjWa8JSkROxU1WmBy2OQnYCTwrIu+LcGzGGGPGsL66+K4Hvqyqd7Zv8GrhfU5EFLgBOCOy4fkWC1BcXDzUcRhjjDkEYe/bB13E11eCWgac2ctjvwf+Z2BhDapcgMsuu2yo4zDGGHN4cnEztjv4Xzu6q+G21MabwCnAPqzahDHGjCSxuOT0ZvcH+kpQ7+DWgHqyh8fOAbYOSmiDQFWbgJeHOg5jjDGHZUdPG/tKULcBfxaRq4CnVbVNRGJxyekPwLWDH6Mxxhjj9LnchjfF/Ge46hEVwESgAfi2qv4xKhEaY4wZk/pdD0pEkoGTgGzcGM+rqtrS55OMMcaYARqWCxYaY4wxkVllyhhjjBmgw51mPmKJyLnAj4BEYD3wae8C5EPaZzTw+bP4JPAN3AKS9cC1qro22rFG2qH8zkXkPOCvqpoWxRCjwuffxBLgV8B43GUdn1PVt6Ida6T5/FmcD9wIBHHj9Fepao8z0kY6EQkAdwMbVPW2Hh4f9PfNMdWCEpFs4C7gY6oquLJNPz7UfUYDnz8LAX4KnKWqRwI/AB6JdqyRdii/c2+NstuAQPQijA6ffxPjcCXQblXV5cDNwL3RjjXSfP4skoF7gAu8/48ngF9GO9ZoEJGFwCrgwl4ej8j75phKUMAHgTdVdZt3/3fAZd4ng0PZZzTw8zqbgM+o6j7v/logx1ujazTx9Tv33pzvAa6LcnzR4vf/Y4e3HA7A48DHoxhjtPj5WcTiPqiM9+6nAo3RCzGqrgb+BDzYy+MRed8ca11804A9YfcLgXQgDag+hH1Gg35fp6ruBnZDR/P+duBxVW2OZqBR4Pd3fof3tT56oUWVn5/DfKBYRO7ElUOrAr4ZzSCjxM//R62IfB54VUTKcQlrVBbRVtVrAETkg73sEpH3zbHWgorBjaV013aI+4wGvl+niKQAfwfmAp+JcFxDod+fhYh8EWhV1f+LWlTR5+dvIh7vYn1VPQY3FvW0iCRGIb5o8vM3sQT4PnCEquYBPwQeHoW9LX5E5H1zrCWoAiAv7P4UoFJV6w5xn9HA1+sUkenAq7g/tBWqWhW9EKPGz8/iCuBYEVmHW+k5WUTWiUj480Y6Pz+HImCzqr4OoKqP4VoOs6MWZXT4+VmcCbwSNiniN8BiXEGDsSYi75tjLUE9B5zgDXQDfB547DD2GQ36fZ0ikgasBh5R1UtUtSG6IUZNvz8LVT1OVRd7g+HnAA2qeqSqFkU51kjy87f/T2CWiBwNHevGhYBdUYsyOvz8LN4G3i8i7WvmnQfsUtWyKMU4nETkfXPMXagrIufgpkIm4AoUfgr36e9P3ptPj/uoasXQRBw5/f0sROQ7uJl7G7o9daWqlkc12Ajz83cRtu9MYKOqpkY7zkjz+f9xKm52ZwpuIs2XVXXUFWv2+bO4GrgGaMZNM79GVTcNTcSRJyJ34/72bxORY4jw++aYS1DGGGNGhrHWxWeMMWaEsARljDFmWLIEZYwxZliyBGWMMWZYsgRlRjQRmTXUMYx2IpIhIhkROG5y2BRtYw4y1kodmSEgImfiKqIvx9Uuexe4QVXXDPC4HwJuAo4acJDDiIj8E3hCVX87gGOsBh5V1Z8PQkhbcbXW1g3CscKtAW4BHu3pQa8A6fXAR4EJwH7gH8BN7ReMi8gNwJGqep6IfBdYoqqXDnKcZohYC8pElIhcCfwVVxInF8jBVb9+WkROHuDhsxiFf8OqevZAklMEZEfouJN6e8BLTq8DGcAKXCHW04HJwJsiktn9Oap6iyWn0cVaUCZivOrftwNXeCVx2v3J69pZALzsXfxXpapf8Z53Gu7Tf4a3pMEfgLNxF4X+B3eV+izg90C8iFR5+84F/h+uYGc1rvz/D1W11TtHKXAccDSu4Ou1uCUBTvDuf1xVC0UkFvgWru5gOvA8cLWqlnqx/QHYApwCXBZW2bv9dX8M+DYwB9di/AduzaQWr2WzG1cmR4Ebuh8PV3z1UWATcB+Qq6qt3rFvByao6hV9naeP38lMYCPwN+Ai73U+gFsm4hRcAtgBfEVVV4lI+zpPr4rIf6vqAyJyFfB1XIJ5Hfiiqu7s4VyJuAt6z8aVwdkHfE9V7xeRfwDTgb+JyPWqemu3p1+PK6n0ybBtu7z1yVbjauB9tdv5bqCzNXUDrrBtCrASV4rnu6raY2vNDE+j7tOnGVZOwi1e9lT3B1T1h6r6Jx/H+CIwFfdmNg9XHfkLqvomLlFt8JJTAq7cyjbcm+FK4GJc12K7z+OWysjGXe2+CvcGPQlXa7D9De/LwCeBM3BVmkuB+8OOM897TXneMTqIyAxci/GrqjoBOBb4MK4MTrvjgYW4rqu+jrcKt3zDB71jx3iv6S8+z9ObFO81TcItH3Krt20RLiE/g7eukaoe7T3nJC85XYDrVr0Ul8zW4FrDPX3Y/RpwDO5DQRrwC+AOEYlT1fNxSePSHpIT3mu5v/tGVQ3hFs0738fr/Dgu+Wfilon43Rgt5DpiWYIykZQNVPT1id6HA7iW1iW47p6zVfXmHvY7BVek81uq2ugV8LwJuDJsn8dU9S2vpuB/gBe8+/XAC7hWGcBVwI2qusPb95u4mmvzwo51r6o2qGpTtzj2AYtU9WURGe/9DMroWkjzSVWtUtUDfR1PVYO4BPIJb9MKXCJ9wed5+nKvqjZ7xTz/F/g0roU6DbeERm/HuQr4uaq+7S278mNcUlvRw76/xyXh9uPVefum+IgvFyju5bF9uK7i/rypqk95f3/3eM8ZdeWpRjNLUCaS9gETRSS++wMiMt7nEg134j7hfwm33sxaETmhh/0mAfu6JcPduDfcduH1A9twb5ztgnT+P8zAdUNWiUgVsBdoAWZ6j1eram0v8bYAV4pIEa6Y6NeAZLquwNu9wGxfx/v/7Z2/axRhEIYfEbTSWPkjFkEtBkEEMY2WEVRQjEgKxSKFhRG0EUGQxHQaxFJEA4JRkRSCpY2NQUX8A2LGwkIkEggETaFJoRbvHq7LJVyCgSW8DxwHd7fzDfsd+4hsfJsAAAJ/SURBVH4zO/vNCNBdpEvPolbzv1scZzHKPrSjjT2nUEqxcxE7HcD10rmZQQuHjia/3YiinenC/qHi81Z8nEJR80I+LCReVRsNGv+LtS0cZ2qCBcqsJG+BH2j37yq3UNsKkFiUu/SW2xXsRk0S96EV8Bu0Gq7yGWivdPvdyb8XqVY3npwEejJzU+OFUmiNqsPF7JxGQtKZmbsyswdFgWWqxy9oLzMngHGUujsFPFrCOItRHnMUzcXmzDxQGqMZk8DlyrnZj4Styn20y/mWIlV4ewn+PQd6m3Q1XoNan6zGDgOmgoskzIqRmfMRcRUYjojf6CK4HjiPdoY+Wvz0I9AXEVvRSvdiycwZoCsiutFu0bPFOygltaG4N/MeRTpDRbnxdqAfVQwulRFgMCLG0QX5CipGaOWZqzYkuHNF5NgH7OVfAV6OPzeBzMxcgXHaUPuQX0WhyUDFzjx/25qPAAMRMYYKO86gYpQ96P5f1e5P4FdEbEPpQEq250p2qwyiOX0aEf1I6HagsvQtKH1rVjmOoMyKkpnDqFruGnqO5QtwDDhSeg7qHroYTQDvgGclEzdQtdsHlJI7CPQW371CgvYN3dc4DgQSlddoFT64DLeHgJfAGEphnSj8baVZ4whKuX1CgtmFKub2LMOPBqMoeixHNv9znHPApYiYRcUaT4B1EdFoQvgAeBERFzLzMXAHRTDf0f25k5lZFSdQsclhND9v0XxNl3x8CNyNiBvVAzNzBkWtk2guZlHRyFcUNa6qdi+mOW63YYwxppY4gjLGGFNLLFDGGGNqiQXKGGNMLbFAGWOMqSUWKGOMMbXEAmWMMaaWWKCMMcbUEguUMcaYWvIHkTiAHulpjWIAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "p2_array=linrange(0,1,0.025)\n",
+    "sweep=sweep_p2(p2_array,600)\n",
+    "plot(sweep,label='Olin')\n",
+    "\n",
+    "decorate(title='Olin-Wellesley Bikeshare', xlabel='Customer arrival rate at Olin', ylabel='Customers who find no bikes available')\n",
+    "\n",
+    "savefig('chap04-fig_ex_2')"
+   ]
+  },
+  {
+   "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": 88,
+   "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": "code",
+   "execution_count": 106,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_multiple_functions(p1,p2,num_steps,num_runs):\n",
+    "    series=TimeSeries()\n",
+    "    for i in range(num_runs):\n",
+    "        state=run_simulation(p1,p2,num_steps)\n",
+    "        series[i]=state.olin_empty\n",
+    "    return series     "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 142,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Average value is  2.95\n",
+      "0      1\n",
+      "1     16\n",
+      "2      0\n",
+      "3     11\n",
+      "4      0\n",
+      "5      3\n",
+      "6      0\n",
+      "7      0\n",
+      "8      0\n",
+      "9      0\n",
+      "10     0\n",
+      "11    14\n",
+      "12     2\n",
+      "13     0\n",
+      "14     0\n",
+      "15     1\n",
+      "16     0\n",
+      "17    10\n",
+      "18     0\n",
+      "19     1\n",
+      "dtype: int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "series=run_multiple_functions(0.3,0.3,300,20)\n",
+    "average=TimeSeries.mean(series)\n",
+    "print('Average value is ',average)\n",
+    "print(series)"
+   ]
+  },
+  {
+   "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": 184,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_multiple_functions(p1_array):\n",
+    "    sweep=SweepSeries()\n",
+    "    for p1 in p1_array:\n",
+    "        series_t=TimeSeries()\n",
+    "        for i in range(20):\n",
+    "            state=run_simulation(p1,0.3,60)\n",
+    "            series_t[i]=state.olin_empty\n",
+    "        sweep[p1]=TimeSeries.mean(series_t)\n",
+    "        #print(sweep)\n",
+    "    return sweep"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 185,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.00     0.00\n",
+      "0.05     0.00\n",
+      "0.10     0.00\n",
+      "0.15     0.00\n",
+      "0.20     0.00\n",
+      "0.25     0.00\n",
+      "0.30     0.00\n",
+      "0.35     0.10\n",
+      "0.40     1.65\n",
+      "0.45     2.75\n",
+      "0.50     4.85\n",
+      "0.55     6.70\n",
+      "0.60     7.80\n",
+      "0.65    11.65\n",
+      "0.70    13.95\n",
+      "0.75    18.65\n",
+      "0.80    20.00\n",
+      "0.85    21.80\n",
+      "0.90    26.60\n",
+      "0.95    29.00\n",
+      "1.00    31.65\n",
+      "dtype: float64\n",
+      "Saving figure to file chap04-figEx4.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "p1_array=linrange(0,1,.05)\n",
+    "sweep=run_multiple_functions(p1_array)\n",
+    "print(sweep)\n",
+    "plot(sweep, label='Olin')\n",
+    "\n",
+    "decorate(title='Olin-Wellesley Bikeshare',\n",
+    "         xlabel='Arrival rate at Olin (p1 in customers/min)', \n",
+    "         ylabel='Average Number of unhappy customers')\n",
+    "\n",
+    "savefig('chap04-figEx4.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "What value of p1 minimizes the average number of unhappy customers? Just based on that set of 20 runs, if p1 is .30 or less there will be no unhappy customers ever. Based on another set of 200 runs (Fig Ex4a), you might expect one unhappy customer every 200 hrs at p1=0.25 (0.005 unhappy customers/hr). "
+   ]
+  }
+ ],
+ "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap05mneal.ipynb b/code/chap05mneal.ipynb
new file mode 100644
index 00000000..e6d42094
--- /dev/null
+++ b/code/chap05mneal.ipynb
@@ -0,0 +1,1781 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 5\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": 1,
+   "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.py module\n",
+    "from modsim import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Reading data\n",
+    "\n",
+    "Pandas is a library that provides tools for reading and processing data.  `read_html` reads a web page from a file or the Internet and creates one `DataFrame` for each table on the page."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pandas import read_html"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The data directory contains a downloaded copy of https://en.wikipedia.org/wiki/World_population_estimates\n",
+    "\n",
+    "The arguments of `read_html` specify the file to read and how to interpret the tables in the file.  The result, `tables`, is a sequence of `DataFrame` objects; `len(tables)` reports the length of the sequence."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "6"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "filename = 'data/World_population_estimates.html'\n",
+    "tables = read_html(filename, header=0, index_col=0, decimal='M')\n",
+    "len(tables)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can select the `DataFrame` we want using the bracket operator.  The tables are numbered from 0, so `tables[2]` is actually the third table on the page.\n",
+    "\n",
+    "`head` selects the header and the first five rows."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "scrolled": true
+   },
+   "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>United States Census Bureau (2017)[28]</th>\n",
+       "      <th>Population Reference Bureau (1973–2016)[15]</th>\n",
+       "      <th>United Nations Department of Economic and Social Affairs (2015)[16]</th>\n",
+       "      <th>Maddison (2008)[17]</th>\n",
+       "      <th>HYDE (2007)[24]</th>\n",
+       "      <th>Tanton (1994)[18]</th>\n",
+       "      <th>Biraben (1980)[19]</th>\n",
+       "      <th>McEvedy &amp; Jones (1978)[20]</th>\n",
+       "      <th>Thomlinson (1975)[21]</th>\n",
+       "      <th>Durand (1974)[22]</th>\n",
+       "      <th>Clark (1967)[23]</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Year</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1950</th>\n",
+       "      <td>2557628654</td>\n",
+       "      <td>2.516000e+09</td>\n",
+       "      <td>2.525149e+09</td>\n",
+       "      <td>2.544000e+09</td>\n",
+       "      <td>2.527960e+09</td>\n",
+       "      <td>2.400000e+09</td>\n",
+       "      <td>2.527000e+09</td>\n",
+       "      <td>2.500000e+09</td>\n",
+       "      <td>2.400000e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.486000e+09</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1951</th>\n",
+       "      <td>2594939877</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.572851e+09</td>\n",
+       "      <td>2.571663e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1952</th>\n",
+       "      <td>2636772306</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.619292e+09</td>\n",
+       "      <td>2.617949e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1953</th>\n",
+       "      <td>2682053389</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.665865e+09</td>\n",
+       "      <td>2.665959e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1954</th>\n",
+       "      <td>2730228104</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.713172e+09</td>\n",
+       "      <td>2.716927e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      United States Census Bureau (2017)[28]  \\\n",
+       "Year                                           \n",
+       "1950                              2557628654   \n",
+       "1951                              2594939877   \n",
+       "1952                              2636772306   \n",
+       "1953                              2682053389   \n",
+       "1954                              2730228104   \n",
+       "\n",
+       "      Population Reference Bureau (1973–2016)[15]  \\\n",
+       "Year                                                \n",
+       "1950                                 2.516000e+09   \n",
+       "1951                                          NaN   \n",
+       "1952                                          NaN   \n",
+       "1953                                          NaN   \n",
+       "1954                                          NaN   \n",
+       "\n",
+       "      United Nations Department of Economic and Social Affairs (2015)[16]  \\\n",
+       "Year                                                                        \n",
+       "1950                                       2.525149e+09                     \n",
+       "1951                                       2.572851e+09                     \n",
+       "1952                                       2.619292e+09                     \n",
+       "1953                                       2.665865e+09                     \n",
+       "1954                                       2.713172e+09                     \n",
+       "\n",
+       "      Maddison (2008)[17]  HYDE (2007)[24]  Tanton (1994)[18]  \\\n",
+       "Year                                                            \n",
+       "1950         2.544000e+09     2.527960e+09       2.400000e+09   \n",
+       "1951         2.571663e+09              NaN                NaN   \n",
+       "1952         2.617949e+09              NaN                NaN   \n",
+       "1953         2.665959e+09              NaN                NaN   \n",
+       "1954         2.716927e+09              NaN                NaN   \n",
+       "\n",
+       "      Biraben (1980)[19]  McEvedy & Jones (1978)[20]  Thomlinson (1975)[21]  \\\n",
+       "Year                                                                          \n",
+       "1950        2.527000e+09                2.500000e+09           2.400000e+09   \n",
+       "1951                 NaN                         NaN                    NaN   \n",
+       "1952                 NaN                         NaN                    NaN   \n",
+       "1953                 NaN                         NaN                    NaN   \n",
+       "1954                 NaN                         NaN                    NaN   \n",
+       "\n",
+       "     Durand (1974)[22]  Clark (1967)[23]  \n",
+       "Year                                      \n",
+       "1950               NaN      2.486000e+09  \n",
+       "1951               NaN               NaN  \n",
+       "1952               NaN               NaN  \n",
+       "1953               NaN               NaN  \n",
+       "1954               NaN               NaN  "
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "table2 = tables[2]\n",
+    "table2.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`tail` selects the last five rows."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "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>United States Census Bureau (2017)[28]</th>\n",
+       "      <th>Population Reference Bureau (1973–2016)[15]</th>\n",
+       "      <th>United Nations Department of Economic and Social Affairs (2015)[16]</th>\n",
+       "      <th>Maddison (2008)[17]</th>\n",
+       "      <th>HYDE (2007)[24]</th>\n",
+       "      <th>Tanton (1994)[18]</th>\n",
+       "      <th>Biraben (1980)[19]</th>\n",
+       "      <th>McEvedy &amp; Jones (1978)[20]</th>\n",
+       "      <th>Thomlinson (1975)[21]</th>\n",
+       "      <th>Durand (1974)[22]</th>\n",
+       "      <th>Clark (1967)[23]</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Year</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2012</th>\n",
+       "      <td>7013871313</td>\n",
+       "      <td>7.057075e+09</td>\n",
+       "      <td>7.080072e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2013</th>\n",
+       "      <td>7092128094</td>\n",
+       "      <td>7.136796e+09</td>\n",
+       "      <td>7.162119e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2014</th>\n",
+       "      <td>7169968185</td>\n",
+       "      <td>7.238184e+09</td>\n",
+       "      <td>7.243784e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2015</th>\n",
+       "      <td>7247892788</td>\n",
+       "      <td>7.336435e+09</td>\n",
+       "      <td>7.349472e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2016</th>\n",
+       "      <td>7325996709</td>\n",
+       "      <td>7.418152e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      United States Census Bureau (2017)[28]  \\\n",
+       "Year                                           \n",
+       "2012                              7013871313   \n",
+       "2013                              7092128094   \n",
+       "2014                              7169968185   \n",
+       "2015                              7247892788   \n",
+       "2016                              7325996709   \n",
+       "\n",
+       "      Population Reference Bureau (1973–2016)[15]  \\\n",
+       "Year                                                \n",
+       "2012                                 7.057075e+09   \n",
+       "2013                                 7.136796e+09   \n",
+       "2014                                 7.238184e+09   \n",
+       "2015                                 7.336435e+09   \n",
+       "2016                                 7.418152e+09   \n",
+       "\n",
+       "      United Nations Department of Economic and Social Affairs (2015)[16]  \\\n",
+       "Year                                                                        \n",
+       "2012                                       7.080072e+09                     \n",
+       "2013                                       7.162119e+09                     \n",
+       "2014                                       7.243784e+09                     \n",
+       "2015                                       7.349472e+09                     \n",
+       "2016                                                NaN                     \n",
+       "\n",
+       "      Maddison (2008)[17]  HYDE (2007)[24]  Tanton (1994)[18]  \\\n",
+       "Year                                                            \n",
+       "2012                  NaN              NaN                NaN   \n",
+       "2013                  NaN              NaN                NaN   \n",
+       "2014                  NaN              NaN                NaN   \n",
+       "2015                  NaN              NaN                NaN   \n",
+       "2016                  NaN              NaN                NaN   \n",
+       "\n",
+       "      Biraben (1980)[19]  McEvedy & Jones (1978)[20]  Thomlinson (1975)[21]  \\\n",
+       "Year                                                                          \n",
+       "2012                 NaN                         NaN                    NaN   \n",
+       "2013                 NaN                         NaN                    NaN   \n",
+       "2014                 NaN                         NaN                    NaN   \n",
+       "2015                 NaN                         NaN                    NaN   \n",
+       "2016                 NaN                         NaN                    NaN   \n",
+       "\n",
+       "     Durand (1974)[22]  Clark (1967)[23]  \n",
+       "Year                                      \n",
+       "2012               NaN               NaN  \n",
+       "2013               NaN               NaN  \n",
+       "2014               NaN               NaN  \n",
+       "2015               NaN               NaN  \n",
+       "2016               NaN               NaN  "
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "table2.tail()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Long column names are awkard to work with, but we can replace them with abbreviated names."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "table2.columns = ['census', 'prb', 'un', 'maddison', \n",
+    "                  'hyde', 'tanton', 'biraben', 'mj', \n",
+    "                  'thomlinson', 'durand', 'clark']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's what the DataFrame looks like now.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "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>census</th>\n",
+       "      <th>prb</th>\n",
+       "      <th>un</th>\n",
+       "      <th>maddison</th>\n",
+       "      <th>hyde</th>\n",
+       "      <th>tanton</th>\n",
+       "      <th>biraben</th>\n",
+       "      <th>mj</th>\n",
+       "      <th>thomlinson</th>\n",
+       "      <th>durand</th>\n",
+       "      <th>clark</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Year</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1950</th>\n",
+       "      <td>2557628654</td>\n",
+       "      <td>2.516000e+09</td>\n",
+       "      <td>2.525149e+09</td>\n",
+       "      <td>2.544000e+09</td>\n",
+       "      <td>2.527960e+09</td>\n",
+       "      <td>2.400000e+09</td>\n",
+       "      <td>2.527000e+09</td>\n",
+       "      <td>2.500000e+09</td>\n",
+       "      <td>2.400000e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.486000e+09</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1951</th>\n",
+       "      <td>2594939877</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.572851e+09</td>\n",
+       "      <td>2.571663e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1952</th>\n",
+       "      <td>2636772306</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.619292e+09</td>\n",
+       "      <td>2.617949e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1953</th>\n",
+       "      <td>2682053389</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.665865e+09</td>\n",
+       "      <td>2.665959e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1954</th>\n",
+       "      <td>2730228104</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.713172e+09</td>\n",
+       "      <td>2.716927e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "          census           prb            un      maddison          hyde  \\\n",
+       "Year                                                                       \n",
+       "1950  2557628654  2.516000e+09  2.525149e+09  2.544000e+09  2.527960e+09   \n",
+       "1951  2594939877           NaN  2.572851e+09  2.571663e+09           NaN   \n",
+       "1952  2636772306           NaN  2.619292e+09  2.617949e+09           NaN   \n",
+       "1953  2682053389           NaN  2.665865e+09  2.665959e+09           NaN   \n",
+       "1954  2730228104           NaN  2.713172e+09  2.716927e+09           NaN   \n",
+       "\n",
+       "            tanton       biraben            mj    thomlinson durand  \\\n",
+       "Year                                                                  \n",
+       "1950  2.400000e+09  2.527000e+09  2.500000e+09  2.400000e+09    NaN   \n",
+       "1951           NaN           NaN           NaN           NaN    NaN   \n",
+       "1952           NaN           NaN           NaN           NaN    NaN   \n",
+       "1953           NaN           NaN           NaN           NaN    NaN   \n",
+       "1954           NaN           NaN           NaN           NaN    NaN   \n",
+       "\n",
+       "             clark  \n",
+       "Year                \n",
+       "1950  2.486000e+09  \n",
+       "1951           NaN  \n",
+       "1952           NaN  \n",
+       "1953           NaN  \n",
+       "1954           NaN  "
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "table2.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The first column, which is labeled `Year`, is special.  It is the **index** for this `DataFrame`, which means it contains the labels for the rows.\n",
+    "\n",
+    "Some of the values use scientific notation; for example, `2.544000e+09` is shorthand for $2.544 \\cdot 10^9$ or 2.544 billion.\n",
+    "\n",
+    "`NaN` is a special value that indicates missing data."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Series\n",
+    "\n",
+    "We can use dot notation to select a column from a `DataFrame`.  The result is a `Series`, which is like a `DataFrame` with a single column."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    2557628654\n",
+       "1951    2594939877\n",
+       "1952    2636772306\n",
+       "1953    2682053389\n",
+       "1954    2730228104\n",
+       "Name: census, dtype: int64"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census = table2.census\n",
+    "census.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "2012    7013871313\n",
+       "2013    7092128094\n",
+       "2014    7169968185\n",
+       "2015    7247892788\n",
+       "2016    7325996709\n",
+       "Name: census, dtype: int64"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census.tail()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Like a `DataFrame`, a `Series` contains an index, which labels the rows.\n",
+    "\n",
+    "`1e9` is scientific notation for $1 \\cdot 10^9$ or 1 billion."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "From here on, we will work in units of billions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    2.525149\n",
+       "1951    2.572851\n",
+       "1952    2.619292\n",
+       "1953    2.665865\n",
+       "1954    2.713172\n",
+       "Name: un, dtype: float64"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "un = table2.un / 1e9\n",
+    "un.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    2.557629\n",
+       "1951    2.594940\n",
+       "1952    2.636772\n",
+       "1953    2.682053\n",
+       "1954    2.730228\n",
+       "Name: census, dtype: float64"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census = table2.census / 1e9\n",
+    "census.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's what these estimates look like."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap05-fig01.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(census, ':', label='US Census')\n",
+    "plot(un, '--', label='UN DESA')\n",
+    "    \n",
+    "decorate(xlabel='Year',\n",
+    "         ylabel='World population (billion)')\n",
+    "savefig('chap05-fig01.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following expression computes the elementwise differences between the two series, then divides through by the UN value to produce [relative errors](https://en.wikipedia.org/wiki/Approximation_error), then finds the largest element.\n",
+    "\n",
+    "So the largest relative error between the estimates is about 1.3%."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1.3821293828998855"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "max(abs(census - un) / un) * 100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** Break down that expression into smaller steps and display the intermediate results, to make sure you understand how it works.\n",
+    "\n",
+    "1.  Compute the elementwise differences, `census - un`\n",
+    "2.  Compute the absolute differences, `abs(census - un)`\n",
+    "3.  Compute the relative differences, `abs(census - un) / un`\n",
+    "4.  Compute the percent differences, `abs(census - un) / un * 100`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    0.032480\n",
+       "1951    0.022089\n",
+       "1952    0.017480\n",
+       "1953    0.016188\n",
+       "1954    0.017056\n",
+       "1955    0.020448\n",
+       "1956    0.023728\n",
+       "1957    0.028307\n",
+       "1958    0.032107\n",
+       "1959    0.030321\n",
+       "1960    0.016999\n",
+       "1961    0.001137\n",
+       "1962   -0.000978\n",
+       "1963    0.008650\n",
+       "1964    0.017462\n",
+       "1965    0.021303\n",
+       "1966    0.023203\n",
+       "1967    0.021812\n",
+       "1968    0.020639\n",
+       "1969    0.021050\n",
+       "1970    0.021525\n",
+       "1971    0.023573\n",
+       "1972    0.023695\n",
+       "1973    0.022914\n",
+       "1974    0.021304\n",
+       "1975    0.018063\n",
+       "1976    0.014049\n",
+       "1977    0.011268\n",
+       "1978    0.008441\n",
+       "1979    0.007486\n",
+       "          ...   \n",
+       "1987   -0.018115\n",
+       "1988   -0.023658\n",
+       "1989   -0.028560\n",
+       "1990   -0.031861\n",
+       "1991   -0.037323\n",
+       "1992   -0.038763\n",
+       "1993   -0.040597\n",
+       "1994   -0.042404\n",
+       "1995   -0.042619\n",
+       "1996   -0.041576\n",
+       "1997   -0.040716\n",
+       "1998   -0.040090\n",
+       "1999   -0.039403\n",
+       "2000   -0.039129\n",
+       "2001   -0.038928\n",
+       "2002   -0.038837\n",
+       "2003   -0.039401\n",
+       "2004   -0.040006\n",
+       "2005   -0.041050\n",
+       "2006   -0.041964\n",
+       "2007   -0.043192\n",
+       "2008   -0.044599\n",
+       "2009   -0.046508\n",
+       "2010   -0.057599\n",
+       "2011   -0.061999\n",
+       "2012   -0.066201\n",
+       "2013   -0.069991\n",
+       "2014   -0.073816\n",
+       "2015   -0.101579\n",
+       "2016         NaN\n",
+       "Length: 67, dtype: float64"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census-un"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    0.032480\n",
+       "1951    0.022089\n",
+       "1952    0.017480\n",
+       "1953    0.016188\n",
+       "1954    0.017056\n",
+       "1955    0.020448\n",
+       "1956    0.023728\n",
+       "1957    0.028307\n",
+       "1958    0.032107\n",
+       "1959    0.030321\n",
+       "1960    0.016999\n",
+       "1961    0.001137\n",
+       "1962    0.000978\n",
+       "1963    0.008650\n",
+       "1964    0.017462\n",
+       "1965    0.021303\n",
+       "1966    0.023203\n",
+       "1967    0.021812\n",
+       "1968    0.020639\n",
+       "1969    0.021050\n",
+       "1970    0.021525\n",
+       "1971    0.023573\n",
+       "1972    0.023695\n",
+       "1973    0.022914\n",
+       "1974    0.021304\n",
+       "1975    0.018063\n",
+       "1976    0.014049\n",
+       "1977    0.011268\n",
+       "1978    0.008441\n",
+       "1979    0.007486\n",
+       "          ...   \n",
+       "1987    0.018115\n",
+       "1988    0.023658\n",
+       "1989    0.028560\n",
+       "1990    0.031861\n",
+       "1991    0.037323\n",
+       "1992    0.038763\n",
+       "1993    0.040597\n",
+       "1994    0.042404\n",
+       "1995    0.042619\n",
+       "1996    0.041576\n",
+       "1997    0.040716\n",
+       "1998    0.040090\n",
+       "1999    0.039403\n",
+       "2000    0.039129\n",
+       "2001    0.038928\n",
+       "2002    0.038837\n",
+       "2003    0.039401\n",
+       "2004    0.040006\n",
+       "2005    0.041050\n",
+       "2006    0.041964\n",
+       "2007    0.043192\n",
+       "2008    0.044599\n",
+       "2009    0.046508\n",
+       "2010    0.057599\n",
+       "2011    0.061999\n",
+       "2012    0.066201\n",
+       "2013    0.069991\n",
+       "2014    0.073816\n",
+       "2015    0.101579\n",
+       "2016         NaN\n",
+       "Length: 67, dtype: float64"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "abs(census-un)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    0.012862\n",
+       "1951    0.008585\n",
+       "1952    0.006674\n",
+       "1953    0.006072\n",
+       "1954    0.006286\n",
+       "1955    0.007404\n",
+       "1956    0.008439\n",
+       "1957    0.009887\n",
+       "1958    0.011011\n",
+       "1959    0.010208\n",
+       "1960    0.005617\n",
+       "1961    0.000369\n",
+       "1962    0.000311\n",
+       "1963    0.002702\n",
+       "1964    0.005350\n",
+       "1965    0.006399\n",
+       "1966    0.006829\n",
+       "1967    0.006289\n",
+       "1968    0.005827\n",
+       "1969    0.005821\n",
+       "1970    0.005832\n",
+       "1971    0.006258\n",
+       "1972    0.006166\n",
+       "1973    0.005847\n",
+       "1974    0.005332\n",
+       "1975    0.004437\n",
+       "1976    0.003388\n",
+       "1977    0.002670\n",
+       "1978    0.001965\n",
+       "1979    0.001712\n",
+       "          ...   \n",
+       "1987    0.003591\n",
+       "1988    0.004604\n",
+       "1989    0.005461\n",
+       "1990    0.005988\n",
+       "1991    0.006900\n",
+       "1992    0.007054\n",
+       "1993    0.007277\n",
+       "1994    0.007490\n",
+       "1995    0.007423\n",
+       "1996    0.007142\n",
+       "1997    0.006903\n",
+       "1998    0.006709\n",
+       "1999    0.006511\n",
+       "2000    0.006386\n",
+       "2001    0.006274\n",
+       "2002    0.006183\n",
+       "2003    0.006197\n",
+       "2004    0.006216\n",
+       "2005    0.006302\n",
+       "2006    0.006365\n",
+       "2007    0.006473\n",
+       "2008    0.006604\n",
+       "2009    0.006805\n",
+       "2010    0.008328\n",
+       "2011    0.008860\n",
+       "2012    0.009350\n",
+       "2013    0.009772\n",
+       "2014    0.010190\n",
+       "2015    0.013821\n",
+       "2016         NaN\n",
+       "Length: 67, dtype: float64"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "abs(census-un)/un"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    1.286247\n",
+       "1951    0.858540\n",
+       "1952    0.667365\n",
+       "1953    0.607232\n",
+       "1954    0.628640\n",
+       "1955    0.740425\n",
+       "1956    0.843928\n",
+       "1957    0.988701\n",
+       "1958    1.101054\n",
+       "1959    1.020766\n",
+       "1960    0.561750\n",
+       "1961    0.036871\n",
+       "1962    0.031146\n",
+       "1963    0.270201\n",
+       "1964    0.535045\n",
+       "1965    0.639908\n",
+       "1966    0.682939\n",
+       "1967    0.628856\n",
+       "1968    0.582745\n",
+       "1969    0.582126\n",
+       "1970    0.583151\n",
+       "1971    0.625807\n",
+       "1972    0.616597\n",
+       "1973    0.584666\n",
+       "1974    0.533223\n",
+       "1975    0.443692\n",
+       "1976    0.338849\n",
+       "1977    0.266959\n",
+       "1978    0.196499\n",
+       "1979    0.171246\n",
+       "          ...   \n",
+       "1987    0.359053\n",
+       "1988    0.460423\n",
+       "1989    0.546078\n",
+       "1990    0.598794\n",
+       "1991    0.690025\n",
+       "1992    0.705441\n",
+       "1993    0.727689\n",
+       "1994    0.749047\n",
+       "1995    0.742263\n",
+       "1996    0.714242\n",
+       "1997    0.690252\n",
+       "1998    0.670935\n",
+       "1999    0.651132\n",
+       "2000    0.638560\n",
+       "2001    0.627448\n",
+       "2002    0.618347\n",
+       "2003    0.619705\n",
+       "2004    0.621627\n",
+       "2005    0.630170\n",
+       "2006    0.636478\n",
+       "2007    0.647257\n",
+       "2008    0.660376\n",
+       "2009    0.680460\n",
+       "2010    0.832811\n",
+       "2011    0.885957\n",
+       "2012    0.935034\n",
+       "2013    0.977243\n",
+       "2014    1.019023\n",
+       "2015    1.382129\n",
+       "2016         NaN\n",
+       "Length: 67, dtype: float64"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "abs(census-un)/un*100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`max` and `abs` are built-in functions provided by Python, but NumPy also provides version that are a little more general.  When you import `modsim`, you get the NumPy versions of these functions."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Constant growth"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can select a value from a `Series` using bracket notation.  Here's the first element:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.557628654"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census[1950]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And the last value."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "7.325996709"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census[2016]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "But rather than \"hard code\" those dates, we can get the first and last labels from the `Series`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1950"
+      ]
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_0 = get_first_label(census)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2016"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_end = get_last_label(census)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "66"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "elapsed_time = t_end - t_0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And we can get the first and last values:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.557628654"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "p_0 = get_first_value(census)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "7.325996709"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "p_end = get_last_value(census)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then we can compute the average annual growth in billions of people per year."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4.768368055"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "total_growth = p_end - p_0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.07224800083333333"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "annual_growth = total_growth / elapsed_time"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### TimeSeries"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's create a `TimeSeries` to contain values generated by a linear growth model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "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",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "Series([], dtype: float64)"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results = TimeSeries()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Initially the `TimeSeries` is empty, but we can initialize it so the starting value, in 1950, is the 1950 population estimated by the US Census."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "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>1950</th>\n",
+       "      <td>2.557629</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "1950    2.557629\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results[t_0] = census[t_0]\n",
+    "results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After that, the population in the model grows by a constant amount each year."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for t in linrange(t_0, t_end-1):\n",
+    "    results[t+1] = results[t] + annual_growth"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`linrange` is defined in the `modsim` library.  It is similar to `linspace`, but instead of taking parameters `start`, `stop`, and `num`, it takes `start`, `stop`, and `step`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "help(linrange)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's what the results looks like, compared to the actual data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap03-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(census, ':', label='US Census', color='red')\n",
+    "plot(un, '--', label='UN DESA')\n",
+    "plot(results, color='gray', label='model')\n",
+    "\n",
+    "decorate(xlabel='Year', \n",
+    "         ylabel='World population (billion)',\n",
+    "         title='Constant growth')\n",
+    "savefig('chap03-fig02.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The model fits the data pretty well after 1990, but not so well before."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercises\n",
+    "\n",
+    "**Optional Exercise:**  Try fitting the model using data from 1970 to the present, and see if that does a better job.\n",
+    "\n",
+    "Hint: \n",
+    "\n",
+    "1. Copy the code from above and make a few changes.  Test your code after each small change.\n",
+    "\n",
+    "2. Make sure your `TimeSeries` starts in 1950, even though the estimated annual growth is based on later data.\n",
+    "\n",
+    "3. You might want to add a constant to the starting value to match the data better."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap05-figEx01.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "p_70=census[1970]\n",
+    "t_70=1970\n",
+    "elapsed_time=t_end-t_70\n",
+    "total_growth=census[t_end]-census[t_70]\n",
+    "annual_growth=total_growth/elapsed_time\n",
+    "\n",
+    "results = TimeSeries()\n",
+    "results[t_0] = census[t_0]\n",
+    "for t in linrange(t_0, t_end-1,1):\n",
+    "    results[t+1] = results[t] + annual_growth\n",
+    "\n",
+    "plot(census, ':', label='US Census', color='red')\n",
+    "plot(un, '--', label='UN DESA')\n",
+    "plot(results, color='gray', label='model')\n",
+    "\n",
+    "decorate(xlabel='Year', \n",
+    "         ylabel='World population (billion)',\n",
+    "         title='Constant growth')\n",
+    "savefig('chap05-figEx01.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The rms fit would be better if the curves matched at t=1970 instead of 1950."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap05-figEx01a.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "results[t_0]=p_70-annual_growth*(t_70-t_0)\n",
+    "for t in linrange(t_0, t_end-1,1):\n",
+    "    results[t+1] = results[t] + annual_growth\n",
+    "    \n",
+    "plot(census, ':', label='US Census', color='red')\n",
+    "plot(un, '--', label='UN DESA')\n",
+    "plot(results, color='green', label='shifted model')\n",
+    "\n",
+    "decorate(xlabel='Year', \n",
+    "         ylabel='World population (billion)',\n",
+    "         title='Constant growth')\n",
+    "savefig('chap05-figEx01a.pdf')"
+   ]
+  }
+ ],
+ "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap06mneal.ipynb b/code/chap06mneal.ipynb
new file mode 100644
index 00000000..9f48e19d
--- /dev/null
+++ b/code/chap06mneal.ipynb
@@ -0,0 +1,954 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 6\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": 1,
+   "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.py module\n",
+    "from modsim import *\n",
+    "\n",
+    "from pandas import read_html"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Code from the previous chapter\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "filename = 'data/World_population_estimates.html'\n",
+    "tables = read_html(filename, header=0, index_col=0, decimal='M')\n",
+    "table2 = tables[2]\n",
+    "table2.columns = ['census', 'prb', 'un', 'maddison', \n",
+    "                  'hyde', 'tanton', 'biraben', 'mj', \n",
+    "                  'thomlinson', 'durand', 'clark']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    2.525149\n",
+       "1951    2.572851\n",
+       "1952    2.619292\n",
+       "1953    2.665865\n",
+       "1954    2.713172\n",
+       "Name: un, dtype: float64"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "un = table2.un / 1e9\n",
+    "un.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    2.557629\n",
+       "1951    2.594940\n",
+       "1952    2.636772\n",
+       "1953    2.682053\n",
+       "1954    2.730228\n",
+       "Name: census, dtype: float64"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census = table2.census / 1e9\n",
+    "census.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.07224800083333333"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_0 = get_first_label(census)\n",
+    "t_end = get_last_label(census)\n",
+    "elapsed_time = t_end - t_0\n",
+    "\n",
+    "p_0 = get_first_value(census)\n",
+    "p_end = get_last_value(census)\n",
+    "total_growth = p_end - p_0\n",
+    "\n",
+    "annual_growth = total_growth / elapsed_time"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### System objects"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can rewrite the code from the previous chapter using system objects."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "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>t_0</th>\n",
+       "      <td>1950.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>2016.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>p_0</th>\n",
+       "      <td>2.557629</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>annual_growth</th>\n",
+       "      <td>0.072248</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "t_0              1950.000000\n",
+       "t_end            2016.000000\n",
+       "p_0                 2.557629\n",
+       "annual_growth       0.072248\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "system = System(t_0=t_0, \n",
+    "                t_end=t_end,\n",
+    "                p_0=p_0,\n",
+    "                annual_growth=annual_growth)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And we can encapsulate the code that runs the model in a function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation1(system):\n",
+    "    \"\"\"Runs the constant growth model.\n",
+    "    \n",
+    "    system: System object\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    results = TimeSeries()\n",
+    "    results[system.t_0] = system.p_0\n",
+    "    \n",
+    "    for t in linrange(system.t_0, system.t_end-1):\n",
+    "        results[t+1] = results[t] + system.annual_growth\n",
+    "    \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also encapsulate the code that plots the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_results(census, un, timeseries, title):\n",
+    "    \"\"\"Plot the estimates and the model.\n",
+    "    \n",
+    "    census: TimeSeries of population estimates\n",
+    "    un: TimeSeries of population estimates\n",
+    "    timeseries: TimeSeries of simulation results\n",
+    "    title: string\n",
+    "    \"\"\"\n",
+    "    plot(census, ':', label='US Census')\n",
+    "    plot(un, '--', label='UN DESA')\n",
+    "    plot(timeseries, color='gray', label='model')\n",
+    "    \n",
+    "    decorate(xlabel='Year', \n",
+    "             ylabel='World population (billion)',\n",
+    "             title=title)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's how we run it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "results = run_simulation1(system)\n",
+    "plot_results(census, un, results, 'Constant growth model')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Proportional growth"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's a more realistic model where the number of births and deaths is proportional to the current population."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation2(system):\n",
+    "    \"\"\"Run a model with proportional birth and death.\n",
+    "    \n",
+    "    system: System object\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    results = TimeSeries()\n",
+    "    results[system.t_0] = system.p_0\n",
+    "    \n",
+    "    for t in linrange(system.t_0, system.t_end-1):\n",
+    "        births = system.birth_rate * results[t]\n",
+    "        deaths = system.death_rate * results[t]\n",
+    "        results[t+1] = results[t] + births - deaths\n",
+    "        \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "I picked a death rate that seemed reasonable and then adjusted the birth rate to fit the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system.death_rate = 0.01\n",
+    "system.birth_rate = 0.027"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's what it looks like."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap06-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": [
+    "results = run_simulation2(system)\n",
+    "plot_results(census, un, results, 'Proportional model')\n",
+    "savefig('chap06-fig02.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The model fits the data pretty well for the first 20 years, but not so well after that."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Factoring out the update function"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`run_simulation1` and `run_simulation2` are nearly identical except the body of the loop.  So we can factor that part out into a function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_func1(pop, t, system):\n",
+    "    \"\"\"Compute the population next year.\n",
+    "    \n",
+    "    pop: current population\n",
+    "    t: current year\n",
+    "    system: system object containing parameters of the model\n",
+    "    \n",
+    "    returns: population next year\n",
+    "    \"\"\"\n",
+    "    births = system.birth_rate * pop\n",
+    "    deaths = system.death_rate * pop\n",
+    "    return pop + births - deaths"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The name `update_func` refers to a function object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.update_func1(pop, t, system)>"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "update_func1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Which we can confirm by checking its type."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "function"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type(update_func1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`run_simulation` takes the update function as a parameter and calls it just like any other function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(system, update_func):\n",
+    "    \"\"\"Simulate the system using any update function.\n",
+    "    \n",
+    "    system: System object\n",
+    "    update_func: function that computes the population next year\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    results = TimeSeries()\n",
+    "    results[system.t_0] = system.p_0\n",
+    "    \n",
+    "    for t in linrange(system.t_0, system.t_end-1):\n",
+    "        results[t+1] = update_func(results[t], t, system)\n",
+    "        \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's how we use it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "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>t_0</th>\n",
+       "      <td>1950.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>2016.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>p_0</th>\n",
+       "      <td>2.557629</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>birth_rate</th>\n",
+       "      <td>0.027000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>death_rate</th>\n",
+       "      <td>0.010000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "t_0           1950.000000\n",
+       "t_end         2016.000000\n",
+       "p_0              2.557629\n",
+       "birth_rate       0.027000\n",
+       "death_rate       0.010000\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_0 = get_first_label(census)\n",
+    "t_end = get_last_label(census)\n",
+    "p_0 = census[t_0]\n",
+    "\n",
+    "system = System(t_0=get_first_label(census), \n",
+    "                t_end=t_end,\n",
+    "                p_0=p_0,\n",
+    "                birth_rate=0.027,\n",
+    "                death_rate=0.01)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "results = run_simulation(system, update_func1)\n",
+    "plot_results(census, un, results, 'Proportional model, factored')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Remember not to put parentheses after `update_func1`.  What happens if you try?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** When you run `run_simulation`, it runs `update_func1` once for each year between `t_0` and `t_end`.  To see that for yourself, add a print statement at the beginning of `update_func1` that prints the values of `t` and `pop`, then run `run_simulation` again."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_func1(pop, t, system):\n",
+    "    \"\"\"Compute the population next year.\n",
+    "    \n",
+    "    pop: current population\n",
+    "    t: current year\n",
+    "    system: system object containing parameters of the model\n",
+    "    \n",
+    "    returns: population next year\n",
+    "    \"\"\"\n",
+    "    print (t,pop)\n",
+    "    births = system.birth_rate * pop\n",
+    "    deaths = system.death_rate * pop\n",
+    "    return pop + births - deaths"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1950.0 2.557628654\n",
+      "1951.0 2.601108341118\n",
+      "1952.0 2.645327182917006\n",
+      "1953.0 2.6902977450265952\n",
+      "1954.0 2.7360328066920476\n",
+      "1955.0 2.7825453644058125\n",
+      "1956.0 2.829848635600711\n",
+      "1957.0 2.8779560624059233\n",
+      "1958.0 2.926881315466824\n",
+      "1959.0 2.9766382978297603\n",
+      "1960.0 3.0272411488928666\n",
+      "1961.0 3.078704248424045\n",
+      "1962.0 3.131042220647254\n",
+      "1963.0 3.184269938398258\n",
+      "1964.0 3.2384025273510284\n",
+      "1965.0 3.293455370315996\n",
+      "1966.0 3.349444111611368\n",
+      "1967.0 3.406384661508761\n",
+      "1968.0 3.46429320075441\n",
+      "1969.0 3.523186185167235\n",
+      "1970.0 3.583080350315078\n",
+      "1971.0 3.6439927162704344\n",
+      "1972.0 3.7059405924470314\n",
+      "1973.0 3.768941582518631\n",
+      "1974.0 3.833013589421448\n",
+      "1975.0 3.8981748204416125\n",
+      "1976.0 3.9644437923891203\n",
+      "1977.0 4.031839336859735\n",
+      "1978.0 4.100380605586351\n",
+      "1979.0 4.170087075881319\n",
+      "1980.0 4.240978556171301\n",
+      "1981.0 4.313075191626214\n",
+      "1982.0 4.3863974698838595\n",
+      "1983.0 4.460966226871885\n",
+      "1984.0 4.536802652728707\n",
+      "1985.0 4.613928297825096\n",
+      "1986.0 4.692365078888122\n",
+      "1987.0 4.77213528522922\n",
+      "1988.0 4.8532615850781164\n",
+      "1989.0 4.935767032024445\n",
+      "1990.0 5.0196750715688605\n",
+      "1991.0 5.1050095477855315\n",
+      "1992.0 5.191794710097886\n",
+      "1993.0 5.28005522016955\n",
+      "1994.0 5.369816158912433\n",
+      "1995.0 5.461103033613944\n",
+      "1996.0 5.553941785185382\n",
+      "1997.0 5.648358795533533\n",
+      "1998.0 5.744380895057604\n",
+      "1999.0 5.8420353702735826\n",
+      "2000.0 5.941349971568234\n",
+      "2001.0 6.042352921084894\n",
+      "2002.0 6.145072920743337\n",
+      "2003.0 6.249539160395973\n",
+      "2004.0 6.355781326122704\n",
+      "2005.0 6.46382960866679\n",
+      "2006.0 6.573714712014126\n",
+      "2007.0 6.685467862118366\n",
+      "2008.0 6.799120815774378\n",
+      "2009.0 6.9147058696425425\n",
+      "2010.0 7.032255869426465\n",
+      "2011.0 7.151804219206714\n",
+      "2012.0 7.273384890933229\n",
+      "2013.0 7.397032434079093\n",
+      "2014.0 7.522781985458438\n",
+      "2015.0 7.650669279211232\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "results = run_simulation(system, update_func1)\n",
+    "plot_results(census, un, results, 'Proportional model, factored')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Combining birth and death"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since births and deaths get added up, we don't have to compute them separately.  We can combine the birth and death rates into a single net growth rate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_func2(pop, t, system):\n",
+    "    \"\"\"Compute the population next year.\n",
+    "    \n",
+    "    pop: current population\n",
+    "    t: current year\n",
+    "    system: system object containing parameters of the model\n",
+    "    \n",
+    "    returns: population next year\n",
+    "    \"\"\"\n",
+    "    net_growth = system.alpha  * pop\n",
+    "    return pop + net_growth"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's how it works:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "system.alpha = system.birth_rate - system.death_rate\n",
+    "\n",
+    "results = run_simulation(system, update_func2)\n",
+    "plot_results(census, un, results, 'Proportional model, combined birth and death')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.017 0.017 0.017\n"
+     ]
+    }
+   ],
+   "source": [
+    "system.alpha\n",
+    "system.alpha1=system.alpha\n",
+    "system.alpha2=system.alpha\n",
+    "print(system.alpha, system.alpha1,system.alpha2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercises\n",
+    "\n",
+    "**Exercise:** Maybe the reason the proportional model doesn't work very well is that the growth rate, `alpha`, is changing over time.  So let's try a model with different growth rates before and after 1980 (as an arbitrary choice).\n",
+    "\n",
+    "Write an update function that takes `pop`, `t`, and `system` as parameters.  The system object, `system`, should contain two parameters: the growth rate before 1980, `alpha1`, and the growth rate after 1980, `alpha2`.  It should use `t` to determine which growth rate to use.  Note: Don't forget the `return` statement.\n",
+    "\n",
+    "Test your function by calling it directly, then pass it to `run_simulation`.  Plot the results.  Adjust the parameters `alpha1` and `alpha2` to fit the data as well as you can.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "def update_func3(pop, t, system):\n",
+    "    \"\"\"Compute the population next year.\n",
+    "    \n",
+    "    pop: current population\n",
+    "    t: current year\n",
+    "    system: system object containing parameters of the model\n",
+    "    \n",
+    "    returns: population next year\n",
+    "    \"\"\"\n",
+    "    if t<=1980:\n",
+    "        system.alpha=system.alpha1\n",
+    "    elif t<=2000:\n",
+    "        system.alpha=system.alpha2\n",
+    "    else: \n",
+    "        system.alpha=system.alpha3\n",
+    "    net_growth = system.alpha  * pop\n",
+    "    return pop + net_growth"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.601108341118"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "update_func3(system.p_0,system.t_0,system)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#run this model several times, adjusting alpha1 alpha2, and alpha3 manually to get best fit.\n",
+    "system.alpha1=0.0185\n",
+    "system.alpha2=0.0161\n",
+    "system.alpha3=0.0115\n",
+    "results = run_simulation(system, update_func3)\n",
+    "plot_results(census, un, results, 'Proportional model, combined birth and death, rate changes in 1980 & 2000')"
+   ]
+  }
+ ],
+ "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap07mneal.ipynb b/code/chap07mneal.ipynb
new file mode 100644
index 00000000..6a47cf6f
--- /dev/null
+++ b/code/chap07mneal.ipynb
@@ -0,0 +1,854 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 7\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": 1,
+   "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.py module\n",
+    "from modsim import *\n",
+    "\n",
+    "from pandas import read_html"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Code from the previous chapter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "filename = 'data/World_population_estimates.html'\n",
+    "tables = read_html(filename, header=0, index_col=0, decimal='M')\n",
+    "table2 = tables[2]\n",
+    "table2.columns = ['census', 'prb', 'un', 'maddison', \n",
+    "                  'hyde', 'tanton', 'biraben', 'mj', \n",
+    "                  'thomlinson', 'durand', 'clark']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    2.525149\n",
+       "1951    2.572851\n",
+       "1952    2.619292\n",
+       "1953    2.665865\n",
+       "1954    2.713172\n",
+       "Name: un, dtype: float64"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "un = table2.un / 1e9\n",
+    "un.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    2.557629\n",
+       "1951    2.594940\n",
+       "1952    2.636772\n",
+       "1953    2.682053\n",
+       "1954    2.730228\n",
+       "Name: census, dtype: float64"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census = table2.census / 1e9\n",
+    "census.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_results(census, un, timeseries, title):\n",
+    "    \"\"\"Plot the estimates and the model.\n",
+    "    \n",
+    "    census: TimeSeries of population estimates\n",
+    "    un: TimeSeries of population estimates\n",
+    "    timeseries: TimeSeries of simulation results\n",
+    "    title: string\n",
+    "    \"\"\"\n",
+    "    plot(census, ':', label='US Census')\n",
+    "    plot(un, '--', label='UN DESA')\n",
+    "    plot(timeseries, color='gray', label='model')\n",
+    "    \n",
+    "    decorate(xlabel='Year', \n",
+    "             ylabel='World population (billion)',\n",
+    "             title=title)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(system, update_func):\n",
+    "    \"\"\"Simulate the system using any update function.\n",
+    "    \n",
+    "    system: System object\n",
+    "    update_func: function that computes the population next year\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    results = TimeSeries()\n",
+    "    results[system.t_0] = system.p_0\n",
+    "    \n",
+    "    for t in linrange(system.t_0, system.t_end-1):\n",
+    "        results[t+1] = update_func(results[t], t, system)\n",
+    "        \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Quadratic growth"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's the implementation of the quadratic growth model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_func_quad(pop, t, system):\n",
+    "    \"\"\"Compute the population next year with a quadratic model.\n",
+    "    \n",
+    "    pop: current population\n",
+    "    t: current year\n",
+    "    system: system object containing parameters of the model\n",
+    "    \n",
+    "    returns: population next year\n",
+    "    \"\"\"\n",
+    "    net_growth = system.alpha * pop + system.beta * pop**2\n",
+    "    return pop + net_growth"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's a `System` object with the parameters `alpha` and `beta`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "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>t_0</th>\n",
+       "      <td>1950.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>2016.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>p_0</th>\n",
+       "      <td>2.557629</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>alpha</th>\n",
+       "      <td>0.025000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>beta</th>\n",
+       "      <td>-0.001800</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "t_0      1950.000000\n",
+       "t_end    2016.000000\n",
+       "p_0         2.557629\n",
+       "alpha       0.025000\n",
+       "beta       -0.001800\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_0 = get_first_label(census)\n",
+    "t_end = get_last_label(census)\n",
+    "p_0 = census[t_0]\n",
+    "\n",
+    "system = System(t_0=t_0, \n",
+    "                t_end=t_end,\n",
+    "                p_0=p_0,\n",
+    "                alpha=0.025,\n",
+    "                beta=-0.0018)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And here are the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap07-fig01.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "results = run_simulation(system, update_func_quad)\n",
+    "\n",
+    "plot_results(census, un, results, 'Quadratic model')\n",
+    "savefig('chap07-fig01.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:**  Can you find values for the parameters that make the model fit better?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap07-fig01a.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "system.alpha=0.0241\n",
+    "system.beta=-.00163\n",
+    "\n",
+    "results = run_simulation(system, update_func_quad)\n",
+    "\n",
+    "plot_results(census, un, results, 'Quadratic model')\n",
+    "savefig('chap07-fig01a.pdf')\n",
+    "#not any better"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Equilibrium\n",
+    "\n",
+    "To understand the quadratic model better, let's plot net growth as a function of population."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pop_array = linspace(0, 15, 100)\n",
+    "net_growth_array = system.alpha * pop_array + system.beta * pop_array**2\n",
+    "None"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's what it looks like."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap03-fig05.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.set_style('whitegrid')\n",
+    "\n",
+    "plot(pop_array, net_growth_array)\n",
+    "decorate(xlabel='Population (billions)',\n",
+    "         ylabel='Net growth (billions)')\n",
+    "savefig('chap03-fig05.pdf')\n",
+    "\n",
+    "sns.set_style('white')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's what it looks like.  Remember that the x axis is population now, not time."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It looks like the growth rate passes through 0 when the population is a little less than 14 billion.\n",
+    "\n",
+    "In the book we found that the net growth is 0 when the population is $-\\alpha/\\beta$:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "-system.alpha / system.beta"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is the equilibrium the population tends toward."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`sns` is a library called Seaborn which provides functions that control the appearance of plots.  In this case I want a grid to make it easier to estimate the population where the growth rate crosses through 0."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Disfunctions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When people first learn about functions, there are a few things they often find confusing.  In this section I present and explain some common problems with functions.\n",
+    "\n",
+    "As an example, suppose you want a function that takes a `System` object, with variables `alpha` and `beta`, as a parameter and computes the carrying capacity, `-alpha/beta`.  Here's a good solution:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "13.88888888888889\n"
+     ]
+    }
+   ],
+   "source": [
+    "def carrying_capacity(system):\n",
+    "    K = -system.alpha / system.beta\n",
+    "    return K\n",
+    "    \n",
+    "sys1 = System(alpha=0.025, beta=-0.0018)\n",
+    "pop = carrying_capacity(sys1)\n",
+    "print(pop)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's see all the ways that can go wrong.\n",
+    "\n",
+    "**Disfunction #1:** Not using parameters.  In the following version, the function doesn't take any parameters; when `sys1` appears inside the function, it refers to the object we created outside the function.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "13.88888888888889\n"
+     ]
+    }
+   ],
+   "source": [
+    "def carrying_capacity():\n",
+    "    K = -sys1.alpha / sys1.beta\n",
+    "    return K\n",
+    "    \n",
+    "sys1 = System(alpha=0.025, beta=-0.0018)\n",
+    "pop = carrying_capacity()\n",
+    "print(pop)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This version actually works, but it is not as versatile as it could be.  If there are several `System` objects, this function can only work with one of them, and only if it is named `system`.\n",
+    "\n",
+    "**Disfunction #2:** Clobbering the parameters.  When people first learn about parameters, they often write functions like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "13.88888888888889\n"
+     ]
+    }
+   ],
+   "source": [
+    "def carrying_capacity(system):\n",
+    "    system = System(alpha=0.025, beta=-0.0018)\n",
+    "    K = -system.alpha / system.beta\n",
+    "    return K\n",
+    "    \n",
+    "sys1 = System(alpha=0.025, beta=-0.0018)\n",
+    "pop = carrying_capacity(sys1)\n",
+    "print(pop)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this example, we have a `System` object named `sys1` that gets passed as an argument to `carrying_capacity`.  But when the function runs, it ignores the argument and immediately replaces it with a new `System` object.  As a result, this function always returns the same value, no matter what argument is passed.\n",
+    "\n",
+    "When you write a function, you generally don't know what the values of the parameters will be.  Your job is to write a function that works for any valid values.  If you assign your own values to the parameters, you defeat the whole purpose of functions.\n",
+    "\n",
+    "\n",
+    "**Disfunction #3:** No return value.  Here's a version that computes the value of `K` but doesn't return it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "None\n"
+     ]
+    }
+   ],
+   "source": [
+    "def carrying_capacity(system):\n",
+    "    K = -system.alpha / system.beta\n",
+    "    \n",
+    "sys1 = System(alpha=0.025, beta=-0.0018)\n",
+    "pop = carrying_capacity(sys1)\n",
+    "print(pop)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A function that doesn't have a return statement always returns a special value called `None`, so in this example the value of `pop` is `None`.  If you are debugging a program and find that the value of a variable is `None` when it shouldn't be, a function without a return statement is a likely cause.\n",
+    "\n",
+    "**Disfunction #4:** Ignoring the return value.  Finally, here's a version where the function is correct, but the way it's used is not."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "13.88888888888889"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def carrying_capacity(system):\n",
+    "    K = -system.alpha / system.beta\n",
+    "    return K\n",
+    "    \n",
+    "sys2 = System(alpha=0.025, beta=-0.0018)\n",
+    "carrying_capacity(sys2)\n",
+    "\n",
+    "# print(K)     This line won't work because K only exists inside the function."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this example, `carrying_capacity` runs and returns `K`, but the return value is dropped.\n",
+    "\n",
+    "When you call a function that returns a value, you should do something with the result.  Often you assign it to a variable, as in the previous examples, but you can also use it as part of an expression.\n",
+    "\n",
+    "For example, you could eliminate the temporary variable `pop` like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "13.88888888888889\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(carrying_capacity(sys1))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Or if you had more than one system, you could compute the total carrying capacity like this:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "27.77777777777778"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "total = carrying_capacity(sys1) + carrying_capacity(sys2)\n",
+    "total"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercises\n",
+    "\n",
+    "**Exercise:** In the book, I present a different way to parameterize the quadratic model:\n",
+    "\n",
+    "$ \\Delta p = r p (1 - p / K) $\n",
+    "\n",
+    "where $r=\\alpha$ and $K=-\\alpha/\\beta$.  Write a version of `update_func` that implements this version of the model.  Test it by computing system variables `r` and `K` equivalent to `alpha` and `beta`, and confirm that you get the same results. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_func_quad2(pop, t, system):\n",
+    "    \"\"\"Compute the population next year with a quadratic model.\n",
+    "    \n",
+    "    pop: current population\n",
+    "    t: current year\n",
+    "    system: system object containing parameters of the model\n",
+    "    \n",
+    "    returns: population next year\n",
+    "    \"\"\"\n",
+    "    net_growth = system.r * pop *(1-pop/system.K)\n",
+    "    return pop + net_growth"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "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>t_0</th>\n",
+       "      <td>1950.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>2016.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>p_0</th>\n",
+       "      <td>2.557629</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>r</th>\n",
+       "      <td>0.025000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>K</th>\n",
+       "      <td>13.888889</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "t_0      1950.000000\n",
+       "t_end    2016.000000\n",
+       "p_0         2.557629\n",
+       "r           0.025000\n",
+       "K          13.888889\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 62,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_0 = get_first_label(census)\n",
+    "t_end = get_last_label(census)\n",
+    "p_0 = census[t_0]\n",
+    "\n",
+    "system = System(t_0=t_0, \n",
+    "                t_end=t_end,\n",
+    "                p_0=p_0,\n",
+    "                r=0.025,\n",
+    "                K=13.8888889)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap07-figEx01.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "results = run_simulation(system, update_func_quad2)\n",
+    "\n",
+    "plot_results(census, un, results, 'Quadratic model')\n",
+    "savefig('chap07-figEx01.pdf')"
+   ]
+  },
+  {
+   "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap08mneal.ipynb b/code/chap08mneal.ipynb
new file mode 100644
index 00000000..438fdc9c
--- /dev/null
+++ b/code/chap08mneal.ipynb
@@ -0,0 +1,1178 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 8\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": 6,
+   "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.py module\n",
+    "from modsim import *\n",
+    "\n",
+    "from pandas import read_html"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Functions from the previous chapter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_results(census, un, timeseries, title):\n",
+    "    \"\"\"Plot the estimates and the model.\n",
+    "    \n",
+    "    census: TimeSeries of population estimates\n",
+    "    un: TimeSeries of population estimates\n",
+    "    timeseries: TimeSeries of simulation results\n",
+    "    title: string\n",
+    "    \"\"\"\n",
+    "    plot(census, ':', label='US Census')\n",
+    "    plot(un, '--', label='UN DESA')\n",
+    "    plot(timeseries, color='gray', label='model')\n",
+    "    \n",
+    "    decorate(xlabel='Year', \n",
+    "             ylabel='World population (billion)',\n",
+    "             title=title)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(system, update_func):\n",
+    "    \"\"\"Simulate the system using any update function.\n",
+    "    \n",
+    "    system: System object\n",
+    "    update_func: function that computes the population next year\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    results = TimeSeries()\n",
+    "    results[system.t_0] = system.p_0\n",
+    "    \n",
+    "    for t in linrange(system.t_0, system.t_end-1):\n",
+    "        results[t+1] = update_func(results[t], t, system)\n",
+    "        \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Reading the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "filename = 'data/World_population_estimates.html'\n",
+    "tables = read_html(filename, header=0, index_col=0, decimal='M')\n",
+    "table2 = tables[2]\n",
+    "table2.columns = ['census', 'prb', 'un', 'maddison', \n",
+    "                  'hyde', 'tanton', 'biraben', 'mj', \n",
+    "                  'thomlinson', 'durand', 'clark']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "un = table2.un / 1e9\n",
+    "census = table2.census / 1e9\n",
+    "plot(census, ':', label='US Census')\n",
+    "plot(un, '--', label='UN DESA')\n",
+    "    \n",
+    "decorate(xlabel='Year', \n",
+    "             ylabel='World population (billion)',\n",
+    "             title='Estimated world population')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Running the quadratic model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's the update function for the quadratic growth model with parameters `alpha` and `beta`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_func_quad(pop, t, system):\n",
+    "    \"\"\"Update population based on a quadratic model.\n",
+    "    \n",
+    "    pop: current population in billions\n",
+    "    t: what year it is\n",
+    "    system: system object with model parameters\n",
+    "    \"\"\"\n",
+    "    net_growth = system.alpha * pop + system.beta * pop**2\n",
+    "    return pop + net_growth"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Extract the starting time and population."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.557628654"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_0 = get_first_label(census)\n",
+    "t_end = get_last_label(census)\n",
+    "p_0 = get_first_value(census)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Initialize the system object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "scrolled": true
+   },
+   "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>t_0</th>\n",
+       "      <td>1950.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>2016.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>p_0</th>\n",
+       "      <td>2.557629</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>alpha</th>\n",
+       "      <td>0.025000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>beta</th>\n",
+       "      <td>-0.001800</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "t_0      1950.000000\n",
+       "t_end    2016.000000\n",
+       "p_0         2.557629\n",
+       "alpha       0.025000\n",
+       "beta       -0.001800\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "system = System(t_0=t_0, \n",
+    "                t_end=t_end,\n",
+    "                p_0=p_0,\n",
+    "                alpha=0.025,\n",
+    "                beta=-0.0018)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Run the model and plot results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "results = run_simulation(system, update_func_quad)\n",
+    "plot_results(census, un, results, 'Quadratic model')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Generating projections"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To generate projections, all we have to do is change `t_end`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap08-fig03.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "system.t_end = 2250\n",
+    "results = run_simulation(system, update_func_quad)\n",
+    "plot_results(census, un, results, 'World population projection')\n",
+    "savefig('chap08-fig03.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The population in the model converges on the equilibrium population, `-alpha/beta`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "13.856665141368708"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results[system.t_end]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "13.88888888888889"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "-system.alpha / system.beta"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:**  What happens if we start with an initial population above the carrying capacity, like 20 billion?  Run the model with initial populations between 1 and 20 billion, and plot the results on the same axes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_6_results(census, un, timeseries1,timeseries2,timeseries3,timeseries4,timeseries5,timeseries6, title):\n",
+    "    \"\"\"Plot the estimates and the 6 models.\n",
+    "    \n",
+    "    This is very clumsy, but I spent way too much time trying to get an array based function to work.\n",
+    "    census: TimeSeries of population estimates\n",
+    "    un: TimeSeries of population estimates\n",
+    "    timeseries: TimeSeries of simulation results\n",
+    "    title: string\n",
+    "    \"\"\"\n",
+    "    plot(census, ':', label='US Census')\n",
+    "    plot(un, '--', label='UN DESA')\n",
+    "    plot(timeseries1, color='gray', label='model (1 b)')\n",
+    "    plot(timeseries2, color='black', label='model (5 b)')\n",
+    "    plot(timeseries3, color='red', label='model (9 b)')\n",
+    "    plot(timeseries4, color='blue', label='model (13 b)')\n",
+    "    plot(timeseries5, color='green', label='model (17 b)')\n",
+    "    plot(timeseries6, color='yellow', label='model (20 b)')\n",
+    "    \n",
+    "    decorate(xlabel='Year', \n",
+    "             ylabel='World population (billion)',\n",
+    "             title=title)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap08-figEx01b.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "system.t_end = 2250\n",
+    "\n",
+    "system.p_0=1\n",
+    "results1=TimeSeries()\n",
+    "results1 = run_simulation(system, update_func_quad)\n",
+    "system.p_0=5\n",
+    "results2=TimeSeries()\n",
+    "results2 = run_simulation(system, update_func_quad)\n",
+    "system.p_0=9\n",
+    "results3=TimeSeries()\n",
+    "results3 = run_simulation(system, update_func_quad)\n",
+    "system.p_0=13\n",
+    "results4=TimeSeries()\n",
+    "results4 = run_simulation(system, update_func_quad)\n",
+    "system.p_0=17\n",
+    "results5=TimeSeries()\n",
+    "results5 = run_simulation(system, update_func_quad)\n",
+    "system.p_0=20\n",
+    "results6=TimeSeries()\n",
+    "results6 = run_simulation(system, update_func_quad)\n",
+    "\n",
+    "plot_6_results(census, un, results1,results2,results3,results4,results5,results6, 'World population projection')\n",
+    "savefig('chap08-figEx01b.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Comparing projections"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can compare the projection from our model with projections produced by people who know what they are doing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "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>United States Census Bureau (2015)[28]</th>\n",
+       "      <th>Population Reference Bureau (1973-2015)[15]</th>\n",
+       "      <th>United Nations Department of Economic and Social Affairs (2015)[16]</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Year</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2016</th>\n",
+       "      <td>7.334772e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>7.432663e+09</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2017</th>\n",
+       "      <td>7.412779e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2018</th>\n",
+       "      <td>7.490428e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2019</th>\n",
+       "      <td>7.567403e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2020</th>\n",
+       "      <td>7.643402e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>7.758157e+09</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      United States Census Bureau (2015)[28]  \\\n",
+       "Year                                           \n",
+       "2016                            7.334772e+09   \n",
+       "2017                            7.412779e+09   \n",
+       "2018                            7.490428e+09   \n",
+       "2019                            7.567403e+09   \n",
+       "2020                            7.643402e+09   \n",
+       "\n",
+       "      Population Reference Bureau (1973-2015)[15]  \\\n",
+       "Year                                                \n",
+       "2016                                          NaN   \n",
+       "2017                                          NaN   \n",
+       "2018                                          NaN   \n",
+       "2019                                          NaN   \n",
+       "2020                                          NaN   \n",
+       "\n",
+       "      United Nations Department of Economic and Social Affairs (2015)[16]  \n",
+       "Year                                                                       \n",
+       "2016                                       7.432663e+09                    \n",
+       "2017                                                NaN                    \n",
+       "2018                                                NaN                    \n",
+       "2019                                                NaN                    \n",
+       "2020                                       7.758157e+09                    "
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "table3 = tables[3]\n",
+    "table3.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`NaN` is a special value that represents missing data, in this case because some agencies did not publish projections for some years."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "table3.columns = ['census', 'prb', 'un']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This function plots projections from the UN DESA and U.S. Census.  It uses `dropna` to remove the `NaN` values from each series before plotting it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_projections(table):\n",
+    "    \"\"\"Plot world population projections.\n",
+    "    \n",
+    "    table: DataFrame with columns 'un' and 'census'\n",
+    "    \"\"\"\n",
+    "    census_proj = table.census / 1e9\n",
+    "    un_proj = table.un / 1e9\n",
+    "    \n",
+    "    plot(census_proj.dropna(), 'b:', label='US Census')\n",
+    "    plot(un_proj.dropna(), 'g--', label='UN DESA')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Run the model until 2100, which is as far as the other projections go."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "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>t_0</th>\n",
+       "      <td>1950.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>2100.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>p_0</th>\n",
+       "      <td>2.557629</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>alpha</th>\n",
+       "      <td>0.025000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>beta</th>\n",
+       "      <td>-0.001800</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "t_0      1950.000000\n",
+       "t_end    2100.000000\n",
+       "p_0         2.557629\n",
+       "alpha       0.025000\n",
+       "beta       -0.001800\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "system = System(t_0=t_0, \n",
+    "                t_end=2100,\n",
+    "                p_0=p_0,\n",
+    "                alpha=0.025,\n",
+    "                beta=-0.0018)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap04-fig02.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xl8VNXd+PHPTCb7vm+EBJJwgEDYFAFZFEVQKShqtbU+2sfa2p8+1dZWrdZa19qKba2VurWPrUtrHwVrhVoXUBQRZd9PSEISQshO9n3m/v64k5AhCRlIJhvf9+uVF5m7fucC851z7veeYzEMAyGEEGKosQ52AEIIIUR3JEEJIYQYkiRBCSGEGJIkQQkhhBiSJEEJIYQYkiRBCSGEGJIkQYnTopRaq5Rac9KyMUopQym16aTlEUoph1LqsjM818dKqZWnWP+mUurlMzm2pymlLnBekyA3t09RSi3v9DpPKXW75yLsX739XZ3GcSxKqVuUUn7O1zcppcr7HqEYjiRBidP1MXDeScsuBgqBmUqpkE7L5wB24NOBCW1Y+19gXqfX5wJ/HqRYzsQK4KF+OM584AXA5nz9BjCxH44rhiFJUOJ0fQzEK6VGd1p2EeYH7HHggk7L5wBbtda1Axbd8GXp/EJrXaa1bhisYE6X1rqyn/6eT74OjVrr0n44rhiGbL1vIoSL7UANZiuqQCllARYCzwEKszX1jnPbOcD69h2VUpcAjwCTgHLgD8BKrbWhlPqF85hWYBbwg5NPrJS6AXgQiAdeB3x6ClIpdRNwJ+Y38J9gtuReBH6mtXY4tzkH+DVma6UO+KtzfatS6gLgbecxfgn4A/8A7tBaNzrXbwCCtdZ1zuP9AliqtT6nm3jSgacwWwj+wCHgPq31O85uygXAAqXU1VrrFKVUnvPa/MF5jf8HuB0YDRx07rvOeeyXgQbnca8GKoCXtNaP9nBtXgaagSDgSqAIeEBr/bdO621AuvPn65it4PuA/3Je/63AXVrrLc59Psb8MvJj5+v/An4GjHLG+4DWem2nGL4P/NC5fi/wI8xW+AbnJrVKqW87f1+ptY7qdB1XOq+jA1gN/EhrXauUSgEOA9dg/jtLAr4CbtVaa+f+DwDfBaKBA87r+O/urpMYfNKCEqdFa20HNmEmEYBMzA+6zZjJaBGAUsqG+cG/3vl6PrAO+BcwDfPD7gHg/3U6/BJgo/PY6zqfVyl1IWaX12+A6ZgJ5Wu9hDsBWIqZQL+N+cH0gPN444BPgP3OOG8BbgAe77R/EGZyuwpYhpl8V/Vyzi6cCeZfQK3zvU0F9gD/q5TyAe7AvH5/dMZysvswu89+jnm93wbeUUpN6bTNdzA/4M8BXgIeUUrNOEVYN2F+0ZiO+UXhVWfSbXe9M56FwOfObf4buA3z728f8IFSKr6b97sY+L0z3snA88CbSqnZzvXfxkzWTzjfzwZgrfP6XOU8TCrml4vOx40APgNaMbtDVwBz6doV+gvge8CFmMl0pXP/KzG/cHwLGO885/+d1C0thhBpQYkz8THmBzaY3Xufaa2blVLrgeeUUolAAuCF+eEGZovovU7f6rOUUqMwP3yfdS5rBH7ZqYXT+Zy3Am9rrVc51/0IM6Gdig24XmudB+xUSj0K3KuUehgzWeUC/6O1NoCDSqkfAq84W0I4479Va/15p3P+Qyl1hxvXqDN/zKTxZ611pfNYK4HrgFit9RGlVAvQoLUu67yjM7ndCTymtf67c/EvlFLnAXdjJhKAHK31A87fH3W+lxnAth5iygduc17rg87k9H3Mv1sArbV+2RlDGGaCv65Tq+37mMnhduD+k459H/Bkp3hznMnyLswW3v8Dntda/9l5rHud24UDlc7fS50t1c7H/Sbml+obtNaNzn1vAr5wfuFoaX//WuuNzvWrgPbjp2C2HPO11nnOfwcbMROeGIKkBSXOxCfAdGcr6SLgIwCt9SHgCOYH1xzgi/YPEiADs5XQ2WdAgvMDEOBwe3LqxiTM7kWc5zIwu29O5YgzObX7EogFopzxfOE8Tud4vDG7tcDsFtx80v7emF2ZbnPeS/ojcJVS6nml1AZOdH169bJ7jDPe7q5dRqfXh05aX+uMtSefn3Stv8S8xu1yOv2unHF2xODc9/OTYmiXATyglKpr/wFu5MR1m0invzuttaG1vkdrnX2KeNuPu7PTvymcx2nBtZAiq9PvNZy4Dq8CpUCuUuor4B5g/0nHE0OIJChxJrYBbZjdQ/PpdJ/J+fv5wOyTlnf3IdB+Q9x6im26275dS7dbndB20uv289jdjMfh/Olu/+6mAei2R0IpFQhswWy15WN2OS3rbttu9HRNLLj+/+3uWpx8vTrr7trYezivuzG0swE/xezKbP/JwOxubY/1TKZRONNrYQGz8ASzVbkEM7neBOxWSk1CDEmSoMRp01q3Yd6H+jbmB932TqvXA1Mw77V0TlAHMJNWZ3Mwv9Eed+O0u+la3j69l31GK6WiOr2eidmqqnTGM8vZhdY5nlZOtB68cW1VzASaAM2JD8HQTuvH9hDHBZitsnla68edxQKxznXt5+/2A1trXYNZxNDdtTvYw/nccfK1mwns6mHbbMzr0hGD87rN6iGGA0Cy1jq7/Qez0OIbzvVZJ59fKbVPKXUVp05cB4ApSin/TsvOwfx76vVaKKVWAN/TWr+vtb4Ds0VXC5zRc3rC8+QelDhTn2BWaX3gLJxo9xFmd5aB2Wpo9ySwVSn1M8yb39Mxv2W3V/H1dr6ngU+d94Hexawmm4KZuHriDbyslLoH86b7/ZwogngW877YM0qpPwBjMG/c/0VrXd0pnhed91tCnOtf0lrXK6X2YX6jf0Qp9QjmDfnL6drVBmZVnQ9wrbPabTrwO+c6X+efdUCaUipRa330pP2fAB5WShVitl6vBRbjWtJ/uqY578n9FbNlcylmy7cLrXWDUuoZ4LdKqQbMe3e3YybkF7vZ5dfA35RSB4EPMAstHsIsQgH4LfCSUmon8AVmgUcs5v2g9scXZiilTr5/9hpmkUv7fcJwzKKVD7XW+51VfKfiBTyplCrBrEKcBcQ5fxdDkLSgxJn6GAjEtZWE88O1ELNworXT8p2YVVfXYJYVP45ZCty5aq5HWusvnPvegvlNfyLwt152q8C8t/I5ZtJ8ErMKEK11EWZXz3Tn8V7C/LC+7aRj/B34D/Am8BZmOXR7y+a/MZPEfuAKenhQ1Rn7/ZiJZj9mdduPMVuO7ZV2f8RMELuUUif/v/wD5of+rzGr/5ZjlrP35QHo9zFbdbuc7+NKrfWXp9j+p5hfLP4Xs8U8GbjQed/RhdZ6DWZZ/I8w3+9PgP/XXjTh/PNnwGPO9zMfuNTZBbcH8wvI+5hdop2P24D5dxaCee9pNea9uBXuvGGt9f9hPqbwJGYr7lHgdq31+lPuKAaNRWbUFSORs7qr4/mZM9j/Ak56zmmkcD7nFKS1vrofj/kZsFFrfV9/HVMI6eITQpwx5/2gycA4zIenheg30sUnhOiLGZgtzSxOerBWiL6SLj4hhBBD0rDq4lNK+WIOBXMM12c2hBBCDE9emENSfaW1bu68YlglKMzkJFM3CCHEyDMPsyqzw3BLUMcAXnvtNeLi4gY7FiGEEH1UXFzM9ddfD87P986GW4KyA8TFxTFq1KjBjkUIIUT/6XLbRqr4hBBCDEmSoIQQQgxJkqCEEEIMSZKghBBCDEmSoIQQQgxJkqCEEEKctra2Nmpra7HbPTdmwnArMxdCCDEIDMPg+PHjlJWVUV5ezvHjxzEMg/DwcM4//3wsllNN4HxmJEEJIYToVkNDA2VlZR0/bW1tXbaprq722PklQQkhhADMbrvy8vKOhFRfX3/K7UNCQlBKeaT1BJKgBoRSis2bNxMREdGx7L333uO1117jlVdeAWD16tW8+uqrtLW1YbfbmTp1Kvfeey/BwcHdHnPNmjX8/e9/p6mpidbWVmbMmMFPfvITQkJCBuQ9CSFGhvr6ekpKSigpKaGyshKHw9Hjtv7+/kRHRxMdHU1kZCS+vr4ejU0S1BCwe/dunn32Wd566y3CwsKw2+089NBD/OIXv+Cpp57qsv1zzz3Hxo0befbZZ4mKiqK1tZXHH3+cW2+9lddflznjhBA9czgcVFZWUlJSQmlpKXV1PU8Y7eXlRWRkJDExMURHRxMYGOix1lJ3RnSC+nJfMV/uLwZg5sQ4Zma4DjD72a6j7MwqA+D8zASmqRiX9Ru2HWFfbgUAF85IImNspMv647VNhAf79TnOsrIyDMOgqakJMP9R3HHHHRw6dKjLtg0NDTz//POsWbOGqChzNnNvb2/uvvtuPvjgA1paWvDx8eGPf/wj77//Pg6Hg8TERB588EFiY2O54YYbmDp1Ktu3b+fYsWPMnj2bRx55BIfDwSOPPML27dvx9vZm1KhR/PKXv+T48eN87WtfY8eOHQAUFhZ2vC4rK+Oee+7h+PHjACxYsIA777yzz9dDCNG/WltbO1pJpaWl3d5LahcaGtrRSoqIiMBqHbxi7xGdoIaL+fPns27dOhYuXIhSimnTpjF//nwWLFjQZdvc3Fz8/PxISUlxWe7v78+yZcsAePvtt8nKyuL//u//sNlsvPHGG/zsZz/jxRdfBKCgoIBXXnmFhoYGLr30Ur788ktsNhtffvkl69atw2Kx8OSTT6K1JiYm5uQQOvzjH/9g1KhR/PnPf6ahoYH777+f2traHrslhRADp7m5meLiYoqLizu+BHfHy8uL6OhoYmJiiImJwd/ff4Aj7ZkkqAHQXZPY4XB0fDPx9vbmqaee4u6772bLli189dVX3HPPPcyePZvf/e53LvtZrdZT9hEDbNiwgT179nDVVVd1nKuxsbFj/YUXXojVaiUoKIjk5GSqq6uZPXs2Xl5eXHPNNcydO5fFixeTmZlJYWFhj+eZN28e3/3udzl27Bhz5szhrrvukuQkxCBqaGjoSEqVlZU9JiV/f39iY2OJjY0lMjISLy+vAY7UPSM6Qc3M6Nqt19ncKYnMnZLY4/oLZyRx4YykHte7270XHh5OVVWVS5FERUUFYWFhALz55puEh4dz0UUXsWzZMpYtW8b3v/99Fi5cSGVlpct+aWlptLW1kZeX59KKam5u5vbbb+fRRx/F4XDwne98h29+85sAtLS0uJSC+vmdiNtisWAYBiEhIfzzn/9k+/btfPHFF9x5553cfPPNXHDBBS7/yFtbWzt+z8zM5KOPPmLz5s188cUXXHPNNbz44otMmjTJresihOi7hoYGioqKOHbsGFVVVT1uFxYWRlxcHHFxcQQFBQ3ovaQzJSNJDID58+fzyiuvdLR8qqurWbNmTUcXntVqZeXKlRQXF3fsc+jQIRISEggNDXU5lo+PD7fccgv3338/5eXlgJmAHn/8cRobG4mNjWXu3Lm8+eabHTc/n376ae6+++5TxrhhwwZuuukmpk2bxv/8z/9wxRVXsHfvXkJCQmhtbSU7OxuAtWvXduyzcuVKVq1axcUXX8z9999PWlpat/fNhBD9q6mpidzcXD777DM++ugjDhw40CU5WSwWIiMjycjI4KKLLmLevHmkp6cTHBw8LJITDGALSillAV4G9mitVyql/IFngZmABdgC3Ka1buz5KMPT/fffzxNPPMHSpUs7mtLLly/nyiuvBGDFihU0NjZyyy230NLSgsViISUlhT/96U/dNr1vvfVW/P39ufnmmwGz9TRz5kxWrVoFwDXXXENJSQlf//rXsVgsxMfH88QTT5wyxvnz57Nx40aWLl1KQEAAoaGhPPLIIwQHB/OTn/yEW265hYiICJYsWdKxz4033si9997L0qVL8fHxQSnF5Zdf3i/XTAjhqqWlhWPHjnH06NEeu++sVitRUVEdLSVPl4F7mqWnPsr+pJSagJmMzgMedCaoR4HRwE2YCepV4JDW+uenOE4KcPijjz6SGXWFECNeW1sbxcXFHD16tMdCB4vFQkxMDAkJCcTGxuLt7T0IkZ65wsJCLrroIoAxWuu8zusGqgV1G/ASUNBp2UYgT2vtAFBK7QAyBigeIYQYkgzDoLKykiNHjnDs2LFuS8Lbu+8SEhKIj4/Hx8dnECL1vAFJUFrr2wGUUpd0WvZ+++9KqWTgTuC7AxGPEEIMNfX19RQWFlJYWEhDQ0O324SHh5OYmEh8fLxLsdNINehVfEqpGcAa4A9a63cHOx4hhBgora2tFBUVUVhYSGVlZbfbBAUFMWrUKBITEwkICBjgCAfXoCYopdR1wCrgdq21jNEjhBjxDMOgqqqK/Px8ioqKup1Pydvbm8TERJKSkggNDR02VXf9bdASlFLqa8DvgUu01lsHKw4hhBgIra2tFBYWkp+fT21tbZf17cUOSUlJxMbGDuoQQ0PFYLagVmJW772klGpftklrfdvghSSEEP2nfZK//Px8jh071m1rKSQkhKSkJBITE4d9WXh/G9AEpbW+qdPv6hSbCiHEsNXa2sqRI0coKCjotrXk5eVFYmIiycnJZ3UXXm8GvUhCCCFGitraWvLy8igsLOy2PDw0NJTk5GQSExOx2eTjtzdyhQZAbxMWrl69ml/84he8+eabjBs3rmOb733veyxevJgVK1a4HG/16tU89thjHQ8rt0+pcfvtt3eMg3fvvfeyadMml3MCXHXVVfzXf/0XdXV1PPHEE+zatQuLxYLVauX666/nmmuucdn+iSee4NVXX+XDDz8kLq7ncQ2FOFsZhkFJSQmHDx/uGH6sM5vNRmJiIqNHj+4Yf1O4RxLUEGEYBnfddRdvvvmmW/3Q55xzDs8//3zH688//5zvfOc7vPXWWyQmmgPg3nTTTR3DIZ3sqaeeIiAggHfeeQeLxUJJSQnXXnst8fHxzJ07FzCHUHr77bdZvHgxr776Kj/+8Y/74Z0KMTK0tLRw5MgR8vLyun1uKTg4mDFjxkhrqQ9G9FXbenQ324v2uLXt+Og05qec57JsY94WDpZl97jP9ITJnJOY2acY282ePZvW1lZ+9atf8fOf9zjaU4/mzJnDokWL+Nvf/uZWIikrKyMyMpLW1lZ8fHyIjY3lmWeecfmGt3btWkaPHt2R6G677bYhNVeMEIOhtraWw4cPU1hY2KXowWKxEBcXx5gxY4iIiJB7S300ohPUcGKxWPjVr37F8uXLmTdvHhdeeOFpH2P8+PF88sknHa9ffvll3nnnHZdtfv3rX6OU4vbbb+eOO+5g1qxZTJs2jenTp3PZZZeRlHRiepHXX3+dK664gsmTJxMdHc2aNWs6pvAQ4mzSPvxQTk4OJSUlXdb7+PgwevRoUlJS5EtcP5IENQB6m7CwXUxMDI899hj33Xdfl8Tirs7Dn5yqi2/8+PG899577Nu3j6+++opNmzbx3HPP8fTTT7Nw4UL27dvHwYMHO0Ynv+KKK/jrX//KN77xDflWKM4ahmFw7NgxcnJyup1rKTQ0lDFjxpCQkDBkJ/0bzkZ0gjonMbNPXXDzU87r0u13JnqbsLCzhQsXsmTJEu65557T7rfeu3evS5FFT9ra2nj44Yf50Y9+xKRJk5g0aRLf/va3WbVqFW+88QYLFy7ktddew2azdczK29bWRmlpKRs3bux2KnohRpK2tjaOHDlCbm5ul/tLFouF2NhYxo4dK914HiaPKg+A3iYsPNm9995LaWkpmzdvdvscn3zyCR9//DHXXnttr9vabDYOHz7MqlWrOmbIbWtrIycnh4kTJ1JTU8O6det47rnnWL9+PevXr2fjxo0sW7aMv/zlL27HJMRw09zczMGDB/nwww/Zu3evS3KyWq0kJydzwQUXcO655xIZGSnJycNGdAtqqOhtwsKT+fr68tRTT3Up+e5s69atLF++HDgxRMqf/vQnoqOjO7bp7h7UlClTePjhh3n66ad58sknWbx4Mf7+/jgcDhYtWsRtt93Ga6+9RmpqKrNmzXLZ9/vf/z6XX345WVlZbrXUhBgumpqayMnJIT8/v0vhg4+PDykpKaSkpJwVIz00tDZQ0VBBZWMl5Q3lVDZWUtFYgQUL3zvnewMay2lNWKjMMYlGAXbgiNY6x1OB9XD+FGTCQiFEP2loaCA7O5sjR4509HC0CwgIIDU1lVGjRo3YMvHa5lo+K/iMkvoSSupKKKkvob6lvtttfbx8+P2lv+/3VmOfJixUSkUCPwRuAcKBCsALCFdKFQCvAL/TWne9gyiEEENQXV0d2dnZFBYWdpmlNiQkhPT0dOLj44d9F15Ncw1FtUUcqz1GSX0JKyaswMfrxOSGLfYW3j74tlvHarG3UNdSR7BvsKfC7eKUCUop9S3gPmAtsBzYprVuda7zAc4FrgK+Uko9rLV+xcPxCiHEGaupqSE7O5uioqIuiSk8PJz09HRiYmKGXWJqbmvmWN0xjtYc5Wjt0Y4/a5tdxwGcO3ouo0JO9D5F+Efg7eVNq721Y5m3lzdRAVFE+EcQ6R9JZEAkkf6RRPhH4O89sCX0vbWg0oEZWuvGk1dorVuATcAmpdTPgXs8EJ8QQvRZbW0tWmuOHTvWZV1UVBTp6enDtujhl5/+kvzq/C4Jtzul9aUuCcpisbB03FL8bH7EBcURGxhLmF/YkLkOp0xQWusH3TmI1roOeKBfIhJCiH5SV1dHVlZWty2mmJgY0tPTu4xXOVQYhkFlYyX51fnkV+WTX53PBSkXMDVuqst23l7ePSYnHy8fEoITSAhOIC4ojoTghC7bLElb4pH4+4Pbd/6UUouBNMz7Tx201r/v76CEEKIvGhoayMrK6vYeU1xcHOnp6UNq4FbDMKhqqiKvKo/86nwKqgvIq8rrUrCQGJzYJUElBieSXZlNbGAsiSGJJAYndvwZFRA1ZFpDZ8KtBKWUWgXcAOwCWjutMjBnxRVCiEHX2NjIoUOHKCgo6JKYYmNjUUoRGho6SNF1b2P+Rt7Nepfqpupet82vzu+ybJlaxtUTr8bby9sT4Q0qd1tQK4B5WuudngxGCCHORHNzM4cOHSI/P79LuXh0dDRKKcLDwwcpOrOIIfd4LrUttcxMnOmyzma19Zic/L39SQ5NJjksmeTQZFLCUrpsE+gT6ImQhwR3E5Qd2O/JQIT7eponqrMtW7bwyCOP8O677w5gZEIMrPYRUHJzc7tMEBgZGYlSisjIyAGPq76lHl2hOVRxiOzKbAprCnEYDgJ9Ajk34VyXbre0iDQAfG2+LskoOSyZ6IDoYd1F11fuJqiVwHNKqceB0s4rtNY1/R6VEEKcgsPhoKCggKysLJqbm13WhYeHo5QiKmrg7r+02lvJrszmQPkBDpYfpKC6axcjmImruK6Y+OD4jmXRAdE8sOABEoITsFpk9LnO3E1QDwOBwE2Y950ALM7fh+QQvjk5OWRlZXU77XJ/sdlsjBs3jtTU1FNut2XLFn7zm98QHx/P4cOH8ff357vf/S6vvPIKhw8f5pJLLuG+++7jjTfe4JVXXsFqtRIVFcUDDzzAmDFjKCkp6RifLyEhgYqKCpf3+dhjj1FVVYXdbueGG27g6quv9th7FmIwtY8ufvDgQerrXQsIgoODmTBhwoA/x9Rqb+Wu9++iua25x20sFguJwYmkRaThZfXqsq5z6bc4wd0ENcmjUXhAd03+/tbW1kZubm6vCQpgz549PPjgg0ycOJHvfOc7vPDCC/z1r3+lrq6O+fPnM3nyZF566SXeeOMNIiIiWL16Nbfddhtr167l4YcfZsqUKdx5553k5+dzxRVXdJz/Bz/4Ab/+9a/JyMigtraWa6+9lrS0NI++byEGQ0VFBfv37+8y7YW/vz9KKUaNGuXRxFTRUMHe0r2kRqS6JBRvL28SgxPJPZ7bscxisTAmbAwqSpEWkcbY8LEEeAd4LLaRyq0EpbXOV0qFAJcDSUAJsFZrXe7J4Ppi7NixA9KCGjt2rFvbjho1iokTJwIwevRogoOD8fHxISIigsDAQP7zn/9w2WWXdTyTsWLFCh577DEKCwv5/PPPuece8zno5ORkzjvPnAIkLy+PgoIC7rvvvo7zNDU1sX//freSphDDQW1tLfv376e01OXuAt7e3qSnp5OSkuKRuZgchoPDxw+zp3QPu0t2c7TmKACXpl/apcUzIXoCDa0NTIiewISoCaRHpktC6gfulplPBt4HqoA8YAzwG6XUIq31ds+Fd+ZSU1OH1Ie0j4+Py+uTB5/s7pufYRi0tbVhsVhc+rPb97Xb7QQHB/PPf/6zY115eTnBwcHs3CkFl2J4a2lpQWtNfr7rKAlWq5UxY8aQlpbW5f9VXzW2NrK/bD+7S3azt3QvdS11XbY5UHaAK8Zf4bJs6bilLFPL+jUW4f58UL8DVmqtJ2itL9Vajwd+6Vwu+sHMmTNZt24dlZWVALz11luEhYWRnJzMvHnzeOONNwAoKipiy5YtAIwZMwY/P7+OBHXs2DGWLl3K3r17B+dNCNEPHA4Hubm5rF+/nry8vI7kZLFYSEpKYuHChUycOLFfk1NeVR6/3fxbfvSfH/HCthf4ovCLLsnJZrWREZPBrFGzuhRASHGDZ7h7D2oacMlJy34H/Lx/wzl7nXfeeVitVm688UYcDgcRERE8//zzWK1WHnzwQX76059y6aWXEhcXx/jx4wGzVbZq1Soee+wxXnrpJdra2rjjjjuYMWNGRxITYrgwDIPS0lL27dvXpQAiKiqKjIwMQkJCPHJuHy8fDpYf7LI8xDeEybGTyYzNZELUBHxtI38+qKHErfmglFLZwAqt9e5Oy6YAb2qt0z0Y38lxpCDzQQkx4tTU1LBv3z7Ky11vawcGBpKRkdHnyjzDMDhae5RtRdvYUbyDH876IaF+oS7r719/PxUNFYwOHU1mbCaZsZmMDh19Vj+HNBD6NB+U09PAOqXU00A+kAL8APh1/4UphDjbNDc3o7XuMjSRt7c348aNIyUlBav1zLrPDMOgsKaQbce2sa1oG6X1J4osdhTv4IKUCzpeWywWbp52M5EBkYT5DZ0x+s527lbxPaOUasIcjy8GKADu0Vq/5snghBAjk2EY5Ofnc/DgQVpbTwzvabFYSE5ORil1RveY2pPS1qKtbD+23SUpdbareJdLggJIjRg6RVXC5PauzRmxAAAgAElEQVRo5lrrF4EXPRiLEOIsUFlZyd69e6mudh1/Ljo6moyMDIKDz2zG1t0lu1lzYA1FtUXdrve1+ZIZm8n0+OlMihl2j3aelXqbUfczrfVcpdQOTowg4UJrPd0jkQkhRpTm5mYOHDjAkSNHXJb3130moEty8rP5kRmbyYyEGWREZ4zIEb9Hst5aUKucfz5NDwnKXUopC/AysEdrvVIp5QU8BSxxxrFSa/1cX84hhBh6DMMgLy8PrbVLd56Xlxfp6emMHTvW7QdtDcPgcNVhthZtZcWEFdisJz7CMqIzCPYNpqmtiWlx0zgn4RwmRk+UpDSM9Taj7uvOP1/uy0mUUhOAZ4HzgD3Oxd8DxmEOoxQMbFZKbddaf9mXcwkhho6Kigr27t1LTY3rmNLx8fFMnDiRgAD3Rls43nicLwq/YHPhZkrqSgBIj0hnWvy0jm28rF7cPvN24oLi8LP59d+bEIOmty6+Hrv22rnZxXcb8BJmcUW7K4EXtNZtwHGl1N+BbwGSoIQY5pqbm9m/fz+FhYUuywMDA5k0aRIxMTG9HsMwDA6UH2DD4Q3sKd3T5eHYz4987pKggG7nSxLDV29dfP0yUoTW+nYApVTnh32TgM6d0YVAZn+cTwgxOAzDoLCwkP3799PS0tKxvL07LzU1tdey8YbWBjYf2czHeR93W4Xna/PlnIRzmJM0p9/jF0NLb118f/Hgua24ts4smBMjCiGGodraWvbs2eMyHQyY3XkZGRn4+/v3eox9pft4ftvz3U5dMT5qPHOS5jA1bqqM6HCWGKguvu4UAAmdXidgtqKEEMOI3W4nOzub7Oxsl+nWAwICmDx5slvdee2Sw5KxO058T/X39mdO0hwWJC8gNii2X+MWQ9+AdPH14J/Afyul/gUEAdcBt3rwfEKIflZWVsaePXtcxs6zWCykpqYybty4Hqvzaptr2Zi/kWnx00gIPvE9NcgniJmJM8mvzueClAs4L/E8aS2dxQazi++PQCqwC/ABntdaf+LB8wkh+klPRRDh4eFkZmb2OKhreUM57+e8z6aCTbQ52qhqquL6zOtdtrlu0nX4ePnIGHhiYB/U1Vrf1On3NuBOd/cVQgw+wzA4evQo+/btcymC8Pb2ZsKECYwe3f3gqoU1hbyX/R5bi7a6VONtObqFFRNW4O994v6UtJhEO3cf1JV5n4Q4yzU2NrJ79+4uM9smJiaSkZGBr69rYjEMg+zKbN7Lfo+9pV3nKEsOS+bisRfLg7SiR+4+qPsXAKVUIBAPHNFady2zEUKMOO0Dux44cIC2traO5T0VQRiGwe6S3byX/R65x3O7HG9C9ASWpC1BRSrpxhOn5O6U71HAn4ClmOXgDqXU68BtWutaD8YnhBhEdXV17Nq1q2OmZzCLIFJSUhg/fjw2W/cfIe9mvUtBdYHLPtPjp7M4dTHJYckej1uMDO6OZv4c0AwozIdrU4BfAc8AN3kiMCHE4Gmfdl1r7VI6HhQUxJQpU4iIiOhxX4vFwpK0Jbyw7QVsVhuzk2azaOwiKRMXp83dBHUBMEpr3eR8rZVSNwCHPRKVEGLQVFdXs2vXLpfpMCwWC2lpaaSnp3eUjjsMB1sKt7C7ZDffnfFdl+66afHTWD5+OXOS5sgEgOKMuZugcjFLwvd1WhYPlHe/uRBiuHE4HGRnZ5OVleVSaRcaGsqUKVMIDTWnSDcMg61FW/lX1r86Bm7dVbKLqXFTO/axWqxcln4ZAC0tUFMDUVED+GbEiNBbmfkPnL/uAj5QSj2LOeV7HPD/gH95NjwhxECora1lx44dLq0mLy8vxo0bR2pqKhaLBcMw2Fm8k3f0O13mXfoo9yOXBAVw/Di89x5s2QJJSXDXXQPyVsQI0lsL6spOv2vg4k6v84HJ/R6REGLAGIbR0WrqfK8pPDycqVOnEhQU1FGV945+hyPVrpMN+tn8WJS6iIvHXnzyoQH45BMwDMjKgtJSOI1Rj4Totcz8woEKRAgxsGpra9m5cydVVVUdy6xWK+PHj2fs2LEAHCg7wD/1Pzl83PV2s6/Nl4VjFrJo7CICfQIpKwOvMPDu9EhTeDhkZsKuXWZiqqqSBCVOT29dfE8DD2qtq3rZLhJ4WGt9W38GJ4Tof4ZhkJuby8GDB11aTWFhYUydOpXg4GDAHJbo6S1Pu9yP8vby5sKUC7kk9RKCfYPJyoL//Af27YObboJZs1zPdfnlcNFFMG4cyCNP4nT11sX3EfCFUupT4B/Al1rragClVDgwG7gaWAD80JOBCiH6rr6+np07d7o812S1Whk3bhxpaWkulXhRAVHMHT2XT/M/xWa1MT95PkvSlhDqF9qxTU4O7HUOErFhQ9cElSyPPIk+6K2L7x2l1HrM6dl/D4xTSjVhzuXkA+wFXgVu11o3eDpYIcSZMQyDvLw8Dhw4gN1+YjqL0NBQpk6dis3fRlZFFipKuez3tXFfw8vixZK0JQR6hePj43rcefPg3XfBboegIGhuBl8ZSk/0k17LzLXWdcBTwFNKqVjMmXAdmMMdlXk4PiFEHzU0NLBz506XiQQtFgvp6emMSR3DxoKNrDu0DrvDzqMLHyXYN7hju1C/UOaFf4M1fzO78R57DPz8Thw7KMjs2ktOlvtLov+5+xwUAFrrEqDEQ7EIIfpR+8jje/bscRlDLzg4mKlTp5LdkM1DnzxEecOJxxnXHlrLdZOu63QMeP55swIPYNMm855SZ+ee69G3Ic5ip5WghBDDQ0tLC3v27KGo6MTzSu2jQVgiLfxxzx/Jq8pz2ScqIIpxkeNcllkssGgRvPaa+To/39ORC3GCJCghRpiysjJ27txJU1NTx7LAwEBGjx/Nh0UfsuPQDpftA30CWZJ6OX7FCyjeYTPHiOlk9mw4fBgWLICUlAF4A0I4SYISYoSw2+0cPHiQ3FzXKS7iR8VT4FPAWzveos1xoqvPZrVx0diLmB29hN8/FUBlJdhsMGcOhHUaPs/bG268caDehRAnuJ2glFKLgTTAq/NyrfXv+zsoIcTpqa6uZseOHdTWnpj9xtfXl8zMTCKiI3hzw5suyem8UeexXC0nMiASw4DQUKishLY2s1z8yiu7O4sQA8vd+aBWATdgjsnX2mmVgVl+LoQYBIZhkJOT02VajNjYWKZMmdIxy+3VE6/mxW0vkhSSwrKx15GZNKZjW4sFLrsM/vpXswDiggsG+l0I0T13W1ArgHla652eDEYI4b7uysdbaKE1upVzzz3X5aHbzKgZnIsPB9+dzOepFjJvdT3W5Mnw+ON0ec5JiMHkboKyA/s9GYgQwn2FhYUu5eN2w04++RyyHqK1rJXJZZPJiMno2L6kxMJX72YCsGMHHDlijjDezmKR5CSGHncT1ErgOaXU40Bp5xVa65p+j0oI0a22tjb27NlDYWFhx7LC5kIOWA7Q5NOExTBbTW/se4MHox7Ey2reMk5KgmnTzOQUFgbV1a4JSoihyN0E9TAQiDm9e/vIkRbn71497COE6EfHjx9n+/btNDSYo4o12Bv4suFLKnwr8PXxxYIFA7DUxzAr4WqsFqvL/suWQXo6zJ/vOuq4EEOVuwlqkkejEEL0qH3OJq01hmFgGAb76vax176XgNAAfC1mIURbsy/W7MsxDl/ErsM2Lp3uepyEBPNHiOHCrQSltc5XSoUAl2OOxVcCrNVay5TvQnhQY2MjO3bs6CiEKG8pZ2PVRlqDWgkKDurYbmbiTBbGXc3KDaG0AXl5sHOn2a0nxHDlbpn5ZOB9oArIA8YAv1FKLdJab/dceEKcvYqLi9m1axctLS0dy/a37ccaYSXQFghATGAM35z8TSZETwBg4UL48EOzGy81dVDCFqLfuNvF9ztgpdb6qfYFSqkfO5fP90RgQpyt7HY7+/btI7/TwHfto4/PSZrDgxseoqDQzsKkJdy2YAneXiduKF16qTkFhowsLkYCdxPUNOCSk5b9Dvh5/4YjxNmtpqaG7du3U1tbS11bHb5WX0ICQ5g2bRqRkZEUFkLj5psIrUigJC8OFuFSphQQYP4IMRJYe98EgEog46RlGcjUG0L0C8MwOHz4MJ9++inVNdXsqNnB68deJ9crlwULFhAZGQlARASENU4nwBFHZaU5/YUQI5W7LaingXVKqaeBfCAF+AHwaw/FJcRZo7m5mV27dlFSUkJFSwUfVX5EeWs5EeERZJNNWVMZCd5m+V1AAFxxBaxeDV/7mtmdJ8RI5W4V3zPOqd5vAGKAAuAerfVrfQ1AKXUl8BDmLL2VwC1a65y+HleI4aC8vNx8tqmpgR01O/iq+itsPjbi4+KpqPDGtzXeZZBXgPPPh+nTITBwkIIWYoC4PZq51vpF4MX+PLlSyh94FZiitc5WSv0Qc/DZy/vzPEIMNYZhkJWVxaFDhyhrLuOjCrPVFBISgr9/GPv3eRNetpRAyyJCl7v+N7VaJTmJs8MpE5RS6jOt9Vyl1A5OjCDhQms9vbvlbvLCHJEi1Pk6CGjqeXMhhr+mpia2b99OaXkp22u2s7V6KxarhZiYGPz9/BkdkkLknpuob46nBXjvPbj22sGOWoiB11sLapXzz9954uRa6zql1K3A50qpCsyEdb4nziXEUFBWVmY+eFtfwdqytZS3luPn50dUZBS+3r4sH7+ci8deTFaslWeegcWLYcmSwY5aiMFxygSltX7d+Wu01nrlyeuVUo/25eTOB4B/DkzUWucopX4AvKWUmqq17rbFJsRwZBgGWmsOHToEgL+XP1jAzy8cwxFMelQqN069kbigOADGj4df/hJCQgYzaiEGV48JSikVA8xyvnxIKaUxu+PahQJ3AD/rw/kXA5s6FUU8C/wWiARkGCUxIjQ2NrJ9+3YqKys7lvn5BDDL96e8sO8Fkpu+xnWLFxIX5PrUhyQncbY7VQuqBrgfs2rPj64z5zYDj/Xx/NuB25VSsVrrEuAK4LCM8SdGipKSErbt2Mae43uYEDgBi8VCdHQ0U6dOY9+zvpxb9QQ2/Pn73+Duu815mYQQph4TlNa6CTgPQCm1Wmu9or9PrrVer5R6EvhYKdWCWWa+vL/PI8RAczgcHDx4kK0Ht/JBxQeUtZQBsOKcFaSlpWGxWPjWt+Dhh/1JTIRvflOSkxAnc/c5qBVKKSvmnFDt/418gEla64/7EoDW+lnMrj0hRoSGhga2bdvGZ0c+47Oqz7AbdlpbfMj1yyU6KbpjKvbYWPjJT2D0aLN0XAjhyt3RzL8OvAAEn7SqHIjt76CEGK6Ki4vZtHUT75e8T35TPna7hcqKcBrrw7l28pWE+oa6bJ+SMjhxCjEcuPug7qOYxRD1wEWYU8D/CtjgobiEGFYcDgcHDhzgo70fsaFyA42ORgDq6qKhbizTGr5D7oejaJ4Lfn6DHKwQw4S7HQsJWus/YM4JpbTWOzGnf7/FU4EJMVzU19ez4dMN/OmrP7GufB2NjkZsXjbi4uK49ZKlzLfcT5BjFKmpYLcPdrRCDB/utqCKlFIhWuujSqkxSikLUAxEezA2IYa8oqIiNny1gXeK36G6rRqAAP8AxiaO5ebpNzMhegLTfMzEJLPbCnF63E1Q72GOZr4c+AJzdPMm4LCnAhNiKLPb7ezfv5+8vDx8DB+aW+0cLQoiNtaPSzLnckPmDQT6mAPmZWYOcrBCDFPudvH9GFgL2IHbAAXMQ7r4xFmorq6OTz7dSFZOlvn6eCgtX34fe1M8Efm3c82Y73UkJyHEmXO3zLwF+KXzZRXmCBBCnHWOHj3K7t27aWtro6qpBlr9qLVbmBS/mPjq2diMALZtg0tOnn9aCHHaehvNfA09jGLezhMP8Aox1Njtdvbu3UtBQUHHstjgaI4aLVjr4xl/TjH7t4zi+uvlXpMQ/aW3FtTOAYlCiCGstraWrdu2UlNTg9Vi9ooHBgYyY8YMAoOCeWvDIQyjgQcfshMc6PYUa0KIXvQ2mvlDAxWIEEPRkSNH2L5zB4VVRTgMGB2aQFLSKDIzM7HZzP8+l58/Fn8fL7y8ZDgIIfqTuyNJrO5pnXTxiZGora2NPXv2sD/nIMW1pTS0tNLQ3EZgZBLLpk3rGK4IIMjfexAjFWLkcrc/YtdJryOBq4A/9284Qgy+mpoavtz6FTnFh6lpqqWlzUFdq53mCD8K6+0UldeTGB002GEKMeK5W8XXpatPKfUC8Md+j0iIQWIYBgUFBXy1cyuFVcdotbcCEBAdQJvNj6jGscSHxGCTrjwhBkRf7ujmAPIIohgR2tra2LVrF7uz91LeUGnWrlot+CcEkZE2kakxUzl4uIpzJ8ZJghJigLh7D2rZSYt8gGuBPf0ekRADrLq6ms+3bCa7JJfqhgba7A6Cw/wJTYngAnU+aZEpAMyeHDC4gQpxlnG3BfX0Sa/tQBbw3f4NR4iBYxgG+fn57Nu3j6PVxZTV1NLa5qDV30ZSShLXnrOIIBkRQohB4+49qDGeDkSIgdTa2squXbs4duwYALFBUZTW1lAXCGEBaQQ3jCPQW1pMQgwmt+9BKaXOA64D4oAjwCtaa+niE8NOVVUVW7dtpbGhsWNZWGgY18xYzvptpWQkjWL25HiXUnIhxMBz9x7UTZjTsq8G8oBk4HOl1Le01v/0WHRC9CPDMDiUc4hPvvqMhqZWxkYlAJCSksLEiRPx8vJibGwy3javQY5UCAHut6AeBJZorT9tX6CUWgisAiRBiSGvpaWFT7d8xs7sfVTVm4UQvrZAll20kISEhI7tJDkJMXS4m6AigC0nLduI+cCuEENaWXkZ//70fUqqSmlsbqPN7sBhs1Jss+EfFDHY4QkheuDuAx1/AlYqpXwBlFJW4GfA3zwVmBB9ZRgG2/bt4G/r/kHJ8VIwwM/HhldoAGHRU1k8aT4hgT6DHaYQogfutqAuA8YB31ZKFQExQChQq5T6VvtGWmv5OiqGhMbGRt7d+G/yjuZ3LLN4WUhRY5iVPg8fix+xEVKlJ8RQ5m6C+p5HoxCiH+UUHmbtJ/+hvKoaL6uVAF8b3oG+LJg9j6lJk6Q6T4hhwt3noD5RSnkBM4EkoATYpLVu82RwQpwOwzDIysrigy0fU1xVhWEYtOIgJimO6xZ+jfCAsMEOUQhxGtwtM08G3gVGA0VAIlCmlFqktc71YHxCuKWpqYnt27dTUVFBQmgM5bU1NDkc+IeN4Zyx8yQ5CTEMnc5QRx8BP9FatyqlfIAngWeAyz0VnBC9cTgclJSWsHvXblpaWgDwttqYmj6RyrYoFp+bIVNjCDFMuZugzge+rrVuBdBatyil7gGKPRaZEL0or6tk9ca1NBxrJDUmHgCLxcK4ceNIT0/veC2EGJ7cTVCNQDyQ32lZPFDV7xEJ0QuHw8GWvO2s/2wT9ccbMYBgvyBGx0Qzffp0IiPl8TwhRgJ3E9T/Av9SSj0MFAApmM9B/cVDcQnRrfKGSv69/SNKco7SWt+CgQFYKG1o49o5cwkK9B/sEIUQ/cTdBPWwc9vfYD4DVYCZnH7V1wCUUpMx72WFYk7j8T2t9ba+HleMLHaHna1Hd7Nlx5c0lzcA4O/rjWG3ER05gRWL5klyEmKEcbfM3A7cD9yvlPLTWjf1x8mVUgHA+8DNWut1SqnlwGvA+P44vhgZSuvKWbfnYyryjuFoNJ9ssFgsjI6MZ+a0eYxOiMPbJrPcCjHSuFtmHgCsBL4BhCilKoCXgfvbCyfO0CVAjtZ6nfP1O8DhPhxPjCB2h52vju5i/bYt1B6pJsDbCz8fG/7e/kxJy2DWObPw9vYe7DCFEB7ibhffKmAscDVQiHkP6ueYpeZ39uH844BipdSfgCmYRRd39+F4YgSxt9nZ/MV2aovMWpzGZgeJYVFceN5cUlJSpEJPiBHO3QS1HBirtT7ufK2VUjuAA/QtQXljjvN3odZ6i7OLb51SKllr3dyH44phrrq6mu3btzPKFkaFtQKLw5vIgHguPH8hY5JiBzs8IcQAcDdBHQdCnH+2swIVfTx/EXBAa70FQGv9T6XUS5ittQN9PLYYZiobqwjzDSEvL48DBw7gcDjws/kyITYFH79oli2ei6+vjD4uxNnC3QT1Z+A9pdRjQA7mUEf3AhuUUsvaN9Jav3Oa5/838JRSaobWeptSaj5gIPehzip2h51tRXvYsH8rYceDSQg4Mcq4zWZjwZzzSUxMlC49Ic4y7iaom51/PnLS8kucP2AmltNKUFrrYqXUFcAqpVQg0Ays6K8qQTH0HW+s5sOcz9h14DBtxXVUOyoIjBtDaIA/YWFhTJ8+ncDAwMEOUwgxCNwtMx/jqQC01huB8zx1fDE0GYbBvtIsvijYTt2xaqyl9VgcBl54U1HdxIzMySilsFqlfFyIs5W7LSgh+k1DayOfHP6CvNICGo7U4GhsI8jPh5YGX+LD4rhs0fnEx0khhBBnO0lQYkAVVB3lPf0pLVV1NB6rA4eBr82XhJBY4ickcs6Mafj6+g52mEKIIUASlBgQdoedLUd28tH+rdQW1BCCBV9vLyICwogNjiZjYoY82ySEcCEJSgyIFnsrn+7ZRf3hKrwcDposXqREjGJUdBzTp08nJCRksEMUQgwxp0xQSqk1mNV5PdJar+jXiMSI43A4yM/JY3RzIDWUYcWPKN8o1JhxTJ82BS8vr8EOUQgxBPXWgtrp/DMVc+bcv2I+o5QIfBtY47nQxHBmGAYWi4W6ujp27NhBVVUVQT4BjIseDQ5fLl4wi8TEhMEOUwgxhJ0yQWmtHwJQSm0BLuk8DYZS6jXMkceFcFHXUs/be9YTUh+Kra4Ou93esS59dDLTpk3D31+mxhBCnJq796AmALtOWnYISO7fcMRwd7S6mL9/9R9KskvwbobJCWMJ9PPFarUyfvx4xo4dK4UQQgi3uPsU5JfAM0qpMAClVBTwR+ATTwUmhhfDMNhdfIA1W9dxXBfj1WzHgYMj5ccJDg5m3rx5pKamSnISQrjtdIY6ehOoUEo1AX7Ax5jzQ4mzXKu9lY9zNrNv/z5aK5sI8vWmtq2NcJ9IFsw8h+lTJ0khhBDitLk71FE+cK5SagwQBxzVWhd4NDIxLNQ01/Huzvc5dqgQR4t5rynQ15+0qETmzZ5FbGzMIEcohBiueiszX9bDqmil1FQ4oxHMxQiRU3aEVz94B5+GJmzOMfPC/EOZmj6ZKZlT8PGRqTGEEGeutxbU072sP+0RzMXIsH7vF3z42acYzW20WCyEBvkyKiye+TPnytQYQoh+0VuZ+RgApdRkrfWegQlJDGWGYZCbm0vBvhxwdukZhpXE8LFcsXgRAZ3mchJCiL5wt0hivVJqjNa6zqPRiCGtvr6enTt3UllZSWRACPEhEZTV1DFv+lwuPv9caTUJIfqVuwlKA7OBDzwYixiiDMNg38GDFBw+7PLQbeZYxfjxGcTGRA1idEKIkep0Bot9TylVDhTRaXw+rfX0fo9KDBnHq6v5y79WU1FZwdRRqfh427BYLIwbN460tDSZUFAI4THuJqgXnT/iLGEYBnsP7WfN+g9obG4E4GBxIedPnMy0adMIDQ0d5AiFECOdu89B/QVAKRUPJAElzmejxAjU0NDAB5+v59CRbGxeJ7r0bGHBnHveLAL9/QYxOiHE2cKtBKWUisQcGHYR0AL4KKU+B1Zorcs8GJ8YQIZhkJuXy4dbNlDTUAuAt5eVgCA/MsbP4IrZc6VLTwgxYNzt4vstUAMkaK1LlFIJmM9I/Q643lPBiYHT0NDA6vc/4FhFHlgcHcsjEqJYNvcyooMiBy84IcRZyd0EtQhIby8z11oXKaVuBvI8FZgYGGaFnubdjeupbqrGy2olJNAHLx8vMqdmcuHEedisMo6eEGLguZugDMwBYjs/B+ULNPV7RGLA1NfXs2vXLg7m51DTVA2A3eHAEejHNRddzpio0YMcoRDibOZugloN/EMpdTdQAKQATziXi2GmfTQIrTV2u53ooDAq6qspb6pn1Nix3LTwcoL9ZEQIIcTgcjdB3QO8AGxy7tOMWTRxj4fiEh5SXV3Nl1u309RwojFssVi4+Lx5NPp7MTs1Q0aEEEIMCb2NZp6mtc7WWtcD1yul/hsIxywzN061rxha7HY7u/bu44PNm6hvbWBaUho2LyuhoaFMmTJFnmsSQgw5vbWgtFIqF/g3sBb4WGtd7PmwRH8qLy/n862b2Xooi1ZHCwC5ZSUsu+BCUlNTpXRcCDEk9Zag4oALgYXAM0CiUuoTYB3wb611jofjE33Q0tLC7r272aF3UdVYg68vtDaC3dsLW1KYJCchxJDW23QbZcA/nD8opRIxk9UC4G6lVKPWWnk8SnFaDMPgyJFCtuz8ksLjRbTZ2wDw8fUiMDyMBVPPZ27aZLnXJIQY0tweLFYpFQLMwUxO8zHLzjd6KC5xhurq6nj/403sOXwQ3wA7Xs4k5B3qy7gJ41iQNodAH6nQE0IMfb0WSQBLgWXA+cBezO69G4Ev+qtQQil1BfCK1jq4P453NnI4HOTk5PDvTz+juLYUAwf2JishIX6EjY5i4eR5jAlPklaTEGLY6K0FlQVsxhzJ/JueKJBQSqUDKwH55DxD5eXl7N27l9raWnx8DAzMoYqa/W1kzJjGhePOw8/mO8hRCiHE6ektQf0duAS4C5iglHoX2KS1dpx6N/copQKAV4EfAa/3xzHPJk1NTezfv5+jR492LEsIjaKytQFrdCBfn30JYyMTBzFCIYQ4c70VSXxTKWXF7N5bCjwHxCul3scsO/+31rq8D+d/3vmzuw/HOOs4HA6yc3L5ePNWgvy8CHZOf2Gz2VBKMT9uAYG+AXh7ef//9u49OK7yvOP4d7W6S7Z8vyFjG9s8tnBsY7Ax92CcFFKGQAMtnUDCrZSGlClJ0yQzTVpoUkqAUEoCTbmYW5kJMBkIkCGQUKYkJA7QQAyOHtmWFXyTdbMutizrsts/3iNYG8m2ZO0l1u8z4xl5z+7RT7t7znPe96qqqxkAAA8TSURBVLznPVlOKiIyfIccJBG1ll6L/n3VzGYDnwZuBtYczjoGYmZfAHrd/aFonXIYmpub+dVv3mJd7SY6etsoihdz4rHHUVlZSVVVFcXFuleTiBwdDvd+UOXAGYTRe2cDi4E3Ca2f4boSKDWzt4FCoCT6+VPuvv0I1ntU6u/O2/x+HVvb6unobSdJkk72kZg4nmXLlmU7oojIiDrUKL47CAVpCfAH4CXgNuDn0fRHw+buK1J+z2zgXXdfeiTrPBolEgnq6upwdxo6mmjc00wymaSkpID2ghiz5lZy6pKF2Y4pIjLiDtWCWgA8Arzo7hszkEciyWSShoYG1r37LjubmmnpbqarJ9zdpGBcEWOnj+HjU6s4bfZS4rpfk4gchQ41SOKCTIRw9zqgPBO/649BR0cH69evp7ZuK7WN9XQmdjO2rJD84jglM8YwdcpUzp6zkkmlE7IdVUQkbYY1wEHSo7u7m5qaGurq6ujt6+P3DXX0JLpJxmJ0lsWpnDuJkysXs2RqlebQE5GjngpUDkgmk9TV1VFTU0N3d5htPJ6Xx6Qx5bzf3U6iooi5M4/lkkXnML5Et8UQkdFBBSrLGhsbee+992hrbycvZRqiiRMnsvL0U3nidy9z+tzFLKtcSF5MrSYRGT1UoLKkvb2d9evX09DQyM5du9ne3kDVjJlMGFdBVVUV06ZNIxaL8bdn/YW680RkVFKByrC9e/dSXV3Ntm3bSCaT1OzYQUvXLhKxJHU9nVx89oXk53/4sag4ichopQKVIT09PWzcuJHa2loSiQSdPXup391IT7yLnpI8ussLaSpup2lPO9MqNDpPREQFKs36L7TdsGED3d3ddPf10LCnid379pA/ppBxcybR29nN+JIKLlpyloqTiEhEBSpNkskk27dvp7q6ms7OTto7u9jcuJN4UTdF5QWUzRlHfnkh+fF8Lpy/nEVTTBfcioikUIEaYclkkp07d1JdXU1HRwcAW5qb2NrWQF8cYqVFzJ47nrxYjPkT57CicqnucCsiMgAVqBGSTCZpamqiurqa1tbW/ZaNH1tOLbvoLo4Tj+cxNn88q20lU8omZimtiEjuU4EaAc3Nzbg7zc3N9PT2EYvFyI/nkZ+fz5w5czjuuOPY9evnaOvcy0VLz2DB1Fm69bqIyCGoQB2B1tbWMMt4QwO793azpaWJ1n1tTB87mVUrVjBv3jyKisKt1j9/yvmUFBbrYlsRkcOkAjUMbW1t1NTUUF9fTyKZoGVvK/XtLbTv66KnJJ/68j4WLFyw36CHsiKdZxIRGQoVqCFobW2lpqaGrdt2EMsLhWnX3naSyQTFE4toGpNHTyxGWXEejR1tGjIuInIEVKAOQ0tLCzU1Nfxhyw52tLSzq6uV0vIEeTEoqCiiaEoZ8eJ8ju8t4OTKj7H0mOM1ZFxE5AipQA0imUzS3NzMhg0baGpqAmBj41Z29+wGIJZfzNQ5E4iX5DOupIITp5/A3AmzdI5JRGSEqEAdoH+4eE1NDS0tLfstG19eQuveLnrKCyicUML0SdNYOv0EZo07RqPyRERGmApU5IOZH3wDtVu309G1h/nTpwEQi8WorKxk+emn8NBbz1E1fTYrZy9mWvnkLKcWETl6jfoC1dvby5YtW9i0aRM7Wxup2V5Pd7ILgOld4znBjmfevHmUloZReDd9/LOUFBRnM7KIyKgwagvUvn372Lx5MxtrN9LY0UxrVzu9fb2Q3wM9MXpK89k9vpTFixfv9zoVJxGRzBh1BaqppY21b62juraGRF5nKEjJsCwWj1E+YwzNiQSLZsxmlS3NblgRkVFsVBWo1tZWnn3xBWobt5Ggj3heHmPLCskrjFM0qYSKKeNYMGU+CyfPY0xRebbjioiMaqOqQLW0tFBalE+SBAA9cSiYXs78OXOomnI8s8dV6g62IiI5YlQVqJkzZ9La2sqWfbuIVRSwYsFilh5jVBSPzXY0ERE5wKgqUAUFBSxbtozjquZRXlhGvmZ7EBHJWaOqQPUbpxaTiEjO0wkXERHJSSpQIiKSk1SgREQkJ6lAiYhITsr6IAkzuxz4CmE+h07gRnd/M7upREQk27LagjIzA24HznP3pcC3gB9lM5OIiOSGbLeg9gHXuvuO6P9vAtPMrNDduwd4fhygvr4+U/lERCSNUvbnH7kwNZZMJjObZhBmFgMeA4rd/ZJBnnMG8FpGg4mISCac6e6/SH0g2y0oAMysDHgYmAmcd5CnvgGcCewA+tKfTERE0iwOTCfs3/eT9RaUmR0LPAf8HrjK3fdmNZCIiOSErBYoMxsDvAM84u43Zy2IiIjknGwXqK8TRu6tO2DRue7enIVIIiKSI7LexSciIjIQzSQhIiI5SQVKRERyUk4MM8910TVaDwPr3P0OM5sA3AcsBfYAa9z9nui5E4B7gCqgBPi2uz8WLftT4FagCPgdcI27t+dA5irgv4BywpRTX3P3n0bLrgb+HigAfkaYiqonDXkHnPIqOk/5ecJ39XHgZndPmtlk4FFgFpAArnP316N1ZeR9HkbmeYTPYDJQCDzo7ndG6zoF+B7hM9gOXJ5yAXtWc6e8bjzwFvAP7v50JnMP470uIcxSczpQBtzv7rfneOYZwBpgGqHxcJu7Px6tK5P7jkGnnzOzccD/AlenPJa2bVEtqEMws4XAz4HUi4fvAnYTitBK4HwzuyBa9jCw1d1PBFYD/2FmldGHuAb4jLsbUAv8W45kvhd4KJpu6mrgSTPLN7NFwM3A2YAB44Cb0pB3wCmvzOxTwJ8DJwGLgHOAS6OXfR94zd2rgMuBp8ysNFPv8zAzPwz8MHr+qcBfm9kqMysEngb+zt0XRj8/ONKZjyB3/wHPI0BFymMZyT3MzLcBE4CTgeXADWa2Mscz/yuw1t2XEK4Hvc/MpmV43zHo9HNR9rWEfUGqtG2LKlCHdgPwAPBUymMnAY+5e180JdMLwCVRK+UThJ067r4VOAVoAT4JvOHuG6J13Ad8Ntrws5Y5WhYHxkc/jwG6op8/DfzY3RvdPQH8gPAFHGkDTnlF2HCfcPc97t5F+LJfbmb5wAXA/QDu/jawgbBRZ+p9HlLm6DkPAk9EmduAjYSjzuVAu7v/MuV555rZxBHOPNzcAP9IGG2bOuI2U7mH+v2IAVcA34y+722EQlCdq5mj58SBiih/KdBLaJFkct8x6PRzwI1R1g9am+neFtXFdwju/kUAM/tkysNrgSvM7JeEputngB5gHuHD+5KZnR8tu8Pda8xsJrAlZR1bgbGEgjCiTfUhZoZQ0F4xs5uAKcBl7t4bZa47IHPlSGaN8tb1/57oy/td4MeEq8t/OsDvnwTkuXvjAMtKycD7PIzMuPua/gfN7DzgNOAaQgv1g8zu3m1mjcAxwIhebjGc3Gb2iSjjnxBa5v32+06nK/cwMk8mfN6rzewBQst/jbvffeB2mEOZAb5OmMrt0uhv+LK7N2R43zFg7uig9rzo8dSXpHVbVAtqeL5M6J/9LfAM8DLQTThPM4dwhHY6cBlwl5mdRHivBxrTn6kpmwbMbGbFwA+BK929EjgL+EG0URyYOZbOvNGUV08SCv21B/n9A72XB1sGaco9hMypr/kc4dzDJdGR6sH+nrQ43NzRTC/fJZynOTBPRnMP4b0uILRG5gKrCIX1ejO7KIczA/w38B13n0Hoiv+qma0YJDPpyjxI7sGkdVtUgRqesYQTxYvcfTXhA9lIOOEKodmOu28EfgGsAN4HZqSs4xhgl7vvyXLmRUCpuz8fZf418B6ha/LAzDMIR0EjLtoRvk748p7j7q0H+f0NQCzqUj1wWcbe5yFmxsxiZnYn8C/Aanf/WfSc/V5jZgXARGDbSGceRu5LCUfCL5rZ24RzOreb2fWZzD3EzI2E3oFH3T3h7juB5wnn/XIys5lNAs7gw66yDYSDyLMGeE1a9x2D5B5MWrdFFajhuR64BcDMphKOMJ5w983A/xFG6PQvO43Qj/sSsNLM5qes49lsZyYUqQozOy1aNpdw9PZbQpfEhWY2JWruX0dofY0oC1NevQr8yN0v8w/nY3yW0GddZmZFwJXAM+7eSziHdl30+sVR5lfJ0Ps81MzRsu8QdjgnR331/dYCE/s/A8JAlV8dYseQkdzufqe7z3X3pdFJ8zeBr7j7f2Yq9zAydxPm9+zfDssJ54bfyNXMhO7FrUTnhaOCdVaUN2P7joPkHlC6t0WdgxqeW4HHzOxdQkvkm+7ePxPvxcD3zexvCAcAt/QvM7OrgKejE46bgM/lQmYzuxi4O+ru6yUME90ULbsFeIXQbbKWMDpqpH2RMFjg4ihLv3MJI4h+QxiW/SxhOCvAF4AHor8nCVwRnQzP1Ps8pMxmVgl8iXBU+XJKP/7d7r7GzP4M+F7UtdKcpsxDzn2wFbl7T4ZyDyfzXxG+0+sJ3X1P+IdD43Mus4dh5hcC95jZNwiDI25199eizJnadwya2weffi5t26KmOhIRkZykLj4REclJKlAiIpKTVKBERCQnqUCJiEhOUoESEZGcpGHmIhlgZk8CxwPLPWU2+Oh6nP8hXBD5erbyieQitaBEMuN6wrxl/9T/QHQdzqPAt1ScRD5K10GJZIiZrQZ+Apzu7m+Y2b2Eq+5XuXsiujDyZuBY4F3gBnd/J3rtOYQpkoww2e/LwFXu3m5mjxN6Q1YCe4GPRVf4i/xRUwtKJEOiuffuBe43s1WEee4uj4rTKYT7Ld1IaGk9ALxkZmOj6WeeAe5y98nAAsIcitekrP4cws35Vqo4ydFC56BEMutrhDnhngf+MrpnGIS5ER9x91ej/z9sZjcQbovyKHCSu2+MugWnA03sPxHnK+6elsllRbJFLSiRDIpuUvfvwCZ3T504cxZwrZm19v8jdP8dG93m4gIzqwPWA/9MuLNt6o3ftiNylFELSiTz+vjoPXG2E25u+Y3+B6JZoHea2ZmEwRUr+u9OamYvHPB6nUyWo45aUCK54VHgOjNbDh/cxXYdsITQWuoD9plZ3MwuI9w+ojBbYUUyQQVKJAe4+yuE23GsMbN24B7gmuh2Cz8BngLeAXYSBkc8SBgoIXLU0jBzERHJSWpBiYhITlKBEhGRnKQCJSIiOUkFSkREcpIKlIiI5CQVKBERyUkqUCIikpNUoEREJCf9P0yZZ56q5t0YAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "results = run_simulation(system, update_func_quad)\n",
+    "\n",
+    "plot_results(census, un, results, 'World population projections')\n",
+    "plot_projections(table3)\n",
+    "savefig('chap04-fig02.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "People who know what they are doing expect the growth rate to decline more sharply than our model projects."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercises\n",
+    "\n",
+    "**Optional exercise:** The net growth rate of world population has been declining for several decades.  That observation suggests one more way to generate projections, by extrapolating observed changes in growth rate.\n",
+    "\n",
+    "The `modsim` library provides a function, `compute_rel_diff`, that computes relative differences of the elements in a sequence.  It is a wrapper for the NumPy function `ediff1d`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "def compute_rel_diff(seq):\n",
+      "    xs = np.asarray(seq)\n",
+      "    diff = np.ediff1d(xs, np.nan)\n",
+      "    return diff / seq\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "source_code(compute_rel_diff)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's how we can use it to compute the relative differences in the `census` and `un` estimates:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "alpha_census = compute_rel_diff(census)\n",
+    "plot(alpha_census)\n",
+    "\n",
+    "alpha_un = compute_rel_diff(un)\n",
+    "plot(alpha_un)\n",
+    "\n",
+    "decorate(xlabel='Year', label='Net growth rate')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Other than a bump around 1990, net growth rate has been declining roughly linearly since 1965.  As an exercise, you can use this data to make a projection of world population until 2100.\n",
+    "\n",
+    "1. Define a function, `alpha_func`, that takes `t` as a parameter and returns an estimate of the net growth rate at time `t`, based on a linear function `alpha = intercept + slope * t`.  Choose values of `slope` and `intercept` to fit the observed net growth rates since 1965.\n",
+    "\n",
+    "2. Call your function with a range of `ts` from 1960 to 2020 and plot the results.\n",
+    "\n",
+    "3. Create a `System` object that includes `alpha_func` as a system variable.\n",
+    "\n",
+    "4. Define an update function that uses `alpha_func` to compute the net growth rate at the given time `t`.\n",
+    "\n",
+    "5. Test your update function with `t_0 = 1960` and `p_0 = census[t_0]`.\n",
+    "\n",
+    "6. Run a simulation from 1960 to 2100 with your update function, and plot the results.\n",
+    "\n",
+    "7. Compare your projections with those from the US Census and UN."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1965 0.02053176728437212\n",
+      "1966 0.020911551029763803\n",
+      "1967 0.02109058925415572\n",
+      "1968 0.02101656992547482\n",
+      "1969 0.020758188486659338\n",
+      "1970 0.02047634637090081\n",
+      "1971 0.02020818429559682\n",
+      "1972 0.01985720289669974\n",
+      "1973 0.01942307949759347\n",
+      "1974 0.018951122249287078\n",
+      "1975 0.018451250053342288\n",
+      "1976 0.018012165954475304\n",
+      "1977 0.017733081691009327\n",
+      "1978 0.017660373676849746\n",
+      "1979 0.017733142573392077\n",
+      "1980 0.01779837434815221\n",
+      "1981 0.017827650403505917\n",
+      "1982 0.01792104480553395\n",
+      "1983 0.018082043263461734\n",
+      "1984 0.018258274003086366\n",
+      "1985 0.018458583147941614\n",
+      "1986 0.018560906303449712\n",
+      "1987 0.01841288422276466\n",
+      "1988 0.01786326916513628\n",
+      "1989 0.017364563479923413\n",
+      "1990 0.01655611582078212\n",
+      "1991 0.01589800279277194\n",
+      "1992 0.015280632144474183\n",
+      "1993 0.014737986202132534\n",
+      "1994 0.0142615853328304\n",
+      "1995 0.01379254395511941\n",
+      "1996 0.013343302439389169\n",
+      "1997 0.012988535013695223\n",
+      "1998 0.01274819781096187\n",
+      "1999 0.012595669665169867\n",
+      "2000 0.012475576914740197\n",
+      "2001 0.012363793230324945\n",
+      "2002 0.012281440429518646\n",
+      "2003 0.012223017749625578\n",
+      "2004 0.012180328767820279\n",
+      "2005 0.012148023140354647\n",
+      "2006 0.012115152134682531\n",
+      "2007 0.012069835509940846\n",
+      "2008 0.012004281280093811\n",
+      "2009 0.011918780280830502\n",
+      "2010 0.011829541279946\n",
+      "2011 0.01172816112359535\n",
+      "2012 0.011588443192049321\n",
+      "2013 0.011402290446640954\n",
+      "2014 0.014590164477571362\n"
+     ]
+    }
+   ],
+   "source": [
+    "# start by deducing reasonable values for slope and intercept\n",
+    "# I'll paste alpha_un data between 1965 and 2014 into Excel to get a linear fit\n",
+    "# I ignore 2014 data point because it is way off line. Y=-2.24e-4+4.61e-1X, R2=0.936\n",
+    "for i in range(50):\n",
+    "    print (i+1965, alpha_un[i+1965])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 103,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define a function, alpha_func, that takes t as a parameter and returns an estimate of the net growth rate at time t, \n",
+    "#based on a linear function alpha = intercept + slope * t. Choose values of slope and intercept to fit the observed \n",
+    "#net growth rates since 1965.\n",
+    "def alpha_func(t):\n",
+    "    slope=-2.253e-4\n",
+    "    intercept=0.464\n",
+    "    alpha=intercept+slope*t\n",
+    "    return alpha"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 98,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0xe4e57f0>]"
+      ]
+     },
+     "execution_count": 98,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Call your function with a range of ts from 1960 to 2020 and plot the results.\n",
+    "alpha=TimeSeries()\n",
+    "for t in linrange(system.t_0,system.t_end-1):\n",
+    "    alpha[t]=alpha_func(t)\n",
+    "plot (alpha)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "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>t_0</th>\n",
+       "      <td>1960</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>2100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>p_0</th>\n",
+       "      <td>3.043</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>beta</th>\n",
+       "      <td>-0.0018</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>alpha_func</th>\n",
+       "      <td>&lt;function alpha_func at 0x000000000E659E18&gt;</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "t_0                                                  1960\n",
+       "t_end                                                2100\n",
+       "p_0                                                 3.043\n",
+       "beta                                              -0.0018\n",
+       "alpha_func    <function alpha_func at 0x000000000E659E18>\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 99,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Create a System object that includes alpha_func as a system variable.\n",
+    "system = System(t_0=1960, \n",
+    "                t_end=2100,\n",
+    "                p_0=census[1960],\n",
+    "                beta=-0.0018,\n",
+    "                alpha_func=alpha_func)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define an update function that uses alpha_func to compute the net growth rate at the given time t.\n",
+    "def update_func_alpha(t,pop,system):\n",
+    "        \n",
+    "    growth = pop*alpha_func(t)\n",
+    "    return growth"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.2039020770727397 3.043001508 1960\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Test your update function with t_0 = 1960 and p_0 = census[t_0].\n",
+    "\n",
+    "system.t_0=1960\n",
+    "system.p_0=census[1960]\n",
+    "growth=system.p_0*update_func_alpha(system.t_0,system.p_0,system)\n",
+    "print(growth,system.p_0,system.t_0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 102,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation_alpha(system, update_func_alpha):\n",
+    "    \"\"\"Simulate the system using any update function.\n",
+    "    \n",
+    "    system: System object\n",
+    "    update_func: function that computes the population next year\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    results = TimeSeries()\n",
+    "    results[system.t_0] = system.p_0\n",
+    "    \n",
+    "    for t in linrange(system.t_0, system.t_end-1):\n",
+    "        results[t+1] = results[t]+update_func_alpha(t,results[t],system)\n",
+    "        \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file chap08-figEx02.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Run a simulation from 1960 to 2100 with your update function, and plot the results.\n",
+    "# Compare your projections with those from the US Census and UN.\n",
+    "system.t_0=1960\n",
+    "system.t_end=2100\n",
+    "results = run_simulation_alpha(system, update_func_alpha)\n",
+    "\n",
+    "plot_results(census, un, results, 'World population projections')\n",
+    "plot_projections(table3)\n",
+    "savefig('chap08-figEx02.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Compare your projections with those from the US Census and UN.\n",
+    "    Not a good fit after 2050. "
+   ]
+  }
+ ],
+ "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap09mneal.ipynb b/code/chap09mneal.ipynb
new file mode 100644
index 00000000..a8bf5155
--- /dev/null
+++ b/code/chap09mneal.ipynb
@@ -0,0 +1,1133 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 9\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": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure Jupyter to display the assigned value after an assignment\n",
+    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n",
+    "\n",
+    "# import everything from SymPy.\n",
+    "from sympy import *\n",
+    "\n",
+    "# Set up Jupyter notebook to display math.\n",
+    "init_printing() "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following displays SymPy expressions and provides the option of showing results in LaTeX format."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sympy.printing import latex\n",
+    "\n",
+    "def show(expr, show_latex=False):\n",
+    "    \"\"\"Display a SymPy expression.\n",
+    "    \n",
+    "    expr: SymPy expression\n",
+    "    show_latex: boolean\n",
+    "    \"\"\"\n",
+    "    if show_latex:\n",
+    "        print(latex(expr))\n",
+    "    return expr"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis with SymPy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create a symbol for time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAsAAAASCAYAAACNdSR1AAAABHNCSVQICAgIfAhkiAAAAKpJREFUKJHF0DGKQjEYxPEfKmq/WHgFKxGsvMmyIFuslZV3sPAYnsPKxkLQtVK8hlu42GhhlPB40QcWDoQvMP9MJuFFjXDGZ9Yo5cCdMFdFknf4SwTdNQnX560vqETwClP0scAs8uZ56YOQ9JNnZnvdHvf7qO9NS5xQewZWcMQmBcQ1WqhjXQRuh5nsG8MfYR5ScDnaV/GNLprooYFt6vAQe/y7/vc4Bb5RFyWjHpewStOAAAAAAElFTkSuQmCC\n",
+      "text/latex": [
+       "$$t$$"
+      ],
+      "text/plain": [
+       "t"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t = symbols('t')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you combine symbols and numbers, you get symbolic expressions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAC4AAAASCAYAAAAkAezhAAAABHNCSVQICAgIfAhkiAAAAT9JREFUSInt1D9KQ0EQx/GPErCxEGy8gGihEuzs4gm0sBLBHMBKPIBNCjvBUpAIqfQIFiKChSCm0SA2OYBVRFBBYvEW8nhoeO9FE/zzg2V22Z2Z78LM8Iu0iTZWB5B7BXs4Rytw1NI614LD1LegdVc95H5EQ0bwRnAczpG4HJKVcvjCIiYxFGJ8Ch6H2wkPpzGKt3BuYy0nSFad4j7k7KpCbH+FQ6zjAiexu7OvpPsKxcGPMCYCr2J/EEBplazj+WCv+w3Sqy7xipEUb5s6PZBmVTOylHRpzkJiP4tbvKQIvCsqrbiKWBL1SjNxV08RM5fmRD886CFGWW/jMK6SlOOwGOyPqO84+HiwrUGAZFVyjkMFM3jCDY77yLMcFkwEu6DT2A/Y+shxA3d4FtVXJWPist5qfFv3ydTMGfdff1fvrThTb/K9gpgAAAAASUVORK5CYII=\n",
+      "text/latex": [
+       "$$t + 1$$"
+      ],
+      "text/plain": [
+       "t + 1"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "expr = t + 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The result is an `Add` object, which just represents the sum without trying to compute it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sympy.core.add.Add"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type(expr)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`subs` can be used to replace a symbol with a number, which allows the addition to proceed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAABHNCSVQICAgIfAhkiAAAAOlJREFUOI3N0r1KQ0EQBeDPkEJQEIyg2AipLARBUlgINhY2Fj6Eb2CvjUWw1ldJEdIIVkIiIoJFqoCIf2AliiEWu4vhcpV7wcKBZYbZOcw5h+GPookOBnjDC3o4QG18cCID/EAXN3jAFNbRwF2sB3kbJ39gcoQRTstKWI3AdmpUCgJ3Yr5KjazGFPuYxoygbyOCtvD424b7SC29FuYLsiMO7+JWcHWtDBiW8I7rskDCIYwwR3FXYTHmYfZjGQs5gIrvAzhPzerYwDaOcYY+ngVzNlEXnN7Lo7KCE1ziCZ94xQUOMVtQ0n+LLxK6LQuL4DX5AAAAAElFTkSuQmCC\n",
+      "text/latex": [
+       "$$3$$"
+      ],
+      "text/plain": [
+       "3"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "expr.subs(t, 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`f` is a special class of symbol that represents a function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "f"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f = Function('f')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The type of `f` is `UndefinedFunction`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sympy.core.function.UndefinedFunction"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type(f)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "SymPy understands that `f(t)` means `f` evaluated at `t`, but it doesn't try to evaluate it yet."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAB8AAAAVCAYAAAC+NTVfAAAABHNCSVQICAgIfAhkiAAAAgNJREFUSInt1cuLjmEYBvDfmImZBkNjp6wYYyLHZGNlmD/ATspCLMRmNmKDMuWws7QjO4Qm5bAQRcggQmLBxqdRTpPz8Fk8z5vX4/m+byYbC3e93W/39V7X9d7PkX8wpuIQnuErqtgesaMYRvsYtZZG/saxmg9GwlnsxW7MwzL8QH+G0x856zLYKVQwuZFxdxQ5l8Eu4C3aMtixyJubwZZHbGcj8y3xw01JvUvo+nAN3iOMYEId/Dmac+DaaJp7urEvvq9KePvr8NaXvtsVa31FoaUEVrBH6Hw6BmK9iifoxXdcT8yHcAQbcA0XS9jl0vvVmFfjfK77ZnzEvaTejlHcz5GwWX6qytERv7lZFNL56REW0+2kPjP+WKWG8JKY79Qxf4fPmFXLvBBJzTtjflPH/JvaI1PEa8xoZJ528Cnm1oxgCxbgIb40MG8raWXNq7ib1Idj7vRn9MSfSkcrjQmYVtL6zbwJC4WVPZIQK3glf4AsirnefIvcJqXGyuZdmFJDpIorwnzNTrBiNN43MF8R86WiUN7ntRZbESeFg6gPT0v1oZgHMB8f8ADHE/4a4Zw4kxM/KHTYW8N8Il7iRgbbisfCVqr6dUAV0SEstNM1tMcUO6L44nHytkXeyr8xbxUuh8FxcNrwAidSIHvD1IlRYU1Mwi3hYGkUc4T9f0C4jv+Hn+Eqf+7lUJe+AAAAAElFTkSuQmCC\n",
+      "text/latex": [
+       "$$f{\\left (t \\right )}$$"
+      ],
+      "text/plain": [
+       "f(t)"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f(t)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`diff` returns a `Derivative` object that represents the time derivative of `f`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAADAAAAAhCAYAAACfiCi5AAAABHNCSVQICAgIfAhkiAAAAzJJREFUWIXt102IllUUB/DfqJiDlYlBIQRBMqOB5FdDm3KR1SKKICLIoEXUImzjRmqTRtKHbgqKchEVQZuiQqIyqCyKEqYvoSFcaBJNGGQZZt9vi3uemafH+3y8EzpW84eX+7znnP895z73Oeeey/8MGzA23UGUMatP+4vwyYkIZKr41y+gCcN4Ez9jL0bwE66azqC6Ygg/4GEswdX4Ej2c04F/Jh7BAfwavE2hewaHML+PeFbHHLd2JbyB5yqyJzHekb8zHL6C+7AZy7AGf2JjDW9j8G7K6F4M/6e3OT8vJrm4It+BV1tDZ2nwX8voduF7DNZwnw3ucEY3Erq72wK4Fr9jbkU+ivvbyLgjHN1WkQ9Jb39HA3cMP6ovLmPSpzy7KYBrIoAzSrK1IbuxgXd92OR+S/FAPF+e4T7YwL25ZHdPyCYKyZzMZKP4BdvxUDh/LHRNJXQcW6QdWIitIe9hH9bhD3xQ4/Np3IL3pRwssLv0/F6MV+D1hlisx0Ecxtu4F0e1nxuzpVL7WUU+X/os9zZwb5f/9MpYEDZ7WuKYMpaHg6cq8qGQ72rgPh42a1p8HMM3xZ9+T+I2rIrxo4p8UYyHW7i/ad4l+A5nF39O1AI+rsiPxTivhjdH2r3PpfxrwmBpvokk7nWPMYuBGFfFXNVkPxTjInlcKC2uunNVzMJZ2F8IigUMZM37w4DU7O2TankZ4/hW/oCCFTFWd66K4fAz8YK6fEJd7wBD0tmRC6KHd6Rvd0lGX+zMkRYfl8T4ViHosoByC71d6m9yqEvgAi/EmOtmR2Pcim1S73RDxu5K6Sx5uT7c47HHZCe5Wzqsctgmvel1Nfq5Uvn7sEa/AV9I7XvP5EFYYIGUvC81Bdt0Byja4uLXVu5yuCu4K6fAvTO4l9YZtN0Bim5wBOdK7UK/mBdz7uyTN4iv8XyTUdsd4Dopyf5pxbpMasr6udAsk/Li/DqDLneALXi3D6cnBUUVWill96cV/WqTFWiF9jp90lEsoCd1kqeVdGul0lgsYLnju8xTBoulyvMELvD3BC5OzwPSRX2xdJyfcmi7A6zHV9K18NFpiG8GM5jBfxF/ATf5zF//rHTEAAAAAElFTkSuQmCC\n",
+      "text/latex": [
+       "$$\\frac{d}{d t} f{\\left (t \\right )}$$"
+      ],
+      "text/plain": [
+       "d       \n",
+       "──(f(t))\n",
+       "dt      "
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dfdt = diff(f(t), t)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sympy.core.function.Derivative"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type(dfdt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We need a symbol for `alpha`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAABHNCSVQICAgIfAhkiAAAAOFJREFUKJHV0s0qhVEUxvHfq3wOpYxMZGzGFXAD7sJEkptQdJKUMjIwVMpMoQyNzkQpE0XJmUpOvo7BXuXtbR0jE89sr2f9d8/ea/HHGsQq2njFA1oYwhiecJiB47hCDyfYwHWc17GGd8xk8Gk0rtRqE+jiDI/Yz8CFAC9RNbyb8LqYyuCDaFhKvHZ42xkId3hTPiWDXzCZgaP4wm3iTUfc86YxUIOruKCpFobx0S9yhWd8YrZWX1be2lNG2Fc70dTBLo4iyTEuwtvDXAaPYBP3yiJ0sKVs3LyfcS3+luAf6BtvBTiR60P1+gAAAABJRU5ErkJggg==\n",
+      "text/latex": [
+       "$$\\alpha$$"
+      ],
+      "text/plain": [
+       "α"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "alpha = symbols('alpha')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can write the differential equation for proportional growth."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHQAAAAhCAYAAAAI2Y9jAAAABHNCSVQICAgIfAhkiAAABMZJREFUaIHtmW2IVUUYx3+rpruZWSoUQrVU7Kqw5evSl9wPrfShF4KIqC0KosAyWgyM+lKG9qZhLxStQmQUfikSLKoVKg2lFyxNaAuLtrTWNshKa7e0vX14numepjnnzJl7r/eC84PD7M7Mc+a5/zNnzjPPQOSEZhkwUG8nIumMK9j/QmB3LRyJVIf4QE8g2oF3gFFgL9AJ/AFcWk+nImG0Ab8CTwLnA5cB3wIl4AwP+1OBp4BB4C+1u0fbXgSGgckF/Fmg97ilgE2jUU1NCuuxFdhk1T0PDHnab9EB3wBWAQ8As4GFwBiwPMVuudpd72h7Tcc/xdOHRiNEk6rocZbeZJFVvx5408PxWWr/lqOtH/gFaEmxfUlt2x1tndp2n4cPjUaoJlXR40rgGDDRqt8FPJxnDNyuA91q1bchM3F9hu0AcJj0YG0AWfrHe/jRSIRqUhU9rtDBpyTqurTu2gy7q7WP65oFPKJ/X+KwfTTD9oZEv/u1rl6B2UlALxLpjwAHgHXI5D8Z+BF4OdE/VJNgPSY4nN4F/AmsBR7TgZ/VtqwtyxCwEpmNpwOrtb4E7AO6gb+BD1LG3AjcBOxEvuGGbYm/d2i5BHg7w5daMA1ZMhcBr+v4lyMP+HvkTZuGiGwI1SRYj6YU53uQ5XUKsAfYDtyt/49l/OjxyBLxFXBBon4yEjUPAB0ptrcBfVpuSOkzFfnefIx8Q7LoBU7L6ZNkN7A5o70fEe4uJFoFmIG8pTuAOciDtpfVUE2qrUcQHcjse8Gqb9P6/gzb57TPwpwxRoCDHr4Mkr5suS7b5yTd2mc7/38JvtC2USSgtAnVJEgP15JbCfO1/MSqn67loRzbo0gSI4uf8dsLt3r08eVGLZ9ARE4yqmUfsN9hG6pJkB5FU395GOc/tepHtGxOsZuAzOTPke93Fi2J+x0vuhBxXdsOkAzaQyltIZoE62HeUHvWFcUsQ/P1XnbwNKzldNzMQX6YPYttxiHfxW88fKrWN7QFOBv4GnlwSc5FgsadSITrIkSTYD3MA00LjorQhCTv9yFBQJIh4CfcG2SAuVras9imXcfxOSDoBc7x6GfYSPoDbcIdDK4DJiH7dhehmgTr4bPk+p6BtiFRsMsJE1DMQHLDNmaW/pYzxkVavuvhTyvyY32vm1Pucwg4on4no9SlSBIG0leCUE1qoce/bKCc112L5CJdXKdOrshpv8PRtljbDgBrkDznNY5+m5C3wRVN1pKnEf+GgWeAV5E3djMiZgmJSu10aagmNdXjI8qnAtuQjbKLNepEd0r7RCS8/jClfRnwJRI1lihvwg1TkY9/1l6xVjQjk3k/EhwNA48jmaNOyluXJZZdJZpURY+sM1Bz5GOuvHDaxb1qOy/A9k61vTjAtpEJ1SRXj7wzUJPd7wTORFJZRWnWe24paNcC/AC8EjBmoxOiiZceeWegVyEf6Uoj4sVIvrPIAfds5DvSWuHYjUpRTXL18DkDXQm8X8DJSB0w25Z5SNZ/j9W+gPIeZy75+6JInTEPtIScCkxKtHUhWQ7zQDuAz46fa5FKmIlEtn3Aefw3IDKZjEHk2GgmxVJqkTrRA3yHZEbeAx4Efqf8FvcgG90xZHMdiUQikUgkEok0Jv8AmcyUoSpZbTcAAAAASUVORK5CYII=\n",
+      "text/latex": [
+       "$$\\frac{d}{d t} f{\\left (t \\right )} = \\alpha f{\\left (t \\right )}$$"
+      ],
+      "text/plain": [
+       "d                \n",
+       "──(f(t)) = α⋅f(t)\n",
+       "dt               "
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eq1 = Eq(dfdt, alpha*f(t))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And use `dsolve` to solve it.  The result is the general solution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAG0AAAAaCAYAAAC939IvAAAABHNCSVQICAgIfAhkiAAABMBJREFUaIHtmW2IVUUYx3/rau1tt9awyDLDIjet7MV8CbE0EqX6Em34oaIXKwlrKYQKjXCLrEw/mFT28kELLTGXMpFii4rCILIyrcS03KA3ttrScNda7fbhP4c7zs45Z+52z67R+cFwuM/MPPOcMzPP88xcyMnJqShLgI2ucEA/GJITznhgc2jjY4BlQBvwF1AE7jV1LwDtQG2grgtM/5tDB/+fMB54G+gCdgKTgZnAe8AgSt89KtvSFG4wDTcCDwHNwGhgHPA3MNfTZ67pc42n7hXgR6Au+JWyZSTwCPAx8DPQbZ5vAXOAozIefyKarHnGlpfQBH4GTEEecAL6nhOAocCxSQpHmcZveOpagd+Bgqdulel3hqcuMmB+2ttkTBXwIPAnsmcTsBx4FH24X438/Yzt2ASssX5fARwE3rRkVwJ7jc2pzEGG3+rIG9Auezam33bgD+Lj5HbgW6A6xIiMWIHe7QvgXE99AbjPtMuKYcaGqZZsupFdaMkeIGDxNHKoD7XLKLQai8ClTr9FCf2us9otMLIZAS+WBZH7/hI4OqWtz5OE0Ai8DvyCYtJO5F3shRpNkO2C7wQ+d3StR3lFIpNQ7GpHPr7ZlAVm0M3AAXomIDOBlZTcTbNVhlvtppk2S9IMyYATUQzpBs7OQH81cq9FNFHLgaXADiN73mrbiFxhjfldD/yE4qvNN8AtvsFcf1mNXNwu4BxLXgvsQS5ujEfPbOAZ83wu5sXqUTz8CMW4JO4CBqe0sdkCvJpQvwi4B7m9WWXoDeUJ4Hbkje5HixuUBb6LNsRZaJefBnyNErzVwGLgJOB0lGnvMn3bgNeMzk707byMQStjpSNvMPLWmH5Pm/pxKS/XhVZVGm3Eu1xfce11iVb8JQFjl8tEFOvjFs1sM/ZNlmw+ylb3o4kbDHyAMuyIa4HvjO4nbYUDnQHGmucnjnyIef4WY9hY5HrSzhIdwAkpbQBGBLQJpY7SovuwgnojmpDH6kQhwSVyx7ZXe9gUm0nO79WmpPI4ermLHPl5Rr7e02cg2kFbAvR3IPfbl5yKbI91LwlcjM6sPxgdV3vatBPmDab1Ynwvvp1WpOcEtJvnEHpyJgqq7u50GYDcwO4AuyoZ0/aZZwHF7INl6K1FB94VQIunvgY4Ht1iTClDb8WoQoe5HTF17cgPu1yPJropRf9o08738i5tVDam7cZ/XHFJuov17bQCpXNfn2Eb2YDOL5962hXRajoOZTk20e7bmzJWdHB8J8CuEWihhJYbU/QtNc+n0JnTpQq4jENvKULoArYib3NVTJvJVPhCwXaPcUlIRAs6Y8yglJZC6XyxEAXdfWjlvez0n45cky8uZs0ydISZhZKlVuArlDwNRx/2ZODFXui+G93RtqC7y61oMwxDKfwg4JR/Z348i0kOmEegdN2Xgd2B3Op+o2OhU1+PVmXSWaovuBxdXn+Pbiw60AJbC9yAP2ZHxCUioBv7dej7dKMbkW3o7JrmkjNnHjL+/DL7NeHPSv9LJE3aYU0NuvTdUEafAkqZ12ViUd9x2ExauQHyAIp5R6K7yO6APiPRXyGP0buzUn9Sh5KMocBt6AquE4WKPf1oV04CU+ndESMnJycnJycngH8AMtpJn9g1N5kAAAAASUVORK5CYII=\n",
+      "text/latex": [
+       "$$f{\\left (t \\right )} = C_{1} e^{\\alpha t}$$"
+      ],
+      "text/plain": [
+       "           α⋅t\n",
+       "f(t) = C₁⋅ℯ   "
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "solution_eq = dsolve(eq1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can tell it's a general solution because it contains an unspecified constant, `C1`.\n",
+    "\n",
+    "In this example, finding the particular solution is easy: we just replace `C1` with `p_0`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "C1, p_0 = symbols('C1 p_0')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGwAAAAaCAYAAABSHbkRAAAABHNCSVQICAgIfAhkiAAABPVJREFUaIHtmXtollUcxz9uU7eUVlkURiVh6lZa6aaxTItk/rE/ikZKd0Y2aG1UUsSEcEF2m4GtxCwKC0dCrVpihkV0W7DM2Lot09rKKF1mF0vtuv74/l52dt7n2fO827tZ7v3Cw3mf3+38znnO+f1+57yQQQYZpAUrgU0+MeswOJJBPBQD78cVPhpoALqAP4Ae4A7jPQ10A+Ni2ppl+tfH7XwEoBh4HTgI7ADmAouAt4DR9M554vkoyuBGE9wE3A3UAQVAEfAPsDRAZ6npXBnAewH4Dhgfe0hHLuagD1ULnAE8gz5eOzAfRb3ZaC5nAycBx/ZncJoJvxLA2wL8BOQF8Nab3tQAXsKBZVGjGQFoATY472XA38CrDu1S4BdgVByDVWhyb/DoU9DueixErwPYT3he7AC+ArLjOHGE4mQ0txc6tFKjnefQ7gLejjJWTt+46T7TgPvs98We3v396F3tyC032sIYAxsKlFj/DcAVaEJ+Bg4B7wEXDdJ+ObAZ2Ity0A4UUdwFmvg4Rzm0m4GPPVvN5me/KEG5qhv4037XoYnORhXLXyQXG4uAdeZIi6NXB5ziyC0wmZVRjgwRqq3/DjSOZuABFIp6UF45dQB2s1Ee6kEfaQ2wCthutKcc2XIU/nLtPR/YDWzzbH4JLAnqzI+R2Sis7QRmOPRxaDV2ANMD7FQCa619PGRg+Sj/bUU5rT/cAhwTIeOiDXgxQuZJoALlhjLgHYfXANQADwK3pdAvwCPATSgC3YkWA6jaewNthDOBT4HTgS9QIdcI1AMTgcmomt5pul3AS2bzAJq3QExHq2KdR59i9C0heo8avyhicAfRiopCF+FhNujx/Q1Cm8leE8CbYbyXY9hxMQfl9bDFUml2KxzaMuB7FIob0cJ8F1XRCVwFfGO2V7sGc7wOZlr7gUefYO2PIY7NRGE06rywDzgxQgZgUgyZVDAWKAR2oUny8YO1o1O0W4Oi1AGUAnycZa0bye6xx0WJ995IsJ9JeAitiAs8+jlGbw7QyUE7py2G/X0o5A43ipD/YeH6fOM/4dCqgE60E7aRPCegfB8nAiwY9AgMQTush+TJ77Z2AskoREnU35U+stD274zhV7pzWCJydIXwy6xNhPzFaPFWoVx3I6oAC4GvTSYXOAHdTsxPwde0YRRKyNtDeN0o9vq4Fn3kmgj7BSbXFMOXLtKbwxI5tj6AdxwqxXfRW721krwbdwD3Ou95ZvOT6OEMDaaaAxtC+M8Zf7JHv9Xo10XYrzC56kH4OFBstb476XssGY9udHqAy4w2BlV6l3s2VgNverR2T9fHXNJ8UeCGxLCCI4EmdI5YSG/5Cb1niBUoyf6GVt2znn4pOoME5cGhRI751Y6OFh+iknkscAkqq2uB503+eDTJezw7e0jORbej+9Ym4DWznYVuNGahImYgZ7tYqKf/BDkGleStAbxqFEoPmY0VHj8fFSZRZ6WhwNnIpzXosnUzCv370SSXevITCS68lgOfBdgvRtFnN6qU96JqeS3Jt0LDjlo0mHNT1KsheBKGA4lQXBlTPpWQ+J9HLrrA3ZiCTh7wLVqFhwMPow9WnIJOK8mX3J/Tt+j432AeCg9x/8AsQIfKSUPkTxRa0I7JjRJ0sBhd4C5B/q8CfgVOS7t3GfRBFppo/zY8DqrQ8eJ3VFjNS59bGWSQQQYZZDDy8C9a0VmfQqaHZQAAAABJRU5ErkJggg==\n",
+      "text/latex": [
+       "$$f{\\left (t \\right )} = p_{0} e^{\\alpha t}$$"
+      ],
+      "text/plain": [
+       "           α⋅t\n",
+       "f(t) = p₀⋅ℯ   "
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "particular = solution_eq.subs(C1, p_0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the next example, we have to work a little harder to find the particular solution."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Solving the quadratic growth equation \n",
+    "\n",
+    "We'll use the (r, K) parameterization, so we'll need two more symbols:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "r, K = symbols('r K')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can write the differential equation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/latex": [
+       "$$\\frac{d}{d t} f{\\left (t \\right )} = r \\left(1 - \\frac{1}{K} f{\\left (t \\right )}\\right) f{\\left (t \\right )}$$"
+      ],
+      "text/plain": [
+       "d            ⎛    f(t)⎞     \n",
+       "──(f(t)) = r⋅⎜1 - ────⎟⋅f(t)\n",
+       "dt           ⎝     K  ⎠     "
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eq2 = Eq(diff(f(t), t), r * f(t) * (1 - f(t)/K))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And solve it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/latex": [
+       "$$f{\\left (t \\right )} = \\frac{K e^{C_{1} K + r t}}{e^{C_{1} K + r t} - 1}$$"
+      ],
+      "text/plain": [
+       "           C₁⋅K + r⋅t \n",
+       "        K⋅ℯ           \n",
+       "f(t) = ───────────────\n",
+       "        C₁⋅K + r⋅t    \n",
+       "       ℯ           - 1"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "solution_eq = dsolve(eq2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The result, `solution_eq`, contains `rhs`, which is the right-hand side of the solution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEwAAAAmCAYAAABu+H0XAAAABHNCSVQICAgIfAhkiAAAA1xJREFUaIHt2EloXVUcx/GPA3ZhonHAhRhNqitJtGI3KuoTKUXBWrUbhS4q1a1QB9SFFgS1CkFEpYjTQqUOXUgXokRxJVEconEAW2lSsDi2daAqCLr430dvXt+dkvfSPHO/cOCec//n3P/7n3P+57wfNT3BenyEKXyJDRl2t+Hh5LkPb+HBDvkwhGurdjq6Qx+vwgbciqsxikvxb4btiAjqaXgHO3Bvhm0Dm0v6cAxW49yS9keMPszg9JL2E7gOX2BdgW1DfsB2YAs+wP3Yh52YxAkl/anMu3ippe0WHMTdJfrfjNdLfuso/Ia9IhhFNOQHbDduT9Xfw3BJX+bMfmxKnpfhGfyMVSX7j+G+jHdDeA7bkvowvhEr4oacMcfFKtmF75PnyWS8Jv34TkxCk+mWesc5W+SayzGID/FJi2NwhliF+3AA20UOggcU55lmwK7BqyJwM1he0K+RM/ZFeK3Fx4mC8dpSJelfKAJ2sgjU17hEzFST5fgYe5J3DZyKp5L3b+LGpI2Y+fUZ3xsVuWs37sQrOK6Cv2lG8HmqPii2elfZgn+SckeGzdsOP/ZXi63cZKNwfiopG1vsmyvsZVyfan8aj+X415C9wh43+wpxopjYKTExXWFc3INmxI9p5SyxAg/ij1T5Ez+UGH8AW0Uu2lRg2xP8Ik6Z8/C7w2dzjchZ57Qpgwvm5SJhWKyeK5L6GrE1b0rZXJW09S+sa4uTdSJgA6m2u/AXLk7qJ+EnvIELxKm6Ck/q8vG9GHkI37Zpfx4/OnQBXCkutwfEtp1U7kJbU1NTU7MANE+vLD2qpgP0rFraCaoqrrVaWoElp5bOl/+7WnqZmJi9Yte0neRjKwzYqinlMSTUz/04JcduXGhjfUlZm7SvdUhn6xc62FjL+NM6y/H4TPx72V6201zV0iGz5eVFqZZWIHOFpZP+fNTSabFlm/S8WppFOmBb8SzuEfLzpLgGXJm8fx+Pij/XU0l9Wca4IyJgxEr7FI/M0cdRswP2lRAru6qWFjFftbTJtmKTrrNZ/Ja80igYozDpn49fhTzTyt8lnBwQl9SVQl4eyzfvKk8onrg98/1IrZbOpjDpT4grwIuWrlrahxVJIU7+FTgzq8NSV0sb2ue7F46cSzU1NTU1Nb3Ef+4g77VKodtEAAAAAElFTkSuQmCC\n",
+      "text/latex": [
+       "$$\\frac{K e^{C_{1} K + r t}}{e^{C_{1} K + r t} - 1}$$"
+      ],
+      "text/plain": [
+       "    C₁⋅K + r⋅t \n",
+       " K⋅ℯ           \n",
+       "───────────────\n",
+       " C₁⋅K + r⋅t    \n",
+       "ℯ           - 1"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "general = solution_eq.rhs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can evaluate the right-hand side at $t=0$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAADgAAAAmCAYAAACRWlj1AAAABHNCSVQICAgIfAhkiAAAArRJREFUaIHt2EtoXFUcx/FPRCpoArFKF9JomriMWtusLJR0UUoXTR9k0SoFI3FXKFiVrkpAULsJXdRSKqiLtkRpF0Wh9EE2blJQUaN0UzFJQdpK1VpbLQjp4pybTCYzmXszmcmD+4XD3HPu/9zzO/e85nfJqQl78Q1G8DN6y8Ttx4fxuhEX8H7N1VVJL77GqphfidfLxH6M12LsFeyrtbhqacQYnkkZP4yd+Ak9tRJVyBBOFZW9ifs4mKL+GziTsq0G/I3f0JWyzgwezRj/Mr6K14/hI+zAdlxKUb8DP5a514pDeBy7Y/4G/sRTGXVO8kiG2HY041u0COtoHTpN79xqYZT/wF84a2q93ZulzVFhhBM68L3Q2QG0ZdA6SZYOrseEsCl8h6vYEIUltAkvYDze68LTOBbvn8eeWAZNwo5aiheEtfcr3sHnWJFBb2YO4/+Y3i4Tc9HMbXyLMM0S+oRpOhJTX1H8YPw9jV0F5SdwJLPqDFwWzqGx2HgxzwkjfB//FKR/cTPF85txHNfw1jzozcxtHMCLuIv+ovvdwpp7vkRqqZvKObJGGJ1NMd8tTNVXC2K2xrKm+kqbH3qEDjYXlL2L//BKzD+J33FOOE7asVk4ShrqpnSOfIBfSpR/ilvCCBOOjCFhqt4Vtvk0fwBycnKWKcnuNrGgKhYZuRuP5G58sVF3N16BjfgytjGhzEvM4gdnc+PFtApu/Loq3HgFnsAPMk792dz4e2Y6iIRWfGLKy23DF8JfuDFzdOMZSDWC1bjxUdM/N9TdjadhKbvxsiOYUK0bTxisHDKD/tj2bKmrwjPKdjD5bPgS7gh2p5gHKUQ2C4d6p/C5YSBFnYSjKr+Y8QzPK8mSduNSbDLDwlo7aem48UasjYmwk6/Fs+UqLDU33qX0ev1s4STl5OTkLDceAi6OuqcmyqrHAAAAAElFTkSuQmCC\n",
+      "text/latex": [
+       "$$\\frac{K e^{C_{1} K}}{e^{C_{1} K} - 1}$$"
+      ],
+      "text/plain": [
+       "    C₁⋅K \n",
+       " K⋅ℯ     \n",
+       "─────────\n",
+       " C₁⋅K    \n",
+       "ℯ     - 1"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "at_0 = general.subs(t, 0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we want to find the value of `C1` that makes `f(0) = p_0`.\n",
+    "\n",
+    "So we'll create the equation `at_0 = p_0` and solve for `C1`.  Because this is just an algebraic identity, not a differential equation, we use `solve`, not `dsolve`.\n",
+    "\n",
+    "The result from `solve` is a list of solutions.  In this case, [we have reason to expect only one solution](https://en.wikipedia.org/wiki/Picard%E2%80%93Lindel%C3%B6f_theorem), but we still get a list, so we have to use the bracket operator, `[0]`, to select the first one."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(list, 1)"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "solutions = solve(Eq(at_0, p_0), C1)\n",
+    "type(solutions), len(solutions)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/latex": [
+       "$$\\frac{1}{K} \\log{\\left (- \\frac{p_{0}}{K - p_{0}} \\right )}$$"
+      ],
+      "text/plain": [
+       "   ⎛ -p₀  ⎞\n",
+       "log⎜──────⎟\n",
+       "   ⎝K - p₀⎠\n",
+       "───────────\n",
+       "     K     "
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "value_of_C1 = solutions[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now in the general solution, we want to replace `C1` with the value of `C1` we just figured out."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/latex": [
+       "$$- \\frac{K p_{0} e^{r t}}{\\left(K - p_{0}\\right) \\left(- \\frac{p_{0} e^{r t}}{K - p_{0}} - 1\\right)}$$"
+      ],
+      "text/plain": [
+       "             r⋅t        \n",
+       "      -K⋅p₀⋅ℯ           \n",
+       "────────────────────────\n",
+       "         ⎛      r⋅t    ⎞\n",
+       "         ⎜  p₀⋅ℯ       ⎟\n",
+       "(K - p₀)⋅⎜- ─────── - 1⎟\n",
+       "         ⎝   K - p₀    ⎠"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "particular = general.subs(C1, value_of_C1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The result is complicated, but SymPy provides a method that tries to simplify it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAF8AAAArCAYAAAAe/1QiAAAABHNCSVQICAgIfAhkiAAABAZJREFUaIHt2luIVVUYwPHflNB0kS5EUDnkpFBEhTYWdLcHEaOmF3uonnsoqMAyooLmpcB6E42gCCGt6H6BoAsVSCSBJUaGKV28BJXaxTLLwB6+dWb2OZ4z58ycPWef4+w/LPbZa6+91v6+tde3vrO/j5LZuKmIgY8pYtAu4lgsxgVFDN5XxKAF8za2YCHewT3Yi79wDf4o7Mk6wIdYV1N3Ow7ggQ6M/x3uzZx/jMEOjNsV/Ipl6fdxeAZ7sKgDY8/EbtUr/nvTxALMwWFciwF8hs/Fplfh9NRmGT4VZuAbrU/OLLGy9uE3vIoz0rXL8XJN2w0TFyMfOr3hDgnFniaU/jWuFG9fhfnpeCcexgJsFgrtb9L/udiIHanfhWIyn0zXL0x9VRjAj5MRpBdZgf9Sua9Bm+U4hLmZuvPEpF3UpP/38FhN3WJh6mClarfyZDFZX7bQd8/zAd7FD3i+QZt1eKWmblC18q/HVmwTKwTOSW0O4M9M+Rs/5fP4vc1e4WlcjP0YqdPmK2FustwsXMF+zBBKH8AJwm08E8PCxs+tUwbyFaP3qLy916XzYWF+bs206U91I5m6PqzH0+n8CryZuf6ocFWXpHtn5vzcRwVLhfJPydTdj4NCoXCpUOBWXIXzsRa7jHksS7Eq08cdYrJOxS9iYuYLz2oRVutSV7KT3s4QvhWmocLjeAFviJUxT5iUR/Ci8IhOxGX4Od1TT5GHxaa6RLz5H2ETnsDOdL2kCavxUpM2jcxOSZt84sjNtpYZ2C420ePFhnvWFD/XUU+f+Dc73ELbG8W/3u24ayofqqSkpKSkJA8qPnPpB5dMGbMVFCQfj+kQQC80SD4eXfnNIwemdZC8aHoySF50ZkEe9GyQfLKZBWvUD4wUQVcFyccju+HOEd/aN4qPVutxiQhgv5/jmFOZnUDnguTtylGl/FYyC/JgKrMTiDhvVvlbRHw37yB5O3IcQSuZBY1Yo3Wz00p2Qr0AOc2zEzpJO3IcQSuZBRUeVJ0hcAj/1tRd3eDeZtkJjQLkU5WdMJL6Ha8szFGOUWZkfs8Xb9VyEdQY0fhtfkp1xGmF8DBWZup2N7h3nggdZlkglLpNhAy3iPAfvI4bhIJ/T21r+afBWK2wSoQsx2NHnbrJylFJBBhV/qAxW78Zt+E1sYHUWwX7UqmwP51vbyJEv1ia2Unvw91pnIMiKrUzc30Xzk7Hk8Qk7G8yzkTYk8pEaEeOUSob7lA6fpGObwnT8qyxzII8qNjCW4xlJzwnJv+hdK1RgHyDsO1rFZ+d0I4co2SV3yyzIA9ayU7YrTrJaZZwFbspO6EdOQqjleyEXgiQ96QcrWQn0P0B8p6TYyLZCd3M0SJHSUlJSUnJ9OB/T/VHI1A8cC0AAAAASUVORK5CYII=\n",
+      "text/latex": [
+       "$$\\frac{K p_{0} e^{r t}}{K + p_{0} e^{r t} - p_{0}}$$"
+      ],
+      "text/plain": [
+       "         r⋅t    \n",
+       "   K⋅p₀⋅ℯ       \n",
+       "────────────────\n",
+       "        r⋅t     \n",
+       "K + p₀⋅ℯ    - p₀"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "particular = simplify(particular)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Often simplicity is in the eye of the beholder, but that's about as simple as this expression gets.\n",
+    "\n",
+    "Just to double-check, we can evaluate it at `t=0` and confirm that we get `p_0`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABcAAAATCAYAAAB7u5a2AAAABHNCSVQICAgIfAhkiAAAAW1JREFUOI3t0z9IlWEUx/FPJhYkKNogBTk5BJGgtZQGLa0txaXBQTCHCJrDXUEcxIigyNExyMFAWyIaDIKKQNBBkRZHUygtsOE5F14e3yvcKzR1lodzfuf5Pn/OOfxDu4YDzOAe3mMbv/ARN48DfxjwFfzBa0xiKeI/caFR+GxAtjGQaTOhTTUK/xyAoRLtcmgLjYBPYR+baCrRzwd8qRB7gHWpJp8wWAt+JTa/qKFfD/1l+BX8xn1clL5tV42ajMbmsRrw8dAr4S+XXGQNE1Wn+Py+WNtLwB1x+Hepg1rQj8Usb1Fq50Pw/ljv4Ewh3oo5dOKR9L9ncRJbGXwLXVWnubBewhe04SvmpSLfxjk8xqsMdpD5J0pieiP4DD14gx/YwVvcyvJbpCG7m8Wf4l0OHw74aC4cYct4nsVWFQpatScBv1oHvCLNxYjUitNSK3bniR+kZ56uA04aog3sSUN0I09oihO/1Qn+b43ZX76kUtnv3K5vAAAAAElFTkSuQmCC\n",
+      "text/latex": [
+       "$$p_{0}$$"
+      ],
+      "text/plain": [
+       "p₀"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "particular.subs(t, 0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This solution is called the [logistic function](https://en.wikipedia.org/wiki/Population_growth#Logistic_equation).\n",
+    "\n",
+    "In some places you'll see it written in a different form:\n",
+    "\n",
+    "$f(t) = \\frac{K}{1 + A e^{-rt}}$\n",
+    "\n",
+    "where $A = (K - p_0) / p_0$.\n",
+    "\n",
+    "We can use SymPy to confirm that these two forms are equivalent.  First we represent the alternative version of the logistic function:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGkAAAAXCAYAAAAIqmGLAAAABHNCSVQICAgIfAhkiAAAA/1JREFUaIHt2X+o3WMcB/DX7mbubWurkVsKE5YNW2KSWC2ilELpRijRykyJf/woUwqZYlt+NKE0+cOYHzFGtDay60cTNaYZFhY2xphruP74PKfz3fc+59x77rnn3K3uu07fez7v5/l83vf5Ps/n+TzPYQwHLZ7Gj5g02kJGCaehH9eOtpBaOB3/4eYM96YQPz/DdePtxK/BtFYJbBNW4wdMHqRdN/7FspYrKmAtfkVXhtspXuCUkv1sfCfE3oWOFuprF84QE+72QdotUHvitgQzxEtYkeGOS2K+KNlvwT78jAtaqq792IxvML5OmzXif6/XZkRxn3gR52a4nsStTN+n4IVk24ij2yEwg7OShmW4HOuxG3+hV3MzfHHyXWvyTUUfnmqjJh/iH/mCYUkKfBNmY0v6/igmNhO0SSxKOjYL7S/hftX9c6/hT6Dzko8HavBXJP6idmmalBx+WoN/JwVYgT/xB64cTqARxpNC126xNxaxTP1BHgxTU//eGvxz2IPOdmmakTqvzXDjRDHRnz57cPJwgrQAm4SmqzLc7MS91oT/vdiRsXfid/GiWqqpWIUdlp6/ZNrNELNqCz4Wq+7ioQYp4GvVFz2Uz8qslyoOxSxsxzMZfmd6HlKyL8Q2sUd8hHPqxNiFwzP280V5vnoENNXVM6Hw9970LC9d4uwE74mStBd3J8c5IbWwNQkZKr4fhD9F/LNviKq0jOnp+W3B1oOlYmA24HpRoc0qtaugS3VsirgEf+PVJjU1pOdIMXs3ZBw/mLhF6fscsdT7MC/Tvl2onFHuqMHfk/iegm0jHi+1+xL3Zvp3iIHeWrKPF2X3mhHQ1Ige48RV0E8Zbn1yfGbBdqEoNHbhxBqCWo3HhK4lGW6aGMjtqtlhotB8Wantw1iX8TEz+X++ZJ+f7Aua1NSoHrAqBTi+YOsQq2afgbcQlVLzKxxRy2kL8UGKv83+x4bJeD1xlxbslWxRXv13GnhIh2vsn0EqWC5uV7qb1NSoHsTBqx83FGwnJdsnNfosTfz78ldJrcIEsVdsEgOyVaTlR8QVVT9uLfWpDEq5UFiMzzMxnhUz/aiSfbvILs1qalQPYvntEHmygquToydq9OnAy6ppoV33dnNUD9MniP3hN7Hq3xLVVxmNpJepYsBfLNnnpri5C+hGNQ0r3cFtKdCp9RodAKikoty+UA8bDbyb3GLgRn2j/CyvbPzHjpCmoerZD53iUvGVBgKNBpaLAZnbYL8eUTpfJwqDh8Th/JhCmy5R/q/K9N8s0tlIaRqKnizmibx4IP/o965IFblz3WBYKA7WfeLwWN64Z4qfXKa3SdNgeg5KdIjZ9tloCyngQNQ0hjGMYQwHE/4HOhxUXaqk7yMAAAAASUVORK5CYII=\n",
+      "text/latex": [
+       "$$\\frac{1}{p_{0}} \\left(K - p_{0}\\right)$$"
+      ],
+      "text/plain": [
+       "K - p₀\n",
+       "──────\n",
+       "  p₀  "
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A = (K - p_0) / p_0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAH8AAAAkCAYAAACg9OUnAAAABHNCSVQICAgIfAhkiAAABGVJREFUeJzt2luIVlUUwPHfpJCaZkkFlVOa3VHRNKOb2UNIkU6IQZeXXurBygdLiQqUiMJ8CCSjSLpQVnQ3CTK6vUhaZKFhlFamGVleKsssA3tY+8szZ2ac+Wa+7zuMc/5w+M5e55y91/rW3nutc/ampKSP8T6W5WQ3Yy/uarw6JY1kN+ak8yOxFDtwRWEalTSEUTiAy9CMj7EWIwrUqRCOKFqBApggnD9MOP1LXIzNBepU0iAW4t903FmwLoXSV0f+e9iG8wrWpaTB7MQdGIs9WFCoNiUNY6SI95en8nQx/d9QmEYlDWOmcP4xGdk87MNFhWhU0jAexDftyJ/Cz2JmKCkpKSkpORxpSr8HCtWipKSkpCQYgZZ6NtAXP+/2BvphKs4tWpF6cCy2i+XV3sQrDu4DqDUrxKLTGszHLmzE5zi6Tm3+z+SkwI8iAZxZx7YW4ZmcrDfsrhkrnDK0DnV/J9YcKnyo/Y9OS/FwrRu/Evdjhuqd/7SuL5AMwq+4NCfvLbtrPsWt3Xjuiw6OkzBErDI2Ze7fnCsTYfonTOlG+12mns6/VoyerGGN2l1zXGpnDj7C7/hadR1sPlblZMPFrLVLdOxXcUIVdV6Il3P1re7gvp3on8o9sqeIhO8SMXqy3xYatbtmfPqdhXsxEeuE4wZ0sY41OB8DU/k0Yc8WofMU4ZRHq9BrdNKjQrMIv3la8JZYiaQ29rShniN/ubbxvlG7a+ZiP07PyM4S9o5J5avwlUi2ZrVTx9h0fyVZfQcP5O6ZKsJYV1ms9WvdUNGh1mf0IgbFjEy5Fva0oTPn340/Msd+/JOT5WN6hZV4PCd7N8m/x/Nd0G9B0vFQx5R2nlsmMvYslTX+MWI63ShG3iBswIm5+89I94/Gqel8r9a2/yXeZmrJmaneozKyHtnTX/d4DC9lygtFwrI4I9vWwbM7xKtelvFi9MwV8XSBQ88kj+DFTnTc0o5sHF7IySYK523EJPEHbU3XXsfVeCJz/7D0+wsuwG+pjjx/d6JftbSI7Wd/ZmQ9sqe7zt+Vjgp7UnlTF579DDdlyiMdjPXrcCNeE4lLR7PAjnRUwwAxJWZtbsLs1M4+kXlvzVz/ASfn6hkj4vF2MeMNTud7qtSnWlpEeK3QY3uyCd9g0ZPGpfKIdH5KLTTPsBLniKSISPaITgFvirDypNrurqnEwOtF0nk2nhWd7550Lf9qRdtFr8l4O52vFrH9OTF7jRKZ9pIO6uoux4tZZkVG1mN7ss6fKBxQccKidH5fDxXPs15kzNel8gR8K16RKjwkprM31G53zTgxFc4XIWOtiJ+TxC4eIlQ1Z54ZrnXWPRDXOBgGdovvI0Pwgfgat0iMtlqulE7DJ1rnEbWwpxCmimm9XwPbXKJ1ntIe/UXoahaO3iCmzgq3iey+0SwXew2z1MKewpgtsuVGsUq8C3fGNNExN+H23LVbRJxtNPO0HsHUxp4+QZP4+jW9aEVqxOFmT0lJSUlJSUkd+Q+zli1qrpo/4AAAAABJRU5ErkJggg==\n",
+      "text/latex": [
+       "$$\\frac{K}{1 + \\frac{1}{p_{0}} \\left(K - p_{0}\\right) e^{- r t}}$$"
+      ],
+      "text/plain": [
+       "        K         \n",
+       "──────────────────\n",
+       "              -r⋅t\n",
+       "    (K - p₀)⋅ℯ    \n",
+       "1 + ──────────────\n",
+       "          p₀      "
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "logistic = K / (1 + A * exp(-r*t))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To see whether two expressions are equivalent, we can check whether their difference simplifies to 0."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAABHNCSVQICAgIfAhkiAAAAM5JREFUOI3N0rEyQ0EUxvEfJcMVWhoZ8Qpq75PnoDJ0Kl5BK0U67yAUiUYmpZGYoRDNuePOkXszYxS+5ps95/x3Z3c//lC7uMIz3jHCOVpNUBsTzHGDU/RjfY+dOvA2hrqpfhb1y0XQfjSHWE29DUwxw7o0cBzew2cCX3GHNRxl8DD8oeYaj+GdDBbhLzVgWd/K4DKthM8zWO5YWKzN6lwVHIR3asCD8B9v0Lb8O97Ed2T9KgDlqdXInfiO3EBD5GAP1xjjA0+4wHYT9I/1BRgnMa7SDNsAAAAAAElFTkSuQmCC\n",
+      "text/latex": [
+       "$$0$$"
+      ],
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "simplify(particular - logistic)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This test only works one way: if SymPy says the difference reduces to 0, the expressions are definitely equivalent (and not just numerically close).\n",
+    "\n",
+    "But if SymPy can't find a way to simplify the result to 0, that doesn't necessarily mean there isn't one.  Testing whether two expressions are equivalent is a surprisingly hard problem; in fact, there is no algorithm that can solve it in general."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercises\n",
+    "\n",
+    "**Exercise:** Solve the quadratic growth equation using the alternative parameterization\n",
+    "\n",
+    "$\\frac{df(t)}{dt} = \\alpha f(t) + \\beta f^2(t) $"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "alpha, beta = symbols('alpha beta')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/latex": [
+       "$$\\frac{d}{d t} f{\\left (t \\right )} = \\alpha f{\\left (t \\right )} + \\beta f^{2}{\\left (t \\right )}$$"
+      ],
+      "text/plain": [
+       "d                      2   \n",
+       "──(f(t)) = α⋅f(t) + β⋅f (t)\n",
+       "dt                         "
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eqEx1 = Eq(diff(f(t), t), alpha * f(t) + beta*f(t)**2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/latex": [
+       "$$f{\\left (t \\right )} = - \\frac{\\alpha e^{\\alpha \\left(C_{1} + t\\right)}}{\\beta \\left(e^{\\alpha \\left(C_{1} + t\\right)} - 1\\right)}$$"
+      ],
+      "text/plain": [
+       "             α⋅(C₁ + t)   \n",
+       "         -α⋅ℯ             \n",
+       "f(t) = ───────────────────\n",
+       "         ⎛ α⋅(C₁ + t)    ⎞\n",
+       "       β⋅⎝ℯ           - 1⎠"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "solution_eqEx1 = dsolve(eqEx1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHQAAAApCAYAAADkig0OAAAABHNCSVQICAgIfAhkiAAABX1JREFUeJzt23mMXWMYx/FPFV2UFo2lWkaJ2Fojiopi/kBDRZuQWoIoRSOEiITYIkQlmogIQoJYKmlsUVstJbU1bWNto7EUg6il6FRRe/3xnGvO3LnrzLntzTjf5OTe857nvu+Z877v8z7vc35DTk4fYAheQr9U2el4E8vwPqZl2F4LJmNbPJthvd3YpJGVNzFn42GsT86n4VwcizE4LHWtGm24torNROyNH/AVDqnrbnP+Y3+8ghU4D49gRyzGDonNEHyOET1so03lDj0CP+JjvIvjcWsP2/pfMxgfYQ8Mx5e4A5uLDixwFh7tRTttqs/QBdg1+T5CuPaGsGmjKm4CjsJrolNhe8wSnduRstsXS8vU0YJrxOA4ueja/KSuIckxJSmfgvYS9RTKVgkv0RCadQ09EC9jnXBVEzAVr6ZsRuIh4c468Bi2S13fD28n3/fCW/gsqXNAyu4X5Z9Du5jBpTgSrZiOO5Pvrbp35kh8o3NNHoDfytTZa5qxQw8WHfcixgr3dB2uxNWJzWjRQV/gUOH2hguXWuBP4d764XrhamF18r3gnebhlOT3sKWIeLNiFFamznfH8gzrb3rewJzU+ST8LTq4wAuYWfS7iaKzCowSM/RDnCm2KZck1+4VA6HAdOF2lyXH9KK65yhPm8pr6FAx+JaJCPoinF/Bvk+xk3BNbamyo5Oy8cn5Lsn5r/g5dazDtzW2cxDuqsFumHCnK3QOht7yMrbOqK5uNFtQtE/yuSRVtpfY6C9KzvfDGowr8fvfa2xniQiG+qm83+zAjBrrrIVtxZZldTXDvsIJwr0OTM6HioDirZTNMfhLrHU5Tc5oMWOux554SnTmGhFMEO5qFeaKxMFuYotyu66pvJwm4QrRYb+JbckwLMTXKZtxYi3qwFqRgbl8w95mTs5GoF24vFqP2RvlLnPKUhzlfqK+LMbK6iY5OTk9JquosNZ3hzk5VdlY6gM2gAKhXpoxOV8vWaoPqJ6bLagPyBUIvWJDqA+o3KHF6oOtcJw+rkA4Rbi6X8UfPrXo+tYiib5bHXVuKPUB1WfoAp3qAxqsQKjAo7J7YVCWSaIjTxdpvJkibdc/ZTML99dZ72Tckzr/QzzUEXgvVX6zUBj0hPli1q0Q+eN3k6OlyK5d1/V6M+F2s+RwkfZcKZaLE0vYjBXeYmi6MOs19FLcggfxKZ4WSfR/kuuDcQ7urrPeLNQHLeI9aLl3m7UoEIrVBzRGgbCFGKgXVLBZKp7BaenCLDt0kAhAnkmVTUxurPAAJonOfb3E7ytJSrJQH7QrLyeplWL1AY1RIMzDVXi8it2TODVdkGWHjhUP/D3RuWfgMtyUspkgZldx1FlNUjJbvDb7QMz6Dp3rxwIhWyGS+LNE4n5Zcp6ewb1luXjBXlAfEIHSvAzbqIfFQn81qBGVzxAPfJyYhevxnK7pxblKr5+1SErKUav6oEAlOUlPaKgCQfk1lJhE66UCzCxnaCveERqe8cL/jxczpsBA3debXcT7zIt1lZQ8IYKfaiwRI7Va1qsgJxknu+iwkgLhWtVfbrT1sv11yed/MzRLCcr+Yt1bKx7yEhGITEjZfK/7aM5CUnJvDTZZy0mIxMITZa7dpro3+KKX7W+TfK4qFGTVof3FmnJDUXmrEDsXeEco8NL8KRIC34rB0Ff4PjkayRgRpNUqjquZvYULWYQDRALgRjGCW4pu4G+dUSi5pKQUQ3Rum9aL7WArdi6ye0DX/XlmnCr2Z8+L9e87EVKPLWG7UPf9VS4p6Uqb0mvufSmbQfhJp7w1U2aJzEYtTBRpvP7VDHMqcoHYHXQhqyi3Vfl/+CnmeREwjMyo7f8rf+DCRlW+Cic1qvKcnJycnJycnJycuvgX+i5oEd8nttEAAAAASUVORK5CYII=\n",
+      "text/latex": [
+       "$$- \\frac{\\alpha e^{\\alpha \\left(C_{1} + t\\right)}}{\\beta \\left(e^{\\alpha \\left(C_{1} + t\\right)} - 1\\right)}$$"
+      ],
+      "text/plain": [
+       "      α⋅(C₁ + t)   \n",
+       "  -α⋅ℯ             \n",
+       "───────────────────\n",
+       "  ⎛ α⋅(C₁ + t)    ⎞\n",
+       "β⋅⎝ℯ           - 1⎠"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "generalEx1 = solution_eqEx1.rhs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAF0AAAApCAYAAABXwiUUAAAABHNCSVQICAgIfAhkiAAABBlJREFUaIHt2luIVVUcx/FPTQSK4oUoKivTiiwdlexCWcxLScxDEGEoGBlCQvYiQfeILIuEeqmwh6KiKMgCizCLkm5i0s0kKCuajCwbqzFNS1F7+O9h9mzPnMvMPmfOsf2FzTl77f9ea+3/Wfu//mv9DgUFdWABPsFmfIWFw9udI5+F+ADHJ+fjcf2w9eZ/wCj8iJOqtJ+J9/AdbsTLOLE+XTtyuQGrqrQdiS04C8fhJzxRp345ul4VNwFT8eUA1ybiabyUnF8uwtAW7MAJWFGvjjWr08/Hu9iLbzEbc/F+ymYCXsAf6MEr+mI3/G3g5+sSb0Iv0/FZ8n0KPsUPQ3mAcjSj0y8Uzn0b7SLzuA934u7EZpJwzFZcgg4RFtIhYQ3mJeUwWmQypdgvYv9RWIZjc3mSFuIjfa89dOKA+BF6eQvLM/fNwZ+ZskUixGxOjkWZ673tnCJG+jciu3kHSwfV+xbkZBwSI7eXK5Kyi5Lz05LzPdidOvZie5XtjMVKkak03LnHNLrBCpybfG5MlU0Ri5oNyfl07MSsEvf/W2U7PVg8mA7mQbM5fTQOJgeMwe34OWWzX+Tg27Grob07QpkkQscynI3XxYS5E2ckNuPQjdViQTNZpHyPi4mwYBDcIZz6j0gJx2I9fknZzBIpZY8Y7V/gtsZ2s6Cl6RKvd7XH88PSyxYnO5F+L17ratmWY18KCupHXrP9oZzqKWhCChWowRQqUBnmiZG4R2zLzs1cHydWk5NrqLMVVaBVGrSv0ymcvUCsLpeL1WRbymYFnq2x3mZTgS4Tq+VtYj67poRNu9jrH5Nz24exTv8t14vFPkrvhD1SrCIvrbHeR3BPlbZX4anU+T6cXmN7lbgS9+NqAzud2MK4KVuYp4gxQjjzjVTZHGzSl910ih/hwxL3l1OCyqlAE/WX3hqhAq3BXXi1gt1rmJ8tzNPp7WJEbxI/wHW4FQ+nbGYLJ2RTzEpKUDkVqEt/6a2ZVKCPhfQ4ol4NLMbXYjPqoHDsm/qvelcrHc+rUYKaVQUqF17ak+u1JA01sRIvilF4gYhlPXg0ZbMWT2buy0MJor/EVy33qry/1FGhjnJOPzO5PjVdmKeIMVPE4V1C+dko4u3slM0OkTKmGaoSNBYPJfcvFZNutTym8o+1tYb6soxPPrvThXk5vQ3T8ECmfIZY0PTyucMXNENVgoYive1IjnoxTaSVtbyxVXOOeI024DyRIz+I38VoT3figL4JkdZUgkaJATVDPPctyfdTM3bP6Z++5sp8/Cpi9m78JtKl9hK267EkU9ZqSlCH0vH/mZTNCPyl718MubNCrNCqYY5YMbZVMmxxlois7DDyytNnGPh/g1nWiglsQk5tNyv7cHM9G+jGtfVsoKCgoKCgoKCgYLj4DyA2FyVLUBUMAAAAAElFTkSuQmCC\n",
+      "text/latex": [
+       "$$- \\frac{\\alpha e^{C_{1} \\alpha}}{\\beta \\left(e^{C_{1} \\alpha} - 1\\right)}$$"
+      ],
+      "text/plain": [
+       "      C₁⋅α   \n",
+       "  -α⋅ℯ       \n",
+       "─────────────\n",
+       "  ⎛ C₁⋅α    ⎞\n",
+       "β⋅⎝ℯ     - 1⎠"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "at_0Ex1 = generalEx1.subs(t, 0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "'Equality' object is not callable",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-35-2c015eb64891>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msolutionEx1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msolve\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0meqEx1\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mat_0Ex1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mp_0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mC1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;31mTypeError\u001b[0m: 'Equality' object is not callable"
+     ]
+    }
+   ],
+   "source": [
+    "solutionEx1 = solve(eqEx1(at_0Ex1, p_0), C1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFwAAAAXCAYAAACGcCj3AAAABHNCSVQICAgIfAhkiAAAA5NJREFUaIHt2EtoXUUYB/BfUq2NiaQ+8a2L2lqo1loVFQ0VpaIgLqwEF+KTLoIiFDe1C8VFrcWFRrSgUIsLX/guWEwFUesixWJ9FquiFmttRbEqxtjYuPgm5Ob03Nybk8e9gfuHy9z5XvOdOXO++c/QQF3gWexDa60TmaZYjEHcUY3xBTiIFZOZUZ3hLDyEbfgFB1L7DrpwZIGYr2EP2ioZ9uB3tBQYZLqhCQ+iX6zID7EOa/A8fk3yDwrEvij53jea0Vyxup8qMMB0xDNiUr7Awhx9C1YluyLYgR8wo5zBmpTAlTm6S5OuGzeJt74f/2ArriiYVK2wQjzPlziqgm3Rr/3+NMbV5Qw+woD8zfKu5Lwj2byBtdic5H04vWBiU42TRL4HsGASx7lKzM0jecpWMZGflXFen5z347KMrnu0wHWIh0W+6yd5nPY0ztY85dyk7CnjvD3pb87RnZt0b40/xynBVyLfqSiDffg5T3FJSuLFHN0R+Be70JyjPyX5bs7Iu/CdqPPbcHmhlCcWbSLXg8ZO9zqwET+lGMuq8NktKgdGTl5famflOJ2Dw/F2SjSLM1O7q0TWicewGosE5dqk9nX++NT+gb/H6NuKT8R+Vi1aDM/tCJws3tqWHN3ypFtVJujqpO8skfXi6Yzd1+KAUUucIHLtNwpdqwLVrPBmsUC/LRUMYY84Xc3LcTw/tbNzdMeIF/KjYC4wUxxvs/tBj6CXtcQ+fC9yXFLBNq98jgXzxOFqe17AQbyP4zAn47g4tcuMpIxteA7H4h5Rq6UYM7A3E2cvTszINqSxb632KSYAj6b2SZydo2/CNXhhnONcnNp3hwSHZQxewQ2CqH9TYrNA1K52fIo3xUZ6vShFK/FqzoCDmX5TjmzopQ+YOnQLZnW7oME92Cl4+WmC9p4qFtN4sBT/Gf7yD8FMQWF6S2QLxSStE5c8m8SG86e43FlaJs4AbszIn8B7GdnHKd7RVT7EROJaccm0W7Cw38Qx/yXcIr7ccqhUw9vFZvl6pSRWpmCLUv+21F9eyTGDXofeyew0ctOcLVbA2jHGrgdUmvC7k01FKjxLXLhsTP3Hk+OFY0yoU6yaOzFf1M2/cEaJzXWi7mfrer2iDeel3yDuTf+zVLdFcPWXqw3cIS5eWgV/HpDPzyuhSzCCfnHw6SgQo56wREx09rchYzcfDxg+n1SNZrEqPy+cYgMNNNBAA5OF/wGe5NSEo9DxQQAAAABJRU5ErkJggg==\n",
+      "text/latex": [
+       "$$\\left ( p_{0}, \\quad C_{1}\\right )$$"
+      ],
+      "text/plain": [
+       "(p₀, C₁)"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "p_0, C1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:**  Use [WolframAlpha](https://www.wolframalpha.com/) to solve the quadratic growth model, using either or both forms of parameterization:\n",
+    "\n",
+    "    df(t) / dt = alpha f(t) + beta f(t)^2\n",
+    "\n",
+    "or\n",
+    "\n",
+    "    df(t) / dt = r f(t) (1 - f(t)/K)\n",
+    "\n",
+    "Find the general solution and also the particular solution where `f(0) = p_0`."
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![image.png](attachment:image.png)"
+   ]
+  },
+  {
+   "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap11mneal.ipynb b/code/chap11mneal.ipynb
new file mode 100644
index 00000000..a7ed42b2
--- /dev/null
+++ b/code/chap11mneal.ipynb
@@ -0,0 +1,968 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 11\n",
+    "\n",
+    "Copyright 2017 Allen Downey\n",
+    "\n",
+    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "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.py module\n",
+    "from modsim import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### SIR implementation\n",
+    "\n",
+    "We'll use a `State` object to represent the number (or fraction) of people in each compartment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "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>S</th>\n",
+       "      <td>89</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>I</th>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>R</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "S    89\n",
+       "I     1\n",
+       "R     0\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "init = State(S=89, I=1, R=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To convert from number of people to fractions, we divide through by the total."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "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>S</th>\n",
+       "      <td>0.988889</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>I</th>\n",
+       "      <td>0.011111</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>R</th>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "S    0.988889\n",
+       "I    0.011111\n",
+       "R    0.000000\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "init /= sum(init)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`make_system` creates a `System` object with the given parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_system(beta, gamma):\n",
+    "    \"\"\"Make a system object for the SIR model.\n",
+    "    \n",
+    "    beta: contact rate in days\n",
+    "    gamma: recovery rate in days\n",
+    "    \n",
+    "    returns: System object\n",
+    "    \"\"\"\n",
+    "    init = State(S=89, I=1, R=0)\n",
+    "    init /= sum(init)\n",
+    "\n",
+    "    t0 = 0\n",
+    "    t_end = 7 * 14\n",
+    "\n",
+    "    return System(init=init, t0=t0, t_end=t_end,\n",
+    "                  beta=beta, gamma=gamma)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's an example with hypothetical values for `beta` and `gamma`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "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>init</th>\n",
+       "      <td>S    0.988889\n",
+       "I    0.011111\n",
+       "R    0.000000\n",
+       "dtyp...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t0</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>98</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>beta</th>\n",
+       "      <td>0.333333</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>gamma</th>\n",
+       "      <td>0.25</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "init     S    0.988889\n",
+       "I    0.011111\n",
+       "R    0.000000\n",
+       "dtyp...\n",
+       "t0                                                       0\n",
+       "t_end                                                   98\n",
+       "beta                                              0.333333\n",
+       "gamma                                                 0.25\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tc = 3      # time between contacts in days \n",
+    "tr = 4      # recovery time in days\n",
+    "\n",
+    "beta = 1 / tc      # contact rate in per day\n",
+    "gamma = 1 / tr     # recovery rate in per day\n",
+    "\n",
+    "system = make_system(beta, gamma)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The update function takes the state during the current time step and returns the state during the next time step."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_func(state, t, system):\n",
+    "    \"\"\"Update the SIR model.\n",
+    "    \n",
+    "    state: State with variables S, I, R\n",
+    "    t: time step\n",
+    "    system: System with beta and gamma\n",
+    "    \n",
+    "    returns: State object\n",
+    "    \"\"\"\n",
+    "    s, i, r = state\n",
+    "\n",
+    "    infected = system.beta * i * s    \n",
+    "    recovered = system.gamma * i\n",
+    "    \n",
+    "    s -= infected\n",
+    "    i += infected - recovered\n",
+    "    r += recovered\n",
+    "    \n",
+    "    return State(S=s, I=i, R=r)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To run a single time step, we call it like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "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>S</th>\n",
+       "      <td>0.985226</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>I</th>\n",
+       "      <td>0.011996</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>R</th>\n",
+       "      <td>0.002778</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "S    0.985226\n",
+       "I    0.011996\n",
+       "R    0.002778\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "state = update_func(init, 0, system)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can run a simulation by calling the update function for each time step."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(system, update_func):\n",
+    "    \"\"\"Runs a simulation of the system.\n",
+    "    \n",
+    "    system: System object\n",
+    "    update_func: function that updates state\n",
+    "    \n",
+    "    returns: State object for final state\n",
+    "    \"\"\"\n",
+    "    state = system.init\n",
+    "    \n",
+    "    for t in linrange(system.t0, system.t_end):\n",
+    "        state = update_func(state, t, system)\n",
+    "        \n",
+    "    return state"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The result is the state of the system at `t_end`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "scrolled": true
+   },
+   "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>S</th>\n",
+       "      <td>0.520568</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>I</th>\n",
+       "      <td>0.000666</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>R</th>\n",
+       "      <td>0.478766</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "S    0.520568\n",
+       "I    0.000666\n",
+       "R    0.478766\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "run_simulation(system, update_func)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise**  Suppose the time between contacts is 4 days and the recovery time is 5 days.  After 14 weeks, how many students, total, have been infected?\n",
+    "\n",
+    "Hint: what is the change in `S` between the beginning and the end of the simulation?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "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>S</th>\n",
+       "      <td>0.610171</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>I</th>\n",
+       "      <td>0.004672</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>R</th>\n",
+       "      <td>0.385157</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "S    0.610171\n",
+       "I    0.004672\n",
+       "R    0.385157\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Solution goes here\n",
+    "tc = 4      # time between contacts in days \n",
+    "tr = 5     # recovery time in days\n",
+    "\n",
+    "beta = 1 / tc      # contact rate in per day\n",
+    "gamma = 1 / tr     # recovery rate in per day\n",
+    "\n",
+    "system = make_system(beta, gamma)\n",
+    "\n",
+    "run_simulation(system, update_func) #total students infected is (I + R)*N = (1-S)*N; 35 students"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Using TimeSeries objects"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If we want to store the state of the system at each time step, we can use one `TimeSeries` object for each state variable."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(system, update_func):\n",
+    "    \"\"\"Runs a simulation of the system.\n",
+    "    \n",
+    "    Add three Series objects to the System: S, I, R\n",
+    "    \n",
+    "    system: System object\n",
+    "    update_func: function that updates state\n",
+    "    \"\"\"\n",
+    "    S = TimeSeries()\n",
+    "    I = TimeSeries()\n",
+    "    R = TimeSeries()\n",
+    "\n",
+    "    state = system.init\n",
+    "    t0 = system.t0\n",
+    "    S[t0], I[t0], R[t0] = state\n",
+    "    \n",
+    "    for t in linrange(system.t0, system.t_end):\n",
+    "        state = update_func(state, t, system)\n",
+    "        S[t+1], I[t+1], R[t+1] = state\n",
+    "    \n",
+    "    return S, I, R"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's how we call it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tc = 3      # time between contacts in days \n",
+    "tr = 4      # recovery time in days\n",
+    "\n",
+    "beta = 1 / tc      # contact rate in per day\n",
+    "gamma = 1 / tr     # recovery rate in per day\n",
+    "\n",
+    "system = make_system(beta, gamma)\n",
+    "S, I, R = run_simulation(system, update_func)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And then we can plot the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_results(S, I, R):\n",
+    "    \"\"\"Plot the results of a SIR model.\n",
+    "    \n",
+    "    S: TimeSeries\n",
+    "    I: TimeSeries\n",
+    "    R: TimeSeries\n",
+    "    \"\"\"\n",
+    "    plot(S, '--', color='fuchsia', label='Susceptible')\n",
+    "    plot(I, '-', color='red', label='Infectious')\n",
+    "    plot(R, ':', color='maroon', label='Recovered')\n",
+    "    decorate(xlabel='Time (days)',\n",
+    "             ylabel='Fraction of population')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's what they look like."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file figs/chap11-fig01.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_results(S, I, R)\n",
+    "savefig('figs/chap11-fig01.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Using a DataFrame"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Instead of making three `TimeSeries` objects, we can use one `DataFrame`.\n",
+    "\n",
+    "We have to use `row` to selects rows, rather than columns.  But then Pandas does the right thing, matching up the state variables with the columns of the `DataFrame`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(system, update_func):\n",
+    "    \"\"\"Runs a simulation of the system.\n",
+    "        \n",
+    "    system: System object\n",
+    "    update_func: function that updates state\n",
+    "    \n",
+    "    returns: TimeFrame\n",
+    "    \"\"\"\n",
+    "    frame = TimeFrame(columns=system.init.index)\n",
+    "    frame.row[system.t0] = system.init\n",
+    "    \n",
+    "    for t in linrange(system.t0, system.t_end):\n",
+    "        frame.row[t+1] = update_func(frame.row[t], t, system)\n",
+    "    \n",
+    "    return frame"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's how we run it, and what the result looks like."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "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>S</th>\n",
+       "      <th>I</th>\n",
+       "      <th>R</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.988889</td>\n",
+       "      <td>0.011111</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.985226</td>\n",
+       "      <td>0.011996</td>\n",
+       "      <td>0.002778</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0.981287</td>\n",
+       "      <td>0.012936</td>\n",
+       "      <td>0.005777</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0.977055</td>\n",
+       "      <td>0.013934</td>\n",
+       "      <td>0.009011</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0.972517</td>\n",
+       "      <td>0.014988</td>\n",
+       "      <td>0.012494</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "          S         I         R\n",
+       "0  0.988889  0.011111  0.000000\n",
+       "1  0.985226  0.011996  0.002778\n",
+       "2  0.981287  0.012936  0.005777\n",
+       "3  0.977055  0.013934  0.009011\n",
+       "4  0.972517  0.014988  0.012494"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tc = 3      # time between contacts in days \n",
+    "tr = 4      # recovery time in days\n",
+    "\n",
+    "beta = 1 / tc      # contact rate in per day\n",
+    "gamma = 1 / tr     # recovery rate in per day\n",
+    "\n",
+    "system = make_system(beta, gamma)\n",
+    "results = run_simulation(system, update_func)\n",
+    "results.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can extract the results and plot them."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_results(results.S, results.I, results.R)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercises\n",
+    "\n",
+    "**Exercise**  Suppose the time between contacts is 4 days and the recovery time is 5 days.  Simulate this scenario for 14 days and plot the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Solution goes here\n",
+    "tc = 4      # time between contacts in days \n",
+    "tr = 5      # recovery time in days\n",
+    "\n",
+    "beta = 1 / tc      # contact rate in per day\n",
+    "gamma = 1 / tr     # recovery rate in per day\n",
+    "\n",
+    "system = make_system(beta, gamma)\n",
+    "results = run_simulation(system, update_func)\n",
+    "results.head()\n",
+    "plot_results(results.I,results.I,results.I) #just wanted a closer look at the infectious cycle"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Solution goes here\n",
+    "tc = 4      # time between contacts in days \n",
+    "tr = 5      # recovery time in days\n",
+    "\n",
+    "beta = 1 / tc      # contact rate in per day\n",
+    "gamma = 1 / tr     # recovery rate in per day\n",
+    "\n",
+    "system = make_system(beta, gamma)\n",
+    "results = run_simulation(system, update_func)\n",
+    "results.head()\n",
+    "plot_results(results.S,results.I,results.R)"
+   ]
+  },
+  {
+   "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}