def euler_labor_leisure_func(w, r, e, n_guess, b_s, b_splus1, BQ, factor, T_H, chi_n, params, theta, tau_bq, lambdas): """ This function is usually looped through over J, so it does one ability group at a time. Inputs: w = wage rate (scalar) r = rental rate (scalar) e = ability levels (Sx1 array) n_guess = labor distribution (Sx1 array) b_s = wealth holdings at the start of a period (Sx1 array) b_splus1 = wealth holdings for the next period (Sx1 array) BQ = aggregate bequests for a certain ability (scalar) factor = scaling factor to convert to dollars (scalar) T_H = lump sum tax (scalar) chi_n = chi^n_s (Sx1 array) params = parameter list (list) theta = replacement rate for a certain ability (scalar) tau_bq = bequest tax rate (scalar) lambdas = ability weight (scalar) Output: euler = Value of labor leisure euler error (Sx1 array) """ J, S, T, beta, sigma, alpha, Z, delta, ltilde, nu, g_y, g_n_ss, tau_payroll, retire, mean_income_data, a_tax_income, b_tax_income, c_tax_income, d_tax_income, h_wealth, p_wealth, m_wealth, b_ellipse, upsilon = ( params ) tax1 = tax.total_taxes(r, b_s, w, e, n_guess, BQ, lambdas, factor, T_H, None, "SS", False, params, theta, tau_bq) cons = get_cons(r, b_s, w, e, n_guess, BQ, lambdas, b_splus1, params, tax1) income = (r * b_s + w * e * n_guess) * factor deriv = ( 1 - tau_payroll - tax.tau_income(r, b_s, w, e, n_guess, factor, params) - tax.tau_income_deriv(r, b_s, w, e, n_guess, factor, params) * income ) euler = marg_ut_cons(cons, params) * w * deriv * e - marg_ut_labor(n_guess, chi_n, params) return euler
def euler_labor_leisure_func(w, r, e, n_guess, b_s, b_splus1, BQ, factor, T_H, chi_n, params, theta, tau_bq, lambdas): ''' This function is usually looped through over J, so it does one ability group at a time. Inputs: w = wage rate (scalar) r = rental rate (scalar) e = ability levels (Sx1 array) n_guess = labor distribution (Sx1 array) b_s = wealth holdings at the start of a period (Sx1 array) b_splus1 = wealth holdings for the next period (Sx1 array) BQ = aggregate bequests for a certain ability (scalar) factor = scaling factor to convert to dollars (scalar) T_H = lump sum tax (scalar) chi_n = chi^n_s (Sx1 array) params = parameter list (list) theta = replacement rate for a certain ability (scalar) tau_bq = bequest tax rate (scalar) lambdas = ability weight (scalar) Output: euler = Value of labor leisure euler error (Sx1 array) ''' J, S, T, beta, sigma, alpha, Z, delta, ltilde, nu, g_y, g_n_ss, tau_payroll, retire, mean_income_data, \ a_tax_income, b_tax_income, c_tax_income, d_tax_income, h_wealth, p_wealth, m_wealth, b_ellipse, upsilon = params tax1 = tax.total_taxes(r, b_s, w, e, n_guess, BQ, lambdas, factor, T_H, None, 'SS', False, params, theta, tau_bq) cons = get_cons(r, b_s, w, e, n_guess, BQ, lambdas, b_splus1, params, tax1) income = (r * b_s + w * e * n_guess) * factor deriv = 1 - tau_payroll - tax.tau_income( r, b_s, w, e, n_guess, factor, params) - tax.tau_income_deriv( r, b_s, w, e, n_guess, factor, params) * income euler = marg_ut_cons(cons, params) * w * deriv * e - \ marg_ut_labor(n_guess, chi_n, params) return euler
def euler_savings_func(w, r, e, n_guess, b_s, b_splus1, b_splus2, BQ, factor, T_H, chi_b, params, theta, tau_bq, rho, lambdas): ''' This function is usually looped through over J, so it does one ability group at a time. Inputs: w = wage rate (scalar) r = rental rate (scalar) e = ability levels (Sx1 array) n_guess = labor distribution (Sx1 array) b_s = wealth holdings at the start of a period (Sx1 array) b_splus1 = wealth holdings for the next period (Sx1 array) b_splus2 = wealth holdings for 2 periods ahead (Sx1 array) BQ = aggregate bequests for a certain ability (scalar) factor = scaling factor to convert to dollars (scalar) T_H = lump sum tax (scalar) chi_b = chi^b_j for a certain ability (scalar) params = parameter list (list) theta = replacement rate for a certain ability (scalar) tau_bq = bequest tax rate (scalar) rho = mortality rate (Sx1 array) lambdas = ability weight (scalar) Output: euler = Value of savings euler error (Sx1 array) ''' J, S, T, beta, sigma, alpha, Z, delta, ltilde, nu, g_y, g_n_ss, tau_payroll, retire, mean_income_data, \ a_tax_income, b_tax_income, c_tax_income, d_tax_income, h_wealth, p_wealth, m_wealth, b_ellipse, upsilon = params # In order to not have 2 savings euler equations (one that solves the first S-1 equations, and one that solves the last one), # we combine them. In order to do this, we have to compute a consumption term in period t+1, which requires us to have a shifted # e and n matrix. We append a zero on the end of both of these so they will be the right size. We could append any value to them, # since in the euler equation, the coefficient on the marginal utility of # consumption for this term will be zero (since rho is one). e_extended = np.array(list(e) + [0]) n_extended = np.array(list(n_guess) + [0]) tax1 = tax.total_taxes(r, b_s, w, e, n_guess, BQ, lambdas, factor, T_H, None, 'SS', False, params, theta, tau_bq) tax2 = tax.total_taxes(r, b_splus1, w, e_extended[1:], n_extended[1:], BQ, lambdas, factor, T_H, None, 'SS', True, params, theta, tau_bq) cons1 = get_cons(r, b_s, w, e, n_guess, BQ, lambdas, b_splus1, params, tax1) cons2 = get_cons(r, b_splus1, w, e_extended[1:], n_extended[1:], BQ, lambdas, b_splus2, params, tax2) income = (r * b_splus1 + w * e_extended[1:] * n_extended[1:]) * factor deriv = (1 + r * (1 - tax.tau_income(r, b_splus1, w, e_extended[1:], n_extended[1:], factor, params) - tax.tau_income_deriv(r, b_splus1, w, e_extended[1:], n_extended[1:], factor, params) * income) - tax.tau_w_prime(b_splus1, params) * b_splus1 - tax.tau_wealth(b_splus1, params)) savings_ut = rho * np.exp(-sigma * g_y) * chi_b * b_splus1**(-sigma) # Again, not who in this equation, the (1-rho) term will zero out in the last period, so the last entry of cons2 can be complete # gibberish (which it is). It just has to exist so cons2 is the right # size to match all other arrays in the equation. euler = marg_ut_cons(cons1, params) - beta * (1 - rho) * deriv * marg_ut_cons( cons2, params) * np.exp(-sigma * g_y) - savings_ut return euler
def SS_TPI_firstdoughnutring(guesses, winit, rinit, BQinit, T_H_init, initial_b, factor_ss, j, parameters, theta, tau_bq): ''' Solves the first entries of the upper triangle of the twist doughnut. This is separate from the main TPI function because the the values of b and n are scalars, so it is easier to just have a separate function for these cases. Inputs: guesses = guess for b and n (2x1 list) winit = initial wage rate (scalar) rinit = initial rental rate (scalar) BQinit = initial aggregate bequest (scalar) T_H_init = initial lump sum tax (scalar) initial_b = initial distribution of capital (SxJ array) factor_ss = steady state scaling factor (scalar) j = which ability type is being solved for (scalar) parameters = list of parameters (list) theta = replacement rates (Jx1 array) tau_bq = bequest tax rates (Jx1 array) Output: euler errors (2x1 list) ''' b2 = float(guesses[0]) n1 = float(guesses[1]) b1 = float(initial_b[-2, j]) # Euler 1 equations tax1 = tax.total_taxes(rinit, b1, winit, e[-1, j], n1, BQinit, lambdas[j], factor_ss, T_H_init, j, 'TPI_scalar', False, parameters, theta, tau_bq) cons1 = household.get_cons(rinit, b1, winit, e[-1, j], n1, BQinit, lambdas[j], b2, parameters, tax1) bequest_ut = rho[-1] * np.exp(-sigma * g_y) * chi_b[-1, j] * b2**(-sigma) error1 = household.marg_ut_cons(cons1, parameters) - bequest_ut # Euler 2 equations income2 = (rinit * b1 + winit * e[-1, j] * n1) * factor_ss deriv2 = 1 - tau_payroll - tax.tau_income( rinit, b1, winit, e[-1, j], n1, factor_ss, parameters) - tax.tau_income_deriv( rinit, b1, winit, e[-1, j], n1, factor_ss, parameters) * income2 error2 = household.marg_ut_cons(cons1, parameters) * winit * \ e[-1, j] * deriv2 - household.marg_ut_labor(n1, chi_n[-1], parameters) if n1 <= 0 or n1 >= 1: error2 += 1e12 if b2 <= 0: error1 += 1e12 if cons1 <= 0: error1 += 1e12 return [error1] + [error2]
def SS_TPI_firstdoughnutring(guesses, winit, rinit, BQinit, T_H_init, initial_b, factor_ss, j, parameters, theta, tau_bq): ''' Solves the first entries of the upper triangle of the twist doughnut. This is separate from the main TPI function because the the values of b and n are scalars, so it is easier to just have a separate function for these cases. Inputs: guesses = guess for b and n (2x1 list) winit = initial wage rate (scalar) rinit = initial rental rate (scalar) BQinit = initial aggregate bequest (scalar) T_H_init = initial lump sum tax (scalar) initial_b = initial distribution of capital (SxJ array) factor_ss = steady state scaling factor (scalar) j = which ability type is being solved for (scalar) parameters = list of parameters (list) theta = replacement rates (Jx1 array) tau_bq = bequest tax rates (Jx1 array) Output: euler errors (2x1 list) ''' b2 = float(guesses[0]) n1 = float(guesses[1]) b1 = float(initial_b[-2, j]) # Euler 1 equations tax1 = tax.total_taxes(rinit, b1, winit, e[-1, j], n1, BQinit, lambdas[ j], factor_ss, T_H_init, j, 'TPI_scalar', False, parameters, theta, tau_bq) cons1 = household.get_cons( rinit, b1, winit, e[-1, j], n1, BQinit, lambdas[j], b2, parameters, tax1) bequest_ut = rho[-1] * np.exp(-sigma * g_y) * chi_b[-1, j] * b2 ** (-sigma) error1 = household.marg_ut_cons(cons1, parameters) - bequest_ut # Euler 2 equations income2 = (rinit * b1 + winit * e[-1, j] * n1) * factor_ss deriv2 = 1 - tau_payroll - tax.tau_income(rinit, b1, winit, e[ -1, j], n1, factor_ss, parameters) - tax.tau_income_deriv( rinit, b1, winit, e[-1, j], n1, factor_ss, parameters) * income2 error2 = household.marg_ut_cons(cons1, parameters) * winit * \ e[-1, j] * deriv2 - household.marg_ut_labor(n1, chi_n[-1], parameters) if n1 <= 0 or n1 >= 1: error2 += 1e12 if b2 <= 0: error1 += 1e12 if cons1 <= 0: error1 += 1e12 return [error1] + [error2]
def Steady_state_TPI_solver(guesses, winit, rinit, BQinit, T_H_init, factor, j, s, t, params, theta, tau_bq, rho, lambdas, e, initial_b, chi_b, chi_n): ''' Parameters: guesses = distribution of capital and labor (various length list) winit = wage rate ((T+S)x1 array) rinit = rental rate ((T+S)x1 array) BQinit = aggregate bequests ((T+S)x1 array) T_H_init = lump sum tax over time ((T+S)x1 array) factor = scaling factor (scalar) j = which ability type is being solved for (scalar) s = which upper triangle loop is being solved for (scalar) t = which diagonal is being solved for (scalar) params = list of parameters (list) theta = replacement rates (Jx1 array) tau_bq = bequest tax rate (Jx1 array) rho = mortalit rate (Sx1 array) lambdas = ability weights (Jx1 array) e = ability type (SxJ array) initial_b = capital stock distribution in period 0 (SxJ array) chi_b = chi^b_j (Jx1 array) chi_n = chi^n_s (Sx1 array) Output: Value of Euler error (various length list) ''' J, S, T, beta, sigma, alpha, Z, delta, ltilde, nu, g_y, g_n_ss, tau_payroll, retire, mean_income_data, \ a_tax_income, b_tax_income, c_tax_income, d_tax_income, h_wealth, p_wealth, m_wealth, b_ellipse, upsilon = params length = len(guesses) / 2 b_guess = np.array(guesses[:length]) n_guess = np.array(guesses[length:]) if length == S: b_s = np.array([0] + list(b_guess[:-1])) else: b_s = np.array([(initial_b[-(s + 3), j])] + list(b_guess[:-1])) b_splus1 = b_guess b_splus2 = np.array(list(b_guess[1:]) + [0]) w_s = winit[t:t + length] w_splus1 = winit[t + 1:t + length + 1] r_s = rinit[t:t + length] r_splus1 = rinit[t + 1:t + length + 1] n_s = n_guess n_extended = np.array(list(n_guess[1:]) + [0]) e_s = e[-length:, j] e_extended = np.array(list(e[-length + 1:, j]) + [0]) BQ_s = BQinit[t:t + length] BQ_splus1 = BQinit[t + 1:t + length + 1] T_H_s = T_H_init[t:t + length] T_H_splus1 = T_H_init[t + 1:t + length + 1] # Savings euler equations tax_s = tax.total_taxes(r_s, b_s, w_s, e_s, n_s, BQ_s, lambdas[j], factor, T_H_s, j, 'TPI', False, params, theta, tau_bq) tax_splus1 = tax.total_taxes(r_splus1, b_splus1, w_splus1, e_extended, n_extended, BQ_splus1, lambdas[j], factor, T_H_splus1, j, 'TPI', True, params, theta, tau_bq) cons_s = household.get_cons(r_s, b_s, w_s, e_s, n_s, BQ_s, lambdas[j], b_splus1, params, tax_s) cons_splus1 = household.get_cons(r_splus1, b_splus1, w_splus1, e_extended, n_extended, BQ_splus1, lambdas[j], b_splus2, params, tax_splus1) income_splus1 = (r_splus1 * b_splus1 + w_splus1 * e_extended * n_extended) * factor savings_ut = rho[-(length):] * np.exp(-sigma * g_y) * \ chi_b[-(length):, j] * b_splus1 ** (-sigma) deriv_savings = 1 + r_splus1 * ( 1 - tax.tau_income(r_splus1, b_splus1, w_splus1, e_extended, n_extended, factor, params) - tax.tau_income_deriv(r_splus1, b_splus1, w_splus1, e_extended, n_extended, factor, params) * income_splus1 ) - tax.tau_w_prime(b_splus1, params) * b_splus1 - tax.tau_wealth( b_splus1, params) error1 = household.marg_ut_cons( cons_s, params) - beta * (1 - rho[-(length):]) * np.exp( -sigma * g_y) * deriv_savings * household.marg_ut_cons( cons_splus1, params) - savings_ut # Labor leisure euler equations income_s = (r_s * b_s + w_s * e_s * n_s) * factor deriv_laborleisure = 1 - tau_payroll - tax.tau_income( r_s, b_s, w_s, e_s, n_s, factor, params) - tax.tau_income_deriv( r_s, b_s, w_s, e_s, n_s, factor, params) * income_s error2 = household.marg_ut_cons(cons_s, params) * w_s * e[ -(length):, j] * deriv_laborleisure - household.marg_ut_labor( n_s, chi_n[-length:], params) # Check and punish constraint violations mask1 = n_guess < 0 error2[mask1] += 1e12 mask2 = n_guess > ltilde error2[mask2] += 1e12 mask3 = cons_s < 0 error2[mask3] += 1e12 mask4 = b_guess <= 0 error2[mask4] += 1e12 mask5 = cons_splus1 < 0 error2[mask5] += 1e12 return list(error1.flatten()) + list(error2.flatten())
def Steady_state_TPI_solver(guesses, winit, rinit, BQinit, T_H_init, factor, j, s, t, params, theta, tau_bq, rho, lambdas, e, initial_b, chi_b, chi_n): ''' Parameters: guesses = distribution of capital and labor (various length list) winit = wage rate ((T+S)x1 array) rinit = rental rate ((T+S)x1 array) BQinit = aggregate bequests ((T+S)x1 array) T_H_init = lump sum tax over time ((T+S)x1 array) factor = scaling factor (scalar) j = which ability type is being solved for (scalar) s = which upper triangle loop is being solved for (scalar) t = which diagonal is being solved for (scalar) params = list of parameters (list) theta = replacement rates (Jx1 array) tau_bq = bequest tax rate (Jx1 array) rho = mortalit rate (Sx1 array) lambdas = ability weights (Jx1 array) e = ability type (SxJ array) initial_b = capital stock distribution in period 0 (SxJ array) chi_b = chi^b_j (Jx1 array) chi_n = chi^n_s (Sx1 array) Output: Value of Euler error (various length list) ''' J, S, T, beta, sigma, alpha, Z, delta, ltilde, nu, g_y, g_n_ss, tau_payroll, retire, mean_income_data, \ a_tax_income, b_tax_income, c_tax_income, d_tax_income, h_wealth, p_wealth, m_wealth, b_ellipse, upsilon = params length = len(guesses) / 2 b_guess = np.array(guesses[:length]) n_guess = np.array(guesses[length:]) if length == S: b_s = np.array([0] + list(b_guess[:-1])) else: b_s = np.array([(initial_b[-(s + 3), j])] + list(b_guess[:-1])) b_splus1 = b_guess b_splus2 = np.array(list(b_guess[1:]) + [0]) w_s = winit[t:t + length] w_splus1 = winit[t + 1:t + length + 1] r_s = rinit[t:t + length] r_splus1 = rinit[t + 1:t + length + 1] n_s = n_guess n_extended = np.array(list(n_guess[1:]) + [0]) e_s = e[-length:, j] e_extended = np.array(list(e[-length + 1:, j]) + [0]) BQ_s = BQinit[t:t + length] BQ_splus1 = BQinit[t + 1:t + length + 1] T_H_s = T_H_init[t:t + length] T_H_splus1 = T_H_init[t + 1:t + length + 1] # Savings euler equations tax_s = tax.total_taxes(r_s, b_s, w_s, e_s, n_s, BQ_s, lambdas[ j], factor, T_H_s, j, 'TPI', False, params, theta, tau_bq) tax_splus1 = tax.total_taxes(r_splus1, b_splus1, w_splus1, e_extended, n_extended, BQ_splus1, lambdas[ j], factor, T_H_splus1, j, 'TPI', True, params, theta, tau_bq) cons_s = household.get_cons(r_s, b_s, w_s, e_s, n_s, BQ_s, lambdas[ j], b_splus1, params, tax_s) cons_splus1 = household.get_cons(r_splus1, b_splus1, w_splus1, e_extended, n_extended, BQ_splus1, lambdas[ j], b_splus2, params, tax_splus1) income_splus1 = (r_splus1 * b_splus1 + w_splus1 * e_extended * n_extended) * factor savings_ut = rho[-(length):] * np.exp(-sigma * g_y) * \ chi_b[-(length):, j] * b_splus1 ** (-sigma) deriv_savings = 1 + r_splus1 * (1 - tax.tau_income( r_splus1, b_splus1, w_splus1, e_extended, n_extended, factor, params) - tax.tau_income_deriv( r_splus1, b_splus1, w_splus1, e_extended, n_extended, factor, params) * income_splus1) - tax.tau_w_prime( b_splus1, params) * b_splus1 - tax.tau_wealth(b_splus1, params) error1 = household.marg_ut_cons(cons_s, params) - beta * (1 - rho[-(length):]) * np.exp(-sigma * g_y) * deriv_savings * household.marg_ut_cons( cons_splus1, params) - savings_ut # Labor leisure euler equations income_s = (r_s * b_s + w_s * e_s * n_s) * factor deriv_laborleisure = 1 - tau_payroll - tax.tau_income(r_s, b_s, w_s, e_s, n_s, factor, params) - tax.tau_income_deriv( r_s, b_s, w_s, e_s, n_s, factor, params) * income_s error2 = household.marg_ut_cons(cons_s, params) * w_s * e[-( length):, j] * deriv_laborleisure - household.marg_ut_labor(n_s, chi_n[-length:], params) # Check and punish constraint violations mask1 = n_guess < 0 error2[mask1] += 1e12 mask2 = n_guess > ltilde error2[mask2] += 1e12 mask3 = cons_s < 0 error2[mask3] += 1e12 mask4 = b_guess <= 0 error2[mask4] += 1e12 mask5 = cons_splus1 < 0 error2[mask5] += 1e12 return list(error1.flatten()) + list(error2.flatten())
def euler_savings_func( w, r, e, n_guess, b_s, b_splus1, b_splus2, BQ, factor, T_H, chi_b, params, theta, tau_bq, rho, lambdas ): """ This function is usually looped through over J, so it does one ability group at a time. Inputs: w = wage rate (scalar) r = rental rate (scalar) e = ability levels (Sx1 array) n_guess = labor distribution (Sx1 array) b_s = wealth holdings at the start of a period (Sx1 array) b_splus1 = wealth holdings for the next period (Sx1 array) b_splus2 = wealth holdings for 2 periods ahead (Sx1 array) BQ = aggregate bequests for a certain ability (scalar) factor = scaling factor to convert to dollars (scalar) T_H = lump sum tax (scalar) chi_b = chi^b_j for a certain ability (scalar) params = parameter list (list) theta = replacement rate for a certain ability (scalar) tau_bq = bequest tax rate (scalar) rho = mortality rate (Sx1 array) lambdas = ability weight (scalar) Output: euler = Value of savings euler error (Sx1 array) """ J, S, T, beta, sigma, alpha, Z, delta, ltilde, nu, g_y, g_n_ss, tau_payroll, retire, mean_income_data, a_tax_income, b_tax_income, c_tax_income, d_tax_income, h_wealth, p_wealth, m_wealth, b_ellipse, upsilon = ( params ) # In order to not have 2 savings euler equations (one that solves the first S-1 equations, and one that solves the last one), # we combine them. In order to do this, we have to compute a consumption term in period t+1, which requires us to have a shifted # e and n matrix. We append a zero on the end of both of these so they will be the right size. We could append any value to them, # since in the euler equation, the coefficient on the marginal utility of # consumption for this term will be zero (since rho is one). e_extended = np.array(list(e) + [0]) n_extended = np.array(list(n_guess) + [0]) tax1 = tax.total_taxes(r, b_s, w, e, n_guess, BQ, lambdas, factor, T_H, None, "SS", False, params, theta, tau_bq) tax2 = tax.total_taxes( r, b_splus1, w, e_extended[1:], n_extended[1:], BQ, lambdas, factor, T_H, None, "SS", True, params, theta, tau_bq, ) cons1 = get_cons(r, b_s, w, e, n_guess, BQ, lambdas, b_splus1, params, tax1) cons2 = get_cons(r, b_splus1, w, e_extended[1:], n_extended[1:], BQ, lambdas, b_splus2, params, tax2) income = (r * b_splus1 + w * e_extended[1:] * n_extended[1:]) * factor deriv = ( 1 + r * ( 1 - tax.tau_income(r, b_splus1, w, e_extended[1:], n_extended[1:], factor, params) - tax.tau_income_deriv(r, b_splus1, w, e_extended[1:], n_extended[1:], factor, params) * income ) - tax.tau_w_prime(b_splus1, params) * b_splus1 - tax.tau_wealth(b_splus1, params) ) savings_ut = rho * np.exp(-sigma * g_y) * chi_b * b_splus1 ** (-sigma) # Again, not who in this equation, the (1-rho) term will zero out in the last period, so the last entry of cons2 can be complete # gibberish (which it is). It just has to exist so cons2 is the right # size to match all other arrays in the equation. euler = ( marg_ut_cons(cons1, params) - beta * (1 - rho) * deriv * marg_ut_cons(cons2, params) * np.exp(-sigma * g_y) - savings_ut ) return euler