ipynb/kerk_phillips-olg_dsge.ipynb

{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Solving a Stochastic OLG Model using DSGE Tools\n",
                "\n",
                "### by [Kerk L. Phillips](https://sites.google.com/site/kerkphillips/home), July 2018\n",
                "\n",
                "The code in this Jupyter notebook was written using Python 3.6."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "This notebook explains how to set up, solve and simulate an overlapping generations (OLG) model using the tools from DSGE modeling.  This notebook uses the linearization techniques implemented in the LinApp package.  This package can be downloaded at the following Github site.  [https://github.com/kerkphil/DSGE-Utilities](https://github.com/kerkphil/DSGE-Utilities).  Alternatively, both those files and this notebook can be found in the public GitHub repository [https://github.com/kerkphil/Jupyter_Notebooks](https://github.com/kerkphil/Jupyter_Notebooks).\n",
                "\n",
                "The LinApp package includes the following functions:\n",
                "\n",
                "LinApp_FindSS - Takes a function, funcname.py, and a steady state value for the exogenous state variables as inputs.  Finds the steady state for the model's endogenous state and jump variables.\n",
                "\n",
                "LinApp_Deriv - Takes a function, funcname.py, as an input.   Generates the derivative matrices needed for the Uhlig toolkit.\n",
                "\n",
                "LinApp_Solve - Takes the derivative matrices as inputs.  Uses the code from the Uhlig toolkit to generate the coefficients for the linearized policy function(s).\n",
                "\n",
                "LinApp_Sim - Takes the policy function coefficients and current state as inputs.  Generates the value(s) of the endogenous state variables for the next period.\n",
                "\n",
                "LinApp_SSL - Takes a history of exogenous state variables and the policy function coefficients as inputs.  Generates a history of state and jump variables using linearization about the steady state."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## A Model"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "We begin by writing down the behavioral equations for a simple OLG model.\n",
                "\n",
                "We use the following definitions:\n",
                "\n",
                "$k_{st}$ is the capital stock in period $t$ for a household of age $s$.\n",
                "\n",
                "$K_t$ is the aggregate capital stock in period $t$\n",
                "\n",
                "$z_t$ is the percent deviation of technology from its long-run value.\n",
                "\n",
                "$r_t$ is the rental rate on capital.\n",
                "\n",
                "$w_t$ is the wage rate.\n",
                "\n",
                "$c_{st}$ is private consumption.\n",
                "\n",
                "$T_{t}$ is a lump-sum transfer from the government.\n",
                "\n",
                "$\\varepsilon_t$ is the random innovation to $z_t$\n",
                "\n",
                "We also have the following parameters:\n",
                "$\\alpha$ is the capital share in GDP.\n",
                "\n",
                "$\\beta$ is the subjective discount factor.\n",
                "\n",
                "$\\gamma$ is the curvature of the utility function.  In our example this is the constant elasticity of intertemporal substitition.  It is also the constant coefficient of relative risk aversion.\n",
                "\n",
                "$\\delta$ is the rate of capital depreciation.\n",
                "\n",
                "$\\tau$ is the flat income tax rate.\n",
                "\n",
                "$\\rho$ is the autocorrelation of $z_t$.\n",
                "\n",
                "$\\sigma$ is the standard deviation of the $\\varepsilon_t$ shocks."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Suppose the household's Bellman equation is given by:\n",
                "$$ V_s(k_{st};\\theta_t) = \\max_{k_{s+1,t+1}} \\frac{c_{st}^{1-\\gamma}-1}{1-\\gamma} + \\beta E_t\\{V_{s+1}(k_{s+1,t+1},\\theta_{t+1})\\} $$\n",
                "\n",
                "$$ (1-\\tau) \\left[w_t\\ell_{s}+(r_t-\\delta)k_{st}\\right] + k_{st} + T_{t} = c_{st}+k_{s+1,t+1} $$\n",
                "\n",
                "The first-order condition is:\n",
                "$$ c_{st}^{-\\gamma} + \\beta V_{s+1,k}(k_t, z_t)= 0 $$\n",
                "The envelope condition is:\n",
                "$$ V_{sk}(k_{st};\\theta_t) = c_t^{-\\gamma}[(r_t-\\delta)(1-\\tau)+1] $$\n",
                "The Euler equation is therefore:\n",
                "$$ c_t^{-\\gamma} = \\beta c_{t+1}^{-\\gamma}[(r_{t+1}-\\delta)(1-\\tau)+1] $$\n",
                "\n",
                "From the firm's problem we have the following:\n",
                "$$ Y_t = K_t^\\alpha (L e^{z_t})^{1-\\alpha} $$\n",
                "$$ r_t = \\alpha \\frac{Y_t}{K_t} $$\n",
                "$$ w_t = (1-\\alpha) \\frac{Y_t}{L} $$\n",
                "\n",
                "Government balances its budget each period:\n",
                "$$ T_t = \\frac{1}{S} \\sum_{s=1}^S \\tau \\left[w_t\\ell_{s}+(r_t-\\delta)k_{st}\\right]$$\n",
                "\n",
                "Market clearing conditions are:\n",
                "$$K_t = \\sum_{s=1}^S k_{st}$$\n",
                "$$L = \\sum_{s=1}^S \\ell_{s}$$\n",
                "\n",
                "Finally, we assume the following law of motion for $ z_t $:\n",
                "$$ z_t = \\rho z_{t-1} + \\varepsilon_t; \\varepsilon_t \\sim iid(0,\\sigma^2) $$"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Rewriting in Matrix Form"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Define the following vectors\n",
                "\n",
                "$$\\mathbf{c}_t \\equiv \\begin{bmatrix} c_{1t} & c_{2t} & \\dots & c_{S-1,t} & c_{St} \\end{bmatrix}^{'}$$\n",
                "$$\\mathbf{c}^-_t \\equiv \\begin{bmatrix} c_{1t} & c_{2t} & \\dots & c_{S-1,t} \\end{bmatrix}^{'}$$\n",
                "$$\\mathbf{c}^+_t \\equiv \\begin{bmatrix} c_{2t} & \\dots & c_{S-1,t} & c_{St} \\end{bmatrix}^{'}$$\n",
                "$$\\mathbf{k}_t \\equiv \\begin{bmatrix} k_{2t} & \\dots & k_{S-1,t} & k_{St} \\end{bmatrix}^{'}$$\n",
                "$$\\mathbf{k}^-_t \\equiv \\begin{bmatrix} 0 & k_{2t} & \\dots & k_{S-1,t} & k_{St} \\end{bmatrix}^{'}$$\n",
                "$$\\mathbf{k}^+_t \\equiv \\begin{bmatrix} k_{2t} & \\dots & k_{S-1,t} & k_{St} & 0 \\end{bmatrix}^{'}$$\n",
                "$$\\mathbf{l} \\equiv \\begin{bmatrix} \\ell_{1} & \\ell_{2} & \\dots & \\ell_{S-1} & \\ell_{S} \\end{bmatrix}^{'}$$\n",
                "\n",
                "Given these definitions we can rewrite the behavioral equations as follows:\n",
                "\n",
                "A vector of Euler equations:\n",
                "$$\\mathbf{U}_c(\\mathbf{c}^-_{t},\\mathbf{l}^-_{t}) = \\beta E_t\\left\\{ \\mathbf{u}_c(\\mathbf{c}^+_{t+1},\\mathbf{l}^+_{t+1})[(r_{t+1}-\\delta)(1-\\tau)+1] \\right\\} $$\n",
                "\n",
                "A vector of budget constraints:\n",
                "$$(1-\\tau) \\left[w_t \\mathbf{l}_{t}+(r_t-\\delta)\\mathbf{k}^-_{t}\\right] + \\mathbf{k}^-_{t} + \\mathbf{T}_{t} = \\mathbf{c}_{t}+\\mathbf{k}^+_{t+1}$$\n",
                "\n",
                "Market clearing conditions:\n",
                "$$\\mathbf{1}_{1 \\times (S-1)} \\mathbf{k}^-_t = K_t$$\n",
                "$$\\mathbf{1}_{1 \\times S} \\mathbf{l} = L $$\n",
                "\n",
                "This system can be solved and simulated the same as an infintinely-lived-agent DSGE model with the following mappings.\n",
                "\n",
                "Endogenous state variables:\n",
                "$$X_t = \\left[\\mathbf{k}_{t-1}\\right]$$\n",
                "\n",
                "Exogenous state variables:\n",
                "$$Z_t = \\left[z_t\\right]$$"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Programming Definitions Functions"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "We want to write a function, $\\Gamma(X_{t+1}, X_t, X_{t-1}, Y_{t+1}, Y_t, Z_{t+1}, Z_t) = 0 $ based on the Euler equations.  This is now a $(n_x-1) \\times 1$ vector-evaluted function, rather than the scalar-evaluated function from a typical DSGE model with infintely-lived agents."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "First we can define $Y_t, r_t, w_t$ and $\\mathbf{c}_t$ as functions of the state $(k_t, z_t)$ using the budget constraint and the conditions from the firm's problem.  The parameters of the model, $\\alpha, \\beta, \\gamma, \\delta, \\tau, \\rho$ and  $\\sigma$, are included in the Python list `params`.  We let $\\mathbf{l}_t$ be a vector of $\\frac{1}{S}$ terms so that $L=1$.  We add definitions for aggregate consumption ($C_t$), aggregate investment ($I_t$), and individual within-period utility ($u_t$).\n",
                "\n",
                "$$ C_t = \\mathbf{1}_{1 \\times S} \\mathbf{c}_t $$\n",
                "$$ I_t = Y_t - C_t $$\n",
                "$$ u_{st} = \\frac{c_{st}^{1-\\gamma}-1}{1-\\gamma} $$"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [],
            "source": [
                "def Modeldefs(Xp, X, Z, params):\n",
                "    '''\n",
                "    This function takes vectors of endogenous and exogenous state variables\n",
                "    along with a vector of 'jump' variables and returns explicitly defined\n",
                "    values for consumption, gdp, wages, real interest rates, and transfers\n",
                "    \n",
                "    Inputs are:\n",
                "        Xp: value of capital holdings in next period\n",
                "        X: value of capital holdings this period\n",
                "        Z: value of productivity this period\n",
                "        params: list of parameter values\n",
                "    \n",
                "    Output are:\n",
                "        Y: GDP\n",
                "        w: wage rate\n",
                "        r: rental rate on capital\n",
                "        T: transfer payment\n",
                "        c: consumption by age\n",
                "        C: aggregate consumption\n",
                "        I: aggregate investment\n",
                "        u: utiity by age\n",
                "    '''\n",
                "    \n",
                "    # unpack input vectors\n",
                "    kp = np.concatenate([Xp, np.zeros(1)])\n",
                "    k = np.concatenate([np.zeros(1), X])\n",
                "    z = Z\n",
                "    \n",
                "    # find definintion values\n",
                "    K = np.sum(k)\n",
                "    Y = K**alpha*(np.exp(z))**(1-alpha)\n",
                "    w = (1-alpha)*Y\n",
                "    r = alpha*Y/K\n",
                "    T = tau*(w + (r - delta)*K)\n",
                "    c = (1-tau)*(w + (r - delta)*k) + k + T - kp\n",
                "    # check to make sure no consumptions are too low\n",
                "    c = np.maximum(c, .0001*np.ones(S))\n",
                "    C = np.sum(c)\n",
                "    I = Y - C\n",
                "    u = c**(1-gamma)/(1-gamma)\n",
                "    \n",
                "    return K, Y, w, r, T, c, C, I, u"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Next we define our $\\Gamma$ function."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "metadata": {},
            "outputs": [],
            "source": [
                "def Modeldyn(theta0, params):\n",
                "    '''\n",
                "    This function takes vectors of endogenous and exogenous state variables\n",
                "    along with a vector of 'jump' variables and returns values from the\n",
                "    characterizing Euler equations.\n",
                "    \n",
                "    Inputs are:\n",
                "        theta: a vector containng (Xpp, Xp, X, Zp, Z) where:\n",
                "            Xpp: value of capital in two periods\n",
                "            Xp: value of capital in next period\n",
                "            X: value of capital this period\n",
                "            Zp: value of productivity in next period\n",
                "            Z: value of productivity this period\n",
                "        params: list of parameter values\n",
                "    \n",
                "    Output is:\n",
                "        Gam: a vector of Euler equations written so that they are zero at the\n",
                "            steady state values of X, Y & Z.  This is an (S-1)x1 numpy array. \n",
                "    '''\n",
                "    \n",
                "    # unpack theat0\n",
                "    Xpp = theta0[0 : nx]\n",
                "    Xp = theta0[nx : 2*nx]\n",
                "    X = theta0[2*nx : 3*nx]\n",
                "    Yp = theta0[3*nx : 3*nx + ny]\n",
                "    Y = theta0[3*nx + ny : 3*nx + 2*ny]\n",
                "    Zp = theta0[3*nx + 2*ny : 3*nx + 2*ny + nz]\n",
                "    Z = theta0[3*nx + 2*ny+ nz : 3*nx + 2*ny + 2*nz]\n",
                "    \n",
                "    # find definitions for now and next period\n",
                "    K, Y, w, r, T, c, C, I, u = Modeldefs(Xp, X, Z, params)\n",
                "    Kp, Yp, wp, rp, Tp, cp, Cp, Ip, up = Modeldefs(Xpp, Xp, Zp, params)\n",
                "\n",
                "    # truncate c vectors for intertemporal Euler equation\n",
                "    c1 = c[0 : S-1]\n",
                "    c1p = cp[1 : S]\n",
                "    Gam = (c1**(-gamma)) / (beta*c1p**(-gamma)*(1 + (1-tau)*(rp - delta))) - 1.\n",
                "\n",
                "    return Gam"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Writing the Main Program"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Now we can write a program that will solve and simulate our model.\n",
                "First we need to call the Python packages and files we need."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "metadata": {},
            "outputs": [],
            "source": [
                "import numpy as np\n",
                "import matplotlib.pyplot as plt\n",
                "from LinApp import LinApp_FindSS, LinApp_Deriv, LinApp_Solve, LinApp_SSL"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Next we set our parameter values."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "metadata": {},
            "outputs": [],
            "source": [
                "S = 80\n",
                "alpha = .35\n",
                "beta = .99**(80/S)\n",
                "gamma = 2.5\n",
                "delta_ann = .08\n",
                "delta = 1. - (1. - delta_ann)**(80/S)\n",
                "tau = .05\n",
                "rho = .9**(80/S)\n",
                "sigma = .02\n",
                "\n",
                "# make parameter list to pass to functions\n",
                "params = (S, alpha, beta, gamma, delta, tau, rho, sigma)\n",
                "\n",
                "# set LinApp parameters\n",
                "Zbar = np.array([0.])\n",
                "nx = S-1\n",
                "ny = 0\n",
                "nz = 1\n",
                "logX = 0\n",
                "Sylv = 0"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Finding the Steady State"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "To find the steady state we use LinApp_FindSS.\n",
                "\n",
                "This function takes the form - LinApp_FindSS(funcname, param, guessXY, Zbar, nx, ny), where funcname will be \"Gamma\", param will be \"mparams\", guessXY will be scalar guess for the value of kbar, Zbar is 0, nx is 1, and ny is 0.  The output is XYbar, which will just be kbar in our case.  guessXY and Zbar need to be numpy arrays.\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "metadata": {
                "scrolled": true
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "check:  1.1571521518760619e-11\n"
                    ]
                },
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 432x288 with 3 Axes>"
                        ]
                    },
                    "metadata": {
                        "needs_background": "light"
                    },
                    "output_type": "display_data"
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Kbar:   7.943210686243731\n",
                        "Ybar:   [2.06537363]\n",
                        "Cbar:   107.83217737006362\n",
                        "Ibar:   [-105.76680374]\n",
                        "Tbar:   [0.07149584]\n",
                        "wbar:   [1.34249286]\n",
                        "rbar:   [0.09100612]\n"
                    ]
                }
            ],
            "source": [
                "# take a guess for steady state values of k\n",
                "kguess = 0.001\n",
                "guessXY = kguess*np.ones(nx)\n",
                "\n",
                "# find the steady state values using LinApp_FindSS\n",
                "XYbar = LinApp_FindSS(Modeldyn, params, guessXY, Zbar, nx, ny)\n",
                "kbar = XYbar[0:nx]\n",
                "\n",
                "# set up steady state input vector\n",
                "theta0 = np.concatenate([kbar, kbar, kbar, Zbar, Zbar])\n",
                "\n",
                "# check SS solution\n",
                "check = Modeldyn(theta0, params)\n",
                "print ('check: ', np.max(np.abs(check)))\n",
                "if np.max(np.abs(check)) > 1.E-6:\n",
                "    print ('Have NOT found steady state')\n",
                "\n",
                "# find other steady state values\n",
                "Kbar, Ybar, wbar, rbar, Tbar, cbar, Cbar, Ibar, ubar = Modeldefs(kbar, kbar, Zbar, params) \n",
                "Cbar = np.sum(cbar)\n",
                "\n",
                "# plot some of these as funtions of age\n",
                "plt.subplot(3, 1, 1)\n",
                "plt.plot(kbar)\n",
                "plt.xticks([])\n",
                "plt.title('SS Capital by Age', y=.92)\n",
                "\n",
                "plt.subplot(3, 1, 2)\n",
                "plt.plot(cbar)\n",
                "plt.xticks([])\n",
                "plt.title('SS Consumption by Age', y=.92)\n",
                "\n",
                "plt.subplot(3, 1, 3)\n",
                "plt.plot(ubar)\n",
                "plt.title('SS Utility by Age', y=.92)\n",
                "\n",
                "plt.show()\n",
                "\n",
                "# print values of aggregates\n",
                "print('Kbar:  ', Kbar)\n",
                "print('Ybar:  ', Ybar)\n",
                "print('Cbar:  ', Cbar)\n",
                "print('Ibar:  ', Ibar)\n",
                "print('Tbar:  ', Tbar)\n",
                "print('wbar:  ', wbar)\n",
                "print('rbar:  ', rbar)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Solving for the Policy Function Parameters"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "The next step is to find the derivatives of the Gamma function and then use these to solve for the coefficients of the linear policy function.  This requires using LinApp_Deriv and LinApp_Solve.\n",
                "\n",
                "We linearize or log-linearize the $\\Gamma(X_{t+1}, X_t, X_{t-1}, Y_{t+1}, Y_t, Z_{t+1}, Z_t) = 0 $ function about the steady state to get the following approximations.\n",
                "\n",
                "$$ A \\tilde X_{t} + B\\tilde X_{t-1} + C \\tilde Y_{t} + D \\tilde Z_{t} = 0$$\n",
                "\n",
                "$$E_t\\left\\{F \\tilde X_{t+1} + G \\tilde X_{t} + H \\tilde X_{t-1} + J \\tilde Y_{t+1} + K \\tilde Y_{t} + L \\tilde Z_{t+1} + M \\tilde Z_{t} \\right\\}= 0$$\n",
                "\n",
                "The top equation approximates the equation(s) defining any jump variables, while the bottom one approximates the equations(s) defining the endogenous state variable(s).\n",
                "\n",
                "Since we have no jump variables, we can ignore the top equation and write the bottom one as:\n",
                "\n",
                "$$E_t\\left\\{F \\tilde X_{t+1} + G \\tilde X_{t} + H \\tilde X_{t-1} + L \\tilde Z_{t+1} + M \\tilde Z_{t} \\right\\}= 0$$\n",
                "\n",
                "The linearized policy and jump functions are given by:\n",
                "\n",
                "$$\\tilde X_{t} = P \\tilde X_{t-1} + Q \\tilde Z_{t}$$\n",
                "\n",
                "$$\\tilde Y_{t} = R \\tilde X_{t-1} + S \\tilde Z_{t}$$\n",
                "\n",
                "Note that $\\tilde X_{t}$ is $X_{t} - \\bar X$ if we are simply linearizing, and is $\\frac{X_{t} - $X_{t} - \\bar X$}{$X_{t} - \\bar X}$ if we are log-linearizing.  The `LinApp_Deriv` function has an option that takes the appropriate derivatives.\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 6,
            "metadata": {},
            "outputs": [],
            "source": [
                "# find the derivatives matrices\n",
                "[AA, BB, CC, DD, FF, GG, HH, JJ, KK, LL, MM] = \\\n",
                "    LinApp_Deriv(Modeldyn, params, theta0, nx, ny, nz, logX)\n",
                "\n",
                "# set value for NN    \n",
                "NN = rho\n",
                "    \n",
                "# find the policy and jump function coefficients\n",
                "PP, QQ, RR, SS = \\\n",
                "    LinApp_Solve(AA,BB,CC,DD,FF,GG,HH,JJ,KK,LL,MM,NN,Zbar,Sylv)\n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Simulating the Model"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Finally we simulate our model using LinApp_SSL\n",
                "\n",
                "This function takes the form - LinApp_SSL(X0, Z, XYbar, logX, PP, QQ, RR, SS), where X0 is the starting value and Z is a numpy array containing a history of Z's generated using the law of motion.  Both Z and kbar must be 2-dimensional numpy arrays.\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 7,
            "metadata": {},
            "outputs": [],
            "source": [
                "# generate a history of Z's\n",
                "nobs = 250\n",
                "Zhist = np.zeros((nobs+1,1))\n",
                "for t in range(1, nobs+1):\n",
                "    Zhist[t,0] = rho*Zhist[t,0] + sigma*np.random.normal(0., 1.)\n",
                "\n",
                "XYbar = kbar\n",
                "X0 = kbar\n",
                "\n",
                "# simulate the model\n",
                "Xhist, Yhist = \\\n",
                "    LinApp_SSL(X0, Zhist, XYbar, logX, PP, QQ, RR, SS)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "With a history of k's and z's we have a history of all our state variables.  We can use our definitions function to get the histories of all the other variables."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 8,
            "metadata": {
                "scrolled": true
            },
            "outputs": [],
            "source": [
                "# generate non-state variables\n",
                "Khist = np.zeros(nobs)\n",
                "Yhist = np.zeros(nobs)\n",
                "whist = np.zeros(nobs)\n",
                "rhist = np.zeros(nobs)\n",
                "Thist = np.zeros(nobs)\n",
                "chist = np.zeros((nobs,S))\n",
                "Chist = np.zeros(nobs)\n",
                "Ihist = np.zeros(nobs)\n",
                "uhist = np.zeros((nobs,S))\n",
                "\n",
                "for t in range(0, nobs):\n",
                "    Khist[t], Yhist[t], whist[t], rhist[t], Thist[t], chist[t,:], Chist[t], Ihist[t], uhist[t,:] \\\n",
                "        = Modeldefs(Xhist[t+1,:], Xhist[t,:], Zhist[t,:], params) "
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Lastly we can plot our simulated data"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 9,
            "metadata": {
                "scrolled": true
            },
            "outputs": [
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 432x288 with 6 Axes>"
                        ]
                    },
                    "metadata": {
                        "needs_background": "light"
                    },
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# plot\n",
                "plt.subplot(3, 2, 1)\n",
                "plt.plot(Khist)\n",
                "plt.xticks([])\n",
                "plt.title('Capital', y=.92)\n",
                "\n",
                "plt.subplot(3, 2, 2)\n",
                "plt.plot(Yhist)\n",
                "plt.xticks([])\n",
                "plt.title('GDP', y=.92)\n",
                "\n",
                "plt.subplot(3, 2, 3)\n",
                "plt.plot(whist)\n",
                "plt.xticks([])\n",
                "plt.title('Wage', y=.92)\n",
                "\n",
                "plt.subplot(3, 2, 4)\n",
                "plt.plot(rhist)\n",
                "plt.xticks([])\n",
                "plt.title('Interest', y=.92)\n",
                "\n",
                "plt.subplot(3, 2, 5)\n",
                "plt.plot(Thist)\n",
                "plt.title('Taxes', y=.92)\n",
                "\n",
                "plt.subplot(3, 2, 6)\n",
                "plt.plot(Chist)\n",
                "plt.title('Consumption', y=.92)\n",
                "\n",
                "plt.show()"
            ]
        }
    ],
    "metadata": {
        "celltoolbar": "Raw Cell Format",
        "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.7.3"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 4
}