PS7-Scratch....ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "# Econ 101b Problem Set 7-Scratch..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem set will be due Oct 12 at midnight...\n",
    "\n",
    "#### Sections between Tu AM & Th AM lecture will be problem set section...\n",
    "\n",
    "----\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setting up the Python/Jupyter environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "IPython.OutputArea.prototype._should_scroll = function(lines) {\n",
       "    return false;}"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%javascript\n",
    "\n",
    "IPython.OutputArea.prototype._should_scroll = function(lines) {\n",
    "    return false;}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ABOVE CELL IS \"NO SCROLLING SUBWINDOWS\" SETUP\n",
    "#\n",
    "# keep output cells from shifting to autoscroll: little scrolling\n",
    "# subwindows within the notebook are an annoyance..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# THIS CELL LOADS THE LIBRARIES\n",
    "#\n",
    "# set up the environment by reading in every library we might need: \n",
    "# os... graphics... data manipulation... time... math... statistics...\n",
    "\n",
    "import sys\n",
    "import os\n",
    "from urllib.request import urlretrieve\n",
    "\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import Image\n",
    "\n",
    "import pandas as pd\n",
    "from pandas import DataFrame, Series\n",
    "from datetime import datetime\n",
    "\n",
    "import scipy as sp\n",
    "import numpy as np\n",
    "import math\n",
    "import random\n",
    "\n",
    "import seaborn as sns\n",
    "import statsmodels\n",
    "import statsmodels.api as sm\n",
    "import statsmodels.formula.api as smf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PRETTIER GRAPHICS SETUP\n",
    "#\n",
    "# graphics setup: seaborn-whitegrid and figure size;\n",
    "# graphs in the notebook itself...\n",
    "\n",
    "%matplotlib inline \n",
    "\n",
    "plt.style.use('seaborn-whitegrid')\n",
    "\n",
    "figure_size = plt.rcParams[\"figure.figsize\"]\n",
    "figure_size[0] = 12\n",
    "figure_size[1] = 10\n",
    "plt.rcParams[\"figure.figsize\"] = figure_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already up-to-date: okpy in /anaconda3/lib/python3.6/site-packages (1.13.11)\n",
      "Requirement not upgraded as not directly required: coverage==3.7.1 in /anaconda3/lib/python3.6/site-packages (from okpy) (3.7.1)\n",
      "Requirement not upgraded as not directly required: requests==2.12.4 in /anaconda3/lib/python3.6/site-packages (from okpy) (2.12.4)\n",
      "\u001b[31mdistributed 1.21.8 requires msgpack, which is not installed.\u001b[0m\n",
      "\u001b[33mYou are using pip version 10.0.1, however version 18.0 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n",
      "=====================================================================\n",
      "Assignment: PS6 Notebook\n",
      "OK, version v1.13.11\n",
      "=====================================================================\n",
      "\n",
      "\n",
      "Open the following URL:\n",
      "\n",
      "https://okpy.org/client/login/\n",
      "\n",
      "After logging in, copy the code from the web page and paste it into the box.\n",
      "Then press the \"Enter\" key on your keyboard.\n",
      "\n",
      "Paste your code here: \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR  | auth.py:91 | {'error': 'invalid_grant'}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------------------------------------\n",
      "Authentication error: invalid grant\n",
      "---------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# THIS CELL IS THE KEY TO THE OKPY.ORG AUTOGRADER SYSTEM\n",
    "#\n",
    "# Don't change this cell; just run it. \n",
    "# The result will give you directions about how to log in to the submission system, called OK.\n",
    "# Once you're logged in, you can run this cell again, but it won't ask you who you are because\n",
    "# it remembers you. However, you will need to log in once per assignment.\n",
    "\n",
    "!pip install -U okpy\n",
    "\n",
    "from client.api.notebook import Notebook\n",
    "\n",
    "ok = Notebook('ps6.ok')\n",
    "_ = ok.auth(force=True, inline=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎\n",
    "### RUN THESE CELLS ABOVE FIRST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problem Set 6 (Due Sep 28 11:59:59 PM)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "The autograder, both in the tests you run along the way as you work on the problem set and in calculating the final score, looks in the same directory as the problem set notebook for an \"ok.tests\" directory, and then runs the tests in the \"q\\*\\*.py\" files in that directory (where \"\\*\\*\" denotes a two-digit number, possibly with a leading zero). Those tests take the form of comparing a variable that should be in your namespace and seeing if it is close to some desired value that we get when we do the problem set.\n",
    "\n",
    "Thus while the problem set instructions ask you to run simulations and plot graphs, what you are tested on is whether the appropriate variables in your namespace have (close to the) right values. We do not care what code you use in order to get those variables to the right values. \n",
    "\n",
    "You can run simulations and then pick appropriate values out by slicing a series in order to get the right number. You can use your knowledge of the algebraic solution to the model to have Python calculate the answer, having first set the parameters to the right values. \n",
    "You can even do all of the calculations on pen and paper, and simply code up the variables.\n",
    "    \n",
    "Perhaps we should ask you to do all three—start with simulations, or with algebraic equations with set parameter values, or with full pen-and-paper calculations with only the final results entered into the notebook—and then ask you to check your results from one mode by doing the other two. But: _ars longa, vita brevis_. Focus on what works _for you_: the key is to get a sense of how economists' center-of-gravity analyses of long-run growth work, so that when you encounter such an analysis later, outside the university, you have the right intellectual panoply to evaluate it.\n",
    "\n",
    "----\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "manual_grade": true,
    "manual_problem_id": "PS6TE"
   },
   "source": [
    "**(Task E) Savings and Investment**\n",
    "\n",
    "_Suppose somebody who hasn’t taken any economics courses asks you why some countries are so very, very much poorer than others in the world today. What an  swer would you give? Double-click on this markdown cell and write your answer below:_\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "<font color=\"blue\">ANSWER: </font>\n",
    "\n",
    "----\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(Task F) Long Run Human Populations: Levels and Growth**\n",
    "\n",
    "Run the code cell below, unchanged, to enter Michael Kremer's data—his estimates of human population and its growth, updated to 2015, into the pandas dataframe \"Pop_df\". Then proceed to do the tasks in the markdown cells further down:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# HUMAN POPULATION OVER THE LAST 10000 YEARS\n",
    "#\n",
    "# make sure the standard libraries are active\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import Image\n",
    "\n",
    "Population = (\n",
    "    [-8000,5],\n",
    "    [-4000, 7],\n",
    "    [-2000, 27],\n",
    "    [-1000, 50],\n",
    "    [-500, 100],\n",
    "    [-200, 150],\n",
    "    [0, 170],\n",
    "    [200, 190],\n",
    "    [400, 190],\n",
    "    [600, 200],\n",
    "    [800, 230],\n",
    "    [1000, 265],\n",
    "    [1200, 360],\n",
    "    [1400, 350],\n",
    "    [1500, 425],\n",
    "    [1600, 545],\n",
    "    [1700, 610],\n",
    "    [1750, 720],\n",
    "    [1800, 900],\n",
    "    [1850, 1200],\n",
    "    [1875, 1325],\n",
    "    [1900, 1625],\n",
    "    [1925, 1875],\n",
    "    [1950, 2516],\n",
    "    [1975, 4000],\n",
    "    [2000, 6100],\n",
    "    [2015, 7250])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Population = np.array(Population)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Pop_df = pd.DataFrame(Population) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Pop_df.columns = ['Date', 'Population']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Pop_df['Year'] = 0.0\n",
    "\n",
    "for i in range(26):\n",
    "    Pop_df.Year[i] = Pop_df.Date[i]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Pop_df = Pop_df.set_index('Date')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let us compare growth rates of human populations across different time periods. Set the variables in the code cell below to their appropriate values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Growth_Rate_1000BC_to_1000AD =\n",
    "Growth_Rate_1400_to_1600 =\n",
    "Growth_Rate_1900_to_1950 ="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ok.grade('q03')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now suppose that we are in a Malthusian population régime, in which the rate of population growth is linearly proportional to the relative deviation of typical standards of living from 750 dollars a year, with population growth at zero when output per capita is 750 dollars per year and 1 percent per year when output per worker is 1500. What would you think typical standards of living were in the 1400 to 1600 period and the in the 1900 to 1950 period? Enter the appropriate values for the variables in the code cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SoLtypical1400to1600 =\n",
    "SoLtypical1900to1950 ="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ok.grade('q04')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(Task G) American and British Economic Growth**\n",
    "\n",
    "Run the code cell below, unchanged, to enter Measuring Worth data for the United Kingdom and the United States into the pandas dataframes \"uklongrun_df\" and \"uslongrun_df\" and the pandas dictionaries \"uklongrun_dict\" and \"uslongrun_dict\". Then proceed to do the tasks in the markdown cell further down:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE\n",
    "\n",
    "# British long run real GDP per capita growth\n",
    "# From Sam Williamson and Louis Johnston, Measuring Worth\n",
    "# Data\n",
    "\n",
    "sourceURL = \"http://delong.typepad.com/2018-02-18_ukgdp_1700-2017.csv\"\n",
    "uklongrun_df = pd.read_csv(sourceURL, index_col = 0)\n",
    "\n",
    "uklongrun_dict = {}\n",
    "uklongrun_dict[\"df\"] = uklongrun_df\n",
    "uklongrun_dict[\"sourceURL\"] = sourceURL\n",
    "uklongrun_dict[\"sourceDescription\"] = \"Ryland Thomas and Samuel H. Williamson, 'What Was the Consistent U.K. GDP Then?' MeasuringWorth 2018\"   \n",
    "uklongrun_dict[\"sourceNotes\"] = \"http://www.measuringworth.com/ukgdp/\"\n",
    "\n",
    "# ----\n",
    "\n",
    "# U.S. long run economic growth of real GDP per capita: data cell\n",
    "# From Sam Williamson and Louis Johnston, Measuring Worth\n",
    "\n",
    "sourceURL = \"http://delong.typepad.com/2018-02-18_usgdp_1790-2016.csv\"\n",
    "uslongrun_df = pd.read_csv(sourceURL, index_col = 0)\n",
    "\n",
    "uslongrun_dict = {}\n",
    "uslongrun_dict[\"df\"] = uslongrun_df\n",
    "uslongrun_dict[\"sourceURL\"] = sourceURL\n",
    "uslongrun_dict[\"sourceDescription\"] = \"Louis Johnston and Samuel H. Williamson, 'What Was the U.S. GDP Then?' MeasuringWorth, 2018\"   \n",
    "uslongrun_dict[\"sourceNotes\"] = \"https://www.measuringworth.com/usgdp/\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "manual_grade": true,
    "manual_problem_id": "PS6TG"
   },
   "source": [
    "Now, using the code cell below, plot United Kingdom economic growth in estimated GDP per capita since 1700. And, using the code below that, plot United States economic growth in estimated GDP per capita since 1790 What would you say the key dividing points in the past several centuries economic growth have been for both countries? What key breakpoints do they share? What key breakpoints are confined to one or the other alone? After running your code and looking at your graphs, double-click on this markdown cell and write your answer below:\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "<font color=\"blue\">ANSWER: </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "manual_grade": true,
    "manual_problem_id": "PS6TH"
   },
   "source": [
    "**(Task H) Malthusian Economies**\n",
    "\n",
    "Below we have a function code cell that performs a simulation for the Malthusian economy discussed in lecture and in §5.1 of the DRAFT 3rd edition of DeLong and Olney: _Macroeconomics_, with an interact link to the texbook file at: <http://datahub.berkeley.edu/user-redirect/interact?account=braddelong&repo=LSS18E101b&branch=master&path=m%26O3ed/ch5/2018-02-06_DeLong_and_Olney_Macro_3rd_Ch_5.1%20The%20Reality%20of%20Economic%20Growth-Before%20Modern%20Economic%20Growth.ipynb>\n",
    "\n",
    "This version of the Malthusian model has:\n",
    "\n",
    "* _resource scarcity_: labor efficiency E depends on both the stock of ideas H and natural resources per worker N/L\n",
    "* _Malthusian population response_: up to a point, a higher level of output per worker Y/L calls forth a faster rate of growth of population and the labor force\n",
    "* _Two heads are better than one_: up to a point, a higher population means a greater proportional growth rate of the ideas stock H\n",
    "* _Demographic transition_: Population and labor force growth reaches its maximum when output per worker is twice subsistence, and thereafter declines to zero population growth\n",
    "* _Speed limit on modern economic growth_: the ideas stock H cannot grow faster than 2 percent per year\n",
    "\n",
    "Run the function code cell below\n",
    "\n",
    "The code cell after the function code cell presents a baseline run of this simulation, with parameters calibrated to more-or-less reproduce human economic history from the invention of agriculture up to the year 1, running for 800 decades—8000 years from 8000 BC to the year 1 (set in the function call by setting T=801). \n",
    "\n",
    "1. Run this second code cell to check that it does indeed track human history, with income per worker in year 1 at about 1700 dollars per year and the labor force in year 1 at about 80 million.\n",
    "\n",
    "2. Copy and paste the function call code cell, and edit it by altering the \"T=\" declaration that determines how long the simulation runs for to add more decades in order to track the simulated economy up to the year 2500. When, for these baselien parameter values, does the Industrial Revolution take place?\n",
    "\n",
    "3. Copy and paste the function call code cell, and edit it by altering the \"h=\" declaration that determines how ingenious humans are in their economy to make us and our predecessors more ingenious—choose h=0.00012 instead of the baseline h=0.0000805. When, for these parameter values, does the Industrial Revolution take place?\n",
    "\n",
    "4. Copy and paste the function call code cell, and edit it by altering the \"h=\" declaration that determines how ingenious humans are in their economy to make us and our predecessors less ingenious—choose h=0.00005 instead of the baseline h=0.0000805. When, for these parameter values, does the Industrial Revolution take place?\n",
    "\n",
    "Write your answers to (2), (3), and (4) below in this markdown cell:\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "<font color=\"blue\">ANSWER: </font>\n",
    "\n",
    "----\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# FUNCTION FOR CALCULATING AND GRAPHING THE LEVELS OF \n",
    "# SOLOW GROWTH MODEL VARIABLES IN MALTHUSIAN SIMULATIONS\n",
    "#\n",
    "# ADDING IN TWO HEADS ARE BETTER THAN ONE: TECHNOLOGICAL PROGRESS \n",
    "# PROPORTIONAL TO POPULATION RAISED TO THE POWER LAMBDA...\n",
    "# \n",
    "# IDEAS GROWTH NEVER GREATER THAN 2% PER YEAR\n",
    "#\n",
    "# ADDING IN DEMOGRAPHIC TRANSITION: POPULATION GROWTH SLOWS\n",
    "# AFTER REAL INCOMES REACH 2000 DOLLARS PER YEAR\n",
    "#\n",
    "# might as well put \"check that common libraries are active\" as a default header\n",
    "# in every long python code cell...\n",
    "\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import scipy as sp\n",
    "import numpy as np\n",
    "%matplotlib inline\n",
    "\n",
    "# we are going to want to see what happens for lots of\n",
    "# different model parameter values and ini conditions,\n",
    "# so stuff our small simulation program inside a function, so \n",
    "# we can then invoke it with a single line...\n",
    "#\n",
    "# we are going to assume the economy starts on its ini\n",
    "# balanced growth path...\n",
    "#\n",
    "# we are going to want to keep track not just of what the\n",
    "# economy's variables are at each point in time, but also \n",
    "# what the ini and alternative balanced-growth path \n",
    "# values of variables are. Given the parameters, the new BGP \n",
    "# is attracting the economy to it at the speed (1-α)(n+g+δ), \n",
    "# closing that fraction of the gap between its current state \n",
    "# and the balanced growth path attractor every period...\n",
    "#\n",
    "\n",
    "def sgm_malthus_run(H0=900, N0=2250, gamma=2, L0=2.5, n=0.000442, h=0.0000805, s=0.10, \n",
    "    alpha=1/3, delta=0.04, Delta_s=0, Delta_g=0, Delta_n=0, phi=0.01, ybar = 1500,\n",
    "    lambda_i = 0.5, T = 1001, figure_title = \"Ideas: Two Heads Are (Somewhat) Better than One\"):\n",
    "\n",
    "    sg_df = pd.DataFrame(index=range(T),columns=[\n",
    "        'Year',\n",
    "        'Labor', \n",
    "        'Efficiency',\n",
    "        'Capital',\n",
    "        'Output',\n",
    "        'Output_per_Worker',\n",
    "        'Capital_Output_Ratio',\n",
    "        'Ideas',\n",
    "        'Resources',\n",
    "        'BGP_ini_Labor',\n",
    "        'BGP_ini_Eff',\n",
    "        'BGP_ini_Capital',\n",
    "        'BGP_ini_Output',\n",
    "        'BGP_ini_Output_per_Worker',\n",
    "        'BGP_ini_Capital_Output_Ratio',\n",
    "        'BGP_alt_Labor',\n",
    "        'BGP_alt_Eff',\n",
    "        'BGP_alt_Capital',\n",
    "        'BGP_alt_Output',\n",
    "        'BGP_alt_Output_per_Worker',\n",
    "        'BGP_alt_Capital_Output_Ratio'],\n",
    "        dtype='float')\n",
    "\n",
    "    g = (gamma/(1+gamma))*h - (1/(1+gamma))*n\n",
    "    sg_df.Ideas[0] = H0\n",
    "    sg_df.Resources[0] = N0\n",
    "    E0 = sg_df.Ideas[0]**(gamma/(1+gamma))*(sg_df.Resources[0]/L0)**(1/(1+gamma))\n",
    "    sg_df.Labor[0] = L0\n",
    "    sg_df.BGP_ini_Labor[0] = L0\n",
    "    sg_df.BGP_alt_Labor[0] = L0\n",
    "    sg_df.Efficiency[0] = E0\n",
    "    sg_df.BGP_ini_Eff[0] = E0\n",
    "    sg_df.BGP_alt_Eff[0] = E0\n",
    "    KoverY_ini_steady_state = s/(n+g+delta)\n",
    "    YoverL_ini_steady_state = ((s/(n+g+delta))**(alpha/(1-alpha)) \n",
    "        * E0)\n",
    "    KoverL_ini_steady_state = (YoverL_ini_steady_state *\n",
    "        KoverY_ini_steady_state)\n",
    "    sg_df.Capital[0] = KoverL_ini_steady_state * L0\n",
    "    sg_df.Output[0] = (sg_df.Capital[0]**alpha * (sg_df.Labor[0] * \n",
    "        sg_df.Efficiency[0])**(1-alpha))\n",
    "    sg_df.Output_per_Worker[0] = sg_df.Output[0]/sg_df.Labor[0]\n",
    "    sg_df.Capital_Output_Ratio[0] = sg_df.Capital[0]/sg_df.Output[0]\n",
    "    \n",
    "    sg_df.BGP_ini_Capital_Output_Ratio[0] = (s / (n + g + delta))\n",
    "    sg_df.BGP_ini_Output_per_Worker[0] = sg_df.Efficiency[0] * (\n",
    "        sg_df.BGP_ini_Capital_Output_Ratio[0]*(alpha/(1 - alpha)))\n",
    "    sg_df.BGP_ini_Output[0] = sg_df.BGP_ini_Output_per_Worker[0] * sg_df.Labor[0]\n",
    "    sg_df.BGP_ini_Capital[0] = sg_df.Labor[0] * sg_df.Efficiency[0] * (\n",
    "        sg_df.BGP_ini_Capital_Output_Ratio[0]*(1/(1 - alpha)))\n",
    "    \n",
    "    sg_df.BGP_alt_Capital_Output_Ratio[0] = ((s + Delta_s) / \n",
    "        (n + Delta_n + g + Delta_g + delta))\n",
    "    sg_df.BGP_alt_Output_per_Worker[0] = sg_df.Efficiency[0] * (\n",
    "        sg_df.BGP_alt_Capital_Output_Ratio[0]*(alpha/(1 - alpha)))\n",
    "    sg_df.BGP_alt_Output[0] = sg_df.BGP_alt_Output_per_Worker[0] * sg_df.Labor[0]\n",
    "    sg_df.BGP_alt_Capital[0] = sg_df.Labor[0] * sg_df.Efficiency[0] * (\n",
    "        sg_df.BGP_alt_Capital_Output_Ratio[0]*(1/(1 - alpha)))\n",
    "    \n",
    "\n",
    "    for i in range(T):\n",
    "        if (sg_df.Output_per_Worker[i] < 2*ybar):\n",
    "            n = phi * np.log(sg_df.Output_per_Worker[i]/ybar)\n",
    "        else:\n",
    "            n = phi * np.log(2)*np.exp(-sg_df.Output_per_Worker[i]/(2*ybar) + 1)\n",
    "        sg_df.Labor[i+1] = (sg_df.Labor[i] * np.exp(10*(n + Delta_n)))\n",
    "        sg_df.Ideas[i+1] = sg_df.Ideas[i]*np.exp(10*min((h*sg_df.Labor[i]**lambda_i), 0.02))\n",
    "        sg_df.Resources[i+1] = sg_df.Resources[i]\n",
    "        KoverY_current = sg_df.Capital[i]/sg_df.Output[i]\n",
    "        sg_df.Capital[i+1] = (sg_df.Capital[i] * np.exp(10*(s+Delta_s)/ \n",
    "            KoverY_current - 10*delta))\n",
    "        \n",
    "        sg_df.Efficiency[i+1] = (sg_df.Ideas[i+1]**(gamma/(1+gamma)) * \n",
    "            (sg_df.Resources[i+1]/sg_df.Labor[i+1])**(1/(1+gamma)))\n",
    "        sg_df.Output[i+1] = (sg_df.Capital[i+1]**alpha * \n",
    "            (sg_df.Labor[i+1] * sg_df.Efficiency[i+1])**(1-alpha))\n",
    "        sg_df.Output_per_Worker[i+1] = sg_df.Output[i+1]/sg_df.Labor[i+1]\n",
    "        sg_df.Capital_Output_Ratio[i+1] = (sg_df.Capital[i+1]/\n",
    "            sg_df.Output[i+1])\n",
    "        \n",
    "        sg_df.BGP_ini_Labor[i+1] = (sg_df.BGP_ini_Labor[i] * np.exp(n))\n",
    "        sg_df.BGP_ini_Eff[i+1] = (sg_df.BGP_ini_Eff[i] * np.exp(g))\n",
    "        sg_df.BGP_ini_Capital_Output_Ratio[i+1] = (s / (n + g + delta))\n",
    "        sg_df.BGP_ini_Output_per_Worker[i+1] = sg_df.BGP_ini_Eff[i+1] * (\n",
    "            sg_df.BGP_ini_Capital_Output_Ratio[i+1]**(alpha/(1 - alpha)))\n",
    "        sg_df.BGP_ini_Output[i+1] = (sg_df.BGP_ini_Output_per_Worker[i+1] * \n",
    "            sg_df.BGP_ini_Labor[i+1])\n",
    "        sg_df.BGP_ini_Capital[i+1] = (s / (n + g + delta))**(1/(1-alpha)) * (\n",
    "            sg_df.BGP_ini_Eff[i+1] * sg_df.BGP_ini_Labor[i+1])\n",
    "        \n",
    "        sg_df.BGP_alt_Labor[i+1] = (sg_df.BGP_alt_Labor[i] * np.exp(n+ Delta_n))\n",
    "        sg_df.BGP_alt_Eff[i+1] = (sg_df.BGP_alt_Eff[i] * np.exp(g+ Delta_g))\n",
    "        sg_df.BGP_alt_Capital_Output_Ratio[i+1] = ((s+ Delta_s) / \n",
    "            (n + Delta_n + g + Delta_g + delta))\n",
    "        sg_df.BGP_alt_Output_per_Worker[i+1] = sg_df.BGP_alt_Eff[i+1] * (\n",
    "            sg_df.BGP_alt_Capital_Output_Ratio[i+1]**(alpha/(1 - alpha)))\n",
    "        sg_df.BGP_alt_Output[i+1] = (sg_df.BGP_alt_Output_per_Worker[i+1] * \n",
    "            sg_df.BGP_alt_Labor[i+1])\n",
    "        sg_df.BGP_alt_Capital[i+1] = ((s + Delta_s) / (n + Delta_n + \n",
    "            g + Delta_g + delta))**(1/(1-alpha)) * (\n",
    "            sg_df.BGP_alt_Eff[i+1] * sg_df.BGP_alt_Labor[i+1])\n",
    "    \n",
    "    sg_df.Year = range(-8000, -8000 + 10*T, 10)\n",
    "    \n",
    "    sg_df = sg_df.set_index('Year')\n",
    "        \n",
    "    fig = plt.figure(figsize=(12, 9))\n",
    "\n",
    "    ax1 = plt.subplot(2,3,1)\n",
    "    sg_df.Labor.plot(ax = ax1, title = \"Labor Force\")\n",
    "    plt.ylabel(\"Values\")\n",
    "    plt.ylim(0, )\n",
    "\n",
    "    ax2 = plt.subplot(2,3,2)\n",
    "    sg_df.Efficiency.plot(ax = ax2, title = \"Efficiency of Labor\")\n",
    "    plt.ylim(0, )\n",
    "    \n",
    "    ax3 = plt.subplot(2,3,3)\n",
    "    sg_df.Capital.plot(ax = ax3, title = \"Capital Stock\")\n",
    "    plt.ylim(0, )\n",
    "\n",
    "    ax4 = plt.subplot(2,3,4)\n",
    "    sg_df.Output.plot(ax = ax4, title = \"Output\")\n",
    "    plt.ylabel(\"Values\")\n",
    "    plt.xlabel(\"Years\")\n",
    "    plt.ylim(0, )\n",
    "\n",
    "    ax5 = plt.subplot(2,3,5)\n",
    "    sg_df.Output_per_Worker.plot(ax = ax5, title = \"Output per Worker\")\n",
    "    plt.xlabel(\"Years\")\n",
    "    plt.ylim(0, )\n",
    "\n",
    "    ax6 = plt.subplot(2,3,6)\n",
    "    sg_df.Capital_Output_Ratio.plot(ax = ax6, \n",
    "        title = \"Capital-Output Ratio\")\n",
    "    plt.xlabel(\"Years\")\n",
    "    plt.ylim(0, 6)\n",
    "\n",
    "    plt.suptitle(figure_title, size = 20)\n",
    "\n",
    "    plt.show()\n",
    "    \n",
    "    print(n + Delta_n, \"is the labor force growth rate\")\n",
    "    print(g + Delta_g, \"is the efficiency of labor growth rate\")\n",
    "    print(delta, \"is the depreciation rate\")\n",
    "    print(s + Delta_s, \"is the savings rate\")\n",
    "    print(alpha, \"is the decreasing-returns-to-scale parameter\")\n",
    "    print(\" \")\n",
    "    print(sg_df.Labor[0], \"is the labor force in year 0\")\n",
    "    print(sg_df.Output_per_Worker[0], \"is output per worker in year 0\")\n",
    "    print(\" \")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sgm_malthus_run(T=801, figure_title = \"Demographic Transition\", \n",
    "    h=0.0000805, phi=0.01, ybar = 1500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "_ = ok.submit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appendix: Programming Dos and Don'ts...\n",
    "\n",
    "### A Running List...\n",
    "\n",
    "1. **Do** restart your kernel and run cells up to your current working point every fifteen minutes or so. Yes, it takes a little time. But if you don't, sooner or later the machine's namespace will get confused, and then you will get confused about the state of the machine's namespace, and by assuming things about it that are false you will lose hours and hours...   \n",
    "&nbsp;   \n",
    "\n",
    "2. **Do** edit code cells by copying them below your current version and then working on the copy: when you break everything in the current cell (as you will), you can then go back to the old cell and start fresh...   \n",
    "&nbsp;\n",
    "\n",
    "3. **Do** exercise agile development practices: if there is a line of code that you have not tested, test it. The best way to test is to ask the machine to echo back to you the thing you have just created in its namespace to make sure that it is what you want it to be...   \n",
    "&nbsp;\n",
    "\n",
    "4. **Do** take screenshots of your error messages...   \n",
    "&nbsp;\n",
    "\n",
    "5. **Do** google your error messages: ms. google is your best friend here...   \n",
    "&nbsp;\n",
    "\n",
    "6. **Do not** confuse assignment (\"=\") and test for equality (\"==\"). In general, if there is an \"if\" anywhere nearby, you should be testing for equality. If there is not, you should be assignment a variable in your namespace to a value. **Do** curse the mathematicians 500 years ago who did not realize that in the twenty-first century it would be very convenient if we had different and not confusable symbols for equals-as-assignment and equals-as-test...   \n",
    "&nbsp;\n",
    "\n",
    "----\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(Task ∞) Programming Practices**\n",
    "\n",
    "If it strikes you that anything should be added to this list of programming dos and don'ts, please email it to me at <delong@econ.berkeley.edu>"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Edit Metadata",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}