def test_small_open(self):
agent = AggShockConsumerType()
agent.AgentCount = 100 # Very low number of agents for the sake of speed
agent.cycles = 0
# Make agents heterogeneous in their discount factor
agents = distribute_params(
agent, "DiscFac", 3, Uniform(bot=0.90, top=0.94) # Impatient agents
)
# Make an economy with those agents living in it
small_economy = SmallOpenEconomy(
agents=agents,
Rfree=1.03,
wRte=1.0,
KtoLnow=1.0,
**copy.copy(init_cobb_douglas)
)
small_economy.act_T = 400 # Short simulation history
small_economy.max_loops = 3 # Give up quickly for the sake of time
small_economy.make_AggShkHist() # Simulate a history of aggregate shocks
small_economy.verbose = False # Turn off printed messages
# Give data about the economy to all the agents in it
for this_type in small_economy.agents:
this_type.get_economy_data(small_economy)
small_economy.solve()
def setUp(self):
agent = AggShockConsumerType()
agent.AgentCount = 900 # Very low number of agents for the sake of speed
agent.cycles = 0
# Make agents heterogeneous in their discount factor
self.agents = distribute_params(
agent, "DiscFac", 3, Uniform(bot=0.90, top=0.94) # Impatient agents
)
# Make an economy with those agents living in it
self.economy = CobbDouglasEconomy(agents=self.agents)
def getPostStates(self):
'''
Slightly extends the base version of this method by recalculating aLvlNow to account for the
consumer's (potential) misperception about their productivity level.
Parameters
----------
None
Returns
-------
None
'''
AggShockConsumerType.getPostStates(self)
self.cLvlNow = self.cNrmNow * self.pLvlNow # True consumption level
self.aLvlNow = self.mLvlTrueNow - self.cLvlNow # True asset level
self.aNrmNow = self.aLvlNow / self.pLvlNow # Perceived normalized assets
class testAggShockConsumerType(unittest.TestCase):
def setUp(self):
self.agent = AggShockConsumerType()
self.agent.cycles = 0
self.economy = EconomyExample = CobbDouglasEconomy(
agents=[self.agent])
def test_economy(self):
# Make a Cobb-Douglas economy for the agents
self.economy.makeAggShkHist() # Simulate a history of aggregate shocks
# Have the consumers inherit relevant objects from the economy
self.agent.getEconomyData(self.economy)
self.agent.solve()
def simBirth(self, which_agents):
'''
Makes new consumers for the given indices. Slightly extends base method by also setting
pLvlErrNow = 1.0 for new agents, indicating that they correctly perceive their productivity.
Parameters
----------
which_agents : np.array(Bool)
Boolean array of size self.AgentCount indicating which agents should be "born".
Returns
-------
None
'''
AggShockConsumerType.simBirth(self, which_agents)
if hasattr(self, 'pLvlErrNow'):
self.pLvlErrNow[which_agents] = 1.0
else:
self.pLvlErrNow = np.ones(self.AgentCount)
def simBirth(self, which_agents):
'''
Makes new consumers for the given indices. Slightly extends base method by also setting
pLvlErrNow = 1.0 for new agents, indicating that they correctly perceive their productivity.
Parameters
----------
which_agents : np.array(Bool)
Boolean array of size self.AgentCount indicating which agents should be "born".
Returns
-------
None
'''
AggShockConsumerType.simBirth(self, which_agents)
if hasattr(self, 'pLvlErrNow'):
self.pLvlErrNow[which_agents] = 1.0
else: # This only triggers at the beginning of the very first simulated period
self.pLvlErrNow = np.ones(self.AgentCount)
self.t_since_update = np.zeros(self.AgentCount, dtype=int)
# 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 = False
# 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 = False
# ### Example implementation of AggShockConsumerType
if solve_agg_shocks_micro or solve_agg_shocks_market:
# Make an aggregate shocks consumer type
AggShockExample = AggShockConsumerType()
AggShockExample.cycles = 0
# Make a Cobb-Douglas economy for the agents
EconomyExample = CobbDouglasEconomy(agents=[AggShockExample])
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 " +
if Params.do_sensitivity[7]: # interest rate sensitivity analysis
Rfree_list = (np.linspace(1.0, 1.04, 17) /
InfiniteType.survival_prob[0]).tolist()
sensitivityAnalysis('Rfree', Rfree_list, False)
# =======================================================================
# ========= FBS aggregate shocks model ==================================
#========================================================================
if Params.do_agg_shocks:
# These are the perpetual youth estimates in case we want to skip estimation (and we do)
beta_point_estimate = 0.989142
beta_dist_estimate = 0.985773
nabla_estimate = 0.0077
# Make a set of consumer types for the FBS aggregate shocks model
BaseAggShksType = AggShockConsumerType(**Params.init_agg_shocks)
agg_shocks_type_list = []
for j in range(Params.pref_type_count):
new_type = deepcopy(BaseAggShksType)
new_type.seed = j
new_type.resetRNG()
new_type.makeIncShkHist()
agg_shocks_type_list.append(new_type)
if Params.do_beta_dist:
beta_agg = beta_dist_estimate
nabla_agg = nabla_estimate
else:
beta_agg = beta_point_estimate
nabla_agg = 0.0
DiscFac_list_agg = approxUniform(N=Params.pref_type_count,
bot=beta_agg - nabla_agg,
def setUp(self):
self.agent = AggShockConsumerType()
self.agent.cycles = 0
self.economy = EconomyExample = CobbDouglasEconomy(
agents=[self.agent])