def iterate2(n=None, **kwargs):
localvars = {}
def postIterCallbackFn(nIter, newVArray, currentPolicyArrayList, greedyPolicyList, stoppingResult):
(stoppingDecision, diff) = stoppingResult
print("iter %d, diff %f" % (nIter, diff))
localvars[0] = nIter
bellman.appendIter()
bellman.setInLastIter('v', newVArray)
bellman.setInLastIter('opt_d', currentPolicyArrayList[0])
bellman.setInLastIter('opt_r', currentPolicyArrayList[1])
v0_array = scipy.zeros((len(g.grid_M), len(g.grid_D))); # initial guess for value function
d0_array = scipy.zeros((len(g.grid_M), len(g.grid_D))); # initial guess for policy function for d
r0_array = scipy.ones((len(g.grid_M), len(g.grid_D))); # initial guess for policy function for r
bellman.resetIters()
bellman.appendIter()
bellman.setInLastIter('v', v0_array)
bellman.setInLastIter('opt_d', None)
bellman.setInLastIter('opt_r', None)
params = PonziParams()
time1 = time.time()
result = bellman.grid_policyIteration([g.grid_M, g.grid_D], [d0_array, r0_array], v0_array, params, postIterCallbackFn=postIterCallbackFn, parallel=True)
(nIter, currentVArray, currentPolicyArrayList, greedyPolicyList) = result
time2 = time.time()
nIters = localvars[0]
print("total time: %f, avg time: %f" % (time2-time1, (time2-time1)/nIters))
def test_consumptionSavings1(useValueIter=True, parallel=True, evMethod=EVMethodT.EV_MONTECARLO2):
global g_IterList, g_Grid, g_Params
time1 = time.time()
localvars = {}
def postVIterCallbackFn(nIter, currentVArray, newVArray, optControls, stoppingResult):
(stoppingDecision, diff) = stoppingResult
print("iter %d, diff %f" % (nIter, diff))
localvars[0] = nIter
g_IterList.append((currentVArray, optControls[0], optControls[1]))
def postPIterCallbackFn(nIter, newVArray, currentPolicyArrayList, greedyPolicyList, stoppingResult):
(stoppingDecision, diff) = stoppingResult
print("iter %d, diff %f" % (nIter, diff))
localvars[0] = nIter
grid = scipy.linspace(0.0001, 10, 500)
g_Grid = grid
params = ConsumptionSavingsParams(grid, gamma=1.0, beta=0.75, mean1=0.05, mean2=0.5, var2=1.0, evMethod=evMethod)
g_Params = params
initialVArray = grid; # initial guess for V: a linear fn
g_IterList.append((initialVArray, None, None))
if (useValueIter == True):
result = bellman.grid_valueIteration([grid], initialVArray, params, postIterCallbackFn=postVIterCallbackFn, parallel=parallel)
(nIter, currentVArray, newVArray, optControls) = result
else:
result = bellman.grid_policyIteration([grid], [initialPolicyArray], initialVArray, params, postIterCallbackFn=postPIterCallbackFn, parallel=False)
(nIter, currentVArray, currentPolicyArrayList, greedyPolicyList) = result
newVArray = currentVArray
optControls = currentPolicyArrayList
time2 = time.time()
nIters = localvars[0]
print("total time: %f, avg time: %f" % (time2-time1, (time2-time1)/nIters))
# plot V
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(grid, newVArray)
ax.set_xlabel("W")
ax.set_ylabel("V")
# plot optimal c
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(grid, optControls[0])
ax.set_xlabel("W")
ax.set_ylabel("fraction consumed")
# plot optimal s
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(grid, optControls[1])
ax.set_xlabel("W")
ax.set_ylabel("fraction invested in risky asset")
plt.show()
return result
def test_optdiv2(delta=0.1, mu=0.5, sigma=1.0, dt=1.0, grid=scipy.linspace(0, 5, 200), useValueIter=True):
time1 = time.time()
localvars = {}
def postVIterCallbackFn(nIter, currentVArray, newVArray, optControls, stoppingResult):
global g_iterList
(stoppingDecision, diff) = stoppingResult
print("iter %d, diff %f" % (nIter, diff))
localvars[0] = nIter
def postPIterCallbackFn(nIter, newVArray, currentPolicyArrayList, greedyPolicyList, stoppingResult):
(stoppingDecision, diff) = stoppingResult
print("iter %d, diff %f" % (nIter, diff))
localvars[0] = nIter
initialVArray = grid; # initial guess for V: a linear fn
initialPolicyArray = grid; # initial guess for d: pay out everything
utilityFn = lambda x: x; # linear utility
beta = scipy.power(scipy.e, -(delta * dt))
print("beta = exp(- %f * %f) = %f" % (delta, dt, beta))
zRV = scipy.stats.norm(loc=mu*dt, scale=sigma*scipy.sqrt(dt))
print("income shock: mean %f, sd %f" % (mu*dt, sigma*dt))
bstar = calc_opt_b(mu, sigma, delta)
print("optimal barrier: %f" % bstar)
params = OptDivParams2(utilityFn, beta, zRV, grid); # don't use parallel search with this, since it makes a callback to Python
if (useValueIter == True):
result = bellman.grid_valueIteration([grid], initialVArray, params, postIterCallbackFn=postVIterCallbackFn, parallel=False)
(nIter, currentVArray, newVArray, optControls) = result
else:
result = bellman.grid_policyIteration([grid], [initialPolicyArray], initialVArray, params, postIterCallbackFn=postPIterCallbackFn, parallel=False)
(nIter, currentVArray, currentPolicyArrayList, greedyPolicyList) = result
newVArray = currentVArray
optControls = currentPolicyArrayList
time2 = time.time()
nIters = localvars[0]
print("total time: %f, avg time: %f" % (time2-time1, (time2-time1)/nIters))
# plot V
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(grid, newVArray)
ax.set_xlabel("M")
ax.set_ylabel("V")
# plot optimal d
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(grid, optControls[0])
ax.axvline(bstar, color='gray')
ax.set_xlabel("M")
ax.set_ylabel("optimal d")
plt.show()
return
def test_optdiv1(beta=0.9, pHigh=0.75, grid=scipy.arange(21.0), useValueIter=True):
time1 = time.time()
localvars = {}
def postVIterCallbackFn(nIter, currentVArray, newVArray, optControls, stoppingResult):
global g_iterList
(stoppingDecision, diff) = stoppingResult
print("iter %d, diff %f" % (nIter, diff))
localvars[0] = nIter
def postPIterCallbackFn(nIter, newVArray, currentPolicyArrayList, greedyPolicyList, stoppingResult):
(stoppingDecision, diff) = stoppingResult
print("iter %d, diff %f" % (nIter, diff))
localvars[0] = nIter
initialVArray = grid; # initial guess for V: a linear fn
initialPolicyArray = grid; # initial guess for d: pay out everything
utilityFn = lambda x: x; # linear utility
zStates = [-1.0, 1.0];
zProbs = [1.0-pHigh, pHigh]; # income shock
params = OptDivParams1(utilityFn, beta, zStates, zProbs, grid); # don't use parallel search with this, since it makes a callback to Python
if (useValueIter == True):
result = bellman.grid_valueIteration([grid], initialVArray, params, postIterCallbackFn=postVIterCallbackFn, parallel=False)
(nIter, currentVArray, newVArray, optControls) = result
else:
result = bellman.grid_policyIteration([grid], [initialPolicyArray], initialVArray, params, postIterCallbackFn=postPIterCallbackFn, parallel=False)
(nIter, currentVArray, currentPolicyArrayList, greedyPolicyList) = result
newVArray = currentVArray
optControls = currentPolicyArrayList
time2 = time.time()
nIters = localvars[0]
print("total time: %f, avg time: %f" % (time2-time1, (time2-time1)/nIters))
print("x_0 == 0: %d" % alwaysPayAll(beta, pHigh))
n0 = getn0(beta, pHigh)
optd_fn = linterp.LinInterp1D(grid, optControls[0])
print("n0: %f, d(floor(n0)): %f" % (n0, optd_fn(scipy.floor(n0))))
# plot V
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(grid, newVArray)
ax.set_xlabel("M")
ax.set_ylabel("V")
# plot optimal d
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(grid, optControls[0])
ax.axvline(scipy.floor(n0), color='gray')
ax.set_xlabel("M")
ax.set_ylabel("optimal d")
plt.show()
return result
def test_optdiv3(beta=0.9, grid=scipy.arange(21.0), zDraws=scipy.array([-1.0]*25 + [1.0]*75), useValueIter=True):
time1 = time.time()
localvars = {}
def postVIterCallbackFn(nIter, currentVArray, newVArray, optControls, stoppingResult):
global g_iterList
(stoppingDecision, diff) = stoppingResult
print("iter %d, diff %f" % (nIter, diff))
localvars[0] = nIter
def postPIterCallbackFn(nIter, newVArray, currentPolicyArrayList, greedyPolicyList, stoppingResult):
(stoppingDecision, diff) = stoppingResult
print("iter %d, diff %f" % (nIter, diff))
localvars[0] = nIter
initialVArray = grid; # initial guess for V: a linear fn
initialPolicyArray = grid; # initial guess for d: pay out everything
params = OptDivParams3(grid, beta, zDraws);
if (useValueIter == True):
result = bellman.grid_valueIteration([grid], initialVArray, params, postIterCallbackFn=postVIterCallbackFn, parallel=True)
(nIter, currentVArray, newVArray, optControls) = result
else:
result = bellman.grid_policyIteration([grid], [initialPolicyArray], initialVArray, params, postIterCallbackFn=postPIterCallbackFn, parallel=False)
(nIter, currentVArray, currentPolicyArrayList, greedyPolicyList) = result
newVArray = currentVArray
optControls = currentPolicyArrayList
time2 = time.time()
nIters = localvars[0]
print("total time: %f, avg time: %f" % (time2-time1, (time2-time1)/nIters))
optd_fn = linterp.LinInterp1D(grid, optControls[0])
# plot V
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(grid, newVArray)
dx = grid[1] - grid[0]
deriv = scipy.diff(newVArray) / dx
ax.plot(grid[:-1], deriv)
ax.set_xlabel("M")
ax.set_ylabel("V")
# plot optimal d
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(grid, optControls[0])
ax.set_xlabel("M")
ax.set_ylabel("optimal d")
plt.show()
return result
def test_cake3():
time1 = time.time()
localvars = {}
cakeSizeGrid = scipy.linspace(0.001, 5, 200); # state variable grid
def postIterCallbackFn(nIter, newVArray, currentPolicyArrayList, greedyPolicyList, stoppingResult):
(stoppingDecision, diff) = stoppingResult
print("iter %d, diff %f" % (nIter, diff))
localvars[0] = nIter
initialVArray = cakeSizeGrid; # initial guess for V: a linear fn
initialPolicyArray = cakeSizeGrid; # initial guess for policy: eat everything
utilityFn = scipy.log; # log utility
beta = 0.9
params = CakeParams2(utilityFn, beta, cakeSizeGrid); # don't use parallel search with this, since it makes a callback to Python
result = bellman.grid_policyIteration([cakeSizeGrid], [initialPolicyArray], initialVArray, params, postIterCallbackFn=postIterCallbackFn, parallel=False)
(nIter, currentVArray, currentPolicyArrayList, greedyPolicyList) = result
time2 = time.time()
nIters = localvars[0]
print("total time: %f, avg time: %f" % (time2-time1, (time2-time1)/nIters))
compareCakeSolution(cakeSizeGrid, beta, currentVArray, currentPolicyArrayList[0])
return result
