{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ANSWER\n",
    "\n",
    "#### Emphasize in groups\n",
    "\n",
    "* Continue to push for collaboration and sharing screens to get them to work together\n",
    "* The results at the end of this notebook are wrong on purpose to have students reflect on what makes a plot meaningful. Effectively, the x-axis makes no sense without having real times used; using the location of the number in teh array as a proxy for time is bad when comparing plots\n",
    "* The emphasis here should be on reading in raw data and making sense of how to use it for calculations. \n",
    "    * One important thing to remember is that the calculations we do on the data lead to higher level abstraction of the data. If we are not careful, we could be making conclusions from a level up in abstraction the propagates some error in the calculation. This is the reason for comparing doubling time plots."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <p style=\"text-align: right;\"> &#9989; Put your name here</p>\n",
    "#### <p style=\"text-align: right;\"> &#9989; Put your group member names here</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 04 In-Class Assignment: Analyzing Covid Data\n",
    "\n",
    "This notebook is an modified version of one authored by [Brian O'Shea](https://web.pa.msu.edu/people/osheabr/) at CMSE in the early part of the COVID-19 epidemic.\n",
    "\n",
    "## Goals for today's In-class assignment \n",
    "\n",
    "1. Read JSON data into a Pandas DataFrame\n",
    "2. Perform calculations with the `datetime` class\n",
    "3. Read COVID data from the web into a Pandas DataFrame\n",
    "4. Calculate the Doubling Time for the virus\n",
    "5. Represent that data in plots and discuss meaningful representations of data\n",
    "\n",
    "## Information on the data we will use\n",
    "\n",
    "This notebook uses Pandas to retrieve JSON data files created by the [Johns Hopkins Coronavirus Resource Center](https://coronavirus.jhu.edu) (and stored at [The COVID Tracking Project](https://covidtracking.com/)) to make real-time tracking plots of the growth of the COVID-19 pandemic in the US and Michigan, as well as estimate the doubling time of the number of positive cases.  These data files are updated daily, so re-running the notebook will get the most current data.  It's easy to change the state that is plotted by changing the `my_state` variable.  There's also quite a bit more information in the data files!\n",
    "\n",
    "**Important note:**  The data file tracks the number of people who have _tested positive_ of COVID in the US and Michigan, not an estimate of the total number of positive cases in the US and Michigan."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The imports "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import datetime"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "## 1. Working with JSON data\n",
    "\n",
    "It is a bit of a story to explain what JSON (pronounced \"J\" \"son\") data is but it is worth our time. To understand JSON you have to know a little bit about JavaScript. If you read the <a href=\"https://en.wikipedia.org/wiki/JavaScript\"> wikipedia page </a> you will read:\n",
    "\n",
    "> Alongside HTML and CSS, JavaScript is one of the core technologies of the World Wide Web.[8] JavaScript enables interactive web pages and is an essential part of web applications. The vast majority of websites use it for client-side page behavior,[9] and all major web browsers have a dedicated JavaScript engine to execute it. \n",
    "\n",
    "So the fact that modern browsers have a dynamic character (pages change based on all kinds of inputs) is largely due to an underlying programming language called JavaScript. \n",
    "\n",
    "One problem is that it is likely the case that you want your web server (not on your machine) to dynamically generate content, to be rendered using JavaScript. How to get the dynamic content from the server to your local machine? The exchange of information has to use text to be universal. How do you translate existing JavaScript objects into text and back? You guessed it, that is what JSON is.\n",
    "\n",
    "From <a href=\"https://en.wikipedia.org/wiki/JSON\"> wikipedia JSON page</a>:\n",
    "> JavaScript Object Notation (JSON) is an open standard file format, and data interchange format, that uses human-readable text to store and transmit data objects consisting of attribute–value pairs and array data types (or any other serializable value).\n",
    "\n",
    "> JSON is a language-independent data format. It was derived from JavaScript, but many modern programming languages include code to generate and parse JSON-format data. The official Internet media type for JSON is application/json. JSON filenames use the extension .json. \n",
    "\n",
    "The term `serializable` is worth noting. By this we mean that actual object instances, with all their variable settings and methods, can be stored into a format and then re-created \"as they were\" in another location. That is, the `state` of a system can be stored and then re-created at a later date. Note that JSON was originally set up for JavaScript, but as a \"state saver\" can be used in all kinds of place. Like Python!\n",
    "\n",
    "Bottom line: JSON is a way to exchange information across the internet. We are going to use that!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 DataFrame to JSON and back\n",
    "\n",
    "The `.read_json` and `.to_json` allow us to read and write a DataFrame to JSON. Let's do that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = { \"tens\": [10, 11, 12, 13, 14, 15],\n",
    "            \"twentys\" : [20, 21, 22, 23, 24, 25],\n",
    "            \"thirtys\" : [30, 31, 32, 33, 34, 35]\n",
    "          }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=8 color=\"#009600\">&#9998;</font> Do This - Do the following:\n",
    "* turn that dictionary into a DataFrame\n",
    "* print the DataFrame\n",
    "* write out the DataFrame as a JSON file (look up `to_json`)\n",
    "* take a look at that file with your editor\n",
    "* read that JSON file back into a DataFrame with a different name (look up `read_json`)\n",
    "* print out the new DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   tens  twentys  thirtys\n",
      "0    10       20       30\n",
      "1    11       21       31\n",
      "2    12       22       32\n",
      "3    13       23       33\n",
      "4    14       24       34\n",
      "5    15       25       35\n",
      "   tens  twentys  thirtys\n",
      "0    10       20       30\n",
      "1    11       21       31\n",
      "2    12       22       32\n",
      "3    13       23       33\n",
      "4    14       24       34\n",
      "5    15       25       35\n"
     ]
    }
   ],
   "source": [
    "### ANSWER ###\n",
    "\n",
    "df1 = pd.DataFrame(my_dict)\n",
    "print(df1)\n",
    "df1.to_json(\"temp.json\")\n",
    "df2 = pd.read_json(\"temp.json\")\n",
    "print(df2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Read JSON over the internet\n",
    "\n",
    "But here is the really cool stuff. You don't have to have a JSON file on your local machine to read it in. You can actually read it from a source on the internet and use it locally. Remember, JSON is an exchange file format so that makes perfect sense!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     sepalLength  sepalWidth  petalLength  petalWidth    species\n",
      "0            5.1         3.5          1.4         0.2     setosa\n",
      "1            4.9         3.0          1.4         0.2     setosa\n",
      "2            4.7         3.2          1.3         0.2     setosa\n",
      "3            4.6         3.1          1.5         0.2     setosa\n",
      "4            5.0         3.6          1.4         0.2     setosa\n",
      "..           ...         ...          ...         ...        ...\n",
      "145          6.7         3.0          5.2         2.3  virginica\n",
      "146          6.3         2.5          5.0         1.9  virginica\n",
      "147          6.5         3.0          5.2         2.0  virginica\n",
      "148          6.2         3.4          5.4         2.3  virginica\n",
      "149          5.9         3.0          5.1         1.8  virginica\n",
      "\n",
      "[150 rows x 5 columns]\n"
     ]
    }
   ],
   "source": [
    "iris_df = pd.read_json(\"https://raw.githubusercontent.com/domoritz/maps/master/data/iris.json\")\n",
    "print(iris_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ah, it's our favorite iris dataset but read in from a file on the internet. Open that url once in your browser. Should look pretty understandable at this point."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----\n",
    "## 2. Analyzing COVID data\n",
    "\n",
    "You must be living under a rock to not know about tracking the COVID-19 virus outbreak. Let's see if we can do some data analysis of a time-series, JSON file. \n",
    "\n",
    "Gets the data from [covidtracking.com](https://covidtracking.com) - specifically, the page [https://covidtracking.com/api](https://covidtracking.com/api).  This page has historical data for the US as a whole, for states, and for counties.  The JSON files have a ton of data in addition to what we're showing. The two URLs we are most interested in are:\n",
    "* <a href=\"https://covidtracking.com/api/us/daily\"> https://covidtracking.com/api/us/daily </a> which is the US daily report as a JSON file\n",
    "* <a href=\"https://covidtracking.com/api/v1/states/daily.json\">https://covidtracking.com/api/v1/states/daily.json </a> which is the data for all 50 states.\n",
    "\n",
    "Before you do anything else, you should open those two links in your browser and look at the data. JSON is pretty readable and you need to read a little about what's there so we can do some more work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=8 color=\"#009600\">&#9998;</font> Do This - Do the following:\n",
    "* read the US daily into a DataFrame\n",
    "* read the state data into a DataFrame\n",
    "   * make a DataFrame that contains just the state of Michigan from the state data\n",
    "* print the `.head` of the US and MI DataFrames."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " ALL US \n",
      "        date  states  positive  negative  pending  hospitalizedCurrently  \\\n",
      "0  20200909      56   6329405  77613114   6551.0                32562.0   \n",
      "1  20200908      56   6298422  77059685   8983.0                32263.0   \n",
      "2  20200907      56   6276203  76573198   8986.0                31999.0   \n",
      "3  20200906      56   6247522  76013582   8946.0                32361.0   \n",
      "4  20200905      56   6214407  75310873   9021.0                33502.0   \n",
      "\n",
      "   hospitalizedCumulative  inIcuCurrently  inIcuCumulative  \\\n",
      "0                381926.0          6646.0          18322.0   \n",
      "1                379866.0          6542.0          18189.0   \n",
      "2                378907.0          6630.0          18156.0   \n",
      "3                378415.0          6699.0          18125.0   \n",
      "4                377926.0          6766.0          18089.0   \n",
      "\n",
      "   onVentilatorCurrently  ...          lastModified     total  \\\n",
      "0                 1903.0  ...  2020-09-09T00:00:00Z  83949070   \n",
      "1                 1879.0  ...  2020-09-08T00:00:00Z  83367090   \n",
      "2                 1879.0  ...  2020-09-07T00:00:00Z  82858387   \n",
      "3                 1912.0  ...  2020-09-06T00:00:00Z  82270050   \n",
      "4                 1956.0  ...  2020-09-05T00:00:00Z  81534301   \n",
      "\n",
      "  totalTestResults    posNeg  deathIncrease hospitalizedIncrease  \\\n",
      "0         83942519  83942519           1089                 2060   \n",
      "1         83358107  83358107            358                  959   \n",
      "2         82849401  82849401            225                  492   \n",
      "3         82261104  82261104            449                  489   \n",
      "4         81525280  81525280            918                 1287   \n",
      "\n",
      "   negativeIncrease  positiveIncrease  totalTestResultsIncrease  \\\n",
      "0            553429             30983                    584412   \n",
      "1            486487             22219                    508706   \n",
      "2            559616             28681                    588297   \n",
      "3            702709             33115                    735824   \n",
      "4            761056             44910                    805966   \n",
      "\n",
      "                                       hash  \n",
      "0  e5c534217742be6f09560d25616f96c0d1915b4c  \n",
      "1  c43bc49c6f42a78c85c704d97acdf1044d89bc3b  \n",
      "2  23ba2e4ce89a07512fa56cc86442f9da440d644c  \n",
      "3  b4363094c4b840e8a8660bf8213749232fae73db  \n",
      "4  5a3e0e97caa4d2d9536e2ec55bc6124938a6b430  \n",
      "\n",
      "[5 rows x 25 columns]\n",
      "\n",
      " Michigan \n",
      "          date state  positive   negative  pending  hospitalizedCurrently  \\\n",
      "24   20200909    MI  119863.0  2883414.0      NaN                  616.0   \n",
      "80   20200908    MI  118902.0  2861182.0      NaN                  616.0   \n",
      "136  20200907    MI  118403.0  2844275.0      NaN                  616.0   \n",
      "192  20200906    MI  117191.0  2801811.0      NaN                  616.0   \n",
      "248  20200905    MI  117191.0  2801811.0      NaN                  616.0   \n",
      "\n",
      "     hospitalizedCumulative  inIcuCurrently  inIcuCumulative  \\\n",
      "24                      NaN           158.0              NaN   \n",
      "80                      NaN           158.0              NaN   \n",
      "136                     NaN           158.0              NaN   \n",
      "192                     NaN           158.0              NaN   \n",
      "248                     NaN           158.0              NaN   \n",
      "\n",
      "     onVentilatorCurrently  ...   posNeg  deathIncrease hospitalizedIncrease  \\\n",
      "24                    70.0  ...  3003277             76                    0   \n",
      "80                    76.0  ...  2980084              1                    0   \n",
      "136                   71.0  ...  2962678              4                    0   \n",
      "192                   71.0  ...  2919002              0                    0   \n",
      "248                   71.0  ...  2919002              8                    0   \n",
      "\n",
      "                                         hash commercialScore  \\\n",
      "24   da7d758f7b17c69f974d0a8ad53647858950d47a               0   \n",
      "80   801f7d8795e74bece92bae3adff400cd245cb1bf               0   \n",
      "136  565ca9242bc12540e899aa405fe0e5dbfa627fb3               0   \n",
      "192  f1437d5a6117d5b7364470917e6d6b5310f319fe               0   \n",
      "248  ea5cefa02687fc1df1ba2a8b835240b119e42a2f               0   \n",
      "\n",
      "    negativeRegularScore  negativeScore  positiveScore score  grade  \n",
      "24                     0              0              0     0         \n",
      "80                     0              0              0     0         \n",
      "136                    0              0              0     0         \n",
      "192                    0              0              0     0         \n",
      "248                    0              0              0     0         \n",
      "\n",
      "[5 rows x 54 columns]\n"
     ]
    }
   ],
   "source": [
    "### ANSWER ###\n",
    "\n",
    "us_df = pd.read_json(\"https://covidtracking.com/api/us/daily\")\n",
    "all_states_df = pd.read_json(\"https://covidtracking.com/api/v1/states/daily.json\")\n",
    "\n",
    "# select out MI\n",
    "MI_df = all_states_df[all_states_df['state']==\"MI\"]\n",
    "print('\\n ALL US \\n', us_df.head())\n",
    "print('\\n Michigan \\n', MI_df.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Convert data to DateTime\n",
    "\n",
    "There's a date field in the data but it is not in pandas datetime format. That would be helpful since this is a time series. \n",
    "\n",
    "<font size=8 color=\"#009600\">&#9998;</font> Do This - Let's do what we did before:\n",
    "* Let's make a Series from the `date` field using `to_datetime`. \n",
    "Look at the format of the date of the JSON file in your browser and write the appropriate format specifier to get it into datetime format.\n",
    "* assign the Series to the DataFrame under the name \"datetime\"\n",
    "* make a new DataFrame with all the positive cases in the US along with the datatime (just the two columns)\n",
    "* print the head of the 2-column, positive US cases\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0     2020-09-09\n",
      "1     2020-09-08\n",
      "2     2020-09-07\n",
      "3     2020-09-06\n",
      "4     2020-09-05\n",
      "         ...    \n",
      "227   2020-01-26\n",
      "228   2020-01-25\n",
      "229   2020-01-24\n",
      "230   2020-01-23\n",
      "231   2020-01-22\n",
      "Name: date, Length: 232, dtype: datetime64[ns]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>positive</th>\n",
       "      <th>datetime</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6329405</td>\n",
       "      <td>2020-09-09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>6298422</td>\n",
       "      <td>2020-09-08</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>6276203</td>\n",
       "      <td>2020-09-07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>6247522</td>\n",
       "      <td>2020-09-06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>6214407</td>\n",
       "      <td>2020-09-05</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   positive   datetime\n",
       "0   6329405 2020-09-09\n",
       "1   6298422 2020-09-08\n",
       "2   6276203 2020-09-07\n",
       "3   6247522 2020-09-06\n",
       "4   6214407 2020-09-05"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### ANSWER ###\n",
    "\n",
    "fixed_US_dates = pd.to_datetime(us_df['date'], format='%Y%m%d')\n",
    "print(fixed_US_dates)\n",
    "temp = us_df.assign(datetime=fixed_US_dates)\n",
    "positive_us_df = temp[[\"positive\", \"datetime\"]]\n",
    "positive_us_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do the same for the Michigan State Data. \n",
    "\n",
    "<font size=8 color=\"#009600\">&#9998;</font> Do This - Make a two column DataFrame with datetime and positives."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#your code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24      2020-09-09\n",
      "80      2020-09-08\n",
      "136     2020-09-07\n",
      "192     2020-09-06\n",
      "248     2020-09-05\n",
      "           ...    \n",
      "10473   2020-03-05\n",
      "10495   2020-03-04\n",
      "10508   2020-03-03\n",
      "10514   2020-03-02\n",
      "10520   2020-03-01\n",
      "Name: date, Length: 193, dtype: datetime64[ns]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>positive</th>\n",
       "      <th>datetime</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>119863.0</td>\n",
       "      <td>2020-09-09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>80</th>\n",
       "      <td>118902.0</td>\n",
       "      <td>2020-09-08</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>136</th>\n",
       "      <td>118403.0</td>\n",
       "      <td>2020-09-07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>192</th>\n",
       "      <td>117191.0</td>\n",
       "      <td>2020-09-06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>248</th>\n",
       "      <td>117191.0</td>\n",
       "      <td>2020-09-05</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     positive   datetime\n",
       "24   119863.0 2020-09-09\n",
       "80   118902.0 2020-09-08\n",
       "136  118403.0 2020-09-07\n",
       "192  117191.0 2020-09-06\n",
       "248  117191.0 2020-09-05"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### ANSWER ###\n",
    "\n",
    "fixed_MI_dates = pd.to_datetime(MI_df['date'], format='%Y%m%d')\n",
    "print(fixed_MI_dates)\n",
    "temp = MI_df.assign(datetime=fixed_MI_dates)\n",
    "positive_MI_df = temp[[\"positive\", \"datetime\"]]\n",
    "positive_MI_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Plot cumulative positive tests for US and MI\n",
    "\n",
    "Again, this data is large and thus we need to represent in a way that makes it understandable to us.\n",
    "\n",
    "<font size=8 color=\"#009600\">&#9998;</font> Do This - Using the `.plot` method, make two plots: one for the MI positive cases and one for US positive cases. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fe088a845e0>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "positive_MI_df.plot(x=\"datetime\", y=\"positive\", title=\"MI positive cases\")\n",
    "positive_us_df.plot(x=\"datetime\", y=\"positive\", title=\"US positive cases\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=8 color=\"#009600\">&#9998;</font> Do This - What do you notice about the number of positive cases in the US and in Michigan? How could we characterize the rate at which infections are changing? In particular, what are ways that might be able to compare the two rates on similar scales?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Time Calculations\n",
    "\n",
    "One of the most common ways to compare these rates in epidemiology is [\"Doubling Time\"](https://en.wikipedia.org/wiki/Doubling_time). In the space below we are going to look at the Doubling Time of the virus. But to do that, we will have to make some calculations regarding time differences.\n",
    "\n",
    "You can subtract two `DateTime` elements which yields a `Timedelta`, a data type representing a time difference. Let's try that below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'datetime.timedelta'>\n",
      "30 days, 0:00:00\n",
      "['__abs__', '__add__', '__bool__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__pos__', '__radd__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rmod__', '__rmul__', '__rsub__', '__rtruediv__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', 'days', 'max', 'microseconds', 'min', 'resolution', 'seconds', 'total_seconds']\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "t1 = datetime.datetime(2020, 7, 25)\n",
    "t2 = datetime.datetime(2020, 6, 25)\n",
    "diff = t1 - t2\n",
    "print(type(diff))\n",
    "print(diff)\n",
    "print(dir(diff))\n",
    "print(diff.days)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By looking at the `dir` of the `Timedelta` instance named `diff` we see the various data members, one of which is `.days`. Calling `.days` yields an integer value we can do work with. You could have done `.seconds` or changed the `.resolution` but for the work we are doing, the values are recorded as days so that is what we will work with"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "## 3. Creating the \"Doubling time\" plot\n",
    "\n",
    "Now we calculate an estimate of the [doubling time](https://en.wikipedia.org/wiki/Doubling_time) of positive COVID-19 tests (which gives us a sense of how quickly the virus is spreading).  The doubling time is the amount of time it takes the number of cases to increase by a factor of two.  We use the instantaneous approximation of the doubling time - for times $t_1$ and $t_2$, and number of cases at those times $n_1$ and $n_2$, we can approximately the doubling time $\\tau_d$ as:\n",
    "\n",
    "$\\tau_d \\simeq (t_2 - t_1) \\frac{ln(2)}{ln(n_2/n_1)}$\n",
    "\n",
    "<font size=8 color=\"#009600\">&#9998;</font> Do This - Given that equation, let's write a function called `d_time` which takes as arguments two rows from our time-series, assumed to have the column headers \"datetime\" and \"positive\". Return from that function the doubling time, in days, between those two time periods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here for d_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "### ANSWER ###\n",
    "\n",
    "def d_time(row1, row2):\n",
    "    t1 = row1[\"datetime\"]\n",
    "    t2 = row2[\"datetime\"]\n",
    "    n1 = row1[\"positive\"]\n",
    "    n2 = row2[\"positive\"]\n",
    "    if t1 > t2:\n",
    "        t1,t2 = t2,t1\n",
    "        n1,n2, = n2,n1\n",
    "        print(\"swapped\")\n",
    "    time_delta = (t2 - t1).days\n",
    "    return time_delta * ( np.log(2) / np.log(n2/n1) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test your code, show that it works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55.501723005512716\n"
     ]
    }
   ],
   "source": [
    "### ANSWER ###\n",
    "\n",
    "print(d_time(positive_us_df.iloc[100], positive_us_df.iloc[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Calculating doubling time \n",
    "\n",
    "We have the option of specifying the time delta (every day, every 5 days, every week) to see how the doubling time might change. \n",
    "\n",
    "<font size=8 color=\"#009600\">&#9998;</font> Do This - Let's write a function `d_plot` that takes two arguments.\n",
    "- first is a DataFrame, either the US or the MI that has the two columns, \"positive\" and \"datetime\"\n",
    "- time interval. Conveniently, each element in the DataFrame represents one day, so an interval of 5 means we are using DataFrame rows that are 5 indicies apart. \n",
    " \n",
    "`d_plot` should return an array of doubling times, from the first reported cases up to the latest cases.\n",
    "\n",
    "Here's a hint. The `zip` function will create a list of pairs. If you give it two lists, one a range of indicies from earliest to latest by the interval, and the other a range of values, it will return a list of pairs where the pairs are of (time, value). You do not _need_ to use `zip` to do this calculation, it's just relatively elegant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "### ANSWER ###\n",
    "\n",
    "def d_plot(df, interval):\n",
    "    d_ary = np.zeros(int(len(df)/interval))\n",
    "    d_indx = 0\n",
    "    indxs = zip(range(len(df)-1, 0, -interval), range(len(df)-1-interval, 0, -interval))\n",
    "    for i,j in indxs:\n",
    "        d_ary[d_indx] = d_time(df.iloc[i], df.iloc[j])\n",
    "        d_indx += 1\n",
    "    return d_ary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Plot doubling times\n",
    "\n",
    "A list of doubling times might not be the most useful way to represent our data. So let's instead make a plot to represent the data.\n",
    "\n",
    "<font size=8 color=\"#009600\">&#9998;</font> Do This -  Plot a side-by-side plot of:\n",
    "- doubling time\n",
    "- positives\n",
    "\n",
    "for a given data set (US or MI)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[         nan          nan          nan          nan          nan\n",
      "   0.           2.47878019   2.43544437   2.81694322   4.44796762\n",
      "   7.35540909  12.36026469  17.92537522  22.35445861  29.38924962\n",
      "  38.93853801  44.87645417  53.52431595  56.61713869  66.03711978\n",
      "  63.48116429  50.10407006  39.84830979  38.1075809   36.21831582\n",
      "  38.54318546  44.86776539  55.94867751  64.72297669  78.57352276\n",
      "  94.76508502 103.18649796   0.        ]\n",
      "     positive   datetime\n",
      "231         0 2020-01-22\n",
      "230         0 2020-01-23\n",
      "229         0 2020-01-24\n",
      "228         0 2020-01-25\n",
      "227         0 2020-01-26\n",
      "..        ...        ...\n",
      "4     6214407 2020-09-05\n",
      "3     6247522 2020-09-06\n",
      "2     6276203 2020-09-07\n",
      "1     6298422 2020-09-08\n",
      "0     6329405 2020-09-09\n",
      "\n",
      "[232 rows x 2 columns]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-15-aba7dea89f66>:13: RuntimeWarning: invalid value encountered in long_scalars\n",
      "  return time_delta * ( np.log(2) / np.log(n2/n1) )\n",
      "<ipython-input-15-aba7dea89f66>:13: RuntimeWarning: divide by zero encountered in long_scalars\n",
      "  return time_delta * ( np.log(2) / np.log(n2/n1) )\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fe0c92c18b0>]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### ANSWER ###\n",
    "time_interval = 7\n",
    "res = d_plot(positive_us_df, time_interval)\n",
    "print(res)\n",
    "fig,(ax1, ax2) = plt.subplots(1,2)\n",
    "ax1.plot(res)\n",
    "df = positive_us_df.sort_values(\"datetime\")\n",
    "print(df)\n",
    "ax2.plot(df.datetime, df.positive)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4 Comparing Intervals\n",
    "\n",
    "In the previous section, you picked an interval to use for your doubling time calculation. What happens if we shrink or lengthen that interval?\n",
    "\n",
    "<font size=8 color=\"#009600\">&#9998;</font> Do This - Make 3 doubling time plots for different choices of interval for the same data (US or MI). What happens to the representation of the data?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-15-aba7dea89f66>:13: RuntimeWarning: invalid value encountered in long_scalars\n",
      "  return time_delta * ( np.log(2) / np.log(n2/n1) )\n",
      "<ipython-input-15-aba7dea89f66>:13: RuntimeWarning: divide by zero encountered in long_scalars\n",
      "  return time_delta * ( np.log(2) / np.log(n2/n1) )\n",
      "<ipython-input-15-aba7dea89f66>:13: RuntimeWarning: invalid value encountered in long_scalars\n",
      "  return time_delta * ( np.log(2) / np.log(n2/n1) )\n",
      "<ipython-input-15-aba7dea89f66>:13: RuntimeWarning: divide by zero encountered in long_scalars\n",
      "  return time_delta * ( np.log(2) / np.log(n2/n1) )\n",
      "<ipython-input-15-aba7dea89f66>:13: RuntimeWarning: invalid value encountered in long_scalars\n",
      "  return time_delta * ( np.log(2) / np.log(n2/n1) )\n",
      "<ipython-input-15-aba7dea89f66>:13: RuntimeWarning: divide by zero encountered in long_scalars\n",
      "  return time_delta * ( np.log(2) / np.log(n2/n1) )\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### ANSWER ###\n",
    "\n",
    "fig, ax1 = plt.subplots(1,1)\n",
    "time_intervals = [2,7,14]\n",
    "\n",
    "for time_interval in time_intervals:\n",
    "    \n",
    "    res = d_plot(positive_us_df, time_interval)\n",
    "\n",
    "    ax1.plot(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=8 color=\"#009600\">&#9998;</font> Do This -  What do you notice about this plot? Do you see a problem with how we are representing the data? How might we fix this plot to make this comparison more meaningful?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------\n",
    "### Congratulations, you're done with your in-class assignment!\n",
    "\n",
    "Now, you just need to submit this assignment by uploading it to the course <a href=\"https://d2l.msu.edu/\">Desire2Learn</a> web page for today's in-class assignment submission folder. (Don't forget to add all of the appropriate names in the first cell)."
   ]
  },
  {
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
