def plot_disc_policy():
#First compute policy function...==========================================
N = 500
w = sp.linspace(0,100,N)
w = w.reshape(N,1)
u = lambda c: sp.sqrt(c)
util_vec = u(w)
alpha = 0.5
alpha_util = u(alpha*w)
alpha_util_grid = sp.repeat(alpha_util,N,1)
m = 20
v = 200
f = discretelognorm(w,m,v)
VEprime = sp.zeros((N,1))
VUprime = sp.zeros((N,N))
EVUprime = sp.zeros((N,1))
psiprime = sp.ones((N,1))
gamma = 0.1
beta = 0.9
m = 15
tol = 10**-9
delta = 1+tol
it = 0
while (delta >= tol):
it += 1
psi = psiprime.copy()
arg1 = sp.repeat(sp.transpose(VEprime),N,0)
arg2 = sp.repeat(EVUprime,N,1)
arg = sp.array([arg2,arg1])
psiprime = sp.argmax(arg,axis = 0)
for j in sp.arange(0,m):
VE = VEprime.copy()
VU = VUprime.copy()
EVU = EVUprime.copy()
VEprime = util_vec + beta*((1-gamma)*VE + gamma*EVU)
arg1 = sp.repeat(sp.transpose(VE),N,0)*psiprime
arg2 = sp.repeat(EVU,N,1)*(1-psiprime)
arg = arg1+arg2
VUprime = alpha_util_grid + beta*arg
EVUprime = sp.dot(VUprime,f)
delta = sp.linalg.norm(psiprime -psi)
wr_ind = sp.argmax(sp.diff(psiprime), axis = 1)
wr = w[wr_ind]
print w[250],wr[250]
#Then plot=================================================================
plt.plot(w,psiprime[250,:])
plt.ylim([-.5,1.5])
plt.xlabel(r'$w\prime$')
plt.yticks([0,1])
plt.savefig('disc_policy.pdf')
def disc_policy():
#First compute policy function...==========================================
N = 500
w = sp.linspace(0, 100, N)
w = w.reshape(N, 1)
u = lambda c: sp.sqrt(c)
util_vec = u(w)
alpha = 0.5
alpha_util = u(alpha * w)
alpha_util_grid = sp.repeat(alpha_util, N, 1)
m = 20
v = 200
f = discretelognorm(w, m, v)
VEprime = sp.zeros((N, 1))
VUprime = sp.zeros((N, N))
EVUprime = sp.zeros((N, 1))
psiprime = sp.ones((N, 1))
gamma = 0.1
beta = 0.9
m = 15
tol = 10**-9
delta = 1 + tol
it = 0
while (delta >= tol):
it += 1
psi = psiprime.copy()
arg1 = sp.repeat(sp.transpose(VEprime), N, 0)
arg2 = sp.repeat(EVUprime, N, 1)
arg = sp.array([arg2, arg1])
psiprime = sp.argmax(arg, axis=0)
for j in sp.arange(0, m):
VE = VEprime.copy()
VU = VUprime.copy()
EVU = EVUprime.copy()
VEprime = util_vec + beta * ((1 - gamma) * VE + gamma * EVU)
arg1 = sp.repeat(sp.transpose(VE), N, 0) * psiprime
arg2 = sp.repeat(EVU, N, 1) * (1 - psiprime)
arg = arg1 + arg2
VUprime = alpha_util_grid + beta * arg
EVUprime = sp.dot(VUprime, f)
delta = sp.linalg.norm(psiprime - psi)
wr_ind = sp.argmax(sp.diff(psiprime), axis=1)
wr = w[wr_ind]
print w[250], wr[250]
#Then plot=================================================================
plt.plot(w, psiprime[250, :])
plt.ylim([-.5, 1.5])
plt.xlabel(r'$w\prime$')
plt.yticks([0, 1])
plt.savefig('disc_policy.pdf')
plt.clf()
def reservation_wage():
m = 20
v = 200
N = 500
Wmax = 100
Wmin = 0
gamma = .10
alpha = .5
beta = .9
e_params = (m, v)
u = lambda c: np.sqrt(c)
w = np.linspace(Wmin, Wmax, N)
uaw = u(alpha * w).reshape((N, 1))
uw = u(w)
f = discretelognorm(w, *e_params)
VE = np.zeros(N)
EVU = np.zeros(N)
VU = np.zeros((N, N))
MVE = np.empty((N, N)) #tiled version of VE
MEVU = np.empty((N, N)) #tiled version of EVU
delta = 1.
i = 0
while delta >= 1e-9:
i += 1
#update tiled value functions
MVE[:, :] = VE.reshape((1, N))
MEVU[:, :] = EVU.reshape((N, 1))
#calculate new value functions
VU1 = uaw + beta * np.max(np.dstack([MEVU, MVE]), axis=2)
VE1 = uw + beta * ((1 - gamma) * VE + gamma * EVU)
#test for convergence
d1 = ((VE1 - VE)**2).sum()
d2 = ((VU1 - VU)**2).sum()
delta = max(d1, d2)
#update
VU = VU1
VE = VE1
EVU = np.dot(VU, f).ravel()
#calculate policy function
PSI = np.argmax(np.dstack([MEVU, MVE]), axis=2)
#calculate and plot reservation wage function
wr_ind = np.argmax(np.diff(PSI), axis=1)
wr = w[wr_ind]
plt.plot(w, wr)
plt.savefig('reservation_wage.pdf')
plt.clf()
def reservation_wage():
m = 20
v = 200
N = 500
Wmax = 100
Wmin = 0
gamma = .10
alpha = .5
beta = .9
e_params = (m, v)
u = lambda c: np.sqrt(c)
w = np.linspace(Wmin, Wmax, N)
uaw = u(alpha*w).reshape((N,1))
uw = u(w)
f = discretelognorm(w, *e_params)
VE = np.zeros(N)
EVU = np.zeros(N)
VU = np.zeros((N,N))
MVE = np.empty((N,N)) #tiled version of VE
MEVU = np.empty((N,N)) #tiled version of EVU
delta = 1.
i = 0
while delta >= 1e-9:
i+=1
#update tiled value functions
MVE[:,:] = VE.reshape((1,N))
MEVU[:,:] = EVU.reshape((N,1))
#calculate new value functions
VU1 = uaw + beta*np.max(np.dstack([MEVU, MVE]), axis=2)
VE1 = uw + beta*((1-gamma)*VE + gamma*EVU)
#test for convergence
d1 = ((VE1-VE)**2).sum()
d2 = ((VU1-VU)**2).sum()
delta = max(d1,d2)
#update
VU = VU1
VE = VE1
EVU = np.dot(VU,f).ravel()
#calculate policy function
PSI = np.argmax(np.dstack([MEVU,MVE]), axis=2)
#calculate and plot reservation wage function
wr_ind = np.argmax(np.diff(PSI), axis = 1)
wr = w[wr_ind]
plt.plot(w,wr)
plt.savefig('reservation_wage.pdf')
plt.clf()
def Problem6Real():
N = 500
w = sp.linspace(0,100,N)
w = w.reshape(N,1)
u = lambda c: sp.sqrt(c)
util_vec = u(w)
alpha = 0.5
alpha_util = u(alpha*w)
alpha_util_grid = sp.repeat(alpha_util,N,1)
m = 20
v = 200
f = discretelognorm(w,m,v)
VEprime = sp.zeros((N,1))
VUprime = sp.zeros((N,N))
EVUprime = sp.zeros((N,1))
psiprime = sp.ones((N,1))
gamma = 0.1
beta = 0.9
m = 15
tol = 10**-9
delta = 1+tol
it = 0
while (delta >= tol):
it += 1
psi = psiprime.copy()
arg1 = sp.repeat(sp.transpose(VEprime),N,0)
arg2 = sp.repeat(EVUprime,N,1)
arg = sp.array([arg2,arg1])
psiprime = sp.argmax(arg,axis = 0)
for j in sp.arange(0,m):
VE = VEprime.copy()
VU = VUprime.copy()
EVU = EVUprime.copy()
VEprime = util_vec + beta*((1-gamma)*VE + gamma*EVU)
arg1 = sp.repeat(sp.transpose(VE),N,0)*psiprime
arg2 = sp.repeat(EVU,N,1)*(1-psiprime)
arg = arg1+arg2
VUprime = alpha_util_grid + beta*arg
EVUprime = sp.dot(VUprime,f)
delta = sp.linalg.norm(psiprime -psi)
#print(delta)
wr_ind = sp.argmax(sp.diff(psiprime), axis = 1)
wr = w[wr_ind]
plt.plot(w,wr)
plt.show()
return wr
def jobSearchVI(Wmin, Wmax, N, e_params, alpha, beta, gamma):
"""
Solve the job search problem.
VE denotes the employed value function.
VU denotes the unemployed value function.
EVU denotes E_{w''}V^U(w,w'').
PSI denotes the policy function.
Label employed with 0, unemployed with 1.
"""
u = lambda c: np.sqrt(c)
w = np.linspace(Wmin, Wmax, N)
uaw = u(alpha*w).reshape((N,1))
uw = u(w)
f = discretelognorm(w, *e_params)
VE = np.zeros(N)
EVU = np.zeros(N)
VU = np.zeros((N,N))
MVE = np.empty((N,N)) #tiled version of VE
MEVU = np.empty((N,N)) #tiled version of EVU
delta = 1.
i = 0
while delta >= 1e-9:
i+=1
#update tiled value functions
MVE[:,:] = VE.reshape((1,N))
MEVU[:,:] = EVU.reshape((N,1))
#calculate new value functions
VU1 = uaw + beta*np.max(np.dstack([MEVU, MVE]), axis=2)
VE1 = uw + beta*((1-gamma)*VE + gamma*EVU)
#test for convergence
d1 = math.sqrt(((VE1-VE)**2).sum())
d2 = math.sqrt(((VU1-VU)**2).sum())
delta = max(d1,d2)
#update
VU = VU1
VE = VE1
EVU = np.dot(VU,f).ravel()
#calculate policy function
PSI = np.argmax(np.dstack([MEVU,MVE]), axis=2)
#calculate and plot reservation wage function
wr_ind = np.argmax(np.diff(PSI), axis = 1)
wr = w[wr_ind]
plt.plot(w,wr)
plt.show()
print "Number of iterations:", i
return VE, VU, PSI
def jobSearchVI(Wmin, Wmax, N, e_params, alpha, beta, gamma):
"""
Solve the job search problem.
VE denotes the employed value function.
VU denotes the unemployed value function.
EVU denotes E_{w''}V^U(w,w'').
PSI denotes the policy function.
Label employed with 0, unemployed with 1.
"""
u = lambda c: np.sqrt(c)
w = np.linspace(Wmin, Wmax, N)
uaw = u(alpha * w).reshape((N, 1))
uw = u(w)
f = discretelognorm(w, *e_params)
VE = np.zeros(N)
EVU = np.zeros(N)
VU = np.zeros((N, N))
MVE = np.empty((N, N)) #tiled version of VE
MEVU = np.empty((N, N)) #tiled version of EVU
delta = 1.
i = 0
while delta >= 1e-9:
i += 1
#update tiled value functions
MVE[:, :] = VE.reshape((1, N))
MEVU[:, :] = EVU.reshape((N, 1))
#calculate new value functions
VU1 = uaw + beta * np.max(np.dstack([MEVU, MVE]), axis=2)
VE1 = uw + beta * ((1 - gamma) * VE + gamma * EVU)
#test for convergence
d1 = math.sqrt(((VE1 - VE)**2).sum())
d2 = math.sqrt(((VU1 - VU)**2).sum())
delta = max(d1, d2)
#update
VU = VU1
VE = VE1
EVU = np.dot(VU, f).ravel()
#calculate policy function
PSI = np.argmax(np.dstack([MEVU, MVE]), axis=2)
#calculate and plot reservation wage function
wr_ind = np.argmax(np.diff(PSI), axis=1)
wr = w[wr_ind]
plt.plot(w, wr)
plt.show()
print "Number of iterations:", i
return VE, VU, PSI
def jobSearchMPI(Wmin, Wmax, N, e_params, alpha, beta, gamma):
"""
Solve Job search problem using modified policy function iteration.
"""
# initialize data
u = lambda c: np.sqrt(c)
w = np.linspace(Wmin, Wmax, N)
uaw = u(alpha*w).reshape((N,1))
uw = u(w)
f = discretelognorm(w, *e_params)
VE = np.zeros(N)
EVU = np.zeros(N)
VU = np.zeros((N,N))
PSI = 2*np.ones((N,N)) #initialize policy function
MVE = np.empty((N,N))
MEVU = np.empty((N,N))
delta = 10.
it = 0
while delta >= 1e-9:
it += 1
#calculate new policy function
PSI1 = np.argmax(np.dstack([MEVU,MVE]), axis=2)
#iterate on the value functions
for i in xrange(15):
MVE[:,:] = VE.reshape((1,N))
MEVU[:,:] = EVU.reshape((N,1))
VU = uaw + beta*(MVE*PSI1+MEVU*(1-PSI1))
VE = uw + beta*((1-gamma)*VE + gamma*EVU)
EVU = np.dot(VU,f).ravel()
#test for convergence
delta = math.sqrt(np.abs((PSI1-PSI)).sum())
#update
PSI = PSI1
#calculate and plot reservation wage function
wr_ind = np.argmax(np.diff(PSI), axis = 1)
wr = w[wr_ind]
plt.plot(w,wr)
plt.show()
print "Number of iterations:", it
return PSI
def jobSearchMPI(Wmin, Wmax, N, e_params, alpha, beta, gamma):
"""
Solve Job search problem using modified policy function iteration.
"""
# initialize data
u = lambda c: np.sqrt(c)
w = np.linspace(Wmin, Wmax, N)
uaw = u(alpha * w).reshape((N, 1))
uw = u(w)
f = discretelognorm(w, *e_params)
VE = np.zeros(N)
EVU = np.zeros(N)
VU = np.zeros((N, N))
PSI = 2 * np.ones((N, N)) #initialize policy function
MVE = np.empty((N, N))
MEVU = np.empty((N, N))
delta = 10.
it = 0
while delta >= 1e-9:
it += 1
#calculate new policy function
PSI1 = np.argmax(np.dstack([MEVU, MVE]), axis=2)
#iterate on the value functions
for i in xrange(15):
MVE[:, :] = VE.reshape((1, N))
MEVU[:, :] = EVU.reshape((N, 1))
VU = uaw + beta * (MVE * PSI1 + MEVU * (1 - PSI1))
VE = uw + beta * ((1 - gamma) * VE + gamma * EVU)
EVU = np.dot(VU, f).ravel()
#test for convergence
delta = math.sqrt(np.abs((PSI1 - PSI)).sum())
#update
PSI = PSI1
#calculate and plot reservation wage function
wr_ind = np.argmax(np.diff(PSI), axis=1)
wr = w[wr_ind]
plt.plot(w, wr)
plt.show()
print "Number of iterations:", it
return PSI
def Problem5Real():
N = 500
w = sp.linspace(0,100,N)
w = w.reshape(N,1)
u = lambda c: sp.sqrt(c)
util_vec = u(w)
alpha = 0.5
alpha_util = u(alpha*w)
alpha_util_grid = sp.repeat(alpha_util,N,1)
m = 20
v = 200
f = discretelognorm(w,m,v)
VEprime = sp.zeros((N,1))
VUprime = sp.zeros((N,N))
EVUprime = sp.zeros((N,1))
gamma = 0.1
beta = 0.9
tol = 10**-9
delta1 = 1+tol
delta2 = 1+tol
it = 0
while ((delta1 >= tol) or (delta2 >= tol)):
it += 1
VE = VEprime.copy()
VU = VUprime.copy()
EVU = EVUprime.copy()
VEprime = util_vec + beta*((1-gamma)*VE + gamma*EVU)
arg1 = sp.repeat(sp.transpose(VE),N,0)
arg2 = sp.repeat(EVU,N,1)
arg = sp.array([arg2,arg1])
VUprime = alpha_util_grid + beta*sp.amax(arg,axis = 0)
psi = sp.argmax(arg,axis = 0)
EVUprime = sp.dot(VUprime,f)
delta1 = sp.linalg.norm(VEprime - VE)
delta2 = sp.linalg.norm(VUprime - VU)
#print(delta1)
wr_ind = sp.argmax(sp.diff(psi), axis = 1)
wr = w[wr_ind]
return wr
#plt.plot(w,wr)
#plt.show()
#Problem 2 Solution============================================================
N = 500
w = sp.linspace(0,100,N)
w = w.reshape(N,1)
u = lambda c: sp.sqrt(c)
util_vec = u(w)
alpha = 0.5
alpha_util = u(alpha*w)
alpha_util_grid = sp.repeat(alpha_util,N,1)
m = 20
v = 200
f = discretelognorm(w,m,v)
VEprime = sp.zeros((N,1))
VUprime = sp.zeros((N,N))
EVUprime = sp.zeros((N,1))
psiprime = sp.ones((N,1))
gamma = 0.1
beta = 0.9
m = 15
tol = 10**-9
delta = 1+tol
it = 0
while (delta >= tol):
it += 1
