def test_eval_with_fortran_order(): import numpy as np C_F = np.random.random((50, 50)).T C = C_F.copy() print(C.flags) print(C_F.flags) p = np.random.random((10, 2)) p_F = p.T.copy().T from interpolation.splines import eval_linear out_F_C = eval_linear(((0.0, 1.0, 48), (0.0, 1.0, 48)), C_F, p) out_C_C = eval_linear(((0.0, 1.0, 48), (0.0, 1.0, 48)), C, p) out_F_F = eval_linear(((0.0, 1.0, 48), (0.0, 1.0, 48)), C_F, p_F) out_C_F = eval_linear(((0.0, 1.0, 48), (0.0, 1.0, 48)), C, p_F) assert np.array_equal(out_F_C, out_C_C) assert np.array_equal(out_F_C, out_F_F) assert np.array_equal(out_F_C, out_C_F)
def objective_cap(c, rho, sigma, y): """ The right hand side of the pricing operator """ # First turn w into a function via interpolation #print(c) sigma_func = [lambda points: eval_linear(gridI, sigma[:,0].reshape(grid_size, grid_size),points),\ lambda points: eval_linear(gridI, sigma[:,1].reshape(grid_size, grid_size),points)] rho_func = [lambda points: eval_linear(gridI, rho[:,0].reshape(grid_size, grid_size), points),\ lambda points: eval_linear(gridI, rho[:,1].reshape(grid_size, grid_size), points)] x_prime = (1 - delta_storage) * (y[1] - p_inv( demand_shocks[int(y[2])], rho_func[int(y[2])](y[0:2]))) + shock * c I = c - (1 - delta_cap) * y[0] c_col = x_prime.copy() c_col.fill(c) prime_xc = np.column_stack((c_col, x_prime)) I_prime = [(sigma_func[0](prime_xc) - (1 - delta_cap) * c), (sigma_func[1](prime_xc) - (1 - delta_cap) * c)] #k_prime= x_prime.copy() #k_prime.fill(sigma_func[int(y[2])](y[0:2])) prime = np.column_stack((c_col, x_prime)) integrand = demand_P[0]*(rho_func[0](prime)*shock\ +(1-delta_cap)*(2*phi_prime(I_prime[0]**2)*I_prime[0] +1))\ + demand_P[1]*(rho_func[1](prime)*shock\ +(1-delta_cap)*(2*phi_prime(I_prime[1]**2)*I_prime[1] +1)) Eprof = beta * np.mean(integrand) #print(np.max([beta*Eprof, (2*phi_prime((-(1-delta_cap)*y[0])**2))*(-(1-delta_cap)*y[0])]) - 2*phi_prime(I**2)*I) return np.max([ beta * Eprof, (2 * phi_prime( (-(1 - delta_cap) * y[0])**2)) * (-(1 - delta_cap) * y[0]) ]) - 2 * phi_prime(I**2) * I
def gen_VPi(points, Age, account_ind,\ E_ind, alpha_ind,beta_ind,\ pi_ushock, v_ushock,Xi_cov,Xi_copi): """ Genrates voluntary contribution risk prob""" xi_V_vals = eval_linear(X_cont_W, Xi_cov[Age][account_ind,E_ind,alpha_ind,beta_ind,:],\ points) xi_V_vals = xi_V_vals - max(xi_V_vals) prob_v = np.exp(xi_V_vals) / np.sum(np.exp(xi_V_vals)) #pick a random draw for the voluntary contribution (index in the vol.cont grid) V_ind = np.arange(len(V))[np.searchsorted(np.cumsum(prob_v), v_ushock)] v = V[V_ind] #pull our probabiltiy of risk share matrix for this cont state xi_Pi_vals = eval_linear(X_cont_W, Xi_copi[Age][account_ind,E_ind,alpha_ind,beta_ind,V_ind,:],\ points) xi_Pi_vals = xi_Pi_vals - max(xi_Pi_vals) prob_Pi = np.exp(xi_Pi_vals) / np.sum(np.exp(xi_Pi_vals)) Pi_ind = np.arange(len(Pi))[np.searchsorted(np.cumsum(prob_Pi), pi_ushock)] pi = Pi[Pi_ind] return V_ind, v, Pi_ind, pi
def objective_price(c, rho, sigma, y): """ The right hand side of the pricing operator """ # First turn w into a function via interpolation sigma_func = lambda x, z: eval_linear( gridI, sigma[:, int(y[2])].reshape(grid_size, grid_size), np.array([x, z])) rho_func = [lambda points: eval_linear(gridI, rho[:,0].reshape(grid_size, grid_size), points), \ lambda points: eval_linear(gridI, rho[:,1].reshape(grid_size, grid_size), points)] x_prime = (1 - delta_storage) * (y[1] - p_inv( demand_shocks[int(int(y[2]))], c)) + shock * sigma_func( y[0], y[1]) k_prime = x_prime.copy() k_prime.fill(sigma_func(y[0], y[1])) prime = np.column_stack((k_prime, x_prime)) integrand = demand_P[0]*rho_func[0](prime)\ +demand_P[1]*rho_func[1](prime) Eprice = np.mean(integrand) if S_bar_flag == 1: return np.min([ np.max([beta * Eprice, p(demand_shocks[int(y[2])], y[1])]), p(demand_shocks[int(y[2])], y[1] - S_bar) ]) - c elif S_bar_flag == 0: return np.max([beta * Eprice, p(demand_shocks[int(y[2])], y[1])]) - c
def interpolate(self, spin, bands, kpoints): v = np.concatenate([np.asarray(bands)[:, None], np.asarray(kpoints)], axis=1) if interpolation: from interpolation.splines import eval_linear from interpolation.splines import extrap_options as xto grid, data = self.interpolators[spin] if np.iscomplexobj(data): # only allows interpolating floats, so have to separate real and imag interp_data = np.empty((len(v),) + self.data_shape, dtype=np.complex) interp_data.real = eval_linear(grid, data.real, v, xto.LINEAR).reshape( -1, *self.data_shape ) interp_data.imag = eval_linear(grid, data.imag, v, xto.LINEAR).reshape( -1, *self.data_shape ) else: interp_data = eval_linear(grid, data, v, xto.LINEAR).reshape( -1, *self.data_shape ) else: interp_data = self.interpolators[spin](v) return interp_data
def _get_overlap_ncl(grid, data, points, n_coeffs): initial = np.zeros((n_coeffs, 2), dtype=np.complex64) initial.real[:] = eval_linear(grid, data.real, points[0], xto.LINEAR).reshape((n_coeffs, 2)) initial.imag[:] = eval_linear(grid, data.imag, points[0], xto.LINEAR).reshape((n_coeffs, 2)) initial /= np.linalg.norm(initial) initial[:] = np.conj(initial) res = np.zeros(points.shape[0] - 1) final = np.zeros((n_coeffs, 2), dtype=np.complex64) for i in range(1, points.shape[0]): final.real[:] = eval_linear(grid, data.real, points[i], xto.LINEAR).reshape((n_coeffs, 2)) final.imag[:] = eval_linear(grid, data.imag, points[i], xto.LINEAR).reshape((n_coeffs, 2)) final /= np.linalg.norm(final) sum_ = 0j for j in range(final.shape[0]): sum_ += initial[j, 0] * final[j, 0] + initial[j, 1] * final[j, 1] res[i - 1] = abs(sum_)**2 return res
def get_overlap(self, spin, band_a, kpoint_a, band_b, kpoint_b): # k-points should be in fractional kpoint_a = np.asarray(kpoint_a) kpoint_b = np.asarray(kpoint_b) v1 = np.array([[band_a] + kpoint_a.tolist()]) single_overlap = False if isinstance(band_b, numeric_types): # only one band index given if len(kpoint_b.shape) > 1: # multiple k-point indices given band_b = np.array([band_b] * len(kpoint_b)) else: band_b = np.array([band_b]) kpoint_b = [kpoint_b] single_overlap = True else: band_b = np.asarray(band_b) # v2 now has shape of (nkpoints_b, 4) v2 = np.concatenate([band_b[:, None], kpoint_b], axis=1) # get a big array of all the k-points to interpolate all_v = np.vstack([v1, v2]) # get the interpolate projections for the k-points; p1 is the projections for # kpoint_a, p2 is a list of projections for the kpoint_b if eval_linear: grid, coeffs = self.interpolators[spin] # only allows interpolating floats, so have to separate real and imag parts p1_real, *p2_real = eval_linear(grid, coeffs.real, all_v, xto.LINEAR) p1_imag, *p2_imag = eval_linear(grid, coeffs.imag, all_v, xto.LINEAR) p1 = p1_real + 1j * np.asarray(p1_imag) p2 = p2_real + 1j * np.asarray(p2_imag) else: p1, *p2 = self.interpolators[spin](all_v) p1 = np.asarray(p1) / np.linalg.norm(p1) p2 = np.asarray(p2) / np.linalg.norm(p2, axis=-1)[:, None] braket = np.abs(np.dot(np.conj(p1), p2.T)) overlap = braket**2 if single_overlap: return overlap[0] else: return overlap
def pfi_raw(func, xfromv, pars, args, grid_shape, grid, gp, eps_max, it_max, init_pfunc, x0=None, use_x0=True, verbose=False): ndim = len(grid) eps = 1e9 it_cnt = 0 xe = xfromv( eval_linear(grid, init_pfunc, init_pfunc.reshape(-1, ndim), xto.LINEAR)) values = func(pars, gp, xe, args=args)[0] svalues = values.reshape(grid_shape) if use_x0: z_old = eval_linear(grid, svalues, x0, xto.LINEAR)[0] while eps > eps_max or eps_max < 0: it_cnt += 1 values_old = values.copy() values = svalues.reshape(-1, 3) xe = xfromv(eval_linear(grid, svalues, values, xto.LINEAR)) values = func(pars, gp, xe, args=args)[0] # values = np.maximum(values, -1e2) # values = np.minimum(values, 1e2) svalues = values.reshape(grid_shape) if use_x0: z = eval_linear(grid, svalues, x0, xto.LINEAR)[0] eps = np.abs(z - z_old) z_old = z else: eps = np.linalg.norm(values - values_old) if verbose: print(it_cnt, '- eps:', eps) if it_cnt == it_max: break return values.reshape(grid_shape), it_cnt, eps
def _get_overlap(grid, data, points, n_coeffs): initial = np.zeros(n_coeffs, dtype=np.complex64) initial.real[:] = eval_linear(grid, data.real, points[0], xto.LINEAR) initial.imag[:] = eval_linear(grid, data.imag, points[0], xto.LINEAR) initial /= np.linalg.norm(initial) initial[:] = np.conj(initial) res = np.zeros(points.shape[0] - 1) final = np.zeros(n_coeffs, dtype=np.complex64) for i in range(1, points.shape[0]): final.real[:] = eval_linear(grid, data.real, points[i], xto.LINEAR) final.imag[:] = eval_linear(grid, data.imag, points[i], xto.LINEAR) final /= np.linalg.norm(final) res[i - 1] = np.abs(np.dot(final, initial))**2 return res
def eval_s(itp: object, exo_grid: EmptyGrid, endo_grid: CartesianGrid, interp_type: Linear, s: object): from interpolation.splines import eval_linear assert (s.ndim == 2) coeffs = itp.coefficients gg = endo_grid.__numba_repr__() return eval_linear(gg, coeffs, s)
def get_coefficients(self, spin, bands, kpoints): v = np.concatenate([np.asarray(bands)[:, None], np.asarray(kpoints)], axis=1) if eval_linear: grid, coeffs = self.interpolators[spin] # only allows interpolating floats, so have to separate real and imag parts real_part = eval_linear(grid, coeffs.real, v, xto.LINEAR) imag_part = eval_linear(grid, coeffs.imag, v, xto.LINEAR) interp_coeffs = real_part + 1j * imag_part else: interp_coeffs = self.interpolators[spin](v) # need to renormalize coefficients return interp_coeffs / np.linalg.norm(interp_coeffs, axis=-1)[:, None]
def drfut(i, ss): if iid_process: i = 0 m = dp.node(i) l_ = lb(m, ss, p) u_ = ub(m, ss, p) x = eval_linear((sa0[i, :, 0], ), xa0[i, :, 0], ss)[:, None] x = np.minimum(x, u_) x = np.maximum(x, l_) return x
def eval_is(itp, exo_grid: UnstructuredGrid, endo_grid: CartesianGrid, interp_type: Linear, i, s): from interpolation.splines import eval_linear assert(s.ndim==2) grid = endo_grid # one single CartesianGrid coeffs = itp.coefficients[i] d = len(grid.n) gg = tuple( [(grid.min[i], grid.max[i], grid.n[i]) for i in range(d)] ) return eval_linear(gg, coeffs, s)
def eval_ms(itp, exo_grid: CartesianGrid, endo_grid: CartesianGrid, interp_type: Linear, m, s): assert(m.ndim==s.ndim==2) grid = cat_grids(exo_grid, endo_grid) # one single CartesianGrid coeffs = itp.coefficients d = len(grid.n) gg = tuple( [(grid.min[i], grid.max[i], grid.n[i]) for i in range(d)] ) from interpolation.splines import eval_linear x = np.concatenate([m, s], axis=1) return eval_linear(gg, coeffs, x)
def eval_ms(itp: object, exo_grid: CartesianGrid, endo_grid: CartesianGrid, interp_type: Linear, m: object, s: object): assert(m.ndim==s.ndim==2) grid = exo_grid + endo_grid # one single CartesianGrid coeffs = itp.coefficients gg = grid.__numba_repr__() from interpolation.splines import eval_linear x = np.concatenate([m, s], axis=1) return eval_linear(gg, coeffs, x)
def eval_is( itp: object, exo_grid: UnstructuredGrid, endo_grid: CartesianGrid, interp_type: Linear, i: object, s: object, ): from interpolation.splines import eval_linear assert s.ndim == 2 coeffs = itp.coefficients[i] gg = endo_grid.__numba_repr__() return eval_linear(gg, coeffs, s)
def topolar(car_img, rsamples=0, thsamples=180, intmethod='linear'): #BUG in cubic if rsamples == 0: rsamples = car_img.shape[0] // 2 if len(car_img.shape) == 2: cimg = car_img[:, :, None] elif len(car_img.shape) == 3: cimg = car_img else: print('channel not 2/3') return SUBTH = 360 / thsamples height, width, channel = cimg.shape grid = UCGrid((0, cimg.shape[1] - 1, cimg.shape[1]), (0, cimg.shape[0] - 1, cimg.shape[0])) # filter values if intmethod == 'cubic': coeffs = filter_cubic(grid, cimg) rth = np.zeros((thsamples, rsamples, channel)) for th in range(thsamples): for r in range(rsamples): inty = cimg.shape[0] // 2 + r * math.sin( th * SUBTH / 180 * math.pi) intx = cimg.shape[1] // 2 + r * math.cos( th * SUBTH / 180 * math.pi) if intx >= cimg.shape[1] - 1 or inty >= cimg.shape[0] - 1: rth[th, r] = 0 elif intx < 0 or inty < 0: rth[th, r] = 0 else: if intmethod == 'cubic': rth[th, r] = eval_cubic(grid, coeffs, np.array([inty, intx])) elif intmethod == 'linear': rth[th, r] = eval_linear(grid, cimg, np.array([inty, intx])) if len(car_img.shape) == 2: return rth[:, :, 0] else: return rth
def tocart(polar_img, rheight=0, rwidth=0, intmethod='linear'): if rheight == 0 or rwidth == 0: rheight = polar_img.shape[1] * 2 rwidth = polar_img.shape[1] * 2 #transfer to cartesian based if len(polar_img.shape) == 2: cimg = polar_img[:, :, None] elif len(polar_img.shape) == 3: cimg = polar_img else: print('channel not 2/3') return rth, rr, rchannel = cimg.shape SUBTH = 360 / rth grid = UCGrid((0, cimg.shape[0] - 1, cimg.shape[0]), (0, cimg.shape[1] - 1, cimg.shape[1])) test_out_c = np.zeros((rheight, rwidth, rchannel)) for h in range(rheight): for w in range(rwidth): hy = h - rheight // 2 wx = w - rwidth // 2 intradius = int(np.sqrt(hy * hy + wx * wx)) cth = math.atan2(hy, wx) / np.pi * 180 if cth < 0: intth = (360 + cth) else: intth = (cth) intth /= SUBTH if intth > cimg.shape[0] - 1: intth = cimg.shape[0] - 1 #print(intradius,intth) if intradius >= cimg.shape[1]: test_out_c[h, w] = 0 else: test_out_c[h, w] = eval_linear(grid, cimg, np.array([intth, intradius])) if len(polar_img.shape) == 2: return test_out_c[:, :, 0] else: return test_out_c
def get_mrta_factor(self, spin, band_a, kpoint_a, band_b, kpoint_b): # k-points should be in fractional kpoint_a = np.asarray(kpoint_a) kpoint_b = np.asarray(kpoint_b) v1 = np.array([[band_a] + kpoint_a.tolist()]) single_factor = False if isinstance(band_b, numeric_types): # only one band index given if len(kpoint_b.shape) > 1: # multiple k-point indices given band_b = np.array([band_b] * len(kpoint_b)) else: band_b = np.array([band_b]) kpoint_b = [kpoint_b] single_factor = True else: band_b = np.asarray(band_b) # v2 now has shape of (nkpoints_b, 4) v2 = np.concatenate([band_b[:, None], kpoint_b], axis=1) # get a big array of all the k-points to interpolate all_v = np.vstack([v1, v2]) # get the interpolate projections for the k-points; p1 is the projections for # kpoint_a, p2 is a list of projections for the kpoint_b if eval_linear: p1, *p2 = eval_linear(*self.interpolators[spin], all_v, xto.LINEAR) else: p1, *p2 = self.interpolators[spin](all_v) factor = 1 - np.dot(p1, np.asarray(p2).T) / np.linalg.norm(p1) ** 2 if single_factor: return factor[0] else: return factor
def pfi_determinisic(func, xfromv, pars, args, grid_shape, grid, gp, eps_max, it_max): ndim = len(grid) eps = 1e9 it_cnt = 0 values = func(pars, gp, 0., args=args)[0] while eps > eps_max: it_cnt += 1 values_old = values.copy() svalues = values.reshape(grid_shape) xe = xfromv(eval_linear(grid, svalues, values, xto.LINEAR)) values = func(pars, gp, xe, args=args)[0] eps = np.linalg.norm(values - values_old) if it_cnt == it_max: break return values.reshape(grid_shape), it_cnt, eps
def seriesgen(age,wave_length, W, beta_hat_ts, alpha_hat_ts,V_ushock_ts, Pi_ushock_ts,DBshock,\ a_noadj, etas_noadj, H_adj, a_adj, c_adj, Xi_cov,Xi_copi,policy_VF): """ Returns a time series of one agent to age in baseline year and age in baseline year + wave_len """ length = int(age + wave_length + 2) # generate sequences of shocks for this agent i # remeber start year is tzero. # we generate shocks such that TS_j[t] gives the value of # the shock at t TS_A, TS_A_1 = 0, 0 TS_H, TS_H_1 = 0, 0 TS_DC, TS_DC_1 = 0, 0 TS_C, TS_C_1 = 0, 0 TS_V, TS_V_1 = 0, 0 TS_PI, TS_PI_1 = 0, 0 TS_wage, TS_wage_1 = 0, 0 TS_hinv, TS_hinv_1 = 0, 0 adj_V, adj_V_1 = 0, 0 adj_pi, adj_pi_1 = 0, 0 P_h = np.zeros(length + 1) # generate sequence of house prices P_h[tzero] = 1 / ((1 + r_H)**(age - tzero)) for t in np.arange(tzero, len(P_h) - 1): P_h[t + 1] = (1 + r_H) * P_h[t] # initialize continuous points TS_A = 1e-5 TS_H = 1e-5 TS_DC = 1e-5 wave_data_14 = np.zeros(17) wave_data_10 = np.zeros(17) # generate time series of wage shocks, beta_hat and alpha_hat draws for this guy #DC_H= np.exp(r_h + lnrh_mc.simulate(ts_length = length)) # these need to be made deterministic #DC_L = np.exp(r_l + lnrl_mc.simulate(ts_length = length)) # these need to be made deterministic # get the initial value of the series and draw from account type #sigma_plan =.03 #disc_exog_ind = int(np.where((np.where(W[int(tzero)]== E)[0] \ # == X_disc_exog[:,0]) \ # & (X_disc_exog[:,1] == np.where(alpha_hat \ # == alpha_hat_ts[int(tzero)])[0]) \ # & (X_disc_exog[:,2] == np.where(beta_hat\ # == beta_hat_ts[int(tzero)])[0]))[0]) E_ind = int(W[tzero]) beta_ind = int(beta_hat_ts[tzero]) alpha_ind = int(alpha_hat_ts[tzero]) V_DC = eval_linear(X_cont_W, \ policy_VF[1,E_ind,alpha_ind,beta_ind,:], \ np.array([TS_A,TS_DC,TS_H, P_h[tzero]])) V_DB = eval_linear(X_cont_W, \ policy_VF[0,E_ind,alpha_ind,beta_ind,:], \ np.array([TS_A,TS_DC,TS_H, P_h[tzero]])) V_DC_scaled = ((V_DC - adj_p(tzero)) / sigma_plan) - max( ((V_DC - adj_p(tzero)) / sigma_plan), ((V_DB / sigma_plan))) V_DB_scaled = ((V_DB / sigma_plan)) - max( ((V_DC - adj_p(tzero)) / sigma_plan), ((V_DB / sigma_plan))) Prob_DC = np.exp(V_DC_scaled)/( np.exp(V_DB_scaled) \ + np.exp(V_DC_scaled ) ) account_ind = int( np.searchsorted(np.cumsum(np.array([1 - Prob_DC, Prob_DC])), DBshock)) for t in range(int(tzero), int(length) + 1): if t < R: #get the index for the labour shock E_ind = int(W[t]) beta_ind = int(beta_hat_ts[t]) alpha_ind = int(alpha_hat_ts[t]) E_val = E[int(W[t])] beta_val = beta_hat[int(beta_hat_ts[t])] alpha_val = alpha_hat[int(alpha_hat_ts[t])] #get continuous state index points = np.array([TS_A,TS_DC\ ,TS_H, P_h[t]]) #pull out the probability of voluntary contribution probability matrix for this cont state pi_ushock = Pi_ushock_ts[t] v_ushock = V_ushock_ts[t] args = (account_ind, E_ind, alpha_ind, beta_ind, pi_ushock, v_ushock, Xi_cov, Xi_copi) V_ind, v, Pi_ind, pi = gen_VPi(points, t - tzero, *args) #calculate wage for agent TS_wage = y(t, E[E_ind]) # total liquid wealth for non-adjuster wealth_no_adj = TS_A*(1+r)\ + (1-v -v_S -v_E)*TS_wage # next period DC assets (before returns) # (recall domain of policy functions from def of eval_policy_W) # DC_prime is DC assets at the end of t, before returns into t+1 DC_prime = TS_DC + (v + (v_S + v_E) * account_ind) * TS_wage h = TS_H * (1 - delta_housing) q = P_h[t] TS_DC_1 = (1+(1-pi)*r_l\ + pi*r_h )*DC_prime wealth_adj = wealth_no_adj + P_h[t] * h eta_func = etas_noadj[t-tzero][account_ind,\ E_ind,\ alpha_ind,\ beta_ind,\ Pi_ind,:] eta = eval_linear(X_cont_W,eta_func,\ np.array([wealth_no_adj,\ DC_prime,h,P_h[t]]),\ xto.NEAREST) if np.abs(eta) < 1: a_noadjust_func = a_noadj[t-tzero][account_ind,\ E_ind,\ alpha_ind,\ beta_ind,\ Pi_ind,:] h_prime = h TS_A_1 = eval_linear(X_cont_W,a_noadjust_func,\ np.array([wealth_no_adj,DC_prime,h,q]),\ xto.NEAREST) TS_C = max(1e-10,wealth_no_adj\ - TS_A_1) TS_H_1 = h else: a_prime_adj_func = a_adj[t-tzero][account_ind,\ E_ind,\ alpha_ind,\ beta_ind,\ Pi_ind,:] c_prime_adj_func = c_adj[t-tzero][account_ind,\ E_ind,\ alpha_ind,\ beta_ind,\ Pi_ind,:] H_adj_func = H_adj[t-tzero][account_ind,\ E_ind,\ alpha_ind,\ beta_ind,\ Pi_ind,:] TS_C = max(eval_linear(X_QH_W,\ c_prime_adj_func,\ np.array([DC_prime,q,\ wealth_adj]),xto.NEAREST), 1E-20) TS_H_1 = max(1e-20, eval_linear(X_QH_W,\ H_adj_func,\ np.array([DC_prime,q,\ wealth_adj]), xto.NEAREST)) TS_A_1 = max(1e-20, eval_linear(X_QH_W,\ a_prime_adj_func,\ np.array([DC_prime,q,\ wealth_adj]), xto.NEAREST)) TS_hinv = TS_H_1 - TS_H TS_PI = pi TS_V = v # if t not terminal, iterate forward if t == age: wave_data_10 = np.array([account_ind,age, TS_A*norm,\ TS_H*norm, TS_DC*norm, TS_C*norm, \ TS_wage*norm, TS_V, TS_V*TS_wage*norm, TS_PI, \ int(TS_hinv>0), int(TS_PI>.7), int(TS_V>0), \ alpha_hat_ts[age], beta_hat_ts[age],adj_V, adj_pi]) if t == age + wave_length: # we denote the age at wave_14 by thier age at 10 so they go in 2010 bucket age_wave_10 = age age14 = age + wave_length wave_data_14 = np.array([account_ind,age_wave_10, TS_A*norm,\ TS_H*norm, TS_DC*norm, TS_C*norm, \ TS_wage*norm, TS_V,TS_V*TS_wage*norm, TS_PI, \ int(TS_hinv>0), int(TS_PI>.7), int(TS_V>0), \ alpha_hat_ts[age14], beta_hat_ts[age14],adj_V, adj_pi]) TS_A = TS_A_1 TS_H = TS_H_1 TS_DC = TS_DC_1 return wave_data_10, wave_data_14
def core(i, t, coords, policy_C, policy_D, policy_S, policy_V): # translate state var and set up choice var X0, K0, H0, Ph0, Ps0, N0, A0 = grid_X[coords[0]], grid_K[ coords[1]], grid_H[coords[2]], grid_P[coords[3]], grid_P[ coords[4]], grid_N[coords[5]], grid_A[coords[6]] if (X0 == grid_X[0]) | ( (t >= 15) & (A0 == 0)): # after 2035, there will be sure SSB adjustment return (1, 1, 1, utility(X0, N0)) K0 = X0 * K0 # K from % to $ Ph0 = Ph0 * ((1 - (eta * eta)**t) / (1 - eta * eta))**0.5 Ps0 = Ps0 * ((1 - (eta * eta)**t) / (1 - eta * eta))**0.5 if (t >= T - 3) | (t == 71 - 65): if K0 == 0: grid_D = np.array([0]) else: grid_D = np.arange(21) / 20 grid_D = np.extract(grid_D >= rmd_pct[t], grid_D) grid_C = np.arange(1, 20) / 20 grid_S = np.arange(21) / 20 else: C_guess = policy_C[coords] D_guess = policy_D[coords] S_guess = policy_S[coords] grid_C = np.arange(max(.01, C_guess - .05), min(C_guess + .05, .99), .01) if K0 == 0: grid_D = np.array([0]) else: grid_D = np.arange(max(rmd_pct[t], D_guess - .05), min(D_guess + .05, 1.0), .01) # not optimal to withdraw less than RMD grid_S = np.arange(max(0, S_guess - .05), min(S_guess + .05, 1.0), .01) # SHOCKS re, perm_h, tran_h, perm_s, tran_s, ft = grid_re, grid_perm, grid_tran, grid_perm, grid_tran, grid_ft[ t] wgt_re, wgt_perm, wgt_tran = GQ_wgt, GQ_wgt, GQ_wgt wgt_ft = [1 - p_ft[t], p_ft[t]] if N0 == 1: sp, wgt_sp = np.array([0]), [1] elif N0 == 2: sp, wgt_sp = np.array([0, 1]), [1 - p_s[t], p_s[t]] if A0 == 0: adj, wgt_adj = np.array([0, 1]), [1 - p_SSadj[t], p_SSadj[t]] elif A0 == 1: adj, wgt_adj = np.array([1]), [1] # evaluate at mesh grid for shocks mesh_C, mesh_D, mesh_S, mesh_re, mesh_perm_h, mesh_tran_h, mesh_perm_s, mesh_tran_s, mesh_ft, mesh_sp, mesh_adj = np.meshgrid( grid_C, grid_D, grid_S, re, perm_h, tran_h, perm_s, tran_s, ft, sp, adj, indexing='ij') mesh_shape = [ grid_C.shape[0], grid_D.shape[0], grid_S.shape[0], re.shape[0], perm_h.shape[0], tran_h.shape[0], perm_s.shape[0], tran_s.shape[0], ft.shape[0], sp.shape[0], adj.shape[0] ] mesh_Ph1 = Ph0 * eta + mesh_perm_h mesh_Ps1 = Ps0 * eta + mesh_perm_s mesh_me_h = np.exp(me_mu_h[t] + me_sigma_h[t] * (mesh_Ph1 + mesh_tran_h)) mesh_me_s = np.exp(me_mu_s[t] + me_sigma_s[t] * (mesh_Ps1 + mesh_tran_s)) mesh_L0 = X0 - K0 + (K0 * mesh_D) * ( 1 - tax ) # comprehensive tax rule of SSB later (tax up to 50% or 85% of SSB based on combo inc) mesh_C = mesh_L0 * mesh_C mesh_L1 = mesh_L0 - mesh_C mesh_L1 *= (1 + (mesh_S * mesh_re + (1 - mesh_S) * rf - 1) * (1 - tax)) mesh_L1 += (-H_price[t + 1] * rent * (1 - H0) - mesh_me_h - mesh_me_s * N0 - mesh_ft + (Y_h + Y_s * mesh_sp) * (1 - mesh_adj * SSadj)) mesh_K1 = K0 * (1 - mesh_D) * (K_share[t] * mesh_re + (1 - K_share[t]) * rf) # if L1 < L_min (medicaid limit), withdraw K to fill; if not enough and own home, sell home; if still not enough, claim medicaid mesh_DD = np.clip(L_min - mesh_L1, 0, mesh_K1) mesh_K1 = mesh_K1 - mesh_DD mesh_L1 = mesh_L1 + mesh_DD mesh_H1 = np.ones_like(mesh_L1) * H0 if H0 == 1: mesh_sellhome = mesh_L1 < L_min mesh_sellhome = mesh_sellhome.astype(int) mesh_L1 += H_price[t + 1] * mesh_sellhome * (1 - tax) mesh_H1 = mesh_H1 - mesh_sellhome # new state var grid at next period mesh_X1 = mesh_L1 + mesh_K1 mesh_X1 = np.clip(mesh_X1, grid_X[0], grid_X[-1]) mesh_K1 = np.clip(mesh_K1 / mesh_X1, grid_K[0], grid_K[-1]) grid_P1 = grid_P * ((1 - (eta * eta)**(t + 1)) / (1 - eta * eta))**0.5 mesh_Ph1 = np.clip(mesh_Ph1, grid_P1[0], grid_P1[-1]) mesh_Ps1 = np.clip(mesh_Ps1, grid_P1[0], grid_P1[-1]) mesh_N1 = mesh_sp + 1 mesh_A1 = mesh_adj grid = CGrid(grid_X, grid_K, grid_H, grid_P1, grid_P1, grid_N, grid_A) values = policy_V points = np.stack([ mesh_X1.ravel(), mesh_K1.ravel(), mesh_H1.ravel(), mesh_Ph1.ravel(), mesh_Ps1.ravel(), mesh_N1.ravel(), mesh_A1.ravel() ], axis=-1) mesh_EV1 = eval_linear(grid, values, points).reshape(mesh_shape) mesh_EV1 = np.average(mesh_EV1, axis=(-1), weights=wgt_adj) mesh_EV1 = np.average(mesh_EV1, axis=(-1), weights=wgt_sp) mesh_EV1 = np.average(mesh_EV1, axis=(-1), weights=wgt_ft) mesh_EV1 = np.average(mesh_EV1, axis=(-1), weights=wgt_tran) mesh_EV1 = np.average(mesh_EV1, axis=(-1), weights=wgt_perm) mesh_EV1 = np.average(mesh_EV1, axis=(-1), weights=wgt_tran) mesh_EV1 = np.average(mesh_EV1, axis=(-1), weights=wgt_perm) mesh_EV1 = np.average(mesh_EV1, axis=(-1), weights=wgt_re) mesh_C = mesh_C[:, :, :, 0, 0, 0, 0, 0, 0, 0, 0] mesh_V0 = utility(mesh_C, N0) mesh_V = mesh_V0 + beta * p_h[t] * mesh_EV1 coord_C, coord_D, coord_S = np.unravel_index(np.nanargmax(mesh_V), mesh_V.shape) [C_max, D_max, S_max] = grid_C[coord_C], grid_D[coord_D], grid_S[coord_S] V_max = mesh_V[coord_C, coord_D, coord_S] return (i, C_max, D_max, S_max, V_max)
def evaluate(self, v): return eval_linear(self._grid, self._values, v)
def wrapper(xs, values, points, out): """Calls eval_linear().""" eval_linear((xs, ), values, points, out)
def pfi_t_func_wrap(state): newstate = eval_linear(grid, pfunc, state, xto.LINEAR) return newstate
def __call__(self, v): return eval_linear(self._grid, self._values, v)