예제 #1
0
def Steady_State(guesses, params):
    '''
    Parameters: Steady state distribution of capital guess as array
                size 2*S*J

    Returns:    Array of 2*S*J Euler equation errors
    '''
    chi_b = np.tile(np.array(params[:J]).reshape(1, J), (S, 1))
    chi_n = np.array(params[J:])
    K_guess = guesses[0:S * J].reshape((S, J))
    B = (K_guess * omega_SS * mort_rate.reshape(S, 1)).sum(0)
    K = (omega_SS * K_guess).sum()
    L_guess = guesses[S * J:-1].reshape((S, J))
    L = get_L(e, L_guess)
    Y = get_Y(K, L)
    w = get_w(Y, L)
    r = get_r(Y, K)
    BQ = (1 + r) * B
    K1 = np.array(list(np.zeros(J).reshape(1, J)) + list(K_guess[:-2, :]))
    K2 = K_guess[:-1, :]
    K3 = K_guess[1:, :]
    K1_2 = np.array(list(np.zeros(J).reshape(1, J)) + list(K_guess[:-1, :]))
    K2_2 = K_guess
    factor = guesses[-1]
    taulump = tax.tax_lump(r, K1_2, w, e, L_guess, BQ, bin_weights, factor,
                           omega_SS)
    error1 = Euler1(w, r, e, L_guess, K1, K2, K3, BQ, factor, taulump, chi_b)
    error2 = Euler2(w, r, e, L_guess, K1_2, K2_2, BQ, factor, taulump, chi_n)
    error3 = Euler3(w, r, e, L_guess, K_guess, BQ, factor, chi_b, taulump)
    avI = ((r * K1_2 + w * e * L_guess) * omega_SS).sum()
    error4 = [mean_income - factor * avI]
    # Check and punish constraint violations
    mask1 = L_guess < 0
    error2[mask1] += 1e9
    mask2 = L_guess > ltilde
    error2[mask2] += 1e9
    if K_guess.sum() <= 0:
        error1 += 1e9
    tax1 = tax.total_taxes_SS(r, K1_2, w, e, L_guess, BQ, bin_weights, factor,
                              taulump)
    cons = get_cons(r, K1_2, w, e, L_guess, BQ.reshape(1, J), bin_weights,
                    K2_2, g_y, tax1)
    mask3 = cons < 0
    error2[mask3] += 1e9
    mask4 = K_guess[:-1] <= 0
    error1[mask4] += 1e9
    # print np.abs(np.array(list(error1.flatten()) + list(
    #     error2.flatten()) + list(error3.flatten()) + error4)).max()
    return list(error1.flatten()) + list(error2.flatten()) + list(
        error3.flatten()) + error4
예제 #2
0
파일: SS.py 프로젝트: talumbau/dynamic
def Steady_State(guesses, params):
    '''
    Parameters: Steady state distribution of capital guess as array
                size 2*S*J

    Returns:    Array of 2*S*J Euler equation errors
    '''
    chi_b = np.tile(np.array(params[:J]).reshape(1, J), (S, 1))
    chi_n = np.array(params[J:])
    b_guess = guesses[0: S * J].reshape((S, J))
    B = (b_guess * omega_SS * rho.reshape(S, 1)).sum(0)
    K = (omega_SS * b_guess).sum()
    n_guess = guesses[S * J:-1].reshape((S, J))
    L = get_L(e, n_guess)
    Y = get_Y(K, L)
    w = get_w(Y, L)
    r = get_r(Y, K)
    BQ = (1 + r) * B
    b1 = np.array(list(np.zeros(J).reshape(1, J)) + list(b_guess[:-2, :]))
    b2 = b_guess[:-1, :]
    b3 = b_guess[1:, :]
    b1_2 = np.array(list(np.zeros(J).reshape(1, J)) + list(b_guess[:-1, :]))
    b2_2 = b_guess
    factor = guesses[-1]
    T_H = tax.tax_lump(r, b1_2, w, e, n_guess, BQ, lambdas, factor, omega_SS)
    error1 = Euler1(w, r, e, n_guess, b1, b2, b3, BQ, factor, T_H, chi_b)
    error2 = Euler2(w, r, e, n_guess, b1_2, b2_2, BQ, factor, T_H, chi_n)
    error3 = Euler3(w, r, e, n_guess, b_guess, BQ, factor, chi_b, T_H)
    average_income_model = ((r * b1_2 + w * e * n_guess) * omega_SS).sum()
    error4 = [mean_income_data - factor * average_income_model]
    # Check and punish constraint violations
    mask1 = n_guess < 0
    error2[mask1] += 1e9
    mask2 = n_guess > ltilde
    error2[mask2] += 1e9
    if b_guess.sum() <= 0:
        error1 += 1e9
    tax1 = tax.total_taxes_SS(r, b1_2, w, e, n_guess, BQ, lambdas, factor, T_H)
    cons = get_cons(r, b1_2, w, e, n_guess, BQ.reshape(1, J), lambdas, b2_2, g_y, tax1)
    mask3 = cons < 0
    error2[mask3] += 1e9
    mask4 = b_guess[:-1] <= 0
    error1[mask4] += 1e9
    print np.abs(np.array(list(error1.flatten()) + list(
        error2.flatten()) + list(error3.flatten()) + error4)).max()
    return list(error1.flatten()) + list(
        error2.flatten()) + list(error3.flatten()) + error4
예제 #3
0
def Steady_State(guesses, params):
    '''
    Parameters: Steady state distribution of capital guess as array
                size 2*S*J

    Returns:    Array of 2*S*J Euler equation errors
    '''
    chi_b = np.tile(np.array(params[:J]).reshape(1, J), (S, 1))
    chi_n = np.array(params[J:])
    K_guess = guesses[0: S * J].reshape((S, J))
    B = (K_guess * omega_SS * mort_rate.reshape(S, 1)).sum(0)
    K = (omega_SS * K_guess).sum()
    L_guess = guesses[S * J:-1].reshape((S, J))
    L = get_L(e, L_guess)
    Y = get_Y(K, L)
    w = get_w(Y, L)
    r = get_r(Y, K)
    BQ = (1 + r) * B
    K1 = np.array(list(np.zeros(J).reshape(1, J)) + list(K_guess[:-2, :]))
    K2 = K_guess[:-1, :]
    K3 = K_guess[1:, :]
    K1_2 = np.array(list(np.zeros(J).reshape(1, J)) + list(K_guess[:-1, :]))
    K2_2 = K_guess
    factor = guesses[-1]
    taulump = tax.tax_lump(r, K1_2, w, e, L_guess, BQ, bin_weights, factor, omega_SS)
    error1 = Euler1(w, r, e, L_guess, K1, K2, K3, BQ, factor, taulump, chi_b)
    error2 = Euler2(w, r, e, L_guess, K1_2, K2_2, BQ, factor, taulump, chi_n)
    error3 = Euler3(w, r, e, L_guess, K_guess, BQ, factor, chi_b, taulump)
    avI = ((r * K1_2 + w * e * L_guess) * omega_SS).sum()
    error4 = [mean_income - factor * avI]
    # Check and punish constraint violations
    mask1 = L_guess < 0
    error2[mask1] += 1e9
    mask2 = L_guess > ltilde
    error2[mask2] += 1e9
    if K_guess.sum() <= 0:
        error1 += 1e9
    tax1 = tax.total_taxes_SS(r, K1_2, w, e, L_guess, BQ, bin_weights, factor, taulump)
    cons = get_cons(r, K1_2, w, e, L_guess, BQ.reshape(1, J), bin_weights, K2_2, g_y, tax1)
    mask3 = cons < 0
    error2[mask3] += 1e9
    mask4 = K_guess[:-1] <= 0
    error1[mask4] += 1e9
    # print np.abs(np.array(list(error1.flatten()) + list(
    #     error2.flatten()) + list(error3.flatten()) + error4)).max()
    return list(error1.flatten()) + list(
        error2.flatten()) + list(error3.flatten()) + error4
예제 #4
0
파일: SS.py 프로젝트: talumbau/dynamic
    bssmat = solutions[0:(S-1) * J].reshape(S-1, J)
    BQ = solutions[(S-1)*J:S*J]
    Bss = (np.array(list(bssmat) + list(BQ.reshape(1, J))).reshape(
        S, J) * omega_SS * rho.reshape(S, 1)).sum(0)
    bssmat2 = np.array(list(np.zeros(J).reshape(1, J)) + list(bssmat))
    bssmat3 = np.array(list(bssmat) + list(BQ.reshape(1, J)))
    Kss = (omega_SS[:-1, :] * bssmat).sum() + (omega_SS[-1, :]*BQ).sum()
    nssmat = solutions[S * J:-1].reshape(S, J)
    Lss = get_L(e, nssmat)
    Yss = get_Y(Kss, Lss)
    wss = get_w(Yss, Lss)
    rss = get_r(Yss, Kss)
    b1_2 = np.array(list(np.zeros(J).reshape((1, J))) + list(bssmat))
    factor_ss = solutions[-1]
    BQ = Bss * (1+rss)
    T_Hss = tax.tax_lump(rss, bssmat2, wss, e, nssmat, BQ, lambdas, factor_ss, omega_SS)
    taxss = tax.total_taxes_SS(rss, bssmat2, wss, e, nssmat, BQ, lambdas, factor_ss, T_Hss)
    cssmat = get_cons(rss, bssmat2, wss, e, nssmat, BQ.reshape(1, J), lambdas.reshape(1, J), bssmat3, g_y, taxss)

    constraint_checker(bssmat, nssmat, cssmat)

    '''
    ------------------------------------------------------------------------
    Generate variables for graphs
    ------------------------------------------------------------------------
    b1          = (S-1)xJ array of bssmat in period t-1
    b2          = copy of bssmat
    b3          = (S-1)xJ array of bssmat in period t+1
    b1_2        = SxJ array of bssmat in period t
    b2_2        = SxJ array of bssmat in period t+1
    euler1      = euler errors from first euler equation
예제 #5
0
    Kssvec = Kssmat.sum(1)
    Kss = (omega_SS[:-1, :] * Kssmat).sum() + (omega_SS[-1, :] * BQ).sum()
    Kssavg = Kssvec.mean()
    Kssvec = np.array([0] + list(Kssvec))
    Lssmat = solutions[S * J:-1].reshape(S, J)
    Lssvec = Lssmat.sum(1)
    Lss = get_L(e, Lssmat)
    Lssavg = Lssvec.mean()
    Yss = get_Y(Kss, Lss)
    wss = get_w(Yss, Lss)
    rss = get_r(Yss, Kss)
    k1_2 = np.array(list(np.zeros(J).reshape((1, J))) + list(Kssmat))
    factor_ss = solutions[-1]
    B = Bss * (1 + rss)
    Tss = tax.tax_lump(rss, Kssmat2, wss, e, Lssmat, B, bin_weights, factor_ss,
                       omega_SS)
    taxss = tax.total_taxes_SS(rss, Kssmat2, wss, e, Lssmat, B, bin_weights,
                               factor_ss, Tss)
    cssmat = get_cons(rss, Kssmat2, wss, e,
                      Lssmat, (1 + rss) * B.reshape(1, J),
                      bin_weights.reshape(1, J), Kssmat3, g_y, taxss)

    constraint_checker(Kssmat, Lssmat, wss, rss, e, cssmat, BQ)
    '''
    ------------------------------------------------------------------------
    Generate variables for graphs
    ------------------------------------------------------------------------
    k1          = (S-1)xJ array of Kssmat in period t-1
    k2          = copy of Kssmat
    k3          = (S-1)xJ array of Kssmat in period t+1
    k1_2        = SxJ array of Kssmat in period t
예제 #6
0
    Kssvec = Kssmat.sum(1)
    Kss = (omega_SS[:-1, :] * Kssmat).sum() + (omega_SS[-1, :]*BQ).sum()
    Kssavg = Kssvec.mean()
    Kssvec = np.array([0]+list(Kssvec))
    Lssmat = solutions[S * J:-1].reshape(S, J)
    Lssvec = Lssmat.sum(1)
    Lss = get_L(e, Lssmat)
    Lssavg = Lssvec.mean()
    Yss = get_Y(Kss, Lss)
    wss = get_w(Yss, Lss)
    rss = get_r(Yss, Kss)
    k1_2 = np.array(list(np.zeros(J).reshape((1, J))) + list(Kssmat))
    factor_ss = solutions[-1]
    B = Bss * (1+rss)
    Tss = tax.tax_lump(rss, Kssmat2, wss, e, Lssmat, B, bin_weights, factor_ss, omega_SS)
    taxss = tax.total_taxes_SS(rss, Kssmat2, wss, e, Lssmat, B, bin_weights, factor_ss, Tss)
    cssmat = get_cons(rss, Kssmat2, wss, e, Lssmat, B.reshape(1, J), bin_weights.reshape(1, J), Kssmat3, g_y, taxss)

    constraint_checker(Kssmat, Lssmat, wss, rss, e, cssmat, BQ)

    '''
    ------------------------------------------------------------------------
    Generate variables for graphs
    ------------------------------------------------------------------------
    k1          = (S-1)xJ array of Kssmat in period t-1
    k2          = copy of Kssmat
    k3          = (S-1)xJ array of Kssmat in period t+1
    k1_2        = SxJ array of Kssmat in period t
    k2_2        = SxJ array of Kssmat in period t+1
    euler1      = euler errors from first euler equation
예제 #7
0
if TPI_initial_run:
    initial_K = np.array(list(Kssmat) + list(BQ.reshape(1, J)))
    initial_L = Lssmat
else:
    initial_K = Kssmat_init
    initial_L = Lssmat_init
K0 = (omega_stationary[0] * initial_K[:, :]).sum()
K1_2init = np.array(list(np.zeros(J).reshape(1, J)) + list(initial_K[:-1]))
K2_2init = initial_K
L0 = get_L(e, initial_L)
Y0 = get_Y(K0, L0)
w0 = get_w(Y0, L0)
r0 = get_r(Y0, K0)
B0 = (initial_K * omega_stationary[0] * mort_rate.reshape(S, 1)).sum(0)
tau_lump_0 = tax.tax_lump(r0, K1_2init, w0, e, initial_L, B0, bin_weights,
                          factor_ss, omega_stationary[0])
tax0 = tax.total_taxes_SS(r0, K1_2init, w0, e, initial_L, B0, bin_weights,
                          factor_ss, tau_lump_0)
c0 = get_cons(r0, K1_2init, w0, e, initial_L, (1 + r0) * Bss.reshape(1, J),
              bin_weights.reshape(1, J), K2_2init, g_y, tax0)
constraint_checker1(initial_K[:-1], initial_L, w0, r0, e, c0, B0)
'''
------------------------------------------------------------------------
Solve for equilibrium transition path by TPI
------------------------------------------------------------------------
Kinit        = 1 x T+S vector, initial time path of aggregate capital
               stock
Linit        = 1 x T+S vector, initial time path of aggregate labor
               demand. This is just equal to a 1 x T+S vector of Lss
               because labor is supplied inelastically
Yinit        = 1 x T+S vector, initial time path of aggregate output
예제 #8
0
if TPI_initial_run:
    initial_K = np.array(list(Kssmat) + list(BQ.reshape(1, J)))
    initial_L = Lssmat
else:
    initial_K = Kssmat_init
    initial_L = Lssmat_init
K0 = (omega_stationary[0] * initial_K[:, :]).sum()
K1_2init = np.array(list(np.zeros(J).reshape(1, J)) + list(initial_K[:-1]))
K2_2init = initial_K
L0 = get_L(e, initial_L)
Y0 = get_Y(K0, L0)
w0 = get_w(Y0, L0)
r0 = get_r(Y0, K0)
B0 = (initial_K * omega_stationary[0] * mort_rate.reshape(S, 1)).sum(0)
tau_lump_0 = tax.tax_lump(r0, K1_2init, w0, e, initial_L, B0, bin_weights, factor_ss, omega_stationary[0])
tax0 = tax.total_taxes_SS(r0, K1_2init, w0, e, initial_L, B0, bin_weights, factor_ss, tau_lump_0)
c0 = get_cons(
    r0, K1_2init, w0, e, initial_L, (1 + r0) * Bss.reshape(1, J), bin_weights.reshape(1, J), K2_2init, g_y, tax0
)
constraint_checker1(initial_K[:-1], initial_L, w0, r0, e, c0, B0)

"""
------------------------------------------------------------------------
Solve for equilibrium transition path by TPI
------------------------------------------------------------------------
Kinit        = 1 x T+S vector, initial time path of aggregate capital
               stock
Linit        = 1 x T+S vector, initial time path of aggregate labor
               demand. This is just equal to a 1 x T+S vector of Lss
               because labor is supplied inelastically
예제 #9
0
파일: SS_test.py 프로젝트: talumbau/dynamic
def Steady_State(guesses, params):
    '''
    Parameters: Steady state interest rate, wage rate, distribution of bequests
                government transfers  

    Returns:    Array of 2*S*J Euler equation errors
    '''
    
    
    b_guess_init = np.ones((S, J)) * .01 # should be better way to update these after run for first time...
    n_guess_init = np.ones((S, J)) * .99 * ltilde
    
    r = guesses[0]
    w = guesses[1]
    bq =guesses[2: 1 * J].reshape((1, J))
    T_H = guesses[-1]
    
    guesses =  list(b_guess_init.flatten()) + list(n_guess_init.flatten())  
    
    HH_solve_X2 = lambda x: HH_solve(x, r, w, bq, T_H, final_chi_b_params)
    b, n , c = opt.fsolve(HH_solve_X2, guesses, xtol=1e-13)
    
    Steady_State_X2 = lambda x: Steady_State(x, final_chi_b_params)
    
    solutions = opt.fsolve(Steady_State_X2, guesses, xtol=1e-13)
    
    chi_b = np.tile(np.array(params[:J]).reshape(1, J), (S, 1))
    chi_n = np.array(params[J:])
    r_guess = guesses[0]
    w_guess = guesses[1]
    bq_guess =guesses[2: 1 * J].reshape((1, J))
    T_H_guess = guesses[-1]
    
    b_guess = guesses[0: S * J].reshape((S, J))
    B = (b_guess * omega_SS * rho.reshape(S, 1)).sum(0)
    K = (omega_SS * b_guess).sum()
    n_guess = guesses[S * J:-1].reshape((S, J))
    L = hh_focs.get_L(e, n_guess, omega_SS)
    Y = hh_focs.get_Y(K, L)
    w = hh_focs.get_w(Y, L)
    r = hh_focs.get_r(Y, K)
    BQ = (1 + r) * B
    b1 = np.array(list(np.zeros(J).reshape(1, J)) + list(b_guess[:-2, :]))
    b2 = b_guess[:-1, :]
    b3 = b_guess[1:, :]
    b1_2 = np.array(list(np.zeros(J).reshape(1, J)) + list(b_guess[:-1, :]))
    b2_2 = b_guess
    factor = guesses[-1]
    T_H = tax.tax_lump(r, b1_2, w, e, n_guess, BQ, lambdas, factor, omega_SS)
    error1 = hh_focs.Euler1(w, r, e, n_guess, b1, b2, b3, BQ, factor, T_H, chi_b, rho)
    error2 = hh_focs.Euler2(w, r, e, n_guess, b1_2, b2_2, BQ, factor, T_H, chi_n)
    error3 = hh_focs.Euler3(w, r, e, n_guess, b_guess, BQ, factor, chi_b, T_H)
    average_income_model = ((r * b1_2 + w * e * n_guess) * omega_SS).sum()
    error4 = [mean_income_data - factor * average_income_model]
    # Check and punish constraint violations
    mask1 = n_guess < 0
    error2[mask1] += 1e9
    mask2 = n_guess > ltilde
    error2[mask2] += 1e9
    if b_guess.sum() <= 0:
        error1 += 1e9
    tax1 = tax.total_taxes_SS(r, b1_2, w, e, n_guess, BQ, lambdas, factor, T_H)
    cons = hh_focs.get_cons(r, b1_2, w, e, n_guess, BQ.reshape(1, J), lambdas, b2_2, g_y, tax1)
    mask3 = cons < 0
    error2[mask3] += 1e9
    mask4 = b_guess[:-1] <= 0
    error1[mask4] += 1e9
    # print np.abs(np.array(list(error1.flatten()) + list(
    #     error2.flatten()) + list(error3.flatten()) + error4)).max()
    return list(error1.flatten()) + list(
        error2.flatten()) + list(error3.flatten()) + error4