def test_get_initial_SS_values(baseline, param_updates, filename, dask_client):
p = Specifications(baseline=baseline, num_workers=NUM_WORKERS)
p.update_specifications(param_updates)
p.baseline_dir = os.path.join(CUR_PATH, 'test_io_data', 'OUTPUT')
p.output_base = os.path.join(CUR_PATH, 'test_io_data', 'OUTPUT')
test_tuple = TPI.get_initial_SS_values(p)
(test_initial_values, test_ss_vars, test_theta,
test_baseline_values) = test_tuple
expected_tuple = utils.safe_read_pickle(
os.path.join(CUR_PATH, 'test_io_data', filename))
(exp_initial_values, exp_ss_vars, exp_theta,
exp_baseline_values) = expected_tuple
(B0, b_sinit, b_splus1init, factor, initial_b,
initial_n) = exp_initial_values
B0 = aggr.get_B(exp_ss_vars['bssmat_splus1'], p, 'SS', True)
initial_b = (exp_ss_vars['bssmat_splus1'] * (exp_ss_vars['Bss'] / B0))
B0 = aggr.get_B(initial_b, p, 'SS', True)
b_sinit = np.array(
list(np.zeros(p.J).reshape(1, p.J)) + list(initial_b[:-1]))
b_splus1init = initial_b
exp_initial_values = (B0, b_sinit, b_splus1init, factor, initial_b,
initial_n)
for i, v in enumerate(exp_initial_values):
assert (np.allclose(test_initial_values[i], v, equal_nan=True))
if p.baseline_spending:
for i, v in enumerate(exp_baseline_values):
assert (np.allclose(test_baseline_values[i], v, equal_nan=True))
assert (np.allclose(test_theta, exp_theta))
for k, v in exp_ss_vars.items():
assert (np.allclose(test_ss_vars[k], v, equal_nan=True))
def inner_loop(outer_loop_vars, p, client):
'''
This function solves for the inner loop of the SS. That is, given
the guesses of the outer loop variables (r, w, TR, factor) this
function solves the households' problems in the SS.
Args:
outer_loop_vars (tuple): tuple of outer loop variables,
(bssmat, nssmat, r, BQ, TR, factor) or
(bssmat, nssmat, r, BQ, Y, TR, factor)
bssmat (Numpy array): initial guess at savings, size = SxJ
nssmat (Numpy array): initial guess at labor supply, size = SxJ
BQ (array_like): aggregate bequest amount(s)
Y (scalar): real GDP
TR (scalar): lump sum transfer amount
factor (scalar): scaling factor converting model units to dollars
w (scalar): real wage rate
p (OG-Core Specifications object): model parameters
client (Dask client object): client
Returns:
(tuple): results from household solution:
* euler_errors (Numpy array): errors terms from FOCs,
size = 2SxJ
* bssmat (Numpy array): savings, size = SxJ
* nssmat (Numpy array): labor supply, size = SxJ
* new_r (scalar): real interest rate on firm capital
* new_r_gov (scalar): real interest rate on government debt
* new_r_p (scalar): real interest rate on household
portfolio
* new_w (scalar): real wage rate
* new_TR (scalar): lump sum transfer amount
* new_Y (scalar): real GDP
* new_factor (scalar): scaling factor converting model
units to dollars
* new_BQ (array_like): aggregate bequest amount(s)
* average_income_model (scalar): average income in model
units
'''
# unpack variables to pass to function
if p.budget_balance:
bssmat, nssmat, r, BQ, TR, factor = outer_loop_vars
r_p = r
Y = 1.0 # placeholder
K = 1.0 # placeholder
else:
bssmat, nssmat, r, BQ, Y, TR, factor = outer_loop_vars
K = firm.get_K_from_Y(Y, r, p, 'SS')
# initialize array for euler errors
euler_errors = np.zeros((2 * p.S, p.J))
w = firm.get_w_from_r(r, p, 'SS')
r_gov = fiscal.get_r_gov(r, p)
D, D_d, D_f, new_borrowing, debt_service, new_borrowing_f =\
fiscal.get_D_ss(r_gov, Y, p)
r_p = aggr.get_r_p(r, r_gov, K, D)
bq = household.get_bq(BQ, None, p, 'SS')
tr = household.get_tr(TR, None, p, 'SS')
ubi = p.ubi_nom_array[-1, :, :] / factor
lazy_values = []
for j in range(p.J):
guesses = np.append(bssmat[:, j], nssmat[:, j])
euler_params = (r_p, w, bq[:, j], tr[:, j], ubi[:, j], factor, j, p)
lazy_values.append(
delayed(opt.fsolve)(euler_equation_solver,
guesses * .9,
args=euler_params,
xtol=MINIMIZER_TOL,
full_output=True))
if client:
futures = client.compute(lazy_values, num_workers=p.num_workers)
results = client.gather(futures)
else:
results = results = compute(*lazy_values,
scheduler=dask.multiprocessing.get,
num_workers=p.num_workers)
# for j, result in results.items():
for j, result in enumerate(results):
[solutions, infodict, ier, message] = result
euler_errors[:, j] = infodict['fvec']
bssmat[:, j] = solutions[:p.S]
nssmat[:, j] = solutions[p.S:]
L = aggr.get_L(nssmat, p, 'SS')
B = aggr.get_B(bssmat, p, 'SS', False)
K_demand_open = firm.get_K(L, p.world_int_rate[-1], p, 'SS')
K, K_d, K_f = aggr.get_K_splits(B, K_demand_open, D_d, p.zeta_K[-1])
Y = firm.get_Y(K, L, p, 'SS')
if p.zeta_K[-1] == 1.0:
new_r = p.world_int_rate[-1]
else:
new_r = firm.get_r(Y, K, p, 'SS')
new_w = firm.get_w_from_r(new_r, p, 'SS')
b_s = np.array(list(np.zeros(p.J).reshape(1, p.J)) + list(bssmat[:-1, :]))
new_r_gov = fiscal.get_r_gov(new_r, p)
new_r_p = aggr.get_r_p(new_r, new_r_gov, K, D)
average_income_model = ((new_r_p * b_s + new_w * p.e * nssmat) *
p.omega_SS.reshape(p.S, 1) *
p.lambdas.reshape(1, p.J)).sum()
if p.baseline:
new_factor = p.mean_income_data / average_income_model
else:
new_factor = factor
new_BQ = aggr.get_BQ(new_r_p, bssmat, None, p, 'SS', False)
new_bq = household.get_bq(new_BQ, None, p, 'SS')
tr = household.get_tr(TR, None, p, 'SS')
theta = tax.replacement_rate_vals(nssmat, new_w, new_factor, None, p)
etr_params_3D = np.tile(
np.reshape(p.etr_params[-1, :, :], (p.S, 1, p.etr_params.shape[2])),
(1, p.J, 1))
taxss = tax.net_taxes(new_r_p, new_w, b_s, nssmat, new_bq, factor, tr, ubi,
theta, None, None, False, 'SS', p.e, etr_params_3D,
p)
cssmat = household.get_cons(new_r_p, new_w, b_s, bssmat, nssmat, new_bq,
taxss, p.e, p.tau_c[-1, :, :], p)
total_tax_revenue, _, agg_pension_outlays, UBI_outlays, _, _, _, _, _, _ =\
aggr.revenue(new_r_p, new_w, b_s, nssmat, new_bq, cssmat, Y, L,
K, factor, ubi, theta, etr_params_3D, p, 'SS')
G = fiscal.get_G_ss(Y, total_tax_revenue, agg_pension_outlays, TR,
UBI_outlays, new_borrowing, debt_service, p)
new_TR = fiscal.get_TR(Y, TR, G, total_tax_revenue, agg_pension_outlays,
UBI_outlays, p, 'SS')
return euler_errors, bssmat, nssmat, new_r, new_r_gov, new_r_p, \
new_w, new_TR, Y, new_factor, new_BQ, average_income_model
def SS_solver(bmat, nmat, r, BQ, TR, factor, Y, p, client, fsolve_flag=False):
'''
Solves for the steady state distribution of capital, labor, as well
as w, r, TR and the scaling factor, using functional iteration.
Args:
bmat (Numpy array): initial guess at savings, size = SxJ
nmat (Numpy array): initial guess at labor supply, size = SxJ
r (scalar): real interest rate
BQ (array_like): aggregate bequest amount(s)
TR (scalar): lump sum transfer amount
factor (scalar): scaling factor converting model units to dollars
Y (scalar): real GDP
p (OG-Core Specifications object): model parameters
client (Dask client object): client
Returns:
output (dictionary): dictionary with steady state solution
results
'''
dist = 10
iteration = 0
dist_vec = np.zeros(p.maxiter)
maxiter_ss = p.maxiter
nu_ss = p.nu
if fsolve_flag: # case where already solved via SS_fsolve
maxiter_ss = 1
while (dist > p.mindist_SS) and (iteration < maxiter_ss):
# Solve for the steady state levels of b and n, given w, r,
# Y and factor
if p.budget_balance:
outer_loop_vars = (bmat, nmat, r, BQ, TR, factor)
else:
outer_loop_vars = (bmat, nmat, r, BQ, Y, TR, factor)
(euler_errors, new_bmat, new_nmat, new_r, new_r_gov, new_r_p,
new_w, new_TR, new_Y, new_factor, new_BQ,
average_income_model) =\
inner_loop(outer_loop_vars, p, client)
r = utils.convex_combo(new_r, r, nu_ss)
factor = utils.convex_combo(new_factor, factor, nu_ss)
BQ = utils.convex_combo(new_BQ, BQ, nu_ss)
if p.baseline_spending:
Y = utils.convex_combo(new_Y, Y, nu_ss)
if Y != 0:
dist = np.array(
[utils.pct_diff_func(new_r, r)] +
list(utils.pct_diff_func(new_BQ, BQ)) +
[utils.pct_diff_func(new_Y, Y)] +
[utils.pct_diff_func(new_factor, factor)]).max()
else:
# If Y is zero (if there is no output), a percent difference
# will throw NaN's, so we use an absolute difference
dist = np.array(
[utils.pct_diff_func(new_r, r)] +
list(utils.pct_diff_func(new_BQ, BQ)) + [abs(new_Y - Y)] +
[utils.pct_diff_func(new_factor, factor)]).max()
else:
TR = utils.convex_combo(new_TR, TR, nu_ss)
dist = np.array([utils.pct_diff_func(new_r, r)] +
list(utils.pct_diff_func(new_BQ, BQ)) +
[utils.pct_diff_func(new_TR, TR)] +
[utils.pct_diff_func(new_factor, factor)]).max()
dist_vec[iteration] = dist
# Similar to TPI: if the distance between iterations increases, then
# decrease the value of nu to prevent cycling
if iteration > 10:
if dist_vec[iteration] - dist_vec[iteration - 1] > 0:
nu_ss /= 2.0
print('New value of nu:', nu_ss)
iteration += 1
if VERBOSE:
print('Iteration: %02d' % iteration, ' Distance: ', dist)
# Generate the SS values of variables, including euler errors
bssmat_s = np.append(np.zeros((1, p.J)), bmat[:-1, :], axis=0)
bssmat_splus1 = bmat
nssmat = nmat
rss = r
r_gov_ss = fiscal.get_r_gov(rss, p)
TR_ss = TR
Lss = aggr.get_L(nssmat, p, 'SS')
Bss = aggr.get_B(bssmat_splus1, p, 'SS', False)
(Dss, D_d_ss, D_f_ss, new_borrowing, debt_service,
new_borrowing_f) = fiscal.get_D_ss(r_gov_ss, Y, p)
K_demand_open_ss = firm.get_K(Lss, p.world_int_rate[-1], p, 'SS')
Kss, K_d_ss, K_f_ss = aggr.get_K_splits(Bss, K_demand_open_ss, D_d_ss,
p.zeta_K[-1])
Yss = firm.get_Y(Kss, Lss, p, 'SS')
r_p_ss = aggr.get_r_p(rss, r_gov_ss, Kss, Dss)
# Note that implicity in this computation is that immigrants'
# wealth is all in the form of private capital
I_d_ss = aggr.get_I(bssmat_splus1, K_d_ss, K_d_ss, p, 'SS')
Iss = aggr.get_I(bssmat_splus1, Kss, Kss, p, 'SS')
wss = new_w
BQss = new_BQ
factor_ss = factor
bqssmat = household.get_bq(BQss, None, p, 'SS')
trssmat = household.get_tr(TR_ss, None, p, 'SS')
ubissmat = p.ubi_nom_array[-1, :, :] / factor_ss
theta = tax.replacement_rate_vals(nssmat, wss, factor_ss, None, p)
# Compute effective and marginal tax rates for all agents
etr_params_3D = np.tile(
np.reshape(p.etr_params[-1, :, :], (p.S, 1, p.etr_params.shape[2])),
(1, p.J, 1))
mtrx_params_3D = np.tile(
np.reshape(p.mtrx_params[-1, :, :], (p.S, 1, p.mtrx_params.shape[2])),
(1, p.J, 1))
mtry_params_3D = np.tile(
np.reshape(p.mtry_params[-1, :, :], (p.S, 1, p.mtry_params.shape[2])),
(1, p.J, 1))
mtry_ss = tax.MTR_income(r_p_ss, wss, bssmat_s, nssmat, factor, True, p.e,
etr_params_3D, mtry_params_3D, p)
mtrx_ss = tax.MTR_income(r_p_ss, wss, bssmat_s, nssmat, factor, False, p.e,
etr_params_3D, mtrx_params_3D, p)
etr_ss = tax.ETR_income(r_p_ss, wss, bssmat_s, nssmat, factor, p.e,
etr_params_3D, p)
taxss = tax.net_taxes(r_p_ss, wss, bssmat_s, nssmat, bqssmat, factor_ss,
trssmat, ubissmat, theta, None, None, False, 'SS',
p.e, etr_params_3D, p)
cssmat = household.get_cons(r_p_ss, wss, bssmat_s, bssmat_splus1, nssmat,
bqssmat, taxss, p.e, p.tau_c[-1, :, :], p)
yss_before_tax_mat = household.get_y(r_p_ss, wss, bssmat_s, nssmat, p)
Css = aggr.get_C(cssmat, p, 'SS')
(total_tax_revenue, iit_payroll_tax_revenue, agg_pension_outlays,
UBI_outlays, bequest_tax_revenue, wealth_tax_revenue, cons_tax_revenue,
business_tax_revenue, payroll_tax_revenue,
iit_revenue) = aggr.revenue(r_p_ss, wss, bssmat_s, nssmat, bqssmat,
cssmat, Yss, Lss, Kss, factor, ubissmat,
theta, etr_params_3D, p, 'SS')
Gss = fiscal.get_G_ss(Yss, total_tax_revenue, agg_pension_outlays, TR_ss,
UBI_outlays, new_borrowing, debt_service, p)
# Compute total investment (not just domestic)
Iss_total = aggr.get_I(None, Kss, Kss, p, 'total_ss')
# solve resource constraint
# net foreign borrowing
debt_service_f = fiscal.get_debt_service_f(r_p_ss, D_f_ss)
RC = aggr.resource_constraint(Yss, Css, Gss, I_d_ss, K_f_ss,
new_borrowing_f, debt_service_f, r_p_ss, p)
if VERBOSE:
print('Foreign debt holdings = ', D_f_ss)
print('Foreign capital holdings = ', K_f_ss)
print('resource constraint: ', RC)
if Gss < 0:
print('Steady state government spending is negative to satisfy' +
' budget')
if ENFORCE_SOLUTION_CHECKS and (np.absolute(RC) > p.mindist_SS):
print('Resource Constraint Difference:', RC)
err = 'Steady state aggregate resource constraint not satisfied'
raise RuntimeError(err)
# check constraints
household.constraint_checker_SS(bssmat_splus1, nssmat, cssmat, p.ltilde)
euler_savings = euler_errors[:p.S, :]
euler_labor_leisure = euler_errors[p.S:, :]
if VERBOSE:
print('Maximum error in labor FOC = ',
np.absolute(euler_labor_leisure).max())
print('Maximum error in savings FOC = ',
np.absolute(euler_savings).max())
# Return dictionary of SS results
output = {
'Kss': Kss,
'K_f_ss': K_f_ss,
'K_d_ss': K_d_ss,
'Bss': Bss,
'Lss': Lss,
'Css': Css,
'Iss': Iss,
'Iss_total': Iss_total,
'I_d_ss': I_d_ss,
'nssmat': nssmat,
'Yss': Yss,
'Dss': Dss,
'D_f_ss': D_f_ss,
'D_d_ss': D_d_ss,
'wss': wss,
'rss': rss,
'total_taxes_ss': taxss,
'ubissmat': ubissmat,
'r_gov_ss': r_gov_ss,
'r_p_ss': r_p_ss,
'theta': theta,
'BQss': BQss,
'factor_ss': factor_ss,
'bssmat_s': bssmat_s,
'cssmat': cssmat,
'bssmat_splus1': bssmat_splus1,
'yss_before_tax_mat': yss_before_tax_mat,
'bqssmat': bqssmat,
'TR_ss': TR_ss,
'trssmat': trssmat,
'Gss': Gss,
'total_tax_revenue': total_tax_revenue,
'business_tax_revenue': business_tax_revenue,
'iit_payroll_tax_revenue': iit_payroll_tax_revenue,
'iit_revenue': iit_revenue,
'payroll_tax_revenue': payroll_tax_revenue,
'agg_pension_outlays': agg_pension_outlays,
'UBI_outlays_SS': UBI_outlays,
'bequest_tax_revenue': bequest_tax_revenue,
'wealth_tax_revenue': wealth_tax_revenue,
'cons_tax_revenue': cons_tax_revenue,
'euler_savings': euler_savings,
'debt_service_f': debt_service_f,
'new_borrowing_f': new_borrowing_f,
'debt_service': debt_service,
'new_borrowing': new_borrowing,
'euler_labor_leisure': euler_labor_leisure,
'resource_constraint_error': RC,
'etr_ss': etr_ss,
'mtrx_ss': mtrx_ss,
'mtry_ss': mtry_ss
}
return output
def test_get_B(b, p, method, PreTP, expected):
"""
Test aggregate savings function.
"""
B = aggr.get_B(b, p, method, PreTP)
assert np.allclose(B, expected)
def run_TPI(p, client=None):
'''
Solve for transition path equilibrium of OG-Core.
Args:
p (OG-Core Specifications object): model parameters
client (Dask client object): client
Returns:
output (dictionary): dictionary with transition path solution
results
'''
# unpack tuples of parameters
initial_values, ss_vars, theta, baseline_values = get_initial_SS_values(p)
(B0, b_sinit, b_splus1init, factor, initial_b, initial_n) =\
initial_values
(TRbaseline, Gbaseline, D0_baseline) = baseline_values
# Create time path of UBI household benefits and aggregate UBI outlays
ubi = p.ubi_nom_array / factor
UBI = aggr.get_L(ubi[:p.T], p, 'TPI')
print('Government spending breakpoints are tG1: ', p.tG1, '; and tG2:',
p.tG2)
# Initialize guesses at time paths
# Make array of initial guesses for labor supply and savings
guesses_b = utils.get_initial_path(initial_b, ss_vars['bssmat_splus1'], p,
'ratio')
guesses_n = utils.get_initial_path(initial_n, ss_vars['nssmat'], p,
'ratio')
b_mat = guesses_b
n_mat = guesses_n
ind = np.arange(p.S)
# Get path for aggregate savings and labor supply
L_init = np.ones((p.T + p.S, )) * ss_vars['Lss']
B_init = np.ones((p.T + p.S, )) * ss_vars['Bss']
L_init[:p.T] = aggr.get_L(n_mat[:p.T], p, 'TPI')
B_init[1:p.T] = aggr.get_B(b_mat[:p.T], p, 'TPI', False)[:p.T - 1]
B_init[0] = B0
K_init = B_init * ss_vars['Kss'] / ss_vars['Bss']
K = K_init
K_d = K_init * ss_vars['K_d_ss'] / ss_vars['Kss']
K_f = K_init * ss_vars['K_f_ss'] / ss_vars['Kss']
L = L_init
B = B_init
Y = np.zeros_like(K)
Y[:p.T] = firm.get_Y(K[:p.T], L[:p.T], p, 'TPI')
Y[p.T:] = ss_vars['Yss']
r = np.zeros_like(Y)
r[:p.T] = firm.get_r(Y[:p.T], K[:p.T], p, 'TPI')
r[p.T:] = ss_vars['rss']
# For case where economy is small open econ
r[p.zeta_K == 1] = p.world_int_rate[p.zeta_K == 1]
# Compute other interest rates
r_gov = fiscal.get_r_gov(r, p)
r_p = aggr.get_r_p(r, r_gov, K, ss_vars['Dss'])
# compute w
w = np.zeros_like(r)
w[:p.T] = firm.get_w_from_r(r[:p.T], p, 'TPI')
w[p.T:] = ss_vars['wss']
# initial guesses at fiscal vars
if p.budget_balance:
if np.abs(ss_vars['TR_ss']) < 1e-13:
TR_ss2 = 0.0 # sometimes SS is very small but not zero,
# even if taxes are zero, this get's rid of the
# approximation error, which affects the pct changes below
else:
TR_ss2 = ss_vars['TR_ss']
TR = np.ones(p.T + p.S) * TR_ss2
total_tax_revenue = TR - ss_vars['agg_pension_outlays']
G = np.zeros(p.T + p.S)
D = np.zeros(p.T + p.S)
D_d = np.zeros(p.T + p.S)
D_f = np.zeros(p.T + p.S)
else:
if p.baseline_spending:
TR = TRbaseline
G = Gbaseline
G[p.T:] = ss_vars['Gss']
else:
TR = p.alpha_T * Y
G = np.ones(p.T + p.S) * ss_vars['Gss']
D = np.ones(p.T + p.S) * ss_vars['Dss']
D_d = D * ss_vars['D_d_ss'] / ss_vars['Dss']
D_f = D * ss_vars['D_f_ss'] / ss_vars['Dss']
total_tax_revenue = np.ones(p.T + p.S) * ss_vars['total_tax_revenue']
# Initialize bequests
BQ0 = aggr.get_BQ(r_p[0], initial_b, None, p, 'SS', True)
if not p.use_zeta:
BQ = np.zeros((p.T + p.S, p.J))
for j in range(p.J):
BQ[:, j] = (list(np.linspace(BQ0[j], ss_vars['BQss'][j], p.T)) +
[ss_vars['BQss'][j]] * p.S)
BQ = np.array(BQ)
else:
BQ = (list(np.linspace(BQ0, ss_vars['BQss'], p.T)) +
[ss_vars['BQss']] * p.S)
BQ = np.array(BQ)
TPIiter = 0
TPIdist = 10
euler_errors = np.zeros((p.T, 2 * p.S, p.J))
TPIdist_vec = np.zeros(p.maxiter)
# TPI loop
while (TPIiter < p.maxiter) and (TPIdist >= p.mindist_TPI):
r_gov[:p.T] = fiscal.get_r_gov(r[:p.T], p)
if not p.budget_balance:
K[:p.T] = firm.get_K_from_Y(Y[:p.T], r[:p.T], p, 'TPI')
r_p[:p.T] = aggr.get_r_p(r[:p.T], r_gov[:p.T], K[:p.T], D[:p.T])
outer_loop_vars = (r, w, r_p, BQ, TR, theta)
euler_errors = np.zeros((p.T, 2 * p.S, p.J))
lazy_values = []
for j in range(p.J):
guesses = (guesses_b[:, :, j], guesses_n[:, :, j])
lazy_values.append(
delayed(inner_loop)(guesses, outer_loop_vars, initial_values,
ubi, j, ind, p))
if client:
futures = client.compute(lazy_values, num_workers=p.num_workers)
results = client.gather(futures)
else:
results = results = compute(*lazy_values,
scheduler=dask.multiprocessing.get,
num_workers=p.num_workers)
for j, result in enumerate(results):
euler_errors[:, :, j], b_mat[:, :, j], n_mat[:, :, j] = result
bmat_s = np.zeros((p.T, p.S, p.J))
bmat_s[0, 1:, :] = initial_b[:-1, :]
bmat_s[1:, 1:, :] = b_mat[:p.T - 1, :-1, :]
bmat_splus1 = np.zeros((p.T, p.S, p.J))
bmat_splus1[:, :, :] = b_mat[:p.T, :, :]
etr_params_4D = np.tile(
p.etr_params[:p.T, :, :].reshape(p.T, p.S, 1,
p.etr_params.shape[2]),
(1, 1, p.J, 1))
bqmat = household.get_bq(BQ, None, p, 'TPI')
trmat = household.get_tr(TR, None, p, 'TPI')
tax_mat = tax.net_taxes(r_p[:p.T], w[:p.T], bmat_s, n_mat[:p.T, :, :],
bqmat[:p.T, :, :], factor, trmat[:p.T, :, :],
ubi[:p.T, :, :], theta, 0, None, False, 'TPI',
p.e, etr_params_4D, p)
r_p_path = utils.to_timepath_shape(r_p)
wpath = utils.to_timepath_shape(w)
c_mat = household.get_cons(r_p_path[:p.T, :, :], wpath[:p.T, :, :],
bmat_s, bmat_splus1, n_mat[:p.T, :, :],
bqmat[:p.T, :, :], tax_mat, p.e,
p.tau_c[:p.T, :, :], p)
y_before_tax_mat = household.get_y(r_p_path[:p.T, :, :],
wpath[:p.T, :, :],
bmat_s[:p.T, :, :],
n_mat[:p.T, :, :], p)
(total_tax_rev, iit_payroll_tax_revenue, agg_pension_outlays,
UBI_outlays, bequest_tax_revenue, wealth_tax_revenue,
cons_tax_revenue, business_tax_revenue, payroll_tax_revenue,
iit_revenue) = aggr.revenue(r_p[:p.T], w[:p.T], bmat_s,
n_mat[:p.T, :, :], bqmat[:p.T, :, :],
c_mat[:p.T, :, :], Y[:p.T], L[:p.T],
K[:p.T], factor, ubi[:p.T, :, :], theta,
etr_params_4D, p, 'TPI')
total_tax_revenue[:p.T] = total_tax_rev
dg_fixed_values = (Y, total_tax_revenue, agg_pension_outlays,
UBI_outlays, TR, Gbaseline, D0_baseline)
(Dnew, G[:p.T], D_d[:p.T], D_f[:p.T], new_borrowing,
debt_service, new_borrowing_f) =\
fiscal.D_G_path(r_gov, dg_fixed_values, p)
L[:p.T] = aggr.get_L(n_mat[:p.T], p, 'TPI')
B[1:p.T] = aggr.get_B(bmat_splus1[:p.T], p, 'TPI', False)[:p.T - 1]
K_demand_open = firm.get_K(L[:p.T], p.world_int_rate[:p.T], p, 'TPI')
K[:p.T], K_d[:p.T], K_f[:p.T] = aggr.get_K_splits(
B[:p.T], K_demand_open, D_d[:p.T], p.zeta_K[:p.T])
Ynew = firm.get_Y(K[:p.T], L[:p.T], p, 'TPI')
rnew = r.copy()
rnew[:p.T] = firm.get_r(Ynew[:p.T], K[:p.T], p, 'TPI')
# For case where economy is small open econ
r[p.zeta_K == 1] = p.world_int_rate[p.zeta_K == 1]
r_gov_new = fiscal.get_r_gov(rnew, p)
r_p_new = aggr.get_r_p(rnew[:p.T], r_gov_new[:p.T], K[:p.T],
Dnew[:p.T])
# compute w
wnew = firm.get_w_from_r(rnew[:p.T], p, 'TPI')
b_mat_shift = np.append(np.reshape(initial_b, (1, p.S, p.J)),
b_mat[:p.T - 1, :, :],
axis=0)
BQnew = aggr.get_BQ(r_p_new[:p.T], b_mat_shift, None, p, 'TPI', False)
bqmat_new = household.get_bq(BQnew, None, p, 'TPI')
(total_tax_rev, iit_payroll_tax_revenue, agg_pension_outlays,
UBI_outlays, bequest_tax_revenue, wealth_tax_revenue,
cons_tax_revenue, business_tax_revenue, payroll_tax_revenue,
iit_revenue) = aggr.revenue(r_p_new[:p.T], wnew[:p.T], bmat_s,
n_mat[:p.T, :, :], bqmat_new[:p.T, :, :],
c_mat[:p.T, :, :], Ynew[:p.T], L[:p.T],
K[:p.T], factor, ubi[:p.T, :, :], theta,
etr_params_4D, p, 'TPI')
total_tax_revenue[:p.T] = total_tax_rev
TR_new = fiscal.get_TR(Ynew[:p.T], TR[:p.T], G[:p.T],
total_tax_revenue[:p.T],
agg_pension_outlays[:p.T], UBI_outlays[:p.T], p,
'TPI')
# update vars for next iteration
w[:p.T] = wnew[:p.T]
r[:p.T] = utils.convex_combo(rnew[:p.T], r[:p.T], p.nu)
BQ[:p.T] = utils.convex_combo(BQnew[:p.T], BQ[:p.T], p.nu)
D[:p.T] = Dnew[:p.T]
Y[:p.T] = utils.convex_combo(Ynew[:p.T], Y[:p.T], p.nu)
if not p.baseline_spending:
TR[:p.T] = utils.convex_combo(TR_new[:p.T], TR[:p.T], p.nu)
guesses_b = utils.convex_combo(b_mat, guesses_b, p.nu)
guesses_n = utils.convex_combo(n_mat, guesses_n, p.nu)
print('r diff: ', (rnew[:p.T] - r[:p.T]).max(),
(rnew[:p.T] - r[:p.T]).min())
print('BQ diff: ', (BQnew[:p.T] - BQ[:p.T]).max(),
(BQnew[:p.T] - BQ[:p.T]).min())
print('TR diff: ', (TR_new[:p.T] - TR[:p.T]).max(),
(TR_new[:p.T] - TR[:p.T]).min())
print('Y diff: ', (Ynew[:p.T] - Y[:p.T]).max(),
(Ynew[:p.T] - Y[:p.T]).min())
if not p.baseline_spending:
if TR.all() != 0:
TPIdist = np.array(
list(utils.pct_diff_func(rnew[:p.T], r[:p.T])) + list(
utils.pct_diff_func(BQnew[:p.T], BQ[:p.T]).flatten()) +
list(utils.pct_diff_func(TR_new[:p.T], TR[:p.T]))).max()
else:
TPIdist = np.array(
list(utils.pct_diff_func(rnew[:p.T], r[:p.T])) + list(
utils.pct_diff_func(BQnew[:p.T], BQ[:p.T]).flatten()) +
list(np.abs(TR[:p.T]))).max()
else:
TPIdist = np.array(
list(utils.pct_diff_func(rnew[:p.T], r[:p.T])) +
list(utils.pct_diff_func(BQnew[:p.T], BQ[:p.T]).flatten()) +
list(utils.pct_diff_func(Ynew[:p.T], Y[:p.T]))).max()
TPIdist_vec[TPIiter] = TPIdist
# After T=10, if cycling occurs, drop the value of nu
# wait til after T=10 or so, because sometimes there is a jump up
# in the first couple iterations
# if TPIiter > 10:
# if TPIdist_vec[TPIiter] - TPIdist_vec[TPIiter - 1] > 0:
# nu /= 2
# print 'New Value of nu:', nu
TPIiter += 1
print('Iteration:', TPIiter)
print('\tDistance:', TPIdist)
# Compute effective and marginal tax rates for all agents
mtrx_params_4D = np.tile(
p.mtrx_params[:p.T, :, :].reshape(p.T, p.S, 1, p.mtrx_params.shape[2]),
(1, 1, p.J, 1))
mtry_params_4D = np.tile(
p.mtry_params[:p.T, :, :].reshape(p.T, p.S, 1, p.mtry_params.shape[2]),
(1, 1, p.J, 1))
e_3D = np.tile(p.e.reshape(1, p.S, p.J), (p.T, 1, 1))
mtry_path = tax.MTR_income(r_p_path[:p.T], wpath[:p.T], bmat_s[:p.T, :, :],
n_mat[:p.T, :, :], factor, True, e_3D,
etr_params_4D, mtry_params_4D, p)
mtrx_path = tax.MTR_income(r_p_path[:p.T], wpath[:p.T], bmat_s[:p.T, :, :],
n_mat[:p.T, :, :], factor, False, e_3D,
etr_params_4D, mtrx_params_4D, p)
etr_path = tax.ETR_income(r_p_path[:p.T], wpath[:p.T], bmat_s[:p.T, :, :],
n_mat[:p.T, :, :], factor, e_3D, etr_params_4D,
p)
C = aggr.get_C(c_mat, p, 'TPI')
# Note that implicity in this computation is that immigrants'
# wealth is all in the form of private capital
I_d = aggr.get_I(bmat_splus1[:p.T], K_d[1:p.T + 1], K_d[:p.T], p, 'TPI')
I = aggr.get_I(bmat_splus1[:p.T], K[1:p.T + 1], K[:p.T], p, 'TPI')
# solve resource constraint
# foreign debt service costs
debt_service_f = fiscal.get_debt_service_f(r_p, D_f)
RC_error = aggr.resource_constraint(Y[:p.T - 1], C[:p.T - 1], G[:p.T - 1],
I_d[:p.T - 1], K_f[:p.T - 1],
new_borrowing_f[:p.T - 1],
debt_service_f[:p.T - 1],
r_p[:p.T - 1], p)
# Compute total investment (not just domestic)
I_total = aggr.get_I(None, K[1:p.T + 1], K[:p.T], p, 'total_tpi')
# Compute resource constraint error
rce_max = np.amax(np.abs(RC_error))
print('Max absolute value resource constraint error:', rce_max)
print('Checking time path for violations of constraints.')
for t in range(p.T):
household.constraint_checker_TPI(b_mat[t], n_mat[t], c_mat[t], t,
p.ltilde)
eul_savings = euler_errors[:, :p.S, :].max(1).max(1)
eul_laborleisure = euler_errors[:, p.S:, :].max(1).max(1)
print('Max Euler error, savings: ', eul_savings)
print('Max Euler error labor supply: ', eul_laborleisure)
'''
------------------------------------------------------------------------
Save variables/values so they can be used in other modules
------------------------------------------------------------------------
'''
output = {
'Y': Y[:p.T],
'B': B,
'K': K,
'K_f': K_f,
'K_d': K_d,
'L': L,
'C': C,
'I': I,
'I_total': I_total,
'I_d': I_d,
'BQ': BQ,
'total_tax_revenue': total_tax_revenue,
'business_tax_revenue': business_tax_revenue,
'iit_payroll_tax_revenue': iit_payroll_tax_revenue,
'iit_revenue': iit_revenue,
'payroll_tax_revenue': payroll_tax_revenue,
'TR': TR,
'agg_pension_outlays': agg_pension_outlays,
'bequest_tax_revenue': bequest_tax_revenue,
'wealth_tax_revenue': wealth_tax_revenue,
'cons_tax_revenue': cons_tax_revenue,
'G': G,
'D': D,
'D_f': D_f,
'D_d': D_d,
'r': r,
'r_gov': r_gov,
'r_p': r_p,
'w': w,
'bmat_splus1': bmat_splus1,
'bmat_s': bmat_s[:p.T, :, :],
'n_mat': n_mat[:p.T, :, :],
'c_path': c_mat,
'bq_path': bqmat,
'tr_path': trmat,
'y_before_tax_mat': y_before_tax_mat,
'tax_path': tax_mat,
'eul_savings': eul_savings,
'eul_laborleisure': eul_laborleisure,
'resource_constraint_error': RC_error,
'new_borrowing_f': new_borrowing_f,
'debt_service_f': debt_service_f,
'etr_path': etr_path,
'mtrx_path': mtrx_path,
'mtry_path': mtry_path,
'ubi_path': ubi,
'UBI_path': UBI
}
tpi_dir = os.path.join(p.output_base, "TPI")
utils.mkdirs(tpi_dir)
tpi_vars = os.path.join(tpi_dir, "TPI_vars.pkl")
with open(tpi_vars, "wb") as f:
pickle.dump(output, f)
if np.any(G) < 0:
print('Government spending is negative along transition path' +
' to satisfy budget')
if (((TPIiter >= p.maxiter) or (np.absolute(TPIdist) > p.mindist_TPI))
and ENFORCE_SOLUTION_CHECKS):
raise RuntimeError('Transition path equlibrium not found' +
' (TPIdist)')
if ((np.any(np.absolute(RC_error) >= p.mindist_TPI * 10))
and ENFORCE_SOLUTION_CHECKS):
raise RuntimeError('Transition path equlibrium not found ' +
'(RC_error)')
if ((np.any(np.absolute(eul_savings) >= p.mindist_TPI) or
(np.any(np.absolute(eul_laborleisure) > p.mindist_TPI)))
and ENFORCE_SOLUTION_CHECKS):
raise RuntimeError('Transition path equlibrium not found ' +
'(eulers)')
return output
def get_initial_SS_values(p):
'''
Get values of variables for the initial period and the steady state
equilibrium values.
Args:
p (OG-Core Specifications object): model parameters
Returns:
(tuple): initial period and steady state values:
* initial_values (tuple): initial period variable values,
(b_sinit, b_splus1init, factor, initial_b, initial_n)
* ss_vars (dictionary): dictionary with steady state
solution results
* theta (Numpy array): steady-state retirement replacement
rates, length J
* baseline_values (tuple): (TRbaseline, Gbaseline,
D0_baseline), lump sum transfer and government spending
amounts from the baseline model run
'''
baseline_ss = os.path.join(p.baseline_dir, "SS", "SS_vars.pkl")
ss_baseline_vars = utils.safe_read_pickle(baseline_ss)
factor = ss_baseline_vars['factor_ss']
B0 = aggr.get_B(ss_baseline_vars['bssmat_splus1'], p, 'SS', True)
initial_b = (ss_baseline_vars['bssmat_splus1'] *
(ss_baseline_vars['Bss'] / B0))
initial_n = ss_baseline_vars['nssmat']
TRbaseline = None
Gbaseline = None
if p.baseline_spending:
baseline_tpi = os.path.join(p.baseline_dir, "TPI", "TPI_vars.pkl")
tpi_baseline_vars = utils.safe_read_pickle(baseline_tpi)
TRbaseline = tpi_baseline_vars['TR']
Gbaseline = tpi_baseline_vars['G']
if p.baseline:
ss_vars = ss_baseline_vars
else:
reform_ss_path = os.path.join(p.output_base, "SS", "SS_vars.pkl")
ss_vars = utils.safe_read_pickle(reform_ss_path)
theta = ss_vars['theta']
'''
------------------------------------------------------------------------
Set other parameters and initial values
------------------------------------------------------------------------
'''
# Get an initial distribution of wealth with the initial population
# distribution. When small_open=True, the value of K0 is used as a
# placeholder for first-period wealth
B0 = aggr.get_B(initial_b, p, 'SS', True)
b_sinit = np.array(
list(np.zeros(p.J).reshape(1, p.J)) + list(initial_b[:-1]))
b_splus1init = initial_b
# Intial gov't debt must match that in the baseline
if not p.baseline:
baseline_tpi = os.path.join(p.baseline_dir, "TPI", "TPI_vars.pkl")
tpi_baseline_vars = utils.safe_read_pickle(baseline_tpi)
D0_baseline = tpi_baseline_vars['D'][0]
else:
D0_baseline = None
initial_values = (B0, b_sinit, b_splus1init, factor, initial_b, initial_n)
baseline_values = (TRbaseline, Gbaseline, D0_baseline)
return initial_values, ss_vars, theta, baseline_values