def main_test(self):
Markov_vFuncBool_example = MarkovConsumerType(**Markov_Dict)
TranShkDstn_e = MeanOneLogNormal(
Markov_vFuncBool_example.TranShkStd[0],
123).approx(Markov_vFuncBool_example.TranShkCount)
TranShkDstn_u = DiscreteDistribution(np.ones(1), np.ones(1) * .2)
PermShkDstn = MeanOneLogNormal(
Markov_vFuncBool_example.PermShkStd[0],
123).approx(Markov_vFuncBool_example.PermShkCount)
#employed Income shock distribution
employed_IncShkDstn = combine_indep_dstns(PermShkDstn, TranShkDstn_e)
#unemployed Income shock distribution
unemployed_IncShkDstn = combine_indep_dstns(PermShkDstn, TranShkDstn_u)
# Specify list of IncShkDstns for each state
Markov_vFuncBool_example.IncShkDstn = [[
employed_IncShkDstn, unemployed_IncShkDstn
]]
#solve the consumer's problem
Markov_vFuncBool_example.solve()
self.assertAlmostEqual(
Markov_vFuncBool_example.solution[0].vFunc[1](0.4),
-4.127935542867632)
def update_pref_shock_process(self):
"""
Make a discrete preference shock structure for each period in the cycle
for this agent type, storing them as attributes of self for use in the
solution (and other methods).
Parameters
----------
none
Returns
-------
none
"""
PrefShkDstn = [] # discrete distributions of preference shocks
for t in range(len(self.PrefShkStd)):
PrefShkStd = self.PrefShkStd[t]
new_dstn = MeanOneLogNormal(sigma=PrefShkStd,
seed=self.RNG.randint(
0, 2**31 - 1)).approx(
N=self.PrefShkCount,
tail_N=self.PrefShk_tail_N,
)
PrefShkDstn.append(new_dstn)
# Store the preference shocks in self (time-varying) and restore time flow
self.PrefShkDstn = PrefShkDstn
self.add_to_time_vary("PrefShkDstn")
def updatePrefShockProcess(self):
'''
Make a discrete preference shock structure for each period in the cycle
for this agent type, storing them as attributes of self for use in the
solution (and other methods).
Parameters
----------
none
Returns
-------
none
'''
PrefShkDstn = [] # discrete distributions of preference shocks
for t in range(len(self.PrefShkStd)):
PrefShkStd = self.PrefShkStd[t]
PrefShkDstn.append(
MeanOneLogNormal(
sigma=PrefShkStd
).approx(N=self.PrefShkCount,
tail_N=self.PrefShk_tail_N))
# Store the preference shocks in self (time-varying) and restore time flow
self.PrefShkDstn = PrefShkDstn
self.addToTimeVary('PrefShkDstn')
def test_calc_expectation(self):
dd_0_1_20 = Normal().approx(20)
dd_1_1_40 = Normal(mu=1).approx(40)
dd_10_10_100 = Normal(mu=10, sigma=10).approx(100)
ce1 = calc_expectation(dd_0_1_20)
ce2 = calc_expectation(dd_1_1_40)
ce3 = calc_expectation(dd_10_10_100)
self.assertAlmostEqual(ce1, 0.0)
self.assertAlmostEqual(ce2, 1.0)
self.assertAlmostEqual(ce3, 10.0)
ce4 = calc_expectation(dd_0_1_20, lambda x: 2**x)
self.assertAlmostEqual(ce4, 1.27153712)
ce5 = calc_expectation(dd_1_1_40, lambda x: 2 * x)
self.assertAlmostEqual(ce5, 2.0)
ce6 = calc_expectation(dd_10_10_100, lambda x, y: 2 * x + y, 20)
self.assertAlmostEqual(ce6, 40.0)
ce7 = calc_expectation(dd_0_1_20, lambda x, y: x + y,
np.hstack(np.array([0, 1, 2, 3, 4, 5])))
self.assertAlmostEqual(ce7.flat[3], 3.0)
PermShkDstn = MeanOneLogNormal().approx(200)
TranShkDstn = MeanOneLogNormal().approx(200)
IncShkDstn = combine_indep_dstns(PermShkDstn, TranShkDstn)
ce8 = calc_expectation(IncShkDstn, lambda X: X[0] + X[1])
self.assertAlmostEqual(ce8, 2.0)
ce9 = calc_expectation(
IncShkDstn,
lambda X, a, r: r / X[0] * a + X[1],
np.array([0, 1, 2, 3, 4, 5]), # an aNrmNow grid?
1.05, # an interest rate?
)
self.assertAlmostEqual(ce9[3], 9.518015322143837)
def getShocks(self):
'''
Gets permanent and transitory income shocks for this period as well as preference shocks.
Parameters
----------
None
Returns
-------
None
'''
IndShockConsumerType.getShocks(self) # Get permanent and transitory income shocks
PrefShkNow = np.zeros(self.AgentCount) # Initialize shock array
for t in range(self.T_cycle):
these = t == self.t_cycle
N = np.sum(these)
if N > 0:
PrefShkNow[these] = self.RNG.permutation(
MeanOneLogNormal(
sigma=self.PrefShkStd[t]
).approx(N).X)
self.PrefShkNow = PrefShkNow
def test_drawMeanOneLognormal(self):
self.assertEqual(MeanOneLogNormal().draw(1)[0], 3.5397367004222002)
def update_income_process(self):
self.wage = 1 / (self.SSPmu) #calculate SS wage
self.N = (self.mu_u * (self.IncUnemp * self.UnempPrb) + self.G) / (
self.wage * self.tax_rate
) #calculate SS labor supply from Budget Constraint
PermShkDstn_U = Lognormal(
np.log(self.mu_u) - (self.L * (self.PermShkStd[0])**2) / 2,
self.L * self.PermShkStd[0],
123).approx(self.PermShkCount
) #Permanent Shock Distribution faced when unemployed
PermShkDstn_E = MeanOneLogNormal(self.PermShkStd[0], 123).approx(
self.PermShkCount
) #Permanent Shock Distribution faced when employed
pmf_P = np.concatenate(((1 - self.UnempPrb) * PermShkDstn_E.pmf,
self.UnempPrb * PermShkDstn_U.pmf))
X_P = np.concatenate((PermShkDstn_E.X, PermShkDstn_U.X))
PermShkDstn = [DiscreteDistribution(pmf_P, X_P)]
self.PermShkDstn = PermShkDstn
TranShkDstn_E = MeanOneLogNormal(self.TranShkStd[0], 123).approx(
self.TranShkCount
) #Transitory Shock Distribution faced when employed
TranShkDstn_E.X = (
TranShkDstn_E.X * (1 - self.tax_rate) * self.wage * self.N
) / (
1 - self.UnempPrb
)**2 #NEED TO FIX THIS SQUARE TERM #add wage, tax rate and labor supply
lng = len(TranShkDstn_E.X)
TranShkDstn_U = DiscreteDistribution(
np.ones(lng) / lng, self.IncUnemp *
np.ones(lng)) #Transitory Shock Distribution faced when unemployed
IncShkDstn_E = combine_indep_dstns(
PermShkDstn_E,
TranShkDstn_E) # Income Distribution faced when Employed
IncShkDstn_U = combine_indep_dstns(
PermShkDstn_U,
TranShkDstn_U) # Income Distribution faced when Unemployed
#Combine Outcomes of both distributions
X_0 = np.concatenate((IncShkDstn_E.X[0], IncShkDstn_U.X[0]))
X_1 = np.concatenate((IncShkDstn_E.X[1], IncShkDstn_U.X[1]))
X_I = [X_0, X_1] #discrete distribution takes in a list of arrays
#Combine pmf Arrays
pmf_I = np.concatenate(((1 - self.UnempPrb) * IncShkDstn_E.pmf,
self.UnempPrb * IncShkDstn_U.pmf))
IncShkDstn = [DiscreteDistribution(pmf_I, X_I)]
self.IncShkDstnN = IncShkDstn
self.IncShkDstn = IncShkDstn
self.add_to_time_vary('IncShkDstn')
PermShkDstn_Uw = Lognormal(
np.log(self.mu_u) - (self.L * (self.PermShkStd[0])**2) / 2,
self.L * self.PermShkStd[0],
123).approx(self.PermShkCount
) #Permanent Shock Distribution faced when unemployed
PermShkDstn_Ew = MeanOneLogNormal(self.PermShkStd[0], 123).approx(
self.PermShkCount
) #Permanent Shock Distribution faced when employed
TranShkDstn_Ew = MeanOneLogNormal(self.TranShkStd[0], 123).approx(
self.TranShkCount
) #Transitory Shock Distribution faced when employed
TranShkDstn_Ew.X = (
TranShkDstn_Ew.X * (1 - self.tax_rate) *
(self.wage + self.dx) * self.N) / (
1 - self.UnempPrb)**2 #add wage, tax rate and labor supply
lng = len(TranShkDstn_Ew.X)
TranShkDstn_Uw = DiscreteDistribution(
np.ones(lng) / lng, self.IncUnemp *
np.ones(lng)) #Transitory Shock Distribution faced when unemployed
IncShkDstn_Ew = combine_indep_dstns(
PermShkDstn_Ew,
TranShkDstn_Ew) # Income Distribution faced when Employed
IncShkDstn_Uw = combine_indep_dstns(
PermShkDstn_Uw,
TranShkDstn_Uw) # Income Distribution faced when Unemployed
#Combine Outcomes of both distributions
X_0 = np.concatenate((IncShkDstn_Ew.X[0], IncShkDstn_Uw.X[0]))
X_1 = np.concatenate((IncShkDstn_Ew.X[1], IncShkDstn_Uw.X[1]))
X_I = [X_0, X_1] #discrete distribution takes in a list of arrays
#Combine pmf Arrays
pmf_I = np.concatenate(((1 - self.UnempPrb) * IncShkDstn_Ew.pmf,
self.UnempPrb * IncShkDstn_Uw.pmf))
IncShkDstnW = [DiscreteDistribution(pmf_I, X_I)]
self.IncShkDstnW = IncShkDstnW
self.add_to_time_vary('IncShkDstnW')
