def LinApp_CSL(funcname, param, X0, Z, NN, logX, Sylv, Y0):
'''
Generates a history of X & Y variables by linearizing the policy function
about the current state as in Evans & Phillips cited below.
Parameters
-----------
funcname: function
the name of the function which generates a column vector
from ny+nx dynamic equations.
param: array, dtype=float
A vector of parameter values to be passed to funcname.
X0: array, dtype=float
nx vector of X(1) starting values values.
Z: 2D-array, dtype=float
nobs-by-nz matrix of Z values.
NN: 2D-array, dtype=float
nz-by-nz matrix of VAR coefficients from the law of motion for Z
logX: binary, dtype=int
an indicator that determines if the X & Y variables are
log-linearized (true) or simply linearized (false). Z variables
are always simply linearized, default is 1. Use log-linearized
X & Y if no value is specified for logX
Sylv: binary, dtype=int
an indicator variable telling the program to use the built-in
function sylvester() to solve for QQ and SS, if possible.
Default is Sylv=0.
Y0: array, dtype=float
ny vector of Y(1) starting values values.
Returns
--------
X: 2D-array, dtype=float
nobs-by-nx matrix containing the value of the endogenous
state variables.
Y: 2D-array, dtype=float
nobs-by-ny matrix vector containing the value of the endogenous
non-state variables.
Notes
------
Source: R. Evans and K. Phillips (2014) "Linearization about the Current
State: A Computational Method for Approximating Nonlinear Policy
Functions during Simulation," mimeo, Brigham Young University Department
of Economics.
'''
# Formating
X0 = array(X0)
Y0 = array(Y0)
# get values for nx, ny, nz and nobs
nobs, nz = Z.shape
nx = X0.shape[0]
ny = Y0.shape[0]
# Generate a history of X's and Y's
X = zeros((nobs, nx))
Y = zeros((nobs, ny))
# set starting values
X[0, :] = X0
if ny > 0:
Y[0, :] = Y0
for t in xrange(1, nobs):
# set the linearization point to the current state
if ny > 0:
theta0 = concatenate( (X[t-1,:], X[t-1,:], X[t-1,:], Y[t-1,:],\
Y[t-1,:], Z[t,:], Z[t,:]) )
else:
theta0 = concatenate( (X[t-1,:], X[t-1,:], X[t-1,:], Z[t,:],\
Z[t,:]) )
# take derivatives at the linearization point
AA, BB, CC, DD, FF, GG, HH, JJ, KK, LL, MM, WW, TT = \
LinApp_Deriv(funcname,param,theta0,nx,ny,nz,logX)
# solve for coefficient matrices
PP, QQ, UU, RR, SS, VV = \
LinApp_Solve(AA,BB,CC,DD,FF,GG,HH,JJ, KK,LL,MM,WW,TT,NN,Z[t,:],Sylv)
Xdev = zeros((nx))
Zdev = zeros((nz))
Xtil, Ytil = LinApp_Sim(Xdev, Zdev, PP, QQ, UU, RR, SS, VV)
if Ytil.any():
# used to check whether ny=0 or not
print('Note ny=0!')
# Convert to levels
if logX:
X[t, :] = X[t - 1, :] * exp(Xtil)
if ny > 0:
Y[t, :] = Y[t - 1, :] * exp(Ytil)
else:
X[t, :] = X[t - 1, :] + Xtil
if ny > 0:
Y[t + 1, :] = Y[t, :] + Ytil
return array(X), array(Y)
# set clock for time to calcuate functions
startsolve = timeit.default_timer()
# set name for external files written
name = 'BMsolveLIN'
# -----------------------------------------------------------------------------
# BASELINE
# set up steady state input vector for baseline
theta1 = np.array([kbar1, kbar1, kbar1, 0., 0.])
# find the derivatives matrices
[AA1, BB1, CC1, DD1, FF1, GG1, HH1, JJ1, KK1, LL1, MM1, WW1, TT1] = \
LinApp_Deriv(Modeldyn, params1, theta1, nx, ny, nz, logX)
# find the policy and jump function coefficients
PP1, QQ1, UU1, RR1, SS1, VV1= \
LinApp_Solve(AA1,BB1,CC1,DD1,FF1,GG1,HH1,JJ1,KK1,LL1,MM1,WW1,TT1,NN,Zbar, \
Sylv)
print('baseline coeffs')
print('P: ', PP1)
print('Q: ', QQ1)
print(' ')
# set up coefficient list
coeffs1 = (PP1, QQ1, UU1, RR1, SS1, VV1)
# -----------------------------------------------------------------------------
# CHANGE POLICY
barsdf = pd.DataFrame(bars.T)
barsdf.index = varindex
# print (barsdf.to_latex())
# -----------------------------------------------------------------------------
# BASELINE LINEARIZATION
# set autocorrelation matrix
NN = np.array([rho])
thetabar = np.array([KSDbar, KUDbar, BSDbar, BUDbar, KSDbar, KUDbar, BSDbar, \
BUDbar, KSDbar, KUDbar, BSDbar, BUDbar, 0., 0.])
[AA, BB, CC, DD, FF, GG, HH, JJ, KK, LL, MM, WW, TT] = \
LinApp_Deriv(mdyn, params, thetabar, nx, ny, nz, False)
PP, QQ, UU, RR, SS, VV = \
LinApp_Solve(AA, BB, CC, DD, FF, GG, HH, JJ, KK, LL, MM, WW, TT, NN, \
Zbar, False)
LinCoeffs = (PP, QQ, UU, RR, SS, VV)
# -----------------------------------------------------------------------------
# NEW STEADY STATE
HSDn = .2296
HUDn = .7580
HSIn = .0119
HUIn = .0381
paramsn = np.array([g, beta, delta, gamma, a, b, c, d, f, HSDn, HUDn, HSIn, \
HUIn, nu, mu, ss, q, rho, sigma, beta, nx, ny, nz])
kbar = (((1 + rho) * (1 + g)**theta - 1 + delta) / alpha)**(1 / (alpha - 1))
ybar = kbar**alpha
rbar = alpha * ybar / kbar
wbar = (1 - alpha) * ybar
cbar = wbar + (1 + rbar - delta) * kbar - (1 + g) * (1 + n) * kbar
ibar = ybar - cbar
reportbar = np.array([[ybar], [cbar], [ibar], [kbar], [wbar], [rbar]])
# check SS values
invec = np.array([kbar, kbar, kbar, 0, 0])
check = example_dyn(invec, param)
print 'SS check', check
# find derivatives
AA, BB, CC, DD, FF, GG, HH, JJ, KK, LL, MM, WW, TT = \
LinApp_Deriv(example_dyn,param,invec,1,0,1,0)
# find policy function coefficients
PP, QQ, UU, RR, SS, VV = \
LinApp_Solve(AA,BB,CC,DD,FF,GG,HH,JJ,KK,LL,MM,WW,TT,phi,0,1)
# set function names for EE calculator
efunc = example_efunc
epars = param
tfunc = example_tfunc
tpars = (PP, QQ, kbar)
lfunc = example_lfunc
lpars = (phi)
# collect parameters for simulate_serial function
simpars = (efunc, epars, tfunc, tpars, efunc, epars)
# check SS solution
check = Modeldyn(theta0, params)
print ('check: ', check)
if np.max(np.abs(check)) > 1.E-6:
print ('Have NOT found steady state')
Ybar, wbar, rbar, cbar, ubar = Modeldefs(kbar, kbar, ellbar, 0, params)
print ('Ybar: ', Ybar)
print ('wbar: ', wbar)
print ('rbar: ', rbar)
print ('cbar: ', cbar)
print ('ubar: ', ubar)
# find the derivatives matrices
[AA, BB, CC, DD, FF, GG, HH, JJ, KK, LL, MM] = \
LinApp_Deriv(Modeldyn, params, theta0, nx, ny, nz, logX)
print('FF: ', FF)
print('GG: ', GG)
print('HH: ', HH)
print('LL: ', LL)
print('MM: ', MM)
# set value for NN
NN = rho
# find the policy and jump function coefficients
PP, QQ, RR, SS = \
LinApp_Solve(AA,BB,CC,DD,FF,GG,HH,JJ,KK,LL,MM,NN,Zbar,Sylv)
print ('PP:',PP)
print ('QQ', QQ)
print ('RR:',RR)
do3 = 1
Zbar = [0]
# find SS numerically
guessXY = [.1, .33]
XYbar = LinApp_FindSS(Hansen_dyn, param, guessXY, Zbar, nx, ny)
print 'XYbar', XYbar
Xbar = XYbar[0:nx]
Ybar = XYbar[nx:nx + ny]
theta0 = np.append(np.concatenate((Xbar, Xbar, Xbar)),\
np.concatenate((Zbar, Zbar)) )
NN = 0
#find derivatives and coefficients numerically
AA, BB, CC, DD, FF, GG, HH, JJ, KK, LL, MM, WW, TT = \
LinApp_Deriv(Hansen_dyn,param,theta0,nx,ny,nz,logX)
PP, QQ, UU, RR, SS, VV = \
LinApp_Solve(AA,BB,CC,DD,FF,GG,HH,JJ,KK,LL,MM,WW,TT,NN,Zbar,1)
print "PP\n", PP
print "QQ\n", QQ
print "RR\n", RR
print "SS\n", SS
#find quadratic approximation's steady state\
#[XQtil1, XQtil2] = QuadRoots(.5*HXX,HX-1,H0+sig^2*Hvv/2)
#generate a history of Z's
Z = np.zeros((nobs, nz))
# uncomment for simulation
logX = 0
do3 = 1
Zbar = [0]
# find SS numerically
XYbar = LinApp_FindSS(BrockMirman_dyn, param, .1, Zbar, nx, ny)
print 'XYbar', XYbar
Xbar = XYbar[0:nx]
Ybar = XYbar[nx:nx + ny]
theta0 = np.concatenate((Xbar, Xbar, Xbar, Zbar, Zbar))
NN = rho
#find derivatives and coefficients numerically
AA, BB, CC, DD, FF, GG, HH, JJ, KK, LL, MM, WW, TT = \
LinApp_Deriv(BrockMirman_dyn,param,theta0,nx,ny,nz,logX)
PP, QQ, UU, RR, SS, VV = \
LinApp_Solve(AA,BB,CC,DD,FF,GG,HH,JJ,KK,LL,MM,WW,TT,NN,Zbar,0)
print "PP\n", PP
print "QQ\n", QQ
print "RR\n", RR
print "SS\n", SS
#generate a history of Z's
Z = np.zeros((nobs, nz))
# uncomment for simulation
eps = sig * np.random.randn(nobs, nz)
# uncomment for IRF
# eps = zeros(nobs,nz)
# calculate steady state values
guessXY = np.array([1.])
kbar = LinApp_FindSS(example_dyn, param, guessXY, Zbar, nx, ny)
print('kbar value is ', kbar)
zbar = Zbar
ybar, cbar, ibar, rbar, wbar = example_def(kbar, kbar, zbar, param)
reportbar = np.array([[ybar], [cbar], [ibar], [kbar], [wbar], [rbar]])
# check SS values
invec = np.concatenate([kbar, kbar, kbar, zbar, zbar])
check = example_dyn(invec, param)
print('SS check value is ', check)
# find derivatives
[AA, BB, CC, DD, FF, GG, HH, JJ, KK, LL, MM, WW, TT] = \
LinApp_Deriv(example_dyn, param, invec, nx, ny, nz, logX)
print('FF value is ', FF)
print('GG value is ', GG)
print('HH value is ', HH)
print('LL value is ', LL)
print('MM value is ', MM)
# find policy function coefficients
PP, QQ, UU, RR, SS, VV = \
LinApp_Solve(AA, BB, CC, DD, FF, GG, HH, JJ, KK, LL, MM, WW, TT, \
phi, Zbar, Sylv)
print('PP value is ', PP)
print('QQ value is ', QQ)
# perform simulation
eps = np.random.randn(nobs) * sigma
print('rbar: ', rbar)
print('wbar: ', wbar)
print('cbar: ', cbar)
print('ibar: ', ibar)
print('ubar: ', ubar)
# find derivatives of Gamma
# set the options for LinApp_Deriv
nx = 1 # number of X variables
ny = 0 # number of Y variables
nz = 1 # number of Z variables
takelogs = False # if True the model is log-linearized, otherwise simple linearization
[AA, BB, CC, DD, FF, GG, HH, JJ, KK, LL, MM] = \
LinApp_Deriv(Gamma, mparams, invec, nx, ny, nz, takelogs)
# NN is the autoregressive parameter in z's law of motion
NN = rho
# set the options for LinApp_Solve
Sylv = False # if True use Python's built-in Sylvester equation solver, otherwise us the code in LinApp_Solve
# solve for coefficients
PP, QQ, RR, SS = \
LinApp_Solve(AA, BB, CC, DD, FF, GG, HH, JJ, KK, LL, MM, NN, zbar, Sylv)
print('PP:', PP)
print('QQ', QQ)
#------------------------------------------------------------------------------------------------------
#Simulate
# generate a history of Z's
T = 1000 # number of observations to generate