PS5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "# Econ 101b Problem Set 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Probem set will be due Fri Sep 21 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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%javascript\n",
    "\n",
    "IPython.OutputArea.prototype._should_scroll = function(lines) {\n",
    "    return false;}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": null,
   "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": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "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('ps5.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 5 (Due Sep 21 11:59:59 PM)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(Task A) Graphing the Production Function**\n",
    "\n",
    "The parameter $ \\alpha $ (or alpha) in the Solow Growth Model governs the economy's degree to which growth is oriented toward capital and investment being important (a high value of $ \n",
    "\\alpha $) or not so important (a low value of $ \\alpha $). This task aims to start familiarizing you with its role:\n",
    "\n",
    "The code cell below \"_TASK A CODE_\" calculates and graphs the per-worker version of the production function:\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; $ \\frac{Y}{L} = \\left(\\frac{K}{L}\\right)^{\\alpha}E^{1-\\alpha}  $\n",
    "\n",
    "for $ \\alpha $ = 0.5, E = 1. \n",
    "\n",
    "Copy and paste it further below. Then alter it to calculate the production function for $ \\alpha $ = 0.25, E = 2, and set the output variable:\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; OPW_quartertwo = output_per_worker[500, 1]. Run it. \n",
    "\n",
    "In the subsequent markdown cell \"**(Task A) Answer Discussion**\", describe the these two cases of the production function. How are the economies they describe alike? How are the economies they describe different?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TASK A CODE\n",
    "\n",
    "alpha = 0.5\n",
    "E = 1\n",
    "\n",
    "output_per_worker = np.zeros((501, 2))\n",
    "\n",
    "for i in range(501):\n",
    "    lowestkoverl = 0\n",
    "    output_per_worker[i, 0] = lowestkoverl + 2 * i\n",
    "    output_per_worker[i, 1] = (output_per_worker[i, 0] ** alpha) * E\n",
    "output_per_worker_df = DataFrame(data = output_per_worker, \n",
    "    columns = [\"Capital_per_Worker\", \"Output_per_Worker\"])\n",
    "\n",
    "output_per_worker_df.set_index('Capital_per_Worker').plot()\n",
    "plt.xlabel(\"Capital per Worker\")\n",
    "plt.ylabel(\"Output per Worker\")\n",
    "plt.ylim(0, )\n",
    "\n",
    "str1 = \"Production Function:\"\n",
    "str2 = \"Output per Worker as a Function of Capital per Worker\"\n",
    "str3 = \"for a Constant Value of the Efficiency of Labor\"\n",
    "str4 = \"α = 0.5, E = 1\"\n",
    "plt.title(str1 + \"\\n\" + str2 + \"\\n\" + str3 + \"\\n\" + str4, size = 20)\n",
    "\n",
    "OPW_halfone = output_per_worker[500, 1]\n",
    "\n",
    "print(\"Output per worker =\", OPW_halfone)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "manual_grade": true,
    "manual_problem_id": "Task D Answer Discussion"
   },
   "source": [
    "<font color=\"blue\"> **(Task A) Answer Discussion:** \n",
    "    \n",
    "</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ok.grade('q03')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(Task B): Plotting the Cobb-Douglas Production Function**:\n",
    "\n",
    "Continuing this familiarization process, we will now consider five values for this parameter $ \\alpha $: 1/4, 1/3, 1/2, 2/3, and 3/4:\n",
    "\n",
    "The code cell below, \"_TASK B CODE_\", when run plots output per worker for five different values of the orientation-of-growth-toward-capital-and-investment production function parameter α, adjusting E for each curve so that the value of output per worker is 40 when the capital-output ratio is 200:\n",
    "\n",
    "1. Run the cell.\n",
    "2. Copy the code in the cell. Paste it in a new cell below \"_TASK B CODE_\". Alter the code so that it plots the production function for the five different production function parameters, but with the value of output per worker equal to 200 whenever capital per worker is 800.\n",
    "3. Then in the \"**(Task B) Answer Discussion**\" cell, provide your assessment of whether this production function is in fact sophisticated enough: In your view, does the power to vary $ \\alpha $ and E allow an economist to come \"close enough\" to modeling the different relationships between capital per worker and output per worker that different economies might find themselves having?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TASK B CODE \n",
    "\n",
    "import numpy as np\n",
    "from pandas import DataFrame, Series\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "E = 40\n",
    "\n",
    "for a in range(5):\n",
    "    output_per_worker = np.zeros((501, 2))\n",
    "    alpha = 0.15 * (a + 1)\n",
    "    for i in range(501):\n",
    "        output_per_worker[i, 0] = 2 * i\n",
    "        output_per_worker[i, 1] = ((output_per_worker[i, 0] ** alpha) * E / \n",
    "            ((200) ** alpha) )\n",
    "    output_per_worker_df = DataFrame(data = output_per_worker, \n",
    "        columns = [\"Capital_per_Worker\", \"Output_per_Worker\"])\n",
    "\n",
    "    plt.plot(output_per_worker_df.Capital_per_Worker, output_per_worker_df.Output_per_Worker)\n",
    "    plt.legend([\"α=0.15\", \"α=0.30\", \"α=0.45\", \"α=0.60\", \"α=0.75\"])\n",
    "    \n",
    "plt.xlabel(\"Capital per Worker\")\n",
    "plt.ylabel(\"Output per Worker\")\n",
    "plt.title(\"Production Function for Varying α\\nHolding f(200) = 40\", size = 24)\n",
    "plt.xlim(0, 1000)\n",
    "plt.ylim(0, )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "manual_grade": true,
    "manual_problem_id": "Task D Answer Discussion"
   },
   "source": [
    "<font color=\"blue\"> **(Task B) Answer Discussion:** \n",
    "    \n",
    "</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ok.grade('q04')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(Task C) Getting a Sense of How the Solow Growth Model Behaves Via Simulation**\n",
    "\n",
    "Moving on to dynamics—not just what the production function looks like at a moment in time, but how a Solow Growth Model economy behaves over time:\n",
    "\n",
    "We start out with us giving you a function:\n",
    "\n",
    "    sgm_3_bgp_100yr_run(L0, E0, n=0.01, g=0.015, s=0.20,\n",
    "    alpha=0.5, delta=0.025, Delta_s=0, Delta_g=0, Delta_n=0, \n",
    "    T = 100, graphs = \"LEVELS\")\n",
    "\n",
    "calculating and plotting levels of Solow growth model variables.\n",
    "    \n",
    "Required arguments for the function are the initial level of the labor force, L0, the first argument of the function, and the initial level of the efficiency of labor, E0, the second argument of the function.\n",
    "\n",
    "Optional arguments include:\n",
    "\n",
    "* the curvature of the production function parameter alpha (or $ \\alpha $), \n",
    "\n",
    "* the depreciation rate delta (or $ \\delta $), and the time T for which the simulation is to be run; \n",
    "\n",
    "plus:\n",
    "\n",
    "* the value n of the labor-force growth rate for the baseline balanced-growth path that the economy is initially on, and the value Delta_n (or $ {\\Delta}n $) for the differential in the labor-force growth rate between the initial and the alternative balanced-gorwth path;\n",
    "\n",
    "* the value g of the efficiency-of-labor growth rate for the baseline balanced-growth path that the economy is on, and the value Delta_g (or $ {\\Delta}g $) of the differential between the baseline and the alternative scenario;   \n",
    "\n",
    "* the value s of the savings-investment share of output Y for the baseline balanced-growth path that the economy is on, and the value Delta_s (or $ {\\Delta}s $) of the differential between the baseline and the alternative scenario;\n",
    "\n",
    "* the period over which the simulation is to be run\n",
    "\n",
    "* whether the function is to plot the variables in levels (graph = \"LEVELS\"), in logs (graph = \"LOGS\"), or not plot them at all (graph = \"NONE\")\n",
    "\n",
    "If optional arguments are not given, then they take on their default values:\n",
    "\n",
    "* Zero for three baseline-alternative scenario differentials: Delta_s, Delta_n, and Delta_g ($ {\\Delta}s, {\\Delta}n, {\\Delta}g) $.\n",
    "* A labor-force growth rate n=0.01\n",
    "* An efficiency-of-labor growth rate g=0.015\n",
    "* A savings-investment share s=0.20\n",
    "* An orientation-of-growth-toward capital parameter: ($ \\alpha $) alpha=0.5\n",
    "* A depreciation rate of capital ($ \\delta $) delta=0.025\n",
    "* A time span for the simulation to run T = 100\n",
    "* A final flag for the type of graphs to be plotted: graphs == \"LEVELS\" leads the function to plot the levels of the SGM variables.\n",
    "\n",
    "The function will return a dictionary. If you save the return and park it in a variable, you can then access all of the caculated values inside the function in the \"df\" lobe, and all the graphics in the \"plots\" lobe.\n",
    "\n",
    "Begin by checking the function: run the base case with the two percentage point boost to annual labor force growth Delta_n = 0.01 ($ {\\Delta}n = 0.01 $), run other cases, and report any bugs you think you find—screenshots and emails to delong@econ.berkeley.edu.\n",
    "\n",
    "Then go on to the descriptions and tasks further down..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TASK C CODE\n",
    "#\n",
    "# FUNCTION FOR CALCULATING AND GRAPHING THE LEVELS OF \n",
    "# SOLOW GROWTH MODEL VARIABLES IN SIMULATIONS\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 base 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 base\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 base 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",
    "# variables are:\n",
    "#\n",
    "# * L0: initial labor force\n",
    "# * E0: initial efficiency of labor\n",
    "# * n: labor-force growth rate\n",
    "# * g: efficiency-of-labor growth rate\n",
    "# * s: savings-investment share\n",
    "# * alpha: growth orientation toward capital and investment parameter\n",
    "# * delta: depreciation rate\n",
    "# * Delta_s: jump in s \n",
    "# * Delta_g: jump in g\n",
    "# * Delta_n: jump in n\n",
    "\n",
    "\n",
    "def sgm_3_bgp_100yr_run(L0, E0, n=0.01, g=0.015, s=0.20, \n",
    "    alpha=0.5, delta=0.025, Delta_s=0, Delta_g=0, Delta_n=0, \n",
    "    T = 100, graphs=\"LEVELS\"):\n",
    "\n",
    "    sg_df = pd.DataFrame(index=range(T),columns=['Labor', \n",
    "        'Efficiency',\n",
    "        'Capital',\n",
    "        'Output',\n",
    "        'Output_per_Worker',\n",
    "        'Capital_Output_Ratio',\n",
    "        'BGP_base_Labor',\n",
    "        'BGP_base_Efficiency',\n",
    "        'BGP_base_Output',\n",
    "        'BGP_base_Output_per_Worker',\n",
    "        'BGP_base_Capital_Output_Ratio',\n",
    "        'BGP_base_Capital',\n",
    "        'BGP_alt_Labor',\n",
    "        'BGP_alt_Efficiency',\n",
    "        'BGP_alt_Output',\n",
    "        'BGP_alt_Output_per_Worker',\n",
    "        'BGP_alt_Capital_Output_Ratio',\n",
    "        'BGP_alt_Capital'],\n",
    "        dtype='float')\n",
    "\n",
    "    sg_df.Labor[0] = L0\n",
    "    sg_df.BGP_base_Labor[0] = L0\n",
    "    sg_df.BGP_alt_Labor[0] = L0\n",
    "    sg_df.Efficiency[0] = E0\n",
    "    sg_df.BGP_base_Efficiency[0] = E0\n",
    "    sg_df.BGP_alt_Efficiency[0] = E0\n",
    "\n",
    "    KoverY_base_steady_state = s/(n+g+delta)\n",
    "    YoverL_base_steady_state = ((s/(n+g+delta))**(alpha/(1-alpha)) \n",
    "        * E0)\n",
    "    KoverL_base_steady_state = (YoverL_base_steady_state *\n",
    "        KoverY_base_steady_state)\n",
    "    \n",
    "    sg_df.Capital[0] = KoverL_base_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_base_Capital_Output_Ratio[0] = (s / (n + g + delta))\n",
    "    sg_df.BGP_base_Output_per_Worker[0] = sg_df.Efficiency[0] * (\n",
    "        sg_df.BGP_base_Capital_Output_Ratio[0]*(alpha/(1 - alpha)))\n",
    "    sg_df.BGP_base_Output[0] = sg_df.BGP_base_Output_per_Worker[0] * sg_df.Labor[0]\n",
    "    sg_df.BGP_base_Capital[0] = sg_df.BGP_base_Output[0] * (\n",
    "        sg_df.BGP_base_Capital_Output_Ratio[0])\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.BGP_alt_Output[0] * (\n",
    "        sg_df.BGP_alt_Capital_Output_Ratio[0])\n",
    "    \n",
    "    for i in range(T):\n",
    "        sg_df.Labor[i+1] = (sg_df.Labor[i] * np.exp(n + Delta_n))\n",
    "        sg_df.Efficiency[i+1] = (sg_df.Efficiency[i] * np.exp(g + Delta_g))\n",
    "        KoverY_current = sg_df.Capital[i]/sg_df.Output[i]\n",
    "        sg_df.Capital[i+1] = (sg_df.Capital[i] * np.exp((s+Delta_s)/ \n",
    "            KoverY_current - delta))\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",
    "    for i in range(T):\n",
    "        sg_df.BGP_base_Labor[i+1] = (sg_df.BGP_base_Labor[i] * np.exp(n))\n",
    "        sg_df.BGP_base_Efficiency[i+1] = (sg_df.BGP_base_Efficiency[i] * np.exp(g))\n",
    "        sg_df.BGP_base_Capital_Output_Ratio[i+1] = (s / (n + g + delta))\n",
    "        sg_df.BGP_base_Output_per_Worker[i+1] = sg_df.BGP_base_Efficiency[i+1] * (\n",
    "            sg_df.BGP_base_Capital_Output_Ratio[i+1]**(alpha/(1 - alpha)))\n",
    "        sg_df.BGP_base_Output[i+1] = (sg_df.BGP_base_Output_per_Worker[i+1] * \n",
    "            sg_df.BGP_base_Labor[i+1])\n",
    "        sg_df.BGP_base_Capital[i+1] = (s / (n + g + delta))**(1/(1-alpha)) * (\n",
    "            sg_df.Efficiency[i+1] * sg_df.Labor[i+1])\n",
    "\n",
    "    for i in range(T):\n",
    "        sg_df.BGP_alt_Labor[i+1] = (sg_df.BGP_alt_Labor[i] * np.exp(n + Delta_n))\n",
    "        sg_df.BGP_alt_Efficiency[i+1] = (sg_df.BGP_alt_Efficiency[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_Efficiency[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 + g + Delta_g + delta))**(1/(1-alpha)) * (\n",
    "            sg_df.BGP_alt_Efficiency[i+1] * sg_df.BGP_alt_Labor[i+1])  \n",
    "    \n",
    "    if (graphs == \"LEVELS\"):\n",
    "        fig = plt.figure(figsize=(12, 12))\n",
    "\n",
    "        ax1 = plt.subplot(2,3,1)\n",
    "        sg_df.BGP_base_Labor.plot(ax = ax1, title = \"BGP (base) Labor\")\n",
    "        sg_df.BGP_alt_Labor.plot(ax = ax1, title = \"BGP (alt) Labor\")\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.BGP_base_Efficiency.plot(ax = ax2, title = \"BGP (base) Efficiency\")\n",
    "        sg_df.BGP_alt_Efficiency.plot(ax = ax2, title = \"BGP (alt) Efficiency\")\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.BGP_base_Capital.plot(ax = ax3, title = \"BGP (base) Capital Stock\")\n",
    "        sg_df.BGP_alt_Capital.plot(ax = ax3, title = \"BGP (alt) Capital Stock\")\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.BGP_base_Output.plot(ax = ax4, title = \"BGP (base) Output\")\n",
    "        sg_df.BGP_alt_Output.plot(ax = ax4, title = \"BGP (alt) Output\")\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.BGP_base_Output_per_Worker.plot(ax = ax5, title = \"BGP (base) Output per Worker\")\n",
    "        sg_df.BGP_alt_Output_per_Worker.plot(ax = ax5, title = \"BGP (alt) Output per Worker\")\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.BGP_base_Capital_Output_Ratio.plot(ax = ax6, \n",
    "            title = \"BGP (base) Capital-Output Ratio\")\n",
    "        sg_df.BGP_alt_Capital_Output_Ratio.plot(ax = ax6, \n",
    "            title = \"BGP (alt) Capital-Output Ratio\")\n",
    "        sg_df.Capital_Output_Ratio.plot(ax = ax6, \n",
    "            title = \"Capital-Output Ratio\")\n",
    "        plt.xlabel(\"Years\")\n",
    "        plt.ylim(0, )\n",
    "\n",
    "        plt.suptitle('Solow Growth Model: Levels: Simulation Run', size = 20)\n",
    "\n",
    "        plt.show()\n",
    "        \n",
    "    if (graphs == \"LOGS\"):\n",
    "        fig = plt.figure(figsize=(12, 12))\n",
    "\n",
    "        ax1 = plt.subplot(2,3,1)\n",
    "        np.log(sg_df.BGP_base_Labor).plot(ax = ax1, title = \"BGP (base) Labor\")\n",
    "        np.log(sg_df.BGP_alt_Labor).plot(ax = ax1, title = \"BGP (alt) Labor\")\n",
    "        np.log(sg_df.Labor).plot(ax = ax1, title = \"Log Labor Force\")\n",
    "        plt.ylabel(\"Values\")\n",
    "        plt.ylim(0, )\n",
    "\n",
    "        ax2 = plt.subplot(2,3,2)\n",
    "        np.log(sg_df.BGP_base_Efficiency).plot(ax = ax2, title = \"BGP (base) Efficiency\")\n",
    "        np.log(sg_df.BGP_alt_Efficiency).plot(ax = ax2, title = \"BGP (alt) Efficiency\")\n",
    "        np.log(sg_df.Efficiency).plot(ax = ax2, title = \"Log Efficiency of Labor\")\n",
    "        plt.ylim(0, )\n",
    "    \n",
    "        ax3 = plt.subplot(2,3,3)\n",
    "        np.log(sg_df.BGP_base_Capital).plot(ax = ax3, title = \"BGP (base) Capital Stock\")\n",
    "        np.log(sg_df.BGP_alt_Capital).plot(ax = ax3, title = \"BGP (alt) Capital Stock\")\n",
    "        np.log(sg_df.Capital).plot(ax = ax3, title = \"Log Capital Stock\")\n",
    "        plt.ylim(0, )\n",
    "\n",
    "        ax4 = plt.subplot(2,3,4)\n",
    "        np.log(sg_df.BGP_base_Output).plot(ax = ax4, title = \"BGP (base) Output\")\n",
    "        np.log(sg_df.BGP_alt_Output).plot(ax = ax4, title = \"BGP (alt) Output\")\n",
    "        np.log(sg_df.Output).plot(ax = ax4, title = \"Log Output\")\n",
    "        plt.ylabel(\"Values\")\n",
    "        plt.xlabel(\"Years\")\n",
    "        plt.ylim(0, )\n",
    "\n",
    "        ax5 = plt.subplot(2,3,5)\n",
    "        np.log(sg_df.BGP_base_Output_per_Worker).plot(ax = ax5, title = \"BGP (base) Output per Worker\")\n",
    "        np.log(sg_df.BGP_alt_Output_per_Worker).plot(ax = ax5, title = \"BGP (alt) Output per Worker\")\n",
    "        np.log(sg_df.Output_per_Worker).plot(ax = ax5, title = \"Log Output per Worker\")\n",
    "        plt.xlabel(\"Years\")\n",
    "        plt.ylim(0, )\n",
    "\n",
    "        ax6 = plt.subplot(2,3,6)\n",
    "        sg_df.BGP_base_Capital_Output_Ratio.plot(ax = ax6, \n",
    "            title = \"BGP (base) Capital-Output Ratio\")\n",
    "        sg_df.BGP_alt_Capital_Output_Ratio.plot(ax = ax6, \n",
    "            title = \"BGP (alt) Capital-Output Ratio\")\n",
    "        sg_df.Capital_Output_Ratio.plot(ax = ax6, \n",
    "            title = \"Capital-Output Ratio\")\n",
    "        plt.xlabel(\"Years\")\n",
    "        plt.ylim(0, )\n",
    "\n",
    "        plt.suptitle('Solow Growth Model: Logs: Simulation Run', size = 20)\n",
    "\n",
    "        plt.show()\n",
    "    \n",
    "    if ((graphs != \"LEVELS\") and (graphs != \"LOGS\")):\n",
    "        fig = \"NONE\"\n",
    "        \n",
    "    print(\"The blue line is the initial balanced-growth path;\")\n",
    "    print(\"the orange line is the alternative balanced growth path;\")\n",
    "    print(\"the green line is the track of the economy as it transitions\")\n",
    "    print(\"from the baseline to the alternative BGP.\")\n",
    "    print(\" \")\n",
    "    \n",
    "    print(n, \"is the baseline labor-force growth rate\")\n",
    "    print(g, \"is the baseline efficiency-of-labor growth rate\")\n",
    "    print(s, \"is the baseline savings rate\")\n",
    "    print(\" \")\n",
    "          \n",
    "    print(n + Delta_n, \"is the alternative labor-force growth rate\")\n",
    "    print(g + Delta_g, \"is the alternative efficiency-of-labor growth rate\")\n",
    "    print(s + Delta_s, \"is the alternative savings-investment rate\")\n",
    "    print(\" \")\n",
    "    \n",
    "    print(delta, \"is the depreciation rate\")\n",
    "    print(alpha, \"is the orientation-of-growth-toward-capital parameter\")\n",
    "    \n",
    "    SGM_dict = {}\n",
    "    SGM_dict[\"df\"] = sg_df\n",
    "    SGM_dict[\"plots\"] = fig\n",
    "    \n",
    "    return SGM_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now let's see how this works in a base case...\n",
    "\n",
    "output = sgm_3_bgp_100yr_run(L0=1000, E0=1, graphs = \"LEVELS\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now let's see how this works in a base case and with the labor-\n",
    "# force growth rate boosted by 1% per year in the alternative case...\n",
    "\n",
    "output = sgm_3_bgp_100yr_run(L0=1000, E0=1, Delta_n=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now let's save our results to a particular variable—output1—\n",
    "# and look at what the value of the capital stock is in year 50...\n",
    "\n",
    "# Save the output of fhe function...\n",
    "\n",
    "output1 = sgm_3_bgp_100yr_run(L0=1000, E0=1, n=0.0, g=0.0, s=0.20, \n",
    "    alpha=0.5, delta=0.025, Delta_s=0.0, Delta_g=0, Delta_n=0.01, graphs=\"LEVELS\")\n",
    "\n",
    "# Now look at the 50th value of the \"Capital\" series in the\n",
    "# \"df\" lobe of the dictionary \"output1\"...\n",
    "\n",
    "print(\" \")\n",
    "print(\" \")\n",
    "print(\"The value of the capital stock in the 50th year =\", output1[\"df\"].Capital[50])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now insert code cells between this markdown cell and the \"# Task C answer variables\" code cell. In them, run three simulations. in each simulation boost one of the savings rate, the efficiency of labor growth rate, and the labor force growth rate by one percentage point. \n",
    "\n",
    "Then calculate the values of K/Y in the 50th year of the simulation for each of your three simulations. In the \"# Task C answer variables\" code cell, set the variables equal to their values in your three respective simulation runs. In the \"Task C Answer Description\" markdown cell, write two paragraphs telling us what you find out about the effects of these different changes in the economic environment on a Solow growth model economy from these simulation runs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Task C answer variables\n",
    "\n",
    "KoverY_50_splus = __ # In the simulation run boosting the savings rate, the value of \n",
    "                     # the capital output ratio in the 50th year goes here\n",
    "\n",
    "KoverY_50_nplus = __ # In the simulation run boosting the labor force growth rate, the\n",
    "                     #  value of the capital output ratio in the 50th year goes here\n",
    "\n",
    "KoverY_50_gplus = __ # In the simulation run boosting the efficiency of labor growth\n",
    "                     # rate, the log value of the capital output ratio in the 50th year \n",
    "                     # goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "manual_grade": true,
    "manual_problem_id": "Task B Answer Discussion"
   },
   "source": [
    "<font color = \"blue\">**Task C Answer Discussion**:\n",
    "    \n",
    "</font>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ok.grade('q01')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(Task D): Different Values of the Production Function Parameter $\\alpha$**\n",
    "\n",
    "Still working with our simulation function, insert code cells immediately below to calculate—logs and levels—the effect in the Solow growth model, starting from our default base case balanced growth path, of a permanent six percentage point increase in the savings-investment rate s for five different values of the production function curvature parameter alpha ($\\alpha$): 1/4, 1/3, 1/2, 2/3, and 3/4. \n",
    "\n",
    "Also calculate the values of Y/L in the 50th year of the simulation for each of your  simulations. In the subsequent code cell \"Task D answer variables\" set the variables equal to their values in your five respective simulation runs.\n",
    "\n",
    "In the subsequent markdown cell \"Task D Answer Discussion\", write two paragraphs about what these simulation runs tell you about the differences between economies in which diminishing returns to investment set in quickly because growth is oriented away from capital and investment ($ \\alpha $, near zero), and economies in which diminishing returns set in slowly because growth is oriented toward capital and investment ($ \\alpha $ high, near one):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Task D answer variables\n",
    "\n",
    "YoverL_50_alphaquarter = __ # In the simulation run boosting the savings rate \n",
    "                            # with alpha=0.25, the value of output-per-worker\n",
    "                            # in the 50th year goes here\n",
    "\n",
    "YoverL_50_alphathird = __ # In the simulation run boosting the savings rate \n",
    "                          # with alpha=1/3, the value of output-per-worker\n",
    "                          # in the 50th year goes here\n",
    "\n",
    "YoverL_50_alphahalf = __ # In the simulation run boosting the savings rate \n",
    "                         # with alpha=0.5, the value of output-per-worker\n",
    "                         # in the 50th year goes here\n",
    "\n",
    "YoverL_50_alphatwothirds = __ # In the simulation run boosting the savings rate \n",
    "                              # with alpha=2/3, the value of output-per-worker\n",
    "                              # in the 50th year goes here\n",
    "        \n",
    "YoverL_50_alphathreequarters = __ # In the simulation run boosting the savings rate \n",
    "                                  # with alpha=3/4, the value of output-per-worker\n",
    "                                  # in the 50th year goes here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "manual_grade": true,
    "manual_problem_id": "Task C Answer Discussion"
   },
   "source": [
    "<font color=\"blue\"> **Task D Answer Discussion**:\n",
    "    \n",
    "</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ok.grade('q02')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(Task E): Calibrating the Model to the U.S. Today**\n",
    "\n",
    "The code cell below gives parameter values roughly calibrated to the U.S. economy today, and sets two variables—KoverYstarinitial and YoverLstarinitial—equal to the capital/output ratio and output per worker level for the U.S. today along its current balanced growth path. Copy and paste the code cell, and alter it to calculate and print two variables:\n",
    "\n",
    "    KoverYstaralt\n",
    "    YoverLstaralt\n",
    "    \n",
    "equal to their alternative balanced growth path values if the U.S. savings-investment rate had been 2.75 percentage points higher. Then add more code cells calculating new variables:\n",
    "\n",
    "    KoverYstarbase_F2\n",
    "    YoverLstarbase_F2\n",
    "    KoverYstaralt_F2\n",
    "    YoverLstaralt_F2\n",
    "\n",
    "corresponding to a Solow growth model economy with alpha = 1/2 and YoverLstarbase_F2 = 130000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# in the U.S. today values are approximately:\n",
    "\n",
    "n = 0.01\n",
    "g = 0.015\n",
    "delta = 0.025\n",
    "\n",
    "sbase = 0.22\n",
    "alpha = 0.333\n",
    " \n",
    "KoverYstarbase = sbase/(n + g + delta)\n",
    "\n",
    "E = 65067.5831863\n",
    "\n",
    "YoverLstarbase = KoverYstarbase**(alpha/(1-alpha)) * E\n",
    "\n",
    "print(KoverYstarbase, \"= KoverYstarbase\")\n",
    "print(YoverLstarbase, \"= YoverLstarbase\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# higher savings-investment rate s:\n",
    "\n",
    "n = 0.01\n",
    "g = 0.015\n",
    "delta = 0.025\n",
    "\n",
    "sbase = 0.22\n",
    "alpha = 0.333\n",
    "\n",
    "salt = sbase + 0.0275\n",
    " \n",
    "KoverYstaralt = salt/(n+g+delta)\n",
    "YoverLstaralt = \n",
    "\n",
    "print(KoverYstaralt, \"= KoverYstaralt\")\n",
    "print(YoverLstaralt, \"= YoverLstaralt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# higher alpha and higher savings-investment rate s\n",
    "\n",
    "n = 0.01\n",
    "g = 0.015\n",
    "delta = 0.025\n",
    "\n",
    "sbase = 0.22\n",
    "alpha = 0.333\n",
    " \n",
    "KoverYstarbase_F2\n",
    "YoverLstarbase_F2\n",
    "KoverYstaralt_F2\n",
    "YoverLstaralt_F2\n",
    "\n",
    "print(KoverYstarbase_F2, \"= KoverYstarbase_F2\")\n",
    "print(YoverLstarbase_F2, \"= YoverLstarbase_F2\")\n",
    "print(KoverYstaralt_F2, \"= KoverYstaralt_F2\")\n",
    "print(YoverLstaralt_F2, \"= YoverLstaralt_F2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ok.grade('q05')"
   ]
  },
  {
   "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": {
  "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
}