From 26b323856dd98c7b9ddeabe2df706b7374a9ab2c Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Mon, 9 Dec 2019 19:19:15 -0500 Subject: [PATCH 01/43] remove deprecated RepAgentModel file, it was used in cAndCwithStickyE but it is now updated to use ConsRepAgentModel --- HARK/ConsumptionSaving/RepAgentModel.py | 11 ----------- 1 file changed, 11 deletions(-) delete mode 100644 HARK/ConsumptionSaving/RepAgentModel.py diff --git a/HARK/ConsumptionSaving/RepAgentModel.py b/HARK/ConsumptionSaving/RepAgentModel.py deleted file mode 100644 index 6dbae740a..000000000 --- a/HARK/ConsumptionSaving/RepAgentModel.py +++ /dev/null @@ -1,11 +0,0 @@ -''' -This file appears to be an old version of what is now ConsRepAgentModel.py. -Its previous contents have been entirely removed and replaced with a universal -import from ConsRepAgentModel. Whenever a user imports from this file, they -will get a warning that they should import from ConsRepAgentModel instead. -''' - -import warnings -from HARK.ConsumptionSaving.ConsRepAgentModel import * - -warnings.warn('Please import from ConsRepAgentModel rather than RepAgentModel. This module will be removed in a future version of HARK.') \ No newline at end of file From f953536d1218a9099ad216918f6d98957452d68d Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Mon, 9 Dec 2019 19:30:10 -0500 Subject: [PATCH 02/43] remove py2 specific imports --- HARK/ConsumptionSaving/ConsAggShockModel.py | 4 ---- HARK/ConsumptionSaving/ConsGenIncProcessModel.py | 4 ---- HARK/ConsumptionSaving/ConsIndShockModel.py | 6 ------ HARK/ConsumptionSaving/ConsMarkovModel.py | 3 --- HARK/ConsumptionSaving/ConsMedModel.py | 4 ---- HARK/ConsumptionSaving/ConsPrefShockModel.py | 4 ---- HARK/ConsumptionSaving/ConsRepAgentModel.py | 4 ---- HARK/ConsumptionSaving/ConsumerParameters.py | 1 - HARK/ConsumptionSaving/TractableBufferStockModel.py | 3 --- 9 files changed, 33 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsAggShockModel.py b/HARK/ConsumptionSaving/ConsAggShockModel.py index fd1c99702..52a2bbd28 100644 --- a/HARK/ConsumptionSaving/ConsAggShockModel.py +++ b/HARK/ConsumptionSaving/ConsAggShockModel.py @@ -4,10 +4,6 @@ basic solver. Also includes a subclass of Market called CobbDouglas economy, used for solving "macroeconomic" models with aggregate shocks. ''' -from __future__ import division, print_function -from __future__ import absolute_import -from builtins import str -from builtins import range import numpy as np import scipy.stats as stats from HARK.interpolation import LinearInterp, LinearInterpOnInterp1D, ConstantFunction, IdentityFunction,\ diff --git a/HARK/ConsumptionSaving/ConsGenIncProcessModel.py b/HARK/ConsumptionSaving/ConsGenIncProcessModel.py index 748e0b1fd..36234e1a8 100644 --- a/HARK/ConsumptionSaving/ConsGenIncProcessModel.py +++ b/HARK/ConsumptionSaving/ConsGenIncProcessModel.py @@ -4,10 +4,6 @@ ConsIndShockModel by explicitly tracking persistent income as a state variable, and allows (log) persistent income to follow an AR1 process rather than random walk. ''' -from __future__ import division, print_function -from __future__ import absolute_import -from builtins import str -from builtins import range from copy import deepcopy import numpy as np from HARK import AgentType, HARKobject diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index 01e0e2f7a..86aa387df 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -12,12 +12,6 @@ See NARK for information on variable naming conventions. See HARK documentation for mathematical descriptions of the models being solved. ''' -from __future__ import division -from __future__ import print_function -from __future__ import absolute_import -from builtins import str -from builtins import range -from builtins import object from copy import copy, deepcopy import numpy as np from scipy.optimize import newton diff --git a/HARK/ConsumptionSaving/ConsMarkovModel.py b/HARK/ConsumptionSaving/ConsMarkovModel.py index d1f90280a..2d03ed80f 100644 --- a/HARK/ConsumptionSaving/ConsMarkovModel.py +++ b/HARK/ConsumptionSaving/ConsMarkovModel.py @@ -4,9 +4,6 @@ include a Markov state; the interest factor, permanent growth factor, and income distribution can vary with the discrete state. ''' -from __future__ import division, print_function -from __future__ import absolute_import -from builtins import range from copy import deepcopy import numpy as np from HARK import AgentType diff --git a/HARK/ConsumptionSaving/ConsMedModel.py b/HARK/ConsumptionSaving/ConsMedModel.py index 75b2502ad..cd4578815 100644 --- a/HARK/ConsumptionSaving/ConsMedModel.py +++ b/HARK/ConsumptionSaving/ConsMedModel.py @@ -1,10 +1,6 @@ ''' Consumption-saving models that also include medical spending. ''' -from __future__ import division, print_function -from __future__ import absolute_import -from builtins import str -from builtins import range import numpy as np from scipy.optimize import brentq from HARK import HARKobject diff --git a/HARK/ConsumptionSaving/ConsPrefShockModel.py b/HARK/ConsumptionSaving/ConsPrefShockModel.py index 636c8c3dd..a0b6f98a4 100644 --- a/HARK/ConsumptionSaving/ConsPrefShockModel.py +++ b/HARK/ConsumptionSaving/ConsPrefShockModel.py @@ -6,10 +6,6 @@ 2) A combination of (1) and ConsKinkedR, demonstrating how to construct a new model by inheriting from multiple classes. ''' -from __future__ import division, print_function -from __future__ import absolute_import -from builtins import str -from builtins import range import numpy as np from HARK.utilities import approxMeanOneLognormal from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType, ConsumerSolution, ConsIndShockSolver, \ diff --git a/HARK/ConsumptionSaving/ConsRepAgentModel.py b/HARK/ConsumptionSaving/ConsRepAgentModel.py index 1f58c2c3b..e0d985ce9 100644 --- a/HARK/ConsumptionSaving/ConsRepAgentModel.py +++ b/HARK/ConsumptionSaving/ConsRepAgentModel.py @@ -4,10 +4,6 @@ take a heterogeneous agents approach. In RA models, all attributes are either time invariant or exist on a short cycle; models must be infinite horizon. ''' -from __future__ import division, print_function -from __future__ import absolute_import -from builtins import str -from builtins import range import numpy as np from HARK.interpolation import LinearInterp from HARK.simulation import drawUniform, drawDiscrete diff --git a/HARK/ConsumptionSaving/ConsumerParameters.py b/HARK/ConsumptionSaving/ConsumerParameters.py index 83d6f827b..8bdfcd66d 100644 --- a/HARK/ConsumptionSaving/ConsumerParameters.py +++ b/HARK/ConsumptionSaving/ConsumerParameters.py @@ -3,7 +3,6 @@ consumption-saving models. These models can be found in ConsIndShockModel, ConsAggShockModel, ConsPrefShockModel, and ConsMarkovModel. ''' -from __future__ import division, print_function from copy import copy import numpy as np diff --git a/HARK/ConsumptionSaving/TractableBufferStockModel.py b/HARK/ConsumptionSaving/TractableBufferStockModel.py index 057b4c3d5..1fb135f89 100644 --- a/HARK/ConsumptionSaving/TractableBufferStockModel.py +++ b/HARK/ConsumptionSaving/TractableBufferStockModel.py @@ -20,9 +20,6 @@ Despite the non-standard solution method, the iterative process can be embedded in the HARK framework, as shown below. ''' -from __future__ import division, print_function -from __future__ import absolute_import -from builtins import str import numpy as np # Import the HARK library. From 4b616b93a76014a0169e2095311d8b9d4e035889 Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Thu, 12 Dec 2019 08:51:13 -0500 Subject: [PATCH 03/43] breakup example/test and code --- HARK/ConsumptionSaving/ConsIndShockModel.py | 176 +----------------- HARK/ConsumptionSaving/__init__.py | 1 + .../ConsumptionSaving/example_ConsIndShock.py | 148 +++++++++++++++ 3 files changed, 159 insertions(+), 166 deletions(-) create mode 100644 HARK/ConsumptionSaving/example_ConsIndShock.py diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index 86aa387df..c3e9b83b6 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -24,6 +24,11 @@ CRRAutilityPP, CRRAutilityP_inv, CRRAutility_invP, CRRAutility_inv, \ CRRAutilityP_invP +__all__ = ['ConsumerSolution', 'ValueFunc', 'MargValueFunc', 'MargMargValueFunc', +'ConsPerfForesightSolver', 'ConsIndShockSetup', 'ConsIndShockSolverBasic', +'ConsIndShockSolver', 'ConsKinkedRsolver', 'PerfForesightConsumerType', +'IndShockConsumerType', 'KinkedRconsumerType'] + utility = CRRAutility utilityP = CRRAutilityP utilityPP = CRRAutilityPP @@ -85,18 +90,11 @@ def __init__(self, cFunc=None, vFunc=None, None ''' # Change any missing function inputs to NullFunc - if cFunc is None: - cFunc = NullFunc() - if vFunc is None: - vFunc = NullFunc() - if vPfunc is None: - vPfunc = NullFunc() - if vPPfunc is None: - vPPfunc = NullFunc() - self.cFunc = cFunc - self.vFunc = vFunc - self.vPfunc = vPfunc - self.vPPfunc = vPPfunc + self.cFunc = cFunc if cFunc is not None else NullFunc() + self.vFunc = vFunc if vFunc is not None else NullFunc() + self.vPfunc = vPfunc if vPfunc is not None else NullFunc() + # vPFunc = NullFunc() if vPfunc is None else vPfunc + self.vPPfunc = vPPfunc if vPPfunc is not None else NullFunc() self.mNrmMin = mNrmMin self.hNrm = hNrm self.MPCmin = MPCmin @@ -2659,157 +2657,3 @@ def constructAssetsGrid(parameters): aXtraGrid = np.insert(aXtraGrid, j, a) return aXtraGrid - -#################################################################################################### - -def main(): - import HARK.ConsumptionSaving.ConsumerParameters as Params - from HARK.utilities import plotFuncsDer, plotFuncs - from time import time - mystr = lambda number : "{:.4f}".format(number) - - do_simulation = True - - # Make and solve an example perfect foresight consumer - PFexample = PerfForesightConsumerType(**Params.init_perfect_foresight) - PFexample.cycles = 0 # Make this type have an infinite horizon - - start_time = time() - PFexample.solve() - end_time = time() - print('Solving a perfect foresight consumer took ' + mystr(end_time-start_time) + ' seconds.') - PFexample.unpackcFunc() - PFexample.timeFwd() - - # Plot the perfect foresight consumption function - print('Perfect foresight consumption function:') - mMin = PFexample.solution[0].mNrmMin - plotFuncs(PFexample.cFunc[0],mMin,mMin+10) - - if do_simulation: - PFexample.T_sim = 120 # Set number of simulation periods - PFexample.track_vars = ['mNrmNow'] - PFexample.initializeSim() - PFexample.simulate() - -############################################################################### - - # Make and solve an example consumer with idiosyncratic income shocks - IndShockExample = IndShockConsumerType(**Params.init_idiosyncratic_shocks) - IndShockExample.cycles = 0 # Make this type have an infinite horizon - - start_time = time() - IndShockExample.solve() - end_time = time() - print('Solving a consumer with idiosyncratic shocks took ' + mystr(end_time-start_time) + ' seconds.') - IndShockExample.unpackcFunc() - IndShockExample.timeFwd() - - # Plot the consumption function and MPC for the infinite horizon consumer - print('Concave consumption function:') - plotFuncs(IndShockExample.cFunc[0],IndShockExample.solution[0].mNrmMin,5) - print('Marginal consumption function:') - plotFuncsDer(IndShockExample.cFunc[0],IndShockExample.solution[0].mNrmMin,5) - - # Compare the consumption functions for the perfect foresight and idiosyncratic - # shock types. Risky income cFunc asymptotically approaches perfect foresight cFunc. - print('Consumption functions for perfect foresight vs idiosyncratic shocks:') - plotFuncs([PFexample.cFunc[0],IndShockExample.cFunc[0]],IndShockExample.solution[0].mNrmMin,100) - - # Compare the value functions for the two types - if IndShockExample.vFuncBool: - print('Value functions for perfect foresight vs idiosyncratic shocks:') - plotFuncs([PFexample.solution[0].vFunc,IndShockExample.solution[0].vFunc], - IndShockExample.solution[0].mNrmMin+0.5,10) - - # Simulate some data; results stored in mNrmNow_hist, cNrmNow_hist, and pLvlNow_hist - if do_simulation: - IndShockExample.T_sim = 120 - IndShockExample.track_vars = ['mNrmNow','cNrmNow','pLvlNow'] - IndShockExample.makeShockHistory() # This is optional, simulation will draw shocks on the fly if it isn't run. - IndShockExample.initializeSim() - IndShockExample.simulate() - - ########################################################################### - - # Make and solve an idiosyncratic shocks consumer with a finite lifecycle - LifecycleExample = IndShockConsumerType(**Params.init_lifecycle) - LifecycleExample.cycles = 1 # Make this consumer live a sequence of periods exactly once - - start_time = time() - LifecycleExample.solve() - end_time = time() - print('Solving a lifecycle consumer took ' + mystr(end_time-start_time) + ' seconds.') - LifecycleExample.unpackcFunc() - LifecycleExample.timeFwd() - - # Plot the consumption functions during working life - print('Consumption functions while working:') - mMin = min([LifecycleExample.solution[t].mNrmMin for t in range(LifecycleExample.T_cycle)]) - plotFuncs(LifecycleExample.cFunc[:LifecycleExample.T_retire],mMin,5) - - # Plot the consumption functions during retirement - print('Consumption functions while retired:') - plotFuncs(LifecycleExample.cFunc[LifecycleExample.T_retire:],0,5) - LifecycleExample.timeRev() - - # Simulate some data; results stored in mNrmNow_hist, cNrmNow_hist, pLvlNow_hist, and t_age_hist - if do_simulation: - LifecycleExample.T_sim = 120 - LifecycleExample.track_vars = ['mNrmNow','cNrmNow','pLvlNow','t_age'] - LifecycleExample.initializeSim() - LifecycleExample.simulate() - -############################################################################### - - # Make and solve a "cyclical" consumer type who lives the same four quarters repeatedly. - # The consumer has income that greatly fluctuates throughout the year. - CyclicalExample = IndShockConsumerType(**Params.init_cyclical) - CyclicalExample.cycles = 0 - - start_time = time() - CyclicalExample.solve() - end_time = time() - print('Solving a cyclical consumer took ' + mystr(end_time-start_time) + ' seconds.') - CyclicalExample.unpackcFunc() - CyclicalExample.timeFwd() - - # Plot the consumption functions for the cyclical consumer type - print('Quarterly consumption functions:') - mMin = min([X.mNrmMin for X in CyclicalExample.solution]) - plotFuncs(CyclicalExample.cFunc,mMin,5) - - # Simulate some data; results stored in cHist, mHist, bHist, aHist, MPChist, and pHist - if do_simulation: - CyclicalExample.T_sim = 480 - CyclicalExample.track_vars = ['mNrmNow','cNrmNow','pLvlNow','t_cycle'] - CyclicalExample.initializeSim() - CyclicalExample.simulate() - -############################################################################### - - # Make and solve an agent with a kinky interest rate - KinkyExample = KinkedRconsumerType(**Params.init_kinked_R) - KinkyExample.cycles = 0 # Make the Example infinite horizon - - start_time = time() - KinkyExample.solve() - end_time = time() - print('Solving a kinky consumer took ' + mystr(end_time-start_time) + ' seconds.') - KinkyExample.unpackcFunc() - print('Kinky consumption function:') - KinkyExample.timeFwd() - plotFuncs(KinkyExample.cFunc[0],KinkyExample.solution[0].mNrmMin,5) - - if do_simulation: - KinkyExample.T_sim = 120 - KinkyExample.track_vars = ['mNrmNow','cNrmNow','pLvlNow'] - KinkyExample.initializeSim() - KinkyExample.simulate() - - return PFexample - -if __name__ == '__main__': - PFexample = main() - - diff --git a/HARK/ConsumptionSaving/__init__.py b/HARK/ConsumptionSaving/__init__.py index e69de29bb..43c3e7b4d 100644 --- a/HARK/ConsumptionSaving/__init__.py +++ b/HARK/ConsumptionSaving/__init__.py @@ -0,0 +1 @@ +from .ConsIndShockModel import * \ No newline at end of file diff --git a/HARK/ConsumptionSaving/example_ConsIndShock.py b/HARK/ConsumptionSaving/example_ConsIndShock.py new file mode 100644 index 000000000..1f1dc31ff --- /dev/null +++ b/HARK/ConsumptionSaving/example_ConsIndShock.py @@ -0,0 +1,148 @@ +import HARK.ConsumptionSaving.ConsumerParameters as Params +from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType, IndShockConsumerType, KinkedRconsumerType +from HARK.utilities import plotFuncsDer, plotFuncs +from time import time + + +mystr = lambda number : "{:.4f}".format(number) + +do_simulation = True + +# Make and solve an example perfect foresight consumer +PFexample = PerfForesightConsumerType(**Params.init_perfect_foresight) +PFexample.cycles = 0 # Make this type have an infinite horizon + +start_time = time() +PFexample.solve() +end_time = time() +print('Solving a perfect foresight consumer took ' + mystr(end_time-start_time) + ' seconds.') +PFexample.unpackcFunc() +PFexample.timeFwd() + +# Plot the perfect foresight consumption function +print('Perfect foresight consumption function:') +mMin = PFexample.solution[0].mNrmMin +plotFuncs(PFexample.cFunc[0],mMin,mMin+10) + +if do_simulation: + PFexample.T_sim = 120 # Set number of simulation periods + PFexample.track_vars = ['mNrmNow'] + PFexample.initializeSim() + PFexample.simulate() + +"" +# Make and solve an example consumer with idiosyncratic income shocks +IndShockExample = IndShockConsumerType(**Params.init_idiosyncratic_shocks) +IndShockExample.cycles = 0 # Make this type have an infinite horizon + +start_time = time() +IndShockExample.solve() +end_time = time() +print('Solving a consumer with idiosyncratic shocks took ' + mystr(end_time-start_time) + ' seconds.') +IndShockExample.unpackcFunc() +IndShockExample.timeFwd() + +# Plot the consumption function and MPC for the infinite horizon consumer +print('Concave consumption function:') +plotFuncs(IndShockExample.cFunc[0],IndShockExample.solution[0].mNrmMin,5) +print('Marginal consumption function:') +plotFuncsDer(IndShockExample.cFunc[0],IndShockExample.solution[0].mNrmMin,5) + +# Compare the consumption functions for the perfect foresight and idiosyncratic +# shock types. Risky income cFunc asymptotically approaches perfect foresight cFunc. +print('Consumption functions for perfect foresight vs idiosyncratic shocks:') +plotFuncs([PFexample.cFunc[0],IndShockExample.cFunc[0]],IndShockExample.solution[0].mNrmMin,100) + +# Compare the value functions for the two types +if IndShockExample.vFuncBool: + print('Value functions for perfect foresight vs idiosyncratic shocks:') + plotFuncs([PFexample.solution[0].vFunc,IndShockExample.solution[0].vFunc], + IndShockExample.solution[0].mNrmMin+0.5,10) + +# Simulate some data; results stored in mNrmNow_hist, cNrmNow_hist, and pLvlNow_hist +if do_simulation: + IndShockExample.T_sim = 120 + IndShockExample.track_vars = ['mNrmNow','cNrmNow','pLvlNow'] + IndShockExample.makeShockHistory() # This is optional, simulation will draw shocks on the fly if it isn't run. + IndShockExample.initializeSim() + IndShockExample.simulate() + +########################################################################### + +# Make and solve an idiosyncratic shocks consumer with a finite lifecycle +LifecycleExample = IndShockConsumerType(**Params.init_lifecycle) +LifecycleExample.cycles = 1 # Make this consumer live a sequence of periods exactly once + +start_time = time() +LifecycleExample.solve() +end_time = time() +print('Solving a lifecycle consumer took ' + mystr(end_time-start_time) + ' seconds.') +LifecycleExample.unpackcFunc() +LifecycleExample.timeFwd() + +# Plot the consumption functions during working life +print('Consumption functions while working:') +mMin = min([LifecycleExample.solution[t].mNrmMin for t in range(LifecycleExample.T_cycle)]) +plotFuncs(LifecycleExample.cFunc[:LifecycleExample.T_retire],mMin,5) + +# Plot the consumption functions during retirement +print('Consumption functions while retired:') +plotFuncs(LifecycleExample.cFunc[LifecycleExample.T_retire:],0,5) +LifecycleExample.timeRev() + +# Simulate some data; results stored in mNrmNow_hist, cNrmNow_hist, pLvlNow_hist, and t_age_hist +if do_simulation: + LifecycleExample.T_sim = 120 + LifecycleExample.track_vars = ['mNrmNow','cNrmNow','pLvlNow','t_age'] + LifecycleExample.initializeSim() + LifecycleExample.simulate() + +"" +# Make and solve a "cyclical" consumer type who lives the same four quarters repeatedly. +# The consumer has income that greatly fluctuates throughout the year. +CyclicalExample = IndShockConsumerType(**Params.init_cyclical) +CyclicalExample.cycles = 0 + +start_time = time() +CyclicalExample.solve() +end_time = time() +print('Solving a cyclical consumer took ' + mystr(end_time-start_time) + ' seconds.') +CyclicalExample.unpackcFunc() +CyclicalExample.timeFwd() + +# Plot the consumption functions for the cyclical consumer type +print('Quarterly consumption functions:') +mMin = min([X.mNrmMin for X in CyclicalExample.solution]) +plotFuncs(CyclicalExample.cFunc,mMin,5) + +# Simulate some data; results stored in cHist, mHist, bHist, aHist, MPChist, and pHist +if do_simulation: + CyclicalExample.T_sim = 480 + CyclicalExample.track_vars = ['mNrmNow','cNrmNow','pLvlNow','t_cycle'] + CyclicalExample.initializeSim() + CyclicalExample.simulate() + +"" +# Make and solve an agent with a kinky interest rate +KinkyExample = KinkedRconsumerType(**Params.init_kinked_R) +KinkyExample.cycles = 0 # Make the Example infinite horizon + +start_time = time() +KinkyExample.solve() +end_time = time() +print('Solving a kinky consumer took ' + mystr(end_time-start_time) + ' seconds.') +KinkyExample.unpackcFunc() +print('Kinky consumption function:') +KinkyExample.timeFwd() +plotFuncs(KinkyExample.cFunc[0],KinkyExample.solution[0].mNrmMin,5) + +if do_simulation: + KinkyExample.T_sim = 120 + KinkyExample.track_vars = ['mNrmNow','cNrmNow','pLvlNow'] + KinkyExample.initializeSim() + KinkyExample.simulate() + + + +"" + From 0bff841e9564fb2498aff078813abf24ca48ea0e Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Thu, 16 Jan 2020 14:50:19 +0530 Subject: [PATCH 04/43] breakup ConsAggShockModel --- HARK/ConsumptionSaving/ConsAggShockModel.py | 199 +------------ .../example_ConsAggShockModel.py | 264 ++++++++++++++++++ 2 files changed, 266 insertions(+), 197 deletions(-) create mode 100644 HARK/ConsumptionSaving/example_ConsAggShockModel.py diff --git a/HARK/ConsumptionSaving/ConsAggShockModel.py b/HARK/ConsumptionSaving/ConsAggShockModel.py index 52a2bbd28..08c43a3df 100644 --- a/HARK/ConsumptionSaving/ConsAggShockModel.py +++ b/HARK/ConsumptionSaving/ConsAggShockModel.py @@ -15,7 +15,7 @@ from HARK.ConsumptionSaving.ConsIndShockModel import ConsumerSolution, IndShockConsumerType from HARK import HARKobject, Market, AgentType from copy import deepcopy -import matplotlib.pyplot as plt +# import matplotlib.pyplot as plt # All plotting is commented out utility = CRRAutility utilityP = CRRAutilityP @@ -25,6 +25,7 @@ utility_inv = CRRAutility_inv + class MargValueFunc2D(HARKobject): ''' A class for representing a marginal value function in models where the @@ -1764,199 +1765,3 @@ def __init__(self, AFunc): ''' self.AFunc = AFunc self.distance_criteria = ['AFunc'] - - -############################################################################### - -def main(): - import HARK.ConsumptionSaving.ConsumerParameters as Params - from time import clock - from HARK.utilities import plotFuncs - - def mystr(number): return "{:.4f}".format(number) - - solve_agg_shocks_micro = False # Solve an AggShockConsumerType's microeconomic problem - solve_agg_shocks_market = True # Solve for the equilibrium aggregate saving rule in a CobbDouglasEconomy - - solve_markov_micro = False # Solve an AggShockMarkovConsumerType's microeconomic problem - solve_markov_market = True # Solve for the equilibrium aggregate saving rule in a CobbDouglasMarkovEconomy - solve_krusell_smith = True # Solve a simple Krusell-Smith-style two state, two shock model - solve_poly_state = False # Solve a CobbDouglasEconomy with many states, potentially utilizing the "state jumper" - - # EXAMPLE IMPLEMENTATIONS OF AggShockConsumerType ### - - if solve_agg_shocks_micro or solve_agg_shocks_market: - # Make an aggregate shocks consumer type - AggShockExample = AggShockConsumerType(**Params.init_agg_shocks) - AggShockExample.cycles = 0 - - # Make a Cobb-Douglas economy for the agents - EconomyExample = CobbDouglasEconomy(agents=[AggShockExample], **Params.init_cobb_douglas) - EconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks - - # Have the consumers inherit relevant objects from the economy - AggShockExample.getEconomyData(EconomyExample) - - if solve_agg_shocks_micro: - # Solve the microeconomic model for the aggregate shocks example type (and display results) - t_start = clock() - AggShockExample.solve() - t_end = clock() - print('Solving an aggregate shocks consumer took ' + mystr(t_end-t_start) + ' seconds.') - print('Consumption function at each aggregate market resources-to-labor ratio gridpoint:') - m_grid = np.linspace(0, 10, 200) - AggShockExample.unpackcFunc() - for M in AggShockExample.Mgrid.tolist(): - mMin = AggShockExample.solution[0].mNrmMin(M) - c_at_this_M = AggShockExample.cFunc[0](m_grid+mMin, M*np.ones_like(m_grid)) - plt.plot(m_grid+mMin, c_at_this_M) - plt.ylim(0., None) - plt.show() - - if solve_agg_shocks_market: - # Solve the "macroeconomic" model by searching for a "fixed point dynamic rule" - t_start = clock() - print('Now solving for the equilibrium of a Cobb-Douglas economy. This might take a few minutes...') - EconomyExample.solve() - t_end = clock() - print('Solving the "macroeconomic" aggregate shocks model took ' + str(t_end - t_start) + ' seconds.') - - print('Aggregate savings as a function of aggregate market resources:') - plotFuncs(EconomyExample.AFunc, 0, 2*EconomyExample.kSS) - print('Consumption function at each aggregate market resources gridpoint (in general equilibrium):') - AggShockExample.unpackcFunc() - m_grid = np.linspace(0, 10, 200) - AggShockExample.unpackcFunc() - for M in AggShockExample.Mgrid.tolist(): - mMin = AggShockExample.solution[0].mNrmMin(M) - c_at_this_M = AggShockExample.cFunc[0](m_grid+mMin, M*np.ones_like(m_grid)) - plt.plot(m_grid+mMin, c_at_this_M) - plt.ylim(0., None) - plt.show() - - # EXAMPLE IMPLEMENTATIONS OF AggShockMarkovConsumerType # - - if solve_markov_micro or solve_markov_market or solve_krusell_smith: - # Make a Markov aggregate shocks consumer type - AggShockMrkvExample = AggShockMarkovConsumerType(**Params.init_agg_mrkv_shocks) - AggShockMrkvExample.IncomeDstn[0] = 2*[AggShockMrkvExample.IncomeDstn[0]] - AggShockMrkvExample.cycles = 0 - - # Make a Cobb-Douglas economy for the agents - MrkvEconomyExample = CobbDouglasMarkovEconomy(agents=[AggShockMrkvExample], **Params.init_mrkv_cobb_douglas) - MrkvEconomyExample.DampingFac = 0.2 # Turn down damping - MrkvEconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks - AggShockMrkvExample.getEconomyData( - MrkvEconomyExample) # Have the consumers inherit relevant objects from the economy - - if solve_markov_micro: - # Solve the microeconomic model for the Markov aggregate shocks example type (and display results) - t_start = clock() - AggShockMrkvExample.solve() - t_end = clock() - print('Solving an aggregate shocks Markov consumer took ' + mystr(t_end-t_start) + ' seconds.') - - print('Consumption function at each aggregate market \ - resources-to-labor ratio gridpoint (for each macro state):') - m_grid = np.linspace(0, 10, 200) - AggShockMrkvExample.unpackcFunc() - for i in range(2): - for M in AggShockMrkvExample.Mgrid.tolist(): - mMin = AggShockMrkvExample.solution[0].mNrmMin[i](M) - c_at_this_M = AggShockMrkvExample.cFunc[0][i](m_grid+mMin, M*np.ones_like(m_grid)) - plt.plot(m_grid+mMin, c_at_this_M) - plt.ylim(0., None) - plt.show() - - if solve_markov_market: - # Solve the "macroeconomic" model by searching for a "fixed point dynamic rule" - t_start = clock() - print('Now solving a two-state Markov economy. This should take a few minutes...') - MrkvEconomyExample.solve() - t_end = clock() - print('Solving the "macroeconomic" aggregate shocks model took ' + str(t_end - t_start) + ' seconds.') - - print('Consumption function at each aggregate market \ - resources-to-labor ratio gridpoint (for each macro state):') - m_grid = np.linspace(0, 10, 200) - AggShockMrkvExample.unpackcFunc() - for i in range(2): - for M in AggShockMrkvExample.Mgrid.tolist(): - mMin = AggShockMrkvExample.solution[0].mNrmMin[i](M) - c_at_this_M = AggShockMrkvExample.cFunc[0][i](m_grid+mMin, M*np.ones_like(m_grid)) - plt.plot(m_grid+mMin, c_at_this_M) - plt.ylim(0., None) - plt.show() - - if solve_krusell_smith: - # Make a Krusell-Smith agent type - # NOTE: These agents aren't exactly like KS, as they don't have serially correlated unemployment - KSexampleType = deepcopy(AggShockMrkvExample) - KSexampleType.IncomeDstn[0] = [[np.array([0.96, 0.04]), np.array([1.0, 1.0]), np.array([1.0/0.96, 0.0])], - [np.array([0.90, 0.10]), np.array([1.0, 1.0]), np.array([1.0/0.90, 0.0])]] - - # Make a KS economy - KSeconomy = deepcopy(MrkvEconomyExample) - KSeconomy.agents = [KSexampleType] - KSeconomy.AggShkDstn = [[np.array([1.0]), np.array([1.0]), np.array([1.05])], - [np.array([1.0]), np.array([1.0]), np.array([0.95])]] - KSeconomy.PermGroFacAgg = [1.0, 1.0] - KSexampleType.getEconomyData(KSeconomy) - KSeconomy.makeAggShkHist() - - # Solve the K-S model - t_start = clock() - print('Now solving a Krusell-Smith-style economy. This should take about a minute...') - KSeconomy.solve() - t_end = clock() - print('Solving the Krusell-Smith model took ' + str(t_end - t_start) + ' seconds.') - - if solve_poly_state: - StateCount = 15 # Number of Markov states - GrowthAvg = 1.01 # Average permanent income growth factor - GrowthWidth = 0.02 # PermGroFacAgg deviates from PermGroFacAgg in this range - Persistence = 0.90 # Probability of staying in the same Markov state - PermGroFacAgg = np.linspace(GrowthAvg-GrowthWidth, GrowthAvg+GrowthWidth, num=StateCount) - - # Make the Markov array with chosen states and persistence - PolyMrkvArray = np.zeros((StateCount, StateCount)) - for i in range(StateCount): - for j in range(StateCount): - if i == j: - PolyMrkvArray[i, j] = Persistence - elif (i == (j-1)) or (i == (j+1)): - PolyMrkvArray[i, j] = 0.5*(1.0 - Persistence) - PolyMrkvArray[0, 0] += 0.5*(1.0 - Persistence) - PolyMrkvArray[StateCount-1, StateCount-1] += 0.5*(1.0 - Persistence) - - # Make a consumer type to inhabit the economy - PolyStateExample = AggShockMarkovConsumerType(**Params.init_agg_mrkv_shocks) - PolyStateExample.MrkvArray = PolyMrkvArray - PolyStateExample.PermGroFacAgg = PermGroFacAgg - PolyStateExample.IncomeDstn[0] = StateCount*[PolyStateExample.IncomeDstn[0]] - PolyStateExample.cycles = 0 - - # Make a Cobb-Douglas economy for the agents - PolyStateEconomy = CobbDouglasMarkovEconomy(agents=[PolyStateExample], **Params.init_mrkv_cobb_douglas) - PolyStateEconomy.MrkvArray = PolyMrkvArray - PolyStateEconomy.PermGroFacAgg = PermGroFacAgg - PolyStateEconomy.PermShkAggStd = StateCount*[0.006] - PolyStateEconomy.TranShkAggStd = StateCount*[0.003] - PolyStateEconomy.slope_prev = StateCount*[1.0] - PolyStateEconomy.intercept_prev = StateCount*[0.0] - PolyStateEconomy.update() - PolyStateEconomy.makeAggShkDstn() - PolyStateEconomy.makeAggShkHist() # Simulate a history of aggregate shocks - PolyStateExample.getEconomyData( - PolyStateEconomy) # Have the consumers inherit relevant objects from the economy - - # Solve the many state model - t_start = clock() - print('Now solving an economy with ' + str(StateCount) + ' Markov states. This might take a while...') - PolyStateEconomy.solve() - t_end = clock() - print('Solving a model with ' + str(StateCount) + ' states took ' + str(t_end - t_start) + ' seconds.') - - -if __name__ == '__main__': - main() diff --git a/HARK/ConsumptionSaving/example_ConsAggShockModel.py b/HARK/ConsumptionSaving/example_ConsAggShockModel.py new file mode 100644 index 000000000..c8d462a70 --- /dev/null +++ b/HARK/ConsumptionSaving/example_ConsAggShockModel.py @@ -0,0 +1,264 @@ +import HARK.ConsumptionSaving.ConsumerParameters as Params +from time import process_time +import numpy as np +import matplotlib.pyplot as plt +from HARK.utilities import plotFuncs +from HARK.ConsumptionSaving.ConsAggShockModel import ( + AggShockConsumerType, + CobbDouglasEconomy, + AggShockMarkovConsumerType, + CobbDouglasMarkovEconomy, +) + + +def mystr(number): + return "{:.4f}".format(number) + + +solve_agg_shocks_micro = False # Solve an AggShockConsumerType's microeconomic problem +solve_agg_shocks_market = ( + True +) # Solve for the equilibrium aggregate saving rule in a CobbDouglasEconomy + +solve_markov_micro = ( + False +) # Solve an AggShockMarkovConsumerType's microeconomic problem +solve_markov_market = ( + True +) # Solve for the equilibrium aggregate saving rule in a CobbDouglasMarkovEconomy +solve_krusell_smith = ( + True +) # Solve a simple Krusell-Smith-style two state, two shock model +solve_poly_state = ( + False +) # Solve a CobbDouglasEconomy with many states, potentially utilizing the "state jumper" + +# EXAMPLE IMPLEMENTATIONS OF AggShockConsumerType ### + +if solve_agg_shocks_micro or solve_agg_shocks_market: + # Make an aggregate shocks consumer type + AggShockExample = AggShockConsumerType(**Params.init_agg_shocks) + AggShockExample.cycles = 0 + + # Make a Cobb-Douglas economy for the agents + EconomyExample = CobbDouglasEconomy( + agents=[AggShockExample], **Params.init_cobb_douglas + ) + EconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks + + # Have the consumers inherit relevant objects from the economy + AggShockExample.getEconomyData(EconomyExample) + +if solve_agg_shocks_micro: + # Solve the microeconomic model for the aggregate shocks example type (and display results) + t_start = process_time() + AggShockExample.solve() + t_end = process_time() + print( + "Solving an aggregate shocks consumer took " + + mystr(t_end - t_start) + + " seconds." + ) + print( + "Consumption function at each aggregate market resources-to-labor ratio gridpoint:" + ) + m_grid = np.linspace(0, 10, 200) + AggShockExample.unpackcFunc() + for M in AggShockExample.Mgrid.tolist(): + mMin = AggShockExample.solution[0].mNrmMin(M) + c_at_this_M = AggShockExample.cFunc[0](m_grid + mMin, M * np.ones_like(m_grid)) + plt.plot(m_grid + mMin, c_at_this_M) + plt.ylim(0.0, None) + plt.show() + +if solve_agg_shocks_market: + # Solve the "macroeconomic" model by searching for a "fixed point dynamic rule" + t_start = process_time() + print( + "Now solving for the equilibrium of a Cobb-Douglas economy. This might take a few minutes..." + ) + EconomyExample.solve() + t_end = process_time() + print( + 'Solving the "macroeconomic" aggregate shocks model took ' + + str(t_end - t_start) + + " seconds." + ) + + print("Aggregate savings as a function of aggregate market resources:") + plotFuncs(EconomyExample.AFunc, 0, 2 * EconomyExample.kSS) + print( + "Consumption function at each aggregate market resources gridpoint (in general equilibrium):" + ) + AggShockExample.unpackcFunc() + m_grid = np.linspace(0, 10, 200) + AggShockExample.unpackcFunc() + for M in AggShockExample.Mgrid.tolist(): + mMin = AggShockExample.solution[0].mNrmMin(M) + c_at_this_M = AggShockExample.cFunc[0](m_grid + mMin, M * np.ones_like(m_grid)) + plt.plot(m_grid + mMin, c_at_this_M) + plt.ylim(0.0, None) + plt.show() + +# EXAMPLE IMPLEMENTATIONS OF AggShockMarkovConsumerType # + +if solve_markov_micro or solve_markov_market or solve_krusell_smith: + # Make a Markov aggregate shocks consumer type + AggShockMrkvExample = AggShockMarkovConsumerType(**Params.init_agg_mrkv_shocks) + AggShockMrkvExample.IncomeDstn[0] = 2 * [AggShockMrkvExample.IncomeDstn[0]] + AggShockMrkvExample.cycles = 0 + + # Make a Cobb-Douglas economy for the agents + MrkvEconomyExample = CobbDouglasMarkovEconomy( + agents=[AggShockMrkvExample], **Params.init_mrkv_cobb_douglas + ) + MrkvEconomyExample.DampingFac = 0.2 # Turn down damping + MrkvEconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks + AggShockMrkvExample.getEconomyData( + MrkvEconomyExample + ) # Have the consumers inherit relevant objects from the economy + +if solve_markov_micro: + # Solve the microeconomic model for the Markov aggregate shocks example type (and display results) + t_start = process_time() + AggShockMrkvExample.solve() + t_end = process_time() + print( + "Solving an aggregate shocks Markov consumer took " + + mystr(t_end - t_start) + + " seconds." + ) + + print( + "Consumption function at each aggregate market \ + resources-to-labor ratio gridpoint (for each macro state):" + ) + m_grid = np.linspace(0, 10, 200) + AggShockMrkvExample.unpackcFunc() + for i in range(2): + for M in AggShockMrkvExample.Mgrid.tolist(): + mMin = AggShockMrkvExample.solution[0].mNrmMin[i](M) + c_at_this_M = AggShockMrkvExample.cFunc[0][i]( + m_grid + mMin, M * np.ones_like(m_grid) + ) + plt.plot(m_grid + mMin, c_at_this_M) + plt.ylim(0.0, None) + plt.show() + +if solve_markov_market: + # Solve the "macroeconomic" model by searching for a "fixed point dynamic rule" + t_start = process_time() + print("Now solving a two-state Markov economy. This should take a few minutes...") + MrkvEconomyExample.solve() + t_end = process_time() + print( + 'Solving the "macroeconomic" aggregate shocks model took ' + + str(t_end - t_start) + + " seconds." + ) + + print( + "Consumption function at each aggregate market \ + resources-to-labor ratio gridpoint (for each macro state):" + ) + m_grid = np.linspace(0, 10, 200) + AggShockMrkvExample.unpackcFunc() + for i in range(2): + for M in AggShockMrkvExample.Mgrid.tolist(): + mMin = AggShockMrkvExample.solution[0].mNrmMin[i](M) + c_at_this_M = AggShockMrkvExample.cFunc[0][i]( + m_grid + mMin, M * np.ones_like(m_grid) + ) + plt.plot(m_grid + mMin, c_at_this_M) + plt.ylim(0.0, None) + plt.show() + +if solve_krusell_smith: + # Make a Krusell-Smith agent type + # NOTE: These agents aren't exactly like KS, as they don't have serially correlated unemployment + KSexampleType = deepcopy(AggShockMrkvExample) + KSexampleType.IncomeDstn[0] = [ + [np.array([0.96, 0.04]), np.array([1.0, 1.0]), np.array([1.0 / 0.96, 0.0])], + [np.array([0.90, 0.10]), np.array([1.0, 1.0]), np.array([1.0 / 0.90, 0.0])], + ] + + # Make a KS economy + KSeconomy = deepcopy(MrkvEconomyExample) + KSeconomy.agents = [KSexampleType] + KSeconomy.AggShkDstn = [ + [np.array([1.0]), np.array([1.0]), np.array([1.05])], + [np.array([1.0]), np.array([1.0]), np.array([0.95])], + ] + KSeconomy.PermGroFacAgg = [1.0, 1.0] + KSexampleType.getEconomyData(KSeconomy) + KSeconomy.makeAggShkHist() + + # Solve the K-S model + t_start = process_time() + print( + "Now solving a Krusell-Smith-style economy. This should take about a minute..." + ) + KSeconomy.solve() + t_end = process_time() + print("Solving the Krusell-Smith model took " + str(t_end - t_start) + " seconds.") + +if solve_poly_state: + StateCount = 15 # Number of Markov states + GrowthAvg = 1.01 # Average permanent income growth factor + GrowthWidth = 0.02 # PermGroFacAgg deviates from PermGroFacAgg in this range + Persistence = 0.90 # Probability of staying in the same Markov state + PermGroFacAgg = np.linspace( + GrowthAvg - GrowthWidth, GrowthAvg + GrowthWidth, num=StateCount + ) + + # Make the Markov array with chosen states and persistence + PolyMrkvArray = np.zeros((StateCount, StateCount)) + for i in range(StateCount): + for j in range(StateCount): + if i == j: + PolyMrkvArray[i, j] = Persistence + elif (i == (j - 1)) or (i == (j + 1)): + PolyMrkvArray[i, j] = 0.5 * (1.0 - Persistence) + PolyMrkvArray[0, 0] += 0.5 * (1.0 - Persistence) + PolyMrkvArray[StateCount - 1, StateCount - 1] += 0.5 * (1.0 - Persistence) + + # Make a consumer type to inhabit the economy + PolyStateExample = AggShockMarkovConsumerType(**Params.init_agg_mrkv_shocks) + PolyStateExample.MrkvArray = PolyMrkvArray + PolyStateExample.PermGroFacAgg = PermGroFacAgg + PolyStateExample.IncomeDstn[0] = StateCount * [PolyStateExample.IncomeDstn[0]] + PolyStateExample.cycles = 0 + + # Make a Cobb-Douglas economy for the agents + PolyStateEconomy = CobbDouglasMarkovEconomy( + agents=[PolyStateExample], **Params.init_mrkv_cobb_douglas + ) + PolyStateEconomy.MrkvArray = PolyMrkvArray + PolyStateEconomy.PermGroFacAgg = PermGroFacAgg + PolyStateEconomy.PermShkAggStd = StateCount * [0.006] + PolyStateEconomy.TranShkAggStd = StateCount * [0.003] + PolyStateEconomy.slope_prev = StateCount * [1.0] + PolyStateEconomy.intercept_prev = StateCount * [0.0] + PolyStateEconomy.update() + PolyStateEconomy.makeAggShkDstn() + PolyStateEconomy.makeAggShkHist() # Simulate a history of aggregate shocks + PolyStateExample.getEconomyData( + PolyStateEconomy + ) # Have the consumers inherit relevant objects from the economy + + # Solve the many state model + t_start = process_time() + print( + "Now solving an economy with " + + str(StateCount) + + " Markov states. This might take a while..." + ) + PolyStateEconomy.solve() + t_end = process_time() + print( + "Solving a model with " + + str(StateCount) + + " states took " + + str(t_end - t_start) + + " seconds." + ) From 520fa1d2a8afdef97a07d709f6c07062d5c0ebb0 Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Thu, 16 Jan 2020 14:56:57 +0530 Subject: [PATCH 05/43] add __all__ var to ConsAggShockModel --- HARK/ConsumptionSaving/ConsAggShockModel.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/HARK/ConsumptionSaving/ConsAggShockModel.py b/HARK/ConsumptionSaving/ConsAggShockModel.py index 08c43a3df..26f05d513 100644 --- a/HARK/ConsumptionSaving/ConsAggShockModel.py +++ b/HARK/ConsumptionSaving/ConsAggShockModel.py @@ -17,6 +17,10 @@ from copy import deepcopy # import matplotlib.pyplot as plt # All plotting is commented out +__all__ = ['MargValueFunc2D', 'AggShockConsumerType', 'AggShockMarkovConsumerType', +'CobbDouglasEconomy', 'SmallOpenEconomy', 'CobbDouglasMarkovEconomy', +'SmallOpenMarkovEconomy', 'CobbDouglasAggVars', 'AggregateSavingRule', 'AggShocksDynamicRule'] + utility = CRRAutility utilityP = CRRAutilityP utilityPP = CRRAutilityPP @@ -25,7 +29,6 @@ utility_inv = CRRAutility_inv - class MargValueFunc2D(HARKobject): ''' A class for representing a marginal value function in models where the From d5b6e55b51f4e7a2ad2290c1ec083d64d52a9251 Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Thu, 16 Jan 2020 14:59:35 +0530 Subject: [PATCH 06/43] update ConsPortfolioModel.py --- HARK/ConsumptionSaving/ConsPortfolioModel.py | 833 ++++++++++++------- 1 file changed, 529 insertions(+), 304 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsPortfolioModel.py b/HARK/ConsumptionSaving/ConsPortfolioModel.py index f88f25717..87cecd7ce 100644 --- a/HARK/ConsumptionSaving/ConsPortfolioModel.py +++ b/HARK/ConsumptionSaving/ConsPortfolioModel.py @@ -2,40 +2,50 @@ # Rfree and Risky-parameters. This should be possible by creating a list of # functions instead. -import math # we're using math for log and exp, might want to just use numpy? -import scipy.optimize as sciopt # we're using scipy optimize to optimize and fsolve -import scipy.integrate # used to calculate the expectation over returns -import scipy.stats as stats # for densities related to the returns distributions -from copy import deepcopy # it's convenient to copy things some times instead of re-creating them +import math # we're using math for log and exp, might want to just use numpy? +import scipy.optimize as sciopt # we're using scipy optimize to optimize and fsolve +import scipy.integrate # used to calculate the expectation over returns +import scipy.stats as stats # for densities related to the returns distributions +from copy import ( + deepcopy, +) # it's convenient to copy things some times instead of re-creating them # Solution is inherited from in the PortfolioSolution class, NullFunc is used # throughout HARK when no input is given and AgentType is used for .preSolve from HARK import Solution, NullFunc, AgentType from HARK.ConsumptionSaving.ConsIndShockModel import ( - PerfForesightConsumerType, # for .__init__ - IndShockConsumerType, # PortfolioConsumerType inherits from it - ConsIndShockSolver, # ConsIndShockPortfolioSolver inherits from it - ValueFunc, # to do the re-curving of value functions for interpolation - MargValueFunc, # same as above, but for marginal value functions - utility_inv, # inverse CRRA - ) + PerfForesightConsumerType, # for .__init__ + IndShockConsumerType, # PortfolioConsumerType inherits from it + ConsIndShockSolver, # ConsIndShockPortfolioSolver inherits from it + ValueFunc, # to do the re-curving of value functions for interpolation + MargValueFunc, # same as above, but for marginal value functions + utility_inv, # inverse CRRA +) from HARK.utilities import ( - approxLognormal, # for approximating the lognormal returns factor - combineIndepDstns, # for combining the existing - ) + approxLognormal, # for approximating the lognormal returns factor + combineIndepDstns, # for combining the existing +) -from HARK.simulation import drawLognormal # random draws for simulating agents +from HARK.simulation import drawLognormal # random draws for simulating agents from HARK.interpolation import ( LinearInterp, # piece-wise linear interpolation - LowerEnvelope, # lower envelope for consumption function around borrowing constraint - ) + LowerEnvelope, # lower envelope for consumption function around borrowing constraint +) -import numpy as np # for array operations +import numpy as np # for array operations +__all__ = [ + "PortfolioSolution", + "ContinuousDomain", + "DiscreteDomain", + "PortfolioConsumerType", + "ConsIndShockPortfolioSolver", + "LogNormalPortfolioConsumerType", +] # REMARK: The Campbell and Viceira (2002) approximation can be calculated from # the code below. TODO clean up # def CambellVicApprox() @@ -53,7 +63,7 @@ def _PerfForesightLogNormalPortfolioShare(Rfree, RiskyAvg, RiskyStd, CRRA): - ''' + """ Calculate the optimal portfolio share in the perfect foresight model. This does not depend on resources today or the time period. @@ -72,17 +82,18 @@ def _PerfForesightLogNormalPortfolioShare(Rfree, RiskyAvg, RiskyStd, CRRA): ------- optShare : Number The optimal portfolio share in the perfect foresight portofolio model. - ''' - PortfolioObjective = lambda share: _PerfForesightLogNormalPortfolioObjective(share, - Rfree, - RiskyAvg, - RiskyStd, - CRRA) - optShare = sciopt.minimize_scalar(PortfolioObjective, bounds=(0.0, 1.0), method='bounded').x + """ + PortfolioObjective = lambda share: _PerfForesightLogNormalPortfolioObjective( + share, Rfree, RiskyAvg, RiskyStd, CRRA + ) + optShare = sciopt.minimize_scalar( + PortfolioObjective, bounds=(0.0, 1.0), method="bounded" + ).x return optShare + def _PerfForesightDiscretePortfolioShare(Rfree, RiskyDstn, CRRA): - ''' + """ Calculate the optimal portfolio share in the perfect foresight model. This Does not depend on resources today or the time period. This version assumes that the return factor distribution is characterized by a discrete distribution @@ -103,12 +114,13 @@ def _PerfForesightDiscretePortfolioShare(Rfree, RiskyDstn, CRRA): ------- optShare : Number The optimal portfolio share in the perfect foresight portofolio model. - ''' - PortfolioObjective = lambda share: _PerfForesightDiscretePortfolioObjective(share, - Rfree, - RiskyDstn, - CRRA) - optShare = sciopt.minimize_scalar(PortfolioObjective, bounds=(0.0, 1.0), method='bounded').x + """ + PortfolioObjective = lambda share: _PerfForesightDiscretePortfolioObjective( + share, Rfree, RiskyDstn, CRRA + ) + optShare = sciopt.minimize_scalar( + PortfolioObjective, bounds=(0.0, 1.0), method="bounded" + ).x return optShare @@ -116,7 +128,7 @@ def _PerfForesightDiscretePortfolioShare(Rfree, RiskyDstn, CRRA): # It can either be "discrete" in which case it is only the number of draws that # are used, or it can be continuous in which case bounds and a pdf has to be supplied. def _PerfForesightLogNormalPortfolioIntegrand(share, Rfree, RiskyAvg, RiskyStd, CRRA): - ''' + """ Returns a function to evaluate the integrand for calculating the expectation in the perfect foresight porfolio problem with lognormal return factors. @@ -135,17 +147,18 @@ def _PerfForesightLogNormalPortfolioIntegrand(share, Rfree, RiskyAvg, RiskyStd, ------- integrand : function (lambda) Can be used to evaluate the integrand and the sent to a quadrature procedure. - ''' - muNorm = np.log(RiskyAvg/np.sqrt(1+RiskyStd**2/RiskyAvg**2)) - sigmaNorm = np.sqrt(np.log(1+RiskyStd**2/RiskyAvg**2)) - sharedobjective = lambda r: (Rfree+share*(r-Rfree))**(1-CRRA) + """ + muNorm = np.log(RiskyAvg / np.sqrt(1 + RiskyStd ** 2 / RiskyAvg ** 2)) + sigmaNorm = np.sqrt(np.log(1 + RiskyStd ** 2 / RiskyAvg ** 2)) + sharedobjective = lambda r: (Rfree + share * (r - Rfree)) ** (1 - CRRA) pdf = lambda r: stats.lognorm.pdf(r, s=sigmaNorm, scale=np.exp(muNorm)) - integrand = lambda r: sharedobjective(r)*pdf(r) + integrand = lambda r: sharedobjective(r) * pdf(r) return integrand + def _PerfForesightLogNormalPortfolioObjective(share, Rfree, RiskyAvg, RiskyStd, CRRA): - ''' + """ Returns the integral used in the perfect foresight portoflio choice problem with lognormal return factors evaluated at share. @@ -164,15 +177,17 @@ def _PerfForesightLogNormalPortfolioObjective(share, Rfree, RiskyAvg, RiskyStd, ------- integrand : function (lambda) Can be used to evaluate the integrand and the sent to a quadrature procedure. - ''' - integrand = _PerfForesightLogNormalPortfolioIntegrand(share, Rfree, RiskyAvg, RiskyStd, CRRA) - a = 0.0 # Cannot be negative - b = 5.0 # This is just an upper bound. pdf should be 0 here. - return -((1-CRRA)**-1)*scipy.integrate.quad(integrand, a, b)[0] + """ + integrand = _PerfForesightLogNormalPortfolioIntegrand( + share, Rfree, RiskyAvg, RiskyStd, CRRA + ) + a = 0.0 # Cannot be negative + b = 5.0 # This is just an upper bound. pdf should be 0 here. + return -((1 - CRRA) ** -1) * scipy.integrate.quad(integrand, a, b)[0] def _PerfForesightDiscretePortfolioObjective(share, Rfree, RiskyDstn, CRRA): - ''' + """ Returns the integral used in the perfect foresight portoflio choice problem with discretely distributed return factors evaluated at share. @@ -191,14 +206,15 @@ def _PerfForesightDiscretePortfolioObjective(share, Rfree, RiskyDstn, CRRA): ------- integrand : function (lambda) Can be used to evaluate the integrand and the sent to a quadrature procedure. - ''' - vals = (Rfree+share*(RiskyDstn[1]-Rfree))**(1-CRRA) + """ + vals = (Rfree + share * (RiskyDstn[1] - Rfree)) ** (1 - CRRA) weights = RiskyDstn[0] - return -((1-CRRA)**-1)*np.dot(vals, weights) + return -((1 - CRRA) ** -1) * np.dot(vals, weights) + def _calcwFunc(AdjustPrb, AdjustCount, ShareNowCount, vFunc_adj, CRRA): - ''' + """ Set up the value function at the point of consumption, but before portofolio choice. Depends on the probability of getting the porfolio choice this period, the possible shares today (if AdjustPrb is not 1) and the value function @@ -225,11 +241,11 @@ def _calcwFunc(AdjustPrb, AdjustCount, ShareNowCount, vFunc_adj, CRRA): ------- integrand : function (lambda) Can be used to evaluate the integrand and the sent to a quadrature procedure. - ''' + """ # AdjustCount could in principle just be inferred from AdjustPrb instead of # cartying it arround FIXME / TODO - wFunc = [] + wFunc = [] if AdjustCount == 1: # Just take the adjuster for ShareIndex in range(ShareNowCount[0]): @@ -239,9 +255,13 @@ def _calcwFunc(AdjustPrb, AdjustCount, ShareNowCount, vFunc_adj, CRRA): for ShareIndex in range(ShareNowCount[1]): # TODO FIXME better grid evalgrid = np.linspace(0, 100, 200) - evVals = AdjustPrb*vFunc_adj[0][ShareIndex](evalgrid) + (1-AdjustPrb)*vFunc_adj[1][ShareIndex](evalgrid) - with np.errstate(divide='ignore', over='ignore', under='ignore', invalid='ignore'): - evValsNvrs = utility_inv(evVals,gam=CRRA) + evVals = AdjustPrb * vFunc_adj[0][ShareIndex](evalgrid) + ( + 1 - AdjustPrb + ) * vFunc_adj[1][ShareIndex](evalgrid) + with np.errstate( + divide="ignore", over="ignore", under="ignore", invalid="ignore" + ): + evValsNvrs = utility_inv(evVals, gam=CRRA) wFunc.append(ValueFunc(LinearInterp(evVals, evValsNvrs), CRRA)) return wFunc @@ -255,35 +275,46 @@ def RiskyDstnFactory(RiskyAvg=1.0, RiskyStd=0.0): a list of lists where the first list contains the weights (probabilities) and the second list contains the values. """ - RiskyAvgSqrd = RiskyAvg**2 - RiskyVar = RiskyStd**2 + RiskyAvgSqrd = RiskyAvg ** 2 + RiskyVar = RiskyStd ** 2 - mu = math.log(RiskyAvg/(math.sqrt(1+RiskyVar/RiskyAvgSqrd))) - sigma = math.sqrt(math.log(1+RiskyVar/RiskyAvgSqrd)) + mu = math.log(RiskyAvg / (math.sqrt(1 + RiskyVar / RiskyAvgSqrd))) + sigma = math.sqrt(math.log(1 + RiskyVar / RiskyAvgSqrd)) return lambda RiskyCount: approxLognormal(RiskyCount, mu=mu, sigma=sigma) + def LogNormalRiskyDstnDraw(RiskyAvg=1.0, RiskyStd=0.0): """ A class for generating functions that draw random values from a log-normal distribution as parameterized by the input `RiskyAvg` and `RiskyStd` values. The returned function takes no argument and returns a value. """ - RiskyAvgSqrd = RiskyAvg**2 - RiskyVar = RiskyStd**2 + RiskyAvgSqrd = RiskyAvg ** 2 + RiskyVar = RiskyStd ** 2 - mu = math.log(RiskyAvg/(math.sqrt(1+RiskyVar/RiskyAvgSqrd))) - sigma = math.sqrt(math.log(1+RiskyVar/RiskyAvgSqrd)) + mu = math.log(RiskyAvg / (math.sqrt(1 + RiskyVar / RiskyAvgSqrd))) + sigma = math.sqrt(math.log(1 + RiskyVar / RiskyAvgSqrd)) return lambda rngSeed: drawLognormal(1, mu=mu, sigma=sigma, seed=rngSeed) class PortfolioSolution(Solution): - distance_criteria = ['cFunc'] - - def __init__(self, cFunc=None, vFunc=None, wFunc=None, - vPfunc=None, RiskyShareFunc=None, vPPfunc=None, - mNrmMin=None, hNrm=None, MPCmin=None, MPCmax=None): + distance_criteria = ["cFunc"] + + def __init__( + self, + cFunc=None, + vFunc=None, + wFunc=None, + vPfunc=None, + RiskyShareFunc=None, + vPPfunc=None, + mNrmMin=None, + hNrm=None, + MPCmin=None, + MPCmax=None, + ): """We implement three different ways to allow portfolio choice. The agent can choose: @@ -318,11 +349,11 @@ def __init__(self, cFunc=None, vFunc=None, wFunc=None, vPfunc = NullFunc() if vPPfunc is None: vPPfunc = NullFunc() - self.cFunc = cFunc - self.vFunc = vFunc - self.vPfunc = vPfunc + self.cFunc = cFunc + self.vFunc = vFunc + self.vPfunc = vPfunc self.RiskyShareFunc = RiskyShareFunc - self.wFunc = wFunc + self.wFunc = wFunc # self.vPPfunc = vPPfunc # self.mNrmMin = mNrmMin # self.hNrm = hNrm @@ -333,9 +364,9 @@ def __init__(self, cFunc=None, vFunc=None, wFunc=None, # These domains are convenient for switching to relavent code paths internally. # It might be simpler to just pass in vectors instead of DiscreteDomain. class ContinuousDomain(object): - def __init__(self, lower, upper, points = [np.nan]): + def __init__(self, lower, upper, points=[np.nan]): if lower > upper: - raise Exception('lower bounds is larger than upper bound') + raise Exception("lower bounds is larger than upper bound") else: self.lower = lower self.upper = upper @@ -347,6 +378,7 @@ def getPoints(self): def len(self): return len(self.points) + class DiscreteDomain(object): def __init__(self, points): self.points = points @@ -359,25 +391,32 @@ def len(self): def getPoints(self): return self.points + class PortfolioConsumerType(IndShockConsumerType): # We add CantAdjust to the standard set of poststate_vars_ here. We call it # CantAdjust over CanAdjust, because this allows us to index into the # "CanAdjust = 1- CantAdjust" at all times (it's the 0th offset). - poststate_vars_ = ['aNrmNow', 'pLvlNow', 'RiskyShareNow', 'CantAdjust'] + poststate_vars_ = ["aNrmNow", "pLvlNow", "RiskyShareNow", "CantAdjust"] time_inv_ = deepcopy(IndShockConsumerType.time_inv_) - time_inv_ = time_inv_ + ['approxRiskyDstn', 'RiskyCount', 'RiskyShareCount'] - time_inv_ = time_inv_ + ['RiskyShareLimitFunc', 'PortfolioDomain'] - time_inv_ = time_inv_ + ['AdjustPrb', 'PortfolioGrid', 'AdjustCount'] + time_inv_ = time_inv_ + ["approxRiskyDstn", "RiskyCount", "RiskyShareCount"] + time_inv_ = time_inv_ + ["RiskyShareLimitFunc", "PortfolioDomain"] + time_inv_ = time_inv_ + ["AdjustPrb", "PortfolioGrid", "AdjustCount"] - def __init__(self,cycles=1,time_flow=True,verbose=False,quiet=False,**kwds): + def __init__(self, cycles=1, time_flow=True, verbose=False, quiet=False, **kwds): # Initialize a basic AgentType - PerfForesightConsumerType.__init__(self,cycles=cycles,time_flow=time_flow, - verbose=verbose,quiet=quiet, **kwds) + PerfForesightConsumerType.__init__( + self, + cycles=cycles, + time_flow=time_flow, + verbose=verbose, + quiet=quiet, + **kwds + ) # Check that an adjustment probability is set. If not, default to always. - if not hasattr(self, 'AdjustPrb'): + if not hasattr(self, "AdjustPrb"): self.AdjustPrb = 1.0 self.AdjustCount = 1 elif self.AdjustPrb == 1.0: @@ -388,24 +427,29 @@ def __init__(self,cycles=1,time_flow=True,verbose=False,quiet=False,**kwds): # the consumer cannot adjust in a given period. self.AdjustCount = 2 - if not hasattr(self, 'PortfolioDomain'): + if not hasattr(self, "PortfolioDomain"): if self.AdjustPrb < 1.0: - raise Exception('Please supply a PortfolioDomain when setting AdjustPrb < 1.0.') + raise Exception( + "Please supply a PortfolioDomain when setting AdjustPrb < 1.0." + ) else: - self.PortfolioDomain = ContinuousDomain(0,1) - + self.PortfolioDomain = ContinuousDomain(0, 1) if isinstance(self.PortfolioDomain, DiscreteDomain): self.DiscreteCase = True if self.vFuncBool == False: if self.verbose: - print('Setting vFuncBool to True to accomodate dicrete portfolio optimization.') + print( + "Setting vFuncBool to True to accomodate dicrete portfolio optimization." + ) self.vFuncBool = True else: self.DiscreteCase = False if self.AdjustPrb < 1.0: - raise Exception('Occational inability to re-optimize portfolio (AdjustPrb < 1.0) is currently not possible with continuous choice of the portfolio share.') + raise Exception( + "Occational inability to re-optimize portfolio (AdjustPrb < 1.0) is currently not possible with continuous choice of the portfolio share." + ) # Now we can set up the PortfolioGrid! This is the portfolio values # you can enter the period with. It's exact for discrete , for continuous @@ -414,7 +458,9 @@ def __init__(self,cycles=1,time_flow=True,verbose=False,quiet=False,**kwds): if self.BoroCnstArt is not 0.0: if self.verbose: - print("Setting BoroCnstArt to 0.0 as this is required by PortfolioConsumerType.") + print( + "Setting BoroCnstArt to 0.0 as this is required by PortfolioConsumerType." + ) self.BoroCnstArt = 0.0 self.ShareNowCount = [1] @@ -427,14 +473,16 @@ def __init__(self,cycles=1,time_flow=True,verbose=False,quiet=False,**kwds): self.update() - self.RiskyShareLimitFunc = lambda RiskyDstn: _PerfForesightDiscretePortfolioShare(self.Rfree, RiskyDstn, self.CRRA) + self.RiskyShareLimitFunc = lambda RiskyDstn: _PerfForesightDiscretePortfolioShare( + self.Rfree, RiskyDstn, self.CRRA + ) def preSolve(self): AgentType.preSolve(self) self.updateSolutionTerminal() def updateSolutionTerminal(self): - ''' + """ Updates the terminal period solution for a portfolio shock consumer. Only fills in the consumption function and marginal value function. @@ -445,13 +493,15 @@ def updateSolutionTerminal(self): Returns ------- None - ''' + """ # repeat according to number of portfolio adjustment situations # TODO FIXME this is technically incorrect, too many in [0] - cFunc_terminal = LinearInterp([0.0, 1.0], [0.0,1.0]) # c=m in terminal period - vFunc_terminal = LinearInterp([0.0, 1.0], [0.0,0.0]) # This is overwritten - RiskyShareFunc_terminal = LinearInterp([0.0, 1.0], [0.0,0.0]) # c=m in terminal period + cFunc_terminal = LinearInterp([0.0, 1.0], [0.0, 1.0]) # c=m in terminal period + vFunc_terminal = LinearInterp([0.0, 1.0], [0.0, 0.0]) # This is overwritten + RiskyShareFunc_terminal = LinearInterp( + [0.0, 1.0], [0.0, 0.0] + ) # c=m in terminal period if isinstance(self.PortfolioDomain, DiscreteDomain): PortfolioGridCount = len(self.PortfolioDomain.points) @@ -459,31 +509,42 @@ def updateSolutionTerminal(self): # This should be "PortfolioGridCount" that was set earlier, PortfolioGridCount = 1 - vFunc_terminal = PortfolioGridCount*[ValueFunc(cFunc_terminal, self.CRRA)] - vFunc_terminal = self.AdjustCount*[vFunc_terminal] - - vPfunc_terminal = PortfolioGridCount*[MargValueFunc(cFunc_terminal, self.CRRA)] - vPfunc_terminal = self.AdjustCount*[vPfunc_terminal] - - cFunc_terminal = PortfolioGridCount*[cFunc_terminal] - cFunc_terminal = self.AdjustCount*[cFunc_terminal] - - RiskyShareFunc_terminal = PortfolioGridCount*[RiskyShareFunc_terminal] - RiskyShareFunc_terminal = self.AdjustCount*[RiskyShareFunc_terminal] - - wFunc_terminal = _calcwFunc(self.AdjustPrb, self.AdjustCount, self.ShareNowCount, vFunc_terminal, self.CRRA) - - self.solution_terminal = PortfolioSolution(cFunc = cFunc_terminal, - RiskyShareFunc = RiskyShareFunc_terminal, - vFunc = vFunc_terminal, - wFunc = wFunc_terminal, - vPfunc = vPfunc_terminal, - mNrmMin=0.0, hNrm=None, - MPCmin=None, MPCmax=None) - + vFunc_terminal = PortfolioGridCount * [ValueFunc(cFunc_terminal, self.CRRA)] + vFunc_terminal = self.AdjustCount * [vFunc_terminal] + + vPfunc_terminal = PortfolioGridCount * [ + MargValueFunc(cFunc_terminal, self.CRRA) + ] + vPfunc_terminal = self.AdjustCount * [vPfunc_terminal] + + cFunc_terminal = PortfolioGridCount * [cFunc_terminal] + cFunc_terminal = self.AdjustCount * [cFunc_terminal] + + RiskyShareFunc_terminal = PortfolioGridCount * [RiskyShareFunc_terminal] + RiskyShareFunc_terminal = self.AdjustCount * [RiskyShareFunc_terminal] + + wFunc_terminal = _calcwFunc( + self.AdjustPrb, + self.AdjustCount, + self.ShareNowCount, + vFunc_terminal, + self.CRRA, + ) + + self.solution_terminal = PortfolioSolution( + cFunc=cFunc_terminal, + RiskyShareFunc=RiskyShareFunc_terminal, + vFunc=vFunc_terminal, + wFunc=wFunc_terminal, + vPfunc=vPfunc_terminal, + mNrmMin=0.0, + hNrm=None, + MPCmin=None, + MPCmax=None, + ) def getPostStates(self): - ''' + """ Calculates end-of-period assets for each consumer of this type. Parameters @@ -493,10 +554,12 @@ def getPostStates(self): Returns ------- None - ''' + """ # Calculate post decision ressources self.aNrmNow = self.mNrmNow - self.cNrmNow - self.aLvlNow = self.aNrmNow*self.pLvlNow # Useful in some cases to precalculate asset level + self.aLvlNow = ( + self.aNrmNow * self.pLvlNow + ) # Useful in some cases to precalculate asset level # We calculate the risky share given post decision assets aNrmNow. We # do this for all agents that have self.CantAdjust == 0 and save the @@ -511,21 +574,23 @@ def getPostStates(self): # First take adjusters these = np.logical_and(these_adjust, these_t) - RiskyShareNow[these] = self.solution[t].RiskyShareFunc[0][0](self.aNrmNow[these]) # should be redefined on mNrm in solve and calculated in getControls + RiskyShareNow[these] = self.solution[t].RiskyShareFunc[0][0]( + self.aNrmNow[these] + ) # should be redefined on mNrm in solve and calculated in getControls these_cant_adjust = self.CantAdjust == 1 these = np.logical_and(these_cant_adjust, these_t) - RiskyShareNow[these] = self.RiskySharePrev[these] # should be redefined on mNrm in solve and calculated in getControls - + RiskyShareNow[these] = self.RiskySharePrev[ + these + ] # should be redefined on mNrm in solve and calculated in getControls # Store the result in self self.RiskyShareNow = RiskyShareNow return None - # Simulation methods def getStates(self): - ''' + """ Calculates updated values of normalized market resources and permanent income level for each agent. Uses pLvlNow, aNrmNow, PermShkNow, TranShkNow. @@ -536,9 +601,9 @@ def getStates(self): Returns ------- None - ''' + """ RiskySharePrev = self.RiskyShareNow - self.RiskySharePrev = RiskySharePrev # Save this for the non-adjusters! + self.RiskySharePrev = RiskySharePrev # Save this for the non-adjusters! pLvlPrev = self.pLvlNow aNrmPrev = self.aNrmNow @@ -549,25 +614,29 @@ def getStates(self): RiskyNow = self.getRisky() # Calculate the portfolio return from last period to current period. - RportNow = RfreeNow + RiskySharePrev*(RiskyNow-RfreeNow) + RportNow = RfreeNow + RiskySharePrev * (RiskyNow - RfreeNow) # Calculate new states: normalized market resources and permanent income level - self.pLvlNow = pLvlPrev*self.PermShkNow # Updated permanent income level - self.PlvlAggNow = self.PlvlAggNow*self.PermShkAggNow # Updated aggregate permanent productivity level - ReffNow = RportNow/self.PermShkNow # "Effective" interest factor on normalized assets - self.bNrmNow = ReffNow*aNrmPrev # Bank balances before labor income - self.mNrmNow = self.bNrmNow + self.TranShkNow # Market resources after income + self.pLvlNow = pLvlPrev * self.PermShkNow # Updated permanent income level + self.PlvlAggNow = ( + self.PlvlAggNow * self.PermShkAggNow + ) # Updated aggregate permanent productivity level + ReffNow = ( + RportNow / self.PermShkNow + ) # "Effective" interest factor on normalized assets + self.bNrmNow = ReffNow * aNrmPrev # Bank balances before labor income + self.mNrmNow = self.bNrmNow + self.TranShkNow # Market resources after income # Figure out who can adjust their portfolio this period. - self.CantAdjust = stats.bernoulli.rvs(1-self.AdjustPrb, size=self.AgentCount) + self.CantAdjust = stats.bernoulli.rvs(1 - self.AdjustPrb, size=self.AgentCount) # New agents are always allowed to optimize their portfolio, because they # have no past portfolio to "keep". self.CantAdjust[self.new_agents] = 0.0 return None - def simBirth(self,which_agents): - ''' + def simBirth(self, which_agents): + """ Makes new consumers for the given indices. Initialized variables include aNrm and pLvl, as well as time variables t_age and t_cycle. Normalized assets and permanent income levels are drawn from lognormal distributions given by aNrmInitMean and aNrmInitStd (etc). @@ -580,20 +649,36 @@ def simBirth(self,which_agents): Returns ------- None - ''' + """ # Get and store states for newly born agents - N = np.sum(which_agents) # Number of new consumers to make - self.aNrmNow[which_agents] = drawLognormal(N,mu=self.aNrmInitMean,sigma=self.aNrmInitStd,seed=self.RNG.randint(0,2**31-1)) - pLvlInitMeanNow = self.pLvlInitMean + np.log(self.PlvlAggNow) # Account for newer cohorts having higher permanent income - self.pLvlNow[which_agents] = drawLognormal(N,mu=pLvlInitMeanNow,sigma=self.pLvlInitStd,seed=self.RNG.randint(0,2**31-1)) - - self.t_age[which_agents] = 0 # How many periods since each agent was born - self.t_cycle[which_agents] = 0 # Which period of the cycle each agent is currently in - self.new_agents = which_agents # store for portfolio choice forced to be allowed in first period + N = np.sum(which_agents) # Number of new consumers to make + self.aNrmNow[which_agents] = drawLognormal( + N, + mu=self.aNrmInitMean, + sigma=self.aNrmInitStd, + seed=self.RNG.randint(0, 2 ** 31 - 1), + ) + pLvlInitMeanNow = self.pLvlInitMean + np.log( + self.PlvlAggNow + ) # Account for newer cohorts having higher permanent income + self.pLvlNow[which_agents] = drawLognormal( + N, + mu=pLvlInitMeanNow, + sigma=self.pLvlInitStd, + seed=self.RNG.randint(0, 2 ** 31 - 1), + ) + + self.t_age[which_agents] = 0 # How many periods since each agent was born + self.t_cycle[ + which_agents + ] = 0 # Which period of the cycle each agent is currently in + self.new_agents = ( + which_agents + ) # store for portfolio choice forced to be allowed in first period return None def getControls(self): - ''' + """ Calculates consumption for each consumer of this type using the consumption functions. Parameters @@ -603,9 +688,9 @@ def getControls(self): Returns ------- None - ''' + """ cNrmNow = np.zeros(self.AgentCount) + np.nan - MPCnow = np.zeros(self.AgentCount) + np.nan + MPCnow = np.zeros(self.AgentCount) + np.nan these_cant_adjust = self.CantAdjust == 1 these_can_adjust = self.CantAdjust == 0 @@ -613,35 +698,72 @@ def getControls(self): for t in range(self.T_cycle): these_t = t == self.t_cycle these = np.logical_and(these_t, these_can_adjust) - cNrmNow[these], MPCnow[these] = self.solution[t].cFunc[0][0].eval_with_derivative(self.mNrmNow[these]) + cNrmNow[these], MPCnow[these] = ( + self.solution[t].cFunc[0][0].eval_with_derivative(self.mNrmNow[these]) + ) if any(these_cant_adjust): for portfolio_index, portfolio_value in enumerate(self.ShareNow): these_portfolio = np.equal(portfolio_value, self.RiskySharePrev) these = np.logical_and(these_t, these_portfolio) - cNrmNow[these], MPCnow[these] = self.solution[t].cFunc[1][portfolio_index].eval_with_derivative(self.mNrmNow[these]) + cNrmNow[these], MPCnow[these] = ( + self.solution[t] + .cFunc[1][portfolio_index] + .eval_with_derivative(self.mNrmNow[these]) + ) self.cNrmNow = cNrmNow self.MPCnow = MPCnow return None def getRisky(self): - return self.drawRiskyFunc(self.RNG.randint(0,2**31-1)) + return self.drawRiskyFunc(self.RNG.randint(0, 2 ** 31 - 1)) + class ConsIndShockPortfolioSolver(ConsIndShockSolver): - ''' + """ A class for solving a one period consumption-saving problem with portfolio choice. An instance of this class is created by the function solveConsPortfolio in each period. - ''' - def __init__(self, solution_next, IncomeDstn, LivPrb, DiscFac, CRRA, Rfree, - PermGroFac, BoroCnstArt, aXtraGrid, vFuncBool, CubicBool, - approxRiskyDstn, RiskyCount, RiskyShareCount, RiskyShareLimitFunc, - AdjustPrb, PortfolioGrid, AdjustCount, PortfolioDomain): - - ConsIndShockSolver.__init__(self, solution_next, IncomeDstn, LivPrb, DiscFac, CRRA, Rfree, - PermGroFac, BoroCnstArt, aXtraGrid, vFuncBool, CubicBool) + """ + def __init__( + self, + solution_next, + IncomeDstn, + LivPrb, + DiscFac, + CRRA, + Rfree, + PermGroFac, + BoroCnstArt, + aXtraGrid, + vFuncBool, + CubicBool, + approxRiskyDstn, + RiskyCount, + RiskyShareCount, + RiskyShareLimitFunc, + AdjustPrb, + PortfolioGrid, + AdjustCount, + PortfolioDomain, + ): + + ConsIndShockSolver.__init__( + self, + solution_next, + IncomeDstn, + LivPrb, + DiscFac, + CRRA, + Rfree, + PermGroFac, + BoroCnstArt, + aXtraGrid, + vFuncBool, + CubicBool, + ) self.PortfolioDomain = PortfolioDomain if isinstance(self.PortfolioDomain, DiscreteDomain): @@ -671,9 +793,8 @@ def __init__(self, solution_next, IncomeDstn, LivPrb, DiscFac, CRRA, Rfree, self.updateShockDstn() self.makeRshareGrid() - def makeEndOfPrdvFunc(self, AdjustIndex, ShareIndex): - ''' + """ Construct the end-of-period value function for this period, storing it as an attribute of self for use by other methods. @@ -684,26 +805,33 @@ def makeEndOfPrdvFunc(self, AdjustIndex, ShareIndex): Returns ------- none - ''' + """ if not self.DiscreteCase: - raise Exception("vFuncBool == True is not supported for continuous portfolio choice.") + raise Exception( + "vFuncBool == True is not supported for continuous portfolio choice." + ) # We will need to index vFuncNext wrt the state next period given choices # today. - VLvlNext = (self.PermShkVals_temp**(1.0-self.CRRA)*\ - self.PermGroFac**(1.0-self.CRRA))*self.vFuncsNext[AdjustIndex][ShareIndex](self.mNrmNext[AdjustIndex][ShareIndex]) - EndOfPrdv = self.DiscFacEff*np.sum(VLvlNext*self.ShkPrbs_temp,axis=0) - EndOfPrdvNvrs = self.uinv(EndOfPrdv) # value transformed through inverse utility + VLvlNext = ( + self.PermShkVals_temp ** (1.0 - self.CRRA) + * self.PermGroFac ** (1.0 - self.CRRA) + ) * self.vFuncsNext[AdjustIndex][ShareIndex]( + self.mNrmNext[AdjustIndex][ShareIndex] + ) + EndOfPrdv = self.DiscFacEff * np.sum(VLvlNext * self.ShkPrbs_temp, axis=0) + EndOfPrdvNvrs = self.uinv( + EndOfPrdv + ) # value transformed through inverse utility # Manually input (0,0) pair - EndOfPrdvNvrs = np.insert(EndOfPrdvNvrs,0,0.0) - aNrm_temp = np.insert(self.aNrmNow,0,0.0) + EndOfPrdvNvrs = np.insert(EndOfPrdvNvrs, 0, 0.0) + aNrm_temp = np.insert(self.aNrmNow, 0, 0.0) - EndOfPrdvNvrsFunc = LinearInterp(aNrm_temp,EndOfPrdvNvrs) - self.EndOfPrdvFunc = ValueFunc(EndOfPrdvNvrsFunc,self.CRRA) + EndOfPrdvNvrsFunc = LinearInterp(aNrm_temp, EndOfPrdvNvrs) + self.EndOfPrdvFunc = ValueFunc(EndOfPrdvNvrsFunc, self.CRRA) - - def makevFunc(self,solution, AdjustIndex, ShareIndex): - ''' + def makevFunc(self, solution, AdjustIndex, ShareIndex): + """ Creates the value function for this period, defined over market resources m. self must have the attribute EndOfPrdvFunc in order to execute. @@ -718,24 +846,26 @@ def makevFunc(self,solution, AdjustIndex, ShareIndex): vFuncNow : ValueFunc A representation of the value function for this period, defined over normalized market resources m: v = vFuncNow(m). - ''' + """ # Compute expected value and marginal value on a grid of market resources - mNrm_temp = self.mNrmMinNow + self.aXtraGrid - cNrmNow = solution.cFunc[AdjustIndex][ShareIndex](mNrm_temp) - aNrmNow = mNrm_temp - cNrmNow - vNrmNow = self.u(cNrmNow) + self.EndOfPrdvFunc(aNrmNow) + mNrm_temp = self.mNrmMinNow + self.aXtraGrid + cNrmNow = solution.cFunc[AdjustIndex][ShareIndex](mNrm_temp) + aNrmNow = mNrm_temp - cNrmNow + vNrmNow = self.u(cNrmNow) + self.EndOfPrdvFunc(aNrmNow) # Construct the beginning-of-period value function - vNvrs = self.uinv(vNrmNow) # value transformed through inverse utility + vNvrs = self.uinv(vNrmNow) # value transformed through inverse utility # Manually insert (0,0) pair. - mNrm_temp = np.insert(mNrm_temp,0,0.0) # np.insert(mNrm_temp,0,self.mNrmMinNow) - vNvrs = np.insert(vNvrs,0,0.0) - vNvrsFuncNow = LinearInterp(mNrm_temp,vNvrs) - vFuncNow = ValueFunc(vNvrsFuncNow,self.CRRA) + mNrm_temp = np.insert( + mNrm_temp, 0, 0.0 + ) # np.insert(mNrm_temp,0,self.mNrmMinNow) + vNvrs = np.insert(vNvrs, 0, 0.0) + vNvrsFuncNow = LinearInterp(mNrm_temp, vNvrs) + vFuncNow = ValueFunc(vNvrsFuncNow, self.CRRA) return vFuncNow - def addvFunc(self,solution): - ''' + def addvFunc(self, solution): + """ Creates the value function for this period and adds it to the solution. Parameters @@ -749,21 +879,27 @@ def addvFunc(self,solution): solution : ConsumerSolution The single period solution passed as an input, but now with the value function (defined over market resources m) as an attribute. - ''' + """ if not self.DiscreteCase: - raise Exception('You\'re not supposed to be here. Continuous choice portfolio domain does not support vFuncBool == True or AdjustPrb < 1.0.') + raise Exception( + "You're not supposed to be here. Continuous choice portfolio domain does not support vFuncBool == True or AdjustPrb < 1.0." + ) - vFunc = self.AdjustCount*[[]] + vFunc = self.AdjustCount * [[]] - for AdjustIndex in range(self.AdjustCount): # nonadjuster possible! + for AdjustIndex in range(self.AdjustCount): # nonadjuster possible! # this is where we add to vFunc based on non-adjustment. # Basically repeat the above with the share updated to be the "prev" # share an. We need to keep mNrmNext at two major indeces: adjust and # non-adjust. Adjust will just have one element, but non-adjust will need # one for each of the possible current ("prev") values. - for ShareIndex in range(self.ShareNowCount[AdjustIndex]): # for all share level indeces in the adjuster (1) case + for ShareIndex in range( + self.ShareNowCount[AdjustIndex] + ): # for all share level indeces in the adjuster (1) case self.makeEndOfPrdvFunc(AdjustIndex, ShareIndex) - vFunc[AdjustIndex].append(self.makevFunc(solution, AdjustIndex, ShareIndex)) + vFunc[AdjustIndex].append( + self.makevFunc(solution, AdjustIndex, ShareIndex) + ) solution.vFunc = vFunc return solution @@ -809,9 +945,16 @@ def prepareToCalcRiskyShareContinuous(self): i_s = 0 for s in RshareGrid: Rtilde = self.RiskyShkValsNext - self.Rfree - Reff = self.Rfree + Rtilde*s - mNext = a*Reff/(self.PermGroFac*self.PermShkValsNext) + self.TranShkValsNext - vHatP_a_s = Rtilde*self.PermShkValsNext**(-self.CRRA)*self.vPfuncNext(mNext) + Reff = self.Rfree + Rtilde * s + mNext = ( + a * Reff / (self.PermGroFac * self.PermShkValsNext) + + self.TranShkValsNext + ) + vHatP_a_s = ( + Rtilde + * self.PermShkValsNext ** (-self.CRRA) + * self.vPfuncNext(mNext) + ) vHatP[i_a, i_s] = np.dot(vHatP_a_s, self.ShkPrbsNext) i_s += 1 i_a += 1 @@ -838,13 +981,17 @@ def prepareToCalcRiskyShareDiscrete(self): i_s = 0 for s in RshareGrid: Rtilde = self.RiskyShkValsNext - self.Rfree - Reff = self.Rfree + Rtilde*s - mNrmNext = a*Reff/(self.PermGroFac*self.PermShkValsNext) + self.TranShkValsNext - - - VLvlNext = (self.PermShkValsNext**(1.0-self.CRRA)*\ - self.PermGroFac**(1.0-self.CRRA))*self.vFuncNext(mNrmNext) - vHat_a_s = self.DiscFacEff*np.sum(VLvlNext*self.ShkPrbsNext,axis=0) + Reff = self.Rfree + Rtilde * s + mNrmNext = ( + a * Reff / (self.PermGroFac * self.PermShkValsNext) + + self.TranShkValsNext + ) + + VLvlNext = ( + self.PermShkValsNext ** (1.0 - self.CRRA) + * self.PermGroFac ** (1.0 - self.CRRA) + ) * self.vFuncNext(mNrmNext) + vHat_a_s = self.DiscFacEff * np.sum(VLvlNext * self.ShkPrbsNext, axis=0) vHat[i_a, i_s] = vHat_a_s i_s += 1 @@ -860,11 +1007,10 @@ def calcRiskyShare(self): return RiskyShareFunc - def calcRiskyShareContinuous(self): # This should be fixed by an insert 0 - aGrid = np.array([0.0,]) - Rshare = np.array([1.0,]) + aGrid = np.array([0.0]) + Rshare = np.array([1.0]) i_a = 0 for a in self.aNrmPort: @@ -875,10 +1021,12 @@ def calcRiskyShareContinuous(self): Rshare = np.append(Rshare, 0.0) else: residual = LinearInterp(self.RshareGrid, self.vHatP[i_a, :]) - zero = sciopt.fsolve(residual, Rshare[-1]) + zero = sciopt.fsolve(residual, Rshare[-1]) Rshare = np.append(Rshare, zero) i_a += 1 - RiskyShareFunc = LinearInterp(aGrid, Rshare,intercept_limit=self.RiskyShareLimit, slope_limit=0) # HAVE to specify the slope limit + RiskyShareFunc = LinearInterp( + aGrid, Rshare, intercept_limit=self.RiskyShareLimit, slope_limit=0 + ) # HAVE to specify the slope limit return RiskyShareFunc def calcRiskyShareDiscrete(self): @@ -886,8 +1034,8 @@ def calcRiskyShareDiscrete(self): # choice today for a range of a values (those given in aNrmPort). # Should just use insert below ( at 0) - aGrid = np.array([0.0,]) - Rshare = np.array([1.0,]) # is it true for AdjustPrb < 1? + aGrid = np.array([0.0]) + Rshare = np.array([1.0]) # is it true for AdjustPrb < 1? i_a = 0 # For all positive aNrms @@ -899,11 +1047,17 @@ def calcRiskyShareDiscrete(self): i_a += 1 # TODO FIXME find limiting share for perf foresight - RiskyShareFunc = scipy.interpolate.interp1d(np.insert(self.aNrmPort, 0, 0.0), Rshare, kind='zero',bounds_error=False, fill_value=Rshare[-1]) + RiskyShareFunc = scipy.interpolate.interp1d( + np.insert(self.aNrmPort, 0, 0.0), + Rshare, + kind="zero", + bounds_error=False, + fill_value=Rshare[-1], + ) return RiskyShareFunc def prepareToCalcEndOfPrdvP(self): - ''' + """ Prepare to calculate end-of-period marginal value by creating an array of market resources that the agent could have next period, considering the grid of end-of-period assets and the distribution of shocks he might @@ -919,23 +1073,23 @@ def prepareToCalcEndOfPrdvP(self): ------- aNrmNow : np.array A 1D array of end-of-period assets; also stored as attribute of self. - ''' + """ # We define aNrmNow all the way from BoroCnstNat up to max(self.aXtraGrid) # even if BoroCnstNat < BoroCnstArt, so we can construct the consumption # function as the lower envelope of the (by the artificial borrowing con- # straint) uconstrained consumption function, and the artificially con- # strained consumption function. - aNrmNow = np.asarray(self.aXtraGrid) - ShkCount = self.TranShkValsNext.size - aNrm_temp = np.tile(aNrmNow,(ShkCount,1)) + aNrmNow = np.asarray(self.aXtraGrid) + ShkCount = self.TranShkValsNext.size + aNrm_temp = np.tile(aNrmNow, (ShkCount, 1)) # Tile arrays of the income shocks and put them into useful shapes - aNrmCount = aNrmNow.shape[0] - PermShkVals_temp = (np.tile(self.PermShkValsNext,(aNrmCount,1))).transpose() - TranShkVals_temp = (np.tile(self.TranShkValsNext,(aNrmCount,1))).transpose() - RiskyShkVals_temp = (np.tile(self.RiskyShkValsNext,(aNrmCount,1))).transpose() - ShkPrbs_temp = (np.tile(self.ShkPrbsNext,(aNrmCount,1))).transpose() + aNrmCount = aNrmNow.shape[0] + PermShkVals_temp = (np.tile(self.PermShkValsNext, (aNrmCount, 1))).transpose() + TranShkVals_temp = (np.tile(self.TranShkValsNext, (aNrmCount, 1))).transpose() + RiskyShkVals_temp = (np.tile(self.RiskyShkValsNext, (aNrmCount, 1))).transpose() + ShkPrbs_temp = (np.tile(self.ShkPrbsNext, (aNrmCount, 1))).transpose() if self.AdjustCount == 1: mNrmNext = [[]] @@ -944,34 +1098,36 @@ def prepareToCalcEndOfPrdvP(self): for AdjustIndex in range(self.AdjustCount): for ShareIndex in range(self.ShareNowCount[AdjustIndex]): - # Calculate share at current aNrm. If non-adjusting, it's just - # self.RiskySharePrev, else we use the recently calculated RiskyShareFunc - # First generate mNrmNext for adjusters - if AdjustIndex == 0: # adjust + # Calculate share at current aNrm. If non-adjusting, it's just + # self.RiskySharePrev, else we use the recently calculated RiskyShareFunc + # First generate mNrmNext for adjusters + if AdjustIndex == 0: # adjust sAt_aNrm = self.RiskyShareFunc(aNrmNow) # Then generate for non-adjusters - else: # non-adjuster + else: # non-adjuster sAt_aNrm = self.ShareNow[ShareIndex] # Get cash on hand next period. # Compose possible return factors self.Rtilde = RiskyShkVals_temp - self.Rfree # Combine into effective returns factors, taking into account the share - self.Reff = (self.Rfree + self.Rtilde*sAt_aNrm) + self.Reff = self.Rfree + self.Rtilde * sAt_aNrm # Apply the permanent growth factor and possible permanent shocks - mNrmPreTran = self.Reff/(self.PermGroFac*PermShkVals_temp)*aNrm_temp + mNrmPreTran = ( + self.Reff / (self.PermGroFac * PermShkVals_temp) * aNrm_temp + ) # Add transitory income mNrmNext[AdjustIndex].append(mNrmPreTran + TranShkVals_temp) # Store and report the results - self.PermShkVals_temp = PermShkVals_temp - self.ShkPrbs_temp = ShkPrbs_temp - self.mNrmNext = mNrmNext - self.aNrmNow = aNrmNow + self.PermShkVals_temp = PermShkVals_temp + self.ShkPrbs_temp = ShkPrbs_temp + self.mNrmNext = mNrmNext + self.aNrmNow = aNrmNow return aNrmNow def calcEndOfPrdvP(self): - ''' + """ Calculate end-of-period marginal value of assets at each point in aNrmNow. Does so by taking a weighted sum of next period marginal values across income shocks (in a preconstructed grid self.mNrmNext). @@ -984,22 +1140,28 @@ def calcEndOfPrdvP(self): ------- EndOfPrdvP : np.array A 1D array of end-of-period marginal value of assets - ''' + """ - EndOfPrdvP = self.AdjustCount*[[]] + EndOfPrdvP = self.AdjustCount * [[]] for AdjustIndex in range(self.AdjustCount): for ShareIndex in range(self.ShareNowCount[AdjustIndex]): mNrmNext = self.mNrmNext[AdjustIndex][ShareIndex] - EndOfPrdvP[AdjustIndex].append(np.sum(self.DiscFacEff*self.Reff*self.PermGroFac**(-self.CRRA)* - self.PermShkVals_temp**(-self.CRRA)* - self.vPfuncNext(mNrmNext)*self.ShkPrbs_temp,axis=0)) + EndOfPrdvP[AdjustIndex].append( + np.sum( + self.DiscFacEff + * self.Reff + * self.PermGroFac ** (-self.CRRA) + * self.PermShkVals_temp ** (-self.CRRA) + * self.vPfuncNext(mNrmNext) + * self.ShkPrbs_temp, + axis=0, + ) + ) return EndOfPrdvP - - - def setAndUpdateValues(self,solution_next,IncomeDstn,LivPrb,DiscFac): - ''' + def setAndUpdateValues(self, solution_next, IncomeDstn, LivPrb, DiscFac): + """ Unpacks some of the inputs (and calculates simple objects based on them), storing the results in self for use by other methods. These include: income shocks and probabilities, next period's marginal value function @@ -1024,30 +1186,41 @@ def setAndUpdateValues(self,solution_next,IncomeDstn,LivPrb,DiscFac): Returns ------- None - ''' + """ # TODO: this does not yet # calc sUnderbar -> mertonsammuelson # calc MPC kappaUnderbar # calc human wealth - self.DiscFacEff = DiscFac*LivPrb # "effective" discount factor - self.ShkPrbsNext = self.ShockDstn[0] # but ConsumtionSolver doesn't store the risky shocks - self.PermShkValsNext = self.ShockDstn[1] # but ConsumtionSolver doesn't store the risky shocks - self.TranShkValsNext = self.ShockDstn[2] # but ConsumtionSolver doesn't store the risky shocks - self.RiskyShkValsNext = self.ShockDstn[3] # but ConsumtionSolver doesn't store the risky shocks - self.PermShkMinNext = np.min(self.PermShkValsNext) - self.TranShkMinNext = np.min(self.TranShkValsNext) - self.vPfuncNext = solution_next.vPfunc - self.WorstIncPrb = np.sum(self.ShkPrbsNext[ - (self.PermShkValsNext*self.TranShkValsNext)== - (self.PermShkMinNext*self.TranShkMinNext)]) + self.DiscFacEff = DiscFac * LivPrb # "effective" discount factor + self.ShkPrbsNext = self.ShockDstn[ + 0 + ] # but ConsumtionSolver doesn't store the risky shocks + self.PermShkValsNext = self.ShockDstn[ + 1 + ] # but ConsumtionSolver doesn't store the risky shocks + self.TranShkValsNext = self.ShockDstn[ + 2 + ] # but ConsumtionSolver doesn't store the risky shocks + self.RiskyShkValsNext = self.ShockDstn[ + 3 + ] # but ConsumtionSolver doesn't store the risky shocks + self.PermShkMinNext = np.min(self.PermShkValsNext) + self.TranShkMinNext = np.min(self.TranShkValsNext) + self.vPfuncNext = solution_next.vPfunc + self.WorstIncPrb = np.sum( + self.ShkPrbsNext[ + (self.PermShkValsNext * self.TranShkValsNext) + == (self.PermShkMinNext * self.TranShkMinNext) + ] + ) if self.CubicBool: - self.vPPfuncNext = solution_next.vPPfunc + self.vPPfuncNext = solution_next.vPPfunc if self.vFuncBool: - self.vFuncNext = solution_next.wFunc + self.vFuncNext = solution_next.wFunc # Update the bounding MPCs and PDV of human wealth: # self.PatFac = ((self.Rfree*self.DiscFacEff)**(1.0/self.CRRA))/self.Rfree @@ -1057,11 +1230,8 @@ def setAndUpdateValues(self,solution_next,IncomeDstn,LivPrb,DiscFac): # self.MPCmaxNow = 1.0/(1.0 + (self.WorstIncPrb**(1.0/self.CRRA))* # self.PatFac/solution_next.MPCmax) - - - - def defBoroCnst(self,BoroCnstArt): - ''' + def defBoroCnst(self, BoroCnstArt): + """ Defines the constrained portion of the consumption function as cFuncNowCnst, an attribute of self. Uses the artificial and natural borrowing constraints. @@ -1076,15 +1246,15 @@ def defBoroCnst(self,BoroCnstArt): Returns ------- none - ''' + """ # Calculate the minimum allowable value of money resources in this period - self.BoroCnstNat = 0.0 #(self.solution_next.mNrmMin - self.TranShkMinNext)*\ - #(self.PermGroFac*self.PermShkMinNext)/self.Rfree + self.BoroCnstNat = 0.0 # (self.solution_next.mNrmMin - self.TranShkMinNext)*\ + # (self.PermGroFac*self.PermShkMinNext)/self.Rfree if BoroCnstArt is None: self.mNrmMinNow = self.BoroCnstNat else: - self.mNrmMinNow = np.max([self.BoroCnstNat,BoroCnstArt]) + self.mNrmMinNow = np.max([self.BoroCnstNat, BoroCnstArt]) # Can we just put in *some value* for MPCmaxNow here? # if self.BoroCnstNat < self.mNrmMinNow: @@ -1093,12 +1263,10 @@ def defBoroCnst(self,BoroCnstArt): # self.MPCmaxEff = self.MPCmaxNow # Define the borrowing constraint (limiting consumption function) - self.cFuncNowCnst = LinearInterp(np.array([0.0, 1.0]), - np.array([0.0, 1.0])) - + self.cFuncNowCnst = LinearInterp(np.array([0.0, 1.0]), np.array([0.0, 1.0])) def solve(self): - ''' + """ Solves a one period consumption saving problem with risky income and a portfolio choice over a riskless and a risky asset. @@ -1110,7 +1278,7 @@ def solve(self): ------- solution : ConsumerSolution The solution to the one period problem. - ''' + """ # TODO FIXME # This code is a mix of looping over states ( for the Risky Share funcs) @@ -1126,7 +1294,6 @@ def solve(self): vPfuncs = [[], []] RiskyShareFuncs = [[], []] - for AdjustIndex in range(self.AdjustCount): for PortfolioGridIdx in range(self.ShareNowCount[AdjustIndex]): if self.DiscreteCase: @@ -1142,11 +1309,16 @@ def solve(self): self.RiskyShareFunc = self.calcRiskyShare() else: val = self.PortfolioGrid[PortfolioGridIdx] - self.RiskyShareFunc = scipy.interpolate.interp1d(np.array([0.0,1.0]), np.repeat(val, 2), kind='zero',bounds_error=False, fill_value=val) + self.RiskyShareFunc = scipy.interpolate.interp1d( + np.array([0.0, 1.0]), + np.repeat(val, 2), + kind="zero", + bounds_error=False, + fill_value=val, + ) RiskyShareFuncs[AdjustIndex].append(self.RiskyShareFunc) - # Then solve the consumption choice given optimal portfolio choice aNrm = self.prepareToCalcEndOfPrdvP() @@ -1159,43 +1331,84 @@ def solve(self): self.cFuncLimitSlope = None # Generate all the solutions - for AdjustIndex in range(self.AdjustCount): # stupid name, should be related to adjusting + for AdjustIndex in range( + self.AdjustCount + ): # stupid name, should be related to adjusting for PortfolioGridIdx in range(self.ShareNowCount[AdjustIndex]): - cs_solution = self.makeBasicSolution(EndOfPrdvP[AdjustIndex][PortfolioGridIdx],aNrm,self.makeLinearcFunc) + cs_solution = self.makeBasicSolution( + EndOfPrdvP[AdjustIndex][PortfolioGridIdx], + aNrm, + self.makeLinearcFunc, + ) cFuncs[AdjustIndex].append(cs_solution.cFunc) vPfuncs[AdjustIndex].append(cs_solution.vPfunc) # This is a good place to make it defined at m!!! # solution = self.addMPCandHumanWealth(solution) - solution = PortfolioSolution(cFunc=cFuncs, - vPfunc=vPfuncs, - RiskyShareFunc=RiskyShareFuncs) + solution = PortfolioSolution( + cFunc=cFuncs, vPfunc=vPfuncs, RiskyShareFunc=RiskyShareFuncs + ) if self.vFuncBool: solution = self.addvFunc(solution) - solution.wFunc = _calcwFunc(self.AdjustPrb, self.AdjustCount, self.ShareNowCount, solution.vFunc, self.CRRA) - + solution.wFunc = _calcwFunc( + self.AdjustPrb, + self.AdjustCount, + self.ShareNowCount, + solution.vFunc, + self.CRRA, + ) return solution # The solveOnePeriod function! -def solveConsPortfolio(solution_next, IncomeDstn, LivPrb, DiscFac, - CRRA, Rfree, PermGroFac, BoroCnstArt, - aXtraGrid, vFuncBool, CubicBool, approxRiskyDstn, - RiskyCount, RiskyShareCount, RiskyShareLimitFunc, - AdjustPrb, PortfolioGrid, AdjustCount, PortfolioDomain): +def solveConsPortfolio( + solution_next, + IncomeDstn, + LivPrb, + DiscFac, + CRRA, + Rfree, + PermGroFac, + BoroCnstArt, + aXtraGrid, + vFuncBool, + CubicBool, + approxRiskyDstn, + RiskyCount, + RiskyShareCount, + RiskyShareLimitFunc, + AdjustPrb, + PortfolioGrid, + AdjustCount, + PortfolioDomain, +): # construct solver instance - solver = ConsIndShockPortfolioSolver(solution_next, IncomeDstn, LivPrb, - DiscFac, CRRA, Rfree, PermGroFac, - BoroCnstArt, aXtraGrid, vFuncBool, - CubicBool, approxRiskyDstn, RiskyCount, - RiskyShareCount, RiskyShareLimitFunc, - AdjustPrb, PortfolioGrid, AdjustCount, - PortfolioDomain) + solver = ConsIndShockPortfolioSolver( + solution_next, + IncomeDstn, + LivPrb, + DiscFac, + CRRA, + Rfree, + PermGroFac, + BoroCnstArt, + aXtraGrid, + vFuncBool, + CubicBool, + approxRiskyDstn, + RiskyCount, + RiskyShareCount, + RiskyShareLimitFunc, + AdjustPrb, + PortfolioGrid, + AdjustCount, + PortfolioDomain, + ) # Do some preparatory work solver.prepareToSolve() @@ -1205,27 +1418,39 @@ def solveConsPortfolio(solution_next, IncomeDstn, LivPrb, DiscFac, return portsolution + class LogNormalPortfolioConsumerType(PortfolioConsumerType): - ''' + """ A consumer type with a portfolio choice. This agent type has log-normal return factors. Their problem is defined by a coefficient of relative risk aversion, intertemporal discount factor, interest factor, and time sequences of the permanent income growth rate, survival probability, and return factor averages and standard deviations. - ''' -# time_inv_ = PortfolioConsumerType.time_inv_ + ['approxRiskyDstn', 'RiskyCount', 'RiskyShareCount', 'RiskyShareLimitFunc', 'AdjustPrb', 'PortfolioGrid'] + """ + + # time_inv_ = PortfolioConsumerType.time_inv_ + ['approxRiskyDstn', 'RiskyCount', 'RiskyShareCount', 'RiskyShareLimitFunc', 'AdjustPrb', 'PortfolioGrid'] - def __init__(self,cycles=1,time_flow=True,verbose=False,quiet=False,**kwds): + def __init__(self, cycles=1, time_flow=True, verbose=False, quiet=False, **kwds): - PortfolioConsumerType.__init__(self,cycles=cycles, time_flow=time_flow, - verbose=verbose, quiet=quiet, **kwds) + PortfolioConsumerType.__init__( + self, + cycles=cycles, + time_flow=time_flow, + verbose=verbose, + quiet=quiet, + **kwds + ) - self.approxRiskyDstn = RiskyDstnFactory(RiskyAvg=self.RiskyAvg, - RiskyStd=self.RiskyStd) + self.approxRiskyDstn = RiskyDstnFactory( + RiskyAvg=self.RiskyAvg, RiskyStd=self.RiskyStd + ) # Needed to simulate. Is a function that given 0 inputs it returns a draw # from the risky asset distribution. Only one is needed, because everyone # draws the same shock. - self.drawRiskyFunc = LogNormalRiskyDstnDraw(RiskyAvg=self.RiskyAvg, - RiskyStd=self.RiskyStd) + self.drawRiskyFunc = LogNormalRiskyDstnDraw( + RiskyAvg=self.RiskyAvg, RiskyStd=self.RiskyStd + ) - self.RiskyShareLimitFunc = lambda _: _PerfForesightLogNormalPortfolioShare(self.Rfree, self.RiskyAvg, self.RiskyStd, self.CRRA) + self.RiskyShareLimitFunc = lambda _: _PerfForesightLogNormalPortfolioShare( + self.Rfree, self.RiskyAvg, self.RiskyStd, self.CRRA + ) From 77aaaf3ad96964e9ed26483ad5adc48f6c22e673 Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Thu, 16 Jan 2020 15:06:10 +0530 Subject: [PATCH 07/43] breakup ConsGenIncProcessModel --- .../ConsGenIncProcessModel.py | 152 +-------------- .../example_ConsGenIncProcessModel.py | 182 ++++++++++++++++++ 2 files changed, 186 insertions(+), 148 deletions(-) create mode 100644 HARK/ConsumptionSaving/example_ConsGenIncProcessModel.py diff --git a/HARK/ConsumptionSaving/ConsGenIncProcessModel.py b/HARK/ConsumptionSaving/ConsGenIncProcessModel.py index 36234e1a8..66b9d6230 100644 --- a/HARK/ConsumptionSaving/ConsGenIncProcessModel.py +++ b/HARK/ConsumptionSaving/ConsGenIncProcessModel.py @@ -15,6 +15,10 @@ from HARK.simulation import drawLognormal, drawDiscrete, drawUniform from HARK.ConsumptionSaving.ConsIndShockModel import ConsIndShockSetup, ConsumerSolution, IndShockConsumerType +__all__ = ['ValueFunc2D', 'MargValueFunc2D', 'MargMargValueFunc2D', 'pLvlFuncAR1', +'ConsGenIncProcessSolver', 'GenIncProcessConsumerType', +'IndShockExplicitPermIncConsumerType', 'PersistentShockConsumerType'] + utility = CRRAutility utilityP = CRRAutilityP utilityPP = CRRAutilityPP @@ -1301,151 +1305,3 @@ def updatepLvlNextFunc(self): self.addToTimeVary('pLvlNextFunc') if not orig_time: self.timeRev() - - -############################################################################### - -def main(): - import HARK.ConsumptionSaving.ConsumerParameters as Params - from HARK.utilities import plotFuncs - from time import clock - import matplotlib.pyplot as plt - def mystr(number): return "{:.4f}".format(number) - - do_simulation = False - - # Display information about the pLvlGrid used in these examples - print('The infinite horizon examples presented here use a grid of persistent income levels (pLvlGrid)') - print('based on percentiles of the long run distribution of pLvl for the given parameters. These percentiles') - print('are specified in the attribute pLvlPctiles. Here, the lowest percentile is ' + - str(Params.init_explicit_perm_inc['pLvlPctiles'][0]*100) + ' and the highest') - print('percentile is ' + str(Params.init_explicit_perm_inc['pLvlPctiles'][-1]*100) + '.\n') - - # Make and solve an example "explicit permanent income" consumer with idiosyncratic shocks - ExplicitExample = IndShockExplicitPermIncConsumerType(**Params.init_explicit_perm_inc) - t_start = clock() - ExplicitExample.solve() - t_end = clock() - print('Solving an explicit permanent income consumer took ' + mystr(t_end-t_start) + ' seconds.') - - # Plot the consumption function at various permanent income levels - print('Consumption function by pLvl for explicit permanent income consumer:') - pLvlGrid = ExplicitExample.pLvlGrid[0] - mLvlGrid = np.linspace(0, 20, 300) - for p in pLvlGrid: - M_temp = mLvlGrid + ExplicitExample.solution[0].mLvlMin(p) - C = ExplicitExample.solution[0].cFunc(M_temp, p*np.ones_like(M_temp)) - plt.plot(M_temp, C) - plt.xlim(0., 20.) - plt.ylim(0., None) - plt.xlabel('Market resource level mLvl') - plt.ylabel('Consumption level cLvl') - plt.show() - - # Now solve the *exact same* problem, but with the permanent income normalization - NormalizedExample = IndShockConsumerType(**Params.init_explicit_perm_inc) - t_start = clock() - NormalizedExample.solve() - t_end = clock() - print('Solving the equivalent problem with permanent income normalized out took ' + - mystr(t_end-t_start) + ' seconds.') - - # Show that the normalized consumption function for the "explicit permanent income" consumer - # is almost identical for every permanent income level (and the same as the normalized problem's - # cFunc), but is less accurate due to extrapolation outside the bounds of pLvlGrid. - print('Normalized consumption function by pLvl for explicit permanent income consumer:') - pLvlGrid = ExplicitExample.pLvlGrid[0] - mNrmGrid = np.linspace(0, 20, 300) - for p in pLvlGrid: - M_temp = mNrmGrid*p + ExplicitExample.solution[0].mLvlMin(p) - C = ExplicitExample.solution[0].cFunc(M_temp, p*np.ones_like(M_temp)) - plt.plot(M_temp/p, C/p) - plt.xlim(0., 20.) - plt.ylim(0., None) - plt.xlabel('Normalized market resources mNrm') - plt.ylabel('Normalized consumption cNrm') - plt.show() - print('Consumption function for normalized problem (without explicit permanent income):') - mNrmMin = NormalizedExample.solution[0].mNrmMin - plotFuncs(NormalizedExample.solution[0].cFunc, mNrmMin, mNrmMin+20) - - print('The "explicit permanent income" solution deviates from the solution to the normalized problem because') - print('of errors from extrapolating beyond the bounds of the pLvlGrid. The error is largest for pLvl values') - print('near the upper and lower bounds, and propagates toward the center of the distribution.\n') - - # Plot the value function at various permanent income levels - if ExplicitExample.vFuncBool: - pGrid = np.linspace(0.1, 3.0, 24) - M = np.linspace(0.001, 5, 300) - for p in pGrid: - M_temp = M+ExplicitExample.solution[0].mLvlMin(p) - C = ExplicitExample.solution[0].vFunc(M_temp, p*np.ones_like(M_temp)) - plt.plot(M_temp, C) - plt.ylim([-200, 0]) - plt.xlabel('Market resource level mLvl') - plt.ylabel('Value v') - plt.show() - - # Simulate some data - if do_simulation: - ExplicitExample.T_sim = 500 - ExplicitExample.track_vars = ['mLvlNow', 'cLvlNow', 'pLvlNow'] - ExplicitExample.makeShockHistory() # This is optional - ExplicitExample.initializeSim() - ExplicitExample.simulate() - plt.plot(np.mean(ExplicitExample.mLvlNow_hist, axis=1)) - plt.xlabel('Simulated time period') - plt.ylabel('Average market resources mLvl') - plt.show() - -############################################################################### - - # Make and solve an example "persistent idisyncratic shocks" consumer - PersistentExample = PersistentShockConsumerType(**Params.init_persistent_shocks) - t_start = clock() - PersistentExample.solve() - t_end = clock() - print('Solving a persistent income shocks consumer took ' + mystr(t_end-t_start) + ' seconds.') - - # Plot the consumption function at various levels of persistent income pLvl - print('Consumption function by persistent income level pLvl for a consumer with AR1 coefficient of ' - + str(PersistentExample.PrstIncCorr) + ':') - pLvlGrid = PersistentExample.pLvlGrid[0] - mLvlGrid = np.linspace(0, 20, 300) - for p in pLvlGrid: - M_temp = mLvlGrid + PersistentExample.solution[0].mLvlMin(p) - C = PersistentExample.solution[0].cFunc(M_temp, p*np.ones_like(M_temp)) - plt.plot(M_temp, C) - plt.xlim(0., 20.) - plt.ylim(0., None) - plt.xlabel('Market resource level mLvl') - plt.ylabel('Consumption level cLvl') - plt.show() - - # Plot the value function at various persistent income levels - if PersistentExample.vFuncBool: - pGrid = PersistentExample.pLvlGrid[0] - M = np.linspace(0.001, 5, 300) - for p in pGrid: - M_temp = M+PersistentExample.solution[0].mLvlMin(p) - C = PersistentExample.solution[0].vFunc(M_temp, p*np.ones_like(M_temp)) - plt.plot(M_temp, C) - plt.ylim([-200, 0]) - plt.xlabel('Market resource level mLvl') - plt.ylabel('Value v') - plt.show() - - # Simulate some data - if do_simulation: - PersistentExample.T_sim = 500 - PersistentExample.track_vars = ['mLvlNow', 'cLvlNow', 'pLvlNow'] - PersistentExample.initializeSim() - PersistentExample.simulate() - plt.plot(np.mean(PersistentExample.mLvlNow_hist, axis=1)) - plt.xlabel('Simulated time period') - plt.ylabel('Average market resources mLvl') - plt.show() - - -if __name__ == '__main__': - main() diff --git a/HARK/ConsumptionSaving/example_ConsGenIncProcessModel.py b/HARK/ConsumptionSaving/example_ConsGenIncProcessModel.py new file mode 100644 index 000000000..a41c00abc --- /dev/null +++ b/HARK/ConsumptionSaving/example_ConsGenIncProcessModel.py @@ -0,0 +1,182 @@ +import HARK.ConsumptionSaving.ConsumerParameters as Params +from HARK.utilities import plotFuncs +from time import process_time +import matplotlib.pyplot as plt +import numpy as np +from HARK.ConsumptionSaving.ConsGenIncProcessModel import ( + IndShockExplicitPermIncConsumerType, + IndShockConsumerType, + PersistentShockConsumerType, +) + + +def mystr(number): + return "{:.4f}".format(number) + + +do_simulation = False + +# Display information about the pLvlGrid used in these examples +print( + "The infinite horizon examples presented here use a grid of persistent income levels (pLvlGrid)" +) +print( + "based on percentiles of the long run distribution of pLvl for the given parameters. These percentiles" +) +print( + "are specified in the attribute pLvlPctiles. Here, the lowest percentile is " + + str(Params.init_explicit_perm_inc["pLvlPctiles"][0] * 100) + + " and the highest" +) +print( + "percentile is " + + str(Params.init_explicit_perm_inc["pLvlPctiles"][-1] * 100) + + ".\n" +) + +# Make and solve an example "explicit permanent income" consumer with idiosyncratic shocks +ExplicitExample = IndShockExplicitPermIncConsumerType(**Params.init_explicit_perm_inc) +t_start = process_time() +ExplicitExample.solve() +t_end = process_time() +print( + "Solving an explicit permanent income consumer took " + + mystr(t_end - t_start) + + " seconds." +) + +# Plot the consumption function at various permanent income levels +print("Consumption function by pLvl for explicit permanent income consumer:") +pLvlGrid = ExplicitExample.pLvlGrid[0] +mLvlGrid = np.linspace(0, 20, 300) +for p in pLvlGrid: + M_temp = mLvlGrid + ExplicitExample.solution[0].mLvlMin(p) + C = ExplicitExample.solution[0].cFunc(M_temp, p * np.ones_like(M_temp)) + plt.plot(M_temp, C) +plt.xlim(0.0, 20.0) +plt.ylim(0.0, None) +plt.xlabel("Market resource level mLvl") +plt.ylabel("Consumption level cLvl") +plt.show() + +# Now solve the *exact same* problem, but with the permanent income normalization +NormalizedExample = IndShockConsumerType(**Params.init_explicit_perm_inc) +t_start = process_time() +NormalizedExample.solve() +t_end = process_time() +print( + "Solving the equivalent problem with permanent income normalized out took " + + mystr(t_end - t_start) + + " seconds." +) + +# Show that the normalized consumption function for the "explicit permanent income" consumer +# is almost identical for every permanent income level (and the same as the normalized problem's +# cFunc), but is less accurate due to extrapolation outside the bounds of pLvlGrid. +print("Normalized consumption function by pLvl for explicit permanent income consumer:") +pLvlGrid = ExplicitExample.pLvlGrid[0] +mNrmGrid = np.linspace(0, 20, 300) +for p in pLvlGrid: + M_temp = mNrmGrid * p + ExplicitExample.solution[0].mLvlMin(p) + C = ExplicitExample.solution[0].cFunc(M_temp, p * np.ones_like(M_temp)) + plt.plot(M_temp / p, C / p) +plt.xlim(0.0, 20.0) +plt.ylim(0.0, None) +plt.xlabel("Normalized market resources mNrm") +plt.ylabel("Normalized consumption cNrm") +plt.show() +print( + "Consumption function for normalized problem (without explicit permanent income):" +) +mNrmMin = NormalizedExample.solution[0].mNrmMin +plotFuncs(NormalizedExample.solution[0].cFunc, mNrmMin, mNrmMin + 20) + +print( + 'The "explicit permanent income" solution deviates from the solution to the normalized problem because' +) +print( + "of errors from extrapolating beyond the bounds of the pLvlGrid. The error is largest for pLvl values" +) +print( + "near the upper and lower bounds, and propagates toward the center of the distribution.\n" +) + +# Plot the value function at various permanent income levels +if ExplicitExample.vFuncBool: + pGrid = np.linspace(0.1, 3.0, 24) + M = np.linspace(0.001, 5, 300) + for p in pGrid: + M_temp = M + ExplicitExample.solution[0].mLvlMin(p) + C = ExplicitExample.solution[0].vFunc(M_temp, p * np.ones_like(M_temp)) + plt.plot(M_temp, C) + plt.ylim([-200, 0]) + plt.xlabel("Market resource level mLvl") + plt.ylabel("Value v") + plt.show() + +# Simulate some data +if do_simulation: + ExplicitExample.T_sim = 500 + ExplicitExample.track_vars = ["mLvlNow", "cLvlNow", "pLvlNow"] + ExplicitExample.makeShockHistory() # This is optional + ExplicitExample.initializeSim() + ExplicitExample.simulate() + plt.plot(np.mean(ExplicitExample.mLvlNow_hist, axis=1)) + plt.xlabel("Simulated time period") + plt.ylabel("Average market resources mLvl") + plt.show() + +############################################################################### + +# Make and solve an example "persistent idisyncratic shocks" consumer +PersistentExample = PersistentShockConsumerType(**Params.init_persistent_shocks) +t_start = process_time() +PersistentExample.solve() +t_end = process_time() +print( + "Solving a persistent income shocks consumer took " + + mystr(t_end - t_start) + + " seconds." +) + +# Plot the consumption function at various levels of persistent income pLvl +print( + "Consumption function by persistent income level pLvl for a consumer with AR1 coefficient of " + + str(PersistentExample.PrstIncCorr) + + ":" +) +pLvlGrid = PersistentExample.pLvlGrid[0] +mLvlGrid = np.linspace(0, 20, 300) +for p in pLvlGrid: + M_temp = mLvlGrid + PersistentExample.solution[0].mLvlMin(p) + C = PersistentExample.solution[0].cFunc(M_temp, p * np.ones_like(M_temp)) + plt.plot(M_temp, C) +plt.xlim(0.0, 20.0) +plt.ylim(0.0, None) +plt.xlabel("Market resource level mLvl") +plt.ylabel("Consumption level cLvl") +plt.show() + +# Plot the value function at various persistent income levels +if PersistentExample.vFuncBool: + pGrid = PersistentExample.pLvlGrid[0] + M = np.linspace(0.001, 5, 300) + for p in pGrid: + M_temp = M + PersistentExample.solution[0].mLvlMin(p) + C = PersistentExample.solution[0].vFunc(M_temp, p * np.ones_like(M_temp)) + plt.plot(M_temp, C) + plt.ylim([-200, 0]) + plt.xlabel("Market resource level mLvl") + plt.ylabel("Value v") + plt.show() + +# Simulate some data +if do_simulation: + PersistentExample.T_sim = 500 + PersistentExample.track_vars = ["mLvlNow", "cLvlNow", "pLvlNow"] + PersistentExample.initializeSim() + PersistentExample.simulate() + plt.plot(np.mean(PersistentExample.mLvlNow_hist, axis=1)) + plt.xlabel("Simulated time period") + plt.ylabel("Average market resources mLvl") + plt.show() From 46739f07bd9cf849007b0c19c32aa0a2c7a33089 Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Thu, 16 Jan 2020 15:10:27 +0530 Subject: [PATCH 08/43] breakup ConsPrefShockModel --- HARK/ConsumptionSaving/ConsPrefShockModel.py | 98 +---------------- .../example_ConsPrefShockModel.py | 102 ++++++++++++++++++ 2 files changed, 104 insertions(+), 96 deletions(-) create mode 100644 HARK/ConsumptionSaving/example_ConsPrefShockModel.py diff --git a/HARK/ConsumptionSaving/ConsPrefShockModel.py b/HARK/ConsumptionSaving/ConsPrefShockModel.py index a0b6f98a4..ba314f6bb 100644 --- a/HARK/ConsumptionSaving/ConsPrefShockModel.py +++ b/HARK/ConsumptionSaving/ConsPrefShockModel.py @@ -12,6 +12,8 @@ ValueFunc, MargValueFunc, KinkedRconsumerType, ConsKinkedRsolver from HARK.interpolation import LinearInterpOnInterp1D, LinearInterp, CubicInterp, LowerEnvelope +__all__ = ['PrefShockConsumerType', 'KinkyPrefConsumerType', 'ConsPrefShockSolver', 'ConsKinkyPrefSolver'] + class PrefShockConsumerType(IndShockConsumerType): ''' A class for representing consumers who experience multiplicative shocks to @@ -592,99 +594,3 @@ def solveConsKinkyPref(solution_next,IncomeDstn,PrefShkDstn, solver.prepareToSolve() solution = solver.solve() return solution - -############################################################################### - -def main(): - import HARK.ConsumptionSaving.ConsumerParameters as Params - import matplotlib.pyplot as plt - from HARK.utilities import plotFuncs - from time import clock - mystr = lambda number : "{:.4f}".format(number) - - do_simulation = True - - # Make and solve a preference shock consumer - PrefShockExample = PrefShockConsumerType(**Params.init_preference_shocks) - PrefShockExample.cycles = 0 # Infinite horizon - - t_start = clock() - PrefShockExample.solve() - t_end = clock() - print('Solving a preference shock consumer took ' + str(t_end-t_start) + ' seconds.') - - # Plot the consumption function at each discrete shock - m = np.linspace(PrefShockExample.solution[0].mNrmMin,5,200) - print('Consumption functions at each discrete shock:') - for j in range(PrefShockExample.PrefShkDstn[0][1].size): - PrefShk = PrefShockExample.PrefShkDstn[0][1][j] - c = PrefShockExample.solution[0].cFunc(m,PrefShk*np.ones_like(m)) - plt.plot(m,c) - plt.xlim([0.,None]) - plt.ylim([0.,None]) - plt.show() - - print('Consumption function (and MPC) when shock=1:') - c = PrefShockExample.solution[0].cFunc(m,np.ones_like(m)) - k = PrefShockExample.solution[0].cFunc.derivativeX(m,np.ones_like(m)) - plt.plot(m,c) - plt.plot(m,k) - plt.xlim([0.,None]) - plt.ylim([0.,None]) - plt.show() - - if PrefShockExample.vFuncBool: - print('Value function (unconditional on shock):') - plotFuncs(PrefShockExample.solution[0].vFunc,PrefShockExample.solution[0].mNrmMin+0.5,5) - - # Test the simulator for the pref shock class - if do_simulation: - PrefShockExample.T_sim = 120 - PrefShockExample.track_vars = ['cNrmNow'] - PrefShockExample.makeShockHistory() # This is optional - PrefShockExample.initializeSim() - PrefShockExample.simulate() - - ########################################################################### - - # Make and solve a "kinky preferece" consumer, whose model combines KinkedR and PrefShock - KinkyPrefExample = KinkyPrefConsumerType(**Params.init_kinky_pref) - KinkyPrefExample.cycles = 0 # Infinite horizon - - t_start = clock() - KinkyPrefExample.solve() - t_end = clock() - print('Solving a kinky preference consumer took ' + str(t_end-t_start) + ' seconds.') - - # Plot the consumption function at each discrete shock - m = np.linspace(KinkyPrefExample.solution[0].mNrmMin,5,200) - print('Consumption functions at each discrete shock:') - for j in range(KinkyPrefExample.PrefShkDstn[0][1].size): - PrefShk = KinkyPrefExample.PrefShkDstn[0][1][j] - c = KinkyPrefExample.solution[0].cFunc(m,PrefShk*np.ones_like(m)) - plt.plot(m,c) - plt.ylim([0.,None]) - plt.show() - - print('Consumption function (and MPC) when shock=1:') - c = KinkyPrefExample.solution[0].cFunc(m,np.ones_like(m)) - k = KinkyPrefExample.solution[0].cFunc.derivativeX(m,np.ones_like(m)) - plt.plot(m,c) - plt.plot(m,k) - plt.ylim([0.,None]) - plt.show() - - if KinkyPrefExample.vFuncBool: - print('Value function (unconditional on shock):') - plotFuncs(KinkyPrefExample.solution[0].vFunc,KinkyPrefExample.solution[0].mNrmMin+0.5,5) - - # Test the simulator for the kinky preference class - if do_simulation: - KinkyPrefExample.T_sim = 120 - KinkyPrefExample.track_vars = ['cNrmNow','PrefShkNow'] - KinkyPrefExample.initializeSim() - KinkyPrefExample.simulate() - - -if __name__ == '__main__': - main() diff --git a/HARK/ConsumptionSaving/example_ConsPrefShockModel.py b/HARK/ConsumptionSaving/example_ConsPrefShockModel.py new file mode 100644 index 000000000..07811dd25 --- /dev/null +++ b/HARK/ConsumptionSaving/example_ConsPrefShockModel.py @@ -0,0 +1,102 @@ +import HARK.ConsumptionSaving.ConsumerParameters as Params +import matplotlib.pyplot as plt +from HARK.utilities import plotFuncs +from time import process_time +import numpy as np +from HARK.ConsumptionSaving.ConsPrefShockModel import ( + PrefShockConsumerType, + KinkyPrefConsumerType, +) + +mystr = lambda number: "{:.4f}".format(number) + +do_simulation = True + +# Make and solve a preference shock consumer +PrefShockExample = PrefShockConsumerType(**Params.init_preference_shocks) +PrefShockExample.cycles = 0 # Infinite horizon + +t_start = process_time() +PrefShockExample.solve() +t_end = process_time() +print("Solving a preference shock consumer took " + str(t_end - t_start) + " seconds.") + +# Plot the consumption function at each discrete shock +m = np.linspace(PrefShockExample.solution[0].mNrmMin, 5, 200) +print("Consumption functions at each discrete shock:") +for j in range(PrefShockExample.PrefShkDstn[0][1].size): + PrefShk = PrefShockExample.PrefShkDstn[0][1][j] + c = PrefShockExample.solution[0].cFunc(m, PrefShk * np.ones_like(m)) + plt.plot(m, c) +plt.xlim([0.0, None]) +plt.ylim([0.0, None]) +plt.show() + +print("Consumption function (and MPC) when shock=1:") +c = PrefShockExample.solution[0].cFunc(m, np.ones_like(m)) +k = PrefShockExample.solution[0].cFunc.derivativeX(m, np.ones_like(m)) +plt.plot(m, c) +plt.plot(m, k) +plt.xlim([0.0, None]) +plt.ylim([0.0, None]) +plt.show() + +if PrefShockExample.vFuncBool: + print("Value function (unconditional on shock):") + plotFuncs( + PrefShockExample.solution[0].vFunc, + PrefShockExample.solution[0].mNrmMin + 0.5, + 5, + ) + +# Test the simulator for the pref shock class +if do_simulation: + PrefShockExample.T_sim = 120 + PrefShockExample.track_vars = ["cNrmNow"] + PrefShockExample.makeShockHistory() # This is optional + PrefShockExample.initializeSim() + PrefShockExample.simulate() + +########################################################################### + +# Make and solve a "kinky preferece" consumer, whose model combines KinkedR and PrefShock +KinkyPrefExample = KinkyPrefConsumerType(**Params.init_kinky_pref) +KinkyPrefExample.cycles = 0 # Infinite horizon + +t_start = process_time() +KinkyPrefExample.solve() +t_end = process_time() +print("Solving a kinky preference consumer took " + str(t_end - t_start) + " seconds.") + +# Plot the consumption function at each discrete shock +m = np.linspace(KinkyPrefExample.solution[0].mNrmMin, 5, 200) +print("Consumption functions at each discrete shock:") +for j in range(KinkyPrefExample.PrefShkDstn[0][1].size): + PrefShk = KinkyPrefExample.PrefShkDstn[0][1][j] + c = KinkyPrefExample.solution[0].cFunc(m, PrefShk * np.ones_like(m)) + plt.plot(m, c) +plt.ylim([0.0, None]) +plt.show() + +print("Consumption function (and MPC) when shock=1:") +c = KinkyPrefExample.solution[0].cFunc(m, np.ones_like(m)) +k = KinkyPrefExample.solution[0].cFunc.derivativeX(m, np.ones_like(m)) +plt.plot(m, c) +plt.plot(m, k) +plt.ylim([0.0, None]) +plt.show() + +if KinkyPrefExample.vFuncBool: + print("Value function (unconditional on shock):") + plotFuncs( + KinkyPrefExample.solution[0].vFunc, + KinkyPrefExample.solution[0].mNrmMin + 0.5, + 5, + ) + +# Test the simulator for the kinky preference class +if do_simulation: + KinkyPrefExample.T_sim = 120 + KinkyPrefExample.track_vars = ["cNrmNow", "PrefShkNow"] + KinkyPrefExample.initializeSim() + KinkyPrefExample.simulate() From 8715cac27e4d0b5ea47bca1b018f63a06a00882c Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Thu, 16 Jan 2020 15:14:15 +0530 Subject: [PATCH 09/43] breakup ConsRepAgentModel --- HARK/ConsumptionSaving/ConsRepAgentModel.py | 60 +-------------- .../example_ConsRepAgentModel.py | 73 +++++++++++++++++++ 2 files changed, 75 insertions(+), 58 deletions(-) create mode 100644 HARK/ConsumptionSaving/example_ConsRepAgentModel.py diff --git a/HARK/ConsumptionSaving/ConsRepAgentModel.py b/HARK/ConsumptionSaving/ConsRepAgentModel.py index e0d985ce9..f4c5183ea 100644 --- a/HARK/ConsumptionSaving/ConsRepAgentModel.py +++ b/HARK/ConsumptionSaving/ConsRepAgentModel.py @@ -9,6 +9,8 @@ from HARK.simulation import drawUniform, drawDiscrete from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType, ConsumerSolution, MargValueFunc +__all__ = ['RepAgentConsumerType', 'RepAgentMarkovConsumerType'] + def solveConsRepAgent(solution_next,DiscFac,CRRA,IncomeDstn,CapShare,DeprFac,PermGroFac,aXtraGrid): ''' Solve one period of the simple representative agent consumption-saving model. @@ -326,61 +328,3 @@ def getControls(self): t = self.t_cycle[0] i = self.MrkvNow[0] self.cNrmNow = self.solution[t].cFunc[i](self.mNrmNow) - - -############################################################################### -def main(): - from copy import deepcopy - from time import clock - from HARK.utilities import plotFuncs - import HARK.ConsumptionSaving.ConsumerParameters as Params - - # Make a quick example dictionary - RA_params = deepcopy(Params.init_idiosyncratic_shocks) - RA_params['DeprFac'] = 0.05 - RA_params['CapShare'] = 0.36 - RA_params['UnempPrb'] = 0.0 - RA_params['LivPrb'] = [1.0] - - # Make and solve a rep agent model - RAexample = RepAgentConsumerType(**RA_params) - t_start = clock() - RAexample.solve() - t_end = clock() - print('Solving a representative agent problem took ' + str(t_end-t_start) + ' seconds.') - plotFuncs(RAexample.solution[0].cFunc,0,20) - - # Simulate the representative agent model - RAexample.T_sim = 2000 - RAexample.track_vars = ['cNrmNow','mNrmNow','Rfree','wRte'] - RAexample.initializeSim() - t_start = clock() - RAexample.simulate() - t_end = clock() - print('Simulating a representative agent for ' + str(RAexample.T_sim) + ' periods took ' + str(t_end-t_start) + ' seconds.') - - # Make and solve a Markov representative agent - RA_markov_params = deepcopy(RA_params) - RA_markov_params['PermGroFac'] = [[0.97,1.03]] - RA_markov_params['MrkvArray'] = np.array([[0.99,0.01],[0.01,0.99]]) - RA_markov_params['MrkvNow'] = 0 - RAmarkovExample = RepAgentMarkovConsumerType(**RA_markov_params) - RAmarkovExample.IncomeDstn[0] = 2*[RAmarkovExample.IncomeDstn[0]] - t_start = clock() - RAmarkovExample.solve() - t_end = clock() - print('Solving a two state representative agent problem took ' + str(t_end-t_start) + ' seconds.') - plotFuncs(RAmarkovExample.solution[0].cFunc,0,10) - - # Simulate the two state representative agent model - RAmarkovExample.T_sim = 2000 - RAmarkovExample.track_vars = ['cNrmNow','mNrmNow','Rfree','wRte','MrkvNow'] - RAmarkovExample.initializeSim() - t_start = clock() - RAmarkovExample.simulate() - t_end = clock() - print('Simulating a two state representative agent for ' + str(RAexample.T_sim) + ' periods took ' + str(t_end-t_start) + ' seconds.') - -if __name__ == '__main__': - main() - diff --git a/HARK/ConsumptionSaving/example_ConsRepAgentModel.py b/HARK/ConsumptionSaving/example_ConsRepAgentModel.py new file mode 100644 index 000000000..c71d1639e --- /dev/null +++ b/HARK/ConsumptionSaving/example_ConsRepAgentModel.py @@ -0,0 +1,73 @@ +from copy import deepcopy +from time import process_time +import numpy as np +from HARK.utilities import plotFuncs +import HARK.ConsumptionSaving.ConsumerParameters as Params +from HARK.ConsumptionSaving.ConsRepAgentModel import ( + RepAgentConsumerType, + RepAgentMarkovConsumerType, +) + +# Make a quick example dictionary +RA_params = deepcopy(Params.init_idiosyncratic_shocks) +RA_params["DeprFac"] = 0.05 +RA_params["CapShare"] = 0.36 +RA_params["UnempPrb"] = 0.0 +RA_params["LivPrb"] = [1.0] + +# Make and solve a rep agent model +RAexample = RepAgentConsumerType(**RA_params) +t_start = process_time() +RAexample.solve() +t_end = process_time() +print( + "Solving a representative agent problem took " + str(t_end - t_start) + " seconds." +) +plotFuncs(RAexample.solution[0].cFunc, 0, 20) + +# Simulate the representative agent model +RAexample.T_sim = 2000 +RAexample.track_vars = ["cNrmNow", "mNrmNow", "Rfree", "wRte"] +RAexample.initializeSim() +t_start = process_time() +RAexample.simulate() +t_end = process_time() +print( + "Simulating a representative agent for " + + str(RAexample.T_sim) + + " periods took " + + str(t_end - t_start) + + " seconds." +) + +# Make and solve a Markov representative agent +RA_markov_params = deepcopy(RA_params) +RA_markov_params["PermGroFac"] = [[0.97, 1.03]] +RA_markov_params["MrkvArray"] = np.array([[0.99, 0.01], [0.01, 0.99]]) +RA_markov_params["MrkvNow"] = 0 +RAmarkovExample = RepAgentMarkovConsumerType(**RA_markov_params) +RAmarkovExample.IncomeDstn[0] = 2 * [RAmarkovExample.IncomeDstn[0]] +t_start = process_time() +RAmarkovExample.solve() +t_end = process_time() +print( + "Solving a two state representative agent problem took " + + str(t_end - t_start) + + " seconds." +) +plotFuncs(RAmarkovExample.solution[0].cFunc, 0, 10) + +# Simulate the two state representative agent model +RAmarkovExample.T_sim = 2000 +RAmarkovExample.track_vars = ["cNrmNow", "mNrmNow", "Rfree", "wRte", "MrkvNow"] +RAmarkovExample.initializeSim() +t_start = process_time() +RAmarkovExample.simulate() +t_end = process_time() +print( + "Simulating a two state representative agent for " + + str(RAexample.T_sim) + + " periods took " + + str(t_end - t_start) + + " seconds." +) From e1e606166853907b7bef03187f2939825adc78d9 Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Thu, 16 Jan 2020 15:20:13 +0530 Subject: [PATCH 10/43] breakup ConsMarkovModel --- HARK/ConsumptionSaving/ConsMarkovModel.py | 164 +----------- .../example_ConsMarkovModel.py | 243 ++++++++++++++++++ 2 files changed, 245 insertions(+), 162 deletions(-) create mode 100644 HARK/ConsumptionSaving/example_ConsMarkovModel.py diff --git a/HARK/ConsumptionSaving/ConsMarkovModel.py b/HARK/ConsumptionSaving/ConsMarkovModel.py index 2d03ed80f..1394869c1 100644 --- a/HARK/ConsumptionSaving/ConsMarkovModel.py +++ b/HARK/ConsumptionSaving/ConsMarkovModel.py @@ -14,6 +14,8 @@ from HARK.utilities import CRRAutility, CRRAutilityP, CRRAutilityPP, CRRAutilityP_inv, \ CRRAutility_invP, CRRAutility_inv, CRRAutilityP_invP +__all__ = ['ConsMarkovSolver', 'MarkovConsumerType'] + utility = CRRAutility utilityP = CRRAutilityP utilityPP = CRRAutilityPP @@ -963,165 +965,3 @@ def makeEulerErrorFunc(self,mMax=100,approx_inc_dstn=True): None ''' raise NotImplementedError() - - - -############################################################################### - -def main(): - import HARK.ConsumptionSaving.ConsumerParameters as Params - from HARK.utilities import plotFuncs - from time import clock - from copy import copy - mystr = lambda number : "{:.4f}".format(number) - - do_simulation = True - - # Define the Markov transition matrix for serially correlated unemployment - unemp_length = 5 # Averange length of unemployment spell - urate_good = 0.05 # Unemployment rate when economy is in good state - urate_bad = 0.12 # Unemployment rate when economy is in bad state - bust_prob = 0.01 # Probability of economy switching from good to bad - recession_length = 20 # Averange length of bad state - p_reemploy =1.0/unemp_length - p_unemploy_good = p_reemploy*urate_good/(1-urate_good) - p_unemploy_bad = p_reemploy*urate_bad/(1-urate_bad) - boom_prob = 1.0/recession_length - MrkvArray = np.array([[(1-p_unemploy_good)*(1-bust_prob),p_unemploy_good*(1-bust_prob), - (1-p_unemploy_good)*bust_prob,p_unemploy_good*bust_prob], - [p_reemploy*(1-bust_prob),(1-p_reemploy)*(1-bust_prob), - p_reemploy*bust_prob,(1-p_reemploy)*bust_prob], - [(1-p_unemploy_bad)*boom_prob,p_unemploy_bad*boom_prob, - (1-p_unemploy_bad)*(1-boom_prob),p_unemploy_bad*(1-boom_prob)], - [p_reemploy*boom_prob,(1-p_reemploy)*boom_prob, - p_reemploy*(1-boom_prob),(1-p_reemploy)*(1-boom_prob)]]) - - # Make a consumer with serially correlated unemployment, subject to boom and bust cycles - init_serial_unemployment = copy(Params.init_idiosyncratic_shocks) - init_serial_unemployment['MrkvArray'] = [MrkvArray] - init_serial_unemployment['UnempPrb'] = 0 # to make income distribution when employed - init_serial_unemployment['global_markov'] = False - SerialUnemploymentExample = MarkovConsumerType(**init_serial_unemployment) - SerialUnemploymentExample.cycles = 0 - SerialUnemploymentExample.vFuncBool = False # for easy toggling here - - # Replace the default (lognormal) income distribution with a custom one - employed_income_dist = [np.ones(1),np.ones(1),np.ones(1)] # Definitely get income - unemployed_income_dist = [np.ones(1),np.ones(1),np.zeros(1)] # Definitely don't - SerialUnemploymentExample.IncomeDstn = [[employed_income_dist,unemployed_income_dist,employed_income_dist, - unemployed_income_dist]] - - # Interest factor, permanent growth rates, and survival probabilities are constant arrays - SerialUnemploymentExample.Rfree = np.array(4*[SerialUnemploymentExample.Rfree]) - SerialUnemploymentExample.PermGroFac = [np.array(4*SerialUnemploymentExample.PermGroFac)] - SerialUnemploymentExample.LivPrb = [SerialUnemploymentExample.LivPrb*np.ones(4)] - - # Solve the serial unemployment consumer's problem and display solution - SerialUnemploymentExample.timeFwd() - start_time = clock() - SerialUnemploymentExample.solve() - end_time = clock() - print('Solving a Markov consumer with serially correlated unemployment took ' + mystr(end_time-start_time) + ' seconds.') - print('Consumption functions for each discrete state:') - plotFuncs(SerialUnemploymentExample.solution[0].cFunc,0,50) - if SerialUnemploymentExample.vFuncBool: - print('Value functions for each discrete state:') - plotFuncs(SerialUnemploymentExample.solution[0].vFunc,5,50) - - # Simulate some data; results stored in cHist, mNrmNow_hist, cNrmNow_hist, and MrkvNow_hist - if do_simulation: - SerialUnemploymentExample.T_sim = 120 - SerialUnemploymentExample.MrkvPrbsInit = [0.25,0.25,0.25,0.25] - SerialUnemploymentExample.track_vars = ['mNrmNow','cNrmNow'] - SerialUnemploymentExample.makeShockHistory() # This is optional - SerialUnemploymentExample.initializeSim() - SerialUnemploymentExample.simulate() - -############################################################################### - - # Make a consumer who occasionally gets "unemployment immunity" for a fixed period - UnempPrb = 0.05 # Probability of becoming unemployed each period - ImmunityPrb = 0.01 # Probability of becoming "immune" to unemployment - ImmunityT = 6 # Number of periods of immunity - - StateCount = ImmunityT+1 # Total number of Markov states - IncomeDstnReg = [np.array([1-UnempPrb,UnempPrb]), np.array([1.0,1.0]), np.array([1.0/(1.0-UnempPrb),0.0])] # Ordinary income distribution - IncomeDstnImm = [np.array([1.0]), np.array([1.0]), np.array([1.0])] # Income distribution when unemployed - IncomeDstn = [IncomeDstnReg] + ImmunityT*[IncomeDstnImm] # Income distribution for each Markov state, in a list - - # Make the Markov transition array. MrkvArray[i,j] is the probability of transitioning - # to state j in period t+1 from state i in period t. - MrkvArray = np.zeros((StateCount,StateCount)) - MrkvArray[0,0] = 1.0 - ImmunityPrb # Probability of not becoming immune in ordinary state: stay in ordinary state - MrkvArray[0,ImmunityT] = ImmunityPrb # Probability of becoming immune in ordinary state: begin immunity periods - for j in range(ImmunityT): - MrkvArray[j+1,j] = 1.0 # When immune, have 100% chance of transition to state with one fewer immunity periods remaining - - init_unemployment_immunity = copy(Params.init_idiosyncratic_shocks) - init_unemployment_immunity['MrkvArray'] = [MrkvArray] - ImmunityExample = MarkovConsumerType(**init_unemployment_immunity) - ImmunityExample.assignParameters(Rfree = np.array(np.array(StateCount*[1.03])), # Interest factor same in all states - PermGroFac = [np.array(StateCount*[1.01])], # Permanent growth factor same in all states - LivPrb = [np.array(StateCount*[0.98])], # Same survival probability in all states - BoroCnstArt = None, # No artificial borrowing constraint - cycles = 0) # Infinite horizon - ImmunityExample.IncomeDstn = [IncomeDstn] - - # Solve the unemployment immunity problem and display the consumption functions - start_time = clock() - ImmunityExample.solve() - end_time = clock() - print('Solving an "unemployment immunity" consumer took ' + mystr(end_time-start_time) + ' seconds.') - print('Consumption functions for each discrete state:') - mNrmMin = np.min([ImmunityExample.solution[0].mNrmMin[j] for j in range(StateCount)]) - plotFuncs(ImmunityExample.solution[0].cFunc,mNrmMin,10) - -############################################################################### - - # Make a consumer with serially correlated permanent income growth - UnempPrb = 0.05 # Unemployment probability - StateCount = 5 # Number of permanent income growth rates - Persistence = 0.5 # Probability of getting the same permanent income growth rate next period - - IncomeDstnReg = [np.array([1-UnempPrb,UnempPrb]), np.array([1.0,1.0]), np.array([1.0,0.0])] - IncomeDstn = StateCount*[IncomeDstnReg] # Same simple income distribution in each state - - # Make the state transition array for this type: Persistence probability of remaining in the same state, equiprobable otherwise - MrkvArray = Persistence*np.eye(StateCount) + (1.0/StateCount)*(1.0-Persistence)*np.ones((StateCount,StateCount)) - - init_serial_growth = copy(Params.init_idiosyncratic_shocks) - init_serial_growth['MrkvArray'] = [MrkvArray] - SerialGroExample = MarkovConsumerType(**init_serial_growth) - SerialGroExample.assignParameters(Rfree = np.array(np.array(StateCount*[1.03])), # Same interest factor in each Markov state - PermGroFac = [np.array([0.97,0.99,1.01,1.03,1.05])], # Different permanent growth factor in each Markov state - LivPrb = [np.array(StateCount*[0.98])], # Same survival probability in all states - cycles = 0) - SerialGroExample.IncomeDstn = [IncomeDstn] - - - # Solve the serially correlated permanent growth shock problem and display the consumption functions - start_time = clock() - SerialGroExample.solve() - end_time = clock() - print('Solving a serially correlated growth consumer took ' + mystr(end_time-start_time) + ' seconds.') - print('Consumption functions for each discrete state:') - plotFuncs(SerialGroExample.solution[0].cFunc,0,10) - -############################################################################### - - # Make a consumer with serially correlated interest factors - SerialRExample = deepcopy(SerialGroExample) # Same as the last problem... - SerialRExample.assignParameters(PermGroFac = [np.array(StateCount*[1.01])], # ...but now the permanent growth factor is constant... - Rfree = np.array([1.01,1.02,1.03,1.04,1.05])) # ...and the interest factor is what varies across states - - # Solve the serially correlated interest rate problem and display the consumption functions - start_time = clock() - SerialRExample.solve() - end_time = clock() - print('Solving a serially correlated interest consumer took ' + mystr(end_time-start_time) + ' seconds.') - print('Consumption functions for each discrete state:') - plotFuncs(SerialRExample.solution[0].cFunc,0,10) - - -if __name__ == '__main__': - main() diff --git a/HARK/ConsumptionSaving/example_ConsMarkovModel.py b/HARK/ConsumptionSaving/example_ConsMarkovModel.py new file mode 100644 index 000000000..75ecb3794 --- /dev/null +++ b/HARK/ConsumptionSaving/example_ConsMarkovModel.py @@ -0,0 +1,243 @@ +import HARK.ConsumptionSaving.ConsumerParameters as Params +from HARK.utilities import plotFuncs +from time import process_time +from copy import deepcopy, copy +import numpy as np +from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType + +mystr = lambda number: "{:.4f}".format(number) + +do_simulation = True + +# Define the Markov transition matrix for serially correlated unemployment +unemp_length = 5 # Averange length of unemployment spell +urate_good = 0.05 # Unemployment rate when economy is in good state +urate_bad = 0.12 # Unemployment rate when economy is in bad state +bust_prob = 0.01 # Probability of economy switching from good to bad +recession_length = 20 # Averange length of bad state +p_reemploy = 1.0 / unemp_length +p_unemploy_good = p_reemploy * urate_good / (1 - urate_good) +p_unemploy_bad = p_reemploy * urate_bad / (1 - urate_bad) +boom_prob = 1.0 / recession_length +MrkvArray = np.array( + [ + [ + (1 - p_unemploy_good) * (1 - bust_prob), + p_unemploy_good * (1 - bust_prob), + (1 - p_unemploy_good) * bust_prob, + p_unemploy_good * bust_prob, + ], + [ + p_reemploy * (1 - bust_prob), + (1 - p_reemploy) * (1 - bust_prob), + p_reemploy * bust_prob, + (1 - p_reemploy) * bust_prob, + ], + [ + (1 - p_unemploy_bad) * boom_prob, + p_unemploy_bad * boom_prob, + (1 - p_unemploy_bad) * (1 - boom_prob), + p_unemploy_bad * (1 - boom_prob), + ], + [ + p_reemploy * boom_prob, + (1 - p_reemploy) * boom_prob, + p_reemploy * (1 - boom_prob), + (1 - p_reemploy) * (1 - boom_prob), + ], + ] +) + +# Make a consumer with serially correlated unemployment, subject to boom and bust cycles +init_serial_unemployment = copy(Params.init_idiosyncratic_shocks) +init_serial_unemployment["MrkvArray"] = [MrkvArray] +init_serial_unemployment["UnempPrb"] = 0 # to make income distribution when employed +init_serial_unemployment["global_markov"] = False +SerialUnemploymentExample = MarkovConsumerType(**init_serial_unemployment) +SerialUnemploymentExample.cycles = 0 +SerialUnemploymentExample.vFuncBool = False # for easy toggling here + +# Replace the default (lognormal) income distribution with a custom one +employed_income_dist = [np.ones(1), np.ones(1), np.ones(1)] # Definitely get income +unemployed_income_dist = [np.ones(1), np.ones(1), np.zeros(1)] # Definitely don't +SerialUnemploymentExample.IncomeDstn = [ + [ + employed_income_dist, + unemployed_income_dist, + employed_income_dist, + unemployed_income_dist, + ] +] + +# Interest factor, permanent growth rates, and survival probabilities are constant arrays +SerialUnemploymentExample.Rfree = np.array(4 * [SerialUnemploymentExample.Rfree]) +SerialUnemploymentExample.PermGroFac = [ + np.array(4 * SerialUnemploymentExample.PermGroFac) +] +SerialUnemploymentExample.LivPrb = [SerialUnemploymentExample.LivPrb * np.ones(4)] + +# Solve the serial unemployment consumer's problem and display solution +SerialUnemploymentExample.timeFwd() +start_time = process_time() +SerialUnemploymentExample.solve() +end_time = process_time() +print( + "Solving a Markov consumer with serially correlated unemployment took " + + mystr(end_time - start_time) + + " seconds." +) +print("Consumption functions for each discrete state:") +plotFuncs(SerialUnemploymentExample.solution[0].cFunc, 0, 50) +if SerialUnemploymentExample.vFuncBool: + print("Value functions for each discrete state:") + plotFuncs(SerialUnemploymentExample.solution[0].vFunc, 5, 50) + +# Simulate some data; results stored in cHist, mNrmNow_hist, cNrmNow_hist, and MrkvNow_hist +if do_simulation: + SerialUnemploymentExample.T_sim = 120 + SerialUnemploymentExample.MrkvPrbsInit = [0.25, 0.25, 0.25, 0.25] + SerialUnemploymentExample.track_vars = ["mNrmNow", "cNrmNow"] + SerialUnemploymentExample.makeShockHistory() # This is optional + SerialUnemploymentExample.initializeSim() + SerialUnemploymentExample.simulate() + +############################################################################### + +# Make a consumer who occasionally gets "unemployment immunity" for a fixed period +UnempPrb = 0.05 # Probability of becoming unemployed each period +ImmunityPrb = 0.01 # Probability of becoming "immune" to unemployment +ImmunityT = 6 # Number of periods of immunity + +StateCount = ImmunityT + 1 # Total number of Markov states +IncomeDstnReg = [ + np.array([1 - UnempPrb, UnempPrb]), + np.array([1.0, 1.0]), + np.array([1.0 / (1.0 - UnempPrb), 0.0]), +] # Ordinary income distribution +IncomeDstnImm = [ + np.array([1.0]), + np.array([1.0]), + np.array([1.0]), +] # Income distribution when unemployed +IncomeDstn = [IncomeDstnReg] + ImmunityT * [ + IncomeDstnImm +] # Income distribution for each Markov state, in a list + +# Make the Markov transition array. MrkvArray[i,j] is the probability of transitioning +# to state j in period t+1 from state i in period t. +MrkvArray = np.zeros((StateCount, StateCount)) +MrkvArray[0, 0] = ( + 1.0 - ImmunityPrb +) # Probability of not becoming immune in ordinary state: stay in ordinary state +MrkvArray[ + 0, ImmunityT +] = ( + ImmunityPrb +) # Probability of becoming immune in ordinary state: begin immunity periods +for j in range(ImmunityT): + MrkvArray[ + j + 1, j + ] = ( + 1.0 + ) # When immune, have 100% chance of transition to state with one fewer immunity periods remaining + +init_unemployment_immunity = copy(Params.init_idiosyncratic_shocks) +init_unemployment_immunity["MrkvArray"] = [MrkvArray] +ImmunityExample = MarkovConsumerType(**init_unemployment_immunity) +ImmunityExample.assignParameters( + Rfree=np.array(np.array(StateCount * [1.03])), # Interest factor same in all states + PermGroFac=[ + np.array(StateCount * [1.01]) + ], # Permanent growth factor same in all states + LivPrb=[np.array(StateCount * [0.98])], # Same survival probability in all states + BoroCnstArt=None, # No artificial borrowing constraint + cycles=0, +) # Infinite horizon +ImmunityExample.IncomeDstn = [IncomeDstn] + +# Solve the unemployment immunity problem and display the consumption functions +start_time = process_time() +ImmunityExample.solve() +end_time = process_time() +print( + 'Solving an "unemployment immunity" consumer took ' + + mystr(end_time - start_time) + + " seconds." +) +print("Consumption functions for each discrete state:") +mNrmMin = np.min([ImmunityExample.solution[0].mNrmMin[j] for j in range(StateCount)]) +plotFuncs(ImmunityExample.solution[0].cFunc, mNrmMin, 10) + +############################################################################### + +# Make a consumer with serially correlated permanent income growth +UnempPrb = 0.05 # Unemployment probability +StateCount = 5 # Number of permanent income growth rates +Persistence = ( + 0.5 +) # Probability of getting the same permanent income growth rate next period + +IncomeDstnReg = [ + np.array([1 - UnempPrb, UnempPrb]), + np.array([1.0, 1.0]), + np.array([1.0, 0.0]), +] +IncomeDstn = StateCount * [ + IncomeDstnReg +] # Same simple income distribution in each state + +# Make the state transition array for this type: Persistence probability of remaining in the same state, equiprobable otherwise +MrkvArray = Persistence * np.eye(StateCount) + (1.0 / StateCount) * ( + 1.0 - Persistence +) * np.ones((StateCount, StateCount)) + +init_serial_growth = copy(Params.init_idiosyncratic_shocks) +init_serial_growth["MrkvArray"] = [MrkvArray] +SerialGroExample = MarkovConsumerType(**init_serial_growth) +SerialGroExample.assignParameters( + Rfree=np.array( + np.array(StateCount * [1.03]) + ), # Same interest factor in each Markov state + PermGroFac=[ + np.array([0.97, 0.99, 1.01, 1.03, 1.05]) + ], # Different permanent growth factor in each Markov state + LivPrb=[np.array(StateCount * [0.98])], # Same survival probability in all states + cycles=0, +) +SerialGroExample.IncomeDstn = [IncomeDstn] + + +# Solve the serially correlated permanent growth shock problem and display the consumption functions +start_time = process_time() +SerialGroExample.solve() +end_time = process_time() +print( + "Solving a serially correlated growth consumer took " + + mystr(end_time - start_time) + + " seconds." +) +print("Consumption functions for each discrete state:") +plotFuncs(SerialGroExample.solution[0].cFunc, 0, 10) + +############################################################################### + +# Make a consumer with serially correlated interest factors +SerialRExample = deepcopy(SerialGroExample) # Same as the last problem... +SerialRExample.assignParameters( + PermGroFac=[ + np.array(StateCount * [1.01]) + ], # ...but now the permanent growth factor is constant... + Rfree=np.array([1.01, 1.02, 1.03, 1.04, 1.05]), +) # ...and the interest factor is what varies across states + +# Solve the serially correlated interest rate problem and display the consumption functions +start_time = process_time() +SerialRExample.solve() +end_time = process_time() +print( + "Solving a serially correlated interest consumer took " + + mystr(end_time - start_time) + + " seconds." +) +print("Consumption functions for each discrete state:") +plotFuncs(SerialRExample.solution[0].cFunc, 0, 10) From 4f4545b1d28fd65472331b282f445b8202db4b39 Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Thu, 16 Jan 2020 15:26:35 +0530 Subject: [PATCH 11/43] update ConsMedModel --- HARK/ConsumptionSaving/ConsMedModel.py | 89 +----------------- .../ConsumptionSaving/example_ConsMedModel.py | 94 +++++++++++++++++++ 2 files changed, 97 insertions(+), 86 deletions(-) create mode 100644 HARK/ConsumptionSaving/example_ConsMedModel.py diff --git a/HARK/ConsumptionSaving/ConsMedModel.py b/HARK/ConsumptionSaving/ConsMedModel.py index cd4578815..09d95e2cc 100644 --- a/HARK/ConsumptionSaving/ConsMedModel.py +++ b/HARK/ConsumptionSaving/ConsMedModel.py @@ -16,6 +16,9 @@ MargMargValueFunc2D, VariableLowerBoundFunc2D from copy import deepcopy +__all__ = ['MedShockPolicyFunc', 'cThruXfunc', 'MedThruXfunc', +'MedShockConsumerType', 'ConsMedShockSolver'] + utility_inv = CRRAutility_inv utilityP_inv = CRRAutilityP_inv utility = CRRAutility @@ -1352,89 +1355,3 @@ def solveConsMedShock(solution_next,IncomeDstn,MedShkDstn,LivPrb,DiscFac,CRRA,CR solver.prepareToSolve() # Do some preparatory work solution_now = solver.solve() # Solve the period return solution_now - - -############################################################################### - -def main(): - import HARK.ConsumptionSaving.ConsumerParameters as Params - from HARK.utilities import CRRAutility_inv - from time import clock - import matplotlib.pyplot as plt - mystr = lambda number : "{:.4f}".format(number) - - do_simulation = True - - # Make and solve an example medical shocks consumer type - MedicalExample = MedShockConsumerType(**Params.init_medical_shocks) - t_start = clock() - MedicalExample.solve() - t_end = clock() - print('Solving a medical shocks consumer took ' + mystr(t_end-t_start) + ' seconds.') - - # Plot the consumption function - M = np.linspace(0,30,300) - pLvl = 1.0 - P = pLvl*np.ones_like(M) - for j in range(MedicalExample.MedShkDstn[0][0].size): - MedShk = MedicalExample.MedShkDstn[0][1][j]*np.ones_like(M) - M_temp = M + MedicalExample.solution[0].mLvlMin(pLvl) - C = MedicalExample.solution[0].cFunc(M_temp,P,MedShk) - plt.plot(M_temp,C) - print('Consumption function by medical need shock (constant permanent income)') - plt.show() - - # Plot the medical care function - for j in range(MedicalExample.MedShkDstn[0][0].size): - MedShk = MedicalExample.MedShkDstn[0][1][j]*np.ones_like(M) - Med = MedicalExample.solution[0].MedFunc(M_temp,P,MedShk) - plt.plot(M_temp,Med) - print('Medical care function by medical need shock (constant permanent income)') - plt.ylim([0,20]) - plt.show() - - # Plot the savings function - for j in range(MedicalExample.MedShkDstn[0][0].size): - MedShk = MedicalExample.MedShkDstn[0][1][j]*np.ones_like(M) - Sav = M_temp - MedicalExample.solution[0].cFunc(M_temp,P,MedShk) - MedicalExample.MedPrice[0]*\ - MedicalExample.solution[0].MedFunc(M_temp,P,MedShk) - plt.plot(M_temp,Sav) - print('End of period savings by medical need shock (constant permanent income)') - plt.show() - - # Plot the marginal value function - M = np.linspace(0.0,30,300) - for p in range(MedicalExample.pLvlGrid[0].size): - pLvl = MedicalExample.pLvlGrid[0][p] - M_temp = pLvl*M + MedicalExample.solution[0].mLvlMin(pLvl) - P = pLvl*np.ones_like(M) - vP = MedicalExample.solution[0].vPfunc(M_temp,P)**(-1.0/MedicalExample.CRRA) - plt.plot(M_temp,vP) - print('Marginal value function (pseudo inverse)') - plt.show() - - if MedicalExample.vFuncBool: - # Plot the value function - M = np.linspace(0.0,1,300) - for p in range(MedicalExample.pLvlGrid[0].size): - pLvl = MedicalExample.pLvlGrid[0][p] - M_temp = pLvl*M + MedicalExample.solution[0].mLvlMin(pLvl) - P = pLvl*np.ones_like(M) - v = CRRAutility_inv(MedicalExample.solution[0].vFunc(M_temp,P),gam=MedicalExample.CRRA) - plt.plot(M_temp,v) - print('Value function (pseudo inverse)') - plt.show() - - if do_simulation: - t_start = clock() - MedicalExample.T_sim = 100 - MedicalExample.track_vars = ['mLvlNow','cLvlNow','MedNow'] - MedicalExample.makeShockHistory() - MedicalExample.initializeSim() - MedicalExample.simulate() - t_end = clock() - print('Simulating ' + str(MedicalExample.AgentCount) + ' agents for ' + str(MedicalExample.T_sim) + ' periods took ' + mystr(t_end-t_start) + ' seconds.') - -if __name__ == '__main__': - main() - diff --git a/HARK/ConsumptionSaving/example_ConsMedModel.py b/HARK/ConsumptionSaving/example_ConsMedModel.py new file mode 100644 index 000000000..c1e853c8e --- /dev/null +++ b/HARK/ConsumptionSaving/example_ConsMedModel.py @@ -0,0 +1,94 @@ +import HARK.ConsumptionSaving.ConsumerParameters as Params +from HARK.utilities import CRRAutility_inv +from time import process_time +import matplotlib.pyplot as plt +import numpy as np +from HARK.ConsumptionSaving.ConsMedModel import MedShockConsumerType + +mystr = lambda number: "{:.4f}".format(number) + +do_simulation = True + +# Make and solve an example medical shocks consumer type +MedicalExample = MedShockConsumerType(**Params.init_medical_shocks) +t_start = process_time() +MedicalExample.solve() +t_end = process_time() +print("Solving a medical shocks consumer took " + mystr(t_end - t_start) + " seconds.") + +# Plot the consumption function +M = np.linspace(0, 30, 300) +pLvl = 1.0 +P = pLvl * np.ones_like(M) +for j in range(MedicalExample.MedShkDstn[0][0].size): + MedShk = MedicalExample.MedShkDstn[0][1][j] * np.ones_like(M) + M_temp = M + MedicalExample.solution[0].mLvlMin(pLvl) + C = MedicalExample.solution[0].cFunc(M_temp, P, MedShk) + plt.plot(M_temp, C) +print("Consumption function by medical need shock (constant permanent income)") +plt.show() + +# Plot the medical care function +for j in range(MedicalExample.MedShkDstn[0][0].size): + MedShk = MedicalExample.MedShkDstn[0][1][j] * np.ones_like(M) + Med = MedicalExample.solution[0].MedFunc(M_temp, P, MedShk) + plt.plot(M_temp, Med) +print("Medical care function by medical need shock (constant permanent income)") +plt.ylim([0, 20]) +plt.show() + +# Plot the savings function +for j in range(MedicalExample.MedShkDstn[0][0].size): + MedShk = MedicalExample.MedShkDstn[0][1][j] * np.ones_like(M) + Sav = ( + M_temp + - MedicalExample.solution[0].cFunc(M_temp, P, MedShk) + - MedicalExample.MedPrice[0] + * MedicalExample.solution[0].MedFunc(M_temp, P, MedShk) + ) + plt.plot(M_temp, Sav) +print("End of period savings by medical need shock (constant permanent income)") +plt.show() + +# Plot the marginal value function +M = np.linspace(0.0, 30, 300) +for p in range(MedicalExample.pLvlGrid[0].size): + pLvl = MedicalExample.pLvlGrid[0][p] + M_temp = pLvl * M + MedicalExample.solution[0].mLvlMin(pLvl) + P = pLvl * np.ones_like(M) + vP = MedicalExample.solution[0].vPfunc(M_temp, P) ** (-1.0 / MedicalExample.CRRA) + plt.plot(M_temp, vP) +print("Marginal value function (pseudo inverse)") +plt.show() + +if MedicalExample.vFuncBool: + # Plot the value function + M = np.linspace(0.0, 1, 300) + for p in range(MedicalExample.pLvlGrid[0].size): + pLvl = MedicalExample.pLvlGrid[0][p] + M_temp = pLvl * M + MedicalExample.solution[0].mLvlMin(pLvl) + P = pLvl * np.ones_like(M) + v = CRRAutility_inv( + MedicalExample.solution[0].vFunc(M_temp, P), gam=MedicalExample.CRRA + ) + plt.plot(M_temp, v) + print("Value function (pseudo inverse)") + plt.show() + +if do_simulation: + t_start = process_time() + MedicalExample.T_sim = 100 + MedicalExample.track_vars = ["mLvlNow", "cLvlNow", "MedNow"] + MedicalExample.makeShockHistory() + MedicalExample.initializeSim() + MedicalExample.simulate() + t_end = process_time() + print( + "Simulating " + + str(MedicalExample.AgentCount) + + " agents for " + + str(MedicalExample.T_sim) + + " periods took " + + mystr(t_end - t_start) + + " seconds." + ) From b451567486e05f38d2c31098aa3318874f90553b Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Thu, 16 Jan 2020 15:30:09 +0530 Subject: [PATCH 12/43] update tractablebufferstock --- .../TractableBufferStockModel.py | 103 +-------------- .../example_TractableBufferStockModel.py | 123 ++++++++++++++++++ 2 files changed, 125 insertions(+), 101 deletions(-) create mode 100644 HARK/ConsumptionSaving/example_TractableBufferStockModel.py diff --git a/HARK/ConsumptionSaving/TractableBufferStockModel.py b/HARK/ConsumptionSaving/TractableBufferStockModel.py index 1fb135f89..1fcdc615b 100644 --- a/HARK/ConsumptionSaving/TractableBufferStockModel.py +++ b/HARK/ConsumptionSaving/TractableBufferStockModel.py @@ -31,6 +31,8 @@ from copy import copy from scipy.optimize import newton, brentq +__all__ = ['TractableConsumerSolution', 'TractableConsumerType'] + # If you want to run the "tractable" version of cstwMPC, uncomment the line below # and have TractableConsumerType inherit from cstwMPCagent rather than AgentType #from HARK.cstwMPC.cstwMPC import cstwMPCagent @@ -462,104 +464,3 @@ def getPostStates(self): ''' self.aLvlNow = self.mLvlNow - self.cLvlNow return None - - -############################################################################### - -def main(): - # Import the HARK library. The assumption is that this code is in a folder - # contained in the HARK folder. Also import the ConsumptionSavingModel - import numpy as np # numeric Python - from HARK.utilities import plotFuncs # basic plotting tools - from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType # An alternative, much longer way to solve the TBS model - from time import clock # timing utility - - do_simulation = True - - # Define the model primitives - base_primitives = {'UnempPrb' : .00625, # Probability of becoming unemployed - 'DiscFac' : 0.975, # Intertemporal discount factor - 'Rfree' : 1.01, # Risk-free interest factor on assets - 'PermGroFac' : 1.0025, # Permanent income growth factor (uncompensated) - 'CRRA' : 1.0} # Coefficient of relative risk aversion - - # Define a dictionary to be used in case of simulation - simulation_values = {'aLvlInitMean' : 0.0, # Mean of log initial assets for new agents - 'aLvlInitStd' : 1.0, # Stdev of log initial assets for new agents - 'AgentCount' : 10000, # Number of agents to simulate - 'T_sim' : 120, # Number of periods to simulate - 'T_cycle' : 1} # Number of periods in the cycle - - # Make and solve a tractable consumer type - ExampleType = TractableConsumerType(**base_primitives) - t_start = clock() - ExampleType.solve() - t_end = clock() - print('Solving a tractable consumption-savings model took ' + str(t_end-t_start) + ' seconds.') - - # Plot the consumption function and whatnot - m_upper = 1.5*ExampleType.mTarg - conFunc_PF = lambda m: ExampleType.h*ExampleType.PFMPC + ExampleType.PFMPC*m - #plotFuncs([ExampleType.solution[0].cFunc,ExampleType.mSSfunc,ExampleType.cSSfunc],0,m_upper) - plotFuncs([ExampleType.solution[0].cFunc,ExampleType.solution[0].cFunc_U],0,m_upper) - - if do_simulation: - ExampleType(**simulation_values) # Set attributes needed for simulation - ExampleType.track_vars = ['mLvlNow'] - ExampleType.makeShockHistory() - ExampleType.initializeSim() - ExampleType.simulate() - - - # Now solve the same model using backward induction rather than the analytic method of TBS. - # The TBS model is equivalent to a Markov model with two states, one of them absorbing (permanent unemployment). - MrkvArray = np.array([[1.0-base_primitives['UnempPrb'],base_primitives['UnempPrb']],[0.0,1.0]]) # Define the two state, absorbing unemployment Markov array - init_consumer_objects = {"CRRA":base_primitives['CRRA'], - "Rfree":np.array(2*[base_primitives['Rfree']]), # Interest factor (same in both states) - "PermGroFac":[np.array(2*[base_primitives['PermGroFac']/(1.0-base_primitives['UnempPrb'])])], # Unemployment-compensated permanent growth factor - "BoroCnstArt":None, # Artificial borrowing constraint - "PermShkStd":[0.0], # Permanent shock standard deviation - "PermShkCount":1, # Number of shocks in discrete permanent shock distribution - "TranShkStd":[0.0], # Transitory shock standard deviation - "TranShkCount":1, # Number of shocks in discrete permanent shock distribution - "T_cycle":1, # Number of periods in cycle - "UnempPrb":0.0, # Unemployment probability (not used, as the unemployment here is *permanent*, not transitory) - "UnempPrbRet":0.0, # Unemployment probability when retired (irrelevant here) - "T_retire":0, # Age at retirement (turned off) - "IncUnemp":0.0, # Income when unemployed (irrelevant) - "IncUnempRet":0.0, # Income when unemployed and retired (irrelevant) - "aXtraMin":0.001, # Minimum value of assets above minimum in grid - "aXtraMax":ExampleType.mUpperBnd, # Maximum value of assets above minimum in grid - "aXtraCount":48, # Number of points in assets grid - "aXtraExtra":[None], # Additional points to include in assets grid - "aXtraNestFac":3, # Degree of exponential nesting when constructing assets grid - "LivPrb":[np.array([1.0,1.0])], # Survival probability - "DiscFac":base_primitives['DiscFac'], # Intertemporal discount factor - 'AgentCount':1, # Number of agents in a simulation (irrelevant) - 'tax_rate':0.0, # Tax rate on labor income (irrelevant) - 'vFuncBool':False, # Whether to calculate the value function - 'CubicBool':True, # Whether to use cubic splines (False --> linear splines) - 'MrkvArray':[MrkvArray] # State transition probabilities - } - MarkovType = MarkovConsumerType(**init_consumer_objects) # Make a basic consumer type - employed_income_dist = [np.ones(1),np.ones(1),np.ones(1)] # Income distribution when employed - unemployed_income_dist = [np.ones(1),np.ones(1),np.zeros(1)] # Income distribution when permanently unemployed - MarkovType.IncomeDstn = [[employed_income_dist,unemployed_income_dist]] # set the income distribution in each state - MarkovType.cycles = 0 - - # Solve the "Markov TBS" model - t_start = clock() - MarkovType.solve() - t_end = clock() - MarkovType.unpackcFunc() - - print('Solving the same model "the long way" took ' + str(t_end-t_start) + ' seconds.') - #plotFuncs([ExampleType.solution[0].cFunc,ExampleType.solution[0].cFunc_U],0,m_upper) - plotFuncs(MarkovType.cFunc[0],0,m_upper) - diffFunc = lambda m : ExampleType.solution[0].cFunc(m) - MarkovType.cFunc[0][0](m) - print('Difference between the (employed) consumption functions:') - plotFuncs(diffFunc,0,m_upper) - -if __name__ == '__main__': - main() - diff --git a/HARK/ConsumptionSaving/example_TractableBufferStockModel.py b/HARK/ConsumptionSaving/example_TractableBufferStockModel.py new file mode 100644 index 000000000..c6641ab33 --- /dev/null +++ b/HARK/ConsumptionSaving/example_TractableBufferStockModel.py @@ -0,0 +1,123 @@ +import numpy as np # numeric Python +from HARK.utilities import plotFuncs # basic plotting tools +from HARK.ConsumptionSaving.ConsMarkovModel import ( + MarkovConsumerType, +) # An alternative, much longer way to solve the TBS model +from time import process_time # timing utility +from HARK.ConsumptionSaving.TractableBufferStockModel import TractableConsumerType +import numpy as np + +do_simulation = True + +# Define the model primitives +base_primitives = { + "UnempPrb": 0.00625, # Probability of becoming unemployed + "DiscFac": 0.975, # Intertemporal discount factor + "Rfree": 1.01, # Risk-free interest factor on assets + "PermGroFac": 1.0025, # Permanent income growth factor (uncompensated) + "CRRA": 1.0, +} # Coefficient of relative risk aversion + +# Define a dictionary to be used in case of simulation +simulation_values = { + "aLvlInitMean": 0.0, # Mean of log initial assets for new agents + "aLvlInitStd": 1.0, # Stdev of log initial assets for new agents + "AgentCount": 10000, # Number of agents to simulate + "T_sim": 120, # Number of periods to simulate + "T_cycle": 1, +} # Number of periods in the cycle + +# Make and solve a tractable consumer type +ExampleType = TractableConsumerType(**base_primitives) +t_start = process_time() +ExampleType.solve() +t_end = process_time() +print( + "Solving a tractable consumption-savings model took " + + str(t_end - t_start) + + " seconds." +) + +# Plot the consumption function and whatnot +m_upper = 1.5 * ExampleType.mTarg +conFunc_PF = lambda m: ExampleType.h * ExampleType.PFMPC + ExampleType.PFMPC * m +# plotFuncs([ExampleType.solution[0].cFunc,ExampleType.mSSfunc,ExampleType.cSSfunc],0,m_upper) +plotFuncs([ExampleType.solution[0].cFunc, ExampleType.solution[0].cFunc_U], 0, m_upper) + +if do_simulation: + ExampleType(**simulation_values) # Set attributes needed for simulation + ExampleType.track_vars = ["mLvlNow"] + ExampleType.makeShockHistory() + ExampleType.initializeSim() + ExampleType.simulate() + + +# Now solve the same model using backward induction rather than the analytic method of TBS. +# The TBS model is equivalent to a Markov model with two states, one of them absorbing (permanent unemployment). +MrkvArray = np.array( + [[1.0 - base_primitives["UnempPrb"], base_primitives["UnempPrb"]], [0.0, 1.0]] +) # Define the two state, absorbing unemployment Markov array +init_consumer_objects = { + "CRRA": base_primitives["CRRA"], + "Rfree": np.array( + 2 * [base_primitives["Rfree"]] + ), # Interest factor (same in both states) + "PermGroFac": [ + np.array( + 2 * [base_primitives["PermGroFac"] / (1.0 - base_primitives["UnempPrb"])] + ) + ], # Unemployment-compensated permanent growth factor + "BoroCnstArt": None, # Artificial borrowing constraint + "PermShkStd": [0.0], # Permanent shock standard deviation + "PermShkCount": 1, # Number of shocks in discrete permanent shock distribution + "TranShkStd": [0.0], # Transitory shock standard deviation + "TranShkCount": 1, # Number of shocks in discrete permanent shock distribution + "T_cycle": 1, # Number of periods in cycle + "UnempPrb": 0.0, # Unemployment probability (not used, as the unemployment here is *permanent*, not transitory) + "UnempPrbRet": 0.0, # Unemployment probability when retired (irrelevant here) + "T_retire": 0, # Age at retirement (turned off) + "IncUnemp": 0.0, # Income when unemployed (irrelevant) + "IncUnempRet": 0.0, # Income when unemployed and retired (irrelevant) + "aXtraMin": 0.001, # Minimum value of assets above minimum in grid + "aXtraMax": ExampleType.mUpperBnd, # Maximum value of assets above minimum in grid + "aXtraCount": 48, # Number of points in assets grid + "aXtraExtra": [None], # Additional points to include in assets grid + "aXtraNestFac": 3, # Degree of exponential nesting when constructing assets grid + "LivPrb": [np.array([1.0, 1.0])], # Survival probability + "DiscFac": base_primitives["DiscFac"], # Intertemporal discount factor + "AgentCount": 1, # Number of agents in a simulation (irrelevant) + "tax_rate": 0.0, # Tax rate on labor income (irrelevant) + "vFuncBool": False, # Whether to calculate the value function + "CubicBool": True, # Whether to use cubic splines (False --> linear splines) + "MrkvArray": [MrkvArray], # State transition probabilities +} +MarkovType = MarkovConsumerType(**init_consumer_objects) # Make a basic consumer type +employed_income_dist = [ + np.ones(1), + np.ones(1), + np.ones(1), +] # Income distribution when employed +unemployed_income_dist = [ + np.ones(1), + np.ones(1), + np.zeros(1), +] # Income distribution when permanently unemployed +MarkovType.IncomeDstn = [ + [employed_income_dist, unemployed_income_dist] +] # set the income distribution in each state +MarkovType.cycles = 0 + +# Solve the "Markov TBS" model +t_start = process_time() +MarkovType.solve() +t_end = process_time() +MarkovType.unpackcFunc() + +print( + 'Solving the same model "the long way" took ' + str(t_end - t_start) + " seconds." +) +# plotFuncs([ExampleType.solution[0].cFunc,ExampleType.solution[0].cFunc_U],0,m_upper) +plotFuncs(MarkovType.cFunc[0], 0, m_upper) +diffFunc = lambda m: ExampleType.solution[0].cFunc(m) - MarkovType.cFunc[0][0](m) +print("Difference between the (employed) consumption functions:") +plotFuncs(diffFunc, 0, m_upper) From 01a440671fa2c793c35c39bf33ad6aed19dd8c04 Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Thu, 16 Jan 2020 17:28:28 +0530 Subject: [PATCH 13/43] fix examples for parameter loading --- .../example_ConsAggShockModel.py | 18 ++++++------------ .../example_ConsGenIncProcessModel.py | 2 +- HARK/ConsumptionSaving/example_ConsIndShock.py | 6 +++--- HARK/ConsumptionSaving/example_ConsMedModel.py | 2 +- .../example_ConsPrefShockModel.py | 4 ++-- 5 files changed, 13 insertions(+), 19 deletions(-) diff --git a/HARK/ConsumptionSaving/example_ConsAggShockModel.py b/HARK/ConsumptionSaving/example_ConsAggShockModel.py index c8d462a70..11f978408 100644 --- a/HARK/ConsumptionSaving/example_ConsAggShockModel.py +++ b/HARK/ConsumptionSaving/example_ConsAggShockModel.py @@ -37,13 +37,11 @@ def mystr(number): if solve_agg_shocks_micro or solve_agg_shocks_market: # Make an aggregate shocks consumer type - AggShockExample = AggShockConsumerType(**Params.init_agg_shocks) + AggShockExample = AggShockConsumerType() AggShockExample.cycles = 0 # Make a Cobb-Douglas economy for the agents - EconomyExample = CobbDouglasEconomy( - agents=[AggShockExample], **Params.init_cobb_douglas - ) + EconomyExample = CobbDouglasEconomy(agents=[AggShockExample]) EconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks # Have the consumers inherit relevant objects from the economy @@ -104,14 +102,12 @@ def mystr(number): if solve_markov_micro or solve_markov_market or solve_krusell_smith: # Make a Markov aggregate shocks consumer type - AggShockMrkvExample = AggShockMarkovConsumerType(**Params.init_agg_mrkv_shocks) + AggShockMrkvExample = AggShockMarkovConsumerType() AggShockMrkvExample.IncomeDstn[0] = 2 * [AggShockMrkvExample.IncomeDstn[0]] AggShockMrkvExample.cycles = 0 # Make a Cobb-Douglas economy for the agents - MrkvEconomyExample = CobbDouglasMarkovEconomy( - agents=[AggShockMrkvExample], **Params.init_mrkv_cobb_douglas - ) + MrkvEconomyExample = CobbDouglasMarkovEconomy(agents=[AggShockMrkvExample]) MrkvEconomyExample.DampingFac = 0.2 # Turn down damping MrkvEconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks AggShockMrkvExample.getEconomyData( @@ -223,16 +219,14 @@ def mystr(number): PolyMrkvArray[StateCount - 1, StateCount - 1] += 0.5 * (1.0 - Persistence) # Make a consumer type to inhabit the economy - PolyStateExample = AggShockMarkovConsumerType(**Params.init_agg_mrkv_shocks) + PolyStateExample = AggShockMarkovConsumerType() PolyStateExample.MrkvArray = PolyMrkvArray PolyStateExample.PermGroFacAgg = PermGroFacAgg PolyStateExample.IncomeDstn[0] = StateCount * [PolyStateExample.IncomeDstn[0]] PolyStateExample.cycles = 0 # Make a Cobb-Douglas economy for the agents - PolyStateEconomy = CobbDouglasMarkovEconomy( - agents=[PolyStateExample], **Params.init_mrkv_cobb_douglas - ) + PolyStateEconomy = CobbDouglasMarkovEconomy(agents=[PolyStateExample]) PolyStateEconomy.MrkvArray = PolyMrkvArray PolyStateEconomy.PermGroFacAgg = PermGroFacAgg PolyStateEconomy.PermShkAggStd = StateCount * [0.006] diff --git a/HARK/ConsumptionSaving/example_ConsGenIncProcessModel.py b/HARK/ConsumptionSaving/example_ConsGenIncProcessModel.py index a41c00abc..77fedcb8f 100644 --- a/HARK/ConsumptionSaving/example_ConsGenIncProcessModel.py +++ b/HARK/ConsumptionSaving/example_ConsGenIncProcessModel.py @@ -35,7 +35,7 @@ def mystr(number): ) # Make and solve an example "explicit permanent income" consumer with idiosyncratic shocks -ExplicitExample = IndShockExplicitPermIncConsumerType(**Params.init_explicit_perm_inc) +ExplicitExample = IndShockExplicitPermIncConsumerType() t_start = process_time() ExplicitExample.solve() t_end = process_time() diff --git a/HARK/ConsumptionSaving/example_ConsIndShock.py b/HARK/ConsumptionSaving/example_ConsIndShock.py index 1f1dc31ff..2544edc54 100644 --- a/HARK/ConsumptionSaving/example_ConsIndShock.py +++ b/HARK/ConsumptionSaving/example_ConsIndShock.py @@ -9,7 +9,7 @@ do_simulation = True # Make and solve an example perfect foresight consumer -PFexample = PerfForesightConsumerType(**Params.init_perfect_foresight) +PFexample = PerfForesightConsumerType() PFexample.cycles = 0 # Make this type have an infinite horizon start_time = time() @@ -32,7 +32,7 @@ "" # Make and solve an example consumer with idiosyncratic income shocks -IndShockExample = IndShockConsumerType(**Params.init_idiosyncratic_shocks) +IndShockExample = IndShockConsumerType() IndShockExample.cycles = 0 # Make this type have an infinite horizon start_time = time() @@ -124,7 +124,7 @@ "" # Make and solve an agent with a kinky interest rate -KinkyExample = KinkedRconsumerType(**Params.init_kinked_R) +KinkyExample = KinkedRconsumerType() KinkyExample.cycles = 0 # Make the Example infinite horizon start_time = time() diff --git a/HARK/ConsumptionSaving/example_ConsMedModel.py b/HARK/ConsumptionSaving/example_ConsMedModel.py index c1e853c8e..23a295f32 100644 --- a/HARK/ConsumptionSaving/example_ConsMedModel.py +++ b/HARK/ConsumptionSaving/example_ConsMedModel.py @@ -10,7 +10,7 @@ do_simulation = True # Make and solve an example medical shocks consumer type -MedicalExample = MedShockConsumerType(**Params.init_medical_shocks) +MedicalExample = MedShockConsumerType() t_start = process_time() MedicalExample.solve() t_end = process_time() diff --git a/HARK/ConsumptionSaving/example_ConsPrefShockModel.py b/HARK/ConsumptionSaving/example_ConsPrefShockModel.py index 07811dd25..aa0c48e38 100644 --- a/HARK/ConsumptionSaving/example_ConsPrefShockModel.py +++ b/HARK/ConsumptionSaving/example_ConsPrefShockModel.py @@ -13,7 +13,7 @@ do_simulation = True # Make and solve a preference shock consumer -PrefShockExample = PrefShockConsumerType(**Params.init_preference_shocks) +PrefShockExample = PrefShockConsumerType() PrefShockExample.cycles = 0 # Infinite horizon t_start = process_time() @@ -60,7 +60,7 @@ ########################################################################### # Make and solve a "kinky preferece" consumer, whose model combines KinkedR and PrefShock -KinkyPrefExample = KinkyPrefConsumerType(**Params.init_kinky_pref) +KinkyPrefExample = KinkyPrefConsumerType() KinkyPrefExample.cycles = 0 # Infinite horizon t_start = process_time() From ea56ea6b8c241fa267b56c83158c9b5a23f93f1e Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Sun, 19 Jan 2020 22:50:24 +0530 Subject: [PATCH 14/43] move examples to ipython notebooks with jupytext --- HARK/ConsumptionSaving/__init__.py | 11 +- HARK/__init__.py | 5 +- .../example_ConsAggShockModel.ipynb | 479 +++++++++++++++ .../example_ConsAggShockModel.py | 39 +- .../example_ConsGenIncProcessModel.ipynb | 458 ++++++++++++++ .../example_ConsGenIncProcessModel.py | 6 +- .../example_ConsIndShock.ipynb | 566 ++++++++++++++++++ .../ConsumptionSaving/example_ConsIndShock.py | 112 ++-- .../example_ConsMarkovModel.ipynb | 492 +++++++++++++++ .../example_ConsMarkovModel.py | 8 - .../example_ConsMedModel.ipynb | 313 ++++++++++ .../ConsumptionSaving/example_ConsMedModel.py | 10 +- .../example_ConsPrefShockModel.ipynb | 316 ++++++++++ .../example_ConsPrefShockModel.py | 4 - .../example_ConsRepAgentModel.ipynb | 202 +++++++ .../example_ConsRepAgentModel.py | 18 +- .../example_TractableBufferStockModel.ipynb | 277 +++++++++ .../example_TractableBufferStockModel.py | 1 - 18 files changed, 3210 insertions(+), 107 deletions(-) create mode 100644 examples/ConsumptionSaving/example_ConsAggShockModel.ipynb rename {HARK => examples}/ConsumptionSaving/example_ConsAggShockModel.py (91%) create mode 100644 examples/ConsumptionSaving/example_ConsGenIncProcessModel.ipynb rename {HARK => examples}/ConsumptionSaving/example_ConsGenIncProcessModel.py (98%) create mode 100644 examples/ConsumptionSaving/example_ConsIndShock.ipynb rename {HARK => examples}/ConsumptionSaving/example_ConsIndShock.py (50%) create mode 100644 examples/ConsumptionSaving/example_ConsMarkovModel.ipynb rename {HARK => examples}/ConsumptionSaving/example_ConsMarkovModel.py (97%) create mode 100644 examples/ConsumptionSaving/example_ConsMedModel.ipynb rename {HARK => examples}/ConsumptionSaving/example_ConsMedModel.py (95%) create mode 100644 examples/ConsumptionSaving/example_ConsPrefShockModel.ipynb rename {HARK => examples}/ConsumptionSaving/example_ConsPrefShockModel.py (97%) create mode 100644 examples/ConsumptionSaving/example_ConsRepAgentModel.ipynb rename {HARK => examples}/ConsumptionSaving/example_ConsRepAgentModel.py (89%) create mode 100644 examples/ConsumptionSaving/example_TractableBufferStockModel.ipynb rename {HARK => examples}/ConsumptionSaving/example_TractableBufferStockModel.py (99%) diff --git a/HARK/ConsumptionSaving/__init__.py b/HARK/ConsumptionSaving/__init__.py index 43c3e7b4d..99245567a 100644 --- a/HARK/ConsumptionSaving/__init__.py +++ b/HARK/ConsumptionSaving/__init__.py @@ -1 +1,10 @@ -from .ConsIndShockModel import * \ No newline at end of file +from HARK.ConsumptionSaving.ConsAggShockModel import * +from HARK.ConsumptionSaving.ConsGenIncProcessModel import * +from HARK.ConsumptionSaving.ConsIndShockModel import * +from HARK.ConsumptionSaving.ConsMarkovModel import * +from HARK.ConsumptionSaving.ConsMedModel import * +from HARK.ConsumptionSaving.ConsPortfolioModel import * +from HARK.ConsumptionSaving.ConsPrefShockModel import * +from HARK.ConsumptionSaving.ConsRepAgentModel import * +from HARK.ConsumptionSaving.TractableBufferStockModel import * +from HARK.ConsumptionSaving.ConsumerParameters import * diff --git a/HARK/__init__.py b/HARK/__init__.py index bbfa2eb63..44f72023a 100644 --- a/HARK/__init__.py +++ b/HARK/__init__.py @@ -1,4 +1,3 @@ -from __future__ import absolute_import -from .core import * - +from HARK.core import * +from HARK.ConsumptionSaving import * __version__ = '0.10.3' diff --git a/examples/ConsumptionSaving/example_ConsAggShockModel.ipynb b/examples/ConsumptionSaving/example_ConsAggShockModel.ipynb new file mode 100644 index 000000000..30257be30 --- /dev/null +++ b/examples/ConsumptionSaving/example_ConsAggShockModel.ipynb @@ -0,0 +1,479 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import HARK.ConsumptionSaving.ConsumerParameters as Params\n", + "from time import process_time\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from HARK.utilities import plotFuncs\n", + "from HARK.ConsumptionSaving.ConsAggShockModel import (\n", + " AggShockConsumerType,\n", + " CobbDouglasEconomy,\n", + " AggShockMarkovConsumerType,\n", + " CobbDouglasMarkovEconomy,\n", + ")\n", + "from copy import deepcopy\n", + "def mystr(number):\n", + " return \"{:.4f}\".format(number)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Solve an AggShockConsumerType's microeconomic problem\n", + "solve_agg_shocks_micro = False\n", + "# Solve for the equilibrium aggregate saving rule in a CobbDouglasEconomy\n", + "solve_agg_shocks_market = True\n", + "# Solve an AggShockMarkovConsumerType's microeconomic problem\n", + "solve_markov_micro = False\n", + "# Solve for the equilibrium aggregate saving rule in a CobbDouglasMarkovEconomy\n", + "solve_markov_market = True\n", + "# Solve a simple Krusell-Smith-style two state, two shock model\n", + "solve_krusell_smith = True\n", + "# Solve a CobbDouglasEconomy with many states, potentially utilizing the \"state jumper\"\n", + "solve_poly_state = False" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example impelementation of AggShockConsumerType" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "if solve_agg_shocks_micro or solve_agg_shocks_market:\n", + " # Make an aggregate shocks consumer type\n", + " AggShockExample = AggShockConsumerType()\n", + " AggShockExample.cycles = 0\n", + "\n", + " # Make a Cobb-Douglas economy for the agents\n", + " EconomyExample = CobbDouglasEconomy(agents=[AggShockExample])\n", + " EconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks\n", + "\n", + " # Have the consumers inherit relevant objects from the economy\n", + " AggShockExample.getEconomyData(EconomyExample)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "if solve_agg_shocks_micro:\n", + " # Solve the microeconomic model for the aggregate shocks example type (and display results)\n", + " t_start = process_time()\n", + " AggShockExample.solve()\n", + " t_end = process_time()\n", + " print(\n", + " \"Solving an aggregate shocks consumer took \"\n", + " + mystr(t_end - t_start)\n", + " + \" seconds.\"\n", + " )\n", + " print(\n", + " \"Consumption function at each aggregate market resources-to-labor ratio gridpoint:\"\n", + " )\n", + " m_grid = np.linspace(0, 10, 200)\n", + " AggShockExample.unpackcFunc()\n", + " for M in AggShockExample.Mgrid.tolist():\n", + " mMin = AggShockExample.solution[0].mNrmMin(M)\n", + " c_at_this_M = AggShockExample.cFunc[0](m_grid + mMin, M * np.ones_like(m_grid))\n", + " plt.plot(m_grid + mMin, c_at_this_M)\n", + " plt.ylim(0.0, None)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Now solving for the equilibrium of a Cobb-Douglas economy. This might take a few minutes...\n", + "intercept=-0.343892431186286, slope=1.104593288292029, r-sq=0.9968896217612445\n", + "intercept=-0.5036317603080784, slope=1.1516307652306579, r-sq=0.99558993623854\n", + "intercept=-0.45781284276113077, slope=1.1150500956007625, r-sq=0.9761544937568223\n", + "intercept=-0.3871208372015027, slope=1.0853000270407058, r-sq=0.9820100342330428\n", + "intercept=-0.3646746874098119, slope=1.0763760421084498, r-sq=0.9856903333255791\n", + "intercept=-0.3548104709407357, slope=1.07250161746339, r-sq=0.9860331018283293\n", + "intercept=-0.3504754703630661, slope=1.070813036044259, r-sq=0.9861654830885628\n", + "intercept=-0.3485780110442094, slope=1.0700786458110867, r-sq=0.9862204148294936\n", + "intercept=-0.3477516010972477, slope=1.0697604492756763, r-sq=0.9862437414876912\n", + "intercept=-0.34739343564383973, slope=1.0696231406893215, r-sq=0.986253720644644\n", + "intercept=-0.34723891990561373, slope=1.069564121912548, r-sq=0.9862579935066507\n", + "intercept=-0.34717253299479095, slope=1.069538844447615, r-sq=0.9862598203445164\n", + "Solving the \"macroeconomic\" aggregate shocks model took 472.744824 seconds.\n", + "Aggregate savings as a function of aggregate market resources:\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/ms/dev/HARK/HARK/ConsumptionSaving/ConsAggShockModel.py:1769: RuntimeWarning: divide by zero encountered in log\n", + " Aagg = np.exp(self.intercept + self.slope*np.log(Mnow))\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption function at each aggregate market resources gridpoint (in general equilibrium):\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "if solve_agg_shocks_market:\n", + " # Solve the \"macroeconomic\" model by searching for a \"fixed point dynamic rule\"\n", + " t_start = process_time()\n", + " print(\n", + " \"Now solving for the equilibrium of a Cobb-Douglas economy. This might take a few minutes...\"\n", + " )\n", + " EconomyExample.solve()\n", + " t_end = process_time()\n", + " print(\n", + " 'Solving the \"macroeconomic\" aggregate shocks model took '\n", + " + str(t_end - t_start)\n", + " + \" seconds.\"\n", + " )\n", + "\n", + " print(\"Aggregate savings as a function of aggregate market resources:\")\n", + " plotFuncs(EconomyExample.AFunc, 0, 2 * EconomyExample.kSS)\n", + " print(\n", + " \"Consumption function at each aggregate market resources gridpoint (in general equilibrium):\"\n", + " )\n", + " AggShockExample.unpackcFunc()\n", + " m_grid = np.linspace(0, 10, 200)\n", + " AggShockExample.unpackcFunc()\n", + " for M in AggShockExample.Mgrid.tolist():\n", + " mMin = AggShockExample.solution[0].mNrmMin(M)\n", + " c_at_this_M = AggShockExample.cFunc[0](m_grid + mMin, M * np.ones_like(m_grid))\n", + " plt.plot(m_grid + mMin, c_at_this_M)\n", + " plt.ylim(0.0, None)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example Implementations of AggShockMarkovConsumerType" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "if solve_markov_micro or solve_markov_market or solve_krusell_smith:\n", + " # Make a Markov aggregate shocks consumer type\n", + " AggShockMrkvExample = AggShockMarkovConsumerType()\n", + " AggShockMrkvExample.IncomeDstn[0] = 2 * [AggShockMrkvExample.IncomeDstn[0]]\n", + " AggShockMrkvExample.cycles = 0\n", + "\n", + " # Make a Cobb-Douglas economy for the agents\n", + " MrkvEconomyExample = CobbDouglasMarkovEconomy(agents=[AggShockMrkvExample])\n", + " MrkvEconomyExample.DampingFac = 0.2 # Turn down damping\n", + " MrkvEconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks\n", + " AggShockMrkvExample.getEconomyData(\n", + " MrkvEconomyExample\n", + " ) # Have the consumers inherit relevant objects from the economy" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "if solve_markov_micro:\n", + " # Solve the microeconomic model for the Markov aggregate shocks example type (and display results)\n", + " t_start = process_time()\n", + " AggShockMrkvExample.solve()\n", + " t_end = process_time()\n", + " print(\n", + " \"Solving an aggregate shocks Markov consumer took \"\n", + " + mystr(t_end - t_start)\n", + " + \" seconds.\"\n", + " )\n", + "\n", + " print(\n", + " \"Consumption function at each aggregate market \\\n", + " resources-to-labor ratio gridpoint (for each macro state):\"\n", + " )\n", + " m_grid = np.linspace(0, 10, 200)\n", + " AggShockMrkvExample.unpackcFunc()\n", + " for i in range(2):\n", + " for M in AggShockMrkvExample.Mgrid.tolist():\n", + " mMin = AggShockMrkvExample.solution[0].mNrmMin[i](M)\n", + " c_at_this_M = AggShockMrkvExample.cFunc[0][i](\n", + " m_grid + mMin, M * np.ones_like(m_grid)\n", + " )\n", + " plt.plot(m_grid + mMin, c_at_this_M)\n", + " plt.ylim(0.0, None)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Now solving a two-state Markov economy. This should take a few minutes...\n", + "intercept=[-0.45457028863479326, -0.5608165406907654], slope=[1.1215368972825372, 1.178334499213271], r-sq=[0.9981555551235348, 0.9936211956825644]\n", + "intercept=[-0.39063438982463117, -0.44292984675023017], slope=[1.0773896585972575, 1.0964491558602392], r-sq=[0.9998539446156635, 0.9996166998511072]\n", + "intercept=[-0.3375826098429694, -0.38469230352004224], slope=[1.0657220737945672, 1.0800826397775194], r-sq=[0.999923540564709, 0.999893702729503]\n", + "intercept=[-0.34438955842820446, -0.3938944194405977], slope=[1.0688335020439343, 1.0837845833652027], r-sq=[0.9999202360448058, 0.9998929405844074]\n", + "intercept=[-0.34513135214708335, -0.39438330618459266], slope=[1.0691336344455975, 1.0839898637364869], r-sq=[0.9999195924017966, 0.9998911821689769]\n", + "intercept=[-0.3452067391631015, -0.39440757767055756], slope=[1.0691611379897035, 1.084000818643343], r-sq=[0.9999195629192332, 0.9998910731648093]\n", + "Solving the \"macroeconomic\" aggregate shocks model took 392.50628099999994 seconds.\n", + "Consumption function at each aggregate market resources-to-labor ratio gridpoint (for each macro state):\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "if solve_markov_market:\n", + " # Solve the \"macroeconomic\" model by searching for a \"fixed point dynamic rule\"\n", + " t_start = process_time()\n", + " print(\"Now solving a two-state Markov economy. This should take a few minutes...\")\n", + " MrkvEconomyExample.solve()\n", + " t_end = process_time()\n", + " print(\n", + " 'Solving the \"macroeconomic\" aggregate shocks model took '\n", + " + str(t_end - t_start)\n", + " + \" seconds.\"\n", + " )\n", + "\n", + " print(\n", + " \"Consumption function at each aggregate market \\\n", + " resources-to-labor ratio gridpoint (for each macro state):\"\n", + " )\n", + " m_grid = np.linspace(0, 10, 200)\n", + " AggShockMrkvExample.unpackcFunc()\n", + " for i in range(2):\n", + " for M in AggShockMrkvExample.Mgrid.tolist():\n", + " mMin = AggShockMrkvExample.solution[0].mNrmMin[i](M)\n", + " c_at_this_M = AggShockMrkvExample.cFunc[0][i](\n", + " m_grid + mMin, M * np.ones_like(m_grid)\n", + " )\n", + " plt.plot(m_grid + mMin, c_at_this_M)\n", + " plt.ylim(0.0, None)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Now solving a Krusell-Smith-style economy. This should take about a minute...\n", + "intercept=[-0.6947798030939067, -0.6496080139025368], slope=[1.2149258628023265, 1.1997576240565722], r-sq=[0.9956715905392765, 0.9984824428718454]\n", + "intercept=[-0.3135251476096542, -0.3116229188271141], slope=[1.0431538367667323, 1.045596516196599], r-sq=[0.999962275011029, 0.9998598754299896]\n", + "intercept=[-0.35426968141472726, -0.34868612541912086], slope=[1.0690330861718151, 1.0684800597781756], r-sq=[0.9999980358752275, 0.9999953386182767]\n", + "intercept=[-0.37865592267297, -0.37059636120492523], slope=[1.0786086418446077, 1.0771335410485183], r-sq=[0.9999974645062959, 0.9999922753180536]\n", + "intercept=[-0.37949767811432283, -0.3713660319920014], slope=[1.0789208379791293, 1.0774420381883525], r-sq=[0.9999974136333588, 0.999991775874947]\n", + "intercept=[-0.37949650721764533, -0.3713757146425346], slope=[1.0789185711548974, 1.077446724524536], r-sq=[0.9999974136627449, 0.9999917639921949]\n", + "Solving the Krusell-Smith model took 105.49309900000003 seconds.\n" + ] + } + ], + "source": [ + "if solve_krusell_smith:\n", + " # Make a Krusell-Smith agent type\n", + " # NOTE: These agents aren't exactly like KS, as they don't have serially correlated unemployment\n", + " KSexampleType = deepcopy(AggShockMrkvExample)\n", + " KSexampleType.IncomeDstn[0] = [\n", + " [np.array([0.96, 0.04]), np.array([1.0, 1.0]), np.array([1.0 / 0.96, 0.0])],\n", + " [np.array([0.90, 0.10]), np.array([1.0, 1.0]), np.array([1.0 / 0.90, 0.0])],\n", + " ]\n", + "\n", + " # Make a KS economy\n", + " KSeconomy = deepcopy(MrkvEconomyExample)\n", + " KSeconomy.agents = [KSexampleType]\n", + " KSeconomy.AggShkDstn = [\n", + " [np.array([1.0]), np.array([1.0]), np.array([1.05])],\n", + " [np.array([1.0]), np.array([1.0]), np.array([0.95])],\n", + " ]\n", + " KSeconomy.PermGroFacAgg = [1.0, 1.0]\n", + " KSexampleType.getEconomyData(KSeconomy)\n", + " KSeconomy.makeAggShkHist()\n", + "\n", + " # Solve the K-S model\n", + " t_start = process_time()\n", + " print(\n", + " \"Now solving a Krusell-Smith-style economy. This should take about a minute...\"\n", + " )\n", + " KSeconomy.solve()\n", + " t_end = process_time()\n", + " print(\"Solving the Krusell-Smith model took \" + str(t_end - t_start) + \" seconds.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "if solve_poly_state:\n", + " StateCount = 15 # Number of Markov states\n", + " GrowthAvg = 1.01 # Average permanent income growth factor\n", + " GrowthWidth = 0.02 # PermGroFacAgg deviates from PermGroFacAgg in this range\n", + " Persistence = 0.90 # Probability of staying in the same Markov state\n", + " PermGroFacAgg = np.linspace(\n", + " GrowthAvg - GrowthWidth, GrowthAvg + GrowthWidth, num=StateCount\n", + " )\n", + "\n", + " # Make the Markov array with chosen states and persistence\n", + " PolyMrkvArray = np.zeros((StateCount, StateCount))\n", + " for i in range(StateCount):\n", + " for j in range(StateCount):\n", + " if i == j:\n", + " PolyMrkvArray[i, j] = Persistence\n", + " elif (i == (j - 1)) or (i == (j + 1)):\n", + " PolyMrkvArray[i, j] = 0.5 * (1.0 - Persistence)\n", + " PolyMrkvArray[0, 0] += 0.5 * (1.0 - Persistence)\n", + " PolyMrkvArray[StateCount - 1, StateCount - 1] += 0.5 * (1.0 - Persistence)\n", + "\n", + " # Make a consumer type to inhabit the economy\n", + " PolyStateExample = AggShockMarkovConsumerType()\n", + " PolyStateExample.MrkvArray = PolyMrkvArray\n", + " PolyStateExample.PermGroFacAgg = PermGroFacAgg\n", + " PolyStateExample.IncomeDstn[0] = StateCount * [PolyStateExample.IncomeDstn[0]]\n", + " PolyStateExample.cycles = 0\n", + "\n", + " # Make a Cobb-Douglas economy for the agents\n", + " # Use verbose=False to remove printing of intercept\n", + " PolyStateEconomy = CobbDouglasMarkovEconomy(agents=[PolyStateExample], verbose=False)\n", + " PolyStateEconomy.MrkvArray = PolyMrkvArray\n", + " PolyStateEconomy.PermGroFacAgg = PermGroFacAgg\n", + " PolyStateEconomy.PermShkAggStd = StateCount * [0.006]\n", + " PolyStateEconomy.TranShkAggStd = StateCount * [0.003]\n", + " PolyStateEconomy.slope_prev = StateCount * [1.0]\n", + " PolyStateEconomy.intercept_prev = StateCount * [0.0]\n", + " PolyStateEconomy.update()\n", + " PolyStateEconomy.makeAggShkDstn()\n", + " PolyStateEconomy.makeAggShkHist() # Simulate a history of aggregate shocks\n", + " PolyStateExample.getEconomyData(\n", + " PolyStateEconomy\n", + " ) # Have the consumers inherit relevant objects from the economy\n", + "\n", + " # Solve the many state model\n", + " t_start = process_time()\n", + " print(\n", + " \"Now solving an economy with \"\n", + " + str(StateCount)\n", + " + \" Markov states. This might take a while...\"\n", + " )\n", + " PolyStateEconomy.solve()\n", + " t_end = process_time()\n", + " print(\n", + " \"Solving a model with \"\n", + " + str(StateCount)\n", + " + \" states took \"\n", + " + str(t_end - t_start)\n", + " + \" seconds.\"\n", + " )" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + }, + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/HARK/ConsumptionSaving/example_ConsAggShockModel.py b/examples/ConsumptionSaving/example_ConsAggShockModel.py similarity index 91% rename from HARK/ConsumptionSaving/example_ConsAggShockModel.py rename to examples/ConsumptionSaving/example_ConsAggShockModel.py index 11f978408..bf528a173 100644 --- a/HARK/ConsumptionSaving/example_ConsAggShockModel.py +++ b/examples/ConsumptionSaving/example_ConsAggShockModel.py @@ -9,31 +9,25 @@ AggShockMarkovConsumerType, CobbDouglasMarkovEconomy, ) - - +from copy import deepcopy def mystr(number): return "{:.4f}".format(number) -solve_agg_shocks_micro = False # Solve an AggShockConsumerType's microeconomic problem -solve_agg_shocks_market = ( - True -) # Solve for the equilibrium aggregate saving rule in a CobbDouglasEconomy - -solve_markov_micro = ( - False -) # Solve an AggShockMarkovConsumerType's microeconomic problem -solve_markov_market = ( - True -) # Solve for the equilibrium aggregate saving rule in a CobbDouglasMarkovEconomy -solve_krusell_smith = ( - True -) # Solve a simple Krusell-Smith-style two state, two shock model -solve_poly_state = ( - False -) # Solve a CobbDouglasEconomy with many states, potentially utilizing the "state jumper" +# Solve an AggShockConsumerType's microeconomic problem +solve_agg_shocks_micro = False +# Solve for the equilibrium aggregate saving rule in a CobbDouglasEconomy +solve_agg_shocks_market = True +# Solve an AggShockMarkovConsumerType's microeconomic problem +solve_markov_micro = False +# Solve for the equilibrium aggregate saving rule in a CobbDouglasMarkovEconomy +solve_markov_market = True +# Solve a simple Krusell-Smith-style two state, two shock model +solve_krusell_smith = True +# Solve a CobbDouglasEconomy with many states, potentially utilizing the "state jumper" +solve_poly_state = True -# EXAMPLE IMPLEMENTATIONS OF AggShockConsumerType ### +# ### Example impelementation of AggShockConsumerType if solve_agg_shocks_micro or solve_agg_shocks_market: # Make an aggregate shocks consumer type @@ -98,7 +92,7 @@ def mystr(number): plt.ylim(0.0, None) plt.show() -# EXAMPLE IMPLEMENTATIONS OF AggShockMarkovConsumerType # +# ### Example Implementations of AggShockMarkovConsumerType if solve_markov_micro or solve_markov_market or solve_krusell_smith: # Make a Markov aggregate shocks consumer type @@ -226,7 +220,8 @@ def mystr(number): PolyStateExample.cycles = 0 # Make a Cobb-Douglas economy for the agents - PolyStateEconomy = CobbDouglasMarkovEconomy(agents=[PolyStateExample]) + # Use verbose=False to remove printing of intercept + PolyStateEconomy = CobbDouglasMarkovEconomy(agents=[PolyStateExample], verbose=False) PolyStateEconomy.MrkvArray = PolyMrkvArray PolyStateEconomy.PermGroFacAgg = PermGroFacAgg PolyStateEconomy.PermShkAggStd = StateCount * [0.006] diff --git a/examples/ConsumptionSaving/example_ConsGenIncProcessModel.ipynb b/examples/ConsumptionSaving/example_ConsGenIncProcessModel.ipynb new file mode 100644 index 000000000..238f7e01f --- /dev/null +++ b/examples/ConsumptionSaving/example_ConsGenIncProcessModel.ipynb @@ -0,0 +1,458 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import HARK.ConsumptionSaving.ConsumerParameters as Params\n", + "from HARK.utilities import plotFuncs\n", + "from time import process_time\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from HARK.ConsumptionSaving.ConsGenIncProcessModel import (\n", + " IndShockExplicitPermIncConsumerType,\n", + " IndShockConsumerType,\n", + " PersistentShockConsumerType,\n", + ")\n", + "def mystr(number):\n", + " return \"{:.4f}\".format(number)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "do_simulation = True" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The infinite horizon examples presented here use a grid of persistent income levels (pLvlGrid)\n", + "based on percentiles of the long run distribution of pLvl for the given parameters. These percentiles\n", + "are specified in the attribute pLvlPctiles. Here, the lowest percentile is 0.1 and the highest\n", + "percentile is 99.9.\n", + "\n" + ] + } + ], + "source": [ + "# Display information about the pLvlGrid used in these examples\n", + "print(\n", + " \"The infinite horizon examples presented here use a grid of persistent income levels (pLvlGrid)\"\n", + ")\n", + "print(\n", + " \"based on percentiles of the long run distribution of pLvl for the given parameters. These percentiles\"\n", + ")\n", + "print(\n", + " \"are specified in the attribute pLvlPctiles. Here, the lowest percentile is \"\n", + " + str(Params.init_explicit_perm_inc[\"pLvlPctiles\"][0] * 100)\n", + " + \" and the highest\"\n", + ")\n", + "print(\n", + " \"percentile is \"\n", + " + str(Params.init_explicit_perm_inc[\"pLvlPctiles\"][-1] * 100)\n", + " + \".\\n\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving an explicit permanent income consumer took 24.5819 seconds.\n" + ] + } + ], + "source": [ + "# Make and solve an example \"explicit permanent income\" consumer with idiosyncratic shocks\n", + "ExplicitExample = IndShockExplicitPermIncConsumerType()\n", + "t_start = process_time()\n", + "ExplicitExample.solve()\n", + "t_end = process_time()\n", + "print(\n", + " \"Solving an explicit permanent income consumer took \"\n", + " + mystr(t_end - t_start)\n", + " + \" seconds.\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption function by pLvl for explicit permanent income consumer:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function at various permanent income levels\n", + "print(\"Consumption function by pLvl for explicit permanent income consumer:\")\n", + "pLvlGrid = ExplicitExample.pLvlGrid[0]\n", + "mLvlGrid = np.linspace(0, 20, 300)\n", + "for p in pLvlGrid:\n", + " M_temp = mLvlGrid + ExplicitExample.solution[0].mLvlMin(p)\n", + " C = ExplicitExample.solution[0].cFunc(M_temp, p * np.ones_like(M_temp))\n", + " plt.plot(M_temp, C)\n", + "plt.xlim(0.0, 20.0)\n", + "plt.ylim(0.0, None)\n", + "plt.xlabel(\"Market resource level mLvl\")\n", + "plt.ylabel(\"Consumption level cLvl\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving the equivalent problem with permanent income normalized out took 0.0028 seconds.\n" + ] + } + ], + "source": [ + "# Now solve the *exact same* problem, but with the permanent income normalization\n", + "NormalizedExample = IndShockConsumerType(**Params.init_explicit_perm_inc)\n", + "t_start = process_time()\n", + "NormalizedExample.solve()\n", + "t_end = process_time()\n", + "print(\n", + " \"Solving the equivalent problem with permanent income normalized out took \"\n", + " + mystr(t_end - t_start)\n", + " + \" seconds.\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Normalized consumption function by pLvl for explicit permanent income consumer:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption function for normalized problem (without explicit permanent income):\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Show that the normalized consumption function for the \"explicit permanent income\" consumer\n", + "# is almost identical for every permanent income level (and the same as the normalized problem's\n", + "# cFunc), but is less accurate due to extrapolation outside the bounds of pLvlGrid.\n", + "print(\"Normalized consumption function by pLvl for explicit permanent income consumer:\")\n", + "pLvlGrid = ExplicitExample.pLvlGrid[0]\n", + "mNrmGrid = np.linspace(0, 20, 300)\n", + "for p in pLvlGrid:\n", + " M_temp = mNrmGrid * p + ExplicitExample.solution[0].mLvlMin(p)\n", + " C = ExplicitExample.solution[0].cFunc(M_temp, p * np.ones_like(M_temp))\n", + " plt.plot(M_temp / p, C / p)\n", + "plt.xlim(0.0, 20.0)\n", + "plt.ylim(0.0, None)\n", + "plt.xlabel(\"Normalized market resources mNrm\")\n", + "plt.ylabel(\"Normalized consumption cNrm\")\n", + "plt.show()\n", + "print(\n", + " \"Consumption function for normalized problem (without explicit permanent income):\"\n", + ")\n", + "mNrmMin = NormalizedExample.solution[0].mNrmMin\n", + "plotFuncs(NormalizedExample.solution[0].cFunc, mNrmMin, mNrmMin + 20)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The \"explicit permanent income\" solution deviates from the solution to the normalized problem because\n", + "of errors from extrapolating beyond the bounds of the pLvlGrid. The error is largest for pLvl values\n", + "near the upper and lower bounds, and propagates toward the center of the distribution.\n", + "\n" + ] + } + ], + "source": [ + "print(\n", + " 'The \"explicit permanent income\" solution deviates from the solution to the normalized problem because'\n", + ")\n", + "print(\n", + " \"of errors from extrapolating beyond the bounds of the pLvlGrid. The error is largest for pLvl values\"\n", + ")\n", + "print(\n", + " \"near the upper and lower bounds, and propagates toward the center of the distribution.\\n\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Plot the value function at various permanent income levels\n", + "if ExplicitExample.vFuncBool:\n", + " pGrid = np.linspace(0.1, 3.0, 24)\n", + " M = np.linspace(0.001, 5, 300)\n", + " for p in pGrid:\n", + " M_temp = M + ExplicitExample.solution[0].mLvlMin(p)\n", + " C = ExplicitExample.solution[0].vFunc(M_temp, p * np.ones_like(M_temp))\n", + " plt.plot(M_temp, C)\n", + " plt.ylim([-200, 0])\n", + " plt.xlabel(\"Market resource level mLvl\")\n", + " plt.ylabel(\"Value v\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Simulate some data\n", + "if do_simulation:\n", + " ExplicitExample.T_sim = 500\n", + " ExplicitExample.track_vars = [\"mLvlNow\", \"cLvlNow\", \"pLvlNow\"]\n", + " ExplicitExample.makeShockHistory() # This is optional\n", + " ExplicitExample.initializeSim()\n", + " ExplicitExample.simulate()\n", + " plt.plot(np.mean(ExplicitExample.mLvlNow_hist, axis=1))\n", + " plt.xlabel(\"Simulated time period\")\n", + " plt.ylabel(\"Average market resources mLvl\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a persistent income shocks consumer took 21.1527 seconds.\n" + ] + } + ], + "source": [ + "# Make and solve an example \"persistent idisyncratic shocks\" consumer\n", + "PersistentExample = PersistentShockConsumerType(**Params.init_persistent_shocks)\n", + "t_start = process_time()\n", + "PersistentExample.solve()\n", + "t_end = process_time()\n", + "print(\n", + " \"Solving a persistent income shocks consumer took \"\n", + " + mystr(t_end - t_start)\n", + " + \" seconds.\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption function by persistent income level pLvl for a consumer with AR1 coefficient of 0.98:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function at various levels of persistent income pLvl\n", + "print(\n", + " \"Consumption function by persistent income level pLvl for a consumer with AR1 coefficient of \"\n", + " + str(PersistentExample.PrstIncCorr)\n", + " + \":\"\n", + ")\n", + "pLvlGrid = PersistentExample.pLvlGrid[0]\n", + "mLvlGrid = np.linspace(0, 20, 300)\n", + "for p in pLvlGrid:\n", + " M_temp = mLvlGrid + PersistentExample.solution[0].mLvlMin(p)\n", + " C = PersistentExample.solution[0].cFunc(M_temp, p * np.ones_like(M_temp))\n", + " plt.plot(M_temp, C)\n", + "plt.xlim(0.0, 20.0)\n", + "plt.ylim(0.0, None)\n", + "plt.xlabel(\"Market resource level mLvl\")\n", + "plt.ylabel(\"Consumption level cLvl\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Plot the value function at various persistent income levels\n", + "if PersistentExample.vFuncBool:\n", + " pGrid = PersistentExample.pLvlGrid[0]\n", + " M = np.linspace(0.001, 5, 300)\n", + " for p in pGrid:\n", + " M_temp = M + PersistentExample.solution[0].mLvlMin(p)\n", + " C = PersistentExample.solution[0].vFunc(M_temp, p * np.ones_like(M_temp))\n", + " plt.plot(M_temp, C)\n", + " plt.ylim([-200, 0])\n", + " plt.xlabel(\"Market resource level mLvl\")\n", + " plt.ylabel(\"Value v\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Simulate some data\n", + "if do_simulation:\n", + " PersistentExample.T_sim = 500\n", + " PersistentExample.track_vars = [\"mLvlNow\", \"cLvlNow\", \"pLvlNow\"]\n", + " PersistentExample.initializeSim()\n", + " PersistentExample.simulate()\n", + " plt.plot(np.mean(PersistentExample.mLvlNow_hist, axis=1))\n", + " plt.xlabel(\"Simulated time period\")\n", + " plt.ylabel(\"Average market resources mLvl\")\n", + " plt.show()" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + }, + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/HARK/ConsumptionSaving/example_ConsGenIncProcessModel.py b/examples/ConsumptionSaving/example_ConsGenIncProcessModel.py similarity index 98% rename from HARK/ConsumptionSaving/example_ConsGenIncProcessModel.py rename to examples/ConsumptionSaving/example_ConsGenIncProcessModel.py index 77fedcb8f..3763e7820 100644 --- a/HARK/ConsumptionSaving/example_ConsGenIncProcessModel.py +++ b/examples/ConsumptionSaving/example_ConsGenIncProcessModel.py @@ -8,13 +8,11 @@ IndShockConsumerType, PersistentShockConsumerType, ) - - def mystr(number): return "{:.4f}".format(number) -do_simulation = False +do_simulation = True # Display information about the pLvlGrid used in these examples print( @@ -126,8 +124,6 @@ def mystr(number): plt.ylabel("Average market resources mLvl") plt.show() -############################################################################### - # Make and solve an example "persistent idisyncratic shocks" consumer PersistentExample = PersistentShockConsumerType(**Params.init_persistent_shocks) t_start = process_time() diff --git a/examples/ConsumptionSaving/example_ConsIndShock.ipynb b/examples/ConsumptionSaving/example_ConsIndShock.ipynb new file mode 100644 index 000000000..63f6c9050 --- /dev/null +++ b/examples/ConsumptionSaving/example_ConsIndShock.ipynb @@ -0,0 +1,566 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import HARK.ConsumptionSaving.ConsumerParameters as Params\n", + "from HARK.ConsumptionSaving.ConsIndShockModel import (\n", + " PerfForesightConsumerType,\n", + " IndShockConsumerType,\n", + " KinkedRconsumerType,\n", + ")\n", + "from HARK.utilities import plotFuncsDer, plotFuncs\n", + "from time import time" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "mystr = lambda number: \"{:.4f}\".format(number)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "do_simulation = True" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Make and solve an example perfect foresight consumer\n", + "PFexample = PerfForesightConsumerType()\n", + "# Make this type have an infinite horizon\n", + "PFexample.cycles = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a perfect foresight consumer took 0.6234 seconds.\n" + ] + } + ], + "source": [ + "start_time = time()\n", + "PFexample.solve()\n", + "end_time = time()\n", + "print(\n", + " \"Solving a perfect foresight consumer took \"\n", + " + mystr(end_time - start_time)\n", + " + \" seconds.\"\n", + ")\n", + "PFexample.unpackcFunc()\n", + "PFexample.timeFwd()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Perfect foresight consumption function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the perfect foresight consumption function\n", + "print(\"Perfect foresight consumption function:\")\n", + "mMin = PFexample.solution[0].mNrmMin\n", + "plotFuncs(PFexample.cFunc[0], mMin, mMin + 10)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "if do_simulation:\n", + " PFexample.T_sim = 120 # Set number of simulation periods\n", + " PFexample.track_vars = [\"mNrmNow\"]\n", + " PFexample.initializeSim()\n", + " PFexample.simulate()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Make and solve an example consumer with idiosyncratic income shocks\n", + "IndShockExample = IndShockConsumerType()\n", + "IndShockExample.cycles = 0 # Make this type have an infinite horizon" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "Solving a consumer with idiosyncratic shocks took 0.2175 seconds.\n" + ] + } + ], + "source": [ + "start_time = time()\n", + "IndShockExample.solve()\n", + "end_time = time()\n", + "print(\n", + " \"Solving a consumer with idiosyncratic shocks took \"\n", + " + mystr(end_time - start_time)\n", + " + \" seconds.\"\n", + ")\n", + "IndShockExample.unpackcFunc()\n", + "IndShockExample.timeFwd()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Concave consumption function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marginal consumption function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function and MPC for the infinite horizon consumer\n", + "print(\"Concave consumption function:\")\n", + "plotFuncs(IndShockExample.cFunc[0], IndShockExample.solution[0].mNrmMin, 5)\n", + "print(\"Marginal consumption function:\")\n", + "plotFuncsDer(IndShockExample.cFunc[0], IndShockExample.solution[0].mNrmMin, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions for perfect foresight vs idiosyncratic shocks:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Compare the consumption functions for the perfect foresight and idiosyncratic\n", + "# shock types. Risky income cFunc asymptotically approaches perfect foresight cFunc.\n", + "print(\"Consumption functions for perfect foresight vs idiosyncratic shocks:\")\n", + "plotFuncs(\n", + " [PFexample.cFunc[0], IndShockExample.cFunc[0]],\n", + " IndShockExample.solution[0].mNrmMin,\n", + " 100,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Compare the value functions for the two types\n", + "if IndShockExample.vFuncBool:\n", + " print(\"Value functions for perfect foresight vs idiosyncratic shocks:\")\n", + " plotFuncs(\n", + " [PFexample.solution[0].vFunc, IndShockExample.solution[0].vFunc],\n", + " IndShockExample.solution[0].mNrmMin + 0.5,\n", + " 10,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Simulate some data; results stored in mNrmNow_hist, cNrmNow_hist, and pLvlNow_hist\n", + "if do_simulation:\n", + " IndShockExample.T_sim = 120\n", + " IndShockExample.track_vars = [\"mNrmNow\", \"cNrmNow\", \"pLvlNow\"]\n", + " IndShockExample.makeShockHistory() # This is optional, simulation will draw shocks on the fly if it isn't run.\n", + " IndShockExample.initializeSim()\n", + " IndShockExample.simulate()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Make and solve an idiosyncratic shocks consumer with a finite lifecycle\n", + "LifecycleExample = IndShockConsumerType(**Params.init_lifecycle)\n", + "LifecycleExample.cycles = (\n", + " 1\n", + ") # Make this consumer live a sequence of periods exactly once" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a lifecycle consumer took 0.0202 seconds.\n" + ] + } + ], + "source": [ + "start_time = time()\n", + "LifecycleExample.solve()\n", + "end_time = time()\n", + "print(\"Solving a lifecycle consumer took \" + mystr(end_time - start_time) + \" seconds.\")\n", + "LifecycleExample.unpackcFunc()\n", + "LifecycleExample.timeFwd()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions while working:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9d1CcaZ7n+XkzSWwavHdCAkkII4MwMkhIQq6qVN2lqurq6u7qrurualdtZnbM3l7E7e1EXNxNxO1FzMbe7lxfzMbN7Ezs9MR0VVd1yYJAQgiBQAYkIYOEsIk3aUn/3B8vIFMyIGFUVc8nIgOU75vv+4Dgyy+/z88oQggkEolE8tVCs9wLkEgkEsnCI8VdIpFIvoJIcZdIJJKvIFLcJRKJ5CuIFHeJRCL5ChK0XDeOjY0VmZmZy3V7iUQi+VJy8eLFUSFE3LPOWzZxz8zMpKWlZbluL5FIJF9KFEXpnst50paRSCSSryBS3CUSieQriBR3iUQi+QoixV0ikUi+gkhxl0gkkq8gUtwlEonkK8gzxV1RlFBFUS4oitKqKMp1RVH+w2PO+YGiKCOKolyZfvxocZYrkUgkkrkwlzx3N7BLCGFXFEUH1CuKckwI0fjIeb8TQny08EuUSCQSifALpq6OzPn8Z4q7UBu+26f/qZt+yCbwEolEsgQEPH6czYPYzvbjn3TP+XVz8twVRdEqinIFGAaqhBBNjzntsKIobYqi/KuiKGlPuM6HiqK0KIrSMjIy979AEolE8nXD7/Bire5m8P+4wOQfO9GaQoh5L3fOr1fmM4lJUZRI4BPgl0KIaw88HwPYhRBuRVF+CrwthNj1tGsVFRUJ2X5AIpFIHsY34cJ+th9H8yDCGyB0bTSGHamEZJoAUBTlohCi6FnXmVdvGSHEpKIop4H9wLUHnh974LT/F/jr+VxXIpFIvu54BhzYz/TibBsBFMI3xGMoT0GXEPFc13umuCuKEgd4p4U9DNjDI+KtKEqSEGJg+p+HgBvPtRqJRCL5GiGEwHPPgu1MH65bEyjBWvRbUtBvTyHIFPJC155L5J4E/L2iKFpUj/5fhBCfK4ryV0CLEOIz4FeKohwCfMA48IMXWpVEIpF8hREBgat9DNuZPjy9NjQROox7M9CXJqEJ1y3IPebluS8k0nOXSCRfN4QvgPPyMLa6PnwjU2ijQzGUpxCxKQFFp53TNRbFc5dIJBLJ/Am4fDiaBrDVmwnYPOhS9ES/u4awvFgUjbIo95TiLpFIJIuE3+rBfq4fe+MAwu0nZFUkhrdzCFkViaIsjqjPIMVdIpFIFhjf6BS2uj4cF4cgIAjLj8VQnkpwqmHJ1iDFXSKRSBYIj9mO7XQvU1dHQasQUZSAoTyVoJiwJV+LFHeJRCJ5Qdz3LNhO96rpjCFaDOWp6LeloDUEL9uapLhLJBLJcyCEwHVzHNvpPjzdVjWdcV8G+tJkNGHLL63LvwKJRCL5EjHTndF2uhfvoBNtZAiRh1YSXpSAJnhu6YxLgRR3iUQimQPCG8BxaQjbmT784y6C4sOIeiuH8PVxKNqXb+6RFHeJRCJ5Cvdz1PsJ2Lzo0gxEvrKC0LUxi5ajvhBIcZdIJJLH4Ld7sJ8zYz8/gHD51Bz1b6URstK06DnqC4EUd4lEInkA36QLe910y11fgLDcGAw70whOW7oc9ccxZbdxo65mzudLcZdIJBLAO+zEdroX5xV1kFD4hngMO1LRxYcv25qEEJhv3aCt+hi3G8/h83rm/Fop7hKJ5GuNp8+GtbYXV/sYSpAGfWkS+vIUgiJDl21NLoedG2draas+zmhvN8FhYazbuZuCPQf4s385MqdrSHGXSCRfS9z3LFhre3HfnkAJ1WKoSEO/JRmtfnkKj4QQDN65TWv1MW41nMXncZOQlU3lh79kzdZygkPnV+UqxV0ikXxtEELg7pjEWtODp2u68Gh/ptpHPXR55NDtdHKj/jRt1ccY6b6HLiSU3O0VFOzZT0LWque+rhR3iUTylWdmOIa1thdvvx2tKRjTa1lEbE5ctsKjoc47tFUf50b9abxuF3GZWez50S9Yu20HwWEv7vNLcZdIJF9ZhF8w1TaC9XQvviEn2phQot7IJnxjPErQ0hceeV0ubp6vo63qGIN3OwgKDmH1lu0UVh4gcWXOgqZYSnGXSCRfOYTvgWrSMRdBCeFEv7OasPw4FO3S56iP9nTRWn2c9roaPFNOYlLTqfjBT8gtryA0Qr8o95TiLpFIvjIEPH4czYPY6/rwWzzoUvVEfm/tslST+jwebjedo636GP0329EGBZFTuo2CygOkrM5d/mEdiqKEAnVAyPT5/yqE+PePnBMC/AOwCRgDviWE6Frw1UokEsljCLh82BsHsJ/tJ+DwEpxpJOpwDiHZiz/x6FHGzf20nTrO9dPVuOw2opKS2fHdD8jdsZtwo2nJ1jGXyN0N7BJC2BVF0QH1iqIcE0I0PnDOD4EJIcQqRVHeAf4a+NYirFcikUhm8Tu86hi7hukWATlRGCvSCFmxdCIK4Pd5udPcRFv1UXqutaHRalm1uYzCygOk5eajaJbe33+muAshBGCf/qdu+iEeOe114H+d/vxfgf+sKIoy/VqJRCJZUPw2D7azfTgaBxCeAKHrYjBWpC3pGDsAy/AgbadOcK22CqdlEmNcPNveeY+8ikoiIqOWdC2PMifPXVEULXARWAX830KIpkdOSQF6AYQQPkVRLEAMMPrIdT4EPgRIT09/sZVLJJKvHT6LG/uZPuwXBsEfILwwDkNFGrqEiCVbQ8Dvp/NSM63Vx+hqvYSCQtamzRTuOUBG4QY0mpejp/ucxF0I4QfWK4oSCXyiKEqeEOLaA6c8ztT6QtQuhPgt8FuAoqIiGdVLJJI54Rt3YTvTi6NlCASEb4zHuDONoNilm01qGxvlas1JrtacwD4+hj4qmrLD75BXsRdjbNySrWOuzCtbRggxqSjKaWA/8KC49wFpQJ+iKEGACRhfqEVKJJKvJ77RKay1vTgvD4MCEZsTMexIJShqafq+iECArrbLtFYdo/PiBQSCzMKN7P7gZ2Rt3IxGu3RRut8boOfG3GV1LtkycYB3WtjDgD2oG6YP8hnwfeA88CZQI/12iUTyvHiHndhqenC2joBWg74sCUN5KlpTyJLc3zE5wbXaKtpOncA6MkS4KZLNh94gf/d+IhMSl2QNAAF/gP5bk3S0DNF5ZQS30zfn184lck8C/n7ad9cA/yKE+FxRlL8CWoQQnwF/B/x3RVHuoEbs78z/y5BIJF93PAMObDU9TF0bRdFp0G9PxbA9Ba1h8Zt5CSHovd5Ga9Ux7jSfJ+D3k7augPLv/IBVm0vRBukWfQ2gtkoYuGuho2WIu5eGmbJ50YVqyVofx6pN8Xz0/8ztOnPJlmkDNjzm+f/lgc9dwFtzX75EIpHcx9Nnw1oz3XY3RIthZxr6bSloIxZfUKdsVq6fOUVb9XEmBvoJ1RvYsP81CvbsJzo5ddHvD+ofluFuGx0tQ9xpGcYx6SZIpyGzIJbsogTS86IJ0s3PApIVqhKJZNlwd1uxnupR2+6GBWHck45+awqasMWVppkhGK3Vx7jdWI/f6yV5dS6lh98hp2QrQcFL805h3Oygo3mIjpYhrKMuNFqF9HUxbDm8ksz8WIJfoFOlFHeJRLLkuDstWE91475rQRMRtGRtd91OB+11NbRWHWOsr4fgsHDyd+2jcM9+YtMzF/XeM0wOOeloGaKjZZiJAQeKRiF1TRRFBzNZURhH6AK9W5HiLpFIlgx35yTW6h7cnRY0Bh2mV1YQUZK0qG13hRAM3e2gtfoYNxvq8LndJK7MZu9Pf8WasnJ0oYufeWMdm+LOxWHutAwz0mMDBZJXRVLw7RyyNsQTblz4dwpS3CUSyaLzBVF/NQt9SSLKPH3k+eBxTXGz/gyt1ccYvncXXUgoa7ftpHDPgRcagjFXHBY3dy8N09E8zGCnBYCEFUa2vZXNyo3x6KMWN/NHirtEIlk0XHcnsZ2aEXV1QIa+eHFFfbirc3oIRi2eqSni0jPZ/cOfs3bbTkLCF3fYtcvu5e7lYTpahjDfnkQIiEnVU/qNLFZtSsAUt3RFV1LcJRLJguO6q0bqnntLI+o+j4db58/SWn2Mgds3CdIFs3rLdgr2HCApe/Widob0TPnobB2ho3mYvhvjBAKCyIRwig5msqoogeikpWuN8CBS3CUSyYIghFA3Squ78dyzojEEE/laFhHFSSi6xemKODFopq36ONdqq9T2usmp7Hzvx+Tu2EWYfvGaiPk8frqujtHRPET3tTH8vgCG6FDWV6axqiiB2FT9krcafhQp7hKJ5IUQQuC+q2a/eO5Z0RiDiTy0kojNiYsi6gG/n7uXLtB68ijdbZfV9rpFpRTuPUjauoJFE9WAP0DfzQluN6vVol6Xn3BjMOu2J5O9OYGEFcZlF/QHkeIukUiei1lRr+7G07X4om4fH+NqzUnaak5gHxtFHxPLlre/Q/6ufeijohf8fqB+jYOdVjouDHJnulo0OCyIVZviydmcQHJOFJolnvA0V6S4SySSeaGK+rSn3mVFawwm8vWVRBQtvKgLIei51kpr1VHutjQR8PvVxl3v/3RRG3eN9du5fWGIjuYhbOOu+9WimxPIWBeDdpFspoVEirtEIpkTQgjcdyaxnlp8UXfZ7Vw/c4rW6mNMmPsI1RvYePB1CvbsJyoxeUHvNYN1dIrbzaqgj5vV4qK0tdGUvJ7FisIXqxZdDr5cq5VIJEvOrKhX9+DpfkDUNyeiBC2sqA/euc2VqqPcajiLz+MmKWcNB37xp+SUbluUlgBOq4c7F4e4fWGIoXtWAJJWmdjx7RxWbownbAkals0V38QEjrNn53y+FHeJRPJYviDqpmAivzEdqS+gqHvdLm6eq6O16ihDnXfQhYSSW15BYeVB4jOzFuw+M7infHReHqajeYi+mxOzuehl31xJ9uYEDNFL0yv+WQgh8HR2Yq+txVZ7mqnLlyEQmPPrpbhLJJKHEELg7pi2X7qtaE0hiyLqY/29tFYdpf1MDW6ng5jUdHZ98FNyt+9a8GKj2dTFliG6r6qpi8bYUDYdyCS7KIHo5OXJRX8U4fXivHhRFfSaWry9vQCErF1L7E9/gr6iAgoK5nQtKe4SiQR4QNSru/H02KZFfRURRQkLJup+n487zY20Vh2l93obGm0QOaVbKaw8QMqadQuaSjiTutjRPMTd6dTFMGMw68qTydmcSHym4aVIXfRbrdjPnsVeU4u9ro6AzYYSHEx4aQkxH7yPfudOdElJ876uFHeJ5GvOY0X9m6uI2LRwom4dHeHqqeNcrTmJY3ICY1wC2779ffIrKgk3RS7IPeCB1MXmIe5cHLqfurgxnuziBFJektRFT2/vbHTubGkBnw9tdDSGykoMuyqIKCtDE/Fi7yakuEskX1OEELhvT6ieeu/Ci/r9+aNH6bzYjECQtaGIwsqDZK7fiEazcGmMY/322UwX25gLrU5DZn4sOcUvR+qiCARwtbVhq6nFXluDu+MOAMGrVhLz/vvoKyoIKyxAWcDUTinuEsnXjNlIvapbFfXIhRV1p9XC9dPVtFUfZ3JoQJ0/+vphCnbvxxSfsABfgcrjUxejKHltBSsK4whe5IEfzyLgdOI4fx5bTQ3202fwj42BVkt4URHx//YwhooKgjMyFu3+Utwlkq8RrjvTot5tXVBRF0Jgvn2T1qqjs5ONUtfmsfVb3yW7ZMuCzR99bOriShPl7+SwatPypy56h4axnz6NvbYWx/nzCLcbjV6Pvnw7+opd6Mu3ozWZlmQtzxR3RVHSgH8AEoEA8FshxN88cs5O4FPg3vRTHwsh/mphlyqRSJ4X9z0L1qpu3J0WNU99gbJfPFNObtSfpvXkUUZ6uggOCyN/114K9xxYsMlGauriCB3Ng/dTF1PU1MVVRfEYY5auje6jCCFw37qlRue1p3FdvQqALiWFyLffxrCrgvBNm1CWYGzfo8wlcvcB/0YIcUlRFANwUVGUKiFE+yPnnRVCvLrwS5RIJM+Lu8eqinrHJBq9brr17ot3aRzt6eJK1TFunK1Re6ZnZlH5449Ys20HwaEvLrY+r5/uq2Pcbn44dXHj/gyyNycQk6x/4Xs8L8LjwXGheTr/vAafeQCA0MIC4n7zG/S7KgjJzl72TJxnirsQYgAYmP7cpijKDSAFeFTcJRLJS4Knz4a1qhvXrQk0EUGYDq4govTFxtn5vF46ms7RWnWU/pvtaHU6Vpdtp7Dy4IL0TA8EBObbE9y+MMTdS8N4ZlIXtyeTXZxAQubydV30T05ir6vDVlOL4+xZAg4HSmgoEVu2YPj5z9Hv2EFQXNyyrO1JzMtzVxQlE9gAND3mcJmiKK2AGfgzIcT1x7z+Q+BDgPT09PmuVSKRPAOP2Y61ugdX+xia8OnB02XJaEKeX9StoyO0VR/nas0JnJZJIhOSKP/uB+Tt3EOYwfjCax7rt3OrcZDbzUM4Jt3oQrWsXB9HTkkiKTmRaLTLk+ni6epSs1tqanBevgx+P9q4WIwHD6LfVUFEaSmasOWzhJ6FIoSY24mKogfOAP+bEOLjR44ZgYAQwq4oykHgb4QQ2U+7XlFRkWhpaXnOZUskkgfxDjmwVvcwdXUUJVSLYXsq+q3JaJ6z2dVMN8YrJ45wt6VJTWPcuJkNe18ho2ADiubFBNc+4eJ28xC3m4YY67ej0Sikr4smpySRFQWxBC3iwOwnIfx+pq5cmfXPPZ2dAISsXo1+VwWGXbsIXbfuhb/2F0VRlItCiKJnnTen/3lFUXTA74F/elTYAYQQ1gc+P6ooyn9RFCVWCDE6n0VLJJL54R1xqqLeNoISrMWwKw3DthQ04c+XneJ2OmmvO8WVE0cYN/cRajBSdOgNCvcceOE0xpmeLreahui/PQFCHRi9nJkufrsDx7lz2GtrsZ85g39iAnQ6IjZvJurddzFU7ESXkrLk63oc/oCfmxM353z+XLJlFODvgBtCiP/rCeckAkNCCKEoSjGgAcbmvAqJRDIvfGNTWE/14Lw8jBKkwbAjFf32VLQRzyfqo73dXDlxhPaztXhdUySuzGb/z/+E1WXbX6gbo98XoKd9nNtNg9xrG8XvDWCKC2PzKyvIKU4gMn5xB1Y/Du/g4P3q0MZGhNeLxmRCv6McQ0UFEdu2oTUs3oi+uSKEoMvaReNAI00DTTQPNmP1WJ/9wmnmErlvBb4HXFUU5cr0c/8OSJ9ewN8CbwI/UxTFB0wB74i5+j0SiWTO+CZcqqhfGgKNBv3WFAw7U9Hq5y/Afp+Puy2NXD7xOX3t19DqdKzZUs76va+QuCrnudcohGDonpVbTYPcaRnG5fASqteRuzWZnJKl3xhVi7Y6sNfUYKs+hevaNQB0GelEfec76HdVEL5xI0rQ8pf9DDuHaRpoonGgkcaBRoadwwAkRySzJ2MPxYnFvMrckhLn7LkvNNJzl0jmjs/ixlbbi6N5EAB9SRKGnWlojfMXdfvEOFdPnaCt+hj2iXGMcfEUVh4kr6KScOPzF9hMDjm5dWGQ202DWEfVFgBZhbHklCSSlhuNdgk3RoXfz9Tly9hO1WA7dQpvTw+gpisadu/BsHsXwVlZy56uaPPYaB5sno3OOy2qzx8ZEklJUgklSSWUJpWSZkibfc2Ceu4SiWR58Fs92E73Yr8wAAIiNidiqEgjyBQyr+sIIei/1c6V45/TcaFhdlzdnh//ghUbip67z8tMxeitpiGGu6ygQOrqKDa/soKs9UvbAiDgcuFoaMB26hT22tP4x8dRdDrCS0uJ+eAD9BUV6BLil2w9j8Ptd3Nl+ApNA000DTRxbewaAREgLCiMjQkbeSP7DUqSSsiJykGjvNgfQynuEslLiN/uwXamD0fjAMIfIGLTtKjPc5CE1+XiRv1prpz4nJGeLkLCI1i/71UKKw8Snfx8G4Vej597rSPcbhqip30cERDEpunZcngV2UUJ6KPm94fnRfBNTGA/fQbbqWoc5xoQU1NoDAb0O3Zg2L2LiO3b0eqXr+DJH/Bzc/zmrM1yefgybr8braIlPzafDws+pCSxhMK4QnTahWnRMIMUd4nkJcLv8GI/24e9wYzwBgjfEI9xdzpB8yyxHzf303ryCNfPnMLtdBCXsYLKDz9i7dad6ELnP2koEBD035zg1oVBOi+P4HX70UeFsKEynZziBGJSlk5APX192E+dwlZ9CufFixAIEJSQQOQ3v4l+9y4iNm9elnJ/UN8hdVu7Z22WC4MXZjdBs6OyeSvnLUqTStmUsAl98OJ+z6S4SyQvAQGXD9vZfuz1/QiPn7CCOIx70tHFzT2bJBDw03mphSsnPqe77TIarZbskq1s2PcqyavXzttfFkIw2mvn1oVBOpqHcFo8BIcFkV0UT05JIsmrIlGWoDe6EAJXezv2af/cfesWACHZ2cT85EMMu3YTmrewgz7mw4hzZFbMGwcaGXIOAZAUkcTu9N2UJpVSnFRMbFjskq5LirtEsowEPH7sDWZsZ/oQUz7C8mIwVmagS5j7oAan1cK12ipaq45iHRlGHx3Dlre/Q8Hu/URERs17TdaxKTqaVR99YsCBRquQkRfD6pJEMvJjCNItfoGR8HpxtrSoG6I1p9T+LRoN4Rs3Ev+Xf6luiC5TlbvNY6NlsGVW0O9a7gJgCjFRnFhMaVLp7Cbocm7YSnGXSJYB4QvgaBrAWttLwO4ldHUUxr2ZBM/D3hi4c4srJ45w6/xZ/F4vabn57PjuB6wsKkU7z7Q+l8PL3UvD3L4whLljEoCkVSZ2vLuaVZviCX3O/Pn5EHA4sNefw3aqGvvpMwSsVpSQECK2bcPwi4/QV+wkKDp60dfxKB6/hyvDV1QxH2zi+uh1/MJPqDaUTQmbeH3V65QklbAmes0Lb4IuJFLcJZIlRPgFzktDWE/14J90E5JlwvjdDEIy55aC6PN4uHX+LJePf85QZwe60DDyKvayfu9BYtPmN/jB7w/Qc32cW40D3GsbJeATRCaEU3Ioi5ziBIyxi983xW+xYKutxVZVjaO+HuF2o42MxLB7t7ohumULmgUelv3MNU1XgjYNNNFoVjdBXX4XWkVLXmweP8z/IaVJpRTGFRKsXd7+8U9DirtEsgSIgGCqbQRrdQ++0Sl0aQaiDmcTsipyTm/d7eNjtFYdpbX6OFNWC9HJqex6/yfklu8mZB7iN+Oj32wcoKNZnTEaZtCRtz2F1aWJxKUv/tBo38gItlOnsJ2swnHhAvh8BCUmqv3P9+whfNPSFhQJIeix9dBoViPzC4MXsLgtAKyKXMXhnMOUJpVSlFC06JugC4kUd4lkEVE3A8exVnXhHXSiSwwn5r1cQtdGP1NEhRAMdNzk0rE/0tF0jkAgwMpNxWzY9xrp+YXzEmHHpJtbFwa51TjIuNmBJkhhRUEsq0uTSF+3+AVGnr5+bNVV2Kqqmbp0CYQgOCODmPffx7C3ktC8vCX1p0enRh/aBB10qMVhiRGJVKRVqAVEiSXEhb9cbXzngxR3iWQRmJlTajnZhbfPTlBsGNHfXk1YftwzM0x8Xi+3G+u5fOwzBu92EBwWzob9r7J+32tEJiTOeQ1ej597V0a41ThI741xhIDELOOS+ejuzk5sJ09iO1mFq10d/xCyZg2xH/0CQ2Xlkg60sHvstAy1zIr5nUl1QLUx2EhJUgk/yvsRpcmlpBvSl71qdaGQ4i6RLDDuLguWE1147qlzSqMOZxO+MQFF+3TRcExO0Fp1jNaqozgtk0Qlp7L7g5+Ru2PXnKcbiYDAfGeSW42D3Lk0jNflRx8dwqYDmawuSSQyYfH865mURVuVGqF77qpZJGHr1xP/53+OoXLPkmW4eANero5cpcHcQONAI9dGr+EXfkK0IWyM38irWa9SmlzKmqg1aJ+zOvdlR4q7RLJAePpsWE524749gcagI/LQSiKKnz2ndPDObS4d/yO3Gs4S8PtYsaGIjftfm1ff9MkhJ7eaBrnVNIhtzIUuRMvKTfGsKUkkOXvx8tFFIKD2cDlZha2qCq/ZDFot4Zs3E/XutzHs2YMu4cVaBc9pHdO+eYO5gQZzA82DzTi8DjSKhryYPD7I+0DdBI0vJES7dBW0L4wQMNkDfc3Qe0H9OEekuEskL4h3yIH1ZDdT19XpR6YDmUSUJT91pJ3f56Oj6RyXjv+Rgds3CQ4Lo3DvATbse5WopLm1BXA5vNy5OMytxkEGOy2gQNraaEoOZZG1Pg7dC0xfehrC68Vx4YIaoZ86hX9kFEWnI2LrVmJ/8Qv0uyoIipp/fv18sbgtNA00zUbn/fZ+AFL0KRxccZAtyVvYnLgZU8jzN0NbcrxTYL4CfRfui7ldLYpCFw4pm+Z8KSnuEslz4hubwlrdg/PKsDooY3c6hu0pT51+5LRM0lZ9nNaqo9gnxolMTKLiBx+ybseeOWW9BAKC3hvj3Dw/wL0ro/h9AaKSIij75kpyihMXra9LwOXCce6cGqGfPk3AYkEJD0dfXo6hcg/6HTsWvYeLN+ClbaSNBnMD583nuT52nYAIoNfpKU4s5v1171OWXLbsxUNz5nFR+WAbBHzq8agVkLUTUjdDWjHErwNtELw/t69NirtEMk98Fje2Uz04WoZQtAr67akYdjx9UMbQvbtcPvZHbjacwe/1klm4kcqf/JIVhZvmZL1MDjm5cX6AW42DOCbdhEQEkbstmTVli5e+6LfbsZ85g62qGntdHcLpRGM0YqiowLBvr5qD/hx9aubKTJ+WGTG/MHgBp8+JRtGQH5vPTwp+wpbkLeTF5hGk+RJI2bOi8uSNsOWXkFqsCrr+xTJ1vgTfEYnk5cBv92Cr7cXeNN1+tyQRY0X6E3uqB/x+7jSf59Kxz+i/2Y4uJJS8ir1s2P8qMSlpj33Ng3imfHS0DHHzvGq7KAqk58Ww7a1sVhTEotUtfPqib2ICe00ttpMncTQ0ILxetLGxmA69hqGykojiYhTd4mXZWNwWGgcaOW8+T4O5gQHHAACp+lRezXpVtVqSNmMMfvHB3IuOpR96m1Qh7216clSeuhkS8tSofAGR4i6RPIOAy4ftTB/2c/1qp8aNCWqnxie0352yWeHeYyoAACAASURBVGk7dYIrJ49gHxvFFJ/Azvd+xLqdewiNeLp1IQKCvtsT3GwYoPPyCD5vgKjEcMreWMnqkkQi5tnHfS54h4Znc9Cdzc3g96NLTlZniO7bS1hhIYp2cfx7r99L60jrQ1aLQGDQGShOKuZH+T+iLKmMNOOz/xguK34vDF27L+Q9TWDtU48FhUHKwkblc0GKu0TyBAIeP47zZqynp5t6FcSqTb2e0Klx3NzHpaOfcv1MDT6Pm/S8QnZ/8DOyNj57GIZlZIqb5we42TiAfdxNcFgQq8uSWFOWuChj6bxDQ9hOnMR6/LhaVAQEr1xJzI9/hKGyktDc3EWxeoQQ3LPe47z5/KzVMuWbmu1v/rPCn1GWXPbyWy3OcehrmY7Mm6D/Inid6jFDMqSXQNovVa88MR8WuFf7XHiJv3sSyfIg/AEcLWr/l4DV89SmXkIIeq9f5eKRT+i81IxWp2Pttgo2HTxEbHrmU+/j9fi5e3GYGw0DarOu6WyXsm+uJKswjqCnZNs8D48T9JCcHGJ/9UuM+/YRsnLlgt5vhknXJI2D962WmWrQdEM6h1Yeoiy5jOLEYgzByz+U+rEIAWN3oKfxvs0yqrYdRtGq4r3xPVXI00rAlLq8653mmeKuKEoa8A9AIhAAfiuE+JtHzlGAvwEOAk7gB0KISwu/XIlk8Zjt/1LVjW/MRXCGEdM7awjJ+mIqnd/n5ea5Oi4e+QMj3fcIM5ooe/Nd1u89SLgp8qn3Gemx0V5v5vaFQTwuP6a4MEoOZbG6NBHDPCctPQtV0E9gPX7iIUGP+/WvMOzbT0jWigW9H6hWy5WRK7Ni3j7WrlotwQZKk0r5cf6PZ7NaXko8TjBfetgvn5pQj4VGqgJe8Lb6MWUjBM+9PfNSMpfI3Qf8GyHEJUVRDMBFRVGqhBDtD5xzAMiefpQA/3X6o0Ty0iOEwHVrAuuJLrwDDnSJEcR8P5fQNV/s/zJls9JadYwrJz7HMTlBTGo6e3/yK9Zu20nQU6b/uKd8dFwY5Hq9mdFeO1qdhlUb48ndlkTSHJuHzZWlFnQhBPcs9zg/cH62gGjGaimMK+Tn639OWXIZ62LWvZxWy9M2PmNzYM0rqpCnlUBMNsyxsGy5eeZ3WggxAAxMf25TFOUGkAI8KO6vA/8ghBBAo6IokYqiJE2/ViJ5aXF3WbAc78LTZUUbHUr0O6sJK/hi/5ex/l4uHf2U9rpafB43mYUb2f/zP1GrSJ8gzEIIBu5aaK83c/fiMD5vgJhUPeXv5JC9OWFBe7sstaBb3JbZyLzB3DA7fSjDmMHrK1+ftVpeui6Kfh8MXb0v5L0XwNKrHgsKU4uEtvxqWsyLIXzp+8cvFPP6M6ooSiawAWh65FAK0PvAv/umn3tI3BVF+RD4ECB9maaoSCQAHrMd68luXDfH1VYB31hJRNHDrQJUP72Ni0f+MOun526vYOPB15/aO33K5uFm4yA3zpmZGHSiC9WyujSR3G3JC5qTvpSC7g/4aR9rp95cz7n+c1wdvUpABGatli3JWyhLLiNF/3xDtxeNuWx8ln20rBufi8WcxV1RFD3we+A3Qgjro4cf8xLxhSeE+C3wW4CioqIvHJdIFhvf6BSWqm6mWkdQQoMw7s9Ev+XhVgE+r5dbDXVc/PwTRnq6CDdFPtNPFwFB781x2usHuNc6QsAvSMwyseu9NazcGE/wU6pW58NjBX316kUR9NGpUc6bz1PfX0+DuYFJ9yQKCnmxefyk4CdsTdlKXkzey9N4a2bjs7dpevPzy7HxORcmnR7aB6y0mx+V3iczp584RVF0qML+T0KIjx9zSh/w4O5IKmCe8yokkkXGb3VjPdWDo1mtKjXsTMNQnoIm/H6k5rRaaKs6xpWTR+776T/9FWu3PtlPt0+4uNEwwI1zA9jGXYRG6MjfmcrarUnEJC+MJeEdHMR28iTWY8eZunwZWBxB9wV8tI20Ud9fzznzOdrHVOc1OjSa8tRytiZvpSy5jKjQxe8bMyc8TjBfht5pIe+9AFPj6rEv0cbngwgh6JuY4rrZOivmNwas9E9OzftaimqTP+UE9T3k3wPjQojfPOGcV4CPULNlSoD/JIQoftp1i4qKREtLy7wXLJHMh4DTi/VMH44GMyIgiChOxLgrHa3hvljP+ulnavB5PWSu38SmV75BRv76x1oofn+A7qtjtJ8z03NtDCEgdU0UuduSySqMW5DK0ScJunH/vgUV9EHHIA3mBur762k0N2Lz2mY3QrelbGNrytaXZzao1Xw/In/cxudMRP4l2fj0+gN0DNm5brbMivmNASs2l/o1aRTIitOTm2QkN9lIbpKRtUlG4o2hF4UQRc+6/lwi963A94CriqJcmX7u3wHpAEKIvwWOogr7HdRUyPfn/ZVKJAtIwOPHfq4f25k+hNtP+Pp4jHvSCYpR+6LP+Oktn3/Cvcstc/LTraNTXK83c7NhAKfVQ4QpmI37M1i7JRlT3IvPG521XBYxQvf4PVwevsy5/nPUm+vpmOgAID48nr2Ze9maspWSpJLlL+8PBGDkBvScVwW9p/FLvfHp9Pi4MWDlutnK9X4r1wcs3B604/EHAAjTaVmTZOD19cnkJpnITTayOsFA2AvUOjwzcl8sZOQuWQyEL4DjwiDWmh4Cdi+ha6Mx7ctEl6i+JQ/4/dxurKf5jx8zfO8u4aZI1u99hcLKA4/10wMBQc/1Ma7V9dN9bQwFyMiPJXdbMhnrotG84Hg638SEWlh05AjOlhYQYsEj9D5b36yYNw00MeWbIkgTxKb4TbPR+arIVcvbSdHrUi2Wnob7xUIudY4p+kRIL1UfaSUv/cbnuMMzG42rDwv3Rh3MSG1UuI51ySbWJasR+bpkEytiI9DOsee+oigLFrlLJC89IiBwXhnGWt2Df9xF8AoTpu9lEpKhRqAe1xTXaqu4eORTrCNDRCWnUvnhR+Ru3/VYP91p9XCjwcz1s2ZsYy7CjcEUHcgkd1vyCxca+e0O7DWnsBw5guNcA/h8BK9YQewvfoHx4AFCsrJe6Poun4uWoRZV0Pvr6bJ2AWqf80MrD7EtZRvFicWE6xZvKtMzcY6r9spMZG6+BH6Peix2NeR+A9LLIKMMIjPgJWzhK4Sgf3JqVsTbpwV9wOKaPSclMozcZCOHCpNnBT3JFLokf0iluEu+1MwUIFmO3cM35ESXoifqgzxCstXCIMfkBJePf07rySO4HHaSV+dS8f0fs3JT8Rda7c7kpV8708/dS8ME/IKU1ZFseWMVK9bHvtAQ6YDbjf3MGaxHjmI/fRrhdhOUlET099/D9MorhKxd+9y/8EIIuqxds9F5y2ALbr+bEG0IRYlFvLPmHbYmbyXDmLE80flM3/KexvtiPnJDPabRQfIGKPmpKuZpJRARs/RrfAb+gKBzxD4bic945JNOL3DfHy9eEc266Wg8N8lIVMSTC9sWGynuki8t7m4rlmP38HRZCYoJJfrdNYTlxaJoFMbNfbR8/gntdTX4fT5WFZWy+dAbJOes/cJ1PC4ft5sGuVbXz1i/g+CwIPLKU1hXnkJ00vNnWAifD8f5RqxHjmCrriZgt6ONjiby8GGMr75C2Pr1cx6j9yhOr5OmgSbOmdXofGYKUaYxk7dy3mJbyjY2JWwiNGjx+q0/kYAfhtsfFnOruj5CjKpHnv+mKuYpG0H34vsVC4nL6+fWoO0hIb85aMXlVf3x4CANaxINHMhLJHc6Gl+TaCA8+OWS05drNRLJHPAOO7Gc6MJ1fQyNfroAaXMiilZD/812mv/4MXcvNqENCmLdjt1seuWbRCd/sbhmrN/OtTP93GoaxOv2E5ump+K7a8jenPDcI+pEIMDUpUtYjhzBdvwE/okJNAYDhr17MR48SERpCUrQ8/3a9Vp7OdN3hrq+OlqGWvAGvIQFhVGSVML7695na8pWUg3LkLvtnVKLg2aEvPcCuKfzsQ3JqrWSXqZ65vG58LLkxQOWKS/t0yLePm2v3Bmx4w+oBrkhNIjcJCPvFmeoEXmKkZVxenQvuNeyFEhxl3xp8FtmctUHUYK1GCsz0G9LAR3caWmk+Y8fM3D7JqF6A6XffJv1+14lIvLhnGy/N8Ddy8Ncq+tn4I4FbZCG7KJ41u1Iee7WukIIXNfbsR49ivXYMXwDAyihoegrdmJ65RUitm9HEzL/Puxev5dLw5eo66ujrq9u1jtfYVrBu2veZXvqdjbGb0S31JuLzvGHo3LzZQio9gRxayHvMGRsUcXclPZS+OVCCIZtbjUS75/e6Byw0Dt+P3883hDCumQjlbkJs9ZKWnTYl2Nk32OQ4i556QlM+bCd6cVWbwYh0G9JxlCRRiBYcPXMSS4e+YSJATPGuAQqfvAT8isq0T0y/s06OsX1s2ZuNJiZsnkxxoWx5fAq1pYlEap/PnF0d3Zi/fwI1qNH8XR1QVAQ+q1bMf7pn6Cv2IVWP39LZ3RqlPr+eur66jhvPo/da0en0bE5cTPvrHmH8pTypR1cIQRMdD0s5jNVn9pgdTRc2S+m/fKXIyUxEBB0jzsfylhpN1sYtXtmz8mMCacgJZJ3NqfPCnmcYXHmzy4XUtwlLy3CG8B+3oy1thfh8qm56pUZeIO9NJ/4mEvH/8iU1UJC1ipe+fVfkFOyFc0DE4Mel8aYWRBL3o4U0tZEf6E52Fzw9vdjPXYMy5GjuG/cAEUhvLiY6A/ex7h3L9rIp7f7fZSACHBj/IYanffWcW3sGgDxYfHsy9zH9tTtlCWVLV1mS8CvThR6UMxt0y2iQk2QVgqF76hinrwBdMvg6T+AxxegY9g2LeCqvXJjwIbdrRYCBWkUshMM7FwdPyvia5MMGEJf3lTKhUKKu+SlQwQEzsvDWE9247e4CcmJwrQ/E3eoi/rP/5G26uN43S5WrN9E0WuHSVuX/9Bb5ymbh/ZzC5fG6Bsbw3rsONYjR2aLi0ILC0j4n/4thv0H0CXEz+t6Dq+DRnMjZ/rOcLb/LKNToygo5Mfm89H6jyhPLWdN9JqlsQN8btVW6T4H3Q3qeDiPTT1mSoPMbdM55mWq5bKMVZ8ur5+bgzau9lu41mfhmtlCx9D9QqDwYC1rk4y8sTFlVsizE/SEBL08Hv9SIsVd8tIghMB1cxzL8S41rTFVT9TbOTjDHNR+9t9or6tBiABrtpSz+dBh4jIeLvAZ6bHRVttLR/Mwfl+AlJznT2MMuFzYa2qwfPoZ9vp68PsJyc4m7je/wfjKQYLT5meNdFu7Z73zlqEWfAEfBp2BLSlbKE8tZ1vKNqJDl8DS8Dihr1kV8u5z6ue+6bzsuLVQ8BZkbFVTEiOXb5jGlMdP+4CVa/0WrvVbuNpvoWP4/kZnZLiOvGQT72/NZF2KmrGSGTP3QqCvA1LcJS8FD6U1xoYR/Z01WMMnqfr0v3L7QgPaoCDyd+9j82vfxBSfOPs6vz9A5+URrtb2MXDXQlCwhrVbksjfmUp08vw8bxEIMHXxIpOffort+AkCdjtBCQnEfPA+xtdeIzQnZ87X8vq9XBy+SF1fHWf7zs5uhmaZsvju2u9SnlrO+vj16DSLbA+4rGq1Z/c56Dp3f/NT0aiVnkUfqGKeXrZs+eUOt4/2AStXp6Pxa/0W7gzbmdZxYiKCyUsxsWdtAnkpRvJSTKREfnk3OpcKKe6SZeVxaY3j4SMc/ew/0d12meCwcIpff5ONBw49lPnitHpor+/n2pl+HBYPxthQtr65irVbkggJn59gujvvYfnsU6yf/RGv2YwSHo5x715Mrx8ivLgYRTu3t/VjU2OqmPefpcHcgMPrQKfRUZxYrG6GppYv/mg55/h0VD4dmQ+2gQiAJuj+5mfmNnXzM/SL4wMXG5tLTT28Oh2RXzNbuTtiny3Nj9WHkJ9iZP+6RPJSTOSlmJasovOrhhR3ybLgt7ixVvfgaJlJa0xnKLyf03/8jwzcuUW4KZLt7/6AwsoDhITfj8CHu6201fbR0TJEwCdIy41m53dTyVgXM68NUt/EBNYjR7F89hmutjbQaIjYsoW4P/kNht270YQ/ewNzZrxcbW8tp3tP0zrSikAQHxbP/sz97EjdQUlSyeJuhtoG7/vl3Q1q8RBAUCikbobyP1cj89SiJW95a5nycn06Er/Wr1osnaOO2eMJxhDyU0y8WpBEXrKJ/FQTCcbl3aD9KiHFXbKkPJrWGFGWxEBoN1VH/5qxvh5M8Qns/uHPWbdzN7pgNTXN7w9w99IwbTV9DN2zogvRsm5bCvk7U4hKnLtgBdxu7LWnsXz2Gfa6OvD5CFmzhvi/+AuMr76CLv7ZG6O+gI8rw1c43Xua032n6bZ2A7A2ei0/K/wZO9N2Lu5m6ET3/ai8uwHG76rPB+tVnzzvsCrmKRshaOlS+yadHlXAzZbZqLx7zDl7PNkUSl6KiW9sSCE/xcS6FCPxBinki4kUd8mSIHwB7I0D2Gp6CEz5CC2IZVDfw/GT/zuW4SFi0zM5+Ms/Y3XZ9tl0Rpfdy/X6fq7W9uGweDDFh7Ht7WzWliURHDa3H10hhFox+ulnWI8fJ2C1EhQXR/R772F6/RChq1c/8xoOr4MGcwOne09T11fHpHuSIE0QJYklfHftd9mZtpPEiMRnXmfezEwWejAyn2l7GxqpFgoVva9+TCwE7dL8Oo87PLObnKq18nAxUEpkGPkpJt4uSmNdsuqRx+q/WjnkXwakuEsWFSEEU1dHsRzvUrs1rjQyGNnP+dq/wz42SuKqHCp+8CFZG4tno91xs4PW2l5uNw7i8waey3rxdHdj+fQzLJ99hrevDyUsDEPlHkyvv05EaekzffQhxxBn+s5Q21tL00AT3oAXY7CR8tRyKtIq2JK8ZeGHP8/0MO86d1/QHcPqsYh4VcS3/Er9GJ+7JGmJo3b3Q6mH1/ofngqUHq0WA327OJ38FBN5yaZlbZYluY8Ud8mi4e6yYDlyD0+vjaD4MMZzJ2k491sckxOkrMll309+RUbBBhRFQQQE3e1jtJ7qpbd9HK1Ow+qSRAp2pc55XJ3fZlN99D/8gakrV0BRiCgrJe6XH2HYswdNxJMtHCEEtyduz/rn18euA5CqT+WdNe9QkVbBhvgNBGkW8FdGCBi5CV31cK9OFXTnmHrMmAorK1Qhz9gKMasWvYx/1O6mrW+Sq333NzwHrffb166IjWBDeiTvlWWo1kqyCdM8N68lS4cUd8mC4x1xYjnWhat9DI1Bx0TWJGcv/C1TNgvpeYW88uu/IC03HwCf18+txkFaT/UyMegk3BRMyaEs1pUnE6Z/dgQohMB5oRnLx7/HeuIkwuUiJDub+D//M4yvvoouIeHJ6/R7aRlqmRX0AccACgoFcQX8euOvqUirIMuUtXD+uRAw2gFdZ6cf9eAYUY8ZUyF7L2RuV7NZoh4/DWqhsEx5udZvobVvkrZe1WKZicgVRRXykqzoWRFfl2LE+DWo6vwqIcVdsmD47R41A+bCAEqQBkuKhbOX/xlH2yQrNhRR+sa3ZlvuTtk9XDvTz9XTfUzZvMSm6dnzfi6rNsWjDXq23eAdGsLyySdMfvwJ3p4eNHo9pm+8TuThNwnNW/dEQbZ6rNT31VPbW0t9fz12r51QbSilyaX8tPCnlKeWExsWuzDfECFgvFMV8nvTYm4fVI8ZkmHlLlXIM7dDVOaiReZOj4/rZiutvZNc7bfQ1qdOBpohPTqcDemR/GBLJvmpavqhPkRKw5cd+T8oeWECHj/2s9PzSr1+7HEOzl7/HdZbI6wsKqHs8LdJyFoFgGXEyZXqXm42DODzBsjIi2F9ZTopOZHPjJCFx4Ot9jSTH/8ex9l6CAQILy4m7qNfYKisRBP2+L7gw85hanpqqOmpoXmwGZ/wER0azd7MvexM3UlpcilhQQvQU3ymyVZX/X1Bt5nVY/qE+1H5inKIzloUMXf71F7krX0W2nonaeuz0DFsmy0ISjSGUpBq4vDGFApSIylINREZLj3yryLPFHdFUf4b8CowLITIe8zxncCnwL3ppz4WQvzVQi5S8nIiAgLnxSEsVd0ErB6molw03P2Y0c5esjZu5tBb//OsqA92WrhS1cPdKyNoNAo5JYms35M2Jz/d3dHB5L/+Hstnn+GfmFCrRj/8MZFvvEFwevpjX9Nl6eJUzylqempoG20DIMOYwffWfY9dabvIj81HuxB9xSd7pj3zaatlJpslPBZWTIt5ZjnEZi+4mPv8Ae6M2GnrVe2Vq/0Wbg7YZnutRIXrKEiNZN+6hFkhj5d55F8b5hK5/3/Afwb+4SnnnBVCvLogK5K89AghcN9WR9t5B514Ijw0TXyO+V4HWRs3s+/NPyVxZbY6/u3qKJdOdDNwx0JIeBAb92VQUJFKhOnpqXF+ux3rkaNMfvx7XK1toNNhqKgg8s3DRGzd+oVsFyEE7ePtnOpWBf2uRc3/zo3J5aP1H7E7fTcrI1e+uH9u6Z+OzOtUQZ9U89wJi1aFfMuvVFGPW7OgYh4ICLrGHLT1WaYfk1w3W5ny+gEwhASRl2Li/W2ZFKSoQp4aJUv0v848U9yFEHWKomQu/lIkXwY8ZjuWo/dw35nEF+rnsu0Unfcus2JDEe+++R9JWrWaQEDQ0TLExePdjPXZ0UeFsO2tbNZuTSI49Mk/ckIIplpamPz9x1hPnEBMTRG8aiXxf/mXmF4/RFD0w421fAEfl4cvz0boA44BNIqGTQmbeGv1W+xK20WSPunFvmDHGNw7A52n1ch8vFN9PjRSFfPSn6sfFzA1UQiB2eKirXdStVemo3KbS21jG6rTsC7ZxLc2p1GYZqIgNZIVMRFoZNMsyQMslOdepihKK2AG/kwIcf1xJymK8iHwIUD6E95OS15OfJNurCe7cF4eJhAkuOlq4vq9s6Tm5fHtX/+fJOeswe8N0F5v5tKJbiwjU0QlhrPrvbXkFCc8dZPUNzrK5CefYPnX3+Pp7kYTEYHp1VeJfPMwoQUFD0WfXr+XpsEmqrqrqO2pZcI9QbAmmC3JW2YrRKNCo554r2ficah9zDtPq4/Bq+rzIUY1JXHzj1QxT8hbsHFx4w4PV3onaO1Vhbytz8KYQx0sEaRRWJNk4LXCZApTTeSnRJKToCfoSzDmTbK8KGKmY8/TTlIj98+f4LkbgYAQwq4oykHgb4QQ2c+6ZlFRkWhpaZn/iiVLSsDlw3ZabRcgAgG6PNe53F9FzIp0tr3zfTIK1uNx+WivN3OluhfHpJu4dAObDmSQVRj3xKIjIQTOpiYmfvc7bNWnwOslrGgTkYffxLhv70O9Xdx+N+fN51VB763F5rERoYugPLWcPel72Jay7fn7t/h9YL4EndPReW+T2jVRG6yW82ftgBU71cEUC1AB6vb5aTdbudI7yeWeSa70TtIzrpbpaxRYFa+f9ccLUiNZk2ggVPf17EcueTyKolwUQhQ967wX/mkVQlgf+Pyooij/RVGUWCHE6IteW7J8iIDA0TyItaqbgN3LIN009x4lLDGSA3/yb1i1uQy300fzkXu01vTidvhIyYlk13trSFsb/USv1zcxgeWTPzD5u9+pUbrJRPS73yby7bcJWbly9jyXz8W5/nOc7D7Jmb4zOLwODMEGKtIqqMyopCy5jBDtc5S0CwEjt1Qhv3dG9c9nhjknFkDpz1RBTy974UZbQgh6xp2zIn65d5IbZuvshmeiMZT1aZG8W5LO+rRI8lNMRMgURMkC8cI/SYqiJAJDQgihKEoxoAHGXnhlkmXD1TGB5Ugn3kEnVs04jf1/xG8KUP7hD1m7fSdTNh8NH9/lel0/XrefzIJYNu3PIDHr8S1kZ7z0id/9C7YTJxBeL2EbNpD8859h2LcPzfS8U5fPRV1fHSe7T1LXV8eUbwpTiIl9mfuozKikJLHk+YZBW/qnffPp6Hwm1zwqE/LegKydakbLC/Yztzi9XOmb5ErPpGqz9FkYn7ZXwnRa8lPV4RIb0iNZnxZFoklmrkgWj7mkQv4PYCcQqyhKH/DvAR2AEOJvgTeBnymK4gOmgHfEXLweyUuHd9iJ5eg9XDfHcWumaBk6zrhumNLvfIv83ftxTPqo+x8d3Dg/gPALVhUlsGl/BjEpj09n9NvtWD75AxP//M947t5FYzAQ+fbbRH7r7dnBF96Al/q+Oo7dO0ZNTw1On5Po0Ghey3qNPRl7KEosmv9Ai6lJNSKfic5Hb6vPh8eqOeZZO9XoPCrzeb9VeP0Bbg7YuNI7weVeNTLvHFELgxQFVsXp2bM2nvVpUaxPkz65ZOmZk+e+GEjP/eXB7/BiO9WDvdGMX/i4OlZPj7edTYe+ycYDh7CO+7h4rJs7LUMoWoW1ZUls2JuOKe7xPre7s5OJf/wnLH/4AwGnk9D8fKLe+RbGAwfQhIfjD/i5NHyJo/eOUtVdhcVtwRBsoDKjkgMrDrA5YfP8ctD9PuhvgTvVcLdGnTYkAqALVzdBs3aogh6/7rkyWoQQ9E9OcaVXjcov905yrd+C26faK7H6ENanRU5H5Kpf/nUYwCxZHpbMc5d8eRG+APbzA1hPdRFw+em0tXLD3kTuvj28f+g3TFk11Pz3O9y5NIwuWEvhnnTW704jIvKLXrfw+7GfOcPEP/4TjoYGFJ0O48EDRH3nO4QVFCCE4NroNY5eO8rJ/7+9+46uusr3Pv7eSU56I713SgKhxgDSq3RQcWx4de6M3PuIo3Nt19FZ96qznplnZiyjCwvqYEPFsQ1VOoygtAQSEEgjCSEQ0k56OUlO9vPHLwJCMEEDJ+X7WisrOSe/dfLlt/Sz9tq/vfc3fwslDSW4OLgwOXwyc6LnMC5k3NVNuVQVQs52I9Bz/wWWKqN1XGgSTHjMCPOwG8Dh6ndfNjRZSS+sJPVUxfn58rJaCwBODnYMCfViyZhIhocbYS7ryUV3JOHeB2mtaTxupnLjSazlFootp0gz7yByQhJLbn2FpgYndq/OIzvVCPVRN0UyfHoE4C86gQAAGeVJREFUzu6Xh6+1spLKz7+g4uOPaS4sxCEwEP/fPoz3bbfh4OtLdkU2Xx16hU35mzhdcxqTnYnxoeN5LPoxJoVN6vwql+YG4wjcnO1wcrtxmiIYZ7QkLIC46cYI3eXql0EWVTWQeqqC1FMVHDpVwbGz1bS07deP8XNjYn8/hkd4MyK8H4OCPTDJ9IroASTc+5ims7VUrs+lKbeKGmsFh0q34TY4gJsf/wMob779Ip/slGIcHO0ZeVMkI64Q6o2ZmVSsWkXVuvXoxkZck5IIeOwxPKZPo8RSznu5/2T9nvXkVOZgp+xIDkrm/sT7mRoxFS+nTvTu/P4ExZNto/P8PdDSCPZOxjG4I5YYgX6VO0G/nytPPWUmtaCS1HwzZ6uMY22dTXYMC/Nm6cQYkqL6MSK8n5xNLnosCfc+wlrdRNWWfOpSimnBwpGyf1HrV8vEJ+7H3SeGgxvyyU7JNEJ9ZgTDZ0RcduSubm6mZvt2zKtW0ZCSinJ2xmv+fPotuRsdG8H2gu2s3fEA+4r2odEM8x/Gk8lPclPUTZ07abGxyjjXPGcb5OyAqgLjfd/+MOo+I8wjx4Fj59e0V9Y3cbigkpRTZlJPGRuFvt+yH+TpzKioftwf2Y9Rkf2ID/aUUbnoNSTcezndbKVm9xmqdxbQ2mwlqyqFApXF2HvvICjuBlI2nSL7wH7sTXaMmBHBiBkRuHj8MNRbzGYqP/mEitWf0FJcjCkszOg7essi0hpzeO3kKrakbKG+pZ4QtxCWDl3KgtgFRHh2sAu5tRXOpbfNnW83NhBpKzh6GFMsE/4LYqd1+mxzrTW5ZXWk5htTLKkFFeSU1AJgb6cYHOLJ7TeEM6otzEO8u+AkSCG6KVkt00tprWlIL6VyYy6t1c0U1mVxvH4vg+fNJDZpJmnbzpJ14Bz2DnYMmRzGiBkRuHr+MNQtuXmY33uPqn/+E22x4DZuHP2W3I15eBTrT21k3cl1nKk9g6uDKzOjZrIgdgGjAkdhp35k9NtUbyxRzNwI2Vugtth4P3iYEeRx0yE8GTrxcNXSYuVIYRUH8swcagvzyvpmALxcTOdDfGREP4aFe+HqKGMZ0fPJapk+rKmwhoo1OTSfrqWyuYTD5dsJHj+E2VP+wLHdFfzjj4ewd7Bj2LRwRsyM/EGof99QunzlO9Tu2IEymfBatAinuxezQ2Wy9uQ7HF57GIVidPBolg1fxrSIaT/+YLT6LGRtgsxNxrrzlkZjdB43DQbMMr67B3T476qztHCooIIDeWb255lJO11JU9tyxFh/N2YmBJ4P9Bg/dzlIS/RpMnLvRaw1TVRtyqMutZim1kbSy3ei+jszav7d5BxqJmPvOezsFUMmhTLy0lC3WqnZuo3yd1bSmH4Ee29vvO68g+ypcawx72Ln6Z1YrBaivaJZELuAeTHzCHILar8QraEozQjzrK+gKN143zsSBs42Aj1yXIfLFCvrmziYX8GBvHIO5Jn57mw11lZ9foolOcqH5GgfkqJ88JEHn6KPkJF7H6JbWqn99ixVW/ONefXKgxR7nSX5P+6iuMCLja8XotEkTgpl5KzIH5yl3lpfT+UXX2J+912aCwsxRUbg9N+/YeOgBr44vYbSQ6V4OXlxc9zNLIxbyGDfK7Swa24wHoZmfgVZm9s6ECljimXa/xqh3sHKluLqRg7kmc9/ZRbXAOBob8fwcG/+z6RYkqN9GBnZT9rACdEB+T+kh2vIMFOxJpvWiibO1ueQ1XKIxMXz8Wy4mZ0fFdJiqWbgmCBumBeNp++FB4gtpaWYP/yQio9X01pVhfPw4Zy5bwar/DLZV/w6dtl2jA8dz1NxTzExbCKO9u2MjOvKjLnzzK+MefTmenB0N3qDDpxtNHx2a3+VjNaa0+YG9reNyg/mm8kvN05HdHW0Z1RkP+YPCyY52pehYV5yMqIQV0nCvYdqLq2ncu1JLNmV1DSbSa/aRejUEcT7PETq5nM01JwiZrg/oxfE4BNy4XRDS04O5e++S/WateiWFtSkseyZ4M379geotHxHSG0Iy4YvY1HcovanXWqKIWMdHF9jrD3XreAVDsPvNgI9ajw4tLODtS3M9+aWsfdkOftyzZyrNtaXe7uauCHKhyVjIkmO9iEh2FPOYRHiZ5Jw72F0SytVm/Op2XOGltYmvjPvQQ8w0X/6L/ludw215tOEDvRmzKJYgqIvbBZqSEuj7I0V1O7ahXJ2wjxzFKuH1rKTAzi0OjAldAqL+y9mTMiYy1e7VJ2BE22BXrAX0OA3ACY8CvELICix3emWM5UN7D1Z3hbm5ZypbADAz92R0TG+jInxJTnKh/4B8vBTiK4m4d6DWGubOPf3NHSRhdyadAqdTxI7ZxG5R5zZt6YM/wgPpi6JJyy+H0qp8w0xyt5YQf2+fWhPd44vTGRF/1OcM6UQ5RnFo/0fZX7sfHxdLjnutrIAjq81Ar3wgPFeQAJMfhISFkJA/GX1FVc3ng/zvbnl55tQeLuaGBPty39MimFsjC9xAe5yFosQ15iEew9Rm1dKycoj2FkUh2q24z06EVPRDaRursM7UDNr6RBiRvifD/WanTspf2MFDenpNPdzZ8e8IFYNLAWXXGZGzuTWAbcyMmDkD0PWnGeE+fE1RnciMEblU38P8QvBf8APaqpvamF/npndWWXszi4lu23DkIezA6Ojfbn3xijGxvgyKMhDRuZCXGcS7j1AwZZUrNsqsLY2kxdwGhUwmxP7mnDv18KUewYxaEwQdvZ2aKuV6i1bKFvxJpaMDOp83fh8jjObBzcQ4x/JowOWMjdmLp6Onhc+vLYEvvsCjn5qHJsLEDISpj9jTLn4XuiO1NqqOV5UzdfZpezOKiP1VAVN1lYcHewYHe3D4lFh3BjrR0KIJ/YS5kLYlIR7N6a1Juvd7bhmmGigjvwgF/Jy4nB214xbHMeQSaE4mOzRzc1UrllD2Vtv0pyXT3mAC6vn2rE/0cqM2Nm8M+h2hvpd1Gi6sRoy1huBnrvLeCgamAjTn4XBN/9gu//Zygb2ZJexO6eMb3LKzncWGhTkwX3johgf50dytI+sZhGim5Fw76aszc1kvPgVXhX9KLYWkVLvCQ2OJM0xzn9xdHGg1WLB/NEnlL71Fq1F5ygMcuAfi+woGOnLbfG381z/W/Bx9jE+sMUC2VuNQM/aZOwS9Y6E8Y9A4uLzc+gNTVb2ZZQYo/PssvNns/h7ODF5gD8TBvgxLs6PAA9pESdEdybh3g01lFeT++JOvKw+ZNblcaI5hPgbQxk9Pwb3fk60NjZifu9Dzq14A2WuJCtU8fltdrhMGMtdg+5kYthEo5NRq9XYWHT0U2MevbHKaDU38t8g8TajmYVSlNVa2HHwNFtPFLM7u5TG5lacHOwYHePL7UnhTBjgx8BAD3kIKkQPIuHezZgzCihZeRR35cXB6jzs44dyxy2x+IV50GqxUPbB+xS9/ioO5mqORSo2znVj0PTFPDfoDqK8oowPOfcdpH9szKXXnDU2FsXPN0bo0ZPB3oGTpbVs/TqXrceLOVRQgdYQ4uXM7UnhTIsPlKkWIXq4zjTIXgnMA0q01kPa+b0CXgbmAPXAfVrrQ11daF9w/LN9OO+vwQEHDikzo34zl4gEX1qbmij64B2K33gdp/IassJh1y1BjJn7a5bHLcLN5AZ15bDvDUj7EM4dATuTsUM08f/CgFlYHVw4VFDBts3ZbD1eTG6Z0cx5cIgnD0/rz/T4QAaHeMroXIheojMj93eB5cD7V/j9bKB/29do4PW27+IqHHhhA0ElbtS01mMZG8rCW2airC3kvr+CihVv4VpeR14opD0wiEkLH+Rv4ZOx163GPHrah8Z5Lq3NEDIC5jwPQ26l0eTF11mlbFmTzY6MEsx1TZjsFWNifLlvXBTT4wPlTHMheqkOw11r/bVSKupHLlkIvK+N4yX3KaW8lVLBWuuiLqqxV2tpaiHlmS8Jaw2iuLmImEem4BXozZH3XsLy9io8yxs4E6I49fBYpt32KDf7DQZzLmx/FtI+grpScAuAMf8Jw+6i0WcgX2eVsmHtKbYdL6auyYqnswNTBgUwIyGQiQP88XS+ikbUQogeqSvm3EOB0xe9Lmx7T8K9A7XFVWT+ZSthpiBO60KGPzOPtM+W07ryE3zKLBQF23Py8TlMu+MJFjj7GId0bXwacneCsjfOchlxD42Rk9mdW8WGnWfZdmIbtZYW+rmamD8shDmJwYyN9ZX2cUL0MV0R7u1N0rZ7SLxSaimwFCAiooMWbL3c2cN5VKw6ir+DPwWeJTQGZHFw7nj8S5s4E2Qi96nbmXLnE7jWlsK+FXB4ldG1yDMMpjyNJfFOdp9zZENaEVs/+he1lha8XU3MTQxm7lAJdCH6uq4I90Ig/KLXYcDZ9i7UWr8JvAlGs44u+Ns90okvD2L61oyLnQvpjqm4bn6XkOJmzgU5ce7pf2PSLx7GlLcTPrnH6C2qFPSfSfOIe/m6dTgbvith647j1Fha8HIxMScxiLlDQ7hRAl0I0aYrwn0t8KBSajXGg9QqmW+/spRXNuF/xon61iay8j9kwLF0zH5OVD39ayYuvBv7wx/A8lHGEkaPYPTExzkauIB/ZMP6T4uorD+Mp7MDs4YEMXdoMOPi/CTQhRCX6cxSyI+ByYCfUqoQ+F/ABKC1fgPYiLEMMgdjKeQvr1WxPZm12cqBZ78gvCWIEssZ9J7XCbGrpOnRX3LjnFmolDfh5aFgtUDsVIon/IGPKhP4MqWYAnMBziY7ZiYEsWhECOPj/HF0kEAXQlyZ9FC9DipLK8j40ybCHMMoqMrAdPA1nO9axOAZo7A7/LbxgNTBhZbE29nudQtvnjCReqoCpWBcrB+LRoRy0+BAPGSVixB9nvRQ7Sayd6fQ+OVpQkwhZJ/7Fv+IMuJfegD79Lfg8xfBI5jy0U/y98ZJrDpcQ3VjLTF+bvxu9iAWDg8lyEvOcBFCXD0J92to79uf45vhiruDB5k1u5l8qx2mrHWwvYjWwCEcHvX/eP7MYPb+qwaTfSWzhgRzV3IEY2J8ZKeoEOJnkXC/Rrb/z1vENsZioYHTbluZ0e8jSK2mIWw8/wx5kr9kBVNxqoVIXytPzh7E4lFh+Llf3ntUCCF+Cgn3Ltbc3Mzux1Yy0CWBsqZzODm+yAQyKPK/ieVNc/kwxwcHO8WMBD/uGh3BuFg/6VIkhOhyEu5dqLrUzLHn1jPALYGC2mz6ez5LRcR47qp4gL05PoR6u/DYzHB+kRROgKfMpQshrh0J9y6St+cbqj8rItwtmozKA3gMPMiSimfJzPcnOdqHN+ZHMyMhUNrPCSGuCwn3LnDw7VV4Zvjg5ehDStUW/uodS2nZvcwfFsIL46IYEupl6xKFEH2MhPvPtP33LxPTNIRmmvi8dgcfhUzinrGR3D06En8PeUAqhLANCfefyGq1su3h5SS4jaCiuZSPHPNJvPd+vhkZJh2MhBA2J+H+E5hLSjn+3DoGu4+ksC6P0jkR/PGmW2TVixCi25Bwv0onvjlAw6d5RLn3J7MqjbF/uQdXD29blyWEED8g4X4VdqxYRXCWF76OAaTV7mbe60/ZuiQhhGiXHC3YSeuefpGonCBMdiaOOu1j3nIJdiFE9yUj9w5ordn00N8Y5jqKamsFFYPNzPvV72xdlhBC/CgJ9x9RU1XDoac+JtEjiaL6AryXxDAheZGtyxJCiA5JuF9BTuoRKt8/RqxHPNnVR0n6wy/w8PWzdVlCCNEpEu7t2P3Bp/gediTAOZj0mm+Ys/wJlJ08nhBC9BwS7pdY/8zLxNfFgz2kq2+Z/6o8OBVC9DwS7hfZ8PDzJDonUddaTXFsEfMfkGAXQvRMEu5AQ10De594l2EeoyluKMTl5iCmTF5g67KEEOIn69REslJqllIqUymVo5R6sp3f36eUKlVKpbV9/brrS702Ck5kcvR3nzPAYwi5NSeIeXISCZOn2LosIYT4WTocuSul7IFXgRlAIXBQKbVWa338kks/0Vo/eA1qvGb2frYWj2+tBLmEc7R6HzNe/i0OJpOtyxJCiJ+tMyP3ZCBHa52rtW4CVgMLr21Z197GPy7Hb58jrg4epFv3MPu1xyXYhRC9RmfCPRQ4fdHrwrb3LnWrUuqIUuozpVR4ex+klFqqlEpRSqWUlpb+hHK7xvrf/pWEygSsuoWTQZnMf/5pm9UihBDXQmfCvb1zbPUlr9cBUVrrocA24L32Pkhr/abWOklrneTv7391lXYBS6OFbcuWM9x5DJVNZTROt2PGI8uuex1CCHGtdWa1TCFw8Ug8DDh78QVa6/KLXr4F/Pnnl9a1zuXmk/fS1wzyGMap2mziHptMYFSMrcsSQohrojPhfhDor5SKBs4AdwB3XXyBUipYa13U9nIBcKJLq/yZUtdvxrS9ljDXKI5XpzD5pQdwdJIWeEKI3qvDcNdatyilHgQ2A/bASq31MaXUc0CK1not8JBSagHQApiB+65hzVdl0wuvE1MUiaOpH2mWPcx/TTYmCSF6P6X1pdPn10dSUpJOSUm5pn9j3aN/ZYj9SJpbLeT6ZTLryf+6pn9PCCGuNaVUqtY6qaPreuUO1SaLhV2PvM5w99FUNJVgmWjHrJsl2IUQfUevC/eyM2fJ/NMmEjxGcboul/AHkwkbGG/rsoQQ4rrqVeF+dPsuWtaVEOnen4zqNCa88O84ubjZuiwhhLjuek24b3t1JWG5AXg4+pFW/w3zXrvsCBwhhOgzekUHinVP/pWYUxHYKweOuR9i3isS7EKIvq1Hj9ytVitbHnqZYe7JVLeYqU5qZO5dj9m6LCGEsLkeG+5VZWWkP/MliR43cLb+FAG/GsyQYSNsXZYQQnQLPTLcM/bup251HjHug8iqOcqYPy3B1dPT1mUJIUS30ePCfddbHxCQ4YWfcxDptd8y99X/tnVJQgjR7fSocF//+xeItwwFO81R0wHmLZdgF0KI9vSYcN/4m+cZ6ppErbWK0oQq5v36CVuXJIQQ3Va3D/faqmpSnvqIoR6jOddwGo87o5k0psc3ghJCiGuqW4f7ycNpmN85RpzHYE7WHGfEs7fi6edn67KEEKLb67bhvnvVavodcibQJYyjNfuZ/aqsXxdCiM7qluG+4dmXGFibgJ29HelqP/Nflfl1IYS4Gt0u3Dc89GeGuCRT31pHUUwR85dJsAshxNXqNuHeWFfHN4+/yzDPGylpOIvTokCmTrnf1mUJIUSP1C3CvTAzk8Ll+xnoOZT82kzin5qLb0iwrcsSQogey+bhfuCzNTh/YyXUNYrvqg8y9aVl0rxaCCF+pk4d+auUmqWUylRK5SilLjtPVynlpJT6pO33+5VSUZ353K/+9Are+xzxMHmRZt3LrNcekWAXQogu0GG4K6XsgVeB2UACcKdSKuGSy34FVGit44CXgD939LlVp88RXzEETSvZgRnMf16OEhBCiK7SmZF7MpCjtc7VWjcBq4FLt4guBN5r+/kzYJpSSv3Yh7rYuVPVZKZ2sh0zH112tXULIYT4EZ0J91Dg9EWvC9vea/carXULUAX4XvpBSqmlSqkUpVRKk7WRwIdHMWre7J9WuRBCiCvqTLi3NwLXP+EatNZvaq2TtNZJ7hF+BEVHd6ZGIYQQV6kz4V4IhF/0Ogw4e6VrlFIOgBdg7ooChRBCXL3OhPtBoL9SKlop5QjcAay95Jq1wL1tPy8GdmitLxu5CyGEuD46XOeutW5RSj0IbAbsgZVa62NKqeeAFK31WuDvwAdKqRyMEfsd17JoIYQQP65Tm5i01huBjZe89z8X/dwI3Na1pQkhhPipOrWJSQghRM8i4S6EEL2QhLsQQvRCEu5CCNELKVutWFRK1QCZNvnj3Y8fUGbrIroJuRcXyL24QO7FBQO11h4dXWTLI38ztdZJNvz73YZSKkXuhUHuxQVyLy6Qe3GBUiqlM9fJtIwQQvRCEu5CCNEL2TLc37Th3+5u5F5cIPfiArkXF8i9uKBT98JmD1SFEEJcOzItI4QQvZCEuxBC9EI2CfeOGm73FUqplUqpEqXUd7auxdaUUuFKqZ1KqRNKqWNKqYdtXZOtKKWclVIHlFLpbffiWVvXZEtKKXul1GGl1Hpb12JrSql8pdRRpVRaR0sir/uce1vD7SxgBkaTj4PAnVrr49e1kG5AKTURqAXe11oPsXU9tqSUCgaCtdaHlFIeQCqwqI/+d6EAN611rVLKBOwBHtZa77NxaTahlHoESAI8tdbzbF2PLSml8oEkrXWHG7psMXLvTMPtPkFr/TXSsQoArXWR1vpQ2881wAku79XbJ2hDbdtLU9tXn1z5oJQKA+YCb9u6lp7GFuHemYbbog9TSkUBI4D9tq3EdtqmItKAEmCr1rqv3ou/AU8ArbYupJvQwBalVKpSaumPXWiLcO9UM23RNyml3IHPgd9qrattXY+taK2tWuvhGD2Lk5VSfW7aTik1DyjRWqfaupZuZJzWeiQwG1jWNrXbLluEe2cabos+qG1++XPgQ631F7aupzvQWlcCu4BZNi7FFsYBC9rmmVcDU5VSq2xbkm1prc+2fS8BvsSY5m6XLcK9Mw23RR/T9hDx78AJrfWLtq7HlpRS/kop77afXYDpQIZtq7r+tNa/01qHaa2jMHJih9Z6iY3LshmllFvbYgOUUm7ATOCKK+2ue7hrrVuA7xtunwD+obU+dr3r6A6UUh8De4GBSqlCpdSvbF2TDY0D7sEYnaW1fc2xdVE2EgzsVEodwRgMbdVa9/llgIJAYI9SKh04AGzQWm+60sVy/IAQQvRCskNVCCF6IQl3IYTohSTchRCiF5JwF0KIXkjCXQgheiEJdyGE6IUk3IUQohf6/8nVnpGTvSUaAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption functions during working life\n", + "print(\"Consumption functions while working:\")\n", + "mMin = min(\n", + " [LifecycleExample.solution[t].mNrmMin for t in range(LifecycleExample.T_cycle)]\n", + ")\n", + "plotFuncs(LifecycleExample.cFunc[: LifecycleExample.T_retire], mMin, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions while retired:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption functions during retirement\n", + "print(\"Consumption functions while retired:\")\n", + "plotFuncs(LifecycleExample.cFunc[LifecycleExample.T_retire :], 0, 5)\n", + "LifecycleExample.timeRev()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Simulate some data; results stored in mNrmNow_hist, cNrmNow_hist, pLvlNow_hist, and t_age_hist\n", + "if do_simulation:\n", + " LifecycleExample.T_sim = 120\n", + " LifecycleExample.track_vars = [\"mNrmNow\", \"cNrmNow\", \"pLvlNow\", \"t_age\"]\n", + " LifecycleExample.initializeSim()\n", + " LifecycleExample.simulate()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# Make and solve a \"cyclical\" consumer type who lives the same four quarters repeatedly.\n", + "# The consumer has income that greatly fluctuates throughout the year.\n", + "CyclicalExample = IndShockConsumerType(**Params.init_cyclical)\n", + "CyclicalExample.cycles = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a cyclical consumer took 0.3813 seconds.\n" + ] + } + ], + "source": [ + "start_time = time()\n", + "CyclicalExample.solve()\n", + "end_time = time()\n", + "print(\"Solving a cyclical consumer took \" + mystr(end_time - start_time) + \" seconds.\")\n", + "CyclicalExample.unpackcFunc()\n", + "CyclicalExample.timeFwd()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quarterly consumption functions:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption functions for the cyclical consumer type\n", + "print(\"Quarterly consumption functions:\")\n", + "mMin = min([X.mNrmMin for X in CyclicalExample.solution])\n", + "plotFuncs(CyclicalExample.cFunc, mMin, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# Simulate some data; results stored in cHist, mHist, bHist, aHist, MPChist, and pHist\n", + "if do_simulation:\n", + " CyclicalExample.T_sim = 480\n", + " CyclicalExample.track_vars = [\"mNrmNow\", \"cNrmNow\", \"pLvlNow\", \"t_cycle\"]\n", + " CyclicalExample.initializeSim()\n", + " CyclicalExample.simulate()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# Make and solve an agent with a kinky interest rate\n", + "KinkyExample = KinkedRconsumerType()\n", + "KinkyExample.cycles = 0 # Make the Example infinite horizon" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a kinky consumer took 0.5089 seconds.\n", + "Kinky consumption function:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deXzV9Z3v8dcnCTtZgATISljCLosGRHFBsa1aK+24FKtdrBanrUunTqft3Bl7a3vvHTvtzPTe2qloHatWUau11FrXqrixhFUW2cKSECAhewhkO5/7RwKTIpgDnPDLOef9fDzy8PzO75vf+RzRt1+/v+/v+zV3R0REYktC0AWIiEjkKdxFRGKQwl1EJAYp3EVEYpDCXUQkBiUF9cHp6emen58f1MeLiESllStXHnD3jK7aBRbu+fn5FBUVBfXxIiJRycx2hdNOwzIiIjFI4S4iEoMU7iIiMUjhLiISgxTuIiIxSOEuIhKDFO4iIjEosHnuIiISnprGZjbtrefDfXVh/06X4W5mDwNXAeXuPvlj2s0AlgKfd/ffhV2BiIgA0NoWYseBg2zaV8+mvXV8uLeOTXvr2Vd3+KSvFU7P/RHgF8CjJ2pgZonAfcDLJ12BiEgcqjrY3B7eR4J8Xx1b9jfQ3BoCICnBGDN0IOeNHsL44clMyExhfGYyw+4L7/pdhru7LzGz/C6a3QE8C8wI72NFROJDW8jZcaCBDWXtvfAjQb6/rulom/SBfZiQmcxXzs8/GuSjMwbSO+nUb4ue9pi7mWUDnwMuReEuInHsYFMrH+6rZ+PeOjaW1bFxbx2b99VxuKW9N94r0RgzNJnZo9OP9sTHD08hI7lPxGuJxA3V/wC+6+5tZvaxDc1sAbAAIC8vLwIfLSJy5rk7FfVNbOgU4pvK6thReZAj21Kn9uvFxMwUbjx3BBMzU5iYdfq98ZMRiXAvBBZ1BHs6cKWZtbr788c2dPeFwEKAwsJC7cwtIj1e52GVIz3yTXvrONDQfLRN7uB+TMxMYd60bCZmtQd5VmpfuurwdqfTDnd3H3nktZk9ArxwvGAXEenpwhlWGTssmUvGDW0P8cwUxmemkNqvV8CVf1Q4UyGfBOYA6WZWCvwA6AXg7r/q1upERLpJ9cFm1pfVsn5PHRvKatnYw4ZVTlc4s2VuCPdi7v6V06pGRKQbVNQ3sX5PbftPR6DvqTl09HzOoH5MyupZwyqnS0+oikjMcHf21R1m/Z66vwrzztMOR6YP4OwRg/jSeSOYnJ3K5KxUUvv3vGGV06VwF5Go5O6UVh9iQ1ktH+z57+GVIzc6EwxGZwzk/NHpTMpK4azsVCZmpZDcN/aC/HgU7iLS44VCzu6qxvYQL6tlw5461pfVUtPYAkBiglEwdCBzxg3lrOxUJmenMCEzhf694zfi4vebi0iP5O6U1R5mXUkNa0trWVdawwd7aqk/3Aq0z1gZNzyZKyYPZ1JWKpOzUxk/PJm+vRIDrrxnUbiLSKAqG5pYV1rL2tIa1nWE+ZGhlaQEY3xmMp+ZmsWU7PYgHzssOWpmrARJ4S4iZ0zd4RbWl9aytrSWD/bUsLak9uisFTMYkzGQi8cOZUpOKlNyUpmQmaIe+SlSuItItzjc0saGsjrWdfTI15bWUFxx8Oj53MH9mJaXxpfPH8GUnDQmZ6cysI8iKVL0d1JETlso5BQfaGDV7hrWlNSwZncNW/bX0xpqfyIoI7kPU3NS+ey07I5eeRqDB/QOuOrYpnAXkZNWfbCZNSU1rC6pYfXuataU1By94ZncN4mpOWncdvEopuSkMTUnjWEpfaL6gaBopHAXkY/V0hbiw731rCmpZvXu9kDfcaB9eCXBYNzwFD4zNYtpuWmcnZfGqPSBJCQoyIOmcBeRv7K39hBrdv93r3xdaS1NHbsDpQ/sw9l5aVxfmMu03DSm5KQyQOPkPZL+VETiWEtbiA1ldRTtrGLlrvae+ZH9OnsnJTA5K4WbZo1gel4a03LTyE7rp+GVKKFwF4kjtY0trNpdTdGuKop2VrO2tObocrY5g/px7qjBTM9NY3reICZkpmg+eRRTuIvEKPf2R/aLdlZTtKualbuq2LK/AWh/XH9SVgo3zMyjcMRgCvMHMSylb8AVSyQp3EViROchlqKd1azcXU1FfftqiMl9kzg7bxCfmZLFOfmDmJabFtfrrsQD/emKRKnDLW2s3l3Dsh2VLCuuYnVJ9dEhltzB/bhgTDrnjBhEYf4gxg5N1gyWOKNwF4kSB5taWbW7mmXFVSzbUcnaklqa20KYwcTM9iGWGfmDKRwxiKEaYol7CneRHqrucAsrd1aztKNnvn5PLa0hJzHBmJydys2z8zl31GDOGTG4R+7hKcFSuIv0ELWNLe1DLDvae+Yby+oIefsSt0ee+Jw5cgjnjBikNVikS+FskP0wcBVQ7u6Tj3P+RuC7HYcNwNfdfW1EqxSJQYea21ixs4p3tx/g/e2VrN9TS8ihT1IC0/PSuOPSAs4dOZjpeYPo11srI8rJCec//48AvwAePcH5HcDF7l5tZlcAC4FzI1OeSOxoaQuxtqSGd7dV8u72A6zeXU1Lm9Mr0ZieO4g75xZw/uh0puam0idJYS6np8twd/clZpb/Meff63S4FMg5/bJEol8o5GzaV8d7HWG+fEcVjc1tmMGkrBS+Onsk549JZ0b+IE1LlIiL9D9RtwB/PtFJM1sALADIy8uL8EeLBK+kqpElWyt4d1v7UEt1xx6fozIGcM3ZOcweM4RZo4aQ1l/L3Ur3ili4m9kltIf7BSdq4+4LaR+2obCw0CP12SJBOdjUytLiSpZsqWDJ1gNHV0vMTO3LpeOHMXvMEM4fnc7wVE1NlDMrIuFuZlOAh4Ar3L0yEtcU6YncnY1761iy5QBLtlRQtKuKljanb68EZo0awhdnjeCisRmMzhigBbYkUKcd7maWBzwHfNHdt5x+SSI9S9XBZt7eWsFbWypYsuUABxraH+kfPzyZm2eP5KKCDArzB2mvT+lRwpkK+SQwB0g3s1LgB0AvAHf/FXAPMAT4ZUdPpdXdC7urYJHu5u5sLW/gtU37+cumclbtribkMKh/Ly4oyOCignQuGpuhhbakRwtntswNXZy/Fbg1YhWJBKCptY1lxVX85cNyXv9wPyVVhwCYnJ3CHZcWcMn4oZyVnUqi1meRKKH5VxK3qg8289qm/by+qZy3t1ZwsLmNPkkJXDAmna9fPIZLxw/VjVCJWgp3iSvl9Yd5ecN+Xlq/l6XFVbSFnOEpfZk3PZu544dy/uh0PQ0qMUHhLjGvrOYQL63fx5/X76VoVzXuMCp9ALddNIorJmcyOTtFM1sk5ijcJSbVHmrhpfV7eW7VHpbtqALaZ7fcNbeAKyZnMnbYQAW6xDSFu8SM5tYQb22p4PnVe3h1036aW0OMSh/A3Z8Yy1VTsxiZPiDoEkXOGIW7RL3iigZ+u2w3z60qpbqxhSEDevOFmXl8bno2U3JS1UOXuKRwl6jU3Bri1Y37+e2yXby3vZKkBONTk4ZzzTnZXFiQQa/EhKBLFAmUwl2iSml1I4uWl7BoRQkHGprITuvHdz41jusLc8lI7hN0eSI9hsJdery2kPPWlnIeX7qbNzaXA3DpuKHc1LGOix4sEvkohbv0WHtqDvFMUQnPFJWyp+YQ6QP78M05Y5g/M5ecQf2DLk+kR1O4S4/S3Bri9U37WbSihCVbK3CHCwvS+ccrJ/DJScM0li4SJoW79AjbKxp4ekUJz64q5UBDM8NT+nLHJWO4rjCX3MHqpYucLIW7BOZQcxsvfrCXp1aUsHxnFUkJxtwJQ5k/I09j6SKnSeEuZ9z6PbU8taKE59fsof5wK/lD+vPdy8dzzTnZDE3WQl0ikaBwlzOi9lALi9fs4amiEtbvqaNPUgJXnpXJ52fkcu7IwXrQSCTCFO7SbUIhZ2lxJU8VlfDS+n00tYaYkJnCvfMmMW9qNqn9ewVdokjMUrhLxJXVHOJ3K0t5ZmUJJVWHSO6bxPWFuXx+Ri6TsrQCo8iZoHCXiGhqbeO1jeU8VVTC2x1TGGePGcLff3Icn5o0XPuLipxhCnc5LVv21/Pk8t08v3oP1Y0tZKVqCqNITxDOBtkPA1cB5e4++TjnDfg5cCXQCHzF3VdFulDpOZpa23hp/T5+u3Q3y3dW0TsxgU9MGsb1hblcMCZdUxhFeoBweu6PAL8AHj3B+SuAgo6fc4H/7PirxJiSqkaeWL6bp1eUUHmwmRFD+vP9K8ZzXWEugwf0Dro8Eemky3B39yVmlv8xTeYBj7q7A0vNLM3MMt19b4RqlICt3l3NA28V8/LGfRgwd8Iwbpo1ggvHpJOgXrpIjxSJMfdsoKTTcWnHex8JdzNbACwAyMvLi8BHS3dav6eWH/9pI0uLq0jpm8Q35ozmxnNHkJXWL+jSRKQLkQj343Xd/HgN3X0hsBCgsLDwuG0keNUHm7nvpQ95qqiEwf17889XTWT+jFwG9NH9d5FoEYl/W0uB3E7HOUBZBK4rAXh1436+/9wH1DQ2c8vskdx5WQEpffWwkUi0iUS4LwZuN7NFtN9IrdV4e/SpbWzhh3/cwHOr9zAhM4XffHUGk7JSgy5LRE5ROFMhnwTmAOlmVgr8AOgF4O6/Al6kfRrkNtqnQt7cXcVK99i8r54vPbyMAw3N3HnpGG6/tIDeSVo3XSSahTNb5oYuzjvwzYhVJGfcDxavpy3kPP+N2ZyVo966SCxQ9yzObd5Xz9LiKm69cJSCXSSGKNzj3KPv76RPUgKfL8ztsq2IRA+FexyrO9zC71fv4TNTsxikJ0xFYorCPY49t7KUxuY2vnTeiKBLEZEIU7jHKXfn0aW7mJabxpSctKDLEZEIU7jHqXe3VVJccVC9dpEYpXCPU4++v5PBA3pz5VmZQZciIt1A4R6H9tQc4rVN+5k/I1c7JInEKIV7HHr4nR2YGTfO0pCMSKzSMn9xxN353cpSHlu6i3nTssjW0r0iMUvhHieaW0Pc84f1LFpRwqxRg/nHKycEXZKIdCOFexyoOtjM3z6+kuU7qvjGnNHc/clx2udUJMYp3GPc5n313PKbFZTXN/Hz+dOYNy076JJE5AxQuMew1zft584nV9O/TxJPLZjF9LxBQZckImeIwj0GuTsLlxTzLy99yKSsFB78UiGZqbp5KhJPFO4xpqm1jX98bj3Prirl02dl8tPrptKvt+ayi8QbhXsMqahv4rbHili1u4a75hZw19wCEnTjVCQuKdxjxPo9tSx4tIiqxmZ+8YXpXDUlK+iSRCRACvcY8Kd1e7n7mTUM6t+bZ247XzsqiUh4yw+Y2eVmttnMtpnZ945zPs/M3jCz1Wa2zsyujHypcqxQyPm3VzbzzSdWMTEzhT/crj1QRaRdlz13M0sE7gc+AZQCK8xssbtv7NTsn4Cn3f0/zWwi8CKQ3w31SoeGpla+/dQaXtm4n+vOyeHHn5tMnyTdOBWRduEMy8wEtrl7MYCZLQLmAZ3D3YGUjtepQFkki5S/tqGsljueWM3OyoPcc9VEbp6dj5lunIrIfwsn3LOBkk7HpcC5x7T5n8ArZnYHMAC47HgXMrMFwAKAvLy8k6017rk7jy/bzY9e2Ehav1789tZZnDd6SNBliUgPFM6Y+/G6hH7M8Q3AI+6eA1wJPGZmH7m2uy9090J3L8zIyDj5auNY3eEWbn9iNf/8/HrOGzWEP991oYJdRE4onJ57KZDb6TiHjw673AJcDuDu75tZXyAdKI9EkfFubUkNtz+5irKaw3zvivEsuHCU5q+LyMcKp+e+Aigws5Fm1huYDyw+ps1uYC6AmU0A+gIVkSw0Hrk7v35nB9f+6j3a2pynb5vF3148WsEuIl3qsufu7q1mdjvwMpAIPOzuG8zsXqDI3RcDdwMPmtnf0T5k8xV3P3boRk5CTWMzf//MOl7btJ/LJgzjp9dNIa1/76DLEpEoEdZDTO7+Iu3TGzu/d0+n1xuB2ZEtLX6t3FXFHU+spqKhSbNhROSU6AnVHiQUch5YUsxPX9lMdlo/nv36+UzJSQu6LBGJQgr3HqKyoYlvP72Wt7ZUcOVZw/mXa6aQ0rdX0GWJSJRSuPcAS4sruWvRaqobW/jxZydz47l5GoYRkdOicA9QW8j5xV+28fPXt5A/ZAD/9ZWZTMxK6foXRUS6oHAPSHndYb711Bre217JZ6dl8ePPncXAPvrjEJHIUJoE4O2tFfzdU2toaGrlJ9dO4bpzcjQMIyIRpXA/g9pCzs9f28L/e2MbBUMH8sTXZjF2WHLQZYlIDFK4nyHl9Ye568k1vF9cybXn5PCjeZO1t6mIdBuF+xnw/vZK7ly0mvrDLfzk2ilcX5jb9S+JiJwGhXs3CoWc/3xrOz97ZTP56QN47JaZjB+u2TAi0v0U7t2ktrGFu55azZubK7h6ahb/+280G0ZEzhylTTfYVl7P1x5dSWl1Iz/67GRu0kNJInKGKdwj7PVN+7lr0Rr69krgia/NYkb+4KBLEpE4pHCPEHfnl29u56evbGZSVgoPfLGQ7LR+QZclInFK4R4BLW0hvvfsBzy7qpSrp2Zx3zVTNM1RRAKlcD9NDU2tfP3xlby99QB3zS3gW5cVaHxdRAKncD8N5XWH+cp/rWDz/np+cs0Urp+h+esi0jMo3E/RrsqDfOHBZVQ3NvPrLxcyZ9zQoEsSETkqnA2yMbPLzWyzmW0zs++doM31ZrbRzDaY2RORLbNn2V7RwPUPvM/B5lYWLZilYBeRHqfLnruZJQL3A58ASoEVZra4Y9/UI20KgO8Ds9292sxiNu0276vnxoeWAc6iBbP0xKmI9Ejh9NxnAtvcvdjdm4FFwLxj2nwNuN/dqwHcvTyyZfYMH+6rY/7C90lMgEULzlOwi0iPFU64ZwMlnY5LO97rbCww1szeNbOlZnZ5pArsKXYcOMhNDy2nT1IiTy04jzFDBwZdkojICYVzQ/V48/r8ONcpAOYAOcDbZjbZ3Wv+6kJmC4AFAHl5eSddbFDKag5x00PLCLnz+K2zyE8fEHRJIiIfK5yeeynQeY5fDlB2nDZ/cPcWd98BbKY97P+Kuy9090J3L8zIyDjVms+oyoYmbvr1MuoOtfDoV2eqxy4iUSGccF8BFJjZSDPrDcwHFh/T5nngEgAzS6d9mKY4koUG4XBLGwseW8me6kM8fPMMJmenBl2SiEhYugx3d28FbgdeBjYBT7v7BjO718yu7mj2MlBpZhuBN4DvuHtldxV9Jrg73312HSt3VfPvn5+mBcBEJKqE9RCTu78IvHjMe/d0eu3Atzt+YsLPX9/KH9aU8Z1PjePKszKDLkdE5KSE9RBTvHnxg738x2tbuebsHL4xZ3TQ5YiInDSF+zG2VzTwnWfWMj0vjf/zN2dpETARiUoK904am1v5xuOr6J2UwP1fOJveSfrbIyLRSQuHdXB3/un369lSXs8jN88kSxttiEgUU9e0w+9WlvLc6j3ceWkBF4+Njjn4IiInonAHSqoa+eEfNzJz5GDunPuRZ69ERKJO3Id7KOTc/cxaAH523VQSE3QDVUSiX9yH+6/f2cHyHVXc85mJ5A7uH3Q5IiIREdfhvmV/Pf/68mY+MXEY152TE3Q5IiIRE7fhHgo533/uAwb0SdR8dhGJOXEb7k8s383KXdX8j09PJH1gn6DLERGJqLgM9/K6w9z30oecP3oI15x97L4jIiLRLy7D/YcvbKSpNcT/+pyGY0QkNsVduL+5uZw/rdvLHZeMYaR2VBKRGBVX4d7cGuLeFzYyKn0At12s1R5FJHbFVbg/+v5OiisO8k9XTdCiYCIS0+Im4Sobmvj561u5eGwGl4wbGnQ5IiLdKm7C/WevbqGxuY1/vmqCbqKKSMyLi3DfWFbHouW7+dJ5IxgzNDnockREul1Y4W5ml5vZZjPbZmbf+5h215qZm1lh5Eo8Pe7Oj/+0kdR+vfjW3LFBlyMickZ0Ge5mlgjcD1wBTARuMLOJx2mXDNwJLIt0kafj7a0HeG97JXfOLSC1f6+gyxEROSPC6bnPBLa5e7G7NwOLgHnHafcj4CfA4QjWd1pCIee+lz4kZ1A/vnBuXtDliIicMeGEezZQ0um4tOO9o8xsOpDr7i983IXMbIGZFZlZUUVFxUkXe7Je+GAvG8rquPuTY+mTlNjtnyci0lOEE+7Hm1riR0+aJQD/Dtzd1YXcfaG7F7p7YUZG925l19IW4mevbGb88GSunqr1Y0QkvoQT7qVAbqfjHKCs03EyMBl408x2ArOAxUHfVF20ooRdlY38w+XjtLuSiMSdcMJ9BVBgZiPNrDcwH1h85KS717p7urvnu3s+sBS42t2LuqXiMDQ2t/J/X9/KzPzBemBJROJSl+Hu7q3A7cDLwCbgaXffYGb3mtnV3V3gqXjkvZ1U1DfxD5eP0wNLIhKXksJp5O4vAi8e8949J2g75/TLOnUNTa08uKSYS8ZlUJg/OMhSREQCE3NPqP7mvZ1UN7Zw12V6YElE4ldMhXtDUysPvt3ea5+WmxZ0OSIigYmpcP/NezupUa9dRCR2wr3+cAsPvl3MpeOHqtcuInEvZsL90fd3tffa5xYEXYqISOBiItw799qnqtcuIhIb4X6k1/6ty9RrFxGBGAj3IzNk5o4fypQc9dpFRCAGwv23S9t77XdqrF1E5KioDvfDLW08+PYOLixI11i7iEgnUR3uz6ws5UBDE9+YMyboUkREepSoDffWthAPvLWd6XlpzBqlNWRERDqL2nD/47oySqsP8c05Y7Tyo4jIMaIy3EMh55dvbGf88GQuHa/12kVEjhWV4f7qpv1sLW/g63NGk6BdlkREPiLqwt3d+eUb2xgxpD+fPisz6HJERHqkqAv3d7dVsra0ltsuGk1SYtSVLyJyRkRdOv7yzW0MTe7DNedkB12KiEiPFVXhvmp3Ne9tr2TBRaPok5QYdDkiIj1WWOFuZpeb2WYz22Zm3zvO+W+b2UYzW2dmr5vZiMiXCr98Yztp/Xtxw8y87ri8iEjM6DLczSwRuB+4ApgI3GBmE49pthoodPcpwO+An0S60A/31fHapv3cfP5IBvQJa19vEZG4FU7PfSawzd2L3b0ZWATM69zA3d9w98aOw6VATmTLhAfeKqZ/70S+fH63/E+BiEhMCSfcs4GSTselHe+dyC3An493wswWmFmRmRVVVFSEXWRZzSH+uLaM+TPySOvfO+zfExGJV+GE+/GeEvLjNjS7CSgE/vV45919obsXunthRkZG2EU+/M4OHPjqBflh/46ISDwLZ/C6FMjtdJwDlB3byMwuA/4HcLG7N0WmPKg91MKTy3dz1ZRMcgb1j9RlRURiWjg99xVAgZmNNLPewHxgcecGZjYdeAC42t3LI1ngE8t2c7C5jQUXjYrkZUVEYlqX4e7urcDtwMvAJuBpd99gZvea2dUdzf4VGAg8Y2ZrzGzxCS53Uppa2/ivd3dwwZh0JmWlRuKSIiJxIaw5he7+IvDiMe/d0+n1ZRGuC4A/rCmjvL6Jn143tTsuLyISs3rsE6qhkPPgkmImZKZwYUF60OWIiESVHhvub24pZ2t5AwsuGqnNOERETlKPDfcH3iomK7UvV03JCroUEZGo0yPDfW1JDct2VPHVC0bSS8v6ioictB6ZnAuXFJPcN4n5WiBMROSU9Lhw313ZyJ/X7+XGc0cwUAuEiYickh4X7g+9U0xignHz7PygSxERiVo9KtyrDjbzdFEJn52WzbCUvkGXIyIStXpUuD/2/i4Ot4S01ICIyGnqMeF+uKWN37y/k0vHD6VgWHLQ5YiIRLUeE+7PrCyl6mCzeu0iIhHQI8K9LeQ89HYxU3NSOXfk4KDLERGJej0i3F/ZsI9dlY3cdvFoLTUgIhIBgYe7u/PAkmJGDOnPpyYND7ocEZGYEHi4r9hZzZqSGm69YCSJCeq1i4hEQuDhvnDJdgYP6M215+R23VhERMISaLhvK6/ntU3lfHHWCPr1TgyyFBGRmBJouD+4ZAd9khL40nkjgixDRCTmBBburW3O71fv4brCHIYM7BNUGSIiMSmscDezy81ss5ltM7PvHed8HzN7quP8MjPL7+qaBw420RIKcesFemhJRCTSugx3M0sE7geuACYCN5jZxGOa3QJUu/sY4N+B+7q6blVDM5dPGk5++oCTr1pERD5WOD33mcA2dy9292ZgETDvmDbzgN90vP4dMNe6eBqpzV1LDYiIdJNwwj0bKOl0XNrx3nHbuHsrUAsMOfZCZrbAzIrMrKhfQojpeYNOrWoREflY4YT78XrgfgptcPeF7l7o7oVjMhXsIiLdJZxwLwU6P2GUA5SdqI2ZJQGpQFUkChQRkZMXTrivAArMbKSZ9QbmA4uPabMY+HLH62uBv7j7R3ruIiJyZnS5A7W7t5rZ7cDLQCLwsLtvMLN7gSJ3Xwz8GnjMzLbR3mOf351Fi4jIx+sy3AHc/UXgxWPeu6fT68PAdZEtTURETlXgC4eJiEjkKdxFRGKQwl1EJAYp3EVEYpAFNWPRzCqAXYF8+KlJBw4EXcQZoO8Ze+Llu8bL9xzn7sldNQprtkx3cPeMoD77VJhZkbsXBl1Hd9P3jD3x8l3j6XuG007DMiIiMUjhLiISgxTu4VsYdAFniL5n7ImX76rv2UlgN1RFRKT7qOcuIhKDFO4iIjFI4R6GrjYIjwVm9rCZlZvZ+qBr6U5mlmtmb5jZJjPbYGZ3BV1TdzCzvma23MzWdnzPHwZdU3cys0QzW21mLwRdS3cys51m9oGZrelqSqTG3LvQsUH4FuATtG9KsgK4wd03BlpYhJnZRUAD8Ki7Tw66nu5iZplApruvMrNkYCXw2Rj88zRggLs3mFkv4B3gLndfGnBp3cLMvg0UAinuflXQ9XQXM9sJFLp7lw9rqefetXA2CI967r6EONg9y933uvuqjtf1wCY+uidw1PN2DR2HvTp+YrInZ2Y5wKeBh4KupSdRuHctnA3CJQqZWT4wHVgWbCXdo2OoYg1QDrzq7jH5PYH/AP4BCAVdyBngwCtmttLMFnxcQ4V718La/Fuii5kNBJ4FvuXudUHX0x3cvc3dp9G+7/FMM4u54TYzuwoodzazn0UAAAEfSURBVPeVQddyhsx297OBK4BvdgynHpfCvWvhbBAuUaRjDPpZ4Lfu/lzQ9XQ3d68B3gQuD7iU7jAbuLpjLHoRcKmZPR5sSd3H3cs6/loO/J72YePjUrh3LZwNwiVKdNxo/DWwyd3/Leh6uouZZZhZWsfrfsBlwIfBVhV57v59d89x93za/938i7vfFHBZ3cLMBnRMAsDMBgCfBE44u03h3gV3bwWObBC+CXja3TcEW1XkmdmTwPvAODMrNbNbgq6pm8wGvkh7D29Nx8+VQRfVDTKBN8xsHe0dlFfdPaanCcaBYcA7ZrYWWA78yd1fOlFjTYUUEYlB6rmLiMQghbuISAxSuIuIxCCFu4hIDFK4i4jEIIW7iEgMUriLiMSg/w/HJypz6K/iPgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "start_time = time()\n", + "KinkyExample.solve()\n", + "end_time = time()\n", + "print(\"Solving a kinky consumer took \" + mystr(end_time - start_time) + \" seconds.\")\n", + "KinkyExample.unpackcFunc()\n", + "print(\"Kinky consumption function:\")\n", + "KinkyExample.timeFwd()\n", + "plotFuncs(KinkyExample.cFunc[0], KinkyExample.solution[0].mNrmMin, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "if do_simulation:\n", + " KinkyExample.T_sim = 120\n", + " KinkyExample.track_vars = [\"mNrmNow\", \"cNrmNow\", \"pLvlNow\"]\n", + " KinkyExample.initializeSim()\n", + " KinkyExample.simulate()" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + }, + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/HARK/ConsumptionSaving/example_ConsIndShock.py b/examples/ConsumptionSaving/example_ConsIndShock.py similarity index 50% rename from HARK/ConsumptionSaving/example_ConsIndShock.py rename to examples/ConsumptionSaving/example_ConsIndShock.py index 2544edc54..6f47c197c 100644 --- a/HARK/ConsumptionSaving/example_ConsIndShock.py +++ b/examples/ConsumptionSaving/example_ConsIndShock.py @@ -1,103 +1,123 @@ import HARK.ConsumptionSaving.ConsumerParameters as Params -from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType, IndShockConsumerType, KinkedRconsumerType +from HARK.ConsumptionSaving.ConsIndShockModel import ( + PerfForesightConsumerType, + IndShockConsumerType, + KinkedRconsumerType, +) from HARK.utilities import plotFuncsDer, plotFuncs from time import time +mystr = lambda number: "{:.4f}".format(number) -mystr = lambda number : "{:.4f}".format(number) -do_simulation = True +do_simulation = True # Make and solve an example perfect foresight consumer PFexample = PerfForesightConsumerType() -PFexample.cycles = 0 # Make this type have an infinite horizon +# Make this type have an infinite horizon +PFexample.cycles = 0 start_time = time() PFexample.solve() end_time = time() -print('Solving a perfect foresight consumer took ' + mystr(end_time-start_time) + ' seconds.') +print( + "Solving a perfect foresight consumer took " + + mystr(end_time - start_time) + + " seconds." +) PFexample.unpackcFunc() PFexample.timeFwd() # Plot the perfect foresight consumption function -print('Perfect foresight consumption function:') +print("Perfect foresight consumption function:") mMin = PFexample.solution[0].mNrmMin -plotFuncs(PFexample.cFunc[0],mMin,mMin+10) +plotFuncs(PFexample.cFunc[0], mMin, mMin + 10) if do_simulation: - PFexample.T_sim = 120 # Set number of simulation periods - PFexample.track_vars = ['mNrmNow'] + PFexample.T_sim = 120 # Set number of simulation periods + PFexample.track_vars = ["mNrmNow"] PFexample.initializeSim() PFexample.simulate() -"" # Make and solve an example consumer with idiosyncratic income shocks IndShockExample = IndShockConsumerType() -IndShockExample.cycles = 0 # Make this type have an infinite horizon +IndShockExample.cycles = 0 # Make this type have an infinite horizon start_time = time() IndShockExample.solve() end_time = time() -print('Solving a consumer with idiosyncratic shocks took ' + mystr(end_time-start_time) + ' seconds.') +print( + "Solving a consumer with idiosyncratic shocks took " + + mystr(end_time - start_time) + + " seconds." +) IndShockExample.unpackcFunc() IndShockExample.timeFwd() # Plot the consumption function and MPC for the infinite horizon consumer -print('Concave consumption function:') -plotFuncs(IndShockExample.cFunc[0],IndShockExample.solution[0].mNrmMin,5) -print('Marginal consumption function:') -plotFuncsDer(IndShockExample.cFunc[0],IndShockExample.solution[0].mNrmMin,5) +print("Concave consumption function:") +plotFuncs(IndShockExample.cFunc[0], IndShockExample.solution[0].mNrmMin, 5) +print("Marginal consumption function:") +plotFuncsDer(IndShockExample.cFunc[0], IndShockExample.solution[0].mNrmMin, 5) # Compare the consumption functions for the perfect foresight and idiosyncratic # shock types. Risky income cFunc asymptotically approaches perfect foresight cFunc. -print('Consumption functions for perfect foresight vs idiosyncratic shocks:') -plotFuncs([PFexample.cFunc[0],IndShockExample.cFunc[0]],IndShockExample.solution[0].mNrmMin,100) +print("Consumption functions for perfect foresight vs idiosyncratic shocks:") +plotFuncs( + [PFexample.cFunc[0], IndShockExample.cFunc[0]], + IndShockExample.solution[0].mNrmMin, + 100, +) # Compare the value functions for the two types if IndShockExample.vFuncBool: - print('Value functions for perfect foresight vs idiosyncratic shocks:') - plotFuncs([PFexample.solution[0].vFunc,IndShockExample.solution[0].vFunc], - IndShockExample.solution[0].mNrmMin+0.5,10) + print("Value functions for perfect foresight vs idiosyncratic shocks:") + plotFuncs( + [PFexample.solution[0].vFunc, IndShockExample.solution[0].vFunc], + IndShockExample.solution[0].mNrmMin + 0.5, + 10, + ) # Simulate some data; results stored in mNrmNow_hist, cNrmNow_hist, and pLvlNow_hist if do_simulation: IndShockExample.T_sim = 120 - IndShockExample.track_vars = ['mNrmNow','cNrmNow','pLvlNow'] - IndShockExample.makeShockHistory() # This is optional, simulation will draw shocks on the fly if it isn't run. + IndShockExample.track_vars = ["mNrmNow", "cNrmNow", "pLvlNow"] + IndShockExample.makeShockHistory() # This is optional, simulation will draw shocks on the fly if it isn't run. IndShockExample.initializeSim() IndShockExample.simulate() -########################################################################### - # Make and solve an idiosyncratic shocks consumer with a finite lifecycle LifecycleExample = IndShockConsumerType(**Params.init_lifecycle) -LifecycleExample.cycles = 1 # Make this consumer live a sequence of periods exactly once +LifecycleExample.cycles = ( + 1 +) # Make this consumer live a sequence of periods exactly once start_time = time() LifecycleExample.solve() end_time = time() -print('Solving a lifecycle consumer took ' + mystr(end_time-start_time) + ' seconds.') +print("Solving a lifecycle consumer took " + mystr(end_time - start_time) + " seconds.") LifecycleExample.unpackcFunc() LifecycleExample.timeFwd() # Plot the consumption functions during working life -print('Consumption functions while working:') -mMin = min([LifecycleExample.solution[t].mNrmMin for t in range(LifecycleExample.T_cycle)]) -plotFuncs(LifecycleExample.cFunc[:LifecycleExample.T_retire],mMin,5) +print("Consumption functions while working:") +mMin = min( + [LifecycleExample.solution[t].mNrmMin for t in range(LifecycleExample.T_cycle)] +) +plotFuncs(LifecycleExample.cFunc[: LifecycleExample.T_retire], mMin, 5) # Plot the consumption functions during retirement -print('Consumption functions while retired:') -plotFuncs(LifecycleExample.cFunc[LifecycleExample.T_retire:],0,5) +print("Consumption functions while retired:") +plotFuncs(LifecycleExample.cFunc[LifecycleExample.T_retire :], 0, 5) LifecycleExample.timeRev() # Simulate some data; results stored in mNrmNow_hist, cNrmNow_hist, pLvlNow_hist, and t_age_hist if do_simulation: LifecycleExample.T_sim = 120 - LifecycleExample.track_vars = ['mNrmNow','cNrmNow','pLvlNow','t_age'] + LifecycleExample.track_vars = ["mNrmNow", "cNrmNow", "pLvlNow", "t_age"] LifecycleExample.initializeSim() LifecycleExample.simulate() -"" # Make and solve a "cyclical" consumer type who lives the same four quarters repeatedly. # The consumer has income that greatly fluctuates throughout the year. CyclicalExample = IndShockConsumerType(**Params.init_cyclical) @@ -106,43 +126,37 @@ start_time = time() CyclicalExample.solve() end_time = time() -print('Solving a cyclical consumer took ' + mystr(end_time-start_time) + ' seconds.') +print("Solving a cyclical consumer took " + mystr(end_time - start_time) + " seconds.") CyclicalExample.unpackcFunc() CyclicalExample.timeFwd() # Plot the consumption functions for the cyclical consumer type -print('Quarterly consumption functions:') +print("Quarterly consumption functions:") mMin = min([X.mNrmMin for X in CyclicalExample.solution]) -plotFuncs(CyclicalExample.cFunc,mMin,5) +plotFuncs(CyclicalExample.cFunc, mMin, 5) # Simulate some data; results stored in cHist, mHist, bHist, aHist, MPChist, and pHist if do_simulation: CyclicalExample.T_sim = 480 - CyclicalExample.track_vars = ['mNrmNow','cNrmNow','pLvlNow','t_cycle'] + CyclicalExample.track_vars = ["mNrmNow", "cNrmNow", "pLvlNow", "t_cycle"] CyclicalExample.initializeSim() CyclicalExample.simulate() -"" # Make and solve an agent with a kinky interest rate KinkyExample = KinkedRconsumerType() -KinkyExample.cycles = 0 # Make the Example infinite horizon +KinkyExample.cycles = 0 # Make the Example infinite horizon start_time = time() KinkyExample.solve() end_time = time() -print('Solving a kinky consumer took ' + mystr(end_time-start_time) + ' seconds.') +print("Solving a kinky consumer took " + mystr(end_time - start_time) + " seconds.") KinkyExample.unpackcFunc() -print('Kinky consumption function:') +print("Kinky consumption function:") KinkyExample.timeFwd() -plotFuncs(KinkyExample.cFunc[0],KinkyExample.solution[0].mNrmMin,5) +plotFuncs(KinkyExample.cFunc[0], KinkyExample.solution[0].mNrmMin, 5) if do_simulation: KinkyExample.T_sim = 120 - KinkyExample.track_vars = ['mNrmNow','cNrmNow','pLvlNow'] + KinkyExample.track_vars = ["mNrmNow", "cNrmNow", "pLvlNow"] KinkyExample.initializeSim() KinkyExample.simulate() - - - -"" - diff --git a/examples/ConsumptionSaving/example_ConsMarkovModel.ipynb b/examples/ConsumptionSaving/example_ConsMarkovModel.ipynb new file mode 100644 index 000000000..e4a222e37 --- /dev/null +++ b/examples/ConsumptionSaving/example_ConsMarkovModel.ipynb @@ -0,0 +1,492 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import HARK.ConsumptionSaving.ConsumerParameters as Params\n", + "from HARK.utilities import plotFuncs\n", + "from time import process_time\n", + "from copy import deepcopy, copy\n", + "import numpy as np\n", + "from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType\n", + "mystr = lambda number: \"{:.4f}\".format(number)\n", + "do_simulation = True" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Define the Markov transition matrix for serially correlated unemployment\n", + "unemp_length = 5 # Averange length of unemployment spell\n", + "urate_good = 0.05 # Unemployment rate when economy is in good state\n", + "urate_bad = 0.12 # Unemployment rate when economy is in bad state\n", + "bust_prob = 0.01 # Probability of economy switching from good to bad\n", + "recession_length = 20 # Averange length of bad state\n", + "p_reemploy = 1.0 / unemp_length\n", + "p_unemploy_good = p_reemploy * urate_good / (1 - urate_good)\n", + "p_unemploy_bad = p_reemploy * urate_bad / (1 - urate_bad)\n", + "boom_prob = 1.0 / recession_length\n", + "MrkvArray = np.array(\n", + " [\n", + " [\n", + " (1 - p_unemploy_good) * (1 - bust_prob),\n", + " p_unemploy_good * (1 - bust_prob),\n", + " (1 - p_unemploy_good) * bust_prob,\n", + " p_unemploy_good * bust_prob,\n", + " ],\n", + " [\n", + " p_reemploy * (1 - bust_prob),\n", + " (1 - p_reemploy) * (1 - bust_prob),\n", + " p_reemploy * bust_prob,\n", + " (1 - p_reemploy) * bust_prob,\n", + " ],\n", + " [\n", + " (1 - p_unemploy_bad) * boom_prob,\n", + " p_unemploy_bad * boom_prob,\n", + " (1 - p_unemploy_bad) * (1 - boom_prob),\n", + " p_unemploy_bad * (1 - boom_prob),\n", + " ],\n", + " [\n", + " p_reemploy * boom_prob,\n", + " (1 - p_reemploy) * boom_prob,\n", + " p_reemploy * (1 - boom_prob),\n", + " (1 - p_reemploy) * (1 - boom_prob),\n", + " ],\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Make a consumer with serially correlated unemployment, subject to boom and bust cycles\n", + "init_serial_unemployment = copy(Params.init_idiosyncratic_shocks)\n", + "init_serial_unemployment[\"MrkvArray\"] = [MrkvArray]\n", + "init_serial_unemployment[\"UnempPrb\"] = 0 # to make income distribution when employed\n", + "init_serial_unemployment[\"global_markov\"] = False\n", + "SerialUnemploymentExample = MarkovConsumerType(**init_serial_unemployment)\n", + "SerialUnemploymentExample.cycles = 0\n", + "SerialUnemploymentExample.vFuncBool = False # for easy toggling here" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Replace the default (lognormal) income distribution with a custom one\n", + "employed_income_dist = [np.ones(1), np.ones(1), np.ones(1)] # Definitely get income\n", + "unemployed_income_dist = [np.ones(1), np.ones(1), np.zeros(1)] # Definitely don't\n", + "SerialUnemploymentExample.IncomeDstn = [\n", + " [\n", + " employed_income_dist,\n", + " unemployed_income_dist,\n", + " employed_income_dist,\n", + " unemployed_income_dist,\n", + " ]\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Interest factor, permanent growth rates, and survival probabilities are constant arrays\n", + "SerialUnemploymentExample.Rfree = np.array(4 * [SerialUnemploymentExample.Rfree])\n", + "SerialUnemploymentExample.PermGroFac = [\n", + " np.array(4 * SerialUnemploymentExample.PermGroFac)\n", + "]\n", + "SerialUnemploymentExample.LivPrb = [SerialUnemploymentExample.LivPrb * np.ones(4)]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a Markov consumer with serially correlated unemployment took 0.6064 seconds.\n", + "Consumption functions for each discrete state:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Solve the serial unemployment consumer's problem and display solution\n", + "SerialUnemploymentExample.timeFwd()\n", + "start_time = process_time()\n", + "SerialUnemploymentExample.solve()\n", + "end_time = process_time()\n", + "print(\n", + " \"Solving a Markov consumer with serially correlated unemployment took \"\n", + " + mystr(end_time - start_time)\n", + " + \" seconds.\"\n", + ")\n", + "print(\"Consumption functions for each discrete state:\")\n", + "plotFuncs(SerialUnemploymentExample.solution[0].cFunc, 0, 50)\n", + "if SerialUnemploymentExample.vFuncBool:\n", + " print(\"Value functions for each discrete state:\")\n", + " plotFuncs(SerialUnemploymentExample.solution[0].vFunc, 5, 50)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Simulate some data; results stored in cHist, mNrmNow_hist, cNrmNow_hist, and MrkvNow_hist\n", + "if do_simulation:\n", + " SerialUnemploymentExample.T_sim = 120\n", + " SerialUnemploymentExample.MrkvPrbsInit = [0.25, 0.25, 0.25, 0.25]\n", + " SerialUnemploymentExample.track_vars = [\"mNrmNow\", \"cNrmNow\"]\n", + " SerialUnemploymentExample.makeShockHistory() # This is optional\n", + " SerialUnemploymentExample.initializeSim()\n", + " SerialUnemploymentExample.simulate()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Make a consumer who occasionally gets \"unemployment immunity\" for a fixed period\n", + "UnempPrb = 0.05 # Probability of becoming unemployed each period\n", + "ImmunityPrb = 0.01 # Probability of becoming \"immune\" to unemployment\n", + "ImmunityT = 6 # Number of periods of immunity" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "StateCount = ImmunityT + 1 # Total number of Markov states\n", + "IncomeDstnReg = [\n", + " np.array([1 - UnempPrb, UnempPrb]),\n", + " np.array([1.0, 1.0]),\n", + " np.array([1.0 / (1.0 - UnempPrb), 0.0]),\n", + "] # Ordinary income distribution\n", + "IncomeDstnImm = [\n", + " np.array([1.0]),\n", + " np.array([1.0]),\n", + " np.array([1.0]),\n", + "] # Income distribution when unemployed\n", + "IncomeDstn = [IncomeDstnReg] + ImmunityT * [\n", + " IncomeDstnImm\n", + "] # Income distribution for each Markov state, in a list" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Make the Markov transition array. MrkvArray[i,j] is the probability of transitioning\n", + "# to state j in period t+1 from state i in period t.\n", + "MrkvArray = np.zeros((StateCount, StateCount))\n", + "MrkvArray[0, 0] = (\n", + " 1.0 - ImmunityPrb\n", + ") # Probability of not becoming immune in ordinary state: stay in ordinary state\n", + "MrkvArray[\n", + " 0, ImmunityT\n", + "] = (\n", + " ImmunityPrb\n", + ") # Probability of becoming immune in ordinary state: begin immunity periods\n", + "for j in range(ImmunityT):\n", + " MrkvArray[\n", + " j + 1, j\n", + " ] = (\n", + " 1.0\n", + " ) # When immune, have 100% chance of transition to state with one fewer immunity periods remaining" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "init_unemployment_immunity = copy(Params.init_idiosyncratic_shocks)\n", + "init_unemployment_immunity[\"MrkvArray\"] = [MrkvArray]\n", + "ImmunityExample = MarkovConsumerType(**init_unemployment_immunity)\n", + "ImmunityExample.assignParameters(\n", + " Rfree=np.array(np.array(StateCount * [1.03])), # Interest factor same in all states\n", + " PermGroFac=[\n", + " np.array(StateCount * [1.01])\n", + " ], # Permanent growth factor same in all states\n", + " LivPrb=[np.array(StateCount * [0.98])], # Same survival probability in all states\n", + " BoroCnstArt=None, # No artificial borrowing constraint\n", + " cycles=0,\n", + ") # Infinite horizon\n", + "ImmunityExample.IncomeDstn = [IncomeDstn]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving an \"unemployment immunity\" consumer took 0.5869 seconds.\n", + "Consumption functions for each discrete state:\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/ms/dev/HARK/HARK/interpolation.py:1710: RuntimeWarning: All-NaN slice encountered\n", + " y = np.nanmin(fx,axis=1)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Solve the unemployment immunity problem and display the consumption functions\n", + "start_time = process_time()\n", + "ImmunityExample.solve()\n", + "end_time = process_time()\n", + "print(\n", + " 'Solving an \"unemployment immunity\" consumer took '\n", + " + mystr(end_time - start_time)\n", + " + \" seconds.\"\n", + ")\n", + "print(\"Consumption functions for each discrete state:\")\n", + "mNrmMin = np.min([ImmunityExample.solution[0].mNrmMin[j] for j in range(StateCount)])\n", + "plotFuncs(ImmunityExample.solution[0].cFunc, mNrmMin, 10)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Make a consumer with serially correlated permanent income growth\n", + "UnempPrb = 0.05 # Unemployment probability\n", + "StateCount = 5 # Number of permanent income growth rates\n", + "Persistence = (\n", + " 0.5\n", + ") # Probability of getting the same permanent income growth rate next period" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "IncomeDstnReg = [\n", + " np.array([1 - UnempPrb, UnempPrb]),\n", + " np.array([1.0, 1.0]),\n", + " np.array([1.0, 0.0]),\n", + "]\n", + "IncomeDstn = StateCount * [\n", + " IncomeDstnReg\n", + "] # Same simple income distribution in each state" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Make the state transition array for this type: Persistence probability of remaining in the same state, equiprobable otherwise\n", + "MrkvArray = Persistence * np.eye(StateCount) + (1.0 / StateCount) * (\n", + " 1.0 - Persistence\n", + ") * np.ones((StateCount, StateCount))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "init_serial_growth = copy(Params.init_idiosyncratic_shocks)\n", + "init_serial_growth[\"MrkvArray\"] = [MrkvArray]\n", + "SerialGroExample = MarkovConsumerType(**init_serial_growth)\n", + "SerialGroExample.assignParameters(\n", + " Rfree=np.array(\n", + " np.array(StateCount * [1.03])\n", + " ), # Same interest factor in each Markov state\n", + " PermGroFac=[\n", + " np.array([0.97, 0.99, 1.01, 1.03, 1.05])\n", + " ], # Different permanent growth factor in each Markov state\n", + " LivPrb=[np.array(StateCount * [0.98])], # Same survival probability in all states\n", + " cycles=0,\n", + ")\n", + "SerialGroExample.IncomeDstn = [IncomeDstn]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a serially correlated growth consumer took 0.5156 seconds.\n", + "Consumption functions for each discrete state:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Solve the serially correlated permanent growth shock problem and display the consumption functions\n", + "start_time = process_time()\n", + "SerialGroExample.solve()\n", + "end_time = process_time()\n", + "print(\n", + " \"Solving a serially correlated growth consumer took \"\n", + " + mystr(end_time - start_time)\n", + " + \" seconds.\"\n", + ")\n", + "print(\"Consumption functions for each discrete state:\")\n", + "plotFuncs(SerialGroExample.solution[0].cFunc, 0, 10)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Make a consumer with serially correlated interest factors\n", + "SerialRExample = deepcopy(SerialGroExample) # Same as the last problem...\n", + "SerialRExample.assignParameters(\n", + " PermGroFac=[\n", + " np.array(StateCount * [1.01])\n", + " ], # ...but now the permanent growth factor is constant...\n", + " Rfree=np.array([1.01, 1.02, 1.03, 1.04, 1.05]),\n", + ") # ...and the interest factor is what varies across states" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a serially correlated interest consumer took 0.5100 seconds.\n", + "Consumption functions for each discrete state:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Solve the serially correlated interest rate problem and display the consumption functions\n", + "start_time = process_time()\n", + "SerialRExample.solve()\n", + "end_time = process_time()\n", + "print(\n", + " \"Solving a serially correlated interest consumer took \"\n", + " + mystr(end_time - start_time)\n", + " + \" seconds.\"\n", + ")\n", + "print(\"Consumption functions for each discrete state:\")\n", + "plotFuncs(SerialRExample.solution[0].cFunc, 0, 10)" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + }, + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/HARK/ConsumptionSaving/example_ConsMarkovModel.py b/examples/ConsumptionSaving/example_ConsMarkovModel.py similarity index 97% rename from HARK/ConsumptionSaving/example_ConsMarkovModel.py rename to examples/ConsumptionSaving/example_ConsMarkovModel.py index 75ecb3794..bdae63fb2 100644 --- a/HARK/ConsumptionSaving/example_ConsMarkovModel.py +++ b/examples/ConsumptionSaving/example_ConsMarkovModel.py @@ -4,9 +4,7 @@ from copy import deepcopy, copy import numpy as np from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType - mystr = lambda number: "{:.4f}".format(number) - do_simulation = True # Define the Markov transition matrix for serially correlated unemployment @@ -101,8 +99,6 @@ SerialUnemploymentExample.initializeSim() SerialUnemploymentExample.simulate() -############################################################################### - # Make a consumer who occasionally gets "unemployment immunity" for a fixed period UnempPrb = 0.05 # Probability of becoming unemployed each period ImmunityPrb = 0.01 # Probability of becoming "immune" to unemployment @@ -168,8 +164,6 @@ mNrmMin = np.min([ImmunityExample.solution[0].mNrmMin[j] for j in range(StateCount)]) plotFuncs(ImmunityExample.solution[0].cFunc, mNrmMin, 10) -############################################################################### - # Make a consumer with serially correlated permanent income growth UnempPrb = 0.05 # Unemployment probability StateCount = 5 # Number of permanent income growth rates @@ -219,8 +213,6 @@ print("Consumption functions for each discrete state:") plotFuncs(SerialGroExample.solution[0].cFunc, 0, 10) -############################################################################### - # Make a consumer with serially correlated interest factors SerialRExample = deepcopy(SerialGroExample) # Same as the last problem... SerialRExample.assignParameters( diff --git a/examples/ConsumptionSaving/example_ConsMedModel.ipynb b/examples/ConsumptionSaving/example_ConsMedModel.ipynb new file mode 100644 index 000000000..c9768999c --- /dev/null +++ b/examples/ConsumptionSaving/example_ConsMedModel.ipynb @@ -0,0 +1,313 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import HARK.ConsumptionSaving.ConsumerParameters as Params\n", + "from HARK.utilities import CRRAutility_inv\n", + "from time import time\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from HARK.ConsumptionSaving.ConsMedModel import MedShockConsumerType" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "mystr = lambda number: \"{:.4f}\".format(number)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "do_simulation = True" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/ms/dev/HARK/HARK/ConsumptionSaving/ConsMedModel.py:635: RuntimeWarning: divide by zero encountered in power\n", + " vPgrid = cLvlGrid**(-self.CRRA)\n", + "/Users/ms/dev/HARK/HARK/utilities.py:141: RuntimeWarning: divide by zero encountered in reciprocal\n", + " return( c**(1.0 - gam) / (1.0 - gam) )\n", + "/Users/ms/dev/HARK/HARK/utilities.py:141: RuntimeWarning: divide by zero encountered in power\n", + " return( c**(1.0 - gam) / (1.0 - gam) )\n", + "/Users/ms/dev/HARK/HARK/ConsumptionSaving/ConsMedModel.py:649: RuntimeWarning: invalid value encountered in multiply\n", + " vGrid = utility(cLvlGrid,gam=self.CRRA) + MedShkGrid_tiled*utility(MedGrid,gam=self.CRRAmed)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a medical shocks consumer took 84.2861 seconds.\n" + ] + } + ], + "source": [ + "# Make and solve an example medical shocks consumer type\n", + "MedicalExample = MedShockConsumerType()\n", + "t_start = time()\n", + "MedicalExample.solve()\n", + "t_end = time()\n", + "print(\"Solving a medical shocks consumer took \" + mystr(t_end - t_start) + \" seconds.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption function by medical need shock (constant permanent income)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function\n", + "M = np.linspace(0, 30, 300)\n", + "pLvl = 1.0\n", + "P = pLvl * np.ones_like(M)\n", + "for j in range(MedicalExample.MedShkDstn[0][0].size):\n", + " MedShk = MedicalExample.MedShkDstn[0][1][j] * np.ones_like(M)\n", + " M_temp = M + MedicalExample.solution[0].mLvlMin(pLvl)\n", + " C = MedicalExample.solution[0].cFunc(M_temp, P, MedShk)\n", + " plt.plot(M_temp, C)\n", + "print(\"Consumption function by medical need shock (constant permanent income)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Medical care function by medical need shock (constant permanent income)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the medical care function\n", + "for j in range(MedicalExample.MedShkDstn[0][0].size):\n", + " MedShk = MedicalExample.MedShkDstn[0][1][j] * np.ones_like(M)\n", + " Med = MedicalExample.solution[0].MedFunc(M_temp, P, MedShk)\n", + " plt.plot(M_temp, Med)\n", + "print(\"Medical care function by medical need shock (constant permanent income)\")\n", + "plt.ylim([0, 20])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "End of period savings by medical need shock (constant permanent income)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the savings function\n", + "for j in range(MedicalExample.MedShkDstn[0][0].size):\n", + " MedShk = MedicalExample.MedShkDstn[0][1][j] * np.ones_like(M)\n", + " Sav = (\n", + " M_temp\n", + " - MedicalExample.solution[0].cFunc(M_temp, P, MedShk)\n", + " - MedicalExample.MedPrice[0]\n", + " * MedicalExample.solution[0].MedFunc(M_temp, P, MedShk)\n", + " )\n", + " plt.plot(M_temp, Sav)\n", + "print(\"End of period savings by medical need shock (constant permanent income)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/ms/dev/HARK/HARK/utilities.py:160: RuntimeWarning: divide by zero encountered in power\n", + " return( c**-gam )\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marginal value function (pseudo inverse)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the marginal value function\n", + "M = np.linspace(0.0, 30, 300)\n", + "for p in range(MedicalExample.pLvlGrid[0].size):\n", + " pLvl = MedicalExample.pLvlGrid[0][p]\n", + " M_temp = pLvl * M + MedicalExample.solution[0].mLvlMin(pLvl)\n", + " P = pLvl * np.ones_like(M)\n", + " vP = MedicalExample.solution[0].vPfunc(M_temp, P) ** (-1.0 / MedicalExample.CRRA)\n", + " plt.plot(M_temp, vP)\n", + "print(\"Marginal value function (pseudo inverse)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "if MedicalExample.vFuncBool:\n", + " # Plot the value function\n", + " M = np.linspace(0.0, 1, 300)\n", + " for p in range(MedicalExample.pLvlGrid[0].size):\n", + " pLvl = MedicalExample.pLvlGrid[0][p]\n", + " M_temp = pLvl * M + MedicalExample.solution[0].mLvlMin(pLvl)\n", + " P = pLvl * np.ones_like(M)\n", + " v = CRRAutility_inv(\n", + " MedicalExample.solution[0].vFunc(M_temp, P), gam=MedicalExample.CRRA\n", + " )\n", + " plt.plot(M_temp, v)\n", + " print(\"Value function (pseudo inverse)\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Simulating 10000 agents for 100 periods took 36.5912 seconds.\n" + ] + } + ], + "source": [ + "if do_simulation:\n", + " t_start = time()\n", + " MedicalExample.T_sim = 100\n", + " MedicalExample.track_vars = [\"mLvlNow\", \"cLvlNow\", \"MedNow\"]\n", + " MedicalExample.makeShockHistory()\n", + " MedicalExample.initializeSim()\n", + " MedicalExample.simulate()\n", + " t_end = time()\n", + " print(\n", + " \"Simulating \"\n", + " + str(MedicalExample.AgentCount)\n", + " + \" agents for \"\n", + " + str(MedicalExample.T_sim)\n", + " + \" periods took \"\n", + " + mystr(t_end - t_start)\n", + " + \" seconds.\"\n", + " )" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + }, + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/HARK/ConsumptionSaving/example_ConsMedModel.py b/examples/ConsumptionSaving/example_ConsMedModel.py similarity index 95% rename from HARK/ConsumptionSaving/example_ConsMedModel.py rename to examples/ConsumptionSaving/example_ConsMedModel.py index 23a295f32..5d255aefa 100644 --- a/HARK/ConsumptionSaving/example_ConsMedModel.py +++ b/examples/ConsumptionSaving/example_ConsMedModel.py @@ -1,6 +1,6 @@ import HARK.ConsumptionSaving.ConsumerParameters as Params from HARK.utilities import CRRAutility_inv -from time import process_time +from time import time import matplotlib.pyplot as plt import numpy as np from HARK.ConsumptionSaving.ConsMedModel import MedShockConsumerType @@ -11,9 +11,9 @@ # Make and solve an example medical shocks consumer type MedicalExample = MedShockConsumerType() -t_start = process_time() +t_start = time() MedicalExample.solve() -t_end = process_time() +t_end = time() print("Solving a medical shocks consumer took " + mystr(t_end - t_start) + " seconds.") # Plot the consumption function @@ -76,13 +76,13 @@ plt.show() if do_simulation: - t_start = process_time() + t_start = time() MedicalExample.T_sim = 100 MedicalExample.track_vars = ["mLvlNow", "cLvlNow", "MedNow"] MedicalExample.makeShockHistory() MedicalExample.initializeSim() MedicalExample.simulate() - t_end = process_time() + t_end = time() print( "Simulating " + str(MedicalExample.AgentCount) diff --git a/examples/ConsumptionSaving/example_ConsPrefShockModel.ipynb b/examples/ConsumptionSaving/example_ConsPrefShockModel.ipynb new file mode 100644 index 000000000..c6e4764af --- /dev/null +++ b/examples/ConsumptionSaving/example_ConsPrefShockModel.ipynb @@ -0,0 +1,316 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import HARK.ConsumptionSaving.ConsumerParameters as Params\n", + "import matplotlib.pyplot as plt\n", + "from HARK.utilities import plotFuncs\n", + "from time import process_time\n", + "import numpy as np\n", + "from HARK.ConsumptionSaving.ConsPrefShockModel import (\n", + " PrefShockConsumerType,\n", + " KinkyPrefConsumerType,\n", + ")\n", + "mystr = lambda number: \"{:.4f}\".format(number)\n", + "do_simulation = True" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Make and solve a preference shock consumer\n", + "PrefShockExample = PrefShockConsumerType()\n", + "PrefShockExample.cycles = 0 # Infinite horizon" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a preference shock consumer took 0.8477220000000001 seconds.\n" + ] + } + ], + "source": [ + "t_start = process_time()\n", + "PrefShockExample.solve()\n", + "t_end = process_time()\n", + "print(\"Solving a preference shock consumer took \" + str(t_end - t_start) + \" seconds.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions at each discrete shock:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function at each discrete shock\n", + "m = np.linspace(PrefShockExample.solution[0].mNrmMin, 5, 200)\n", + "print(\"Consumption functions at each discrete shock:\")\n", + "for j in range(PrefShockExample.PrefShkDstn[0][1].size):\n", + " PrefShk = PrefShockExample.PrefShkDstn[0][1][j]\n", + " c = PrefShockExample.solution[0].cFunc(m, PrefShk * np.ones_like(m))\n", + " plt.plot(m, c)\n", + "plt.xlim([0.0, None])\n", + "plt.ylim([0.0, None])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption function (and MPC) when shock=1:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Consumption function (and MPC) when shock=1:\")\n", + "c = PrefShockExample.solution[0].cFunc(m, np.ones_like(m))\n", + "k = PrefShockExample.solution[0].cFunc.derivativeX(m, np.ones_like(m))\n", + "plt.plot(m, c)\n", + "plt.plot(m, k)\n", + "plt.xlim([0.0, None])\n", + "plt.ylim([0.0, None])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "if PrefShockExample.vFuncBool:\n", + " print(\"Value function (unconditional on shock):\")\n", + " plotFuncs(\n", + " PrefShockExample.solution[0].vFunc,\n", + " PrefShockExample.solution[0].mNrmMin + 0.5,\n", + " 5,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Test the simulator for the pref shock class\n", + "if do_simulation:\n", + " PrefShockExample.T_sim = 120\n", + " PrefShockExample.track_vars = [\"cNrmNow\"]\n", + " PrefShockExample.makeShockHistory() # This is optional\n", + " PrefShockExample.initializeSim()\n", + " PrefShockExample.simulate()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Make and solve a \"kinky preferece\" consumer, whose model combines KinkedR and PrefShock\n", + "KinkyPrefExample = KinkyPrefConsumerType()\n", + "KinkyPrefExample.cycles = 0 # Infinite horizon" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a kinky preference consumer took 1.006215 seconds.\n" + ] + } + ], + "source": [ + "t_start = process_time()\n", + "KinkyPrefExample.solve()\n", + "t_end = process_time()\n", + "print(\"Solving a kinky preference consumer took \" + str(t_end - t_start) + \" seconds.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions at each discrete shock:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function at each discrete shock\n", + "m = np.linspace(KinkyPrefExample.solution[0].mNrmMin, 5, 200)\n", + "print(\"Consumption functions at each discrete shock:\")\n", + "for j in range(KinkyPrefExample.PrefShkDstn[0][1].size):\n", + " PrefShk = KinkyPrefExample.PrefShkDstn[0][1][j]\n", + " c = KinkyPrefExample.solution[0].cFunc(m, PrefShk * np.ones_like(m))\n", + " plt.plot(m, c)\n", + "plt.ylim([0.0, None])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption function (and MPC) when shock=1:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Consumption function (and MPC) when shock=1:\")\n", + "c = KinkyPrefExample.solution[0].cFunc(m, np.ones_like(m))\n", + "k = KinkyPrefExample.solution[0].cFunc.derivativeX(m, np.ones_like(m))\n", + "plt.plot(m, c)\n", + "plt.plot(m, k)\n", + "plt.ylim([0.0, None])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "if KinkyPrefExample.vFuncBool:\n", + " print(\"Value function (unconditional on shock):\")\n", + " plotFuncs(\n", + " KinkyPrefExample.solution[0].vFunc,\n", + " KinkyPrefExample.solution[0].mNrmMin + 0.5,\n", + " 5,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Test the simulator for the kinky preference class\n", + "if do_simulation:\n", + " KinkyPrefExample.T_sim = 120\n", + " KinkyPrefExample.track_vars = [\"cNrmNow\", \"PrefShkNow\"]\n", + " KinkyPrefExample.initializeSim()\n", + " KinkyPrefExample.simulate()" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + }, + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/HARK/ConsumptionSaving/example_ConsPrefShockModel.py b/examples/ConsumptionSaving/example_ConsPrefShockModel.py similarity index 97% rename from HARK/ConsumptionSaving/example_ConsPrefShockModel.py rename to examples/ConsumptionSaving/example_ConsPrefShockModel.py index aa0c48e38..89e332abf 100644 --- a/HARK/ConsumptionSaving/example_ConsPrefShockModel.py +++ b/examples/ConsumptionSaving/example_ConsPrefShockModel.py @@ -7,9 +7,7 @@ PrefShockConsumerType, KinkyPrefConsumerType, ) - mystr = lambda number: "{:.4f}".format(number) - do_simulation = True # Make and solve a preference shock consumer @@ -57,8 +55,6 @@ PrefShockExample.initializeSim() PrefShockExample.simulate() -########################################################################### - # Make and solve a "kinky preferece" consumer, whose model combines KinkedR and PrefShock KinkyPrefExample = KinkyPrefConsumerType() KinkyPrefExample.cycles = 0 # Infinite horizon diff --git a/examples/ConsumptionSaving/example_ConsRepAgentModel.ipynb b/examples/ConsumptionSaving/example_ConsRepAgentModel.ipynb new file mode 100644 index 000000000..336d8464f --- /dev/null +++ b/examples/ConsumptionSaving/example_ConsRepAgentModel.ipynb @@ -0,0 +1,202 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from copy import deepcopy\n", + "from time import time\n", + "import numpy as np\n", + "from HARK.utilities import plotFuncs\n", + "import HARK.ConsumptionSaving.ConsumerParameters as Params\n", + "from HARK.ConsumptionSaving.ConsRepAgentModel import (\n", + " RepAgentConsumerType,\n", + " RepAgentMarkovConsumerType,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Make a quick example dictionary\n", + "RA_params = deepcopy(Params.init_idiosyncratic_shocks)\n", + "RA_params[\"DeprFac\"] = 0.05\n", + "RA_params[\"CapShare\"] = 0.36\n", + "RA_params[\"UnempPrb\"] = 0.0\n", + "RA_params[\"LivPrb\"] = [1.0]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a representative agent problem took 0.2792696952819824 seconds.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Make and solve a rep agent model\n", + "RAexample = RepAgentConsumerType(**RA_params)\n", + "t_start = time()\n", + "RAexample.solve()\n", + "t_end = time()\n", + "print(\n", + " \"Solving a representative agent problem took \" + str(t_end - t_start) + \" seconds.\"\n", + ")\n", + "plotFuncs(RAexample.solution[0].cFunc, 0, 20)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Simulating a representative agent for 2000 periods took 9.091149091720581 seconds.\n" + ] + } + ], + "source": [ + "# Simulate the representative agent model\n", + "RAexample.T_sim = 2000\n", + "RAexample.track_vars = [\"cNrmNow\", \"mNrmNow\", \"Rfree\", \"wRte\"]\n", + "RAexample.initializeSim()\n", + "t_start = time()\n", + "RAexample.simulate()\n", + "t_end = time()\n", + "print(\n", + " \"Simulating a representative agent for \"\n", + " + str(RAexample.T_sim)\n", + " + \" periods took \"\n", + " + str(t_end - t_start)\n", + " + \" seconds.\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a two state representative agent problem took 0.7686238288879395 seconds.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Make and solve a Markov representative agent\n", + "RA_markov_params = deepcopy(RA_params)\n", + "RA_markov_params[\"PermGroFac\"] = [[0.97, 1.03]]\n", + "RA_markov_params[\"MrkvArray\"] = np.array([[0.99, 0.01], [0.01, 0.99]])\n", + "RA_markov_params[\"MrkvNow\"] = 0\n", + "RAmarkovExample = RepAgentMarkovConsumerType(**RA_markov_params)\n", + "RAmarkovExample.IncomeDstn[0] = 2 * [RAmarkovExample.IncomeDstn[0]]\n", + "t_start = time()\n", + "RAmarkovExample.solve()\n", + "t_end = time()\n", + "print(\n", + " \"Solving a two state representative agent problem took \"\n", + " + str(t_end - t_start)\n", + " + \" seconds.\"\n", + ")\n", + "plotFuncs(RAmarkovExample.solution[0].cFunc, 0, 10)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Simulating a two state representative agent for 2000 periods took 9.762195110321045 seconds.\n" + ] + } + ], + "source": [ + "# Simulate the two state representative agent model\n", + "RAmarkovExample.T_sim = 2000\n", + "RAmarkovExample.track_vars = [\"cNrmNow\", \"mNrmNow\", \"Rfree\", \"wRte\", \"MrkvNow\"]\n", + "RAmarkovExample.initializeSim()\n", + "t_start = time()\n", + "RAmarkovExample.simulate()\n", + "t_end = time()\n", + "print(\n", + " \"Simulating a two state representative agent for \"\n", + " + str(RAexample.T_sim)\n", + " + \" periods took \"\n", + " + str(t_end - t_start)\n", + " + \" seconds.\"\n", + ")" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + }, + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/HARK/ConsumptionSaving/example_ConsRepAgentModel.py b/examples/ConsumptionSaving/example_ConsRepAgentModel.py similarity index 89% rename from HARK/ConsumptionSaving/example_ConsRepAgentModel.py rename to examples/ConsumptionSaving/example_ConsRepAgentModel.py index c71d1639e..121413911 100644 --- a/HARK/ConsumptionSaving/example_ConsRepAgentModel.py +++ b/examples/ConsumptionSaving/example_ConsRepAgentModel.py @@ -1,5 +1,5 @@ from copy import deepcopy -from time import process_time +from time import time import numpy as np from HARK.utilities import plotFuncs import HARK.ConsumptionSaving.ConsumerParameters as Params @@ -17,9 +17,9 @@ # Make and solve a rep agent model RAexample = RepAgentConsumerType(**RA_params) -t_start = process_time() +t_start = time() RAexample.solve() -t_end = process_time() +t_end = time() print( "Solving a representative agent problem took " + str(t_end - t_start) + " seconds." ) @@ -29,9 +29,9 @@ RAexample.T_sim = 2000 RAexample.track_vars = ["cNrmNow", "mNrmNow", "Rfree", "wRte"] RAexample.initializeSim() -t_start = process_time() +t_start = time() RAexample.simulate() -t_end = process_time() +t_end = time() print( "Simulating a representative agent for " + str(RAexample.T_sim) @@ -47,9 +47,9 @@ RA_markov_params["MrkvNow"] = 0 RAmarkovExample = RepAgentMarkovConsumerType(**RA_markov_params) RAmarkovExample.IncomeDstn[0] = 2 * [RAmarkovExample.IncomeDstn[0]] -t_start = process_time() +t_start = time() RAmarkovExample.solve() -t_end = process_time() +t_end = time() print( "Solving a two state representative agent problem took " + str(t_end - t_start) @@ -61,9 +61,9 @@ RAmarkovExample.T_sim = 2000 RAmarkovExample.track_vars = ["cNrmNow", "mNrmNow", "Rfree", "wRte", "MrkvNow"] RAmarkovExample.initializeSim() -t_start = process_time() +t_start = time() RAmarkovExample.simulate() -t_end = process_time() +t_end = time() print( "Simulating a two state representative agent for " + str(RAexample.T_sim) diff --git a/examples/ConsumptionSaving/example_TractableBufferStockModel.ipynb b/examples/ConsumptionSaving/example_TractableBufferStockModel.ipynb new file mode 100644 index 000000000..576dc599a --- /dev/null +++ b/examples/ConsumptionSaving/example_TractableBufferStockModel.ipynb @@ -0,0 +1,277 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # numeric Python\n", + "from HARK.utilities import plotFuncs # basic plotting tools\n", + "from HARK.ConsumptionSaving.ConsMarkovModel import (\n", + " MarkovConsumerType,\n", + ") # An alternative, much longer way to solve the TBS model\n", + "from time import process_time # timing utility\n", + "from HARK.ConsumptionSaving.TractableBufferStockModel import TractableConsumerType\n", + "import numpy as np\n", + "do_simulation = True" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Define the model primitives\n", + "base_primitives = {\n", + " \"UnempPrb\": 0.00625, # Probability of becoming unemployed\n", + " \"DiscFac\": 0.975, # Intertemporal discount factor\n", + " \"Rfree\": 1.01, # Risk-free interest factor on assets\n", + " \"PermGroFac\": 1.0025, # Permanent income growth factor (uncompensated)\n", + " \"CRRA\": 1.0,\n", + "} # Coefficient of relative risk aversion" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Define a dictionary to be used in case of simulation\n", + "simulation_values = {\n", + " \"aLvlInitMean\": 0.0, # Mean of log initial assets for new agents\n", + " \"aLvlInitStd\": 1.0, # Stdev of log initial assets for new agents\n", + " \"AgentCount\": 10000, # Number of agents to simulate\n", + " \"T_sim\": 120, # Number of periods to simulate\n", + " \"T_cycle\": 1,\n", + "} # Number of periods in the cycle" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a tractable consumption-savings model took 0.005015999999999909 seconds.\n" + ] + } + ], + "source": [ + "# Make and solve a tractable consumer type\n", + "ExampleType = TractableConsumerType(**base_primitives)\n", + "t_start = process_time()\n", + "ExampleType.solve()\n", + "t_end = process_time()\n", + "print(\n", + " \"Solving a tractable consumption-savings model took \"\n", + " + str(t_end - t_start)\n", + " + \" seconds.\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function and whatnot\n", + "m_upper = 1.5 * ExampleType.mTarg\n", + "conFunc_PF = lambda m: ExampleType.h * ExampleType.PFMPC + ExampleType.PFMPC * m\n", + "# plotFuncs([ExampleType.solution[0].cFunc,ExampleType.mSSfunc,ExampleType.cSSfunc],0,m_upper)\n", + "plotFuncs([ExampleType.solution[0].cFunc, ExampleType.solution[0].cFunc_U], 0, m_upper)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "if do_simulation:\n", + " ExampleType(**simulation_values) # Set attributes needed for simulation\n", + " ExampleType.track_vars = [\"mLvlNow\"]\n", + " ExampleType.makeShockHistory()\n", + " ExampleType.initializeSim()\n", + " ExampleType.simulate()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Now solve the same model using backward induction rather than the analytic method of TBS.\n", + "# The TBS model is equivalent to a Markov model with two states, one of them absorbing (permanent unemployment).\n", + "MrkvArray = np.array(\n", + " [[1.0 - base_primitives[\"UnempPrb\"], base_primitives[\"UnempPrb\"]], [0.0, 1.0]]\n", + ") # Define the two state, absorbing unemployment Markov array\n", + "init_consumer_objects = {\n", + " \"CRRA\": base_primitives[\"CRRA\"],\n", + " \"Rfree\": np.array(\n", + " 2 * [base_primitives[\"Rfree\"]]\n", + " ), # Interest factor (same in both states)\n", + " \"PermGroFac\": [\n", + " np.array(\n", + " 2 * [base_primitives[\"PermGroFac\"] / (1.0 - base_primitives[\"UnempPrb\"])]\n", + " )\n", + " ], # Unemployment-compensated permanent growth factor\n", + " \"BoroCnstArt\": None, # Artificial borrowing constraint\n", + " \"PermShkStd\": [0.0], # Permanent shock standard deviation\n", + " \"PermShkCount\": 1, # Number of shocks in discrete permanent shock distribution\n", + " \"TranShkStd\": [0.0], # Transitory shock standard deviation\n", + " \"TranShkCount\": 1, # Number of shocks in discrete permanent shock distribution\n", + " \"T_cycle\": 1, # Number of periods in cycle\n", + " \"UnempPrb\": 0.0, # Unemployment probability (not used, as the unemployment here is *permanent*, not transitory)\n", + " \"UnempPrbRet\": 0.0, # Unemployment probability when retired (irrelevant here)\n", + " \"T_retire\": 0, # Age at retirement (turned off)\n", + " \"IncUnemp\": 0.0, # Income when unemployed (irrelevant)\n", + " \"IncUnempRet\": 0.0, # Income when unemployed and retired (irrelevant)\n", + " \"aXtraMin\": 0.001, # Minimum value of assets above minimum in grid\n", + " \"aXtraMax\": ExampleType.mUpperBnd, # Maximum value of assets above minimum in grid\n", + " \"aXtraCount\": 48, # Number of points in assets grid\n", + " \"aXtraExtra\": [None], # Additional points to include in assets grid\n", + " \"aXtraNestFac\": 3, # Degree of exponential nesting when constructing assets grid\n", + " \"LivPrb\": [np.array([1.0, 1.0])], # Survival probability\n", + " \"DiscFac\": base_primitives[\"DiscFac\"], # Intertemporal discount factor\n", + " \"AgentCount\": 1, # Number of agents in a simulation (irrelevant)\n", + " \"tax_rate\": 0.0, # Tax rate on labor income (irrelevant)\n", + " \"vFuncBool\": False, # Whether to calculate the value function\n", + " \"CubicBool\": True, # Whether to use cubic splines (False --> linear splines)\n", + " \"MrkvArray\": [MrkvArray], # State transition probabilities\n", + "}\n", + "MarkovType = MarkovConsumerType(**init_consumer_objects) # Make a basic consumer type\n", + "employed_income_dist = [\n", + " np.ones(1),\n", + " np.ones(1),\n", + " np.ones(1),\n", + "] # Income distribution when employed\n", + "unemployed_income_dist = [\n", + " np.ones(1),\n", + " np.ones(1),\n", + " np.zeros(1),\n", + "] # Income distribution when permanently unemployed\n", + "MarkovType.IncomeDstn = [\n", + " [employed_income_dist, unemployed_income_dist]\n", + "] # set the income distribution in each state\n", + "MarkovType.cycles = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Solve the \"Markov TBS\" model\n", + "t_start = process_time()\n", + "MarkovType.solve()\n", + "t_end = process_time()\n", + "MarkovType.unpackcFunc()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving the same model \"the long way\" took 3.202354 seconds.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Difference between the (employed) consumption functions:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print(\n", + " 'Solving the same model \"the long way\" took ' + str(t_end - t_start) + \" seconds.\"\n", + ")\n", + "# plotFuncs([ExampleType.solution[0].cFunc,ExampleType.solution[0].cFunc_U],0,m_upper)\n", + "plotFuncs(MarkovType.cFunc[0], 0, m_upper)\n", + "diffFunc = lambda m: ExampleType.solution[0].cFunc(m) - MarkovType.cFunc[0][0](m)\n", + "print(\"Difference between the (employed) consumption functions:\")\n", + "plotFuncs(diffFunc, 0, m_upper)" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + }, + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/HARK/ConsumptionSaving/example_TractableBufferStockModel.py b/examples/ConsumptionSaving/example_TractableBufferStockModel.py similarity index 99% rename from HARK/ConsumptionSaving/example_TractableBufferStockModel.py rename to examples/ConsumptionSaving/example_TractableBufferStockModel.py index c6641ab33..ec7ca7660 100644 --- a/HARK/ConsumptionSaving/example_TractableBufferStockModel.py +++ b/examples/ConsumptionSaving/example_TractableBufferStockModel.py @@ -6,7 +6,6 @@ from time import process_time # timing utility from HARK.ConsumptionSaving.TractableBufferStockModel import TractableConsumerType import numpy as np - do_simulation = True # Define the model primitives From 13a486f46d0c28cb726e00b0f755f10c73e146df Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Thu, 23 Jan 2020 15:09:26 +0530 Subject: [PATCH 15/43] setup testing, fix bugs in code --- HARK/ConsumptionSaving/ConsMarkovModel.py | 22 +++--- HARK/ConsumptionSaving/tests/__init__.py | 0 .../tests/test_ConsMarkovModel.py | 70 +++++++++++++++++++ HARK/__init__.py | 3 +- 4 files changed, 86 insertions(+), 9 deletions(-) create mode 100644 HARK/ConsumptionSaving/tests/__init__.py create mode 100644 HARK/ConsumptionSaving/tests/test_ConsMarkovModel.py diff --git a/HARK/ConsumptionSaving/ConsMarkovModel.py b/HARK/ConsumptionSaving/ConsMarkovModel.py index 1394869c1..85331e5a1 100644 --- a/HARK/ConsumptionSaving/ConsMarkovModel.py +++ b/HARK/ConsumptionSaving/ConsMarkovModel.py @@ -593,7 +593,7 @@ def makevFunc(self,solution): return vFuncNow -def solveConsMarkov(solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,Rfree,PermGroFac, +def _solveConsMarkov(solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,Rfree,PermGroFac, MrkvArray,BoroCnstArt,aXtraGrid,vFuncBool,CubicBool): ''' Solves a single period consumption-saving problem with risky income and @@ -681,7 +681,7 @@ class MarkovConsumerType(IndShockConsumerType): def __init__(self,cycles=1,time_flow=True,**kwds): IndShockConsumerType.__init__(self,cycles=1,time_flow=True,**kwds) - self.solveOnePeriod = solveConsMarkov + self.solveOnePeriod = _solveConsMarkov self.poststate_vars += ['MrkvNow'] if not hasattr(self, 'global_markov'): self.global_markov = False @@ -702,15 +702,19 @@ def checkMarkovInputs(self): StateCount = self.MrkvArray[0].shape[0] # Check that arrays are the right shape - assert self.Rfree.shape == (StateCount,),'Rfree not the right shape!' + if not isinstance(self.Rfree, np.ndarray) or self.Rfree.shape != (StateCount, ): + raise ValueError('Rfree not the right shape, it should an array of Rfree of all the states.') # Check that arrays in lists are the right shape for MrkvArray_t in self.MrkvArray: - assert MrkvArray_t.shape == (StateCount,StateCount),'MrkvArray not the right shape!' + if not isinstance(MrkvArray_t, np.ndarray) or MrkvArray_t.shape != (StateCount, StateCount): + raise ValueError('MrkvArray not the right shape, it should be of the size states*statres.') for LivPrb_t in self.LivPrb: - assert LivPrb_t.shape == (StateCount,),'Array in LivPrb is not the right shape!' - for PermGroFac_t in self.LivPrb: - assert PermGroFac_t.shape == (StateCount,),'Array in PermGroFac is not the right shape!' + if not isinstance(LivPrb_t, np.ndarray) or LivPrb_t.shape != (StateCount, ): + raise ValueError('Array in LivPrb is not the right shape, it should be an array of length equal to number of states') + for PermGroFac_t in self.PermGroFac: + if not isinstance(PermGroFac_t, np.ndarray) or PermGroFac_t.shape != (StateCount, ): + raise ValueError('Array in PermGroFac is not the right shape, it should be an array of length equal to number of states') # Now check the income distribution. # Note IncomeDstn is (potentially) time-varying, so it is in time_vary. @@ -718,8 +722,10 @@ def checkMarkovInputs(self): # at a particular point in time. Each income distribution at a point in time should itself # be a list, with each element corresponding to the income distribution # conditional on a particular Markov state. + # TODO: should this be a numpy array too? for IncomeDstn_t in self.IncomeDstn: - assert len(IncomeDstn_t) == StateCount,'List in IncomeDstn is not the right length!' + if not isinstance(IncomeDstn_t, list) or len(IncomeDstn_t) != StateCount: + raise ValueError('List in IncomeDstn is not the right length, it should be length equal to number of states') def preSolve(self): """ diff --git a/HARK/ConsumptionSaving/tests/__init__.py b/HARK/ConsumptionSaving/tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/HARK/ConsumptionSaving/tests/test_ConsMarkovModel.py b/HARK/ConsumptionSaving/tests/test_ConsMarkovModel.py new file mode 100644 index 000000000..7de568b28 --- /dev/null +++ b/HARK/ConsumptionSaving/tests/test_ConsMarkovModel.py @@ -0,0 +1,70 @@ +import numpy as np +from HARK import MarkovConsumerType +import HARK.ConsumptionSaving.ConsumerParameters as Params +from copy import copy +import unittest + +class test_ConsMarkovSolver(unittest.TestCase): + def setUp(self): + + # Define the Markov transition matrix for serially correlated unemployment + unemp_length = 5 # Averange length of unemployment spell + urate_good = 0.05 # Unemployment rate when economy is in good state + urate_bad = 0.12 # Unemployment rate when economy is in bad state + bust_prob = 0.01 # Probability of economy switching from good to bad + recession_length = 20 # Averange length of bad state + p_reemploy = 1.0 / unemp_length + p_unemploy_good = p_reemploy * urate_good / (1 - urate_good) + p_unemploy_bad = p_reemploy * urate_bad / (1 - urate_bad) + boom_prob = 1.0 / recession_length + self.MrkvArray = np.array( + [ + [ + (1 - p_unemploy_good) * (1 - bust_prob), + p_unemploy_good * (1 - bust_prob), + (1 - p_unemploy_good) * bust_prob, + p_unemploy_good * bust_prob, + ], + [ + p_reemploy * (1 - bust_prob), + (1 - p_reemploy) * (1 - bust_prob), + p_reemploy * bust_prob, + (1 - p_reemploy) * bust_prob, + ], + [ + (1 - p_unemploy_bad) * boom_prob, + p_unemploy_bad * boom_prob, + (1 - p_unemploy_bad) * (1 - boom_prob), + p_unemploy_bad * (1 - boom_prob), + ], + [ + p_reemploy * boom_prob, + (1 - p_reemploy) * boom_prob, + p_reemploy * (1 - boom_prob), + (1 - p_reemploy) * (1 - boom_prob), + ], + ] + ) + + init_serial_unemployment = copy(Params.init_idiosyncratic_shocks) + init_serial_unemployment["MrkvArray"] = [self.MrkvArray] + self.model = MarkovConsumerType(**init_serial_unemployment) + + def test_checkMarkovInputs(self): + # check Rfree + self.assertRaises(ValueError, self.model.checkMarkovInputs) + # fix Rfree + self.model.Rfree = np.array(4 * [self.model.Rfree]) + # check MrkvArray, first mess up the setup + self.model.MrkvArray = np.random.rand(3, 3) + self.assertRaises(ValueError, self.model.checkMarkovInputs) + # then fix it back + self.model.MrkvArray = self.MrkvArray + # check LivPrb + self.assertRaises(ValueError, self.model.checkMarkovInputs) + # fix LivPrb + self.model.LivPrb = [np.array(4 * self.model.LivPrb)] + # check PermGroFac + self.assertRaises(ValueError, self.model.checkMarkovInputs) + # fix PermGroFac + self.model.PermGroFac = [np.array(4 * self.model.PermGroFac)] diff --git a/HARK/__init__.py b/HARK/__init__.py index 44f72023a..c235d788e 100644 --- a/HARK/__init__.py +++ b/HARK/__init__.py @@ -1,3 +1,4 @@ +__version__ = '0.10.3' + from HARK.core import * from HARK.ConsumptionSaving import * -__version__ = '0.10.3' From c8dffd8a8d7b38fef6d5681b51eeb4a381f0cc80 Mon Sep 17 00:00:00 2001 From: sb Date: Sun, 9 Feb 2020 17:03:00 -0500 Subject: [PATCH 16/43] adding test for default solution to PerfForesightConsumerType. See #504 --- HARK/tests/test_PerfForesightConsumerType.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 HARK/tests/test_PerfForesightConsumerType.py diff --git a/HARK/tests/test_PerfForesightConsumerType.py b/HARK/tests/test_PerfForesightConsumerType.py new file mode 100644 index 000000000..049c0fee0 --- /dev/null +++ b/HARK/tests/test_PerfForesightConsumerType.py @@ -0,0 +1,18 @@ +from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType + +import unittest + +class testPerfForesightConsumerType(unittest.TestCase): + + def test_default_solution(self): + agent = PerfForesightConsumerType() + agent.solve() + c = agent.solution[0].cFunc + + self.assertEqual(c.x_list[0], -0.9805825242718447) + self.assertEqual(c.x_list[1], 0.01941747572815533) + self.assertEqual(c.y_list[0], 0) + self.assertEqual(c.y_list[1], 0.511321002804608) + self.assertEqual(c.decay_extrap, False) + + From b229a2c4fb48d5f863a084b2ae329b7348de1e69 Mon Sep 17 00:00:00 2001 From: sb Date: Mon, 10 Feb 2020 09:28:19 -0500 Subject: [PATCH 17/43] adding test for IndShockConsumerType.getShocks() --- HARK/tests/test_IndShockConsumerType.py | 31 +++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 HARK/tests/test_IndShockConsumerType.py diff --git a/HARK/tests/test_IndShockConsumerType.py b/HARK/tests/test_IndShockConsumerType.py new file mode 100644 index 000000000..41a3eda70 --- /dev/null +++ b/HARK/tests/test_IndShockConsumerType.py @@ -0,0 +1,31 @@ +from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType + +import numpy as np +import unittest + +class testIndShockConsumerType(unittest.TestCase): + + def test_getShocks(self): + agent = IndShockConsumerType( + AgentCount = 2, + T_sim = 10 + ) + + agent.solve() + + agent.initializeSim() + agent.simBirth(np.array([True,False])) + agent.simOnePeriod() + agent.simBirth(np.array([False,True])) + + agent.getShocks() + + self.assertEqual(agent.PermShkNow[0], + 1.0050166461586711) + self.assertEqual(agent.PermShkNow[1], + 1.0050166461586711) + self.assertEqual(agent.TranShkNow[0], + 1.1176912196531754) + + + From 75e57ec18beee197c7ef63c88bb1026fd29525e8 Mon Sep 17 00:00:00 2001 From: sb Date: Sat, 15 Feb 2020 16:16:56 -0500 Subject: [PATCH 18/43] adding tests for IndShockConsumerType class, based on BufferStock REMARK. fixes #510 --- HARK/tests/test_IndShockConsumerType.py | 92 +++++++++++++++++++++++++ 1 file changed, 92 insertions(+) create mode 100644 HARK/tests/test_IndShockConsumerType.py diff --git a/HARK/tests/test_IndShockConsumerType.py b/HARK/tests/test_IndShockConsumerType.py new file mode 100644 index 000000000..774d445d2 --- /dev/null +++ b/HARK/tests/test_IndShockConsumerType.py @@ -0,0 +1,92 @@ +from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType +import HARK.ConsumptionSaving.ConsumerParameters as Params +import numpy as np +import unittest + +class testBufferStock(unittest.TestCase): + """ Tests of the results of the BufferStock REMARK. + """ + + def setUp(self): + # Make a dictionary containing all parameters needed to solve the model + self.base_params = Params.init_idiosyncratic_shocks + + # Set the parameters for the baseline results in the paper + # using the variable values defined in the cell above + self.base_params['PermGroFac'] = [1.03] + self.base_params['Rfree'] = 1.04 + self.base_params['DiscFac'] = 0.96 + self.base_params['CRRA'] = 2.00 + self.base_params['UnempPrb'] = 0.005 + self.base_params['IncUnemp'] = 0.0 + self.base_params['PermShkStd'] = [0.1] + self.base_params['TranShkStd'] = [0.1] + self.base_params['LivPrb'] = [1.0] + self.base_params['CubicBool'] = True + self.base_params['T_cycle'] = 1 + self.base_params['BoroCnstArt'] = None + + def test_baseEx(self): + baseEx = IndShockConsumerType(**self.base_params) + baseEx.cycles = 100 # Make this type have a finite horizon (Set T = 100) + + baseEx.solve() + baseEx.unpackcFunc() + + m = np.linspace(0,9.5,1000) + + c_m = baseEx.cFunc[0](m) # c_m can be used to define the limiting infinite-horizon consumption rule here + c_t1 = baseEx.cFunc[-2](m) # c_t1 defines the second-to-last period consumption rule + c_t5 = baseEx.cFunc[-6](m) # c_t5 defines the T-5 period consumption rule + c_t10 = baseEx.cFunc[-11](m) + + self.assertEqual(c_m[500], 1.4008090582203356) + self.assertEqual(c_t1[500], 2.9227437159255216) + self.assertEqual(c_t5[500], 1.7350607327187664) + self.assertEqual(c_t10[500], 1.4991390649979213) + self.assertEqual(c_t10[600], 1.6101476268581576) + self.assertEqual(c_t10[700], 1.7196531041366991) + + def test_GICFails(self): + GIC_fail_dictionary = dict(self.base_params) + GIC_fail_dictionary['Rfree'] = 1.08 + GIC_fail_dictionary['PermGroFac'] = [1.00] + + GICFailExample = IndShockConsumerType( + cycles=0, # cycles=0 makes this an infinite horizon consumer + **GIC_fail_dictionary) + + GICFailExample.solve() # Above, we set up the problem but did not solve it + GICFailExample.unpackcFunc() # Make the consumption function easily accessible for plotting + m = np.linspace(0,5,1000) + c_m = GICFailExample.cFunc[0](m) + + self.assertEqual(c_m[500], 0.7772637042393458) + self.assertEqual(c_m[700], 0.8392649061916746) + + def test_infinite_horizon(self): + baseEx_inf = IndShockConsumerType(cycles=0, + **self.base_params) + + baseEx_inf.solve() + baseEx_inf.unpackcFunc() + + m1 = np.linspace(1,baseEx_inf.solution[0].mNrmSS,50) # m1 defines the plot range on the left of target m value (e.g. m <= target m) + c_m1 = baseEx_inf.cFunc[0](m1) + + self.assertEqual(c_m1[0], 0.8527887545025995) + self.assertEqual(c_m1[-1], 1.0036279936408656) + + x1 = np.linspace(0,25,1000) + cfunc_m = baseEx_inf.cFunc[0](x1) + + self.assertEqual(cfunc_m[500], 1.8902146173138235) + self.assertEqual(cfunc_m[700], 2.1591451850267176) + + m = np.linspace(0.001,8,1000) + + # Use the HARK method derivative to get the derivative of cFunc, and the values are just the MPC + MPC = baseEx_inf.cFunc[0].derivative(m) + + self.assertEqual(MPC[500], 0.08415000641504392) + self.assertEqual(MPC[700], 0.07173144137912524) From 68f41443377f0648dee5e7da7a04d586bf044914 Mon Sep 17 00:00:00 2001 From: sb Date: Sat, 15 Feb 2020 17:05:14 -0500 Subject: [PATCH 19/43] using assertAlmostEqual for tests to avoid failures due to operating system --- HARK/tests/test_IndShockConsumerType.py | 28 ++++++++++++------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/HARK/tests/test_IndShockConsumerType.py b/HARK/tests/test_IndShockConsumerType.py index 774d445d2..f7f8401d2 100644 --- a/HARK/tests/test_IndShockConsumerType.py +++ b/HARK/tests/test_IndShockConsumerType.py @@ -40,12 +40,12 @@ def test_baseEx(self): c_t5 = baseEx.cFunc[-6](m) # c_t5 defines the T-5 period consumption rule c_t10 = baseEx.cFunc[-11](m) - self.assertEqual(c_m[500], 1.4008090582203356) - self.assertEqual(c_t1[500], 2.9227437159255216) - self.assertEqual(c_t5[500], 1.7350607327187664) - self.assertEqual(c_t10[500], 1.4991390649979213) - self.assertEqual(c_t10[600], 1.6101476268581576) - self.assertEqual(c_t10[700], 1.7196531041366991) + self.assertAlmostEqual(c_m[500], 1.4008090582203356) + self.assertAlmostEqual(c_t1[500], 2.9227437159255216) + self.assertAlmostEqual(c_t5[500], 1.7350607327187664) + self.assertAlmostEqual(c_t10[500], 1.4991390649979213) + self.assertAlmostEqual(c_t10[600], 1.6101476268581576) + self.assertAlmostEqual(c_t10[700], 1.7196531041366991) def test_GICFails(self): GIC_fail_dictionary = dict(self.base_params) @@ -61,8 +61,8 @@ def test_GICFails(self): m = np.linspace(0,5,1000) c_m = GICFailExample.cFunc[0](m) - self.assertEqual(c_m[500], 0.7772637042393458) - self.assertEqual(c_m[700], 0.8392649061916746) + self.assertAlmostEqual(c_m[500], 0.7772637042393458) + self.assertAlmostEqual(c_m[700], 0.8392649061916746) def test_infinite_horizon(self): baseEx_inf = IndShockConsumerType(cycles=0, @@ -74,19 +74,19 @@ def test_infinite_horizon(self): m1 = np.linspace(1,baseEx_inf.solution[0].mNrmSS,50) # m1 defines the plot range on the left of target m value (e.g. m <= target m) c_m1 = baseEx_inf.cFunc[0](m1) - self.assertEqual(c_m1[0], 0.8527887545025995) - self.assertEqual(c_m1[-1], 1.0036279936408656) + self.assertAlmostEqual(c_m1[0], 0.8527887545025995) + self.assertAlmostEqual(c_m1[-1], 1.0036279936408656) x1 = np.linspace(0,25,1000) cfunc_m = baseEx_inf.cFunc[0](x1) - self.assertEqual(cfunc_m[500], 1.8902146173138235) - self.assertEqual(cfunc_m[700], 2.1591451850267176) + self.assertAlmostEqual(cfunc_m[500], 1.8902146173138235) + self.assertAlmostEqual(cfunc_m[700], 2.1591451850267176) m = np.linspace(0.001,8,1000) # Use the HARK method derivative to get the derivative of cFunc, and the values are just the MPC MPC = baseEx_inf.cFunc[0].derivative(m) - self.assertEqual(MPC[500], 0.08415000641504392) - self.assertEqual(MPC[700], 0.07173144137912524) + self.assertAlmostEqual(MPC[500], 0.08415000641504392) + self.assertAlmostEqual(MPC[700], 0.07173144137912524) From 1c8df30926a60a9aefe2629fea27d572baaa20aa Mon Sep 17 00:00:00 2001 From: sb Date: Sat, 15 Feb 2020 17:24:32 -0500 Subject: [PATCH 20/43] adding tests for failed GIC and AIC conditions on GICFailedExample. See #525 --- HARK/tests/test_IndShockConsumerType.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/HARK/tests/test_IndShockConsumerType.py b/HARK/tests/test_IndShockConsumerType.py index f7f8401d2..143deed90 100644 --- a/HARK/tests/test_IndShockConsumerType.py +++ b/HARK/tests/test_IndShockConsumerType.py @@ -64,6 +64,9 @@ def test_GICFails(self): self.assertAlmostEqual(c_m[500], 0.7772637042393458) self.assertAlmostEqual(c_m[700], 0.8392649061916746) + self.assertFalse(GICFailExample.GIC) + self.assertFalse(GICFailExample.AIC) + def test_infinite_horizon(self): baseEx_inf = IndShockConsumerType(cycles=0, **self.base_params) From 6c1acc7e067339d7ad8866d24f3d080d16e15c3a Mon Sep 17 00:00:00 2001 From: sb Date: Sat, 15 Feb 2020 17:41:19 -0500 Subject: [PATCH 21/43] removing comments from tests that was causing unicode error on Travis --- HARK/tests/test_IndShockConsumerType.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/HARK/tests/test_IndShockConsumerType.py b/HARK/tests/test_IndShockConsumerType.py index 143deed90..e7b1e69f4 100644 --- a/HARK/tests/test_IndShockConsumerType.py +++ b/HARK/tests/test_IndShockConsumerType.py @@ -35,9 +35,9 @@ def test_baseEx(self): m = np.linspace(0,9.5,1000) - c_m = baseEx.cFunc[0](m) # c_m can be used to define the limiting infinite-horizon consumption rule here - c_t1 = baseEx.cFunc[-2](m) # c_t1 defines the second-to-last period consumption rule - c_t5 = baseEx.cFunc[-6](m) # c_t5 defines the T-5 period consumption rule + c_m = baseEx.cFunc[0](m) + c_t1 = baseEx.cFunc[-2](m) + c_t5 = baseEx.cFunc[-6](m) c_t10 = baseEx.cFunc[-11](m) self.assertAlmostEqual(c_m[500], 1.4008090582203356) @@ -56,8 +56,8 @@ def test_GICFails(self): cycles=0, # cycles=0 makes this an infinite horizon consumer **GIC_fail_dictionary) - GICFailExample.solve() # Above, we set up the problem but did not solve it - GICFailExample.unpackcFunc() # Make the consumption function easily accessible for plotting + GICFailExample.solve() + GICFailExample.unpackcFunc() m = np.linspace(0,5,1000) c_m = GICFailExample.cFunc[0](m) From 24293a394e4874bdeced9ef4e8c8fa2a8634fa88 Mon Sep 17 00:00:00 2001 From: sb Date: Mon, 17 Feb 2020 16:20:00 -0500 Subject: [PATCH 22/43] moving test into ConsumptionSaving/tests --- HARK/{ => ConsumptionSaving}/tests/test_IndShockConsumerType.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename HARK/{ => ConsumptionSaving}/tests/test_IndShockConsumerType.py (100%) diff --git a/HARK/tests/test_IndShockConsumerType.py b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py similarity index 100% rename from HARK/tests/test_IndShockConsumerType.py rename to HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py From 91c2128ce30def837aa193707ee5dadc6d410428 Mon Sep 17 00:00:00 2001 From: sb Date: Tue, 18 Feb 2020 10:30:47 -0500 Subject: [PATCH 23/43] __init__.py for tests directory --- HARK/ConsumptionSaving/tests/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 HARK/ConsumptionSaving/tests/__init__.py diff --git a/HARK/ConsumptionSaving/tests/__init__.py b/HARK/ConsumptionSaving/tests/__init__.py new file mode 100644 index 000000000..e69de29bb From bfaa7f18cdc02175e6c256a9ae95517089e7f4cb Mon Sep 17 00:00:00 2001 From: llorracc <@users.noreply.github.com> Date: Wed, 19 Feb 2020 00:22:07 +0100 Subject: [PATCH 24/43] Update checkConditions() --- HARK/ConsumptionSaving/ConsIndShockModel.py | 262 +++++++++++++++----- 1 file changed, 195 insertions(+), 67 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index db3784b43..7e3928bdc 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -915,7 +915,7 @@ def prepareToCalcEndOfPrdvP(self): ShkPrbs_temp = (np.tile(self.ShkPrbsNext,(aNrmCount,1))).transpose() # Get cash on hand next period - mNrmNext = self.Rfree/(self.PermGroFac*PermShkVals_temp)*aNrm_temp + TranShkVals_temp + mNrmNext = self.Rfree/(self.PermGroFac*PermShkVals_temp)*aNrm_temp + TranShkVals_temp # CDC 20191205: This should be divided by LivPrb[0] for Blanchard insurance # Store and report the results self.PermShkVals_temp = PermShkVals_temp @@ -1854,12 +1854,12 @@ def getPostStates(self): def checkConditions(self,verbose=False,verbose_reference=False,public_call=False): ''' This method checks whether the instance's type satisfies the Growth Impatience Condition - (GIC), Return Impatience Condition (RIC), Absolute Impatience Condition (AIC), Weak Return - Impatience Condition (WRIC), Finite Human Wealth Condition (FHWC) and Finite Value of - Autarky Condition (FVAC). These are the conditions that are sufficient for nondegenerate - solutions under infinite horizon with a 1 period cycle. Depending on the model at hand, a - different combination of these conditions must be satisfied. To check which conditions are - relevant to the model at hand, a reference to the relevant theoretical literature is made. + (GIC), Return Impatience Condition (RIC), Absolute Impatience Condition (AIC), Return + Impatience Condition (RIC), Finite Human Wealth Condition (FHWC) and Finite Value of + Autarky Condition (FVAC). Depending on the configuration of parameter values, some + combination of these conditions must be satisfied in order for the problem to have + a nondegenerate solution. To check which conditions are required, in the verbose mode + a reference to the relevant theoretical literature is made. Parameters ---------- @@ -1888,18 +1888,18 @@ def checkConditions(self,verbose=False,verbose_reference=False,public_call=False self.AIF = AIF if AIF<1: self.AIC = True - if public_call: - print('The value of the absolute impatience factor for the supplied parameter values satisfies the Absolute Impatience Condition.', end = " ") - if verbose: - violated = False - print('Therefore, the absolute amount of consumption is expected to fall over time.') + if public_call or verbose: + print('The value of the absolute impatience factor (AIF) for the supplied parameter values satisfies the Absolute Impatience Condition.', end = " ") + if verbose: + violated = False + print(' Because the AIF < 1, the absolute amount of consumption is expected to fall over time.') print() else: self.AIC = False print('The given type violates the Absolute Impatience Condition with the supplied parameter values; the AIF is %1.5f ' % (AIF), end=" ") if verbose: violated = True - print('Therefore, the absolute amount of consumption is expected to grow over time') + print(' Because the AIF > 1, the absolute amount of consumption is expected to grow over time') print() #Evaluate and report on the Growth Impatience Condition @@ -1908,17 +1908,17 @@ def checkConditions(self,verbose=False,verbose_reference=False,public_call=False if GIF<1: self.GIC = True - if public_call: - print('The value of the growth impatience factor for the supplied parameter values satisfies the Growth Impatience Condition.', end = " ") - if verbose: - print(' Therefore, the ratio of individual wealth to permanent income will fall indefinitely.') + if public_call or verbose: + print('The value of the Growth Impatience Factor for the supplied parameter values satisfies the Growth Impatience Condition.', end = " ") + if verbose: + print(' Therefore, the ratio of individual wealth to permanent income will fall indefinitely.') print() else: self.GIC = False violated = True print('The given parameter values violate the Growth Impatience Condition for this consumer type; the GIF is: %2.4f' % (GIF), end = " ") if verbose: - print(' Therefore, the ratio of individual wealth to permanent income grow toward infinity.') + print(' Therefore, the ratio of individual wealth to permanent income is expected to grow toward infinity.') print() @@ -1928,17 +1928,17 @@ def checkConditions(self,verbose=False,verbose_reference=False,public_call=False self.RIF = RIF if RIF<1: self.RIC = True - if public_call: + if public_call or verbose: print('The return impatience factor value for the supplied parameter values satisfies the Return Impatience Condition.', end = " ") - if verbose: - print('Therefore, the limiting consumption function is not c(m)=0') + if verbose: + print('Therefore, the limiting consumption function is not c(m)=0 for all m') print() else: self.RIC = False violated = True print('The given type violates the Return Impatience Condition with the supplied parameter values; the factor is %1.5f ' % (RIF), end = " ") if verbose: - print('Therefore, the limiting consumption function is c(m)=0') + print('Therefore, the limiting consumption function is c(m)=0 for all m') print() #Evaluate and report on the Finite Human Wealth Condition @@ -1947,13 +1947,13 @@ def checkConditions(self,verbose=False,verbose_reference=False,public_call=False if FHWF<1: self.hNrm = 1.0/(1.0-self.PermGroFac[0]/self.Rfree) self.FHWC = True - if public_call: + if public_call or verbose: print('The Finite Human wealth factor value for the supplied parameter values satisfies the Finite Human Wealth Condition.', end = " ") - if verbose: - print('Therefore, the limiting consumption function is not c(m)=Infinity') - print('and human wealth normalized by permanent income is %2.5f' % (self.hNrm)) - self.cNrmPDV = 1.0/(1.0-self.Thorn/self.Rfree) - print('and the PDV of future consumption growth is %2.5f' % (self.cNrmPDV) ) + if verbose: + print('Therefore, the limiting consumption function is not c(m)=Infinity') + print('and human wealth normalized by permanent income is %2.5f' % (self.hNrm)) + self.cNrmPDV = 1.0/(1.0-self.Thorn/self.Rfree) + print('and the PDV of future consumption growth is %2.5f' % (self.cNrmPDV) ) print() else: self.FHWC = False @@ -1964,7 +1964,6 @@ def checkConditions(self,verbose=False,verbose_reference=False,public_call=False print() if verbose and violated and verbose_reference: print('[!] For more information on the conditions, see Table 3 in "Theoretical Foundations of Buffer Stock Saving" at http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/') - return violated @@ -2131,7 +2130,8 @@ def calcBoundingValues(self): horizon model with only one period repeated indefinitely. Store results as attributes of self. Human wealth is the present discounted value of expected future income after receiving income this period, ignoring mort- - ality. The maximum MPC is the limit of the MPC as m --> mNrmMin. The + ality (because your income matters to you only if you are still alive). + The maximum MPC is the limit of the MPC as m --> mNrmMin. The minimum MPC is the limit of the MPC as m --> infty. Parameters @@ -2234,7 +2234,7 @@ def makeEulerErrorFunc(self,mMax=100,approx_inc_dstn=True): # Calculate expected marginal value and implied optimal consumption ExvPnextGrid = self.DiscFac*self.Rfree*self.LivPrb[0]*self.PermGroFac[0]**(-self.CRRA)* \ np.sum(PermShkVals_tiled**(-self.CRRA)*vPnextArray*ShkPrbs_tiled,axis=0) - cOptGrid = ExvPnextGrid**(-1.0/self.CRRA) + cOptGrid = ExvPnextGrid**(-1.0/self.CRRA) # This is the 'Endogenous Gridpoints' step # Calculate Euler error and store an interpolated function EulerErrorNrmGrid = (cNowGrid - cOptGrid)/cOptGrid @@ -2255,9 +2255,8 @@ def checkConditions(self,verbose=False,public_call=True): This method checks whether the instance's type satisfies the Growth Impatience Condition (GIC), Return Impatience Condition (RIC), Absolute Impatience Condition (AIC), Weak Return Impatience Condition (WRIC), Finite Human Wealth Condition (FHWC) and Finite Value of - Autarky Condition (FVAC). These are the conditions that are sufficient for nondegenerate - infinite horizon solutions when there is a 1 period cycle. Depending on the model at hand, a - different combination of these conditions must be satisfied. (For an exposition of the + Autarky Condition (FVAC). When combinations of these conditions are satisfied, the + solution to the problem exhibits different characteristics. (For an exposition of the conditions, see http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/) Parameters @@ -2271,71 +2270,203 @@ def checkConditions(self,verbose=False,public_call=True): ------- None ''' - violated = PerfForesightConsumerType.checkConditions(self, verbose=verbose, verbose_reference=False) + violated = False # PerfForesightConsumerType.checkConditions(self, verbose=False, verbose_reference=False) if self.cycles!=0 or self.T_cycle > 1: return - EPermShkInv=np.dot(self.PermShkDstn[0][0],1/self.PermShkDstn[0][1]) - PermGroFacAdj=self.PermGroFac[0]*EPermShkInv - Thorn = (self.Rfree*self.DiscFac*self.LivPrb[0])**(1/self.CRRA) - GIF = Thorn/PermGroFacAdj - self.GIF = GIF - self.Thorn = Thorn - self.PermGroFacAdj = PermGroFacAdj - self.EPermShkInv = EPermShkInv + # For theory, see hyperlink targets to expressions in + # url=http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory + # For example, the hyperlink to the relevant section of the paper + url='http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory' + # would be referenced below as: + # [url]/#Uncertainty-Modified-Conditions + self.InvPermShkDstn=deepcopy(self.PermShkDstn) + self.InvPermShkDstn[0][1]=1/self.PermShkDstn[0][1] + EPermShkInv=np.dot(self.InvPermShkDstn[0][0],1/self.PermShkDstn[0][1]) # $\Ex_{t}[\psi^{-1}_{t+1}]$ (in first eqn in sec) + InvEPermShkInv=(1/EPermShkInv) # $\underline{\psi}$ in the paper (\bar{\isp} in private version) + PermGroFacAdj=self.PermGroFac[0]*InvEPermShkInv # [url]/#PGroAdj + # [url]/#Pat, adjusted to include mortality +# Thorn = ((self.Rfree/self.LivPrb[0])*(self.DiscFac*self.LivPrb[0]))**(1/self.CRRA) + Thorn = ((self.Rfree*self.DiscFac))**(1/self.CRRA) + GIF = Thorn/(self.PermGroFac[0] ) # [url]/#GIF + GIFInd = Thorn/(self.PermGroFac[0]*InvEPermShkInv) # [url]/#GIFI + GIFAgg = Thorn*self.LivPrb[0]/self.PermGroFac[0] # [url]#/GIFA + +# self.Rnorm = self.Rfree*EPermShkInv/(self.PermGroFac[0]*self.LivPrb[0]) + self.GIF = GIF + self.GIFInd = GIFInd + self.GIFAgg = GIFAgg + self.Thorn = Thorn + self.PermGroFacAdj = PermGroFacAdj + self.EPermShkInv = EPermShkInv + self.InvEPermShkInv = InvEPermShkInv + self.DiscFacGIFMax = ((self.PermGroFac[0] )**(self.CRRA))/(self.Rfree) # DiscFac at growth impatience knife edge + self.DiscFacGIFIMax = ((self.PermGroFac[0]*InvEPermShkInv)**(self.CRRA))/(self.Rfree) # DiscFac at growth impatience knife edge + self.DiscFacGIFAMax = ((self.PermGroFac[0] )**(self.CRRA))/(self.Rfree*self.LivPrb[0]) # DiscFac at growth impatience knife edge #Evaluate and report on the Growth Impatience Condition - if GIF<1: + # [url]/#GIC + if GIF<=1: self.GIC = True - if public_call: - print('The value of the growth impatience factor for the supplied parameter values satisfies the Growth Impatience Condition.', end = " ") - if verbose: - print('Therefore, a target level of wealth exists.') + if public_call or verbose: + print('The value of the Growth Impatience Factor for the supplied parameter values satisfies the Growth Impatience Condition.', end = " ") + if verbose: + print('Therefore, a target level of the ratio of expected market resources to expected permanent income exists (see '+url+'/#onetarget).') print() else: self.GIC = False violated = True - print('The given parameter values violate the Growth Impatience Condition for this consumer type; the GIF is: %2.4f' % (GIF), end = " ") + print('The given parameter values violate the Growth Impatience Condition; the GIF is: %2.4f' % (GIF), end = " ") + if verbose: + print('') + print('Therefore, a target level of wealth does not exist. (see '+url+'/#onetarget)') + print() + + if GIFInd<=1: + self.GICInd = True + if public_call or verbose: + print('The value of the Individual Growth Impatience Factor for the supplied parameter values satisfies the Individual Growth Impatience Condition.', end = " ") + if verbose: + print('Therefore, a target level of the individual market resources ratio m exists (see '+url+'/#onetarget).') + print() + else: + self.GICInd = False + violated = True + print('The given parameter values violate the Individual Growth Impatience Condition; the GIFInd is: %2.4f' % (GIFInd), end = " ") if verbose: - print('Therefore, a target level of wealth does not exist.') + print('') + print('Therefore, a target ratio of individual market resources to individual permanent income does not exist. (see '+url+'/#onetarget)') + print() + + if GIFAgg<=1: + self.GICAgg = True + if public_call or verbose: + print('The value of the Aggregate Growth Impatience Factor for the supplied parameter values satisfies the Aggregate Growth Impatience Condition.', end = " ") + if verbose: + print('Therefore, it is possible that a target level of the ratio of expected market resources to expected permanent income exists (see '+url+'/#onetarget).') + print() + else: + self.GICAgg = False + violated = True + print('The given parameter values violate the Aggregate Growth Impatience Condition; the GIFAgg is: %2.4f' % (GIFAgg), end = " ") + if verbose: + print('') + print('Therefore, a target ratio of aggregate resources to aggreg permanent income does not exist. (see '+url+'/#onetarget)') print() #Evaluate and report on the Weak Return Impatience Condition - WRIF=(self.LivPrb[0]*(self.UnempPrb**(1/self.CRRA))*(self.Rfree*self.DiscFac)**(1/self.CRRA))/self.Rfree + # [url]/#WRIF modified to incorporate LivPrb + WRIF=(self.UnempPrb**(1/self.CRRA))*(self.Rfree*self.DiscFac*self.LivPrb[0])**(1/self.CRRA)/self.Rfree self.WRIF = WRIF - if WRIF<1: + if WRIF<=1: self.WRIC = True - if public_call: - print('The Weak Return Impatience Factor value for the supplied parameter values satisfies the Weak Return Impatience Condition.') + if public_call or verbose: + print('The Weak Return Impatience Factor value for the supplied parameter values satisfies the Weak Return Impatience Condition (see '+url+'/#WRIC).') + print() else: self.WRIC = False violated = True print('The given type violates the Weak Return Impatience Condition with the supplied parameter values. The WRIF is: %2.4f' % (WRIF), end = " ") if verbose: - print('Therefore, a nondegenerate solution is not available.') + print('') + print('Therefore, a nondegenerate solution is not available (see '+url+'/#WRIC.') print() #Evaluate and report on the Finite Value of Autarky Condition - EPermShkValFunc=np.dot(self.PermShkDstn[0][0],self.PermShkDstn[0][1]**(1-self.CRRA)) - self.EPermShkValFunc = EPermShkValFunc - FVAF=self.LivPrb[0]*self.DiscFac*EPermShkValFunc*(self.PermGroFac[0]**(1-self.CRRA)) + # Hyperlink to paper: [url]/#Autarky-Value + EpShkuInv = np.dot(self.PermShkDstn[0][0],self.PermShkDstn[0][1]**(1-self.CRRA)) + if self.CRRA != 1.0: + uInvEpShkuInv = EpShkuInv**(1/(1-self.CRRA)) # The term that gives a utility-consequence-adjusted utility growth + else: + uInvEpShkuInv = 1.0 + + self.uInvEpShkuInv = uInvEpShkuInv + FVAF=self.LivPrb[0]*self.DiscFac*self.uInvEpShkuInv self.FVAF = FVAF - if FVAF<1: + if FVAF<=1: self.FVAC = True - if public_call: + if public_call or verbose: print('The Finite Value of autarky factor value for the supplied parameter values satisfies the Finite Value of Autarky Condition.') + if self.WRIC: + print('Since both WRIC and FVAC are satisfied, the problem has a nondegenerate solution') else: self.FVAC = False print('The given type violates the Finite Value of Autarky Condition with the supplied parameter values. The FVAF is %2.4f' %(FVAF), end = " ") violated = True - if verbose: - print('Therefore, a nondegenerate solution is not available.') + if public_call or verbose: + print('Therefore, a nondegenerate solution is not available (see '+url+'/#Conditions-Under-Which-the-Problem-Defines-a-Contraction-Mapping') print() if verbose and violated: - print('\n[!] For more information on the conditions, see Table 3 in "Theoretical Foundations of Buffer Stock Saving" at http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/') + print('\n[!] For more information on the conditions, see Tables 3 and 4 in "Theoretical Foundations of Buffer Stock Saving" at '+url+'/#Factors-Defined-And-Compared') + print('') + + if verbose: + print('GIF = %2.6f ' % (GIF)) + print('GIFInd = %2.6f ' % (GIFInd)) + print('GIFAgg = %2.6f ' % (GIFAgg)) + print('Thorn = %2.6f ' % (Thorn)) + print('PermGroFacAdj = %2.6f ' % (PermGroFacAdj)) + print('uInvEpShkuInv = %2.6f ' % (uInvEpShkuInv)) + print('FVAF = %2.6f ' % (FVAF)) + print('WRIF = %2.6f ' % (WRIF)) + print('DiscFacGIFMax = %2.6f ' % (self.DiscFacGIFMax)) + print('DiscFacGIFAMax= %2.6f ' % (self.DiscFacGIFAMax)) + print('DiscFacGIFAMax= %2.6f ' % (self.DiscFacGIFIMax)) + + def Ex_Mtp1_over_Ex_Ptp1(self,mRat,verbose=False): + cRat = self.solution[-1].cFunc(mRat) + aRat = mRat-cRat + Ex_Ptp1 = PermGroFac[0] + Ex_bLev_tp1 = aRat*self.Rfree + Ex_Mtp1 = Ex_bLev_tp1 + return Ex_Mtp1/Ex_Ptp1 + + def Ex_mtp1(self,mRat,verbose=False): + cRat = self.solution[-1].cFunc(mRat) + aRat = mRat-cRat + Ex_bRat_tp1 = aRat*self.Rfree*self.EPermShkInv/self.PermGroFac[0] + Ex_Mtp1 = (Ex_bRat_tp1 + 1)*Ex_Ptp1 # mean TranShk and PermShk are 1 + return Ex_Mtp1/Ex_Ptp1 + + def calcTargets(self,verbose=False): + ''' + If the problem is one that satisfies the conditions required for target ratios of different + variables to permanent income to exist, and has been solved to within the self-defined + tolerance, this method calculates the target values of market resources, consumption, + and assets. + + Parameters + ---------- + verbose : boolean + Specifies different levels of verbosity of feedback. When False, it prints no results. + When True, it reports all target values, and passes the verbosity indicator to the + checkConditions method which responds accordingly. + + Returns + ------- + None + ''' + infinite_horizon = cycles_left == 0 + if not infinite_horizon: + print('The calcTargets method works only for infinite horizon models.') + return + + + # To be written. + # Defining: + ## Rnorm = Rfree/(PermGroFac[0]*PermShk) + ## EPermShkInv = E[PermShk**(-1)] + ## InvEPermShkInv = 1/EPermShkInv + ## ExRnorm = E[Rfree/(PermGroFac[0]*PermShk)] = Rfree EPermShkInv / PermGroFac[0] + ## InvExRnorm = 1/ExRnorm + ## The "sustainable consumption" locus is given by + # cSust = InvExRnorm + m*(1-InvExRnorm) + + # The target level of m, mTarg, will be the value such that + # cSust[m] = cFunc[m] class KinkedRconsumerType(IndShockConsumerType): @@ -2349,10 +2480,7 @@ class KinkedRconsumerType(IndShockConsumerType): time_inv_.remove('Rfree') time_inv_ += ['Rboro', 'Rsave'] - def __init__(self, - cycles=1, - time_flow=True, - **kwds): + def __init__(self,cycles=1,time_flow=True,**kwds): ''' Instantiate a new ConsumerType with given data. See ConsumerParameters.init_kinked_R for a dictionary of From fe1b6544f6d88a6139c95a35616c33ef129a8aa8 Mon Sep 17 00:00:00 2001 From: llorracc <@users.noreply.github.com> Date: Thu, 20 Feb 2020 00:09:59 +0100 Subject: [PATCH 25/43] Further small tweaks to factor calculations --- HARK/ConsumptionSaving/ConsIndShockModel.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index 7e3928bdc..881bd419d 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -2388,7 +2388,7 @@ def checkConditions(self,verbose=False,public_call=True): if FVAF<=1: self.FVAC = True if public_call or verbose: - print('The Finite Value of autarky factor value for the supplied parameter values satisfies the Finite Value of Autarky Condition.') + print('The Finite Value of Autarky Factor (FVAV) for the supplied parameter values satisfies the Finite Value of Autarky Condition.') if self.WRIC: print('Since both WRIC and FVAC are satisfied, the problem has a nondegenerate solution') else: From 4d6d4b4e6eada0ca1a5f4f836b5046e8541efb86 Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Thu, 20 Feb 2020 10:06:46 +0530 Subject: [PATCH 26/43] add future imports back and py3.6 support, absolute_imports for v0.10.4 --- HARK/ConsumptionSaving/ConsAggShockModel.py | 4 ++++ .../ConsGenIncProcessModel.py | 4 ++++ HARK/ConsumptionSaving/ConsIndShockModel.py | 9 ++++++++- HARK/ConsumptionSaving/ConsMarkovModel.py | 3 +++ HARK/ConsumptionSaving/ConsMedModel.py | 4 ++++ HARK/ConsumptionSaving/ConsPrefShockModel.py | 4 ++++ HARK/ConsumptionSaving/ConsRepAgentModel.py | 4 ++++ HARK/ConsumptionSaving/ConsumerParameters.py | 1 + .../TractableBufferStockModel.py | 3 +++ HARK/ConsumptionSaving/__init__.py | 20 +++++++++---------- .../tests/test_ConsMarkovModel.py | 2 +- HARK/__init__.py | 2 +- 12 files changed, 47 insertions(+), 13 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsAggShockModel.py b/HARK/ConsumptionSaving/ConsAggShockModel.py index 838792bbf..dc1c0a43f 100644 --- a/HARK/ConsumptionSaving/ConsAggShockModel.py +++ b/HARK/ConsumptionSaving/ConsAggShockModel.py @@ -4,6 +4,10 @@ basic solver. Also includes a subclass of Market called CobbDouglas economy, used for solving "macroeconomic" models with aggregate shocks. ''' +from __future__ import division, print_function +from __future__ import absolute_import +from builtins import str +from builtins import range import numpy as np import scipy.stats as stats from HARK.interpolation import LinearInterp, LinearInterpOnInterp1D, ConstantFunction, IdentityFunction,\ diff --git a/HARK/ConsumptionSaving/ConsGenIncProcessModel.py b/HARK/ConsumptionSaving/ConsGenIncProcessModel.py index b21bb7218..83f51501e 100644 --- a/HARK/ConsumptionSaving/ConsGenIncProcessModel.py +++ b/HARK/ConsumptionSaving/ConsGenIncProcessModel.py @@ -4,6 +4,10 @@ ConsIndShockModel by explicitly tracking persistent income as a state variable, and allows (log) persistent income to follow an AR1 process rather than random walk. ''' +from __future__ import division, print_function +from __future__ import absolute_import +from builtins import str +from builtins import range from copy import deepcopy import numpy as np from HARK import AgentType, HARKobject diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index 10a98d362..863f6479d 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -12,11 +12,16 @@ See NARK for information on variable naming conventions. See HARK documentation for mathematical descriptions of the models being solved. ''' +from __future__ import division +from __future__ import print_function +from __future__ import absolute_import +from builtins import str +from builtins import range +from builtins import object from copy import copy, deepcopy import numpy as np from scipy.optimize import newton from HARK import AgentType, Solution, NullFunc, HARKobject -import HARK.ConsumptionSaving.ConsumerParameters as Params from HARK.utilities import warnings # Because of "patch" to warnings modules from HARK.interpolation import CubicInterp, LowerEnvelope, LinearInterp from HARK.simulation import drawDiscrete, drawLognormal, drawUniform @@ -24,6 +29,8 @@ combineIndepDstns, makeGridExpMult, CRRAutility, CRRAutilityP, \ CRRAutilityPP, CRRAutilityP_inv, CRRAutility_invP, CRRAutility_inv, \ CRRAutilityP_invP +import HARK.ConsumptionSaving.ConsumerParameters as Params + __all__ = ['ConsumerSolution', 'ValueFunc', 'MargValueFunc', 'MargMargValueFunc', 'ConsPerfForesightSolver', 'ConsIndShockSetup', 'ConsIndShockSolverBasic', diff --git a/HARK/ConsumptionSaving/ConsMarkovModel.py b/HARK/ConsumptionSaving/ConsMarkovModel.py index 85331e5a1..2641dd9eb 100644 --- a/HARK/ConsumptionSaving/ConsMarkovModel.py +++ b/HARK/ConsumptionSaving/ConsMarkovModel.py @@ -4,6 +4,9 @@ include a Markov state; the interest factor, permanent growth factor, and income distribution can vary with the discrete state. ''' +from __future__ import division, print_function +from __future__ import absolute_import +from builtins import range from copy import deepcopy import numpy as np from HARK import AgentType diff --git a/HARK/ConsumptionSaving/ConsMedModel.py b/HARK/ConsumptionSaving/ConsMedModel.py index 982f74b7d..32aaea065 100644 --- a/HARK/ConsumptionSaving/ConsMedModel.py +++ b/HARK/ConsumptionSaving/ConsMedModel.py @@ -1,6 +1,10 @@ ''' Consumption-saving models that also include medical spending. ''' +from __future__ import division, print_function +from __future__ import absolute_import +from builtins import str +from builtins import range import numpy as np from scipy.optimize import brentq from HARK import HARKobject diff --git a/HARK/ConsumptionSaving/ConsPrefShockModel.py b/HARK/ConsumptionSaving/ConsPrefShockModel.py index 0e3108908..340c3aff2 100644 --- a/HARK/ConsumptionSaving/ConsPrefShockModel.py +++ b/HARK/ConsumptionSaving/ConsPrefShockModel.py @@ -6,6 +6,10 @@ 2) A combination of (1) and ConsKinkedR, demonstrating how to construct a new model by inheriting from multiple classes. ''' +from __future__ import division, print_function +from __future__ import absolute_import +from builtins import str +from builtins import range import numpy as np from HARK.utilities import approxMeanOneLognormal from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType, ConsumerSolution, ConsIndShockSolver, \ diff --git a/HARK/ConsumptionSaving/ConsRepAgentModel.py b/HARK/ConsumptionSaving/ConsRepAgentModel.py index f4c5183ea..b0b755ccb 100644 --- a/HARK/ConsumptionSaving/ConsRepAgentModel.py +++ b/HARK/ConsumptionSaving/ConsRepAgentModel.py @@ -4,6 +4,10 @@ take a heterogeneous agents approach. In RA models, all attributes are either time invariant or exist on a short cycle; models must be infinite horizon. ''' +from __future__ import division, print_function +from __future__ import absolute_import +from builtins import str +from builtins import range import numpy as np from HARK.interpolation import LinearInterp from HARK.simulation import drawUniform, drawDiscrete diff --git a/HARK/ConsumptionSaving/ConsumerParameters.py b/HARK/ConsumptionSaving/ConsumerParameters.py index a4ae56863..53ca2688a 100644 --- a/HARK/ConsumptionSaving/ConsumerParameters.py +++ b/HARK/ConsumptionSaving/ConsumerParameters.py @@ -3,6 +3,7 @@ consumption-saving models. These models can be found in ConsIndShockModel, ConsAggShockModel, ConsPrefShockModel, and ConsMarkovModel. ''' +from __future__ import division, print_function from copy import copy import numpy as np diff --git a/HARK/ConsumptionSaving/TractableBufferStockModel.py b/HARK/ConsumptionSaving/TractableBufferStockModel.py index 1fcdc615b..f47425fe2 100644 --- a/HARK/ConsumptionSaving/TractableBufferStockModel.py +++ b/HARK/ConsumptionSaving/TractableBufferStockModel.py @@ -20,6 +20,9 @@ Despite the non-standard solution method, the iterative process can be embedded in the HARK framework, as shown below. ''' +from __future__ import division, print_function +from __future__ import absolute_import +from builtins import str import numpy as np # Import the HARK library. diff --git a/HARK/ConsumptionSaving/__init__.py b/HARK/ConsumptionSaving/__init__.py index 99245567a..44b489c35 100644 --- a/HARK/ConsumptionSaving/__init__.py +++ b/HARK/ConsumptionSaving/__init__.py @@ -1,10 +1,10 @@ -from HARK.ConsumptionSaving.ConsAggShockModel import * -from HARK.ConsumptionSaving.ConsGenIncProcessModel import * -from HARK.ConsumptionSaving.ConsIndShockModel import * -from HARK.ConsumptionSaving.ConsMarkovModel import * -from HARK.ConsumptionSaving.ConsMedModel import * -from HARK.ConsumptionSaving.ConsPortfolioModel import * -from HARK.ConsumptionSaving.ConsPrefShockModel import * -from HARK.ConsumptionSaving.ConsRepAgentModel import * -from HARK.ConsumptionSaving.TractableBufferStockModel import * -from HARK.ConsumptionSaving.ConsumerParameters import * +# from HARK.ConsumptionSaving.ConsumerParameters import * +# from HARK.ConsumptionSaving.ConsAggShockModel import * +# from HARK.ConsumptionSaving.ConsGenIncProcessModel import * +# from HARK.ConsumptionSaving.ConsIndShockModel import * +# from HARK.ConsumptionSaving.ConsMarkovModel import * +# from HARK.ConsumptionSaving.ConsMedModel import * +# from HARK.ConsumptionSaving.ConsPortfolioModel import * +# from HARK.ConsumptionSaving.ConsPrefShockModel import * +# from HARK.ConsumptionSaving.ConsRepAgentModel import * +# from HARK.ConsumptionSaving.TractableBufferStockModel import * diff --git a/HARK/ConsumptionSaving/tests/test_ConsMarkovModel.py b/HARK/ConsumptionSaving/tests/test_ConsMarkovModel.py index 7de568b28..6de68dfd3 100644 --- a/HARK/ConsumptionSaving/tests/test_ConsMarkovModel.py +++ b/HARK/ConsumptionSaving/tests/test_ConsMarkovModel.py @@ -1,5 +1,5 @@ import numpy as np -from HARK import MarkovConsumerType +from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType import HARK.ConsumptionSaving.ConsumerParameters as Params from copy import copy import unittest diff --git a/HARK/__init__.py b/HARK/__init__.py index c235d788e..f15296917 100644 --- a/HARK/__init__.py +++ b/HARK/__init__.py @@ -1,4 +1,4 @@ +from __future__ import absolute_import __version__ = '0.10.3' from HARK.core import * -from HARK.ConsumptionSaving import * From 6177dd0718904d8a5002b2dfac7eddb3cb0716bd Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Thu, 20 Feb 2020 10:11:10 +0530 Subject: [PATCH 27/43] move consumptionsaving tests to test dir --- .../tests/test_modelInits.py | 66 ++++++++ .../tests/test_modelcomparisons.py | 157 ++++++++++++++++++ 2 files changed, 223 insertions(+) create mode 100644 HARK/ConsumptionSaving/tests/test_modelInits.py create mode 100644 HARK/ConsumptionSaving/tests/test_modelcomparisons.py diff --git a/HARK/ConsumptionSaving/tests/test_modelInits.py b/HARK/ConsumptionSaving/tests/test_modelInits.py new file mode 100644 index 000000000..4d4d9b2e2 --- /dev/null +++ b/HARK/ConsumptionSaving/tests/test_modelInits.py @@ -0,0 +1,66 @@ +""" +This file tests whether HARK's models are initialized correctly. +""" + + +# Bring in modules we need +import unittest +import numpy as np +import HARK.ConsumptionSaving.ConsumerParameters as Params +from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType +from HARK.ConsumptionSaving.ConsIndShockModel import KinkedRconsumerType +from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType +from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType +from HARK.utilities import plotFuncsDer, plotFuncs +from copy import copy + +class testInitialization(unittest.TestCase): + # We don't need a setUp method for the tests to run, but it's convenient + # if we want to test various things on the same model in different test_* + # methods. + def test_PerfForesightConsumerType(self): + try: + model = PerfForesightConsumerType(**Params.init_perfect_foresight) + except: + self.fail("PerfForesightConsumerType failed to initialize with Params.init_perfect_foresight.") + + def test_IndShockConsumerType(self): + try: + model = IndShockConsumerType(**Params.init_lifecycle) + except: + self.fail("IndShockConsumerType failed to initialize with Params.init_lifecycle.") + + def test_KinkedRconsumerType(self): + try: + model = KinkedRconsumerType(**Params.init_kinked_R) + except: + self.fail("KinkedRconsumerType failed to initialize with Params.init_kinked_R.") + + def test_MarkovConsumerType(self): + try: + unemp_length = 5 # Averange length of unemployment spell + urate_good = 0.05 # Unemployment rate when economy is in good state + urate_bad = 0.12 # Unemployment rate when economy is in bad state + bust_prob = 0.01 # Probability of economy switching from good to bad + recession_length = 20 # Averange length of bad state + p_reemploy =1.0/unemp_length + p_unemploy_good = p_reemploy*urate_good/(1-urate_good) + p_unemploy_bad = p_reemploy*urate_bad/(1-urate_bad) + boom_prob = 1.0/recession_length + MrkvArray = np.array([[(1-p_unemploy_good)*(1-bust_prob),p_unemploy_good*(1-bust_prob), + (1-p_unemploy_good)*bust_prob,p_unemploy_good*bust_prob], + [p_reemploy*(1-bust_prob),(1-p_reemploy)*(1-bust_prob), + p_reemploy*bust_prob,(1-p_reemploy)*bust_prob], + [(1-p_unemploy_bad)*boom_prob,p_unemploy_bad*boom_prob, + (1-p_unemploy_bad)*(1-boom_prob),p_unemploy_bad*(1-boom_prob)], + [p_reemploy*boom_prob,(1-p_reemploy)*boom_prob, + p_reemploy*(1-boom_prob),(1-p_reemploy)*(1-boom_prob)]]) + + # Make a consumer with serially correlated unemployment, subject to boom and bust cycles + init_serial_unemployment = copy(Params.init_idiosyncratic_shocks) + init_serial_unemployment['MrkvArray'] = [MrkvArray] + init_serial_unemployment['UnempPrb'] = 0 # to make income distribution when employed + init_serial_unemployment['global_markov'] = False + SerialUnemploymentExample = MarkovConsumerType(**init_serial_unemployment) + except: + self.fail("MarkovConsumerType failed to initialize with boom/bust unemployment.") diff --git a/HARK/ConsumptionSaving/tests/test_modelcomparisons.py b/HARK/ConsumptionSaving/tests/test_modelcomparisons.py new file mode 100644 index 000000000..5177b4cd3 --- /dev/null +++ b/HARK/ConsumptionSaving/tests/test_modelcomparisons.py @@ -0,0 +1,157 @@ +""" +This file implements unit tests for several of the ConsumptionSaving models in HARK. +These tests compare the output of different models in specific cases in which those models +should yield the same output. The code will pass these tests if and only if the output is close +"enough". +""" + +# Bring in modules we need +import unittest +from copy import deepcopy +import numpy as np + +# Bring in the HARK models we want to test +from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType, IndShockConsumerType +from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType +from HARK.ConsumptionSaving.TractableBufferStockModel import TractableConsumerType + + +class Compare_PerfectForesight_and_Infinite(unittest.TestCase): + """ + Class to compare output of the perfect foresight and infinite horizon models. + When income uncertainty is removed from the infinite horizon model, it reduces in theory to + the perfect foresight model. This class implements tests to make sure it reduces in practice + to the perfect foresight model as well. + """ + + def setUp(self): + """ + Prepare to compare the models by initializing and solving them + """ + # Set up and solve infinite type + import HARK.ConsumptionSaving.ConsumerParameters as Params + + # Define a test dictionary that should have the same solution in the + # perfect foresight and idiosyncratic shocks models. + test_dictionary = deepcopy(Params.init_idiosyncratic_shocks) + test_dictionary['LivPrb'] = [1.] + test_dictionary['DiscFac'] = 0.955 + test_dictionary['PermGroFac'] = [1.] + test_dictionary['PermShkStd'] = [0.] + test_dictionary['TranShkStd'] = [0.] + test_dictionary['UnempPrb'] = 0. + test_dictionary['T_cycle'] = 1 + test_dictionary['T_retire'] = 0 + test_dictionary['BoroCnstArt'] = None + + InfiniteType = IndShockConsumerType(**test_dictionary) + InfiniteType.cycles = 0 + + InfiniteType.updateIncomeProcess() + InfiniteType.solve() + InfiniteType.timeFwd() + InfiniteType.unpackcFunc() + + # Make and solve a perfect foresight consumer type with the same parameters + PerfectForesightType = PerfForesightConsumerType(**test_dictionary) + PerfectForesightType.cycles = 0 + + PerfectForesightType.solve() + PerfectForesightType.unpackcFunc() + PerfectForesightType.timeFwd() + + self.InfiniteType = InfiniteType + self.PerfectForesightType = PerfectForesightType + + def test_consumption(self): + """" + Now compare the consumption functions and make sure they are "close" + """ + def diffFunc(m): return self.PerfectForesightType.solution[0].cFunc(m) - \ + self.InfiniteType.cFunc[0](m) + points = np.arange(0.5, 10., .01) + difference = diffFunc(points) + max_difference = np.max(np.abs(difference)) + + self.assertLess(max_difference, 0.01) + + +class Compare_TBS_and_Markov(unittest.TestCase): + """ + Class to compare output of the Tractable Buffer Stock and Markov models. + The only uncertainty in the TBS model is over when the agent will enter an absorbing state + with 0 income. With the right transition arrays and income processes, this is just a special + case of the Markov model. So with the right inputs, we should be able to solve the two + different models and get the same outputs. + """ + def setUp(self): + # Set up and solve TBS + base_primitives = {'UnempPrb': .015, + 'DiscFac': 0.9, + 'Rfree': 1.1, + 'PermGroFac': 1.05, + 'CRRA': .95} + TBSType = TractableConsumerType(**base_primitives) + TBSType.solve() + + # Set up and solve Markov + MrkvArray = [np.array([[1.0-base_primitives['UnempPrb'], base_primitives['UnempPrb']],[0.0, 1.0]])] + Markov_primitives = {"CRRA": base_primitives['CRRA'], + "Rfree": np.array(2*[base_primitives['Rfree']]), + "PermGroFac": [np.array(2*[base_primitives['PermGroFac'] / + (1.0-base_primitives['UnempPrb'])])], + "BoroCnstArt": None, + "PermShkStd": [0.0], + "PermShkCount": 1, + "TranShkStd": [0.0], + "TranShkCount": 1, + "T_total": 1, + "UnempPrb": 0.0, + "UnempPrbRet": 0.0, + "T_retire": 0, + "IncUnemp": 0.0, + "IncUnempRet": 0.0, + "aXtraMin": 0.001, + "aXtraMax": TBSType.mUpperBnd, + "aXtraCount": 48, + "aXtraExtra": [None], + "aXtraNestFac": 3, + "LivPrb":[np.array([1.0,1.0]),], + "DiscFac": base_primitives['DiscFac'], + 'Nagents': 1, + 'psi_seed': 0, + 'xi_seed': 0, + 'unemp_seed': 0, + 'tax_rate': 0.0, + 'vFuncBool': False, + 'CubicBool': True, + 'MrkvArray': MrkvArray, + 'T_cycle':1 + } + + MarkovType = MarkovConsumerType(**Markov_primitives) + MarkovType.cycles = 0 + employed_income_dist = [np.ones(1), np.ones(1), np.ones(1)] + unemployed_income_dist = [np.ones(1), np.ones(1), np.zeros(1)] + MarkovType.IncomeDstn = [[employed_income_dist, unemployed_income_dist]] + + MarkovType.solve() + MarkovType.unpackcFunc() + + self.TBSType = TBSType + self.MarkovType = MarkovType + + def test_consumption(self): + # Now compare the consumption functions and make sure they are "close" + + def diffFunc(m): return self.TBSType.solution[0].cFunc(m) - self.MarkovType.cFunc[0][0](m) + points = np.arange(0.1, 10., .01) + difference = diffFunc(points) + max_difference = np.max(np.abs(difference)) + + self.assertLess(max_difference, 0.01) + + +if __name__ == '__main__': + # Run all the tests + unittest.main() From abef8e37ce959e631344917c7a18705a5b39b752 Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Thu, 20 Feb 2020 10:11:37 +0530 Subject: [PATCH 28/43] move consumptionsaving tests to test dir --- HARK/tests/test_modelInits.py | 66 ------------ HARK/tests/test_modelcomparisons.py | 157 ---------------------------- 2 files changed, 223 deletions(-) delete mode 100644 HARK/tests/test_modelInits.py delete mode 100644 HARK/tests/test_modelcomparisons.py diff --git a/HARK/tests/test_modelInits.py b/HARK/tests/test_modelInits.py deleted file mode 100644 index 4d4d9b2e2..000000000 --- a/HARK/tests/test_modelInits.py +++ /dev/null @@ -1,66 +0,0 @@ -""" -This file tests whether HARK's models are initialized correctly. -""" - - -# Bring in modules we need -import unittest -import numpy as np -import HARK.ConsumptionSaving.ConsumerParameters as Params -from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType -from HARK.ConsumptionSaving.ConsIndShockModel import KinkedRconsumerType -from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType -from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType -from HARK.utilities import plotFuncsDer, plotFuncs -from copy import copy - -class testInitialization(unittest.TestCase): - # We don't need a setUp method for the tests to run, but it's convenient - # if we want to test various things on the same model in different test_* - # methods. - def test_PerfForesightConsumerType(self): - try: - model = PerfForesightConsumerType(**Params.init_perfect_foresight) - except: - self.fail("PerfForesightConsumerType failed to initialize with Params.init_perfect_foresight.") - - def test_IndShockConsumerType(self): - try: - model = IndShockConsumerType(**Params.init_lifecycle) - except: - self.fail("IndShockConsumerType failed to initialize with Params.init_lifecycle.") - - def test_KinkedRconsumerType(self): - try: - model = KinkedRconsumerType(**Params.init_kinked_R) - except: - self.fail("KinkedRconsumerType failed to initialize with Params.init_kinked_R.") - - def test_MarkovConsumerType(self): - try: - unemp_length = 5 # Averange length of unemployment spell - urate_good = 0.05 # Unemployment rate when economy is in good state - urate_bad = 0.12 # Unemployment rate when economy is in bad state - bust_prob = 0.01 # Probability of economy switching from good to bad - recession_length = 20 # Averange length of bad state - p_reemploy =1.0/unemp_length - p_unemploy_good = p_reemploy*urate_good/(1-urate_good) - p_unemploy_bad = p_reemploy*urate_bad/(1-urate_bad) - boom_prob = 1.0/recession_length - MrkvArray = np.array([[(1-p_unemploy_good)*(1-bust_prob),p_unemploy_good*(1-bust_prob), - (1-p_unemploy_good)*bust_prob,p_unemploy_good*bust_prob], - [p_reemploy*(1-bust_prob),(1-p_reemploy)*(1-bust_prob), - p_reemploy*bust_prob,(1-p_reemploy)*bust_prob], - [(1-p_unemploy_bad)*boom_prob,p_unemploy_bad*boom_prob, - (1-p_unemploy_bad)*(1-boom_prob),p_unemploy_bad*(1-boom_prob)], - [p_reemploy*boom_prob,(1-p_reemploy)*boom_prob, - p_reemploy*(1-boom_prob),(1-p_reemploy)*(1-boom_prob)]]) - - # Make a consumer with serially correlated unemployment, subject to boom and bust cycles - init_serial_unemployment = copy(Params.init_idiosyncratic_shocks) - init_serial_unemployment['MrkvArray'] = [MrkvArray] - init_serial_unemployment['UnempPrb'] = 0 # to make income distribution when employed - init_serial_unemployment['global_markov'] = False - SerialUnemploymentExample = MarkovConsumerType(**init_serial_unemployment) - except: - self.fail("MarkovConsumerType failed to initialize with boom/bust unemployment.") diff --git a/HARK/tests/test_modelcomparisons.py b/HARK/tests/test_modelcomparisons.py deleted file mode 100644 index 5177b4cd3..000000000 --- a/HARK/tests/test_modelcomparisons.py +++ /dev/null @@ -1,157 +0,0 @@ -""" -This file implements unit tests for several of the ConsumptionSaving models in HARK. -These tests compare the output of different models in specific cases in which those models -should yield the same output. The code will pass these tests if and only if the output is close -"enough". -""" - -# Bring in modules we need -import unittest -from copy import deepcopy -import numpy as np - -# Bring in the HARK models we want to test -from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType, IndShockConsumerType -from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType -from HARK.ConsumptionSaving.TractableBufferStockModel import TractableConsumerType - - -class Compare_PerfectForesight_and_Infinite(unittest.TestCase): - """ - Class to compare output of the perfect foresight and infinite horizon models. - When income uncertainty is removed from the infinite horizon model, it reduces in theory to - the perfect foresight model. This class implements tests to make sure it reduces in practice - to the perfect foresight model as well. - """ - - def setUp(self): - """ - Prepare to compare the models by initializing and solving them - """ - # Set up and solve infinite type - import HARK.ConsumptionSaving.ConsumerParameters as Params - - # Define a test dictionary that should have the same solution in the - # perfect foresight and idiosyncratic shocks models. - test_dictionary = deepcopy(Params.init_idiosyncratic_shocks) - test_dictionary['LivPrb'] = [1.] - test_dictionary['DiscFac'] = 0.955 - test_dictionary['PermGroFac'] = [1.] - test_dictionary['PermShkStd'] = [0.] - test_dictionary['TranShkStd'] = [0.] - test_dictionary['UnempPrb'] = 0. - test_dictionary['T_cycle'] = 1 - test_dictionary['T_retire'] = 0 - test_dictionary['BoroCnstArt'] = None - - InfiniteType = IndShockConsumerType(**test_dictionary) - InfiniteType.cycles = 0 - - InfiniteType.updateIncomeProcess() - InfiniteType.solve() - InfiniteType.timeFwd() - InfiniteType.unpackcFunc() - - # Make and solve a perfect foresight consumer type with the same parameters - PerfectForesightType = PerfForesightConsumerType(**test_dictionary) - PerfectForesightType.cycles = 0 - - PerfectForesightType.solve() - PerfectForesightType.unpackcFunc() - PerfectForesightType.timeFwd() - - self.InfiniteType = InfiniteType - self.PerfectForesightType = PerfectForesightType - - def test_consumption(self): - """" - Now compare the consumption functions and make sure they are "close" - """ - def diffFunc(m): return self.PerfectForesightType.solution[0].cFunc(m) - \ - self.InfiniteType.cFunc[0](m) - points = np.arange(0.5, 10., .01) - difference = diffFunc(points) - max_difference = np.max(np.abs(difference)) - - self.assertLess(max_difference, 0.01) - - -class Compare_TBS_and_Markov(unittest.TestCase): - """ - Class to compare output of the Tractable Buffer Stock and Markov models. - The only uncertainty in the TBS model is over when the agent will enter an absorbing state - with 0 income. With the right transition arrays and income processes, this is just a special - case of the Markov model. So with the right inputs, we should be able to solve the two - different models and get the same outputs. - """ - def setUp(self): - # Set up and solve TBS - base_primitives = {'UnempPrb': .015, - 'DiscFac': 0.9, - 'Rfree': 1.1, - 'PermGroFac': 1.05, - 'CRRA': .95} - TBSType = TractableConsumerType(**base_primitives) - TBSType.solve() - - # Set up and solve Markov - MrkvArray = [np.array([[1.0-base_primitives['UnempPrb'], base_primitives['UnempPrb']],[0.0, 1.0]])] - Markov_primitives = {"CRRA": base_primitives['CRRA'], - "Rfree": np.array(2*[base_primitives['Rfree']]), - "PermGroFac": [np.array(2*[base_primitives['PermGroFac'] / - (1.0-base_primitives['UnempPrb'])])], - "BoroCnstArt": None, - "PermShkStd": [0.0], - "PermShkCount": 1, - "TranShkStd": [0.0], - "TranShkCount": 1, - "T_total": 1, - "UnempPrb": 0.0, - "UnempPrbRet": 0.0, - "T_retire": 0, - "IncUnemp": 0.0, - "IncUnempRet": 0.0, - "aXtraMin": 0.001, - "aXtraMax": TBSType.mUpperBnd, - "aXtraCount": 48, - "aXtraExtra": [None], - "aXtraNestFac": 3, - "LivPrb":[np.array([1.0,1.0]),], - "DiscFac": base_primitives['DiscFac'], - 'Nagents': 1, - 'psi_seed': 0, - 'xi_seed': 0, - 'unemp_seed': 0, - 'tax_rate': 0.0, - 'vFuncBool': False, - 'CubicBool': True, - 'MrkvArray': MrkvArray, - 'T_cycle':1 - } - - MarkovType = MarkovConsumerType(**Markov_primitives) - MarkovType.cycles = 0 - employed_income_dist = [np.ones(1), np.ones(1), np.ones(1)] - unemployed_income_dist = [np.ones(1), np.ones(1), np.zeros(1)] - MarkovType.IncomeDstn = [[employed_income_dist, unemployed_income_dist]] - - MarkovType.solve() - MarkovType.unpackcFunc() - - self.TBSType = TBSType - self.MarkovType = MarkovType - - def test_consumption(self): - # Now compare the consumption functions and make sure they are "close" - - def diffFunc(m): return self.TBSType.solution[0].cFunc(m) - self.MarkovType.cFunc[0][0](m) - points = np.arange(0.1, 10., .01) - difference = diffFunc(points) - max_difference = np.max(np.abs(difference)) - - self.assertLess(max_difference, 0.01) - - -if __name__ == '__main__': - # Run all the tests - unittest.main() From 9d7f61c9df65c101c5d7f0feb7fe4b319b80f7e7 Mon Sep 17 00:00:00 2001 From: llorracc <@users.noreply.github.com> Date: Thu, 20 Feb 2020 17:44:41 +0100 Subject: [PATCH 29/43] Final updates for checkConditions before turnover to Seb and Mridul --- HARK/ConsumptionSaving/ConsIndShockModel.py | 116 ++++++++++---------- 1 file changed, 55 insertions(+), 61 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index 2f639471a..bc77c42fd 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -1852,10 +1852,10 @@ def getPostStates(self): def checkConditions(self,verbose=False,verbose_reference=False,public_call=False): ''' - This method checks whether the instance's type satisfies the Growth Impatience Condition - (GIC), Return Impatience Condition (RIC), Absolute Impatience Condition (AIC), Return - Impatience Condition (RIC), Finite Human Wealth Condition (FHWC) and Finite Value of - Autarky Condition (FVAC). Depending on the configuration of parameter values, some + This method checks whether the instance's type satisfies the Absolute Impatience Condition (AIC), + the Return Impatience Condition (RIC), the Finite Human Wealth Condition (FHWC) and the perfect foresight + model's version of the Finite Value of the Growth Impatience Condition (GIC_PF) and + Autarky Condition (FVAC_PF). Depending on the configuration of parameter values, some combination of these conditions must be satisfied in order for the problem to have a nondegenerate solution. To check which conditions are required, in the verbose mode a reference to the relevant theoretical literature is made. @@ -1902,22 +1902,22 @@ def checkConditions(self,verbose=False,verbose_reference=False,public_call=False print() #Evaluate and report on the Growth Impatience Condition - GIF = Thorn/self.PermGroFac[0] - self.GIF = GIF + GIFPF = Thorn/self.PermGroFac[0] + self.GIFPF = GIFPF - if GIF<1: - self.GIC = True + if GIFPF<1: + self.GICPF = True if public_call or verbose: - print('The value of the Growth Impatience Factor for the supplied parameter values satisfies the Growth Impatience Condition.', end = " ") + print('The value of the Growth Impatience Factor for the supplied parameter values satisfies the Perfect Foresight Growth Impatience Condition.', end = " ") if verbose: - print(' Therefore, the ratio of individual wealth to permanent income will fall indefinitely.') + print(' Therefore, for a perfect foresight consumer, the ratio of individual wealth to permanent income will fall indefinitely.') print() else: - self.GIC = False + self.GICPF = False violated = True - print('The given parameter values violate the Growth Impatience Condition for this consumer type; the GIF is: %2.4f' % (GIF), end = " ") + print('The given parameter values violate the Perfect Foresight Growth Impatience Condition for this consumer type; the GIFPF is: %2.4f' % (GIFPF), end = " ") if verbose: - print(' Therefore, the ratio of individual wealth to permanent income is expected to grow toward infinity.') + print(' Therefore, for a perfect foresight consumer the ratio of individual wealth to permanent income is expected to grow toward infinity.') print() @@ -2251,8 +2251,7 @@ def preSolve(self): def checkConditions(self,verbose=False,public_call=True): ''' - This method checks whether the instance's type satisfies the Growth Impatience Condition - (GIC), Return Impatience Condition (RIC), Absolute Impatience Condition (AIC), Weak Return + This method checks whether the instance's type satisfies the Absolute Impatience Condition (AIC), Weak Return Impatience Condition (WRIC), Finite Human Wealth Condition (FHWC) and Finite Value of Autarky Condition (FVAC). When combinations of these conditions are satisfied, the solution to the problem exhibits different characteristics. (For an exposition of the @@ -2289,38 +2288,38 @@ def checkConditions(self,verbose=False,public_call=True): # [url]/#Pat, adjusted to include mortality # Thorn = ((self.Rfree/self.LivPrb[0])*(self.DiscFac*self.LivPrb[0]))**(1/self.CRRA) Thorn = ((self.Rfree*self.DiscFac))**(1/self.CRRA) - GIF = Thorn/(self.PermGroFac[0] ) # [url]/#GIF + GIFPF = Thorn/(self.PermGroFac[0] ) # [url]/#GIF GIFInd = Thorn/(self.PermGroFac[0]*InvEPermShkInv) # [url]/#GIFI - GIFAgg = Thorn*self.LivPrb[0]/self.PermGroFac[0] # [url]#/GIFA + GIFAgg = Thorn*self.LivPrb[0]/self.PermGroFac[0] # Lower bound of aggregate wealth growth if all inheritances squandered -# self.Rnorm = self.Rfree*EPermShkInv/(self.PermGroFac[0]*self.LivPrb[0]) - self.GIF = GIF - self.GIFInd = GIFInd - self.GIFAgg = GIFAgg - self.Thorn = Thorn - self.PermGroFacAdj = PermGroFacAdj - self.EPermShkInv = EPermShkInv - self.InvEPermShkInv = InvEPermShkInv - self.DiscFacGIFMax = ((self.PermGroFac[0] )**(self.CRRA))/(self.Rfree) # DiscFac at growth impatience knife edge - self.DiscFacGIFIMax = ((self.PermGroFac[0]*InvEPermShkInv)**(self.CRRA))/(self.Rfree) # DiscFac at growth impatience knife edge - self.DiscFacGIFAMax = ((self.PermGroFac[0] )**(self.CRRA))/(self.Rfree*self.LivPrb[0]) # DiscFac at growth impatience knife edge +# self.Rnorm = self.Rfree*EPermShkInv/(self.PermGroFac[0]*self.LivPrb[0]) + self.GIFPF = GIFPF + self.GIFInd = GIFInd + self.GIFAgg = GIFAgg + self.Thorn = Thorn + self.PermGroFacAdj = PermGroFacAdj + self.EPermShkInv = EPermShkInv + self.InvEPermShkInv = InvEPermShkInv + self.DiscFacGIFPFMax = ((self.PermGroFac[0] )**(self.CRRA))/(self.Rfree) # DiscFac at growth impatience knife edge + self.DiscFacGIFIndMax = ((self.PermGroFac[0]*InvEPermShkInv)**(self.CRRA))/(self.Rfree) # DiscFac at growth impatience knife edge + self.DiscFacGIFAggMax = ((self.PermGroFac[0] )**(self.CRRA))/(self.Rfree*self.LivPrb[0]) # DiscFac at growth impatience knife edge #Evaluate and report on the Growth Impatience Condition # [url]/#GIC - if GIF<=1: - self.GIC = True + if GIFPF<1: + self.GICPF = True if public_call or verbose: - print('The value of the Growth Impatience Factor for the supplied parameter values satisfies the Growth Impatience Condition.', end = " ") + print('The value of the Perfect Foresight Growth Impatience Factor for the supplied parameter values satisfies the Perfect Foresight Growth Impatience Condition.', end = " ") if verbose: - print('Therefore, a target level of the ratio of expected market resources to expected permanent income exists (see '+url+'/#onetarget).') + print(' Therefore, in the absence of any risk, the ratio of individual wealth to permanent income would fall indefinitely.') print() else: - self.GIC = False + self.GICPF = False violated = True - print('The given parameter values violate the Growth Impatience Condition; the GIF is: %2.4f' % (GIF), end = " ") + print('The given parameter values violate the Perfect Foresight Growth Impatience Condition; the GIFPF is: %2.4f' % (GIFPF), end = " ") if verbose: print('') - print('Therefore, a target level of wealth does not exist. (see '+url+'/#onetarget)') + print('Therefore, the ratio of wealth to permanent income approaches infinity in the perfect foresight model. (see '+url+' for more).') print() if GIFInd<=1: @@ -2328,7 +2327,7 @@ def checkConditions(self,verbose=False,public_call=True): if public_call or verbose: print('The value of the Individual Growth Impatience Factor for the supplied parameter values satisfies the Individual Growth Impatience Condition.', end = " ") if verbose: - print('Therefore, a target level of the individual market resources ratio m exists (see '+url+'/#onetarget).') + print('Therefore, a target level of the individual market resources ratio m exists (see '+url+'/#onetarget for more).') print() else: self.GICInd = False @@ -2336,7 +2335,7 @@ def checkConditions(self,verbose=False,public_call=True): print('The given parameter values violate the Individual Growth Impatience Condition; the GIFInd is: %2.4f' % (GIFInd), end = " ") if verbose: print('') - print('Therefore, a target ratio of individual market resources to individual permanent income does not exist. (see '+url+'/#onetarget)') + print('Therefore, a target ratio of individual market resources to individual permanent income does not exist. (see '+url+'/#onetarget for more).') print() if GIFAgg<=1: @@ -2344,7 +2343,7 @@ def checkConditions(self,verbose=False,public_call=True): if public_call or verbose: print('The value of the Aggregate Growth Impatience Factor for the supplied parameter values satisfies the Aggregate Growth Impatience Condition.', end = " ") if verbose: - print('Therefore, it is possible that a target level of the ratio of expected market resources to expected permanent income exists (see '+url+'/#onetarget).') + print('Therefore, it is possible that a target level of the ratio of aggregate market resources to aggregate permanent income exists.') # Need to provide reference print() else: self.GICAgg = False @@ -2352,7 +2351,7 @@ def checkConditions(self,verbose=False,public_call=True): print('The given parameter values violate the Aggregate Growth Impatience Condition; the GIFAgg is: %2.4f' % (GIFAgg), end = " ") if verbose: print('') - print('Therefore, a target ratio of aggregate resources to aggreg permanent income does not exist. (see '+url+'/#onetarget)') + print('Therefore, a target ratio of aggregate resources to aggregate permanent income does not exist.') # Need to provide reference print() #Evaluate and report on the Weak Return Impatience Condition @@ -2362,7 +2361,7 @@ def checkConditions(self,verbose=False,public_call=True): if WRIF<=1: self.WRIC = True if public_call or verbose: - print('The Weak Return Impatience Factor value for the supplied parameter values satisfies the Weak Return Impatience Condition (see '+url+'/#WRIC).') + print('The Weak Return Impatience Factor value for the supplied parameter values satisfies the Weak Return Impatience Condition (see '+url+'/#WRIC for more).') print() else: self.WRIC = False @@ -2370,7 +2369,7 @@ def checkConditions(self,verbose=False,public_call=True): print('The given type violates the Weak Return Impatience Condition with the supplied parameter values. The WRIF is: %2.4f' % (WRIF), end = " ") if verbose: print('') - print('Therefore, a nondegenerate solution is not available (see '+url+'/#WRIC.') + print('Therefore, a nondegenerate solution is not available (see '+url+'/#WRIC for more.') print() #Evaluate and report on the Finite Value of Autarky Condition @@ -2403,17 +2402,16 @@ def checkConditions(self,verbose=False,public_call=True): print('') if verbose: - print('GIF = %2.6f ' % (GIF)) - print('GIFInd = %2.6f ' % (GIFInd)) - print('GIFAgg = %2.6f ' % (GIFAgg)) - print('Thorn = %2.6f ' % (Thorn)) - print('PermGroFacAdj = %2.6f ' % (PermGroFacAdj)) - print('uInvEpShkuInv = %2.6f ' % (uInvEpShkuInv)) - print('FVAF = %2.6f ' % (FVAF)) - print('WRIF = %2.6f ' % (WRIF)) - print('DiscFacGIFMax = %2.6f ' % (self.DiscFacGIFMax)) - print('DiscFacGIFAMax= %2.6f ' % (self.DiscFacGIFAMax)) - print('DiscFacGIFAMax= %2.6f ' % (self.DiscFacGIFIMax)) + print('GIFPF = %2.6f ' % (GIFPF)) + print('GIFInd = %2.6f ' % (GIFInd)) + print('GIFAgg = %2.6f ' % (GIFAgg)) + print('Thorn = AIF = %2.6f ' % (Thorn)) + print('PermGroFacAdj = %2.6f ' % (PermGroFacAdj)) + print('uInvEpShkuInv = %2.6f ' % (uInvEpShkuInv)) + print('FVAF = %2.6f ' % (FVAF)) + print('WRIF = %2.6f ' % (WRIF)) + print('DiscFacGIFIndMax = %2.6f ' % (self.DiscFacGIFIndMax)) + print('DiscFacGIFAggMax = %2.6f ' % (self.DiscFacGIFAggMax)) def Ex_Mtp1_over_Ex_Ptp1(self,mRat,verbose=False): cRat = self.solution[-1].cFunc(mRat) @@ -2603,15 +2601,11 @@ def getRfree(self): def checkConditions(self,verbose=False): ''' - This method checks whether the instance's type satisfies the Growth Impatience Condition - (GIC), Return Impatience Condition (RIC), Absolute Impatience Condition (AIC), Weak Return - Impatience Condition (WRIC), Finite Human Wealth Condition (FHWC) and Finite Value of - Autarky Condition (FVAC). These are the conditions that are sufficient for nondegenerate - infinite horizon solutions with a 1 period cycle. Depending on the model at hand, a - different combination of these conditions must be satisfied. To check which conditions are - relevant to the model at hand, a reference to the relevant theoretical literature is made. - - SHOULD BE INHERITED FROM ConsIndShockModel + This method checks whether the instance's type satisfies the Absolute Impatience Condition (AIC), + the Return Impatience Condition (RIC), the Growth Impatience Condition (GIC), the Weak Return + Impatience Condition (WRIC), the Finite Human Wealth Condition (FHWC) and the Finite Value of + Autarky Condition (FVAC). To check which conditions are relevant to the model at hand, a + reference to the relevant theoretical literature is made. Parameters ---------- From dac07bf32c74af9ad56df37f7e8571b11ad2812d Mon Sep 17 00:00:00 2001 From: sb Date: Fri, 21 Feb 2020 09:54:16 -0500 Subject: [PATCH 30/43] update IndShockConsumerType conditions check --- HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py index e7b1e69f4..f6f3f980d 100644 --- a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py +++ b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py @@ -64,8 +64,7 @@ def test_GICFails(self): self.assertAlmostEqual(c_m[500], 0.7772637042393458) self.assertAlmostEqual(c_m[700], 0.8392649061916746) - self.assertFalse(GICFailExample.GIC) - self.assertFalse(GICFailExample.AIC) + self.assertFalse(GICFailExample.GICPF) def test_infinite_horizon(self): baseEx_inf = IndShockConsumerType(cycles=0, From a71e9504e0906eb8654175e64a2bb53a2d7dfde3 Mon Sep 17 00:00:00 2001 From: sb Date: Fri, 21 Feb 2020 10:24:50 -0500 Subject: [PATCH 31/43] functionalize out the conditions (AIC, GICPF, RIC, FHWC) from checkConditions() --- HARK/ConsumptionSaving/ConsIndShockModel.py | 89 ++++++++++++--------- 1 file changed, 52 insertions(+), 37 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index bc77c42fd..efebbaeae 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -1850,40 +1850,12 @@ def getPostStates(self): self.aLvlNow = self.aNrmNow*self.pLvlNow # Useful in some cases to precalculate asset level return None - def checkConditions(self,verbose=False,verbose_reference=False,public_call=False): + def checkAIC(self, thorn): ''' - This method checks whether the instance's type satisfies the Absolute Impatience Condition (AIC), - the Return Impatience Condition (RIC), the Finite Human Wealth Condition (FHWC) and the perfect foresight - model's version of the Finite Value of the Growth Impatience Condition (GIC_PF) and - Autarky Condition (FVAC_PF). Depending on the configuration of parameter values, some - combination of these conditions must be satisfied in order for the problem to have - a nondegenerate solution. To check which conditions are required, in the verbose mode - a reference to the relevant theoretical literature is made. - - Parameters - ---------- - verbose : boolean - Specifies different levels of verbosity of feedback. When False, it only reports whether the - instance's type fails to satisfy a particular condition. When True, it reports all results, i.e. - the factor values for all conditions. - - Returns - ------- - None + Evaluate and report on the Absolute Impatience Condition ''' - # This method only checks for the conditions for infinite horizon models - # with a 1 period cycle. If these conditions are not met, we exit early. - if self.cycles!=0 or self.T_cycle > 1: - return + AIF = thorn - violated = False - - Thorn = (self.Rfree*self.DiscFac*self.LivPrb[0])**(1/self.CRRA) - AIF = Thorn - - #Evaluate and report on the Absolute Impatience Condition - - self.Thorn = Thorn self.AIF = AIF if AIF<1: self.AIC = True @@ -1900,9 +1872,12 @@ def checkConditions(self,verbose=False,verbose_reference=False,public_call=False violated = True print(' Because the AIF > 1, the absolute amount of consumption is expected to grow over time') print() - - #Evaluate and report on the Growth Impatience Condition - GIFPF = Thorn/self.PermGroFac[0] + + def checkGICPF(self,thorn): + ''' + Evaluate and report on the Growth Impatience Condition + ''' + GIFPF = thorn/self.PermGroFac[0] self.GIFPF = GIFPF if GIFPF<1: @@ -1919,9 +1894,11 @@ def checkConditions(self,verbose=False,verbose_reference=False,public_call=False if verbose: print(' Therefore, for a perfect foresight consumer the ratio of individual wealth to permanent income is expected to grow toward infinity.') print() - - #Evaluate and report on the Return Impatience Condition + def checkRIC(self, thorn): + ''' + Evaluate and report on the Return Impatience Condition + ''' RIF = Thorn/self.Rfree self.RIF = RIF @@ -1940,7 +1917,11 @@ def checkConditions(self,verbose=False,verbose_reference=False,public_call=False print('Therefore, the limiting consumption function is c(m)=0 for all m') print() - #Evaluate and report on the Finite Human Wealth Condition + def checkFHWC(self): + ''' + Evaluate and report on the Finite Human Wealth Condition + ''' + FHWF = self.PermGroFac[0]/self.Rfree self.FHWF = FHWF if FHWF<1: @@ -1966,6 +1947,40 @@ def checkConditions(self,verbose=False,verbose_reference=False,public_call=False return violated + def checkConditions(self,verbose=False,verbose_reference=False,public_call=False): + ''' + This method checks whether the instance's type satisfies the Absolute Impatience Condition (AIC), + the Return Impatience Condition (RIC), the Finite Human Wealth Condition (FHWC) and the perfect foresight + model's version of the Finite Value of the Growth Impatience Condition (GIC_PF) and + Autarky Condition (FVAC_PF). Depending on the configuration of parameter values, some + combination of these conditions must be satisfied in order for the problem to have + a nondegenerate solution. To check which conditions are required, in the verbose mode + a reference to the relevant theoretical literature is made. + + Parameters + ---------- + verbose : boolean + Specifies different levels of verbosity of feedback. When False, it only reports whether the + instance's type fails to satisfy a particular condition. When True, it reports all results, i.e. + the factor values for all conditions. + + Returns + ------- + None + ''' + # This method only checks for the conditions for infinite horizon models + # with a 1 period cycle. If these conditions are not met, we exit early. + if self.cycles!=0 or self.T_cycle > 1: + return + + Thorn = (self.Rfree*self.DiscFac*self.LivPrb[0])**(1/self.CRRA) + self.Thorn = thorn + + self.checkAIC(Thorn) + self.checkGICPF(Thorn) + self.checkRIC(Thorn) + self.checkFHWC() + class IndShockConsumerType(PerfForesightConsumerType): ''' A consumer type with idiosyncratic shocks to permanent and transitory income. From c5f0ee5b56e532a320f2ee9f97311c100b98071d Mon Sep 17 00:00:00 2001 From: sb Date: Fri, 21 Feb 2020 11:00:50 -0500 Subject: [PATCH 32/43] functionalize out IndShockConsumerType conditions --- HARK/ConsumptionSaving/ConsIndShockModel.py | 177 ++++++++++---------- 1 file changed, 91 insertions(+), 86 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index efebbaeae..7cba62da6 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -1850,7 +1850,7 @@ def getPostStates(self): self.aLvlNow = self.aNrmNow*self.pLvlNow # Useful in some cases to precalculate asset level return None - def checkAIC(self, thorn): + def checkAIC(self, thorn,verbose,public_call): ''' Evaluate and report on the Absolute Impatience Condition ''' @@ -1873,7 +1873,7 @@ def checkAIC(self, thorn): print(' Because the AIF > 1, the absolute amount of consumption is expected to grow over time') print() - def checkGICPF(self,thorn): + def checkGICPF(self,thorn,verbose,public_call): ''' Evaluate and report on the Growth Impatience Condition ''' @@ -1895,7 +1895,7 @@ def checkGICPF(self,thorn): print(' Therefore, for a perfect foresight consumer the ratio of individual wealth to permanent income is expected to grow toward infinity.') print() - def checkRIC(self, thorn): + def checkRIC(self, thorn,verbose,public_call): ''' Evaluate and report on the Return Impatience Condition ''' @@ -1917,7 +1917,7 @@ def checkRIC(self, thorn): print('Therefore, the limiting consumption function is c(m)=0 for all m') print() - def checkFHWC(self): + def checkFHWC(self,verbose,public_call): ''' Evaluate and report on the Finite Human Wealth Condition ''' @@ -1947,6 +1947,7 @@ def checkFHWC(self): return violated + def checkConditions(self,verbose=False,verbose_reference=False,public_call=False): ''' This method checks whether the instance's type satisfies the Absolute Impatience Condition (AIC), @@ -1976,10 +1977,10 @@ def checkConditions(self,verbose=False,verbose_reference=False,public_call=False Thorn = (self.Rfree*self.DiscFac*self.LivPrb[0])**(1/self.CRRA) self.Thorn = thorn - self.checkAIC(Thorn) - self.checkGICPF(Thorn) - self.checkRIC(Thorn) - self.checkFHWC() + self.checkAIC(Thorn,verbose,public_call) + self.checkGICPF(Thorn,verbose,public_call) + self.checkRIC(Thorn,verbose,public_call) + self.checkFHWC(verbose,public_call) class IndShockConsumerType(PerfForesightConsumerType): ''' @@ -2264,80 +2265,12 @@ def preSolve(self): if not self.quiet: self.checkConditions(verbose=self.verbose,public_call=False) - def checkConditions(self,verbose=False,public_call=True): + def checkGICInd(self,Thorn,verbose,public_call): ''' - This method checks whether the instance's type satisfies the Absolute Impatience Condition (AIC), Weak Return - Impatience Condition (WRIC), Finite Human Wealth Condition (FHWC) and Finite Value of - Autarky Condition (FVAC). When combinations of these conditions are satisfied, the - solution to the problem exhibits different characteristics. (For an exposition of the - conditions, see http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/) - - Parameters - ---------- - verbose : boolean - Specifies different levels of verbosity of feedback. When False, it only reports whether the - instance's type fails to satisfy a particular condition. When True, it reports all results, i.e. - the factor values for all conditions. - - Returns - ------- - None + Check Individual Growth Impatience Factor. ''' - violated = False # PerfForesightConsumerType.checkConditions(self, verbose=False, verbose_reference=False) - - if self.cycles!=0 or self.T_cycle > 1: - return - - # For theory, see hyperlink targets to expressions in - # url=http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory - # For example, the hyperlink to the relevant section of the paper - url='http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory' - # would be referenced below as: - # [url]/#Uncertainty-Modified-Conditions - - self.InvPermShkDstn=deepcopy(self.PermShkDstn) - self.InvPermShkDstn[0][1]=1/self.PermShkDstn[0][1] - EPermShkInv=np.dot(self.InvPermShkDstn[0][0],1/self.PermShkDstn[0][1]) # $\Ex_{t}[\psi^{-1}_{t+1}]$ (in first eqn in sec) - InvEPermShkInv=(1/EPermShkInv) # $\underline{\psi}$ in the paper (\bar{\isp} in private version) - PermGroFacAdj=self.PermGroFac[0]*InvEPermShkInv # [url]/#PGroAdj - # [url]/#Pat, adjusted to include mortality -# Thorn = ((self.Rfree/self.LivPrb[0])*(self.DiscFac*self.LivPrb[0]))**(1/self.CRRA) - Thorn = ((self.Rfree*self.DiscFac))**(1/self.CRRA) - GIFPF = Thorn/(self.PermGroFac[0] ) # [url]/#GIF - GIFInd = Thorn/(self.PermGroFac[0]*InvEPermShkInv) # [url]/#GIFI - GIFAgg = Thorn*self.LivPrb[0]/self.PermGroFac[0] # Lower bound of aggregate wealth growth if all inheritances squandered - -# self.Rnorm = self.Rfree*EPermShkInv/(self.PermGroFac[0]*self.LivPrb[0]) - self.GIFPF = GIFPF - self.GIFInd = GIFInd - self.GIFAgg = GIFAgg - self.Thorn = Thorn - self.PermGroFacAdj = PermGroFacAdj - self.EPermShkInv = EPermShkInv - self.InvEPermShkInv = InvEPermShkInv - self.DiscFacGIFPFMax = ((self.PermGroFac[0] )**(self.CRRA))/(self.Rfree) # DiscFac at growth impatience knife edge - self.DiscFacGIFIndMax = ((self.PermGroFac[0]*InvEPermShkInv)**(self.CRRA))/(self.Rfree) # DiscFac at growth impatience knife edge - self.DiscFacGIFAggMax = ((self.PermGroFac[0] )**(self.CRRA))/(self.Rfree*self.LivPrb[0]) # DiscFac at growth impatience knife edge - - #Evaluate and report on the Growth Impatience Condition - # [url]/#GIC - if GIFPF<1: - self.GICPF = True - if public_call or verbose: - print('The value of the Perfect Foresight Growth Impatience Factor for the supplied parameter values satisfies the Perfect Foresight Growth Impatience Condition.', end = " ") - if verbose: - print(' Therefore, in the absence of any risk, the ratio of individual wealth to permanent income would fall indefinitely.') - print() - else: - self.GICPF = False - violated = True - print('The given parameter values violate the Perfect Foresight Growth Impatience Condition; the GIFPF is: %2.4f' % (GIFPF), end = " ") - if verbose: - print('') - print('Therefore, the ratio of wealth to permanent income approaches infinity in the perfect foresight model. (see '+url+' for more).') - print() - if GIFInd<=1: + if self.GIFInd<=1: self.GICInd = True if public_call or verbose: print('The value of the Individual Growth Impatience Factor for the supplied parameter values satisfies the Individual Growth Impatience Condition.', end = " ") @@ -2347,13 +2280,15 @@ def checkConditions(self,verbose=False,public_call=True): else: self.GICInd = False violated = True - print('The given parameter values violate the Individual Growth Impatience Condition; the GIFInd is: %2.4f' % (GIFInd), end = " ") + print('The given parameter values violate the Individual Growth Impatience Condition; the GIFInd is: %2.4f' % (self.GIFInd), end = " ") if verbose: print('') print('Therefore, a target ratio of individual market resources to individual permanent income does not exist. (see '+url+'/#onetarget for more).') print() - if GIFAgg<=1: + def checkCIGAgg(self, Thorn,verbose,public_call): + + if self.GIFAgg<=1: self.GICAgg = True if public_call or verbose: print('The value of the Aggregate Growth Impatience Factor for the supplied parameter values satisfies the Aggregate Growth Impatience Condition.', end = " ") @@ -2363,14 +2298,17 @@ def checkConditions(self,verbose=False,public_call=True): else: self.GICAgg = False violated = True - print('The given parameter values violate the Aggregate Growth Impatience Condition; the GIFAgg is: %2.4f' % (GIFAgg), end = " ") + print('The given parameter values violate the Aggregate Growth Impatience Condition; the GIFAgg is: %2.4f' % (self.GIFAgg), end = " ") if verbose: print('') print('Therefore, a target ratio of aggregate resources to aggregate permanent income does not exist.') # Need to provide reference print() - #Evaluate and report on the Weak Return Impatience Condition - # [url]/#WRIF modified to incorporate LivPrb + def checkWRIC(self, verbose,public_call): + ''' + Evaluate and report on the Weak Return Impatience Condition + [url]/#WRIF modified to incorporate LivPrb + ''' WRIF=(self.UnempPrb**(1/self.CRRA))*(self.Rfree*self.DiscFac*self.LivPrb[0])**(1/self.CRRA)/self.Rfree self.WRIF = WRIF if WRIF<=1: @@ -2387,8 +2325,11 @@ def checkConditions(self,verbose=False,public_call=True): print('Therefore, a nondegenerate solution is not available (see '+url+'/#WRIC for more.') print() - #Evaluate and report on the Finite Value of Autarky Condition - # Hyperlink to paper: [url]/#Autarky-Value + def checkFVAC(self,verbose,public_call): + ''' + Evaluate and report on the Finite Value of Autarky Condition + Hyperlink to paper: [url]/#Autarky-Value + ''' EpShkuInv = np.dot(self.PermShkDstn[0][0],self.PermShkDstn[0][1]**(1-self.CRRA)) if self.CRRA != 1.0: uInvEpShkuInv = EpShkuInv**(1/(1-self.CRRA)) # The term that gives a utility-consequence-adjusted utility growth @@ -2412,6 +2353,70 @@ def checkConditions(self,verbose=False,public_call=True): print('Therefore, a nondegenerate solution is not available (see '+url+'/#Conditions-Under-Which-the-Problem-Defines-a-Contraction-Mapping') print() + + + + def checkConditions(self,verbose=False,public_call=True): + ''' + This method checks whether the instance's type satisfies the Absolute Impatience Condition (AIC), Weak Return + Impatience Condition (WRIC), Finite Human Wealth Condition (FHWC) and Finite Value of + Autarky Condition (FVAC). When combinations of these conditions are satisfied, the + solution to the problem exhibits different characteristics. (For an exposition of the + conditions, see http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/) + + Parameters + ---------- + verbose : boolean + Specifies different levels of verbosity of feedback. When False, it only reports whether the + instance's type fails to satisfy a particular condition. When True, it reports all results, i.e. + the factor values for all conditions. + + Returns + ------- + None + ''' + violated = False # PerfForesightConsumerType.checkConditions(self, verbose=False, verbose_reference=False) + + if self.cycles!=0 or self.T_cycle > 1: + return + + # For theory, see hyperlink targets to expressions in + # url=http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory + # For example, the hyperlink to the relevant section of the paper + url='http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory' + # would be referenced below as: + # [url]/#Uncertainty-Modified-Conditions + + self.InvPermShkDstn=deepcopy(self.PermShkDstn) + self.InvPermShkDstn[0][1]=1/self.PermShkDstn[0][1] + EPermShkInv=np.dot(self.InvPermShkDstn[0][0],1/self.PermShkDstn[0][1]) # $\Ex_{t}[\psi^{-1}_{t+1}]$ (in first eqn in sec) + + InvEPermShkInv=(1/EPermShkInv) # $\underline{\psi}$ in the paper (\bar{\isp} in private version) + PermGroFacAdj=self.PermGroFac[0]*InvEPermShkInv # [url]/#PGroAdj + # [url]/#Pat, adjusted to include mortality +# Thorn = ((self.Rfree/self.LivPrb[0])*(self.DiscFac*self.LivPrb[0]))**(1/self.CRRA) + Thorn = ((self.Rfree*self.DiscFac))**(1/self.CRRA) + GIFPF = Thorn/(self.PermGroFac[0] ) # [url]/#GIF + GIFInd = Thorn/(self.PermGroFac[0]*InvEPermShkInv) # [url]/#GIFI + GIFAgg = Thorn*self.LivPrb[0]/self.PermGroFac[0] # Lower bound of aggregate wealth growth if all inheritances squandered + +# self.Rnorm = self.Rfree*EPermShkInv/(self.PermGroFac[0]*self.LivPrb[0]) + self.GIFPF = GIFPF + self.GIFInd = GIFInd + self.GIFAgg = GIFAgg + self.Thorn = Thorn + self.PermGroFacAdj = PermGroFacAdj + self.EPermShkInv = EPermShkInv + self.InvEPermShkInv = InvEPermShkInv + self.DiscFacGIFPFMax = ((self.PermGroFac[0] )**(self.CRRA))/(self.Rfree) # DiscFac at growth impatience knife edge + self.DiscFacGIFIndMax = ((self.PermGroFac[0]*InvEPermShkInv)**(self.CRRA))/(self.Rfree) # DiscFac at growth impatience knife edge + self.DiscFacGIFAggMax = ((self.PermGroFac[0] )**(self.CRRA))/(self.Rfree*self.LivPrb[0]) # DiscFac at growth impatience knife edge + + self.checkGICPF(Thorn,verbose,public_call) + self.checkGICInd(Thorn,verbose,public_call) + self.checkCIGAgg(Thorn,verbose,public_call) + self.checkWRIC(verbose,public_call) + if verbose and violated: print('\n[!] For more information on the conditions, see Tables 3 and 4 in "Theoretical Foundations of Buffer Stock Saving" at '+url+'/#Factors-Defined-And-Compared') print('') From d575be3fe33cdb7374e7ff6b8f1038ce25843ebd Mon Sep 17 00:00:00 2001 From: sb Date: Fri, 21 Feb 2020 11:30:31 -0500 Subject: [PATCH 33/43] violated now stored in the agent object to persist across tests --- HARK/ConsumptionSaving/ConsIndShockModel.py | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index 7cba62da6..7813703f2 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -1861,15 +1861,15 @@ def checkAIC(self, thorn,verbose,public_call): self.AIC = True if public_call or verbose: print('The value of the absolute impatience factor (AIF) for the supplied parameter values satisfies the Absolute Impatience Condition.', end = " ") + self.violated = False if verbose: - violated = False print(' Because the AIF < 1, the absolute amount of consumption is expected to fall over time.') print() else: self.AIC = False print('The given type violates the Absolute Impatience Condition with the supplied parameter values; the AIF is %1.5f ' % (AIF), end=" ") + self.violated = True if verbose: - violated = True print(' Because the AIF > 1, the absolute amount of consumption is expected to grow over time') print() @@ -1889,7 +1889,7 @@ def checkGICPF(self,thorn,verbose,public_call): print() else: self.GICPF = False - violated = True + self.violated = True print('The given parameter values violate the Perfect Foresight Growth Impatience Condition for this consumer type; the GIFPF is: %2.4f' % (GIFPF), end = " ") if verbose: print(' Therefore, for a perfect foresight consumer the ratio of individual wealth to permanent income is expected to grow toward infinity.') @@ -1911,7 +1911,7 @@ def checkRIC(self, thorn,verbose,public_call): print() else: self.RIC = False - violated = True + self.violated = True print('The given type violates the Return Impatience Condition with the supplied parameter values; the factor is %1.5f ' % (RIF), end = " ") if verbose: print('Therefore, the limiting consumption function is c(m)=0 for all m') @@ -1938,7 +1938,7 @@ def checkFHWC(self,verbose,public_call): else: self.FHWC = False print('The given type violates the Finite Human Wealth Condition; the Finite Human wealth factor value %2.5f ' % (FHWF), end = " ") - violated = True + self.violated = True if verbose: print('Therefore, the limiting consumption function is c(m)=Infinity for all m') print() @@ -2279,7 +2279,7 @@ def checkGICInd(self,Thorn,verbose,public_call): print() else: self.GICInd = False - violated = True + self.violated = True print('The given parameter values violate the Individual Growth Impatience Condition; the GIFInd is: %2.4f' % (self.GIFInd), end = " ") if verbose: print('') @@ -2297,7 +2297,7 @@ def checkCIGAgg(self, Thorn,verbose,public_call): print() else: self.GICAgg = False - violated = True + self.violated = True print('The given parameter values violate the Aggregate Growth Impatience Condition; the GIFAgg is: %2.4f' % (self.GIFAgg), end = " ") if verbose: print('') @@ -2318,7 +2318,7 @@ def checkWRIC(self, verbose,public_call): print() else: self.WRIC = False - violated = True + self.violated = True print('The given type violates the Weak Return Impatience Condition with the supplied parameter values. The WRIF is: %2.4f' % (WRIF), end = " ") if verbose: print('') @@ -2348,7 +2348,7 @@ def checkFVAC(self,verbose,public_call): else: self.FVAC = False print('The given type violates the Finite Value of Autarky Condition with the supplied parameter values. The FVAF is %2.4f' %(FVAF), end = " ") - violated = True + self.violated = True if public_call or verbose: print('Therefore, a nondegenerate solution is not available (see '+url+'/#Conditions-Under-Which-the-Problem-Defines-a-Contraction-Mapping') print() @@ -2417,7 +2417,7 @@ def checkConditions(self,verbose=False,public_call=True): self.checkCIGAgg(Thorn,verbose,public_call) self.checkWRIC(verbose,public_call) - if verbose and violated: + if verbose and self.violated: print('\n[!] For more information on the conditions, see Tables 3 and 4 in "Theoretical Foundations of Buffer Stock Saving" at '+url+'/#Factors-Defined-And-Compared') print('') From 0e8f1eb6f105feb0af04e4aacd733656460672cb Mon Sep 17 00:00:00 2001 From: sb Date: Fri, 21 Feb 2020 11:46:53 -0500 Subject: [PATCH 34/43] moving the getShocks() test into ConsumptionSaving/tests/ --- .../tests/test_IndShockConsumerType.py | 24 ++++++++++++++ HARK/tests/test_IndShockConsumerType.py | 31 ------------------- 2 files changed, 24 insertions(+), 31 deletions(-) delete mode 100644 HARK/tests/test_IndShockConsumerType.py diff --git a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py index f6f3f980d..1e58fb27e 100644 --- a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py +++ b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py @@ -3,6 +3,30 @@ import numpy as np import unittest +class testIndShockConsumerType(unittest.TestCase): + + def test_getShocks(self): + agent = IndShockConsumerType( + AgentCount = 2, + T_sim = 10 + ) + + agent.solve() + + agent.initializeSim() + agent.simBirth(np.array([True,False])) + agent.simOnePeriod() + agent.simBirth(np.array([False,True])) + + agent.getShocks() + + self.assertEqual(agent.PermShkNow[0], + 1.0050166461586711) + self.assertEqual(agent.PermShkNow[1], + 1.0050166461586711) + self.assertEqual(agent.TranShkNow[0], + 1.1176912196531754) + class testBufferStock(unittest.TestCase): """ Tests of the results of the BufferStock REMARK. """ diff --git a/HARK/tests/test_IndShockConsumerType.py b/HARK/tests/test_IndShockConsumerType.py deleted file mode 100644 index 41a3eda70..000000000 --- a/HARK/tests/test_IndShockConsumerType.py +++ /dev/null @@ -1,31 +0,0 @@ -from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType - -import numpy as np -import unittest - -class testIndShockConsumerType(unittest.TestCase): - - def test_getShocks(self): - agent = IndShockConsumerType( - AgentCount = 2, - T_sim = 10 - ) - - agent.solve() - - agent.initializeSim() - agent.simBirth(np.array([True,False])) - agent.simOnePeriod() - agent.simBirth(np.array([False,True])) - - agent.getShocks() - - self.assertEqual(agent.PermShkNow[0], - 1.0050166461586711) - self.assertEqual(agent.PermShkNow[1], - 1.0050166461586711) - self.assertEqual(agent.TranShkNow[0], - 1.1176912196531754) - - - From 5f19fb706869c29bead0e5f677830a686d76e16c Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Sat, 22 Feb 2020 01:20:36 +0530 Subject: [PATCH 35/43] fix up notebook utilities (#537) (cherry picked from commit 90d566d0d2c8dc7c8c452d0444ef8f2a1ce56110) --- HARK/utilities.py | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/HARK/utilities.py b/HARK/utilities.py index 7f4cd7230..97463a491 100644 --- a/HARK/utilities.py +++ b/HARK/utilities.py @@ -1337,6 +1337,7 @@ def test_latex_installation(pf): os.system('apt-get update') os.system('apt-get install texlive texlive-latex-extra texlive-xetex dvipng') latexExists=True + return True else: raise ImportError('Please install a full distribution of LaTeX on your computer then rerun. \n \ A full distribution means textlive, texlive-latex-extras, texlive-xetex, dvipng, and ghostscript') @@ -1358,7 +1359,7 @@ def in_ipynb(): return False -def setup_latex_env_notebook(pf): +def setup_latex_env_notebook(pf, latexExists): """ This is needed for use of the latex_envs notebook extension which allows the use of environments in Markdown. @@ -1367,13 +1368,15 @@ def setup_latex_env_notebook(pf): pf: str (platform) output of determine_platform() """ - if test_latex_installation(pf): + import os + from matplotlib import rc + import matplotlib.pyplot as plt + plt.rc('font', family='serif') + plt.rc('text', usetex=latexExists) + if latexExists: latex_preamble = r'\usepackage{amsmath}\usepackage{amsfonts}\usepackage[T1]{fontenc}' - import os - from os import path - import matplotlib.pyplot as plt latexdefs_path = os.getcwd()+'/latexdefs.tex' - if path.isfile(latexdefs_path): + if os.path.isfile(latexdefs_path): latex_preamble = latex_preamble+r'\input{'+latexdefs_path+r'}' else: # the required latex_envs package needs this file to exist even if it is empty from pathlib import Path From 8e948537d6ac54a3f29db8cb6948fe47c514a392 Mon Sep 17 00:00:00 2001 From: Sebastian Benthall Date: Mon, 24 Feb 2020 07:10:24 -0500 Subject: [PATCH 36/43] url -> self.url in checkConditions print logic. fixed #539 (#540) * url -> self.url in checkConditions print logic. fixed #539 * further fixes to bugs introduced in checkConditions refactor --- HARK/ConsumptionSaving/ConsIndShockModel.py | 22 ++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index 7813703f2..a4f78e83f 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -1900,7 +1900,7 @@ def checkRIC(self, thorn,verbose,public_call): Evaluate and report on the Return Impatience Condition ''' - RIF = Thorn/self.Rfree + RIF = thorn/self.Rfree self.RIF = RIF if RIF<1: self.RIC = True @@ -1942,9 +1942,9 @@ def checkFHWC(self,verbose,public_call): if verbose: print('Therefore, the limiting consumption function is c(m)=Infinity for all m') print() - if verbose and violated and verbose_reference: + if verbose and self.violated and verbose_reference: print('[!] For more information on the conditions, see Table 3 in "Theoretical Foundations of Buffer Stock Saving" at http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/') - return violated + return self.violated @@ -1975,7 +1975,7 @@ def checkConditions(self,verbose=False,verbose_reference=False,public_call=False return Thorn = (self.Rfree*self.DiscFac*self.LivPrb[0])**(1/self.CRRA) - self.Thorn = thorn + self.Thorn = Thorn self.checkAIC(Thorn,verbose,public_call) self.checkGICPF(Thorn,verbose,public_call) @@ -2275,7 +2275,7 @@ def checkGICInd(self,Thorn,verbose,public_call): if public_call or verbose: print('The value of the Individual Growth Impatience Factor for the supplied parameter values satisfies the Individual Growth Impatience Condition.', end = " ") if verbose: - print('Therefore, a target level of the individual market resources ratio m exists (see '+url+'/#onetarget for more).') + print('Therefore, a target level of the individual market resources ratio m exists (see '+self.url+'/#onetarget for more).') print() else: self.GICInd = False @@ -2283,7 +2283,7 @@ def checkGICInd(self,Thorn,verbose,public_call): print('The given parameter values violate the Individual Growth Impatience Condition; the GIFInd is: %2.4f' % (self.GIFInd), end = " ") if verbose: print('') - print('Therefore, a target ratio of individual market resources to individual permanent income does not exist. (see '+url+'/#onetarget for more).') + print('Therefore, a target ratio of individual market resources to individual permanent income does not exist. (see '+self.url+'/#onetarget for more).') print() def checkCIGAgg(self, Thorn,verbose,public_call): @@ -2314,7 +2314,7 @@ def checkWRIC(self, verbose,public_call): if WRIF<=1: self.WRIC = True if public_call or verbose: - print('The Weak Return Impatience Factor value for the supplied parameter values satisfies the Weak Return Impatience Condition (see '+url+'/#WRIC for more).') + print('The Weak Return Impatience Factor value for the supplied parameter values satisfies the Weak Return Impatience Condition (see '+self.url+'/#WRIC for more).') print() else: self.WRIC = False @@ -2322,7 +2322,7 @@ def checkWRIC(self, verbose,public_call): print('The given type violates the Weak Return Impatience Condition with the supplied parameter values. The WRIF is: %2.4f' % (WRIF), end = " ") if verbose: print('') - print('Therefore, a nondegenerate solution is not available (see '+url+'/#WRIC for more.') + print('Therefore, a nondegenerate solution is not available (see '+self.url+'/#WRIC for more.') print() def checkFVAC(self,verbose,public_call): @@ -2350,7 +2350,7 @@ def checkFVAC(self,verbose,public_call): print('The given type violates the Finite Value of Autarky Condition with the supplied parameter values. The FVAF is %2.4f' %(FVAF), end = " ") self.violated = True if public_call or verbose: - print('Therefore, a nondegenerate solution is not available (see '+url+'/#Conditions-Under-Which-the-Problem-Defines-a-Contraction-Mapping') + print('Therefore, a nondegenerate solution is not available (see '+self.url+'/#Conditions-Under-Which-the-Problem-Defines-a-Contraction-Mapping') print() @@ -2383,7 +2383,7 @@ def checkConditions(self,verbose=False,public_call=True): # For theory, see hyperlink targets to expressions in # url=http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory # For example, the hyperlink to the relevant section of the paper - url='http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory' + self.url='http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory' # would be referenced below as: # [url]/#Uncertainty-Modified-Conditions @@ -2418,7 +2418,7 @@ def checkConditions(self,verbose=False,public_call=True): self.checkWRIC(verbose,public_call) if verbose and self.violated: - print('\n[!] For more information on the conditions, see Tables 3 and 4 in "Theoretical Foundations of Buffer Stock Saving" at '+url+'/#Factors-Defined-And-Compared') + print('\n[!] For more information on the conditions, see Tables 3 and 4 in "Theoretical Foundations of Buffer Stock Saving" at '+self.url+'/#Factors-Defined-And-Compared') print('') if verbose: From e1b52e5d42927d1d18f2ceb3ceff2deae6b4d5bf Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Mon, 24 Feb 2020 18:15:53 +0530 Subject: [PATCH 37/43] fix checkConditions refactor in ConsIndShockModel (#541) --- HARK/ConsumptionSaving/ConsIndShockModel.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index a4f78e83f..ac2377240 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -2375,7 +2375,7 @@ def checkConditions(self,verbose=False,public_call=True): ------- None ''' - violated = False # PerfForesightConsumerType.checkConditions(self, verbose=False, verbose_reference=False) + self.violated = False # PerfForesightConsumerType.checkConditions(self, verbose=False, verbose_reference=False) if self.cycles!=0 or self.T_cycle > 1: return @@ -2416,6 +2416,7 @@ def checkConditions(self,verbose=False,public_call=True): self.checkGICInd(Thorn,verbose,public_call) self.checkCIGAgg(Thorn,verbose,public_call) self.checkWRIC(verbose,public_call) + self.checkFVAC(verbose, public_call) if verbose and self.violated: print('\n[!] For more information on the conditions, see Tables 3 and 4 in "Theoretical Foundations of Buffer Stock Saving" at '+self.url+'/#Factors-Defined-And-Compared') @@ -2427,9 +2428,9 @@ def checkConditions(self,verbose=False,public_call=True): print('GIFAgg = %2.6f ' % (GIFAgg)) print('Thorn = AIF = %2.6f ' % (Thorn)) print('PermGroFacAdj = %2.6f ' % (PermGroFacAdj)) - print('uInvEpShkuInv = %2.6f ' % (uInvEpShkuInv)) - print('FVAF = %2.6f ' % (FVAF)) - print('WRIF = %2.6f ' % (WRIF)) + print('uInvEpShkuInv = %2.6f ' % (self.uInvEpShkuInv)) + print('FVAF = %2.6f ' % (self.FVAF)) + print('WRIF = %2.6f ' % (self.WRIF)) print('DiscFacGIFIndMax = %2.6f ' % (self.DiscFacGIFIndMax)) print('DiscFacGIFAggMax = %2.6f ' % (self.DiscFacGIFAggMax)) From 78210a5d4c667eb7847b6114113e680bcafe5708 Mon Sep 17 00:00:00 2001 From: Mridul Seth Date: Wed, 26 Feb 2020 09:56:34 +0100 Subject: [PATCH 38/43] add jpg to make_figs (#544) --- HARK/utilities.py | 1 + 1 file changed, 1 insertion(+) diff --git a/HARK/utilities.py b/HARK/utilities.py index 97463a491..f7e64a06a 100644 --- a/HARK/utilities.py +++ b/HARK/utilities.py @@ -1409,6 +1409,7 @@ def make_figs(figure_name, saveFigs, drawFigs, target_dir="Figures"): os.makedirs(Figures_dir) # If dir does not exist, create it # Save the figures in several formats print("Saving figure {} in {}".format(figure_name, target_dir)) + plt.savefig(os.path.join(target_dir, '{}.jpg'.format(figure_name))) # For web/html plt.savefig(os.path.join(target_dir, '{}.png'.format(figure_name))) # For web/html plt.savefig(os.path.join(target_dir, '{}.pdf'.format(figure_name))) # For LaTeX plt.savefig(os.path.join(target_dir, '{}.svg'.format(figure_name))) # For html5 From cf4972fad57afb09ec46f2c8a4c801d17934c538 Mon Sep 17 00:00:00 2001 From: sb Date: Wed, 26 Feb 2020 13:22:45 -0500 Subject: [PATCH 39/43] moving test_PerfForesightConsumerType to ConsumptionSaving/tests/ --- .../tests/test_PerfForesightConsumerType.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename HARK/{ => ConsumptionSaving}/tests/test_PerfForesightConsumerType.py (100%) diff --git a/HARK/tests/test_PerfForesightConsumerType.py b/HARK/ConsumptionSaving/tests/test_PerfForesightConsumerType.py similarity index 100% rename from HARK/tests/test_PerfForesightConsumerType.py rename to HARK/ConsumptionSaving/tests/test_PerfForesightConsumerType.py From 16c84c1ad52b7c3e825549eb145a154d8209fee1 Mon Sep 17 00:00:00 2001 From: sb Date: Wed, 26 Feb 2020 14:36:07 -0500 Subject: [PATCH 40/43] adding test_ConsPortfolioModel, based on ConsPortfolioModel Documentation DemARK --- .../tests/test_ConsPortfolioModel.py | 47 +++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 HARK/ConsumptionSaving/tests/test_ConsPortfolioModel.py diff --git a/HARK/ConsumptionSaving/tests/test_ConsPortfolioModel.py b/HARK/ConsumptionSaving/tests/test_ConsPortfolioModel.py new file mode 100644 index 000000000..456f9ed2d --- /dev/null +++ b/HARK/ConsumptionSaving/tests/test_ConsPortfolioModel.py @@ -0,0 +1,47 @@ +import copy +import HARK.ConsumptionSaving.ConsPortfolioModel as cpm +import HARK.ConsumptionSaving.ConsumerParameters as param +import unittest + +class testPortfolioConsumerType(unittest.TestCase): + + def setUp(self): + + # Parameters from Mehra and Prescott (1985): + Avg = 1.08 # equity premium + Std = 0.20 # standard deviation of rate-of-return shocks + + RiskyDstnFunc = cpm.RiskyDstnFactory(RiskyAvg=Avg, RiskyStd=Std) # Generates nodes for integration + RiskyDrawFunc = cpm.LogNormalRiskyDstnDraw(RiskyAvg=Avg, RiskyStd=Std) # Function to generate draws from a lognormal distribution + + init_portfolio = copy.copy(param.init_idiosyncratic_shocks) # Default parameter values for inf horiz model - including labor income with transitory and permanent shocks + init_portfolio['approxRiskyDstn'] = RiskyDstnFunc + init_portfolio['drawRiskyFunc'] = RiskyDrawFunc + init_portfolio['RiskyCount'] = 2 # Number of points in the approximation; 2 points is minimum + init_portfolio['RiskyShareCount'] = 25 # How many discrete points to allow for portfolio share + init_portfolio['Rfree'] = 1.0 # Riskfree return factor (interest rate is zero) + init_portfolio['CRRA'] = 6.0 # Relative risk aversion + + # Uninteresting technical parameters: + init_portfolio['aXtraMax'] = 100 + init_portfolio['aXtraCount'] = 50 + init_portfolio['BoroCnstArt'] = 0.0 # important for theoretical reasons + init_portfolio['DiscFac'] = 0.92 # Make them impatient even wrt a riskfree return of 1.08 + + # Create portfolio choice consumer type + self.pcct = cpm.PortfolioConsumerType(**init_portfolio) + + # %% {"code_folding": []} + # Solve the model under the given parameters + + self.pcct.solve() + + def test_RiskyShareFunc(self): + + self.assertAlmostEqual( + self.pcct.solution[0].RiskyShareFunc[0][0](2).tolist(), + 0.8796982720076255) + + self.assertAlmostEqual( + self.pcct.solution[0].RiskyShareFunc[0][0](8).tolist(), + 0.69738175) From 615c418f5bb6b62b988c98e4febda6b229f4efa2 Mon Sep 17 00:00:00 2001 From: sb Date: Wed, 26 Feb 2020 15:00:45 -0500 Subject: [PATCH 41/43] adding checkConditions() test for PerfForesightConsumerType --- .../tests/test_PerfForesightConsumerType.py | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/HARK/ConsumptionSaving/tests/test_PerfForesightConsumerType.py b/HARK/ConsumptionSaving/tests/test_PerfForesightConsumerType.py index 049c0fee0..14830c468 100644 --- a/HARK/ConsumptionSaving/tests/test_PerfForesightConsumerType.py +++ b/HARK/ConsumptionSaving/tests/test_PerfForesightConsumerType.py @@ -4,10 +4,13 @@ class testPerfForesightConsumerType(unittest.TestCase): + def setUp(self): + self.agent = PerfForesightConsumerType() + self.agent_infinite = PerfForesightConsumerType(cycles=0) + def test_default_solution(self): - agent = PerfForesightConsumerType() - agent.solve() - c = agent.solution[0].cFunc + self.agent.solve() + c = self.agent.solution[0].cFunc self.assertEqual(c.x_list[0], -0.9805825242718447) self.assertEqual(c.x_list[1], 0.01941747572815533) @@ -15,4 +18,10 @@ def test_default_solution(self): self.assertEqual(c.y_list[1], 0.511321002804608) self.assertEqual(c.decay_extrap, False) - + def test_checkConditions(self): + self.agent_infinite.checkConditions() + + self.assertTrue(self.agent_infinite.AIC) + self.assertTrue(self.agent_infinite.GIC) + self.assertTrue(self.agent_infinite.RIC) + self.assertTrue(self.agent_infinite.FHWC) From a30ff3d3b60f523a82f777c3ebd5a1ab7dae6a91 Mon Sep 17 00:00:00 2001 From: sb Date: Wed, 26 Feb 2020 15:03:20 -0500 Subject: [PATCH 42/43] fixing self.violated in checkConditions(), and the PerfForsightConsumerType test --- HARK/ConsumptionSaving/ConsIndShockModel.py | 2 ++ HARK/ConsumptionSaving/tests/test_PerfForesightConsumerType.py | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index ac2377240..0257f2733 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -1974,6 +1974,8 @@ def checkConditions(self,verbose=False,verbose_reference=False,public_call=False if self.cycles!=0 or self.T_cycle > 1: return + self.violated = False + Thorn = (self.Rfree*self.DiscFac*self.LivPrb[0])**(1/self.CRRA) self.Thorn = Thorn diff --git a/HARK/ConsumptionSaving/tests/test_PerfForesightConsumerType.py b/HARK/ConsumptionSaving/tests/test_PerfForesightConsumerType.py index 14830c468..7e20befc1 100644 --- a/HARK/ConsumptionSaving/tests/test_PerfForesightConsumerType.py +++ b/HARK/ConsumptionSaving/tests/test_PerfForesightConsumerType.py @@ -22,6 +22,6 @@ def test_checkConditions(self): self.agent_infinite.checkConditions() self.assertTrue(self.agent_infinite.AIC) - self.assertTrue(self.agent_infinite.GIC) + self.assertTrue(self.agent_infinite.GICPF) self.assertTrue(self.agent_infinite.RIC) self.assertTrue(self.agent_infinite.FHWC) From f778419488170c4ee96c4b6edbc8a33ad1eaff53 Mon Sep 17 00:00:00 2001 From: sb Date: Wed, 26 Feb 2020 16:05:05 -0500 Subject: [PATCH 43/43] adding simulation test for PerfForesightConsumerType --- .../tests/test_PerfForesightConsumerType.py | 52 ++++++++++++++++++- 1 file changed, 51 insertions(+), 1 deletion(-) diff --git a/HARK/ConsumptionSaving/tests/test_PerfForesightConsumerType.py b/HARK/ConsumptionSaving/tests/test_PerfForesightConsumerType.py index 7e20befc1..0d4ae1d33 100644 --- a/HARK/ConsumptionSaving/tests/test_PerfForesightConsumerType.py +++ b/HARK/ConsumptionSaving/tests/test_PerfForesightConsumerType.py @@ -1,5 +1,5 @@ from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType - +import numpy as np import unittest class testPerfForesightConsumerType(unittest.TestCase): @@ -25,3 +25,53 @@ def test_checkConditions(self): self.assertTrue(self.agent_infinite.GICPF) self.assertTrue(self.agent_infinite.RIC) self.assertTrue(self.agent_infinite.FHWC) + + def test_simulation(self): + + self.agent_infinite.solve() + + # Create parameter values necessary for simulation + SimulationParams = { + "AgentCount" : 10000, # Number of agents of this type + "T_sim" : 120, # Number of periods to simulate + "aNrmInitMean" : -6.0, # Mean of log initial assets + "aNrmInitStd" : 1.0, # Standard deviation of log initial assets + "pLvlInitMean" : 0.0, # Mean of log initial permanent income + "pLvlInitStd" : 0.0, # Standard deviation of log initial permanent income + "PermGroFacAgg" : 1.0, # Aggregate permanent income growth factor + "T_age" : None, # Age after which simulated agents are automatically killed + } + + self.agent_infinite(**SimulationParams) # This implicitly uses the assignParameters method of AgentType + + # Create PFexample object + self.agent_infinite.track_vars = ['mNrmNow'] + self.agent_infinite.initializeSim() + self.agent_infinite.simulate() + + self.assertAlmostEqual( + np.mean(self.agent_infinite.mNrmNow_hist,axis=1)[40], + -23.008063500363942 + ) + + self.assertAlmostEqual( + np.mean(self.agent_infinite.mNrmNow_hist,axis=1)[100], + -27.164608851546927 + ) + + ## Try now with the manipulation at time step 80 + + self.agent_infinite.initializeSim() + self.agent_infinite.simulate(80) + self.agent_infinite.aNrmNow += -5. # Adjust all simulated consumers' assets downward by 5 + self.agent_infinite.simulate(40) + + self.assertAlmostEqual( + np.mean(self.agent_infinite.mNrmNow_hist,axis=1)[40], + -23.008063500363942 + ) + + self.assertAlmostEqual( + np.mean(self.agent_infinite.mNrmNow_hist,axis=1)[100], + -29.140261331951606 + )