From d5b56644ba19ce516a0ed1e99b75f8c4534d52f9 Mon Sep 17 00:00:00 2001 From: Mia Skaggs Date: Thu, 13 Sep 2018 15:55:16 -0400 Subject: [PATCH 1/5] Adding chap 4 notebook --- code/chap04mine.ipynb | 1095 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1095 insertions(+) create mode 100644 code/chap04mine.ipynb diff --git a/code/chap04mine.ipynb b/code/chap04mine.ipynb new file mode 100644 index 00000000..6e647f6b --- /dev/null +++ b/code/chap04mine.ipynb @@ -0,0 +1,1095 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Modeling and Simulation in Python\n", + "\n", + "Chapter 4\n", + "\n", + "Copyright 2017 Allen Downey\n", + "\n", + "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Configure Jupyter so figures appear in the notebook\n", + "%matplotlib inline\n", + "\n", + "# Configure Jupyter to display the assigned value after an assignment\n", + "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n", + "\n", + "# import functions from the modsim library\n", + "from modsim import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Returning values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here's a simple function that returns a value:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def add_five(x):\n", + " return x + 5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And here's how we call it." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y = add_five(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you run a function on the last line of a cell, Jupyter displays the result:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "add_five(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But that can be a bad habit, because usually if you call a function and don't assign the result in a variable, the result gets discarded.\n", + "\n", + "In the following example, Jupyter shows the second result, but the first result just disappears." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "add_five(3)\n", + "add_five(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When you call a function that returns a variable, it is generally a good idea to assign the result to a variable." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8 10\n" + ] + } + ], + "source": [ + "y1 = add_five(3)\n", + "y2 = add_five(5)\n", + "\n", + "print(y1, y2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Exercise:** Write a function called `make_state` that creates a `State` object with the state variables `olin=10` and `wellesley=2`, and then returns the new `State` object.\n", + "\n", + "Write a line of code that calls `make_state` and assigns the result to a variable named `init`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def make_state():\n", + " state = State(olin=10, wellesley=2)\n", + " return state" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
values
olin10
wellesley2
\n", + "
" + ], + "text/plain": [ + "olin 10\n", + "wellesley 2\n", + "dtype: int64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "init = make_state()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running simulations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here's the code from the previous notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def step(state, p1, p2):\n", + " \"\"\"Simulate one minute of time.\n", + " \n", + " state: bikeshare State object\n", + " p1: probability of an Olin->Wellesley customer arrival\n", + " p2: probability of a Wellesley->Olin customer arrival\n", + " \"\"\"\n", + " if flip(p1):\n", + " bike_to_wellesley(state)\n", + " \n", + " if flip(p2):\n", + " bike_to_olin(state)\n", + " \n", + "def bike_to_wellesley(state):\n", + " \"\"\"Move one bike from Olin to Wellesley.\n", + " \n", + " state: bikeshare State object\n", + " \"\"\"\n", + " if state.olin == 0:\n", + " state.olin_empty += 1\n", + " return\n", + " state.olin -= 1\n", + " state.wellesley += 1\n", + " \n", + "def bike_to_olin(state):\n", + " \"\"\"Move one bike from Wellesley to Olin.\n", + " \n", + " state: bikeshare State object\n", + " \"\"\"\n", + " if state.wellesley == 0:\n", + " state.wellesley_empty += 1\n", + " return\n", + " state.wellesley -= 1\n", + " state.olin += 1\n", + " \n", + "def decorate_bikeshare():\n", + " \"\"\"Add a title and label the axes.\"\"\"\n", + " decorate(title='Olin-Wellesley Bikeshare',\n", + " xlabel='Time step (min)', \n", + " ylabel='Number of bikes')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here's a modified version of `run_simulation` that creates a `State` object, runs the simulation, and returns the `State` object." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def run_simulation(p1, p2, num_steps):\n", + " \"\"\"Simulate the given number of time steps.\n", + " \n", + " p1: probability of an Olin->Wellesley customer arrival\n", + " p2: probability of a Wellesley->Olin customer arrival\n", + " num_steps: number of time steps\n", + " \"\"\"\n", + " state = State(olin=10, wellesley=2, \n", + " olin_empty=0, wellesley_empty=0)\n", + " \n", + " for i in range(num_steps):\n", + " step(state, p1, p2)\n", + " \n", + " return state" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now `run_simulation` doesn't plot anything:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
values
olin3
wellesley9
olin_empty0
wellesley_empty0
\n", + "
" + ], + "text/plain": [ + "olin 3\n", + "wellesley 9\n", + "olin_empty 0\n", + "wellesley_empty 0\n", + "dtype: int64" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state = run_simulation(0.4, 0.2, 60)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But after the simulation, we can read the metrics from the `State` object." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state.olin_empty" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can run simulations with different values for the parameters. When `p1` is small, we probably don't run out of bikes at Olin." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state = run_simulation(0.2, 0.2, 60)\n", + "state.olin_empty" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When `p1` is large, we probably do." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "14" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state = run_simulation(0.6, 0.2, 60)\n", + "state.olin_empty" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## More for loops" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`linspace` creates a NumPy array of equally spaced numbers." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 0.25, 0.5 , 0.75, 1. ])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p1_array = linspace(0, 1, 5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use an array in a `for` loop, like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "0.25\n", + "0.5\n", + "0.75\n", + "1.0\n" + ] + } + ], + "source": [ + "for p1 in p1_array:\n", + " print(p1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This will come in handy in the next section.\n", + "\n", + "`linspace` is defined in `modsim.py`. You can get the documentation using `help`." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function linspace in module modsim:\n", + "\n", + "linspace(start, stop, num=50, **options)\n", + " Returns an array of evenly-spaced values in the interval [start, stop].\n", + " \n", + " start: first value\n", + " stop: last value\n", + " num: number of values\n", + " \n", + " Also accepts the same keyword arguments as np.linspace. See\n", + " https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html\n", + " \n", + " returns: array or Quantity\n", + "\n" + ] + } + ], + "source": [ + "help(linspace)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`linspace` is based on a NumPy function with the same name. [Click here](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html) to read more about how to use it." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Exercise:** \n", + "Use `linspace` to make an array of 10 equally spaced numbers from 1 to 10 (including both)." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "linspace (1,10,10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Exercise:** The `modsim` library provides a related function called `linrange`. You can view the documentation by running the following cell:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function linrange in module modsim:\n", + "\n", + "linrange(start=0, stop=None, step=1, **options)\n", + " Returns an array of evenly-spaced values in the interval [start, stop].\n", + " \n", + " This function works best if the space between start and stop\n", + " is divisible by step; otherwise the results might be surprising.\n", + " \n", + " By default, the last value in the array is `stop-step`\n", + " (at least approximately).\n", + " If you provide the keyword argument `endpoint=True`,\n", + " the last value in the array is `stop`.\n", + " \n", + " start: first value\n", + " stop: last value\n", + " step: space between values\n", + " \n", + " Also accepts the same keyword arguments as np.linspace. See\n", + " https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html\n", + " \n", + " returns: array or Quantity\n", + "\n" + ] + } + ], + "source": [ + "help(linrange)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Use `linrange` to make an array of numbers from 1 to 11 with a step size of 2." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1., 3., 5., 7., 9., 11.])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "linrange (1, 11, 2, endpoint=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sweeping parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`p1_array` contains a range of values for `p1`." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p2 = 0.2\n", + "num_steps = 60\n", + "p1_array = linspace(0, 1, 11)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following loop runs a simulation for each value of `p1` in `p1_array`; after each simulation, it prints the number of unhappy customers at the Olin station:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0 0\n", + "0.1 0\n", + "0.2 0\n", + "0.30000000000000004 0\n", + "0.4 0\n", + "0.5 10\n", + "0.6000000000000001 19\n", + "0.7000000000000001 16\n", + "0.8 19\n", + "0.9 33\n", + "1.0 39\n" + ] + } + ], + "source": [ + "for p1 in p1_array:\n", + " state = run_simulation(p1, p2, num_steps)\n", + " print(p1, state.olin_empty)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can do the same thing, but storing the results in a `SweepSeries` instead of printing them.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "sweep = SweepSeries()\n", + "\n", + "for p1 in p1_array:\n", + " state = run_simulation(p1, p2, num_steps)\n", + " sweep[p1] = state.olin_empty" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And then we can plot the results." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saving figure to file figs/chap02-fig02.pdf\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot(sweep, label='Olin')\n", + "\n", + "decorate(title='Olin-Wellesley Bikeshare',\n", + " xlabel='Arrival rate at Olin (p1 in customers/min)', \n", + " ylabel='Number of unhappy customers')\n", + "\n", + "savefig('figs/chap02-fig02.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercises\n", + "\n", + "**Exercise:** Wrap this code in a function named `sweep_p1` that takes an array called `p1_array` as a parameter. It should create a new `SweepSeries`, run a simulation for each value of `p1` in `p1_array`, store the results in the `SweepSeries`, and return the `SweepSeries`.\n", + "\n", + "Use your function to plot the number of unhappy customers at Olin as a function of `p1`. Label the axes." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "p1_array = linspace(0, 1, 11)\n", + "p2 = 0.2\n", + "num_steps = 60\n", + "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", + " print(p1, state.olin_empty)\n", + " sweep[p1]=state.olin_empty\n", + "\n", + " return sweep" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0 0\n", + "0.1 0\n", + "0.2 0\n", + "0.30000000000000004 0\n", + "0.4 0\n", + "0.5 8\n", + "0.6000000000000001 12\n", + "0.7000000000000001 23\n", + "0.8 25\n", + "0.9 30\n", + "1.0 44\n", + "Saving figure to file figs/chap02-miajocelyngraph1.pdf\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sweep = sweep_p1(p1_array, p2, num_steps)\n", + "plot(sweep, label = 'Olin')\n", + "decorate(title='Olin-Wellesley Bikeshare',\n", + " xlabel='Arrival rate at Olin (p1 in customers/min)', \n", + " ylabel='Number of unhappy customers')\n", + "\n", + "savefig('figs/chap02-miajocelyngraph1.pdf')" + ] + }, + { + "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": 29, + "metadata": {}, + "outputs": [], + "source": [ + "p1 = 0.5\n", + "p2_array = linspace(0, 1, 11)\n", + "num_steps = 60\n", + "def sweep_p2(p1, p2_array, num_steps):\n", + " sweep = SweepSeries()\n", + " for p2 in p2_array:\n", + " state = run_simulation(p1, p2, num_steps)\n", + " print(p2, state.olin_empty)\n", + " sweep[p2]=state.olin_empty\n", + "\n", + " return sweep" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0 19\n", + "0.1 17\n", + "0.2 9\n", + "0.30000000000000004 5\n", + "0.4 0\n", + "0.5 0\n", + "0.6000000000000001 0\n", + "0.7000000000000001 0\n", + "0.8 0\n", + "0.9 0\n", + "1.0 0\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sweep = sweep_p2(p1, p2_array, num_steps)\n", + "plot(sweep) #plotted to test and see if it worked" + ] + }, + { + "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": 29, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Solution goes here" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution goes here" + ] + }, + { + "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": 31, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# Solution goes here" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 8338ce06293a0fa01b80f5e5058ced1f47ff7db9 Mon Sep 17 00:00:00 2001 From: Mia Skaggs Date: Fri, 14 Sep 2018 17:07:18 -0400 Subject: [PATCH 2/5] Working Chapter 4 --- code/chap04mine.ipynb | 1095 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1095 insertions(+) create mode 100644 code/chap04mine.ipynb diff --git a/code/chap04mine.ipynb b/code/chap04mine.ipynb new file mode 100644 index 00000000..6e647f6b --- /dev/null +++ b/code/chap04mine.ipynb @@ -0,0 +1,1095 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Modeling and Simulation in Python\n", + "\n", + "Chapter 4\n", + "\n", + "Copyright 2017 Allen Downey\n", + "\n", + "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Configure Jupyter so figures appear in the notebook\n", + "%matplotlib inline\n", + "\n", + "# Configure Jupyter to display the assigned value after an assignment\n", + "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n", + "\n", + "# import functions from the modsim library\n", + "from modsim import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Returning values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here's a simple function that returns a value:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def add_five(x):\n", + " return x + 5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And here's how we call it." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y = add_five(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you run a function on the last line of a cell, Jupyter displays the result:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "add_five(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But that can be a bad habit, because usually if you call a function and don't assign the result in a variable, the result gets discarded.\n", + "\n", + "In the following example, Jupyter shows the second result, but the first result just disappears." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "add_five(3)\n", + "add_five(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When you call a function that returns a variable, it is generally a good idea to assign the result to a variable." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8 10\n" + ] + } + ], + "source": [ + "y1 = add_five(3)\n", + "y2 = add_five(5)\n", + "\n", + "print(y1, y2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Exercise:** Write a function called `make_state` that creates a `State` object with the state variables `olin=10` and `wellesley=2`, and then returns the new `State` object.\n", + "\n", + "Write a line of code that calls `make_state` and assigns the result to a variable named `init`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def make_state():\n", + " state = State(olin=10, wellesley=2)\n", + " return state" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
values
olin10
wellesley2
\n", + "
" + ], + "text/plain": [ + "olin 10\n", + "wellesley 2\n", + "dtype: int64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "init = make_state()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running simulations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here's the code from the previous notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def step(state, p1, p2):\n", + " \"\"\"Simulate one minute of time.\n", + " \n", + " state: bikeshare State object\n", + " p1: probability of an Olin->Wellesley customer arrival\n", + " p2: probability of a Wellesley->Olin customer arrival\n", + " \"\"\"\n", + " if flip(p1):\n", + " bike_to_wellesley(state)\n", + " \n", + " if flip(p2):\n", + " bike_to_olin(state)\n", + " \n", + "def bike_to_wellesley(state):\n", + " \"\"\"Move one bike from Olin to Wellesley.\n", + " \n", + " state: bikeshare State object\n", + " \"\"\"\n", + " if state.olin == 0:\n", + " state.olin_empty += 1\n", + " return\n", + " state.olin -= 1\n", + " state.wellesley += 1\n", + " \n", + "def bike_to_olin(state):\n", + " \"\"\"Move one bike from Wellesley to Olin.\n", + " \n", + " state: bikeshare State object\n", + " \"\"\"\n", + " if state.wellesley == 0:\n", + " state.wellesley_empty += 1\n", + " return\n", + " state.wellesley -= 1\n", + " state.olin += 1\n", + " \n", + "def decorate_bikeshare():\n", + " \"\"\"Add a title and label the axes.\"\"\"\n", + " decorate(title='Olin-Wellesley Bikeshare',\n", + " xlabel='Time step (min)', \n", + " ylabel='Number of bikes')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here's a modified version of `run_simulation` that creates a `State` object, runs the simulation, and returns the `State` object." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def run_simulation(p1, p2, num_steps):\n", + " \"\"\"Simulate the given number of time steps.\n", + " \n", + " p1: probability of an Olin->Wellesley customer arrival\n", + " p2: probability of a Wellesley->Olin customer arrival\n", + " num_steps: number of time steps\n", + " \"\"\"\n", + " state = State(olin=10, wellesley=2, \n", + " olin_empty=0, wellesley_empty=0)\n", + " \n", + " for i in range(num_steps):\n", + " step(state, p1, p2)\n", + " \n", + " return state" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now `run_simulation` doesn't plot anything:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
values
olin3
wellesley9
olin_empty0
wellesley_empty0
\n", + "
" + ], + "text/plain": [ + "olin 3\n", + "wellesley 9\n", + "olin_empty 0\n", + "wellesley_empty 0\n", + "dtype: int64" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state = run_simulation(0.4, 0.2, 60)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But after the simulation, we can read the metrics from the `State` object." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state.olin_empty" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can run simulations with different values for the parameters. When `p1` is small, we probably don't run out of bikes at Olin." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state = run_simulation(0.2, 0.2, 60)\n", + "state.olin_empty" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When `p1` is large, we probably do." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "14" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state = run_simulation(0.6, 0.2, 60)\n", + "state.olin_empty" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## More for loops" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`linspace` creates a NumPy array of equally spaced numbers." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 0.25, 0.5 , 0.75, 1. ])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p1_array = linspace(0, 1, 5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use an array in a `for` loop, like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "0.25\n", + "0.5\n", + "0.75\n", + "1.0\n" + ] + } + ], + "source": [ + "for p1 in p1_array:\n", + " print(p1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This will come in handy in the next section.\n", + "\n", + "`linspace` is defined in `modsim.py`. You can get the documentation using `help`." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function linspace in module modsim:\n", + "\n", + "linspace(start, stop, num=50, **options)\n", + " Returns an array of evenly-spaced values in the interval [start, stop].\n", + " \n", + " start: first value\n", + " stop: last value\n", + " num: number of values\n", + " \n", + " Also accepts the same keyword arguments as np.linspace. See\n", + " https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html\n", + " \n", + " returns: array or Quantity\n", + "\n" + ] + } + ], + "source": [ + "help(linspace)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`linspace` is based on a NumPy function with the same name. [Click here](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html) to read more about how to use it." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Exercise:** \n", + "Use `linspace` to make an array of 10 equally spaced numbers from 1 to 10 (including both)." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "linspace (1,10,10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Exercise:** The `modsim` library provides a related function called `linrange`. You can view the documentation by running the following cell:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function linrange in module modsim:\n", + "\n", + "linrange(start=0, stop=None, step=1, **options)\n", + " Returns an array of evenly-spaced values in the interval [start, stop].\n", + " \n", + " This function works best if the space between start and stop\n", + " is divisible by step; otherwise the results might be surprising.\n", + " \n", + " By default, the last value in the array is `stop-step`\n", + " (at least approximately).\n", + " If you provide the keyword argument `endpoint=True`,\n", + " the last value in the array is `stop`.\n", + " \n", + " start: first value\n", + " stop: last value\n", + " step: space between values\n", + " \n", + " Also accepts the same keyword arguments as np.linspace. See\n", + " https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html\n", + " \n", + " returns: array or Quantity\n", + "\n" + ] + } + ], + "source": [ + "help(linrange)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Use `linrange` to make an array of numbers from 1 to 11 with a step size of 2." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1., 3., 5., 7., 9., 11.])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "linrange (1, 11, 2, endpoint=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sweeping parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`p1_array` contains a range of values for `p1`." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p2 = 0.2\n", + "num_steps = 60\n", + "p1_array = linspace(0, 1, 11)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following loop runs a simulation for each value of `p1` in `p1_array`; after each simulation, it prints the number of unhappy customers at the Olin station:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0 0\n", + "0.1 0\n", + "0.2 0\n", + "0.30000000000000004 0\n", + "0.4 0\n", + "0.5 10\n", + "0.6000000000000001 19\n", + "0.7000000000000001 16\n", + "0.8 19\n", + "0.9 33\n", + "1.0 39\n" + ] + } + ], + "source": [ + "for p1 in p1_array:\n", + " state = run_simulation(p1, p2, num_steps)\n", + " print(p1, state.olin_empty)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can do the same thing, but storing the results in a `SweepSeries` instead of printing them.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "sweep = SweepSeries()\n", + "\n", + "for p1 in p1_array:\n", + " state = run_simulation(p1, p2, num_steps)\n", + " sweep[p1] = state.olin_empty" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And then we can plot the results." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saving figure to file figs/chap02-fig02.pdf\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot(sweep, label='Olin')\n", + "\n", + "decorate(title='Olin-Wellesley Bikeshare',\n", + " xlabel='Arrival rate at Olin (p1 in customers/min)', \n", + " ylabel='Number of unhappy customers')\n", + "\n", + "savefig('figs/chap02-fig02.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercises\n", + "\n", + "**Exercise:** Wrap this code in a function named `sweep_p1` that takes an array called `p1_array` as a parameter. It should create a new `SweepSeries`, run a simulation for each value of `p1` in `p1_array`, store the results in the `SweepSeries`, and return the `SweepSeries`.\n", + "\n", + "Use your function to plot the number of unhappy customers at Olin as a function of `p1`. Label the axes." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "p1_array = linspace(0, 1, 11)\n", + "p2 = 0.2\n", + "num_steps = 60\n", + "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", + " print(p1, state.olin_empty)\n", + " sweep[p1]=state.olin_empty\n", + "\n", + " return sweep" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0 0\n", + "0.1 0\n", + "0.2 0\n", + "0.30000000000000004 0\n", + "0.4 0\n", + "0.5 8\n", + "0.6000000000000001 12\n", + "0.7000000000000001 23\n", + "0.8 25\n", + "0.9 30\n", + "1.0 44\n", + "Saving figure to file figs/chap02-miajocelyngraph1.pdf\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sweep = sweep_p1(p1_array, p2, num_steps)\n", + "plot(sweep, label = 'Olin')\n", + "decorate(title='Olin-Wellesley Bikeshare',\n", + " xlabel='Arrival rate at Olin (p1 in customers/min)', \n", + " ylabel='Number of unhappy customers')\n", + "\n", + "savefig('figs/chap02-miajocelyngraph1.pdf')" + ] + }, + { + "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": 29, + "metadata": {}, + "outputs": [], + "source": [ + "p1 = 0.5\n", + "p2_array = linspace(0, 1, 11)\n", + "num_steps = 60\n", + "def sweep_p2(p1, p2_array, num_steps):\n", + " sweep = SweepSeries()\n", + " for p2 in p2_array:\n", + " state = run_simulation(p1, p2, num_steps)\n", + " print(p2, state.olin_empty)\n", + " sweep[p2]=state.olin_empty\n", + "\n", + " return sweep" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0 19\n", + "0.1 17\n", + "0.2 9\n", + "0.30000000000000004 5\n", + "0.4 0\n", + "0.5 0\n", + "0.6000000000000001 0\n", + "0.7000000000000001 0\n", + "0.8 0\n", + "0.9 0\n", + "1.0 0\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sweep = sweep_p2(p1, p2_array, num_steps)\n", + "plot(sweep) #plotted to test and see if it worked" + ] + }, + { + "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": 29, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Solution goes here" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution goes here" + ] + }, + { + "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": 31, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# Solution goes here" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 31154f5c7b217004633a3e6672e7177bf21ca046 Mon Sep 17 00:00:00 2001 From: Mia Skaggs Date: Sun, 23 Sep 2018 01:56:40 -0400 Subject: [PATCH 3/5] Chapter 8 --- code/chap08mine.ipynb | 908 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 908 insertions(+) create mode 100644 code/chap08mine.ipynb diff --git a/code/chap08mine.ipynb b/code/chap08mine.ipynb new file mode 100644 index 00000000..4de65a2d --- /dev/null +++ b/code/chap08mine.ipynb @@ -0,0 +1,908 @@ +{ + "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": 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": [ + "### Functions from the previous chapter" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "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": 3, + "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):\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": 4, + "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": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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": 6, + "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": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.557628654" + ] + }, + "execution_count": 7, + "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": 8, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
values
t_01950.000000
t_end2016.000000
p_02.557629
alpha0.025000
beta-0.001800
\n", + "
" + ], + "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": 8, + "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": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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": 10, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saving figure to file figs/chap04-fig01.pdf\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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('figs/chap04-fig01.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The population in the model converges on the equilibrium population, `-alpha/beta`" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "13.856665141368708" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results[system.t_end]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "13.88888888888889" + ] + }, + "execution_count": 12, + "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": 13, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "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\n", + "\n", + "population_array = linspace(1,20,20)\n", + "for system.p_0 in population_array:\n", + " results = run_simulation(system, update_func_quad)\n", + " plot(results)" + ] + }, + { + "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": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
United States Census Bureau (2015)[28]Population Reference Bureau (1973-2015)[15]United Nations Department of Economic and Social Affairs (2015)[16]
Year
20167.334772e+09NaN7.432663e+09
20177.412779e+09NaNNaN
20187.490428e+09NaNNaN
20197.567403e+09NaNNaN
20207.643402e+09NaN7.758157e+09
\n", + "
" + ], + "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": 14, + "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": 15, + "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": 16, + "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": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
values
t_01950.000000
t_end2100.000000
p_02.557629
alpha0.025000
beta-0.001800
\n", + "
" + ], + "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": 17, + "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": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saving figure to file figs/chap04-fig02.pdf\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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('figs/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": 19, + "metadata": {}, + "outputs": [], + "source": [ + "%psource 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": 20, + "metadata": {}, + "outputs": [], + "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": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution goes here" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution goes here" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution goes here" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution goes here" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution goes here" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution goes here" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution goes here" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution goes here" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Related viewing:** You might be interested in this [video by Hans Rosling about the demographic changes we expect in this century](https://www.youtube.com/watch?v=ezVk1ahRF78)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 5863cf9fb3e64ee4fd419300e58205a1971537fa Mon Sep 17 00:00:00 2001 From: miaskaggs Date: Sat, 20 Oct 2018 19:30:21 -0400 Subject: [PATCH 4/5] Pushing HIV Model to Git --- code/hiv_model.ipynb | 185 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 185 insertions(+) create mode 100644 code/hiv_model.ipynb diff --git a/code/hiv_model.ipynb b/code/hiv_model.ipynb new file mode 100644 index 00000000..58dea91a --- /dev/null +++ b/code/hiv_model.ipynb @@ -0,0 +1,185 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# HIV Model\n", + "Mia Skaggs" + ] + }, + { + "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": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#Define a State object that represents the initial condition.\n", + "init = State(R = 1000, L = 0, E = 0, V = 4E-7) \n", + "\n", + "'''\n", + " R = uninfected cells\n", + " L = latently infected cells\n", + " E = actively infected cells\n", + " V = number of virions\n", + "''';" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#Define a System object that contains the parameters.\n", + "system = System(gamma = 1.36, tau = 0.2, mu = 0.00136, beta = 0.00027,\n", + " rho = 0.1, alpha = 0.036, delta = 0.33, pi = 100, sigma = 2,\n", + " t_0 = 0, t_end = 500)\n", + "\n", + "\n", + "'''\n", + "tau = proportion of lymphocytes activated\n", + "mu = lymphocyte HIV-indepedent death rate\n", + "beta = rate of infection\n", + "rho = proportion of latently infected cells\n", + "alpha = HIV-independent cell activation\n", + "delta = rate of removal of infected cells\n", + "sigma = rate of removal of free virions\n", + "''';" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#Update function\n", + "def update_func(state, t, system):\n", + " unpack(system)\n", + " R, L, E, V = state\n", + " \n", + " #timestep of 1/24 makes it 1 hour per timestep\n", + " drdt = (gamma*tau - mu*R - beta*R*V)*(1/24) \n", + " dldt = (rho*beta*R*V - mu*L - alpha*L)*(1/24)\n", + " dedt = ((1-rho)*beta*R*V + alpha*L - delta*E)*(1/24)\n", + " dvdt = (pi*E - sigma*V)*(1/24)\n", + "\n", + " R += drdt\n", + " L += dldt\n", + " E += dedt\n", + " V += dvdt\n", + " \n", + " return State(R=R, L=L, E=E, V=V)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#Run simulation\n", + "def run_simulation(system, update_func):\n", + " unpack(system)\n", + " \n", + " frame = TimeFrame(columns=init.index) #set the columns equal to init.index\n", + " frame.row[t_0] = init #starts at initial state, t_0\n", + " \n", + " for t in linrange(t_0, t_end):\n", + " frame.row[t+1] = update_func(frame.row[t], t, system) #every time this runs, it adds 1 to the row number\n", + " \n", + " return frame" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saving figure to file figs/HIV-Model.pdf\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3XmczdX/wPHXnd0sxjr2QeKIImOsKWuUfU+JRCgq36RF+uqLZPn28y0iUmn51hfZshUhSiIkWY+9MMNgmDH7zL3398fnznXv7MPM3Fnez8djHs3ncz7L+dzMnDnn8z7nbbJarQghhBCFjZurKyCEEEJkRBooIYQQhZI0UEIIIQolaaCEEEIUStJACSGEKJSkgRJCCFEoebi6AkIUdUqpc8C7WusP0uyvBZwF7tNaH1ZKtQN+BAKAgcBioJrW+lIG19wAxGut+2dyv5pAf631yjRl5YDLQJTWusJtPk93YJ3W2pSDY2vh8Iy3cz8hMiM9KCFcYwWQCPRLW6CUKg88DHyZxfnJQO8M9vcE3POigkK4mjRQQriA1joa+BajJ5VWfyAK2JjFJbYD3ZRSaUdB+gK/5kUdhXA1GeITwnW+BNYppaporcMd9j8OLNVaJ2dx7magNfAQsA1AKeUPdACmAK+lHqiUqgLMBroAPsD3wLjUeyql7gYW2q53Avja8UZKqcrAXOBRIAbYALystY66vccWImekByWE62wGruIwzKeUqgY8CHyRzbkJwHdAL4d93YC9wBWH63kCW4FgoCtGA1YNWKOUMtnKNwKxQCgwFXg9zb1WYfyuaAX0AOoAS3PxnELcFulBCZE3/k8pNTPNviyDDLTWKUqp/wEDgNQAi8eAE1rrvTm45ypgBjDOtt0XWJnmmC7A3UAnrXUYgFLqMYzAhk4YvwOCgZZa60jgqFKqnu26KKXaA42A9lrrRNu+wcBFpdS9GD0qIfKF9KCEyBszgPvTfHXNwXlfAm1sw3BgDO9lFRzhaANQRSl1v1LKB3gEWJ3mmIbAX6mNE4DW+gJwzlZ2r6080uGc39Kc7wtcU0rFKKViMIYBAVQO6ynEbZEelBB546rW+pTjDqVUSnYnaa33K6U00F8ptREIIYPIvkzOjVZKbcWI5tsPHNFaX1TKqd2Iz+R0E7f+QE3b00ty+N4D+AsjqjCty0D5nNRViNshPSghXO9LoA9G9N4OrfXfuTh3FUYDldHwHsAxoKZDDw2lVFWMeVTHgT+BWkqpSg7nhKQ5vypwU2t9ytYIJwH/BwTlop5C5Jr0oIRwva+AfwEVgDm5PPdbjAi8uzACHNLaAhwEliqlxtv2zcEYptsCWDAaoS+UUhOAGsBEh/N/AI7Yzp8ApADzgHIYw4Q1cllfIXJMelBCuJitx7QLIzouo15QVudeAX4BTmqtz2ZQbsXoYV3BmDu1FQgDOmqtk7TWKRjvypKB3cB/MHpHqedbMCb/RmKsgrEDuAZ01Vqbc/WgQuSSSTLqCiGEKIykByWEEKJQkgZKCCFEoSQNlBBCiEJJovgyoZTyBpoB4YC8DBZCiDvjDlQB9qauSpIdaaAy1wz42dWVEEKIYuZBYGdODpQGKnPhAF999RWVK1d2dV2EEKJIu3TpEoMHDwbb79ackAYqc2aAypUrU716dVfXRQghioscvzKRIAkhhBCFkjRQQgghCiVpoIQQQhRK0kAJIYQolCRIQohCJDo6moiICJKTk11dFSFyxdPTk6CgIEqXLp1n15QGSojbYElOJubkKZKjovAqVw6/Onfh5nFnP07R0dFcvnyZatWqUapUKUymLDPGC1FoWK1W4uPjuXjxIkCeNVIF2kAppboD7wC1gQhgttZ6kVLKC/gAI2GbGZijtZ7hcN4LwGtAIEb+m9Fa61hbWXvgfYxUBQeBIVrr07ayYOAToKXtfi9orTcWxLOK4is5OpqwdRtIjoqy7/Pct58q3R7Fq0yZ275uREQE1apVw9fXNy+qKUSBMZlM+Pr6Uq1aNcLCwvKsgSqwd1C2jJ4rgNe01gHAAOA9pVQIMAVQGI1MM+AppdRQ23ldgElAF4xlMnwwEqahlKoArLGdXwZYDWxSSqU+11KMjKHlgZEYSdfuyv+nFcWVJSWF8I3fOzVOAMlRUYR9u46UuLjbvnZycjKlSpW60yoK4TKlSpXK0+HpAmugtNbhQEWt9Xe2BqQ8RnbOm8BTwHSt9XWt9TngXWC07dSngE+11ke01jHA68ATSil/jDTXR7TWK7XWyVrrfwPeQEelVD0gFJhsS8y2DVgLjCioZxbFT9Sfh0iKjATA5OZO6Qb32If2UmJjubzpB6wWy21fX4b1RFGW1/9+CzSKT2t9UynlCyQCm4H5GJk+qwBHHQ49Dtxn+75BmrLTGPWul0EZgLad2wD4O3UoMIPrCpErlpQUbhz4w75dvlULgtq1pfIjnQHjBzM+PJzoI2n/SYrCIDo6mujoaFdXQ+SCK8LMEwA/jKG84cA4237HsZE4IHUg3t+xzJbCOsFW7p/mPMdzsyoTItdiT5/BnGgswuwZEEDgvQ0B8A0OplxoiP24a3v2khIX75I6FhSlFMeOHUu3v1evXqxatSrb8/ft28dDDz2Uo3vt2bOHBx98kKZNm7JzZ47WGM1Qly5d7C/xc2vIkCF89tlnmZb//PPPDBs2jBYtWtC8eXOGDBnCb7/9lqNr79mzh9DQ0HTfCxc0UFpri23IbR/wEcYwHIDj4LsvEGP7PtaxTCllwngPFZO2LM25WZUJkWs3T5ywf1+6YQNM7u727TIhTfC0vRi2JCU69bREeqGhofz00085OnbdunW0bt2a/fv306ZNm9u+Z6RtaDavrVixgldffZUnn3ySn3/+mZ07d9KzZ09GjRrFvn378uWeJUVBBkm0VUrtT7PbG7gOXMIIkkhVn1tDd0fTlNXBGE85mUGZ47lHgWClVKkMyoTIFXNCAvEXbv31HVCvrlO5m4cH5Vu3sm9HHT58RwETxcHrr7/O1KlTGTJkCE2aNKFPnz7s32/8Ckjba+jWrRuzZ8+mRYsWPPTQQ8ybNw+ASZMmsXr1ajZs2ECnTp0A2L9/PwMHDqRp06b07t2bXbt22e8ZERHBiy++SNOmTWnTpo39On379gVg0KBBbNxoBPIuX76cLl260KxZM0aMGMH58+ft19m1axfdu3enSZMmjB8/nvj4jHvE8fHxzJw5k2nTptGpUye8vLzw8vJiwIABjB49mrNnzwJgNptZuHAhHTt2pEWLFowbNy7bBjMhIYFXXnmFFi1a8OCDD/Liiy/mWyNbWBVkD+oPoJpSarxSyl0p1RojYOET4EvgLaVUBaVULWCCbR+2/45USjWyBUbMBFbZ3i2tBhorpQYqpTyVUhMAC7Bda60xws6nK6W8beHovYCvC+6RRXERfzEMq9UKgE9QEB7+/umO8atdC+8KFQCwms3c+OPgHd/3tyOX+OCbP/jgmz/47cildOU7D160lx/QEenKf9x/3l5+5My1dOWbdv9lLz/x9/U7rm9aq1ev5pVXXmH37t3cc889zJw5M8PjTp06haenJzt37uSdd95h/vz5nD59munTp9OjRw8ef/xxtmzZQnh4OCNHjmTo0KHs2bOHCRMm8OKLL/L3338D8OKLL+Lt7c1PP/3E8uXLWb16NevWrbMPOy5dupSuXbuyefNm5s6dy5w5c/jll19o3rw5I0eOJCUlhatXrzJ27FiGDx/O3r17adOmDYcOHcqw3gcOHCApKYm2bdumK3vuuecYMGAAAF988QVr165lyZIl7Nixg3LlyvHSSy9l+dl9/fXXXLp0ie3bt7N582ZiY2P53//+l+PPvjgoyCi+KKArRuRdJMbw3jNa6x3AZOAwcATYC6wEFtrO2whMw5j/dBGj9zTaVhYB9AAm2q7ZH+ihtU6y3bYfcA/GHKiPgRFa68P5/ayi+Im/GGb/vlT1ahkeYzKZKOvwLir66HEsJXxFiPbt29OoUSO8vb3p1q2bvSFJy2QyMWbMGDw9PWnTpg0VK1bkr7/+SnfcunXrCAkJoXv37nh4eNCmTRseeughVq5cyfnz5zlw4AATJ07Ez8+PqlWr8vHHH9OiRYt011m+fDlDhw6lYcOGeHl5MWrUKGJiYtizZw/bt2+nevXq9O3bFw8PD/r27Uv9+vUzrHdkZCSBgYF4enpm+TksX76c559/nuDgYHx8fHjllVfYu3cv586dy/ScgIAAzp49y4YNG4iOjmbx4sWMHTs2y/sUNwU6UVdr/TuQbhBZa50AjLV9ZXTeAmBBJmU/AU0yKTsPPHq79RUiVUL4rRxrpapWyfQ4v9q18SxdmuToaCxJidw8cYLAhg0LoooFysvLi5SUlHT7zWYz3t7e9u3y5cvbv/fw8MBszjgVkL+/v9N5np6eWDII1w8LC2P37t1OgQRms5mHH36Ya9eu4e3tTbly5exld92V8bTHsLAwFixYwEcffWTfl5ycTFhYGNeuXaNSpUpOx2eWE65ixYrcuHGD5OTkdI3UzZs38fb2xsvLi7CwMCZNmsTkyZPt5R4eHly8eBGPTFYg6d+/P7Gxsfz3v//ln//8J/Xr1+ett97i/vvvz/D44kiWOhIiG+aEBBKv2eY+mUz4ZJFh2WQyEXjfvVz9xXgvEnXoCKUbNLjt+SHNG1amecPM79emcTXaNM64RwfQvmkN2jetkWl5l5Y16dKyZq7rVblyZcLCwrjvvluzNlJSUggLC8vXDNRBQUF07tyZOXPm2PdduHABPz8/EhISSExM5Pr165QtWxaArVu3Yjab6dy5c7rrDB06lEGDBtn3nT59mqpVq/Ldd98RFhbmdPzly5czrE+TJk3w8fFhx44d9ndkqf7973/z119/8fnnnxMUFMTkyZN58MEH7eUnTpygVq1aHDhwIMNrnz59mg4dOjBs2DAiIyOZP38+r7zyCj/88EMOPqniQVYzFyIbCeGXAOP9k3fFirh5eWV5fEB9hZuH8dd0UmQk8bcZ2lyYdevWjQ8++IDTp08DcOPGDWbPnk3FihVp1KhRvt23a9eu7Nixgx07dmCxWDh27Bj9+/fnxx9/pEqVKoSGhvLuu++SkJBAWFgYM2bMICnJGPH39PTk5s2bAPTu3ZslS5Zw+vRprFYr69ato1evXly+fJkOHTpw7do1vv76a1JSUli/fn2m76C8vLyYMGECkydPZuvWraSkpBAXF8eSJUtYs2aNfUiud+/ezJ8/n/DwcMxmMx999BGDBw8mISEh02ddv349r776qn0Y0c/Pj8DAwDz+RAs36UEJkY0Eh7+efapkPryXyt3bm4D69Yg6fASA6KPH8M1kiKioGjt2LO7u7owePdo+tNayZUs+++yzbN/H3IlatWoxb9485syZw/jx4yldujQjR460R+nNmTOHt99+m7Zt2+Ll5cXgwYPp3r07YAyZjRw5ktdee40nnniC6OhoxowZQ0REBMHBwcyfP59atWoBsGjRIqZMmcLs2bNp2rQprVu3zrROjz32GAEBASxatIiJEyditVpp0KABn3zyCc2aNQNg1KhRpKSkMHjwYG7cuEG9evX45JNPslyz7tlnn+Xy5ct07dqVxMRE7r33XmbNmpVHn2TRYEqNTBLObNGEZ7du3Zrp+LMoGcI3fEes7YV9pU4d04WYZyTx2jXOL/sGMJZEqvX0UNwd3rFk5NixY9xzzz13XmEhXCizf8cXLlygY8eOALVtS9plS4b4hMhG4rVb4dleDi/9s+JdvjzeFSsCYLWYiTlxMl/qJkRxJg2UEFkwJyaSEmMsPmJyc8OrTM7fAQSoevbvo4/rPK+bEMWdNFBCZCHJYea+V9myTssbZSegXl1MbsbxiVeu2CMBhRA5Iw2UEFlIuuo4vFcuiyPTc/fxwa/2rRDum9KLEiJXpIESIguOvZ6cvn9yFOCwAsHNEyfuKFeUECWNNFBCZCH5+q316bzK5a4HBeBbozoethTu5vh4pwVnhRBZkwZKiCwkOyS487yNSZImNzf8765j3445dSpP6iVESSANlBCZsKSkkBJrJGQ2mUx4BqRfwTwn/OvemjcVc/oMlgzWsBNCpCcNlBCZSI661Xvy8PfPVQSfI++gireSGSYnE5fJit4lhWPepTthNpsJd1jEt6i4fPkyySV8lfuckgZKiEykOA7v5WL+U1omkwn/unfbt2NOFv1hvsxSvmfn2LFjDBw4ME/qMH78eDZt2gTcfqr0119/nenTp+fo2A0bNtCiRQuaNWtmX4Mwt65evcojjzySaQLE7HTo0IEtW7ZkWr5u3ToGDRpEaGgoLVu25Nlnn+X48eM5uvaqVavo1atXuu9dSRooITKRHBVl/96z9J0t0ul/960GKvbcX1iSkrI4uviKjo7Os95DQWeXXbFiBYMHD2bv3r3UqVMn+xMykJCQQFw+ZVqeO3cuc+fOZfz48ezevZtt27bRqFEjnnzyySzzThVm0kAJkQnHIT7PwMwX9cwJ7/Ll7FGAVrOZ2LPn7uh6hZnWmuHDh9OmTRsaN27MU089Zc+zNHLkSG7evEmTJk24fPkyiYmJzJgxg7Zt2/LAAw8wefJk+y/wVatW8fTTTzNx4kSaNm1Kp06dWLp0KQDTp09n3759vPvuu0ydOtXp/sOHD+e9996zbyckJNCkSROMJNuZy+p+w4cPZ/fu3Xz00UcMHToUMFJ59OzZk9DQUAYNGsTRo0ft1zpz5gxPP/00ISEhtG/fnq+/NhJ59+vXD4C2bdty4MCBbFPBr1+/nk6dOhESEsLbb7+daT6t8PBwPvzwQ95//32aN2+Oh4cHvr6+jBkzhj59+nDKFpyT1eedmcjISEaPHk2zZs1o164dEydOzHIV9rwkq5kLkYnkaIceVB6kOQioezfX9vwGwM2Tp5yWQspI3JmDxJ3ch9VcMO8rTO6e+NYNxfeuxnd0nRdffJEBAwbw8ccfExMTw9ixY1m8eDFvvfWWPSvsvn37AHj77bc5duwYK1euxNvbm9dff523336bd955B4Bdu3YxZcoUpk2bxurVq5k6dSpdu3Zl0qRJHD9+nI4dOzJs2DD27Nljv3/Pnj358MMP+cc//gHAtm3bCA4ORimVbd0zu9+nn37KkCFD7Pc7dOgQEyZMYMGCBTRr1owNGzYwfPhwNm/ejI+PD8888wzdunVj0aJFnDlzhieffJL69euzcuVKOnbsyI4dOyhdujRLliyxp4IPCgpi1qxZvPTSS3z++eccP36ciRMn8uGHH9KiRQsWLVrEpUuXMqz3zp07qV69Og0aNEhXNmnSJPv3//73v7P8vDMyf/58AgIC2LVrF7GxsQwdOpTvv/+e3r17Z/t53inpQQmRCacgiSzSIuSU43uo+PPnMWfzHiL+7MECa5wArOZk4s8evOPrLF68mGHDhpGcnMylS5coW7YsERER6e9ntfLNN9/w6quvUqFCBQICAnj55ZdZvXq1PYdTxYoVGTRoEB4eHvTu3ZukpKRsAyM6d+5MREQEhw8fBoxeSM+ePXNU95zeb8WKFfTs2ZNWrVrh4eFBr169qFmzJt9//z2///470dHRjBs3Di8vL+rXr89XX32VYXbfrFLBb9q0iQceeIA2bdrg6enJc889R5kyZTKsd2RkpFP24ozk5PPOiL+/P4cPH2bz5s1YrVbWrFlTII0TSA9KiAxZLRZSbMntADxLB9zxNT1Ll8anUiUSLl/GarUSc+ZMlungS9VuXOA9qFK176z3BHD48GFGjx7NzZs3qVu3LvHx8U5p2FNFRkaSkJDA8OHDnTIOp6ZCB+eU8al5pjJKBe/I19eXjh07smHDBoKDg/nll1946623clT3nN4vLCyMPXv2sGHDBvu+1IzCfn5+VKxY0SmVe2rvLca28LDjdTJLBX/16lWn1PPu7u5UySQfWcWKFbl69WqGZTdu3MDf35+oqKhsP++MjB07Fjc3Nz744AMmTJhA06ZNmTp1aoYNbl6TBkqIDJjj4knNlebu7Y1bHiXh8697tz0BYsyJU1k2UL53Nb7j4baCdvnyZSZMmMB///tfQkJCAGMYL20KdYAyZcrg6enJN998Y/9ll5SUxPnz5wkODs40FXpO9OzZkylTpqCUIiQkxOkXfV4ICgriqaee4uWXX7bvO3fuHBUqVOD48eNcvXoVs9mMu21qwqpVq6hatWq63HJZpYL//fff+fPPP+37rVYrV65cybA+bdq04c0338wwF9PLL79MpUqVmDZt2m193idOnGDQoEGMGzeO8PBwZsyYwdSpU/nss89y/oHdJhniEyIDqRN0ATwC7rz3lMpYVcL46zU+/BIpMbFZn1CIXbt2jUuXLtm/rl69SkxMDFarFR8fHwB+/fVXvv32W3vknpeXF0lJSSQmJuLu7k7Pnj159913uX79OklJScyaNYtnn302R/f38vJK1yNJ9cADD5CYmMiSJUvyJVy6d+/erFixgoMHD2K1Wvn111/p2bMnhw8fplGjRpQtW5YFCxaQnJyM1ppZs2bh6emJl5cXgFPq+cxSwXfv3p3ffvvNnkp+8eLFmfaSgoKCGDlyJOPGjWPv3r1YLBaioqKYPXs2Bw8eZMSIEbf9eX/++edMnz6d2NhYypcvj4+PT4GlnpcelBAZSHH4xefh55dn1/Xw9aVUtarEX7wIWIk5fZoyjRvl2fUL0ogRI5y2a9euzffff8+LL77IiBEjSElJoXbt2jz++OOsX78eq9WKUop77rmHFi1asGzZMt544w3mzJlDr169iIuLo3HjxixevNje88hKjx49mDp1KmfPnk03t8rd3Z1u3bqxbNkyHn744Tx9boBmzZrx5ptv8uabb3LhwgWCgoKYOnUqLVu2BODDDz/k7bffpnXr1gQEBPDKK6/QtGlTrFYr7du3p2vXrrz//vtZpoIvXbo07733HrNmzWLChAl07Ngxy0CPl156iaCgIKZNm8bFixfx8PAgJCSE//73v/aw+Nv5vCdOnMjkyZNp3749KSkpNG/enClTpuTtB5qJAk35rpR6GJgJ1AUigH9rrRcppe4CTgGO8Y5LtdbP2M57AXgNCAS+BUZrrWNtZe2B94E6wEFgiNb6tK0sGPgEaGm73wta6405rGstJOV7iXXj4J9c/WUXAIENG1Kx7YPZnJFzUUeOcmXHTwD4VKpE9X59AEn5ntc+++wzDh8+zLvvvuvqqpQoRTLlu1KqBrASeBsoAzwOzFBKdQFCgN+01v4OX6mNUxdgEtAFqAL4APNsZRWANcAU2zVXA5uUUqnPtRT4EygPjASW2hpDIbLkOPTm4Z93PSgA/zp32V9SJ1y+7LQgrbhzkZGRHDp0iC+//JIBAwa4ujriDhTkO6hawNda69Vaa4vWei+wHXgAaAr8kcl5TwGfaq2PaK1jgNeBJ5RS/kBf4IjWeqXWOllr/W/AG+iolKoHhAKTtdZJWuttwFpgRCb3EcIuJdZhiM//9haJzYy7jw+latSwb8ecur1lc0TG9u3bx5NPPkn79u1p0aKFq6sj7kCBvYPSWv8M/Jy6rZQqBzwIfAk8C/gppU4A/sBGYILW+gbQwLad6jRGw1rPVnYUZxq4D/AD/k4dCrQ5DjTPw8cSxZRzDypvGygwJu2mLhobc+o0ZUOa5Pk9SqrOnTvTuXNnV1dD5AGXRPEppQIxejN7MN4pXQd+AJphDPcFAx/ZDvfH4d2U1toKJAC+acts4nJQJkSWHOdA5fUQH4BvrZqY3IwX04lXr5J040ae30OIoq7Ao/hsQ2/fYvR8BmutLcAgh0OilFJvADuVUh5ALFDK4XwTxnuoGFtZ2gbH16GsVCZlQmTKarFgdlifzD0Po/js1/T2xrdmMLFnzwK2Fc7zoSEUoigr0B6UUuohjF7TGqC/1jpBKeWrlJqtlHKcSecFpABmjIbMMbYydSLJyQzKAOrb9h8FgpVSpTIoEyJTTpN0S5XCzSN//o5zyrRbDFJwCJHXCqwHpZSqA6wHJmmt56Xu11rH2cLPyyulnseIxpsJfKa1tiqlvgQ+UUqtAM7YylZprWOVUquB2UqpgRgRfOMAC7Bda52klDoITFdKTQRaA72AVgX1zKJocpqkmw+9p1R+tWri5uGBJSWFpBs3sGayUrUQJVVB9qDGAgEYoeUxDl+zgD5AEBAGHMIIDZ8AYJu3NA1jWPAiRu9ptK0sAugBTAQigf5AD6116sqH/YB7MOZAfQyM0FofLoBnFUWY0/Ceb/69snTz9MS3Vi37tqSCF8JZQUbxjQfGZ3FIjyzOXQAsyKTsJyDDECit9Xng0VxUUwhS4hx6UPnYQIERzRdjy9VjTU7BarU6LeRZXJ0/f54aDqH2JUVCQgIxMTFUqFDB1VUpEmQtPiHSMMfdSoPh7ps2ziZv+QbXwM22PpvVasFaBHtRkydPpn79+pw8eTJHx3/11VfMnDnTvp2TZILZuZ0U9LlJa37y5Ek6d+5MkyZN+Oabb26nigA8+eST/PFHZlM+s5Zdevo///yT5557jpYtWxIaGsqAAQP44YcfcnTtCxcuoJQiOjra6XtXkwZKiDRSYgtmiA/A5O6O/1217dvmxMR8vV9ei42N5bvvvqNPnz58+eWXOTonMjISxyXWDhw4kKNkgq60ZcsWKlWqxO+//35Hq1PkV5r6X375haeffppOnTqxfft29uzZw+jRo3nttdfYuDFHq7sVStJACZGGOf5WA5WfQRKpHKP5LAmJFOT6mHdq/fr13HPPPTzzzDOsW7eOqKhbWYhXrlxJly5daNKkCY8//jgnTpxg06ZNLFq0iO3bt9uTCKb2fv7zn/8wZswYp+v36dOHVatWAVmnWE+1cOFCnnjiCad9Tz31VLaN54ULF2jSpAlLliyhTZs2tGrVirfeeguLxcL8+fOZP38++/fvJyQkhKSkJE6dOsWwYcNo1qwZjzzyCOvWrbNfKyYmhkmTJtG8eXNatmzJv/71L5KTkxk7dixhYWGMHz+exYsXZ/tMR48eZcCAAdx///0MHz48y8Zt6tSpvPDCC/Tr1w8fHx/c3d3p1KkTEydO5K+//rIft3z5crp06UKzZs0YMWIE58+fz/JzsVgsvPPOO7Qj+95HAAAgAElEQVRu3ZpWrVoxYsQI/rZNMC8Ispq5EGmYnXpQ+TvEB1CqWjXcvb0BsFrMWJOTMdmG/fZd/JPfww7l6Dr1K97NQ7Wcl/b56dwejl/JWQh7SNX7CK2Wu5XVly1bxtNPP02dOnW49957WbFiBSNGjGDnzp1Mnz6djz76iJCQED788ENeeOEFNm3axIkTJzh27BgLFji/Vu7duzc9e/YkOjqa0qVLc/r0ac6ePUuXLl2yTLFe2iHbcY8ePZg7dy6XLl2icuXKRERE8Pvvv/Of//wn22eJi4tDa82WLVs4c+YMgwcPpkOHDowdOxaLxWKvc2xsLE8//TTDhg1j8eLFHDt2jGeffZYqVaoQGhrKW2+9RWRkJJs2bQLgmWee4ZNPPmH+/Pl06NCBN954g06dOmWbNv65555j4MCBfP311+zevZtnn32WmjVrpqv3X3/9xblz53jkkUfSlTn29jZv3szcuXNZtGgRdevWZcmSJYwcOZL169dn+pn88MMP/PTTT3z33Xf4+voyefJkFi1alOVQY16SHpQQaTimYncvlf8Lj5jc3fGrc6sXVVSG+Q4dOkR4eDhdunQB4PHHH+err77CYrGwbt06evXqRWhoKG5ubowcOZLZs2dnmQ23du3aNGjQwP6Lfd26dXTq1Ak/P78sU6w7qlatGiEhIfZhrY0bN9K6desMM/pmZNSoUfj4+NCgQQOUUhn2Fnbs2IG/vz8jRozA09OTRo0a0a9fP/73v/+RlJTEpk2beOmllyhbtixly5bl/fffp3v37umuk9Uz7d+/n7i4OJ599lk8PT158MEHadu2bYZ1Tu1ZZZfyffny5QwdOpSGDRvi5eXFqFGjiImJYc+ePZmeExAQQEREBN9++y2XLl1i+vTpBdY4gfSghHBitVqd3kF5+BXMylgBde/m0sULAFgSE7H6+xf6aL5ly5Zx8+ZN2rdvDxjDQZGRkWzbto2rV686LdTq5eVF48bZZwfu3bs369atY8CAAaxfv96edyirFOtp9erVi6VLlzJ8+HDWr1/P8OHDc/xMjtF1np6emDOYm3bx4kX+/vtvQkND7fvMZjMNGzYkKiqK5ORkqlatai/LLF1PVs9UqlQpKlSo4JSnqXr16hkO/1asWBGAq1evpksJHx8fj8Viwc/Pj7CwMBYsWMBHH31kL09OTiYsLCzDnhlA69atmTx5MkuXLmXmzJnUqFGD1157jQ4dOmR4fF6TBkoIB5akJKwW45eSm4dnnqV6z45PlcqYwi4CxlJLluRk3L28CK3WKNfDbo4eqtUi3bBfXoiJiWHDhg0sXryYu+++275/4cKFfPnll1SrVo3LttT2YPwinDNnTrp3TGl17dqVWbNmsW3bNpKSkmjVyphXn1WK9bQeeeQRpk2bxr59+zh79mye/zINCgri3nvvZdmyZfZ9ly9fxmQyUa5cOTw9Pbl06ZK9bvv27ePMmTPpkipm9UxHjhwhIiKClJQUPGwrmVy+fJmgoKB09alevTp16tRh8+bNPPXUU05lX3zxBStXrmTTpk0EBQUxdOhQBg26tbLc6dOnqVq1KteuXcvwWc+fP0+DBg1YunQpN2/e5Ouvv+Yf//gH+/fvx7MAfjZkiE8IB07vnwqo9wRgcnPD5HHrB96SULiH+dauXUvlypVp1aoVFStWtH899thj7N69m4YNG7J27Vr+/PNPzGYzn376KT/++CP+/v54eXnZU56nFRgYSNu2bZk2bRo9evTAzc34FZVVivW0AgICaNeuHdOmTaNz58729PN5pW3btvz999+sWrWKlJQUzp8/z9ChQ1m2bBnu7u507dqVuXPnEh0dTWRkJLNnz+b69euA0StzTPee2TM1bdqU8uXLM3fuXJKSkti9ezdbt27NtE6vvfYac+fOZfXq1SQmJpKUlMS3337LggULeOGFFzCZTPTu3ZslS5Zw+vRprFarfRjW8Q+JtHbv3s3zzz9PWFgY/v7+BAYGEhAQYG8085v0oIRwkOK4ikSp/A+QcOTmeevH0ZKYiNVaeIf5li1bluF7lXr16tGwYUO01kycOJFXX32VK1eu0KBBA+bPn4/JZKJdu3Z89dVXtG3blh07dqS7Rp8+ffj+++/p3bu3fV92KdbT6tWrF2PGjOH111/Pu4e2KVOmDB9//DEzZ85kxowZeHt72+8H8M9//pMZM2bw6KOPYrFY6N69OyNGGGno+vbty5QpUzh79izjx4/P8pkWLVrEm2++SfPmzVFKpWajzVDbtm2ZN28eCxcuZObMmaSkpFCnTh3+7//+j06dOgFGgxgdHc2YMWOIiIggODiY+fPnU6tWLS5cuJDhdfv168fZs2cZOHAgsbGx1K5dm7lz5xbYv8sCTflelEjK95Lp5slTXP5hC2Bkvq3cpeDyCh07doy7goLsa/J5Bgbao/tE7hw9epQxY8awbds2ey9MFIwimfJdiKLA7LBQbEFE8KXl2CBZikg0X2GSkJDAiRMnmDt3Lv369ZPGqYiT/3tCODAnJNi/dy+Vt+8ucsItTQMlIxy5Ex0dzWOPPUZsbGyuovdE4STvoIRw4NxAFew7KACThwcmd3esZjNWqxVLYiLuefySvzgLCgriwIEDrq6GyCPSgxLCgTneoYFyQcNgMpmc7ltUJu0KkR+kgRLCgfMqEgXfg4K0w3xJWM2Zr74gRHEmDZQQDiwOQ3xuLhpac/PwcJggbMWcmJDl8UIUV9JACeHAuQflunc/jo1jYZ+0K0R+kQZKCBurxYI5Mcm+7co5SMa9jcmQlpRkSQcvSiRpoISwMSckAkZYt5uXNyaHhToLmsnNDXdvL/u249CjECWFNFBC2FhcPAcqLcdhPnMhS2TYoUMHGjVqRJMmTZy+vvrqq3y7p9VqpXPnzk6rcaeyWCy0bduWtWvXsnDhQsaPH5/pdfIixbwoGDIPSggbc4LrI/gcuXl5YXJzw2qxYLWY7SucFxZz5syxr/NWEEwmEwMHDmTVqlWMGjXKqeznn38mMTGRRx55BK9sPiOZJ1V0FGgPSin1sFJqv1IqWil1Sik12ra/jFJqhVIqSil1USn1tMM5JqXU20qpCKXUDaXUf5RSHg7lA23XilVKbVRKBTmUNVZK/WorO6SUalaQzyuKFqdJuoVgcqzJZMLN2zFYomgM86WmT3/zzTcJDQ1l6dKlmM1mFi5cSMeOHWnRogXjxo1zSmG+f/9+Bg4cSNOmTenduze7du3K8Np9+/bl/PnzHDx40Gn/ihUr6NevH15eXsybN8++cOu8efMYNWoUPXr04IEHHiAyMtKeYh7g8OHDDBkyhNDQULp06eLUAxwyZAj/+c9/6NOnDyEhITzxxBOcPn0aMJIEjh49mmbNmtGuXTsmTpxIQhH5/1OUFFgPSilVA1gJPAV8CzQFNimlzgHDADNQBahn239Ga70DGAX0BUKARGA18AYwVSnVAPgEeBTYB8wClgIdlFJetvu8BzwE9AM2K6Vqaq2jC+CRRRHjFMFXCBqoG38c5Nru30iJjbHtMeHu4w35tJK0m4cn5ZqHUub+7BMLZicuLo5y5cqxa9cuUlJS+OKLL1i7di1LliwhKCiIWbNm8dJLL/H5558THh7OyJEjmTp1Ko888gi7d+/mxRdfZNWqVQQHBztdt1y5cnTu3JlVq1bZEyBeu3aN7du327PopvXrr7/yzTffUK1aNQICAuz7IyMjGTZsGGPHjuXTTz/lxIkTjB49msDAQPtK7WvWrOGzzz6jYsWKjBs3jnnz5vHee+8xf/58AgIC2LVrF7GxsQwdOjTdCuzizhVkD6oW8LXWerXW2qK13gtsBzoC/YF/aq3jtNZ/AIsxGiYwGrT3tNYXtNZXgH8Bo21lTwLrtNY7tdYJwETgAaVUXaAd4Km1fk9rnay1XgocAR4rgGcVRZDTKhKF4B3UjT8OGiubm1J/TK35OmnXkpLMjT8OZn+gzYQJEwgNDbV/jR492qm8R48eeHl54evry/Lly3n++ecJDg7Gx8eHV155hb1793Lu3DnWrVtHSEgI3bt3x8PDgzZt2vDQQw+xcuXKDO/7+OOPs3HjRpKSjIjLNWvW0KJFC2rUqJHh8fXq1aN+/fpOjRPA1q1bqVixIk8//TSenp40bNiQoUOHOt23Z8+e1K5dG39/f7p06WJPAe/v78/hw4fZvHkzVquVNWvWSOOUDwqsB6W1/hn4OXVbKVUOeNC2zwqcdDj8ONDT9n0D4Giasqq28xtg9JxS7xGnlDoP3AcEA8fSVOO4rUyIdCwuXocvrTL3Nybyt31YU1KwpBgNk9VsxuSRP9GFbh6eueo9vfvuu1m+g3LM/hoWFsakSZOYPHmyfZ+HhwcXL14kLCyM3bt3p0uh/vDDD2d43dDQUCpVqsSWLVvo2rUrK1asYMKECTmqh6PIyEin1OwA1apVIzw83L5dvnx5p/qmpoAfO3Ysbm5ufPDBB0yYMIGmTZsydepU7rrrrkzrIXLPJUESSqlAYC2wB9gPJGitHUOU4oDUXAf+tm3HMmzlacscz82qTIh0zIVgFQlHZe5vTJn7G2M1m0m8FklqCLxXuXK4FVBG0zvhmNQuKCiIyZMn8+CDD9r3nThxglq1anHw4EE6d+7MnDlz7GUXLlzAz88v02s/9thjrF69msqVKxMfH0+7du1yVA9HVapUISwszGnf+fPnM0wjn9aJEycYNGgQ48aNIzw8nBkzZjB16lQ+++yzbM8VOVfgYeZKqXrAbuAyxtDeTcBHKeX4r8gXSB14jwVKpSnDVp62zPHcrMqESKcwrMOXEZO7O25eRXtOVO/evZk/fz7h4eGYzWY++ugjBg8eTEJCAl27dmXHjh3s2LEDi8XCsWPH6N+/Pz/++GOW1ztw4ABffPEFAwcOxP025qy1bduW69ev89lnn5GcnMzRo0f58ssv6dGjR7bnfv7550yfPp3Y2FjKly+Pj48PgYGBua6DyFpBR/E9hNFrWgP0t703OokxZb62w6H1uTWsdxRQacrCtdY30pYppXwxhvaOZnBe2usK4cTVK5lnxfGdmDkhoVDNicqJUaNG0apVKwYPHkyzZs3Ytm0bn3zyCaVLl6ZWrVrMmzePefPm0axZM8aMGcPIkSPp27dvptcLCAigS5cu/PDDD/Tv3/+26hQYGMjHH3/Mli1baNmyJc8//zzPPPMMjz2W/WvqiRMnYrFYaN++PS1btiQ6Opo33njjtuohMldgKd+VUnWAA8AkrfW8NGXLMcYvRgB1gM3AMK31d0qpMcDzGJF6sRiN2y9a69eUUvcBO4FewK/AbKCl1rqFLYrvNDAH+AAjiu8joI4t2CK7+tZCUr6XKOc+/5IUW0bdmk8+gWfp0gV6/8xSZYMxSTXpWiRWi6SDF4VbUU35PhYIAGYopWIcvmZhROVZgL+AjcB0rfV3tvMWAt8AuzB6W0eByQBa60PAcNsxV4GGwABbWRJGo9YPiAQmAb1z0jiJkqmwzYNylC5PlMNwpBDFVUFG8Y0HMl9/BB7P5DwL8JbtK6PylRjzqzIqOwy0yV1NRUlkSU42QroBk5s7Jnu6i8LDrZQPxBk9PEtSMhazGTcXrhcoRH6TtfiEIP0cqMwiv1zJzSlYwlokgyWEyI0cN1BKqSFKqfLZHylE0VPY1uHLjPMwX9ELlhAiN3LTg5oLZD9BQIgiyFJI3j9l1+C4eXtjcjN+bK0WM5akpCyPF6Ig5fUfTLlpoPYAffL07kIUEo5DfK6apOvp6Ul8NsEPJpPJOQ1HvAzzicIjPj4ezzx8f5ubIAkL8I5S6k3gLOD0k6S1bp5ntRKigBWGSbpBQUFcvHiRatWqUapUqUzfg7n7+GCOiwesWJKSsKSkFImVJUTxZbVaiY+P5+LFi1SqVCnPrpubf9V7bF9CFDvmQpCssLRt3lVYWBjJyclZHmuOj7engXcLuyhzooTLeXp6UqlSJfu/47yQ4wZKaz0lz+4qRCFTGBooMBqpnPyAx/39N2HrjfQSbl7e1HrqSdwKYWi8EHciV+MCSqmBwCtAXYz8TGOAS1rrd/OhbkIUGOdcUIU3ii9VqRo18AwMJDkqCktSIjdPnCSwYQNXV0uIPJWbMPNhwAJgFZA6GeM4MFkp9XreV02IglOY1+HLiMlkIvDehvbt6MNHJORcFDu5ieJ7GXhOaz0DI/stWuuPgae5lUBQiCLJsQdVGFJt5ERAfWUPjki8do0EhzxGQhQHuWmg6uCQHNDBH0DlvKmOEK5R2JIV5oS7tzf+9erZt6MOH3FhbYTIe7lpoDSQUfrMgRhDfUIUSVaLBXPirQmv7j5FJyIu8L5bw3yxp8+QEiPpzkTxkZsgiTeAFUqpUNt5zyql7ga6YyQeFKJIMickkpqt1t1hpYaiwLt8eUpVrUp8WBhWq5UbBw9R4YFWrq6WEHkixz+JtvQXzQFv4DDwMJCAkX9pbf5UT4j8Zylkqd5zq8z9je3fRx89ijkx0YW1ESLv5CrMXGt9BBiWP1URwjWKykKxmfGtGYxX2bIkXb+OJTmZ6KPHKNvkfldXS4g7ltt5UI9jzH1qCCRhJA+cobX+IR/qJkSBKGoh5mmZTCbK3N+YiB+3AxD15yHKNLoPk+SKEkVcbuZBvQB8DOzFyI77MkYD9a1SakT+VE+I/Ofcgyp6DRRAQL269t5fSmwsMadOu7hGQty53PSgXgee0Vr/z2HfV0qpfcAU4JM8rZkQBcS5B1X0hvgATO7ulGl0H9f2/AbA9QN/4F+vbqFMvChETuUmXCkAOJDB/j2AJDIURZalkKzDd6dKN2yAm4exHl9SZCTx5y+4uEZC3JncNFCfAm8ppew/wUopE8bafF/ldcWEKCiFIdVGXnD38SHgnvr27esH/nBhbYS4c1kO8Sml9pI6QQTcgSbAw0qpQxjLHTUAgoDN+VlJIfKTuYiHmTsq0/g+og8fNvLzXLxIfPglSlWRhV5E0ZTdO6j1abbTznf6+XZuqpRqDqzXWgfZtr2BmxiRgal2aa0728oHAu8AVYAdwDCtdYStrDGwEGgEnAGGa6332srKYAR2PAzEAG9qrZfcTp1F8VXUo/gceZYujX/dutw8cQKA6/v2U6pHNxfXSojbk2UDldc5oGxDgiOAtOk57gMitdbp/tRTSjXACMB4FGMtwFnAUqCDUsoL+BZ4D3gI6AdsVkrV1FpHAx9i9PSqAPWATUqpM1rrHXn5XKJoKy5DfKnKhoZw88RJwErc+fMkXI7Ap1KQq6slRK7lOIpPKeUBPIkxByrdYmVa6xdzcJkpQDfgbeBNh/1NMRadzciTwDqt9U5bPSYC15VSdYHagKfW+j3bsUuVUs8DjymlvsJYgqmh1joO+EMptRgYhdELEwKr1VpokhXmFa8yZQioW4ebJ08BRi+qSrdHXVwrIXIvN0ESXwDzgVCMhIVpv3Jioda6KelXRQ8BgpRSfyqlLiulvlFKVbOVNcCYbwWArbE5j9HragAcS3Ot47ayehjvz05mUCYEANaUFKxmM2CEaps8cjV3vdAq27QpYISYx/71F4lXrrq2QkLchtz8NHYH+tvW5LstWuuwTIpigV+AqUAyMBdYjbH2nz8Ql+b4OMA3B2UJWmtrBmVCAOnfPxWXeUNe5crif/dd9gm7kfv2U+XRLi6ulRC5k5sGKgLIrIG5I1rr8Y7bSqnxwBWlVA2MxivtiwFfjKCH7Mp8lFImh0YqtUwIoOivw5eVsk1D7A1U7NmzJF69hncFmbIoio7cNFCvAAuUUm8CZwGLY6HW+u/brYRSairwP6116nBdakr5BIzhPeVwrC8QbNsfD7yU5nL1MYYjT2KMcdTGiO5LLTuKEDbFKYIvLe/y5fGrXZvYs2cBiNy7lyqPPuLiWgmRc7lpoDww3t9sSbPfhPGu505WpmwEhCqlnrBtvw9s0FpfUUp9DexUSrUDfgVmAAe01ieUUucAk1LqJeADjCi+RsBqrXWMUmo1MMO2VmAdYCSyGrtwUFxWkchMudCm9gYq9uw5Ei5dwqeyzIsSRUNugiTmAMuBlhiNQOrXfbb/3okRwHXgFHAOYz7UEACt9SFgOMZcp6sYUYQDbGVJGOHn/YBIYBLQW2t9xXbd0Rg9vb+AjcD0O3mHJoofxxBztyK6Dl9WvCtWwP/uu+3b137dg9VqzeIMIQqP3PSgygJva63P3elNtdbbgTIO29eAwVkcvxJYmUnZYaBNJmXXgcfvpK6ieCtuIeYZKde8GbGnTxurS4SHE3/+PL7Bwa6ulhDZyk0PahkwKL8qIoQrOE/SLZ4NlFeZQEo3aGDfll6UKCpy04OKAf6llBqMMRSX7FiotR6YlxUToiA49aCK4RBfqrKhIdzUGktKConXrhFz6jQBde/O/kQhXCg3PajSwP8wJtnewAjjdvwSosgpzlF8jjz8/AhsdGuOeuTuPfYJykIUVjnuQWmtn87PigjhCsVtHb6slGlyP1GHj2JJSiT55k2iDh2mzP2NXV0tITKVm7X4umZVrrXeeOfVEaJgOTVQvsW7gXL39qZcaAhXd/0KGKtL+Nerh0cxf25RdOXmHVTa1BupEoALGGHcQhQZVrMZS5KR4cVkMuHmnW4N5GIn8L57iTpylOSoKCxJSUT+tpegdg+5ulpCZCjH76C01m6OX4AnxsoMv2CsTi5EkeL4/smtGK3DlxWTuzsVHmht344+ekwWkhWFVm6CJJxorc1a6xPAyxiLvApRpJSk90+OfGsG41ujhm3LytVfdknYuSiUbruBclAaqJAH1xGiQJnjby2EX5IaKJPJRIUHWtt7jPFhYcSeOeviWgmRXm6CJGZnsDsQY/KuLB8kihynEPMS1ECBkY4j8L57ufHnIQCu7foV3+AauHl6urhmQtySmx5UszRfoUBNjNxNI/O+akLkL8chvpIYyVa2WSjutsCQ5Js3idybNo+oEK6VZQ9KKeUY3vNWFoc2An7KkxoJUUBK6juoVO7e3pRv3YqIH7cDEHXwTwLq1ZOcUaLQyG6Ib3sWZWnfqt5Jug0hCpzzSubFdxWJrATUV9zUJ4gPC8NqtXJl+w6q9e2NyS0vXk8LcWey+1cYkMVXV4zUGPHAa/lXRSHyh/MQn68La+I6JpOJiu0ewuRm/H2ZEBFB9BHJ6SkKhyx7UFrrdGvsKaUCgVnAM8AmoIPW+q/8qZ4Q+cc5SKJk9qAAvMqUoWzTJvZ3UNd278Gvdm08/P1cXDNR0uWqH6+UGggcA3oBg7XW3aRxEkVVSX8H5ahsSBM8AwMBsCQnc+Wnn2VulHC5HDVQSqlgpdQGjNXM1wH1tdbL8rVmQuSzlLiSOQ8qIyZ3d4LatbVvx547R8yJky6skRDZR/G5AS8B/8JIm/6Q1vqXAqiXEPnKkpxsTzdhcnPHJPN/KFWtKoH3NiTq8BEArvy8k1LVquLh7+/imomSKrsovr3A/RjBEB8DjZVSGa7Pr7VekLdVEyL/pM2kWxLW4cuJ8q1aEvf3eZKjo7EkJRHx43aqdO8mn49wiewaqPLA3xhDgeOyOM4KSAMligznNBslM4IvI26engR1bM/F1WsBK3HnLxB99CiBDRu6umqiBMouiq9WAdVDiAIlARKZK1WlCmUaN+LGwYMAXPtlN77Vq9uDKIQoKLnJB5VnlFLNgfVa6yDbthfwAdAfMANztNYzHI5/AWOuVSDwLTA6NQReKdUeeB+oAxwEhmitT9vKgoFPgJZABPCCJFYUICHm2SnXohlxf/9N0vXrWFKSubR5C9X79sbkLvPxRcEp0OniSimTUuoZYDPg5VA0BVAYjUwz4Cml1FDbOV2ASUAXoArgA8yzlVUA1tjOLwOsBjbZgjsAlgJ/YgxVjgSWKqXuys9nFEWDWSL4suTm4UFQx/b2FSUSr1zh2u49Lq6VKGkKej2TKcBzpE9w+BQwXWt9XWt9DngXGO1Q9qnW+ojWOgZ4HXhCKeUP9AWOaK1Xaq2Ttdb/BryBjkqpehgL2k7WWidprbcBa4ER+fyMoggwJ5TclcxzyicoiPItW9i3bxz8k9hzMu1RFJyCbqAWaq2bAvZlk5VSZTB6Ro7rqxwH7rN93yBN2WmMetfLoAxA285tAPydZjUMx+uKEiwlVnpQORHYuBF+NWvatyO2biMlJt0CM0LkiwJtoLTWYRnsTp1kEeewLw7wdSi3l2mtrUCCrdw/zXmO52ZVJko4xyG+kroOX06YTCaCOrTDw89Y9sicmMjlH7ZgtVhcWzFRIhSGJYtT/xxz/DPWF4hxKLeXKaVMGO+hYtKWpTk3qzJRwqXE3uoFuPvJmnNZcS9VikoPdwRsGXjDw7m261fXVkqUCC5voLTW14FLGEESqepza+juaJqyOhg/KSczKHM89ygQrJQqlUGZKOGcelB+0oPKTqmqVSnXPNS+fePPQ9zUJ1xYI1ESuLyBsvkSeEspVUEpVQuYYNuXWjZSKdXIFhgxE1hle7e0GmN1i4FKKU+l1ATAAmzXWmuMsPPpSilvWzh6L+Drgn00UdhYkpOxJCcDxjJHbrassiJrZZuG4Fe7ln07YvsOEq9ccVl9RPFXWBqoycBh4AjG8korgYUAtnlL0zDmP13E6D2NtpVFAD2AiUAkxjyqHlrrJNt1+wH3YMyB+hgYobU+XDCPJAorxwAJDz9fWcYnh0wmE5U6dsCrbFkArGYz4d9tIiUuPpszhbg9JllSP2O2ntzZrVu3Ur16dVdXR+Sh+LAwLq5ZC4BPpUpU79fHxTUqWpJu3ODCilVYkoy/A0tVqULVnt1lEq/I0oULF+jYsSNAbdt0omwVlh6UEAXGKcRcIvhyzatMGSp1cg6auLz1R8kfJfKcNFCixJEAiTvnV6sm5VvdmsQbc+oUkXt+c2GNRHEkDZQocZxCzKUHddvK3N/YaZXz678fIOqIBMmKvCMNlChxnHtQMgfqdplMJio8+G90UzcAACAASURBVAB+NYPt+67+9LMshyTyjDRQosSRd1B5x+TmRqXOD+NdoQIAVquVS5s2E38xo0VjhMgdaaBEiSPLHOUtN09PqnR7FM+AAMAWfr7hOxIuR7i4ZqKokwZKlChWq5WUm7dWu/LwlyG+vODh50fVXj3sDb4lJZmwdRtIvHbNxTUTRZk0UKJEsSQlYUmxrSLh7o6bjyQrzCuepUtTtWcP3G0rc1iSEglbu56kyOsurpkoqqSBEiVKSoxj78lfVpHIY17lylKlRzfcPD0BMMfHc/HbtdKTErdFGihRojgO76W+MxF5yycoiCrdu+LmcauRCluzlsQrV11cM1HUSAMlSpS0PSiRP4zljxx6UomJXPx2nQROiFyRBkqUKM4NlARI5CefypWp2rMHbl4O76S+XUfc+QsurpkoKqSBEiWKUwMlQ3z5zqdSENV6OQROpCQTvn6D5JISOSINlChRnEPMZYivIHhXrEC1Pr3tq3ZYrVYub93GjT8OurhmorCTBkqUKM49KGmgCopXubJU79cHr3Ll7Puu7vqVKz/txGqxuLBmojCTBkqUGFaLxWmhWFmHr2B5+PtTrU8vfCpXtu+LOnyY8PUbMScmurBmorCSBkqUGOa4ePtf6+7e3vYIM1Fw3L29qdqzO/533WXfF3fhAhdWrCLpukzoFc6kgRIlRnJUlP17z8BAF9akZHPz8KBSl4cpF9rUvi85KooLK1cTc+asC2smChtpoESJkfz/7Z15tF1Fmeh/ezjjnXNzp4TcjKSACIRAEHgCakBA2xm11Vb6YSuvl9Nz6OXU2s2ybX1OTS/t91Dbdnqv1feQaTkggkgjiCTYTAmpzCS5yc2dpzPv4f1R+56797n3JgGSnHNP6rfWWeec+nbtXbXrnP3V99VXVRMT5c92c3MVS6IxDINFF2+k+1VXl7eK94pF+u/5NUMPP4LvulUuoaYW0ApKc9qgLajao3HNas540xsiEZVjTz5F3513U5qcrGLJNLWAVlCa04awgoq3agVVKyQ6Olj21utpWL68nJY/coSD//c2Mnv3Va9gmqqjFZTmtKE0rl18tYqVTNL96mtpv/SS8gK+bqHA4V/dw8BvH8ArFqtcQk01sKtdgGmEEDcC3wLC8abvB34MfBO4HnCBr0spvxjK90HgE0ALcBdwk5QyE8heAfwzsBp4EniXlHL3ya+Nptbwfb/CxacVVK1hGAZtF6wn2d3FkXvvK08JmNguyfUdovOVryC1dEmVS6k5ldSSBbUB+JqUsjH0+gFwMyBQSmYjcIMQ4t0AQohrgM8A1wA9QBL4RiBbDNwZ5G8F7gB+LYSopTprThFuLo9XUvtAmXYMK5Wqcok085Hq6WHZ295C45o15bTS5CR9d93N4EMPa2vqNKKWHtYXAk/MkX4D8AUp5aiUch/wVeCmkOzfpJRbpZRTwCeBdwghGoE3AVullD+TUpaklF8BEsCmk10RTe3hTEStJ70PVG1jJZN0v+oquq6+qrzYLMD400+z/8c/1WNTpwk14eITQljAecC7hBBfB7LAv6Jcfj3AttDh24Fzg8/nAL8MyXajlO7aQBbOByCDvL85wVXQ1DjFMR3BtxBpOnMNqZ4eBn73INn9+wFwMhkO/+oeGlasoOOKl+k1FeuYWrGgOoAtwA+Alajxpr8GPhjIs6Fjs0A6+NwYlkkpfSAfyBsr8lXm1ZxGFEdGyp/ji9qqWBLN88VubKDnNdfRddWmiGs2s28f+//9p4xseRzPcapYQs3JoiYsKCllP3BlKOkJIcQ3gOuC7+EBgzQwveJnJiwTQhiocaipQFapjMJ5NacRxeGwglp0lCM1tYhhGDStPZN07zKGH/0jE9ueBdT2HSOPbWZi6zbaL7uUxjWrtfu2jqgJC0oIsU4IcXNFchxlDfWjgiSmOYsZ1922CtlqwAB2ziGrzKs5jYhaUFpBLVSsZJLOl1/J0je+PtKOTibDkd/cR9/td5I7dKiKJdScSGrCggLGgI8JIQ4C3wUuAD4EfADYCvydEOIplNvu46jQcYAfAd8VQtwG7AG+BNwupcwIIe4AviyEeCsqgu/DgAf87pTVSlMTuIVCOWTZMC1iepLugifV08Oyt17PxLPPMvLYFtxcDlATfPvuvJv0GWew6OKLIiunaxYeNWFBSSn7gNehovMmgJ8Bn5dS3gZ8DngGpag2B7Jbg3y/BD6Pmv/Uh7KebgpkA8BrgU8BI6hxrddKKXWM6mlGcWRmlex4WyuGWRM/e82LxDBNWtato/cdf07bBesxTKssyx48yMHb7+TQz39JfmCgiqXUvBgM3/erXYaaRAixAth7//33c8YZZ1S7OJoXwfjWrQw++BAATWvPpOsqPdOgHilNTDC65XEm5Q4qn2vpZctovWA9qaVL9BhVlTh48CCbNm0CWBlMGTomteLi02hOGoXB4fLneJuO4KtXYs3NdL7yFbRuuIDRzVuY3LkbUIoqe+AA2QMHSHR00Lr+fBpXr9KW9AJAKyhN3VMIuXgSnZ1VLInmVBBvbaXr6qto3bCB0S1bmNq9l2lFVRgc5Mhv7mPk0SZazn0JTWcJrGSyugXWzItWUJq6xiuVKA5PW1AGic6OqpZHc+pItC+i+5pXURwbZ/zJp5jYvr28z1RpcpKhR/7A8KOP0Xjmalpeso5EZ6d2/9UYWkFp6prC4GB5PCLe1oqVSBwjh6beiLe20HHl5bRtvIjxp59h4plncAtqTWrfc5mUO5iUO0gsXkzTWYLGNWuw03qtxlpAKyhNXZM/MuPeS3Zp997pjJ1O0f7SjbRtWM/Urt2MP7OVwuBgWV4YGqLw+yGGH36EdG8vTWcJ0st7MW39mKwW+s5r6pp8/5Hy50RXVxVLoqkVzFiM5rPPovnss8gfGWBi61Ymd+4qu/983yfz3HNknnsOM56gcdVKGlavIn3G0vL29JpTg1ZQmrrF9zzyoVUFklpBaSpIdnWS7Oqk/b9cxtSuXUzKneT7+8tyr1hgYvt2JrZvx4zHaVixnIZVq0j3LtOW1SlA32FN3VIYHCqPNVipFPF2vcSRZm6sRIKWdetoWbeO4tg4UzvUuFRpcrJ8jFcsMrljJ5M7dmLaMVJLl5Be0Ut6WS+x5qYqlr5+0QpKU7dkDxwof04vW6YjtDTHRby1hUUXb6Rt40UUjhxhavdeMnv2RJWVUyq7AUHNr0v3LiPd20uyp1tbVycIfRc1dUt2f0hB9S6rYkk0CxHDMEh2d5Ps7qb9sksoDA6S2bOXqd17KI2PR44tjo5SHB1l7MmnMEyLZHcXqSU9pJYuJdHVqRXWC0TfNU1d4mRzFI5MB0gYpPRyVZoXgWEYJDs7SXZ20n7JSymOjZPdv5/sc/vJ9R3C99zysb7nkjt0SK2qvuVxpbC6Okn2dJPs6iLR1Ymd1tvSHQ9aQWnqkqldu8rzn5LdXXpei+aEEm9tId56Lq3nnYtXKpE7dJjsc/vJHjgwy7ryPZfc4cPkDh8up8Wamkh0dZLs6iLZ1Um8vR0zFjvV1ah5tILS1CVTO3aWPzeJM6tYEk29Y8ZiNCzvpWF5LwBONkuu7xC5vkPkDx2iODY2K09pcpLS5CRTu3YHKQaxlmYSHYtJtLcTX6zerYb0aT12qhWUpu4ojoyWt1gwTJPG1aurXCLN6YSdTtN05hqazlwDzCiswsAA+SMDanUT163I5VMaH6c0Ph5SWkH06aI24m1txFpbibe1qRVRGhpOC8WlFZSm7hh74sny5/Ty5XoxUE1VqVRYvutSGB6mcCRQWAMDFMfGmV7QNoyby5Hry5Hri+4SbNoxYm2txNtaibW0EGtuxm5uJtbchJWuH6tLKyhNXeFMTTG5Y0f5e+v686pYGo1mNoZllQMuWs5VaV6pRHFklMLQEMXhYQpDwxSHhvGc0pzn8JwShcHByFJN4fPHAmVlN02/N2E3pLEbG5UCWyBbjWgFpakrhv/4GL7nAZDs7ibV01PlEmk0x8aMxcqrWkzj+z7OxEQQwj5GaXSM4tgYxZFRvGJh3nP5rlsOe58bQymrhgashgbsxkbsxgb1PZ3CSqWxUimsZKLqikwrqJPEroNj3POHfQCsXtrCdZetjMif3TvCbx9X83TOWt7Gpo29EfnTu4Z46Mk+AM5dvZjL1y+NyP+0fYDHtqklWTaITi5e1x2RP7a1n//cocZhNp7TzQYRXSj14acOsW2P2obisvOWsG5Ve0T+4J8OsvOAGty94oKlrO2NbvR3/+b97Ds8AcArL1rGyiUtEfmvH91H32AGA3jVJctZ2tEYkf/i4b0MjmYBePVlK+lcFA27ves/djM+pf6Er718FW1NUTfd7Q/solB0sG2TV710OS2NCXJ9h5iUynqayhZJrn0JruthWQujt6jRhDEMQ7nvWlpoWDGT7vs+bi5PaUwpIWdiktL4BKWJCUoTk0dVXsEZcDIZnEzmWCXASiWx04HCSqdIdHTQvO6cUzavSyuoU8E8/uDKbanDeL6P5/nzHuf5Po6rLAXXmy13XI+So+TeXHLHo1Byg/zeLHnJcckXnXnzF0suucL88nzRJZsvzSvP5ktM5UrlusyS50pMZIrz5p/MFpnMFmfqk8lw5L77y9/3+M38/tkpzO1P89ar1rK49fjDzHOlPAVXndsA4lachB3HNLSi01QfwzCw0ynsdIrUkiWz5G6hgBMoq9LEBM7EJM7UVFkpubnccV7Jx83lIsdP7tgJvk/r+vNPUG2OjlZQpwF1Ml46L2apwOHf3FvuEZrxOAOtZwNq2LmlMT4rT77gkEzM/fP//XOb2Tu6f1Z6zIqRtBMk7DhJO0HSTtLbsoQ17Ssix2VL6g+dtBKYC8TXr6kfrEQCq6ODRMfcm3P6rouTyeJkpnCmMriZTFmBuVmlkJxsbl5LzIzP/j+dLIyj9eJPZ4QQK4C9999/P2e8yFUIfN+fFVXj+z7hW2+aUbnn+TOWk2FgVchdb8bCMg1mubFc1ytbVpZpzJKXHK9sOcUscw65i+uq/LZtYlfICyUXN7Dg4jFrljxfcHCC6yfjs+XZfKlc/lTCnnX9qdyMvCE5Wz6RKSor7nA/7uZHcKYmg1tl0HHdtTzU5zEykccw4C+uPTuSN5cv8e1fPEa8JcP5K87g0tVnR9rnkf2P88yR7RwP53WfzSXLNkTSfrvnYXYN71P3xoqRjCWIW/HgFQte6vPy1qV0NETdq5liVrl3TBvbtOsmIkuzsPBdt2xBOdkcbjaL3dRIasmSFzQ2dfDgQTZt2gSwUkq573jy1L0FJYQ4H7gVOA/YA9wopdx8Kssw1wPGMIyjWjZKYc1/gGXOVloRuWVytK1rYrZJjPl/ZDHbInaUX0ciZkFs/gvMZ51Mk04efdZ8Y2p+ue/7xMaGyG7dSmHXHmbCcw06Xn4lzSuW85oVKmVaiTqeS//kAPvHD/HYHskeZwiGYSAzwKWrowqsNdlMc7KpfK2iW1Iuvzk6c0l7dgh73pnpeRbdEkV37kgsgHQsNUtB/XrXgwxlRsrfbdPGtmxs0yorrZil3i9ccu6s/NsHd+H5PpZpYhkWtmlhGqZ6Ny1sw8IyLSzDpCGexjL1Hkea2RiWFQRQNFKtfajrWkEJIeLAXcAtwBXAm4F7hRDLpZQTVS2c5qj4vg+ep/zpU1M4U1OUxsbJHxkg398/y49uxmJ0bnoljatW4noufRP9TBWzjOTGGM6OMpQdwQ3WSxvPTWHgYfg+yXSGydF+0paN77n4nktX1uC65rNIxC2MoJPg+z4Fr0TBVa+8WyTvFllcKFI4vDtSFmNyjFghT8ErzR4/rOhTGGMDFDwrIsyND+KWsuVjXGC+Ye+1ViPNDTOrbBuGwSM7H6TgOce+ycCbVl5OW2ImgMXxPP7PrvuwDKXATMPENIzIu4FR/nz1GRcSM2ceI1mnwObB7ZiE8wWfiZ7LMi3WLVoRKU+mlOdgZhATQ3XiMDAMM/jMTBoGccumKx3dQiXvFJksZcEwZs5hmJihG28GPUPLtEjHoh2MkudQ8hxmrgJgYJjlT+X36TqEG9X3fXz8oNyVjT1fh/IoPVVj3i8Vpz5OK/uox80jCyWb8RSGderURl0rKODlQExKeUvw/SdCiA8AbwO+c7Iumt2/h52/uo2+sdlzFMq9/dBzK2nZ9Mai+8mMOjkGnDkGM/2KzECjGWdJrCFyzJCTZcTNR7PO481tsxJ02KlIufqdDBNu6LF4FE/wYivJonJ+deCB0hRZr9JymF13gG47TbOZAHx818N3XQ7mJyl5lbPtZ5/LA5Z1d7Nk1SqKBx5l5MCjuL7HXRO7Iof6eOB5+L5PKz6LLIPWgsU5OZ/sH+6kEPrj7ukbJ1dwMA1Y29sWdS/6PoeD6EXTMLB7mgn3dFzXY/HAJItRVnBXZwMF36OIR8n3ybkuh0ancAwf34TYxJ+YMGesxWLJZXT8IFnDwzchmYr+RV3XJ1tQ99U2TQoTBSbMmf5tLu9wOLsfHx/bNEklo/kdxyMXBL/YlklmvIQZUjAjmTxHCip6NGZZJBNR66pU8siXVP64bXHx4SPEQsEj+ycz/LGkokvjMUtZ2iEKRZeio9q1MRZjaVM0enX7+DgPukMAJGM2sVil69ilFKzC0BFP8qbGiujW0WE2+yr6NJWwZ7mWc3kHJ3Btr0g2cE06Gv360PAA2wyl8NOJGJYVfWhncg6er/Kfk2rh8tTiiPzeocPsNVXnojEVxzBmlBpAJlvE99Uz/6KmRayPt0by/3ywjwFTBeg0N8RDOQ3ALwcOGcDLWjpYY890LlzX4+6RPsZNB9MwaG6IjhV5HkxmCkq5mgavaOlkqTUTPFQsudw51kfB8LAsg6Z0NL/r+GxqWMqyS19PrC16304W9a6gzgGerUjbDpx7Mi/a/4s7yO3bR9E7VrinwsQkb2UjaQWvRMkvzpMjShGbwqz8RUr+/K6lSH7DpmhG85e8Ao5/fL3wolGkaEaVqePmcTmaggldy3QpGdH8JbdIkdnRhdO4tkG2PcVUZ4rlbW3g5XAzM+eIOS6Fius3GzF6rCQ9ZpIuM4GVnt1jdD2f/HR0oj97bND3IZtX8rk6oz7qIQZgWQYJwyJhzDyki55LLqM6DjHbpGVx1JXpeT4vmVAPnWTcYmVrCy4+Dj6O7zOZL7JvYhLX8IknLJpbovkd16UzF8PDJx63aEsncfHLr6zv4Bc9PHxicRO7ohIFz8VxgrFLY57o0UBum37EMgEoOk5EToWn1vNm8nvW7PMXHBcnGPv07DlWVvC8cn5/Di9woeThEJJXeC+d0PXn6rAVHRdnut5z+LXCY7tzUSi5ONbM+Q0D/FCPrOh65evOGb1acsjZ6neb9L2oUeNDNrREklvR0/OBKcchY7kYBth+tPKe7zMVdPpMjFn5Pc9n0nPIGx4WBvhR5e74Hk4xT3HgOa2gThCNQLYiLQuc1LXuk0uWwL7dxz5Qc1R8wLMN3LiFGzdxEhbFhhiFxhiltF3WEKU5FNkyK4WHT5Nh02bEaDXjpI0ZV5ph2eUXpqU+mxalooffmiRb9PB8g2R3qIduGLiex/hh1bO0TINEdzSAxii5jPerJ1vcNkl0RcOAvYLDxICyMJJxi0SX+qNPP6uKuSITQ2r+mpeKBdvUzzxI7KkC+0cHMYHmZJzGzmiklpHI0z2qesVtiSTnLl0cyT84muXZcTWBs6MxRUtHdH5bnCkuGE/j4dPRkGJFTws+Pq6nlNrh4Qz7pybwgY6mFIn27oiijhdTLB+y8IHFzSk62lQ7eIDve/SPZhnKq45EVzJNbFFPRFPYGYtFkz6+4bM4kaK5MYGPCijyfY8jpSxTxRI+sCjZRKy1K8ipzmGMlUgWlYpqSaRIJKzg9KoMxXwWgo5LMtGM3RLcv6AM3vAURuAejcdSxOyZh7SPr1x9gQVlJxuxm8Ljfz7OwDCuGSiBWHxWFKdreOXWMFONWOno/S+Z/biBgjRi8ah+8sE11LkNA8xkA1Z8Zv6h57q4ZhzPKGEYBqYdj3grfMPDC/JjmFiJBqzYjAVmGCVcw8YzXEzTxLRiURXme1htPSSXRcdsTyb1rqAyQOUEmDQwdTIvuuT1byd53gbah/pmEg1jHg+vQdyyaEtEXXwdToElTr58TCR/+IlgQNyM0RxvqMifJzc9WB8cP59PPGnFaYilIukdxRzFCgssXIPwuZJ2gmTIl28AHaWsihI0KnOGj1KkYgniVgwwMOMxDNumxy3ghf7b6npGRU6wDIukncCuiAi5pqKshmXDtEIKxjTmohVYQjDmVHJJxqN/Ec/z2bg8U/7jNldMQHZdjw0rVLi7ZRqz5CnH44LVSh6zTZrbo+2WKrlcsFb1qeIxi5aKCcyJosP6s9UDPjGXvOBgvyQIc4/btLRFf/6xfInE+ep3lU7atLRE5VauRMOEkjekYixqjo7RdGaL9E6q31VjOjZrAvWaqQKdmRkXVUtj1AwZmyyU56+1NCZmuaHOn8yzOqt+d21NCRor3EzD47myBdvekpwVbHPpOTnWF+aXD47myvP7OlpTs4J5rjony+XB/MDORelZLsr+4Ux5fmF3e5qYHZW/9uxMeX5id3sa2zKVBeUrBXdocArXU+NUSzuaiFdMeH3dmhGmVdjSjobAsafwPJ9DQ+rRZZoGvZ0txKyZ+rmuxxuPDKuoYdOguz302/DV+OKREfXbs02T3s62SP7Gksv1A4N4vk/MNuloTUUUVKHo0JZuxjqFmy/WdZi5EOIa4DtSyt5Q2u+BH0opv32MvCs4QWHmGo1Gc7qjw8xn8wBgCCE+AnwTFcV3HnBHVUul0Wg0mmNS19PcpZRF4DqUYhoBPgO8QUo5V3idRqPRaGqIeregkFI+A7ys2uXQaDQazfOjri0ojUaj0SxctILSaDQaTU1S9y6+F4EF0N/fX+1yaDQazYIn9Cw97sUftYKanx6Ad77zndUuh0aj0dQTPcBxrWSgFdT8bAYuBw7Dca7Zo9FoNJr5sFDK6bh3k6jriboajUajWbjoIAmNRqPR1CRaQWk0Go2mJtEKSqPRaDQ1iVZQGo1Go6lJtILSaDQaTU2iFZRGo9FoahKtoDQajUZTk2gFpdFoNJqaRK8kcRIQQpwP3IraHHEPcKOU8rhnT9c6QoiLgZ9LKTuD73HUhpDXo1bd+LqU8ouh4z8IfAJoAe4CbpJSZk55wV8gQoirgS8BZwIDwFeklN8SQrQC/wpcDUwBfyul/F6QxwA+D7wPiAPfA/5GSulUoQovCCHEnwH/CKxE1fvLQb3rur0BgrZ9CviclPL79d7WAEKIG4FvAYVQ8vuBH1Ol9tYW1Akm+PPeBfwUaAW+ANwrhGiuasFOAEIIQwjxV8C9qD/iNDcDAlgNbARuEEK8O8hzDWqjyGtQy5wkgW+cynK/GIQQy4CfAf+Aas+3A18M6vW/UH/YHuA1wJeEEFcGWd8HvAnYgFJsG4FPn9rSv3CEED3AbcAnpJRNwFuAW4QQG6jj9g5xK7A09L1u2zrEBuBrUsrG0OsHVLG9tYI68bwciEkpb5FSlqSUPwG2Am+rbrFOCDcDf416WIe5AfiClHJUSrkP+CpwU0j2b1LKrVLKKeCTwDuEEI2nqMwvlhXAv0sp75BSeoEl/DtgE6pH+VkpZVZK+QTwHdTDClS9b5FSHgx2cP57Zu5JzSOlPAx0SCl/JYQwgXbAASap7/ZGCHED0Aw8HXxPU8dtHeJC4Ik50qvW3lpBnXjOAZ6tSNsOnFuFspxobpVSXghsmU4IXB89wLbQceH6nlMh24363a09uUU9MUgpH5JS/rfp70KIRcwsIuwDO0OHH63e24ElQf4FgZRyMng4F1BW878Ag9RxewshVgJ/B9wYSl5Lnbe1EMJCDUm8SwhxSAixSwjxSSFEG1Vsb62gTjyNQLYiLQukq1CWE4qU8tAcydM9pXCdw/WN3A8ppQ/kWYD3QwjRAtwN/BF4HMgH9Zlm3nqHPi+0eueBBpRr50bgw0F63bV38JD+38DHpZThjeAaqf+27kB1PH+AGnO8HuUt+WAgr0p76yCJE08GSFWkpVEDq/XI9GBouM7h+kbuRzCgnGSB3Q8hxFrU2OI24J3A2UBSCGGEHlzz1puZP+yCqreU0gOKwBYhxLeBiwJRPbb3ZwEppby9Ij1Dnbd1oJCvDCU9IYT4BnBd8L0q7a0tqBPPNtSAYpiziJrBdYOUchToJ1rncH0r78dqwCDqLqlphBBXoKymO4HrpZR5VPkNVG9zmqPV+yzgsJRy7OSX+MUjhLhSCPF4RXICqOf2/nPgeiHEmBBiDOXG+p8oK6Ju2xpACLFOCHFzRXIcZQ1Vrb21BXXieQAwhBAfQYVmvhnl272jqqU6ufwI+DshxFMok//jwD+HZN8VQtyGCrn/EnD7Qgk7FkKsBn4OfEZKWY5OklJOCSHuQEX0vQf1x3wv8JfBIT8CPi6EuB/Vy/z7IG2h8ASwVAjxUVRbvhR4D/BG1AOr7tpbSnlW+LsQ4glU8MP3g0H/em1rgDHgY0KIg8B3gQuADwEfQAV5VaW9tQV1gpFSFlFm8ZuBEVQI5huC6J565XPAM6gf8mZUWPatAFLKX6LmiNwF9KF6Vwspwun9QBPq4TQVev0PVD084Dngl6hIp18F+W4F/h/wCKo3uQ11nxYEUspx4NWo8OkR4NvAX0kpH6S+23s+6ratAaSUfcDrUPWcQLXp56WUt1HF9tY76mo0Go2mJtEWlEaj0WhqEq2gNBqNRlOTaAWl0Wg0mppEKyiNRqPR1CRaQWk0Go2mJtEKSqPRaDQ1iZ6oq9EcAyHE91GrNs/HzagVzh8AmoJVnU86wdpxDwPvRi1HtBc4V0r5zKm4/tEQQjQAjwKvkFIOVbs8moWJtqA0mmPzYdSKzj2o7VQALg6lfRU1SbOHmbUJTwUfAp6UUu44hdc8LoKVkM3UswAAA+ZJREFUBL4FfKXaZdEsXLQFpdEcg2BVhXEAIcTiIHmwYsVrUEsAnRKEEEngU8ArT9U1XwDfBf5RCPEPUsrd1S6MZuGhFZRGcwIQQryckItPCOGjdt/9FGoxzS3AXwB/A7wLtZzMp6SUPwryNwFfQ21z4AO/BT48zxYnoBY2HZvDnXeNEOKnqPXingTeM31MsEvul1G7nyaBe4JrHBZCrKDCRSiE+Evgq1LKxSH5Z4GPoBbPfR3wT6jddltQW5B8VEr5GICUMieEuBe1nttHns/91GhAu/g0mpPJl4D/DlwC9AJ/QimmjcDtwLdCO49+G6XIrkFte+ADvxZCzNeJfA1KwVRyE2ofnwuDc3wHQAgRA+4PyvFqlOW1FLgz2CLhePkz4FKUov0gcC3wWmAdsAO4reJ89zCzZYNG87zQCkqjOXn8i5TygWCL8J+j9sj5tJRSAl9H7aOzUgixCmURvUNKuTmwYN6F2m7+2nnOfRFq8c5KPiml/A8p5VbUavrnB+nXAGuAt0spt0gptwBvAzYAVz2POt0ipdwRnH8FarO6fVLKPcBHUcEk4efKNkAspC3fNbWDVlAazcljV+jz9IN8enXmfPCeQG2bDSCnV0sHhlE72VbuLTZNFzBXdFx4rGeMmc3k1gHPhV2GUsqDwL5AdryEz/9NlGvvkBDiQdR2HE9JKd3QMcPBe+fzuIZGA2gFpdGcTEoV3715jrODYy8A1odea4HvzZPHQ21tUIk7RxpAbp50A/UcmGtbg7nci+XzSCl3ohToWwAJfAz4TyFEd+h46xjl0mjmRSsojab6PAvEgAYp5S4p5S7gMCpEe+08efqBjud5jeVBoAQAQoglwHJgO2oeFSiLaJpVRzuhEOK9qL3O7pRSvi8oaxdwReiw6ajHUxbhqKkfdBSfRlNlpJRSCHE38EMhxPuBQeALqOCK7fNke5yZ8aXj4T5UVN9Pgl1yQY2D7QhkDnAA+FshxAdQu0D/12OcsxX4vBBiBLVR32tQFtMToWPOB56WUhaeR1k1GkBbUBpNrXADKhT9TtSupS3A1VLKsXmO/wUq2u+4CMa+3oBSfr9DRfQdAjZJKYtSSg+lkHpRgQ0fAT59jNN+Hfghyg0pURGEb66YOHwFKkBEo3ne6B11NZoFiBAijQpwuFZK+acqF2dOhBAtwEHgPCnl3mqXR7Pw0BaURrMAkVJmUWNU7692WY7CjcDtWjlpXihaQWk0C5d/As4TQswXil41gsVi34ua0KvRvCC0i0+j0Wg0NYm2oDQajUZTk2gFpdFoNJqaRCsojUaj0dQkWkFpNBqNpibRCkqj0Wg0Ncn/BwD0nD1ySYFkAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Plot data\n", + "data = run_simulation(system, update_func)\n", + "plot(data.index, data['R'], label='Uninfected Cells', linestyle = ':')\n", + "plot(data.index, data['L'], label='Latently Infected Cells')\n", + "plot(data.index, data['E'], label='Actively Infected Cells', linestyle = '--')\n", + "plot(data.index, data['V'], label='Free Virions')\n", + "decorate(title='HIV Model',\n", + " xlabel='Time (hours)',\n", + " ylabel='Number')\n", + "savefig('figs/HIV-Model.pdf')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From f4ad3cb5deb54bf832d74c5c6d79711d78fe69d7 Mon Sep 17 00:00:00 2001 From: miaskaggs Date: Wed, 28 Nov 2018 17:56:48 -0500 Subject: [PATCH 5/5] "submitting orbital mechanics homework" --- code/orbit_homework.ipynb | 680 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 680 insertions(+) create mode 100644 code/orbit_homework.ipynb diff --git a/code/orbit_homework.ipynb b/code/orbit_homework.ipynb new file mode 100644 index 00000000..6767cded --- /dev/null +++ b/code/orbit_homework.ipynb @@ -0,0 +1,680 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Mia Skaggs\n", + "# Orbital Mechanics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Modeling and Simulation in Python\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": 78, + "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": [ + "### Earth falling into the sun\n", + "\n", + "Here's a question from the web site [Ask an Astronomer](http://curious.astro.cornell.edu/about-us/39-our-solar-system/the-earth/other-catastrophes/57-how-long-would-it-take-the-earth-to-fall-into-the-sun-intermediate):\n", + "\n", + "\"If the Earth suddenly stopped orbiting the Sun, I know eventually it would be pulled in by the Sun's gravity and hit it. How long would it take the Earth to hit the Sun? I imagine it would go slowly at first and then pick up speed.\"\n", + "\n", + "Here's a solution." + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "year" + ], + "text/latex": [ + "$year$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Here are the units we'll need\n", + "\n", + "s = UNITS.second\n", + "N = UNITS.newton\n", + "kg = UNITS.kilogram\n", + "m = UNITS.meter\n", + "year = UNITS.year" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
values
x147000000000.0 meter
y0
vx0
vy-30000.0 meter / second
\n", + "
" + ], + "text/plain": [ + "x 147000000000.0 meter\n", + "y 0\n", + "vx 0\n", + "vy -30000.0 meter / second\n", + "dtype: object" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# And an inition condition (with everything in SI units)\n", + "\n", + "r_0 = 147e9 * m\n", + "\n", + "init = State(x= r_0,\n", + " y = 0,\n", + " vx = 0,\n", + " vy = -30000* m /s)" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
values
initx 147000000000.0 meter\n", + "y ...
G6.674e-11 meter ** 2 * newton / kilogram ** 2
m11.989e+30 kilogram
r_final701879000.0 meter
m25.972e+24 kilogram
t_00 second
t_end5.0 second * year
\n", + "
" + ], + "text/plain": [ + "init x 147000000000.0 meter\n", + "y ...\n", + "G 6.674e-11 meter ** 2 * newton / kilogram ** 2\n", + "m1 1.989e+30 kilogram\n", + "r_final 701879000.0 meter\n", + "m2 5.972e+24 kilogram\n", + "t_0 0 second\n", + "t_end 5.0 second * year\n", + "dtype: object" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Making a system object\n", + "\n", + "r_earth = 6.371e6 * m\n", + "r_sun = 695.508e6 * m\n", + "\n", + "system = System(init=init,\n", + " G=6.674e-11 * N / kg**2 * m**2,\n", + " m1=1.989e30 * kg,\n", + " r_final=r_sun + r_earth,\n", + " m2=5.972e24 * kg,\n", + " t_0=0 * s,\n", + " t_end=(5*year)*s)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [], + "source": [ + "# Here's a function that computes the force of gravity\n", + "\n", + "def universal_gravitation(state, system):\n", + " \"\"\"Computes gravitational force.\n", + " \n", + " state: State object with distance r\n", + " system: System object with m1, m2, and G\n", + " \"\"\"\n", + " x, y, vx, vy = state\n", + " unpack(system)\n", + " \n", + " r = Vector(x, y)\n", + " r_hat = r.hat()\n", + " \n", + " grav = G * m1 * m2 / r.mag**2\n", + " return r_hat*grav" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "[3.6686486e+22 0.0000000e+00] newton" + ], + "text/latex": [ + "$[3.6686486e+22 0.0000000e+00] newton$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "universal_gravitation(init, system)" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [], + "source": [ + "# The slope function\n", + "\n", + "def slope_func(state, t, system):\n", + " \"\"\"Compute derivatives of the state.\n", + " \n", + " state: position, velocity\n", + " t: time\n", + " system: System object containing `g`\n", + " \n", + " returns: derivatives of y and v\n", + " \"\"\"\n", + " x, y, vx, vy = state\n", + " unpack(system) \n", + " \n", + " v = Vector(vx, vy)\n", + " \n", + " force = universal_gravitation(state, system)\n", + " \n", + " dxdt = vx\n", + " dydt = vy\n", + " \n", + " a = -force/m2\n", + " \n", + " return dxdt, dydt, a.x, a.y" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0,\n", + " ,\n", + " ,\n", + " )" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Always test the slope function!\n", + "\n", + "slope_func(init, 0, system)" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'def event_func(state, t, system):\\n r, v = state\\n return r - system.r_final'" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Here's an event function that stops the simulation\n", + "# before the collision\n", + "\n", + "'''def event_func(state, t, system):\n", + " r, v = state\n", + " return r - system.r_final'''" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'event_func(init, 0, system)'" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Always test the event function!\n", + "\n", + "'''event_func(init, 0, system)'''" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
values
solNone
t_events[]
nfev9548
njev0
nlu0
status0
messageThe solver successfully reached the end of the...
successTrue
\n", + "
" + ], + "text/plain": [ + "sol None\n", + "t_events []\n", + "nfev 9548\n", + "njev 0\n", + "nlu 0\n", + "status 0\n", + "message The solver successfully reached the end of the...\n", + "success True\n", + "dtype: object" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Finally we can run the simulation\n", + "\n", + "results, details = run_ode_solver(system, slope_func, max_step = 100000)\n", + "details" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "157784629.8735 second" + ], + "text/latex": [ + "$157784629.8735 second$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Here's how long it takes...\n", + "\n", + "t_final = get_last_label(results) * s" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "1826.2109939062495 day" + ], + "text/latex": [ + "$1826.2109939062495 day$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# ... expressed in units we understand\n", + "\n", + "t_final.to(UNITS.day)" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "too many values to unpack (expected 2)", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[0mts\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlinspace\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mt_0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mt_final\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m201\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mresults\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdetails\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mrun_ode_solver\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msystem\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mslope_func\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mevents\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mevent_func\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mt_eval\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mts\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmax_step\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m100000\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32m~\\Documents\\ModSimPy\\code\\modsim.py\u001b[0m in \u001b[0;36mrun_ode_solver\u001b[1;34m(system, slope_func, **options)\u001b[0m\n\u001b[0;32m 495\u001b[0m \u001b[1;31m# run the solver\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 496\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0munits_off\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 497\u001b[1;33m \u001b[0mbunch\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msolve_ivp\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mf\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mt_0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mt_end\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mevents\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mevents\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0moptions\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 498\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 499\u001b[0m \u001b[1;31m# separate the results from the details\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mC:\\Miniconda3\\lib\\site-packages\\scipy\\integrate\\_ivp\\ivp.py\u001b[0m in \u001b[0;36msolve_ivp\u001b[1;34m(fun, t_span, y0, method, t_eval, dense_output, events, vectorized, **options)\u001b[0m\n\u001b[0;32m 466\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 467\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mevents\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 468\u001b[1;33m \u001b[0mg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mevent\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mt0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my0\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mevent\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mevents\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 469\u001b[0m \u001b[0mt_events\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0m_\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mevents\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 470\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mC:\\Miniconda3\\lib\\site-packages\\scipy\\integrate\\_ivp\\ivp.py\u001b[0m in \u001b[0;36m\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m 466\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 467\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mevents\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 468\u001b[1;33m \u001b[0mg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mevent\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mt0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my0\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mevent\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mevents\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 469\u001b[0m \u001b[0mt_events\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0m_\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mevents\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 470\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\Documents\\ModSimPy\\code\\modsim.py\u001b[0m in \u001b[0;36m\u001b[1;34m(t, y)\u001b[0m\n\u001b[0;32m 476\u001b[0m \u001b[0mMake\u001b[0m \u001b[0mevents\u001b[0m \u001b[0mterminal\u001b[0m \u001b[0mby\u001b[0m \u001b[0mdefault\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 477\u001b[0m \"\"\"\n\u001b[1;32m--> 478\u001b[1;33m \u001b[0mwrapped\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mlambda\u001b[0m \u001b[0mt\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mevent\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mt\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msystem\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 479\u001b[0m \u001b[0mwrapped\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mterminal\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mevent\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'terminal'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 480\u001b[0m \u001b[0mwrapped\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdirection\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mevent\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'direction'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m\u001b[0m in \u001b[0;36mevent_func\u001b[1;34m(state, t, system)\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mevent_func\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mt\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msystem\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mr\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mv\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mstate\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 6\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mr\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0msystem\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mr_final\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mValueError\u001b[0m: too many values to unpack (expected 2)" + ] + } + ], + "source": [ + "# Before plotting, we run the simulation again with `t_eval`\n", + "\n", + "ts = linspace(t_0, t_final, 201)\n", + "results, details = run_ode_solver(system, slope_func, events=event_func, t_eval=ts)" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [], + "source": [ + "# Scaling the time steps to days\n", + "\n", + "results.index /= 60 * 60 * 24" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'TimeFrame' object has no attribute 'r'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# Scaling the distance to million km\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mresults\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mr\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;36m1e9\u001b[0m\u001b[1;33m;\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32mC:\\Miniconda3\\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 4374\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 4375\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-> 4376\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 4377\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4378\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: 'TimeFrame' object has no attribute 'r'" + ] + } + ], + "source": [ + "# Scaling the distance to million km\n", + "\n", + "r = results.r / 1e9;" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# And plotting\n", + "\n", + "plot(results.x, results.y)\n", + "\n", + "\n", + "decorate(xlabel='Horizontal Distance (million km)',\n", + " ylabel='Vertical Distance (million km)')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}