adding new functions and new tests for risky steady state
parent
316c1b4dd6
commit
c56a8e40e8
|
@ -0,0 +1,33 @@
|
|||
function [dr,info]=AIM_first_order_solver(jacobia,M_,dr)
|
||||
try
|
||||
[dr,aimcode]=dynAIMsolver1(jacobia_,M_,dr);
|
||||
|
||||
% reuse some of the bypassed code and tests that may be needed
|
||||
|
||||
if aimcode ~=1
|
||||
info(1) = aimcode;
|
||||
info(2) = 1.0e+8;
|
||||
return
|
||||
end
|
||||
[A,B] =transition_matrix(dr);
|
||||
dr.eigval = eig(A);
|
||||
nba = nd-sdim;
|
||||
|
||||
nyf = sum(kstate(:,2) > M_.maximum_endo_lag+1);
|
||||
|
||||
if nba ~= nyf
|
||||
temp = sort(abs(dr.eigval));
|
||||
if nba > nyf
|
||||
temp = temp(nd-nba+1:nd-nyf)-1-options_.qz_criterium;
|
||||
info(1) = 3;
|
||||
elseif nba < nyf;
|
||||
temp = temp(nd-nyf+1:nd-nba)-1-options_.qz_criterium;
|
||||
info(1) = 4;
|
||||
end
|
||||
info(2) = temp'*temp;
|
||||
return
|
||||
end
|
||||
catch
|
||||
disp(lasterror.message)
|
||||
error('Problem with AIM solver - Try to remove the "aim_solver" option')
|
||||
end
|
|
@ -0,0 +1,170 @@
|
|||
function [dr,info] = dyn_first_order_solver(jacobia,b,M_,dr,options,task)
|
||||
|
||||
info = 0;
|
||||
|
||||
dr.ghx = [];
|
||||
dr.ghu = [];
|
||||
|
||||
klen = M_.maximum_endo_lag+M_.maximum_endo_lead+1;
|
||||
kstate = dr.kstate;
|
||||
kad = dr.kad;
|
||||
kae = dr.kae;
|
||||
nstatic = dr.nstatic;
|
||||
nfwrd = dr.nfwrd;
|
||||
npred = dr.npred;
|
||||
nboth = dr.nboth;
|
||||
order_var = dr.order_var;
|
||||
nd = size(kstate,1);
|
||||
lead_lag_incidence = M_.lead_lag_incidence;
|
||||
nz = nnz(lead_lag_incidence);
|
||||
|
||||
sdyn = M_.endo_nbr - nstatic;
|
||||
|
||||
[junk,cols_b,cols_j] = find(lead_lag_incidence(M_.maximum_endo_lag+1,...
|
||||
order_var));
|
||||
|
||||
if nstatic > 0
|
||||
[Q,R] = qr(b(:,1:nstatic));
|
||||
aa = Q'*jacobia;
|
||||
else
|
||||
aa = jacobia;
|
||||
end
|
||||
k1 = find([1:klen] ~= M_.maximum_endo_lag+1);
|
||||
a = aa(:,nonzeros(lead_lag_incidence(k1,:)'));
|
||||
b(:,cols_b) = aa(:,cols_j);
|
||||
b10 = b(1:nstatic,1:nstatic);
|
||||
b11 = b(1:nstatic,nstatic+1:end);
|
||||
b2 = b(nstatic+1:end,nstatic+1:end);
|
||||
if any(isinf(a(:)))
|
||||
info = 1;
|
||||
return
|
||||
end
|
||||
|
||||
% buildind D and E
|
||||
d = zeros(nd,nd) ;
|
||||
e = d ;
|
||||
|
||||
k = find(kstate(:,2) >= M_.maximum_endo_lag+2 & kstate(:,3));
|
||||
d(1:sdyn,k) = a(nstatic+1:end,kstate(k,3)) ;
|
||||
k1 = find(kstate(:,2) == M_.maximum_endo_lag+2);
|
||||
e(1:sdyn,k1) = -b2(:,kstate(k1,1)-nstatic);
|
||||
k = find(kstate(:,2) <= M_.maximum_endo_lag+1 & kstate(:,4));
|
||||
e(1:sdyn,k) = -a(nstatic+1:end,kstate(k,4)) ;
|
||||
k2 = find(kstate(:,2) == M_.maximum_endo_lag+1);
|
||||
k2 = k2(~ismember(kstate(k2,1),kstate(k1,1)));
|
||||
d(1:sdyn,k2) = b2(:,kstate(k2,1)-nstatic);
|
||||
|
||||
if ~isempty(kad)
|
||||
for j = 1:size(kad,1)
|
||||
d(sdyn+j,kad(j)) = 1 ;
|
||||
e(sdyn+j,kae(j)) = 1 ;
|
||||
end
|
||||
end
|
||||
|
||||
% 1) if mjdgges.dll (or .mexw32 or ....) doesn't exit,
|
||||
% matlab/qz is added to the path. There exists now qz/mjdgges.m that
|
||||
% contains the calls to the old Sims code
|
||||
% 2) In global_initialization.m, if mjdgges.m is visible exist(...)==2,
|
||||
% this means that the DLL isn't avaiable and use_qzdiv is set to 1
|
||||
|
||||
[err,ss,tt,w,sdim,dr.eigval,info1] = mjdgges(e,d,options.qz_criterium);
|
||||
mexErrCheck('mjdgges', err);
|
||||
|
||||
if info1
|
||||
if info1 == -30
|
||||
info(1) = 7;
|
||||
else
|
||||
info(1) = 2;
|
||||
info(2) = info1;
|
||||
info(3) = size(e,2);
|
||||
end
|
||||
return
|
||||
end
|
||||
|
||||
nba = nd-sdim;
|
||||
|
||||
nyf = sum(kstate(:,2) > M_.maximum_endo_lag+1);
|
||||
|
||||
if task == 1
|
||||
dr.rank = rank(w(1:nyf,nd-nyf+1:end));
|
||||
% Under Octave, eig(A,B) doesn't exist, and
|
||||
% lambda = qz(A,B) won't return infinite eigenvalues
|
||||
if ~exist('OCTAVE_VERSION')
|
||||
dr.eigval = eig(e,d);
|
||||
end
|
||||
return
|
||||
end
|
||||
|
||||
if nba ~= nyf
|
||||
temp = sort(abs(dr.eigval));
|
||||
if nba > nyf
|
||||
temp = temp(nd-nba+1:nd-nyf)-1-options.qz_criterium;
|
||||
info(1) = 3;
|
||||
elseif nba < nyf;
|
||||
temp = temp(nd-nyf+1:nd-nba)-1-options.qz_criterium;
|
||||
info(1) = 4;
|
||||
end
|
||||
info(2) = temp'*temp;
|
||||
return
|
||||
end
|
||||
|
||||
np = nd - nyf;
|
||||
n2 = np + 1;
|
||||
n3 = nyf;
|
||||
n4 = n3 + 1;
|
||||
% derivatives with respect to dynamic state variables
|
||||
% forward variables
|
||||
w1 =w(1:n3,n2:nd);
|
||||
if ~isscalar(w1) && (condest(w1) > 1e9);
|
||||
% condest() fails on a scalar under Octave
|
||||
info(1) = 5;
|
||||
info(2) = condest(w1);
|
||||
return;
|
||||
else
|
||||
gx = -w1'\w(n4:nd,n2:nd)';
|
||||
end
|
||||
|
||||
% predetermined variables
|
||||
hx = w(1:n3,1:np)'*gx+w(n4:nd,1:np)';
|
||||
hx = (tt(1:np,1:np)*hx)\(ss(1:np,1:np)*hx);
|
||||
|
||||
k1 = find(kstate(n4:nd,2) == M_.maximum_endo_lag+1);
|
||||
k2 = find(kstate(1:n3,2) == M_.maximum_endo_lag+2);
|
||||
dr.ghx = [hx(k1,:); gx(k2(nboth+1:end),:)];
|
||||
|
||||
%lead variables actually present in the model
|
||||
j3 = nonzeros(kstate(:,3));
|
||||
j4 = find(kstate(:,3));
|
||||
% derivatives with respect to exogenous variables
|
||||
if M_.exo_nbr
|
||||
fu = aa(:,nz+(1:M_.exo_nbr));
|
||||
a1 = b;
|
||||
aa1 = [];
|
||||
if nstatic > 0
|
||||
aa1 = a1(:,1:nstatic);
|
||||
end
|
||||
dr.ghu = -[aa1 a(:,j3)*gx(j4,1:npred)+a1(:,nstatic+1:nstatic+ ...
|
||||
npred) a1(:,nstatic+npred+1:end)]\fu;
|
||||
else
|
||||
dr.ghu = [];
|
||||
end
|
||||
|
||||
% static variables
|
||||
if nstatic > 0
|
||||
temp = -a(1:nstatic,j3)*gx(j4,:)*hx;
|
||||
j5 = find(kstate(n4:nd,4));
|
||||
temp(:,j5) = temp(:,j5)-a(1:nstatic,nonzeros(kstate(:,4)));
|
||||
temp = b10\(temp-b11*dr.ghx);
|
||||
dr.ghx = [temp; dr.ghx];
|
||||
temp = [];
|
||||
end
|
||||
|
||||
if options.use_qzdiv
|
||||
%% Necessary when using Sims' routines for QZ
|
||||
gx = real(gx);
|
||||
hx = real(hx);
|
||||
dr.ghx = real(dr.ghx);
|
||||
dr.ghu = real(dr.ghu);
|
||||
end
|
||||
|
||||
dr.Gy = hx;
|
|
@ -0,0 +1,124 @@
|
|||
function [jacobia_,dr,info,M_,oo_] = dyn_ramsey_linearized_foc(dr,M_,options_,oo_)
|
||||
% function [jacobia_,dr,info,M_,oo_] = dyn_ramsey_linearized_foc(dr,M_,options_,oo_)
|
||||
% computes the Jacobian of the linear approximation of the F.O.C of a
|
||||
% Ramsey problem
|
||||
%
|
||||
% INPUTS
|
||||
% dr [matlab structure] Decision rules for stochastic simulations.
|
||||
% M_ [matlab structure] Definition of the model.
|
||||
% options_ [matlab structure] Global options.
|
||||
% oo_ [matlab structure] Results
|
||||
%
|
||||
% OUTPUTS
|
||||
% dr [matlab structure] Decision rules for stochastic simulations.
|
||||
% info [integer] info=1: the model doesn't define current variables uniquely
|
||||
% info=2: problem in mjdgges.dll info(2) contains error code.
|
||||
% info=3: BK order condition not satisfied info(2) contains "distance"
|
||||
% absence of stable trajectory.
|
||||
% info=4: BK order condition not satisfied info(2) contains "distance"
|
||||
% indeterminacy.
|
||||
% info=5: BK rank condition not satisfied.
|
||||
% info=6: The jacobian matrix evaluated at the steady state is complex.
|
||||
% M_ [matlab structure]
|
||||
% options_ [matlab structure]
|
||||
% oo_ [matlab structure]
|
||||
%
|
||||
% ALGORITHM
|
||||
% ...
|
||||
%
|
||||
% SPECIAL REQUIREMENTS
|
||||
% none.
|
||||
%
|
||||
|
||||
% Copyright (C) 1996-2009 Dynare Team
|
||||
%
|
||||
% This file is part of Dynare.
|
||||
%
|
||||
% Dynare is free software: you can redistribute it and/or modify
|
||||
% it under the terms of the GNU General Public License as published by
|
||||
% the Free Software Foundation, either version 3 of the License, or
|
||||
% (at your option) any later version.
|
||||
%
|
||||
% Dynare is distributed in the hope that it will be useful,
|
||||
% but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
% GNU General Public License for more details.
|
||||
%
|
||||
% You should have received a copy of the GNU General Public License
|
||||
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
info = 0;
|
||||
|
||||
if isfield(M_,'orig_model')
|
||||
orig_model = M_.orig_model;
|
||||
M_.endo_nbr = orig_model.endo_nbr;
|
||||
M_.orig_endo_nbr = orig_model.orig_endo_nbr;
|
||||
M_.aux_vars = orig_model.aux_vars;
|
||||
M_.endo_names = orig_model.endo_names;
|
||||
M_.lead_lag_incidence = orig_model.lead_lag_incidence;
|
||||
M_.maximum_lead = orig_model.maximum_lead;
|
||||
M_.maximum_endo_lead = orig_model.maximum_endo_lead;
|
||||
M_.maximum_lag = orig_model.maximum_lag;
|
||||
M_.maximum_endo_lag = orig_model.maximum_endo_lag;
|
||||
end
|
||||
|
||||
if options_.steadystate_flag
|
||||
k_inst = [];
|
||||
instruments = options_.instruments;
|
||||
for i = 1:size(instruments,1)
|
||||
k_inst = [k_inst; strmatch(options_.instruments(i,:), ...
|
||||
M_.endo_names,'exact')];
|
||||
end
|
||||
ys = oo_.steady_state;
|
||||
[inst_val,info1] = dynare_solve('dyn_ramsey_static_', ...
|
||||
oo_.steady_state(k_inst),0, ...
|
||||
M_,options_,oo_,it_);
|
||||
M_.params = evalin('base','M_.params;');
|
||||
ys(k_inst) = inst_val;
|
||||
[x,check] = feval([M_.fname '_steadystate'],...
|
||||
ys,[oo_.exo_steady_state; ...
|
||||
oo_.exo_det_steady_state]);
|
||||
if size(x,1) < M_.endo_nbr
|
||||
if length(M_.aux_vars) > 0
|
||||
x = add_auxiliary_variables_to_steadystate(x,M_.aux_vars,...
|
||||
M_.fname,...
|
||||
oo_.exo_steady_state,...
|
||||
oo_.exo_det_steady_state,...
|
||||
M_.params);
|
||||
else
|
||||
error([M_.fname '_steadystate.m doesn''t match the model']);
|
||||
end
|
||||
end
|
||||
oo_.steady_state = x;
|
||||
[junk,junk,multbar] = dyn_ramsey_static_(oo_.steady_state(k_inst),M_,options_,oo_,it_);
|
||||
else
|
||||
[oo_.steady_state,info1] = dynare_solve('dyn_ramsey_static_', ...
|
||||
oo_.steady_state,0,M_,options_,oo_,it_);
|
||||
[junk,junk,multbar] = dyn_ramsey_static_(oo_.steady_state,M_,options_,oo_,it_);
|
||||
end
|
||||
|
||||
check1 = max(abs(feval([M_.fname '_static'],...
|
||||
oo_.steady_state,...
|
||||
[oo_.exo_steady_state; ...
|
||||
oo_.exo_det_steady_state], M_.params))) > options_.dynatol ;
|
||||
if check1
|
||||
info(1) = 20;
|
||||
info(2) = check1'*check1;
|
||||
return
|
||||
end
|
||||
|
||||
[jacobia_,M_] = dyn_ramsey_dynamic_(oo_.steady_state,multbar,M_,options_,oo_,it_);
|
||||
klen = M_.maximum_lag + M_.maximum_lead + 1;
|
||||
dr.ys = [oo_.steady_state;zeros(M_.exo_nbr,1);multbar];
|
||||
oo_.steady_state = dr.ys;
|
||||
|
||||
if options_.noprint == 0
|
||||
disp_steady_state(M_,oo_)
|
||||
for i=M_.orig_endo_nbr:M_.endo_nbr
|
||||
if strmatch('mult_',M_.endo_names(i,:))
|
||||
disp(sprintf('%s \t\t %g',M_.endo_names(i,:), ...
|
||||
dr.ys(i)));
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,452 @@
|
|||
function [dr,info] = dyn_risky_steadystate_solver(ys0,M, ...
|
||||
dr,options,oo)
|
||||
|
||||
info = 0;
|
||||
lead_lag_incidence = M.lead_lag_incidence;
|
||||
order_var = dr.order_var;
|
||||
exo_nbr = M.exo_nbr;
|
||||
|
||||
M.var_order_endo_names = M.endo_names(dr.order_var,:);
|
||||
|
||||
[junk,dr.i_fwrd_g,i_fwrd_f] = find(lead_lag_incidence(3,order_var));
|
||||
dr.i_fwrd_f = i_fwrd_f;
|
||||
nd = nnz(lead_lag_incidence) + M.exo_nbr;
|
||||
dr.nd = nd;
|
||||
kk = reshape(1:nd^2,nd,nd);
|
||||
kkk = reshape(1:nd^3,nd^2,nd);
|
||||
dr.i_fwrd2_f = kk(i_fwrd_f,i_fwrd_f);
|
||||
dr.i_fwrd2a_f = kk(i_fwrd_f,:);
|
||||
dr.i_fwrd3_f = kkk(dr.i_fwrd2_f,:);
|
||||
dr.i_uu = kk(end-exo_nbr+1:end,end-exo_nbr+1:end);
|
||||
if options.k_order_solver
|
||||
func = @risky_residuals_k_order;
|
||||
else
|
||||
func = @risky_residuals;
|
||||
end
|
||||
|
||||
if isfield(options,'portfolio') && options.portfolio == 1
|
||||
eq_tags = M.equations_tags;
|
||||
n_tags = size(eq_tags,1);
|
||||
l_var = zeros(n_tags,1);
|
||||
for i=1:n_tags
|
||||
l_var(i) = find(strncmp(eq_tags(i,3),M.endo_names, ...
|
||||
length(cell2mat(eq_tags(i,3)))));
|
||||
end
|
||||
dr.ys = ys0;
|
||||
x0 = ys0(l_var);
|
||||
% dr = first_step_ds(x0,M,dr,options,oo);
|
||||
n = size(ys0);
|
||||
%x0 = ys0;
|
||||
[x, info] = solve1(@risky_residuals_ds,x0,1:n_tags,1:n_tags,0,1,M,dr,options,oo);
|
||||
%[x, info] = solve1(@risky_residuals,x0,1:n,1:n,0,1,M,dr,options,oo);
|
||||
% ys0(l_var) = x;
|
||||
ys0(l_var) = x;
|
||||
dr.ys = ys0;
|
||||
oo.dr = dr;
|
||||
oo.steady_state = ys0;
|
||||
disp_steady_state(M,oo);
|
||||
end
|
||||
|
||||
[ys, info] = csolve(func,ys0,[],1e-10,100,M,dr,options,oo);
|
||||
|
||||
if options.k_order_solver
|
||||
[resid,dr] = risky_residuals_k_order(ys,M,dr,options,oo);
|
||||
else
|
||||
[resid,dr] = risky_residuals(ys,M,dr,options,oo);
|
||||
end
|
||||
|
||||
dr.ys = ys;
|
||||
for i=1:M.endo_nbr
|
||||
disp(sprintf('%16s %12.6f %12.6f',M.endo_names(i,:),ys0(i), ys(i)))
|
||||
end
|
||||
|
||||
dr.ghs2 = zeros(size(dr.ghs2));
|
||||
|
||||
k_var = setdiff(1:M.endo_nbr,l_var);
|
||||
dr.ghx(k_var,:) = dr.ghx;
|
||||
dr.ghu(k_var,:) = dr.ghu;
|
||||
dr.ghxx(k_var,:) = dr.ghxx;
|
||||
dr.ghxu(k_var,:) = dr.ghxu;
|
||||
dr.ghuu(k_var,:) = dr.ghuu;
|
||||
dr.ghs2(k_var,:) = dr.ghs2;
|
||||
end
|
||||
|
||||
function [resid,dr] = risky_residuals(ys,M,dr,options,oo)
|
||||
persistent old_ys old_resid
|
||||
|
||||
lead_lag_incidence = M.lead_lag_incidence;
|
||||
iyv = lead_lag_incidence';
|
||||
iyv = iyv(:);
|
||||
iyr0 = find(iyv) ;
|
||||
|
||||
if M.exo_nbr == 0
|
||||
oo.exo_steady_state = [] ;
|
||||
end
|
||||
|
||||
z = repmat(ys,1,3);
|
||||
z = z(iyr0) ;
|
||||
[resid1,d1,d2] = feval([M.fname '_dynamic'],z,...
|
||||
[oo.exo_simul ...
|
||||
oo.exo_det_simul], M.params, dr.ys, 2);
|
||||
if ~isreal(d1) || ~isreal(d2)
|
||||
pause
|
||||
end
|
||||
|
||||
if options.use_dll
|
||||
% In USE_DLL mode, the hessian is in the 3-column sparse representation
|
||||
d2 = sparse(d2(:,1), d2(:,2), d2(:,3), ...
|
||||
size(d1, 1), size(d1, 2)*size(d1, 2));
|
||||
end
|
||||
|
||||
if isfield(options,'portfolio') && options.portfolio == 1
|
||||
eq_tags = M.equations_tags;
|
||||
n_tags = size(eq_tags,1);
|
||||
portfolios_eq = cell2mat(eq_tags(strcmp(eq_tags(:,2), ...
|
||||
'portfolio'),1));
|
||||
eq = setdiff(1:M.endo_nbr,portfolios_eq);
|
||||
l_var = zeros(n_tags,1);
|
||||
for i=1:n_tags
|
||||
l_var(i) = find(strncmp(eq_tags(i,3),M.endo_names, ...
|
||||
length(cell2mat(eq_tags(i,3)))));
|
||||
end
|
||||
k_var = setdiff(1:M.endo_nbr,l_var);
|
||||
lli1 = lead_lag_incidence(:,k_var);
|
||||
lead_incidence = lli1(3,:)';
|
||||
k = find(lli1');
|
||||
lli2 = lli1';
|
||||
lli2(k) = 1:nnz(lli1);
|
||||
lead_lag_incidence = lli2';
|
||||
x = ys(l_var);
|
||||
dr = first_step_ds(x,M,dr,options,oo);
|
||||
|
||||
|
||||
M.lead_lag_incidence = lead_lag_incidence;
|
||||
lli1a = [nonzeros(lli1'); size(d1,2)+(-M.exo_nbr+1:0)'];
|
||||
d1a = d1(eq,lli1a);
|
||||
ih = 1:size(d2,2);
|
||||
ih = reshape(ih,size(d1,2),size(d1,2));
|
||||
ih1 = ih(lli1a,lli1a);
|
||||
d2a = d2(eq,ih1);
|
||||
|
||||
M.endo_nbr = M.endo_nbr-n_tags;
|
||||
dr = set_state_space(dr,M);
|
||||
|
||||
[junk,dr.i_fwrd_g] = find(lead_lag_incidence(3,dr.order_var));
|
||||
i_fwrd_f = nonzeros(lead_incidence(dr.order_var));
|
||||
i_fwrd2_f = ih(i_fwrd_f,i_fwrd_f);
|
||||
dr.i_fwrd_f = i_fwrd_f;
|
||||
dr.i_fwrd2_f = i_fwrd2_f;
|
||||
nd = nnz(lead_lag_incidence) + M.exo_nbr;
|
||||
dr.nd = nd;
|
||||
kk = reshape(1:nd^2,nd,nd);
|
||||
kkk = reshape(1:nd^3,nd^2,nd);
|
||||
dr.i_fwrd2a_f = kk(i_fwrd_f,:);
|
||||
% dr.i_fwrd3_f = kkk(i_fwrd2_f,:);
|
||||
dr.i_uu = kk(end-M.exo_nbr+1:end,end-M.exo_nbr+1:end);
|
||||
else
|
||||
d1a = d1;
|
||||
d2a = d2;
|
||||
end
|
||||
|
||||
% $$$ [junk,cols_b,cols_j] = find(lead_lag_incidence(2,dr.order_var));
|
||||
% $$$ b = zeros(M.endo_nbr,M.endo_nbr);
|
||||
% $$$ b(:,cols_b) = d1a(:,cols_j);
|
||||
% $$$
|
||||
% $$$ [dr,info] = dyn_first_order_solver(d1a,b,M,dr,options,0);
|
||||
% $$$ if info
|
||||
% $$$ [m1,m2]=max(abs(ys-old_ys));
|
||||
% $$$ disp([m1 m2])
|
||||
% $$$ % print_info(info,options.noprint);
|
||||
% $$$ resid = old_resid+info(2)/40;
|
||||
% $$$ return
|
||||
% $$$ end
|
||||
% $$$
|
||||
% $$$ dr = dyn_second_order_solver(d1a,d2a,dr,M);
|
||||
|
||||
gu1 = dr.ghu(dr.i_fwrd_g,:);
|
||||
|
||||
resid = resid1+0.5*(d1(:,dr.i_fwrd_f)*dr.ghuu(dr.i_fwrd_g,:)+ ...
|
||||
d2(:,dr.i_fwrd2_f)*kron(gu1,gu1))*vec(M.Sigma_e);
|
||||
disp(d1(:,dr.i_fwrd_f)*dr.ghuu(dr.i_fwrd_g,:)*vec(M.Sigma_e));
|
||||
old_ys = ys;
|
||||
disp(max(abs(resid)))
|
||||
old_resid = resid;
|
||||
end
|
||||
|
||||
function [resid,dr] = risky_residuals_ds(x,M,dr,options,oo)
|
||||
persistent old_ys old_resid old_resid1 old_d1 old_d2
|
||||
|
||||
dr = first_step_ds(x,M,dr,options,oo);
|
||||
|
||||
lead_lag_incidence = M.lead_lag_incidence;
|
||||
iyv = lead_lag_incidence';
|
||||
iyv = iyv(:);
|
||||
iyr0 = find(iyv) ;
|
||||
|
||||
if M.exo_nbr == 0
|
||||
oo.exo_steady_state = [] ;
|
||||
end
|
||||
|
||||
eq_tags = M.equations_tags;
|
||||
n_tags = size(eq_tags,1);
|
||||
portfolios_eq = cell2mat(eq_tags(strcmp(eq_tags(:,2), ...
|
||||
'portfolio'),1));
|
||||
eq = setdiff(1:M.endo_nbr,portfolios_eq);
|
||||
l_var = zeros(n_tags,1);
|
||||
for i=1:n_tags
|
||||
l_var(i) = find(strncmp(eq_tags(i,3),M.endo_names, ...
|
||||
length(cell2mat(eq_tags(i,3)))));
|
||||
end
|
||||
k_var = setdiff(1:M.endo_nbr,l_var);
|
||||
lli1 = lead_lag_incidence(:,k_var);
|
||||
k = find(lli1');
|
||||
lli2 = lli1';
|
||||
lli2(k) = 1:nnz(lli1);
|
||||
lead_lag_incidence = lli2';
|
||||
|
||||
ys = dr.ys;
|
||||
ys(l_var) = x;
|
||||
|
||||
z = repmat(ys,1,3);
|
||||
z = z(iyr0) ;
|
||||
[resid1,d1,d2] = feval([M.fname '_dynamic'],z,...
|
||||
[oo.exo_simul ...
|
||||
oo.exo_det_simul], M.params, dr.ys, 2);
|
||||
% $$$ if isempty(old_resid)
|
||||
% $$$ old_resid1 = resid1;
|
||||
% $$$ old_d1 = d1;
|
||||
% $$$ old_d2 = d2;
|
||||
% $$$ old_ys = ys;
|
||||
% $$$ else
|
||||
% $$$ if ~isequal(resid1,old_resid)
|
||||
% $$$ disp('ys')
|
||||
% $$$ disp((ys-old_ys)');
|
||||
% $$$ disp('resids1')
|
||||
% $$$ disp((resid1-old_resid1)')
|
||||
% $$$ old_resid1 = resid1;
|
||||
% $$$ pause
|
||||
% $$$ end
|
||||
% $$$ if ~isequal(d1,old_d1)
|
||||
% $$$ disp('d1')
|
||||
% $$$ disp(d1-old_d1);
|
||||
% $$$ old_d1 = d1;
|
||||
% $$$ pause
|
||||
% $$$ end
|
||||
% $$$ if ~isequal(d2,old_d2)
|
||||
% $$$ disp('d2')
|
||||
% $$$ disp(d2-old_d2);
|
||||
% $$$ old_d2 = d2;
|
||||
% $$$ pause
|
||||
% $$$ end
|
||||
% $$$ end
|
||||
if ~isreal(d1) || ~isreal(d2)
|
||||
pause
|
||||
end
|
||||
|
||||
if options.use_dll
|
||||
% In USE_DLL mode, the hessian is in the 3-column sparse representation
|
||||
d2 = sparse(d2(:,1), d2(:,2), d2(:,3), ...
|
||||
size(d1, 1), size(d1, 2)*size(d1, 2));
|
||||
end
|
||||
|
||||
% $$$ if isfield(options,'portfolio') && options.portfolio == 1
|
||||
% $$$ lli1a = [nonzeros(lli1'); size(d1,2)+(-M.exo_nbr+1:0)'];
|
||||
% $$$ d1a = d1(eq,lli1a);
|
||||
% $$$ ih = 1:size(d2,2);
|
||||
% $$$ ih = reshape(ih,size(d1,2),size(d1,2));
|
||||
% $$$ ih1 = ih(lli1a,lli1a);
|
||||
% $$$ d2a = d2(eq,ih1);
|
||||
% $$$
|
||||
% $$$ M.endo_nbr = M.endo_nbr-n_tags;
|
||||
% $$$ dr = set_state_space(dr,M);
|
||||
% $$$
|
||||
% $$$ dr.i_fwrd_g = find(lead_lag_incidence(3,dr.order_var)');
|
||||
% $$$ else
|
||||
% $$$ d1a = d1;
|
||||
% $$$ d2a = d2;
|
||||
% $$$ end
|
||||
% $$$
|
||||
% $$$ [junk,cols_b,cols_j] = find(lead_lag_incidence(2,dr.order_var));
|
||||
% $$$ b = zeros(M.endo_nbr,M.endo_nbr);
|
||||
% $$$ b(:,cols_b) = d1a(:,cols_j);
|
||||
% $$$
|
||||
% $$$ [dr,info] = dyn_first_order_solver(d1a,b,M,dr,options,0);
|
||||
% $$$ if info
|
||||
% $$$ [m1,m2]=max(abs(ys-old_ys));
|
||||
% $$$ disp([m1 m2])
|
||||
% $$$ % print_info(info,options.noprint);
|
||||
% $$$ resid = old_resid+info(2)/40;
|
||||
% $$$ return
|
||||
% $$$ end
|
||||
% $$$
|
||||
% $$$ dr = dyn_second_order_solver(d1a,d2a,dr,M);
|
||||
|
||||
gu1 = dr.ghu(dr.i_fwrd_g,:);
|
||||
|
||||
% resid = resid1+0.5*(d1(:,dr.i_fwrd_f)*dr.ghuu(dr.i_fwrd_g,:)+ ...
|
||||
% d2(:,dr.i_fwrd2_f)*kron(gu1,gu1))*vec(M.Sigma_e);
|
||||
resid = resid1+0.5*(d2(:,dr.i_fwrd2_f)*kron(gu1,gu1))*vec(M.Sigma_e);
|
||||
|
||||
% $$$ if isempty(old_resid)
|
||||
% $$$ old_resid = resid;
|
||||
% $$$ else
|
||||
% $$$ disp('resid')
|
||||
% $$$ dr = (resid-old_resid)';
|
||||
% $$$ % disp(dr)
|
||||
% $$$ % disp(dr(portfolios_eq))
|
||||
% $$$ old_resid = resid;
|
||||
% $$$ end
|
||||
resid = resid(portfolios_eq)
|
||||
end
|
||||
|
||||
function [dr] = first_step_ds(x,M,dr,options,oo)
|
||||
|
||||
lead_lag_incidence = M.lead_lag_incidence;
|
||||
iyv = lead_lag_incidence';
|
||||
iyv = iyv(:);
|
||||
iyr0 = find(iyv) ;
|
||||
|
||||
if M.exo_nbr == 0
|
||||
oo.exo_steady_state = [] ;
|
||||
end
|
||||
|
||||
eq_tags = M.equations_tags;
|
||||
n_tags = size(eq_tags,1);
|
||||
portfolios_eq = cell2mat(eq_tags(strcmp(eq_tags(:,2), ...
|
||||
'portfolio'),1));
|
||||
eq = setdiff(1:M.endo_nbr,portfolios_eq);
|
||||
l_var = zeros(n_tags,1);
|
||||
for i=1:n_tags
|
||||
l_var(i) = find(strncmp(eq_tags(i,3),M.endo_names, ...
|
||||
length(cell2mat(eq_tags(i,3)))));
|
||||
end
|
||||
k_var = setdiff(1:M.endo_nbr,l_var);
|
||||
lli1 = lead_lag_incidence(:,k_var);
|
||||
k = find(lli1');
|
||||
lli2 = lli1';
|
||||
lli2(k) = 1:nnz(lli1);
|
||||
lead_lag_incidence = lli2';
|
||||
M.lead_lag_incidence = lead_lag_incidence;
|
||||
|
||||
ys = dr.ys;
|
||||
ys(l_var) = x;
|
||||
|
||||
z = repmat(ys,1,3);
|
||||
z = z(iyr0) ;
|
||||
[resid1,d1,d2] = feval([M.fname '_dynamic'],z,...
|
||||
[oo.exo_simul ...
|
||||
oo.exo_det_simul], M.params, dr.ys, 2);
|
||||
if ~isreal(d1) || ~isreal(d2)
|
||||
pause
|
||||
end
|
||||
|
||||
if options.use_dll
|
||||
% In USE_DLL mode, the hessian is in the 3-column sparse representation
|
||||
d2 = sparse(d2(:,1), d2(:,2), d2(:,3), ...
|
||||
size(d1, 1), size(d1, 2)*size(d1, 2));
|
||||
end
|
||||
|
||||
if isfield(options,'portfolio') && options.portfolio == 1
|
||||
lli1a = [nonzeros(lli1'); size(d1,2)+(-M.exo_nbr+1:0)'];
|
||||
d1a = d1(eq,lli1a);
|
||||
ih = 1:size(d2,2);
|
||||
ih = reshape(ih,size(d1,2),size(d1,2));
|
||||
ih1 = ih(lli1a,lli1a);
|
||||
d2a = d2(eq,ih1);
|
||||
|
||||
M.endo_nbr = M.endo_nbr-n_tags;
|
||||
dr = set_state_space(dr,M);
|
||||
|
||||
dr.i_fwrd_g = find(lead_lag_incidence(3,dr.order_var)');
|
||||
else
|
||||
d1a = d1;
|
||||
d2a = d2;
|
||||
end
|
||||
|
||||
[junk,cols_b,cols_j] = find(lead_lag_incidence(2,dr.order_var));
|
||||
b = zeros(M.endo_nbr,M.endo_nbr);
|
||||
b(:,cols_b) = d1a(:,cols_j);
|
||||
|
||||
[dr,info] = dyn_first_order_solver(d1a,b,M,dr,options,0);
|
||||
if info
|
||||
[m1,m2]=max(abs(ys-old_ys));
|
||||
disp([m1 m2])
|
||||
% print_info(info,options.noprint);
|
||||
resid = old_resid+info(2)/40;
|
||||
return
|
||||
end
|
||||
|
||||
dr = dyn_second_order_solver(d1a,d2a,dr,M,...
|
||||
options.threads.kronecker.A_times_B_kronecker_C,...
|
||||
options.threads.kronecker.sparse_hessian_times_B_kronecker_C);
|
||||
end
|
||||
|
||||
function [resid,dr] = risky_residuals_k_order(ys,M,dr,options,oo)
|
||||
|
||||
lead_lag_incidence = M.lead_lag_incidence;
|
||||
npred = dr.npred;
|
||||
exo_nbr = M.exo_nbr;
|
||||
vSigma_e = vec(M.Sigma_e);
|
||||
|
||||
iyv = lead_lag_incidence';
|
||||
iyv = iyv(:);
|
||||
iyr0 = find(iyv) ;
|
||||
|
||||
if M.exo_nbr == 0
|
||||
oo.exo_steady_state = [] ;
|
||||
end
|
||||
|
||||
z = repmat(ys,1,3);
|
||||
z = z(iyr0) ;
|
||||
[resid1,d1,d2,d3] = feval([M.fname '_dynamic'],z,...
|
||||
[oo.exo_simul ...
|
||||
oo.exo_det_simul], M.params, dr.ys, 2);
|
||||
|
||||
hessian = sparse(d2(:,1), d2(:,2), d2(:,3), ...
|
||||
size(d1, 1), size(d1, 2)*size(d1, 2));
|
||||
fy3 = sparse(d2(:,1), d2(:,2), d2(:,3), ...
|
||||
size(d1, 1), size(d1, 2)^3);
|
||||
|
||||
options.order = 3;
|
||||
|
||||
nu2 = exo_nbr*(exo_nbr+1)/2;
|
||||
% $$$ d1_0 = d1;
|
||||
% $$$ gu1 = dr.ghu(dr.i_fwrd_g,:);
|
||||
% $$$ guu = dr.ghuu;
|
||||
% $$$ for i=1:2
|
||||
% $$$ d1 = d1_0 + 0.5*(hessian(:,dr.i_fwrd2a_f)*kron(eye(dr.nd),guu(dr.i_fwrd_g,:)*vSigma_e)+ ...
|
||||
% $$$ fy3(:,dr.i_fwrd3_f)*kron(eye(dr.nd),kron(gu1,gu1)*vSigma_e));
|
||||
% $$$ [junk,cols_b,cols_j] = find(lead_lag_incidence(2,dr.order_var));
|
||||
% $$$ b = zeros(M.endo_nbr,M.endo_nbr);
|
||||
% $$$ b(:,cols_b) = d1(:,cols_j);
|
||||
|
||||
% $$$ [dr,info] = dyn_first_order_solver(d1,b,M,dr,options,0);
|
||||
[g_0, g_1, g_2, g_3] = k_order_perturbation(dr,0,M,options, oo , ['.' ...
|
||||
mexext],d1,d2,d3);
|
||||
gu1 = g_1(dr.i_fwrd_g,end-exo_nbr+1:end);
|
||||
guu = unfold(g_2(:,end-nu2+1:end),exo_nbr);
|
||||
d1old = d1;
|
||||
% disp(max(max(abs(d1-d1old))));
|
||||
% end
|
||||
|
||||
[junk,cols_b,cols_j] = find(lead_lag_incidence(2,dr.order_var));
|
||||
|
||||
resid = resid1+0.5*(d1(:,dr.i_fwrd_f)*guu(dr.i_fwrd_g,:)+hessian(:,dr.i_fwrd2_f)*kron(gu1,gu1))*vec(M.Sigma_e);
|
||||
|
||||
if nargout > 1
|
||||
[dr,info] = k_order_pert(dr,M,options,oo);
|
||||
end
|
||||
end
|
||||
|
||||
function y=unfold(x,n)
|
||||
y = zeros(size(x,1),n*n);
|
||||
k = 1;
|
||||
for i=1:n
|
||||
for j=i:n
|
||||
y(:,(i-1)*n+j) = x(:,k);
|
||||
if i ~= j
|
||||
y(:,(j-1)*n+i) = x(:,k);
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
|
@ -0,0 +1,199 @@
|
|||
function dr = dyn_second_order_solver(jacobia,hessian1,dr,M_,threads_ABC,threads_BC)
|
||||
|
||||
|
||||
dr.ghxx = [];
|
||||
dr.ghuu = [];
|
||||
dr.ghxu = [];
|
||||
dr.ghs2 = [];
|
||||
Gy = dr.Gy;
|
||||
|
||||
kstate = dr.kstate;
|
||||
kad = dr.kad;
|
||||
kae = dr.kae;
|
||||
nstatic = dr.nstatic;
|
||||
nfwrd = dr.nfwrd;
|
||||
npred = dr.npred;
|
||||
nboth = dr.nboth;
|
||||
nyf = nfwrd+nboth;
|
||||
order_var = dr.order_var;
|
||||
nd = size(kstate,1);
|
||||
lead_lag_incidence = M_.lead_lag_incidence;
|
||||
|
||||
np = nd - nyf;
|
||||
n2 = np + 1;
|
||||
n3 = nyf;
|
||||
n4 = n3 + 1;
|
||||
|
||||
k1 = nonzeros(lead_lag_incidence(:,order_var)');
|
||||
kk = [k1; length(k1)+(1:M_.exo_nbr+M_.exo_det_nbr)'];
|
||||
nk = size(kk,1);
|
||||
kk1 = reshape([1:nk^2],nk,nk);
|
||||
kk1 = kk1(kk,kk);
|
||||
hessian = hessian1(:,kk1(:));
|
||||
clear hessian1
|
||||
|
||||
zx = zeros(np,np);
|
||||
zu=zeros(np,M_.exo_nbr);
|
||||
zx(1:np,:)=eye(np);
|
||||
k0 = [1:M_.endo_nbr];
|
||||
gx1 = dr.ghx;
|
||||
hu = dr.ghu(nstatic+[1:npred],:);
|
||||
k0 = find(lead_lag_incidence(M_.maximum_endo_lag+1,order_var)');
|
||||
zx = [zx; gx1(k0,:)];
|
||||
zu = [zu; dr.ghu(k0,:)];
|
||||
k1 = find(lead_lag_incidence(M_.maximum_endo_lag+2,order_var)');
|
||||
zu = [zu; gx1(k1,:)*hu];
|
||||
zx = [zx; gx1(k1,:)*Gy];
|
||||
zx=[zx; zeros(M_.exo_nbr,np);zeros(M_.exo_det_nbr,np)];
|
||||
zu=[zu; eye(M_.exo_nbr);zeros(M_.exo_det_nbr,M_.exo_nbr)];
|
||||
[nrzx,nczx] = size(zx);
|
||||
|
||||
[rhs, err] = sparse_hessian_times_B_kronecker_C(hessian,zx,threads_BC);
|
||||
mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
|
||||
rhs = -rhs;
|
||||
|
||||
%lhs
|
||||
n = M_.endo_nbr+sum(kstate(:,2) > M_.maximum_endo_lag+1 & kstate(:,2) < M_.maximum_endo_lag+M_.maximum_endo_lead+1);
|
||||
A = zeros(M_.endo_nbr,M_.endo_nbr);
|
||||
B = zeros(M_.endo_nbr,M_.endo_nbr);
|
||||
A(:,k0) = jacobia(:,nonzeros(lead_lag_incidence(M_.maximum_endo_lag+1,order_var)));
|
||||
% variables with the highest lead
|
||||
k1 = find(kstate(:,2) == M_.maximum_endo_lag+2);
|
||||
% Jacobian with respect to the variables with the highest lead
|
||||
fyp = jacobia(:,kstate(k1,3)+nnz(M_.lead_lag_incidence(M_.maximum_endo_lag+1,:)));
|
||||
B(:,nstatic+npred-dr.nboth+1:end) = fyp;
|
||||
offset = M_.endo_nbr;
|
||||
gx1 = dr.ghx;
|
||||
[junk,k1,k2] = find(M_.lead_lag_incidence(M_.maximum_endo_lag+M_.maximum_endo_lead+1,order_var));
|
||||
A(1:M_.endo_nbr,nstatic+1:nstatic+npred)=...
|
||||
A(1:M_.endo_nbr,nstatic+[1:npred])+fyp*gx1(k1,1:npred);
|
||||
C = Gy;
|
||||
D = [rhs; zeros(n-M_.endo_nbr,size(rhs,2))];
|
||||
|
||||
|
||||
[err, dr.ghxx] = gensylv(2,A,B,C,D);
|
||||
mexErrCheck('gensylv', err);
|
||||
|
||||
%ghxu
|
||||
%rhs
|
||||
hu = dr.ghu(nstatic+1:nstatic+npred,:);
|
||||
[rhs, err] = sparse_hessian_times_B_kronecker_C(hessian,zx,zu,threads_BC);
|
||||
mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
|
||||
|
||||
hu1 = [hu;zeros(np-npred,M_.exo_nbr)];
|
||||
[nrhx,nchx] = size(Gy);
|
||||
[nrhu1,nchu1] = size(hu1);
|
||||
|
||||
[abcOut,err] = A_times_B_kronecker_C(dr.ghxx,Gy,hu1,threads_ABC);
|
||||
mexErrCheck('A_times_B_kronecker_C', err);
|
||||
B1 = B*abcOut;
|
||||
rhs = -[rhs; zeros(n-M_.endo_nbr,size(rhs,2))]-B1;
|
||||
|
||||
|
||||
%lhs
|
||||
dr.ghxu = A\rhs;
|
||||
|
||||
%ghuu
|
||||
%rhs
|
||||
[rhs, err] = sparse_hessian_times_B_kronecker_C(hessian,zu,threads_BC);
|
||||
mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
|
||||
|
||||
[B1, err] = A_times_B_kronecker_C(B*dr.ghxx,hu1,threads_ABC);
|
||||
mexErrCheck('A_times_B_kronecker_C', err);
|
||||
rhs = -[rhs; zeros(n-M_.endo_nbr,size(rhs,2))]-B1;
|
||||
|
||||
%lhs
|
||||
dr.ghuu = A\rhs;
|
||||
|
||||
dr.ghxx = dr.ghxx(1:M_.endo_nbr,:);
|
||||
dr.ghxu = dr.ghxu(1:M_.endo_nbr,:);
|
||||
rdr.ghuu = dr.ghuu(1:M_.endo_nbr,:);
|
||||
|
||||
|
||||
% dr.ghs2
|
||||
% derivatives of F with respect to forward variables
|
||||
% reordering predetermined variables in diminishing lag order
|
||||
O1 = zeros(M_.endo_nbr,nstatic);
|
||||
O2 = zeros(M_.endo_nbr,M_.endo_nbr-nstatic-npred);
|
||||
LHS = zeros(M_.endo_nbr,M_.endo_nbr);
|
||||
LHS(:,k0) = jacobia(:,nonzeros(lead_lag_incidence(M_.maximum_endo_lag+1,order_var)));
|
||||
RHS = zeros(M_.endo_nbr,M_.exo_nbr^2);
|
||||
kk = find(kstate(:,2) == M_.maximum_endo_lag+2);
|
||||
gu = dr.ghu;
|
||||
guu = dr.ghuu;
|
||||
Gu = [dr.ghu(nstatic+[1:npred],:); zeros(np-npred,M_.exo_nbr)];
|
||||
Guu = [dr.ghuu(nstatic+[1:npred],:); zeros(np-npred,M_.exo_nbr*M_.exo_nbr)];
|
||||
E = eye(M_.endo_nbr);
|
||||
kh = reshape([1:nk^2],nk,nk);
|
||||
kp = sum(kstate(:,2) <= M_.maximum_endo_lag+1);
|
||||
E1 = [eye(npred); zeros(kp-npred,npred)];
|
||||
H = E1;
|
||||
hxx = dr.ghxx(nstatic+[1:npred],:);
|
||||
[junk,k2a,k2] = find(M_.lead_lag_incidence(M_.maximum_endo_lag+2,order_var));
|
||||
k3 = nnz(M_.lead_lag_incidence(1:M_.maximum_endo_lag+1,:))+(1:dr.nsfwrd)';
|
||||
[B1, err] = sparse_hessian_times_B_kronecker_C(hessian(:,kh(k3,k3)),gu(k2a,:),threads_BC);
|
||||
mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
|
||||
RHS = RHS + jacobia(:,k2)*guu(k2a,:)+B1;
|
||||
|
||||
% LHS
|
||||
LHS = LHS + jacobia(:,k2)*(E(k2a,:)+[O1(k2a,:) dr.ghx(k2a,:)*H O2(k2a,:)]);
|
||||
|
||||
RHS = RHS*M_.Sigma_e(:);
|
||||
dr.fuu = RHS;
|
||||
%RHS = -RHS-dr.fbias;
|
||||
RHS = -RHS;
|
||||
dr.ghs2 = LHS\RHS;
|
||||
|
||||
% deterministic exogenous variables
|
||||
if M_.exo_det_nbr > 0
|
||||
hud = dr.ghud{1}(nstatic+1:nstatic+npred,:);
|
||||
zud=[zeros(np,M_.exo_det_nbr);dr.ghud{1};gx(:,1:npred)*hud;zeros(M_.exo_nbr,M_.exo_det_nbr);eye(M_.exo_det_nbr)];
|
||||
R1 = hessian*kron(zx,zud);
|
||||
dr.ghxud = cell(M_.exo_det_length,1);
|
||||
kf = [M_.endo_nbr-nyf+1:M_.endo_nbr];
|
||||
kp = nstatic+[1:npred];
|
||||
dr.ghxud{1} = -M1*(R1+f1*dr.ghxx(kf,:)*kron(dr.ghx(kp,:),dr.ghud{1}(kp,:)));
|
||||
Eud = eye(M_.exo_det_nbr);
|
||||
for i = 2:M_.exo_det_length
|
||||
hudi = dr.ghud{i}(kp,:);
|
||||
zudi=[zeros(np,M_.exo_det_nbr);dr.ghud{i};gx(:,1:npred)*hudi;zeros(M_.exo_nbr+M_.exo_det_nbr,M_.exo_det_nbr)];
|
||||
R2 = hessian*kron(zx,zudi);
|
||||
dr.ghxud{i} = -M2*(dr.ghxud{i-1}(kf,:)*kron(Gy,Eud)+dr.ghxx(kf,:)*kron(dr.ghx(kp,:),dr.ghud{i}(kp,:)))-M1*R2;
|
||||
end
|
||||
R1 = hessian*kron(zu,zud);
|
||||
dr.ghudud = cell(M_.exo_det_length,1);
|
||||
kf = [M_.endo_nbr-nyf+1:M_.endo_nbr];
|
||||
|
||||
dr.ghuud{1} = -M1*(R1+f1*dr.ghxx(kf,:)*kron(dr.ghu(kp,:),dr.ghud{1}(kp,:)));
|
||||
Eud = eye(M_.exo_det_nbr);
|
||||
for i = 2:M_.exo_det_length
|
||||
hudi = dr.ghud{i}(kp,:);
|
||||
zudi=[zeros(np,M_.exo_det_nbr);dr.ghud{i};gx(:,1:npred)*hudi;zeros(M_.exo_nbr+M_.exo_det_nbr,M_.exo_det_nbr)];
|
||||
R2 = hessian*kron(zu,zudi);
|
||||
dr.ghuud{i} = -M2*dr.ghxud{i-1}(kf,:)*kron(hu,Eud)-M1*R2;
|
||||
end
|
||||
R1 = hessian*kron(zud,zud);
|
||||
dr.ghudud = cell(M_.exo_det_length,M_.exo_det_length);
|
||||
dr.ghudud{1,1} = -M1*R1-M2*dr.ghxx(kf,:)*kron(hud,hud);
|
||||
for i = 2:M_.exo_det_length
|
||||
hudi = dr.ghud{i}(nstatic+1:nstatic+npred,:);
|
||||
zudi=[zeros(np,M_.exo_det_nbr);dr.ghud{i};gx(:,1:npred)*hudi+dr.ghud{i-1}(kf,:);zeros(M_.exo_nbr+M_.exo_det_nbr,M_.exo_det_nbr)];
|
||||
R2 = hessian*kron(zudi,zudi);
|
||||
dr.ghudud{i,i} = -M2*(dr.ghudud{i-1,i-1}(kf,:)+...
|
||||
2*dr.ghxud{i-1}(kf,:)*kron(hudi,Eud) ...
|
||||
+dr.ghxx(kf,:)*kron(hudi,hudi))-M1*R2;
|
||||
R2 = hessian*kron(zud,zudi);
|
||||
dr.ghudud{1,i} = -M2*(dr.ghxud{i-1}(kf,:)*kron(hud,Eud)+...
|
||||
dr.ghxx(kf,:)*kron(hud,hudi))...
|
||||
-M1*R2;
|
||||
for j=2:i-1
|
||||
hudj = dr.ghud{j}(kp,:);
|
||||
zudj=[zeros(np,M_.exo_det_nbr);dr.ghud{j};gx(:,1:npred)*hudj;zeros(M_.exo_nbr+M_.exo_det_nbr,M_.exo_det_nbr)];
|
||||
R2 = hessian*kron(zudj,zudi);
|
||||
dr.ghudud{j,i} = -M2*(dr.ghudud{j-1,i-1}(kf,:)+dr.ghxud{j-1}(kf,:)* ...
|
||||
kron(hudi,Eud)+dr.ghxud{i-1}(kf,:)* ...
|
||||
kron(hudj,Eud)+dr.ghxx(kf,:)*kron(hudj,hudi))-M1*R2;
|
||||
end
|
||||
|
||||
end
|
||||
end
|
|
@ -0,0 +1,206 @@
|
|||
function [dr,info,M_,options_,oo_] = stochastic_solvers(dr,task,M_,options_,oo_)
|
||||
% function [dr,info,M_,options_,oo_] = stochastic_solvers(dr,task,M_,options_,oo_)
|
||||
% computes the reduced form solution of a rational expectation model (first or second order
|
||||
% approximation of the stochastic model around the deterministic steady state).
|
||||
%
|
||||
% INPUTS
|
||||
% dr [matlab structure] Decision rules for stochastic simulations.
|
||||
% task [integer] if task = 0 then dr1 computes decision rules.
|
||||
% if task = 1 then dr1 computes eigenvalues.
|
||||
% M_ [matlab structure] Definition of the model.
|
||||
% options_ [matlab structure] Global options.
|
||||
% oo_ [matlab structure] Results
|
||||
%
|
||||
% OUTPUTS
|
||||
% dr [matlab structure] Decision rules for stochastic simulations.
|
||||
% info [integer] info=1: the model doesn't define current variables uniquely
|
||||
% info=2: problem in mjdgges.dll info(2) contains error code.
|
||||
% info=3: BK order condition not satisfied info(2) contains "distance"
|
||||
% absence of stable trajectory.
|
||||
% info=4: BK order condition not satisfied info(2) contains "distance"
|
||||
% indeterminacy.
|
||||
% info=5: BK rank condition not satisfied.
|
||||
% info=6: The jacobian matrix evaluated at the steady state is complex.
|
||||
% M_ [matlab structure]
|
||||
% options_ [matlab structure]
|
||||
% oo_ [matlab structure]
|
||||
%
|
||||
% ALGORITHM
|
||||
% ...
|
||||
%
|
||||
% SPECIAL REQUIREMENTS
|
||||
% none.
|
||||
%
|
||||
|
||||
% Copyright (C) 1996-2009 Dynare Team
|
||||
%
|
||||
% This file is part of Dynare.
|
||||
%
|
||||
% Dynare is free software: you can redistribute it and/or modify
|
||||
% it under the terms of the GNU General Public License as published by
|
||||
% the Free Software Foundation, either version 3 of the License, or
|
||||
% (at your option) any later version.
|
||||
%
|
||||
% Dynare is distributed in the hope that it will be useful,
|
||||
% but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
% GNU General Public License for more details.
|
||||
%
|
||||
% You should have received a copy of the GNU General Public License
|
||||
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
info = 0;
|
||||
|
||||
if (options_.aim_solver == 1) && (options_.order > 1)
|
||||
error('Option "aim_solver" is incompatible with order >= 2')
|
||||
end
|
||||
|
||||
if options_.k_order_solver;
|
||||
if options_.risky_steadystate
|
||||
[dr,info] = dyn_risky_steadystate_solver(oo_.steady_state,M_,dr, ...
|
||||
options_,oo_);
|
||||
else
|
||||
dr = set_state_space(dr,M_);
|
||||
[dr,info] = k_order_pert(dr,M_,options_,oo_);
|
||||
end
|
||||
return;
|
||||
end
|
||||
|
||||
if options_.ramsey_policy
|
||||
% expanding system for Optimal Linear Regulator
|
||||
[jacobia_,dr,info,M_,oo_] = dyn_ramsey_linearized_foc(dr,M_,options_,oo_);
|
||||
else
|
||||
klen = M_.maximum_lag + M_.maximum_lead + 1;
|
||||
iyv = M_.lead_lag_incidence';
|
||||
iyv = iyv(:);
|
||||
iyr0 = find(iyv) ;
|
||||
it_ = M_.maximum_lag + 1 ;
|
||||
|
||||
if M_.exo_nbr == 0
|
||||
oo_.exo_steady_state = [] ;
|
||||
end
|
||||
|
||||
it_ = M_.maximum_lag + 1;
|
||||
z = repmat(dr.ys,1,klen);
|
||||
z = z(iyr0) ;
|
||||
if options_.order == 1
|
||||
[junk,jacobia_] = feval([M_.fname '_dynamic'],z,[oo_.exo_simul ...
|
||||
oo_.exo_det_simul], M_.params, dr.ys, it_);
|
||||
elseif options_.order == 2
|
||||
[junk,jacobia_,hessian1] = feval([M_.fname '_dynamic'],z,...
|
||||
[oo_.exo_simul ...
|
||||
oo_.exo_det_simul], M_.params, dr.ys, it_);
|
||||
if options_.use_dll
|
||||
% In USE_DLL mode, the hessian is in the 3-column sparse representation
|
||||
hessian1 = sparse(hessian1(:,1), hessian1(:,2), hessian1(:,3), ...
|
||||
size(jacobia_, 1), size(jacobia_, 2)*size(jacobia_, 2));
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
if options_.debug
|
||||
save([M_.fname '_debug.mat'],'jacobia_')
|
||||
end
|
||||
|
||||
if ~isreal(jacobia_)
|
||||
if max(max(abs(imag(jacobia_)))) < 1e-15
|
||||
jacobia_ = real(jacobia_);
|
||||
else
|
||||
info(1) = 6;
|
||||
info(2) = sum(sum(imag(jacobia_).^2));
|
||||
return
|
||||
end
|
||||
end
|
||||
|
||||
kstate = dr.kstate;
|
||||
kad = dr.kad;
|
||||
kae = dr.kae;
|
||||
nstatic = dr.nstatic;
|
||||
nfwrd = dr.nfwrd;
|
||||
npred = dr.npred;
|
||||
nboth = dr.nboth;
|
||||
order_var = dr.order_var;
|
||||
nd = size(kstate,1);
|
||||
nz = nnz(M_.lead_lag_incidence);
|
||||
|
||||
sdyn = M_.endo_nbr - nstatic;
|
||||
|
||||
[junk,cols_b,cols_j] = find(M_.lead_lag_incidence(M_.maximum_endo_lag+1, ...
|
||||
order_var));
|
||||
b = zeros(M_.endo_nbr,M_.endo_nbr);
|
||||
b(:,cols_b) = jacobia_(:,cols_j);
|
||||
|
||||
if M_.maximum_endo_lead == 0
|
||||
% backward models: simplified code exist only at order == 1
|
||||
% If required, use AIM solver if not check only
|
||||
if options_.order == 1
|
||||
[k1,junk,k2] = find(kstate(:,4));
|
||||
temp = -b\jacobia_(:,[k2 nz+1:end]);
|
||||
dr.ghx = temp(:,1:npred);
|
||||
if M_.exo_nbr
|
||||
dr.ghu = temp(:,npred+1:end);
|
||||
end
|
||||
dr.eigval = eig(transition_matrix(dr));
|
||||
dr.rank = 0;
|
||||
if any(abs(dr.eigval) > options_.qz_criterium)
|
||||
temp = sort(abs(dr.eigval));
|
||||
nba = nnz(abs(dr.eigval) > options_.qz_criterium);
|
||||
temp = temp(nd-nba+1:nd)-1-options_.qz_criterium;
|
||||
info(1) = 3;
|
||||
info(2) = temp'*temp;
|
||||
end
|
||||
else
|
||||
error(['2nd and 3rd order approximation not implemented for purely ' ...
|
||||
'backward models'])
|
||||
end
|
||||
elseif M_.maximum_endo_lag == 0
|
||||
% purely forward model
|
||||
dr.ghx = [];
|
||||
dr.ghu = -b\jacobia_(:,nz+1:end);
|
||||
elseif options_.risky_steadystate
|
||||
[dr,info] = dyn_risky_steadystate_solver(oo_.steady_state,M_,dr, ...
|
||||
options_,oo_);
|
||||
else
|
||||
% If required, use AIM solver if not check only
|
||||
if (options_.aim_solver == 1) && (task == 0)
|
||||
[dr,info] = AIM_first_order_solver(jacobia_,M_,dr,sdim);
|
||||
|
||||
else % use original Dynare solver
|
||||
[dr,info] = dyn_first_order_solver(jacobia_,b,M_,dr,options_,task);
|
||||
if info
|
||||
return;
|
||||
end
|
||||
end
|
||||
|
||||
if options_.loglinear == 1
|
||||
k = find(dr.kstate(:,2) <= M_.maximum_endo_lag+1);
|
||||
klag = dr.kstate(k,[1 2]);
|
||||
k1 = dr.order_var;
|
||||
|
||||
dr.ghx = repmat(1./dr.ys(k1),1,size(dr.ghx,2)).*dr.ghx.* ...
|
||||
repmat(dr.ys(k1(klag(:,1)))',size(dr.ghx,1),1);
|
||||
dr.ghu = repmat(1./dr.ys(k1),1,size(dr.ghu,2)).*dr.ghu;
|
||||
end
|
||||
|
||||
%exogenous deterministic variables
|
||||
if M_.exo_det_nbr > 0
|
||||
f1 = sparse(jacobia_(:,nonzeros(M_.lead_lag_incidence(M_.maximum_endo_lag+2:end,order_var))));
|
||||
f0 = sparse(jacobia_(:,nonzeros(M_.lead_lag_incidence(M_.maximum_endo_lag+1,order_var))));
|
||||
fudet = sparse(jacobia_(:,nz+M_.exo_nbr+1:end));
|
||||
M1 = inv(f0+[zeros(M_.endo_nbr,nstatic) f1*gx zeros(M_.endo_nbr,nyf-nboth)]);
|
||||
M2 = M1*f1;
|
||||
dr.ghud = cell(M_.exo_det_length,1);
|
||||
dr.ghud{1} = -M1*fudet;
|
||||
for i = 2:M_.exo_det_length
|
||||
dr.ghud{i} = -M2*dr.ghud{i-1}(end-nyf+1:end,:);
|
||||
end
|
||||
end
|
||||
|
||||
if options_.order > 1
|
||||
% Second order
|
||||
dr = dyn_second_order_solver(jacobia_,hessian1,dr,M_,...
|
||||
options_.threads.kronecker.A_times_B_kronecker_C,...
|
||||
options_.threads.kronecker.sparse_hessian_times_B_kronecker_C);
|
||||
end
|
||||
end
|
||||
oo.dr = dr;
|
|
@ -0,0 +1,49 @@
|
|||
var c1 c2 x1 x2 p1 p2 d1 d2 y1 y2;
|
||||
varexo eps_1 eps_2 eta_1 eta_2;
|
||||
|
||||
parameters beta, gamma, kappa, rho_y, rho_d;
|
||||
|
||||
beta = 0.96;
|
||||
gamma = 4;
|
||||
kappa = -0.5;
|
||||
rho_y = 0.9;
|
||||
rho_d = 0.9;
|
||||
|
||||
model;
|
||||
p1*c1^(-gamma-1) = beta*c1(+1)^(-gamma-1)*(d1(+1)+p1(+1));
|
||||
p2*c1^(-gamma-1) = beta*c1(+1)^(-gamma-1)*(d2(+1)+p2(+1));
|
||||
p1*c2^(-gamma-1) = beta*c2(+1)^(-gamma-1)*(d1(+1)+p1(+1));
|
||||
p2*c2^(-gamma-1) = beta*c2(+1)^(-gamma-1)*(d2(+1)+p2(+1));
|
||||
c1 = y1 - (x1(-1)*(p1+d1)-x1*p1) + (x2(-1)*(p2+d2)-x2*p2);
|
||||
c2 = y2 + (x1(-1)*(p1+d1)-x1*p1) - (x2(-1)*(p2+d2)-x2*p2);
|
||||
y1 = (1-rho_y)*0.5 + rho_y*y1(-1) + eps_1;
|
||||
y2 = (1-rho_y)*0.5 + rho_y*y2(-1) + eps_2;
|
||||
d1 = (1-rho_d)*0.5 + rho_d*d1(-1) + eta_1;
|
||||
d2 = (1-rho_d)*0.5 + rho_d*d2(-1) + eta_2;
|
||||
end;
|
||||
|
||||
shocks;
|
||||
var eps_1; stderr 0.01;
|
||||
var eps_2; stderr 0.01;
|
||||
var eta_1; stderr 0.01;
|
||||
var eta_2; stderr 0.01;
|
||||
corr eps_1,eta_1 = -0.5;
|
||||
corr eps_2,eta_2 = -0.5;
|
||||
end;
|
||||
|
||||
initval;
|
||||
c1 = 0.5;
|
||||
c2 = 0.5;
|
||||
y1 = 0.5;
|
||||
y2 = 0.5;
|
||||
d1 = 0.5;
|
||||
d2 = 0.5;
|
||||
p1 = 12.51;
|
||||
p2 = 12.51;
|
||||
x1 = 0.26;
|
||||
x2 = 0.25;
|
||||
end;
|
||||
|
||||
options_.risky_steadystate = 1;
|
||||
|
||||
stoch_simul(irf=0);
|
|
@ -0,0 +1,47 @@
|
|||
var c1 c2 p1 p2 d1 d2 y1 y2;
|
||||
varexo eps_1 eps_2 eta_1 eta_2;
|
||||
|
||||
parameters beta, gamma, kappa, rho_y, rho_d, x1, x2;
|
||||
|
||||
beta = 0.96;
|
||||
gamma = 4;
|
||||
kappa = -0.5;
|
||||
rho_y = 0.9;
|
||||
rho_d = 0.9;
|
||||
x1 = 0;
|
||||
x2 = 0;
|
||||
|
||||
model;
|
||||
p1*c1^(-gamma-1) = beta*c1(+1)^(-gamma-1)*(d1(+1)+p1(+1));
|
||||
//p2*c1^(-gamma-1) = beta*c1(+1)^(-gamma-1)*(d2(+1)+p2(+1));
|
||||
//p1*c2^(-gamma-1) = beta*c2(+1)^(-gamma-1)*(d1(+1)+p1(+1));
|
||||
p2*c2^(-gamma-1) = beta*c2(+1)^(-gamma-1)*(d2(+1)+p2(+1));
|
||||
c1 = y1 - (x1(-1)*(p1+d1)-x1*p1) + (x2(-1)*(p2+d2)-x2*p2);
|
||||
c2 = y2 + (x1(-1)*(p1+d1)-x1*p1) - (x2(-1)*(p2+d2)-x2*p2);
|
||||
y1 = (1-rho_y)*0.5 + rho_y*y1(-1)+eps_1;
|
||||
y2 = (1-rho_y)*0.5 + rho_y*y2(-1) + eps_2;
|
||||
d1 = (1-rho_d)*0.5 + rho_d*d1(-1) + eta_1;
|
||||
d2 = (1-rho_d)*0.5 + rho_d*d2(-1) + eta_2;
|
||||
end;
|
||||
|
||||
shocks;
|
||||
var eps_1; stderr 0.01;
|
||||
var eps_2; stderr 0.01;
|
||||
var eta_1; stderr 0.01;
|
||||
var eta_2; stderr 0.01;
|
||||
corr eps_1,eta_1 = -0.5;
|
||||
corr eps_2,eta_2 = -0.5;
|
||||
end;
|
||||
|
||||
initval;
|
||||
c1 = 0.5;
|
||||
c2 = 0.5;
|
||||
y1 = 0.5;
|
||||
y2 = 0.5;
|
||||
d1 = 0.5;
|
||||
d2 = 0.5;
|
||||
p1 = 1;
|
||||
p2 = 1;
|
||||
end;
|
||||
|
||||
stoch_simul(irf=0);
|
|
@ -0,0 +1,47 @@
|
|||
// Example 1 from Collard's guide to Dynare
|
||||
var y, c, k, a, h, b;
|
||||
varexo e, u;
|
||||
|
||||
parameters beta, rho, alpha, delta, theta, psi, tau;
|
||||
|
||||
alpha = 0.36;
|
||||
rho = 0.95;
|
||||
tau = 0.025;
|
||||
beta = 0.99;
|
||||
delta = 0.025;
|
||||
psi = 0;
|
||||
theta = 2.95;
|
||||
|
||||
phi = 0.1;
|
||||
|
||||
model;
|
||||
c*theta*h^(1+psi)=(1-alpha)*y;
|
||||
k = beta*(((exp(b)*c)/(exp(b(+1))*c(+1)))
|
||||
*(exp(b(+1))*alpha*y(+1)+(1-delta)*k));
|
||||
y = exp(a)*(k(-1)^alpha)*(h^(1-alpha));
|
||||
k = exp(b)*(y-c)+(1-delta)*k(-1);
|
||||
a = rho*a(-1)+tau*b(-1) + e;
|
||||
b = tau*a(-1)+rho*b(-1) + u;
|
||||
end;
|
||||
|
||||
initval;
|
||||
y = 1.08068253095672;
|
||||
c = 0.80359242014163;
|
||||
h = 0.29175631001732;
|
||||
k = 11.08360443260358;
|
||||
a = 0;
|
||||
b = 0;
|
||||
e = 0;
|
||||
u = 0;
|
||||
end;
|
||||
|
||||
options_.solve_tolf = 1e-11;
|
||||
steady;
|
||||
|
||||
shocks;
|
||||
var e; stderr 0.009;
|
||||
var u; stderr 0.009;
|
||||
var e, u = phi*0.009*0.009;
|
||||
end;
|
||||
|
||||
stoch_simul;
|
|
@ -0,0 +1,45 @@
|
|||
// Example 1 from Collard's guide to Dynare
|
||||
var y, c, k, a, h, b;
|
||||
varexo e, u;
|
||||
|
||||
parameters beta, rho, alpha, delta, theta, psi, tau;
|
||||
|
||||
alpha = 0.36;
|
||||
rho = 0.95;
|
||||
tau = 0.025;
|
||||
beta = 0.99;
|
||||
delta = 0.025;
|
||||
psi = 0;
|
||||
theta = 2.95;
|
||||
|
||||
phi = 0.1;
|
||||
|
||||
model(use_dll);
|
||||
c*theta*h^(1+psi)=(1-alpha)*y;
|
||||
k = beta*(((exp(b)*c)/(exp(b(+1))*c(+1)))
|
||||
*(exp(b(+1))*alpha*y(+1)+(1-delta)*k));
|
||||
y = exp(a)*(k(-1)^alpha)*(h^(1-alpha));
|
||||
k = exp(b)*(y-c)+(1-delta)*k(-1);
|
||||
a = rho*a(-1)+tau*b(-1) + e;
|
||||
b = tau*a(-1)+rho*b(-1) + u;
|
||||
end;
|
||||
|
||||
initval;
|
||||
y = 1.08068253095672;
|
||||
c = 0.80359242014163;
|
||||
h = 0.29175631001732;
|
||||
k = 11.08360443260358;
|
||||
a = 0;
|
||||
b = 0;
|
||||
e = 0;
|
||||
u = 0;
|
||||
end;
|
||||
|
||||
shocks;
|
||||
var e; stderr 0.009;
|
||||
var u; stderr 0.009;
|
||||
var e, u = phi*0.009*0.009;
|
||||
end;
|
||||
|
||||
//options_.risky_steadystate = 1;
|
||||
stoch_simul(k_order_solver,order=3,irf=0);
|
|
@ -0,0 +1,45 @@
|
|||
// Example 1 from Collard's guide to Dynare
|
||||
var y, c, k, a, h, b;
|
||||
varexo e, u;
|
||||
|
||||
parameters beta, rho, alpha, delta, theta, psi, tau;
|
||||
|
||||
alpha = 0.36;
|
||||
rho = 0.95;
|
||||
tau = 0.025;
|
||||
beta = 0.99;
|
||||
delta = 0.025;
|
||||
psi = 0;
|
||||
theta = 2.95;
|
||||
|
||||
phi = 0.1;
|
||||
|
||||
model;
|
||||
c*theta*h^(1+psi)=(1-alpha)*y;
|
||||
k = beta*(((exp(b)*c)/(exp(b(+1))*c(+1)))
|
||||
*(exp(b(+1))*alpha*y(+1)+(1-delta)*k));
|
||||
y = exp(a)*(k(-1)^alpha)*(h^(1-alpha));
|
||||
k = exp(b)*(y-c)+(1-delta)*k(-1);
|
||||
a = rho*a(-1)+tau*b(-1) + e;
|
||||
b = tau*a(-1)+rho*b(-1) + u;
|
||||
end;
|
||||
|
||||
initval;
|
||||
y = 1.08068253095672;
|
||||
c = 0.80359242014163;
|
||||
h = 0.29175631001732;
|
||||
k = 11.08360443260358;
|
||||
a = 0;
|
||||
b = 0;
|
||||
e = 0;
|
||||
u = 0;
|
||||
end;
|
||||
|
||||
shocks;
|
||||
var e; stderr 0.009;
|
||||
var u; stderr 0.009;
|
||||
var e, u = phi*0.009*0.009;
|
||||
end;
|
||||
|
||||
options_.risky_steadystate = 1;
|
||||
stoch_simul(irf=0);
|
|
@ -0,0 +1,47 @@
|
|||
// Example 1 from Collard's guide to Dynare
|
||||
var y, c, k, a, h, b;
|
||||
varexo e, u;
|
||||
|
||||
parameters beta, rho, alpha, delta, theta, psi, tau;
|
||||
|
||||
alpha = 0.36;
|
||||
rho = 0.95;
|
||||
tau = 0.025;
|
||||
beta = 0.99;
|
||||
delta = 0.025;
|
||||
psi = 0;
|
||||
theta = 2.95;
|
||||
|
||||
phi = 0.1;
|
||||
|
||||
model(use_dll);
|
||||
c*theta*h^(1+psi)=(1-alpha)*y;
|
||||
k = beta*(((exp(b)*c)/(exp(b(+1))*c(+1)))
|
||||
*(exp(b(+1))*alpha*y(+1)+(1-delta)*k));
|
||||
y = exp(a)*(k(-1)^alpha)*(h^(1-alpha));
|
||||
k = exp(b)*(y-c)+(1-delta)*k(-1);
|
||||
a = rho*a(-1)+tau*b(-1) + e;
|
||||
b = tau*a(-1)+rho*b(-1) + u;
|
||||
end;
|
||||
|
||||
initval;
|
||||
y = 1.08068253095672;
|
||||
c = 0.80359242014163;
|
||||
h = 0.29175631001732;
|
||||
k = 11.08360443260358;
|
||||
a = 0;
|
||||
b = 0;
|
||||
e = 0;
|
||||
u = 0;
|
||||
end;
|
||||
|
||||
shocks;
|
||||
var e; stderr 0.009;
|
||||
var u; stderr 0.009;
|
||||
var e, u = phi*0.009*0.009;
|
||||
end;
|
||||
|
||||
stoch_simul(order=2,irf=0);
|
||||
|
||||
options_.risky_steadystate = 1;
|
||||
stoch_simul(order=3,irf=0);
|
|
@ -0,0 +1,95 @@
|
|||
// This is the Ramsey model with adjustment costs. Jermann(1998),JME 41, pages 257-275
|
||||
// Olaf Weeken
|
||||
// Bank of England, 13 June, 2005
|
||||
// modified January 20, 2006 by Michel Juillard
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// 1. Variable declaration
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
var c, d, erp1, i, k, m1, r1, rf1, w, y, z, mu;
|
||||
varexo ez;
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// 2. Parameter declaration and calibration
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
parameters alf, chihab, xi, delt, tau, g, rho, zbar, a1, a2, betstar, bet;
|
||||
|
||||
alf = 0.36; // capital share in production function
|
||||
//chihab = 0.819; // habit formation parameter
|
||||
chihab = 0.98; // habit formation parameter
|
||||
xi = 1/4.3; // capital adjustment cost parameter
|
||||
delt = 0.025; // quarterly deprecition rate
|
||||
g = 1.005; //quarterly growth rate (note zero growth =>g=1)
|
||||
tau = 5; // curvature parameter with respect to c
|
||||
rho = 0.95; // AR(1) parameter for technology shock
|
||||
|
||||
a1 = (g-1+delt)^(1/xi);
|
||||
a2 = (g-1+delt)-(((g-1+delt)^(1/xi))/(1-(1/xi)))*((g-1+delt)^(1-(1/xi)));
|
||||
betstar = g/1.011138;
|
||||
bet = betstar/(g^(1-tau));
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// 3. Model declaration
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
model(use_dll);
|
||||
g*k = (1-delt)*k(-1) + ((a1/(1-1/xi))*(g*i/k(-1))^(1-1/xi)+a2)*k(-1);
|
||||
d = y - w - i;
|
||||
w = (1-alf)*y;
|
||||
y = z*g^(-alf)*k(-1)^alf;
|
||||
c = w + d;
|
||||
mu = (c-chihab*c(-1)/g)^(-tau)-chihab*bet*(c(+1)*g-chihab*c)^(-tau);
|
||||
mu = (betstar/g)*mu(+1)*(a1*(g*i/k(-1))^(-1/xi))*(alf*z(+1)*g^(1-alf)*
|
||||
(k^(alf-1))+((1-delt+(a1/(1-1/xi))*(g*i(+1)/k)^(1-1/xi)+a2))/
|
||||
(a1*(g*i(+1)/k)^(-1/xi))-g*i(+1)/k);
|
||||
log(z) = rho*log(z(-1)) + ez;
|
||||
|
||||
m1 = (betstar/g)*mu(+1)/mu;
|
||||
rf1 = 1/m1;
|
||||
r1 = (a1*(g*i/k(-1))^(-1/xi))*(alf*z(+1)*g^(1-alf)*(k^(alf-1))+
|
||||
(1-delt+(a1/(1-1/xi))*(g*i(+1)/k)^(1-1/xi)+a2)/
|
||||
(a1*(g*i(+1)/k)^(-1/xi))-g*i(+1)/k);
|
||||
erp1 = r1 - rf1;
|
||||
|
||||
end;
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// 4. Initial values and steady state
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
initval;
|
||||
m1 = betstar/g;
|
||||
rf1 = (1/m1);
|
||||
r1 = (1/m1);
|
||||
erp1 = r1-rf1;
|
||||
|
||||
z = 1;
|
||||
k = (((g/betstar)-(1-delt))/(alf*g^(1-alf)))^(1/(alf-1));
|
||||
y = (g^(-alf))*k^alf;
|
||||
w = (1-alf)*y;
|
||||
i = (1-(1/g)*(1-delt))*k;
|
||||
d = y - w - i;
|
||||
c = w + d;
|
||||
|
||||
mu = ((c-(chihab*c/g))^(-tau))-chihab*bet*((c*g-chihab*c)^(-tau));
|
||||
|
||||
ez = 0;
|
||||
end;
|
||||
|
||||
resid(1);
|
||||
|
||||
steady;
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// 5. Shock declaration
|
||||
//
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
shocks;
|
||||
var ez; stderr 0.001;
|
||||
end;
|
||||
|
||||
options_.risky_steadystate = 1;
|
||||
stoch_simul (order=3,irf=0,periods=20000) erp1, rf1, m1, r1, y, z, c, d, mu, k;
|
|
@ -0,0 +1,99 @@
|
|||
// This is the Ramsey model with adjustment costs. Jermann(1998),JME 41, pages 257-275
|
||||
// Olaf Weeken
|
||||
// Bank of England, 13 June, 2005
|
||||
// modified January 20, 2006 by Michel Juillard
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// 1. Variable declaration
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
var c, d, erp1, i, k, m1, r1, rf1, w, y, z, mu;
|
||||
varexo ez;
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// 2. Parameter declaration and calibration
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
parameters alf, chihab, xi, delt, tau, g, rho, zbar, a1, a2, betstar, bet;
|
||||
|
||||
alf = 0.36; // capital share in production function
|
||||
//chihab = 0.819; // habit formation parameter
|
||||
chihab = 0.98; // habit formation parameter
|
||||
xi = 1/4.3; // capital adjustment cost parameter
|
||||
delt = 0.025; // quarterly deprecition rate
|
||||
g = 1.005; //quarterly growth rate (note zero growth =>g=1)
|
||||
tau = 5; // curvature parameter with respect to c
|
||||
rho = 0.95; // AR(1) parameter for technology shock
|
||||
|
||||
a1 = (g-1+delt)^(1/xi);
|
||||
a2 = (g-1+delt)-(((g-1+delt)^(1/xi))/(1-(1/xi)))*((g-1+delt)^(1-(1/xi)));
|
||||
betstar = g/1.011138;
|
||||
bet = betstar/(g^(1-tau));
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// 3. Model declaration
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
model;
|
||||
g*k = (1-delt)*k(-1) + ((a1/(1-1/xi))*(g*i/k(-1))^(1-1/xi)+a2)*k(-1);
|
||||
d = y - w - i;
|
||||
w = (1-alf)*y;
|
||||
y = z*g^(-alf)*k(-1)^alf;
|
||||
c = w + d;
|
||||
mu = ((c-chihab*c(-1)/g)^(-tau)-chihab*bet*(c(+1)*g-chihab*c)^(-tau))/1e4;
|
||||
mu = (betstar/g)*mu(+1)*(a1*(g*i/k(-1))^(-1/xi))*(alf*z(+1)*g^(1-alf)*
|
||||
(k^(alf-1))+((1-delt+(a1/(1-1/xi))*(g*i(+1)/k)^(1-1/xi)+a2))/
|
||||
(a1*(g*i(+1)/k)^(-1/xi))-g*i(+1)/k);
|
||||
log(z) = rho*log(z(-1)) + ez;
|
||||
|
||||
m1 = (betstar/g)*mu(+1)/mu;
|
||||
rf1 = 1/m1;
|
||||
r1 = (a1*(g*i/k(-1))^(-1/xi))*(alf*z(+1)*g^(1-alf)*(k^(alf-1))+
|
||||
(1-delt+(a1/(1-1/xi))*(g*i(+1)/k)^(1-1/xi)+a2)/
|
||||
(a1*(g*i(+1)/k)^(-1/xi))-g*i(+1)/k);
|
||||
erp1 = r1 - rf1;
|
||||
|
||||
end;
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// 4. Initial values and steady state
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
initval;
|
||||
m1 = betstar/g;
|
||||
rf1 = (1/m1);
|
||||
r1 = (1/m1);
|
||||
erp1 = r1-rf1;
|
||||
|
||||
z = 1;
|
||||
k = (((g/betstar)-(1-delt))/(alf*g^(1-alf)))^(1/(alf-1));
|
||||
y = (g^(-alf))*k^alf;
|
||||
w = (1-alf)*y;
|
||||
i = (1-(1/g)*(1-delt))*k;
|
||||
d = y - w - i;
|
||||
c = w + d;
|
||||
|
||||
mu = (((c-(chihab*c/g))^(-tau))-chihab*bet*((c*g-chihab*c)^(-tau)))/1e4;
|
||||
|
||||
ez = 0;
|
||||
end;
|
||||
|
||||
resid(1);
|
||||
|
||||
steady;
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// 5. Shock declaration
|
||||
//
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
for i=1:100:101;
|
||||
s = i/10000;
|
||||
shocks;
|
||||
var ez; stderr s;
|
||||
end;
|
||||
|
||||
options_.risky_steadystate = 1;
|
||||
stoch_simul (order=2,irf=0,noprint) erp1, rf1, m1, r1, y, z, c, d, mu, k;
|
||||
oo_.steady_state = oo_.dr.ys;
|
||||
end
|
|
@ -0,0 +1,99 @@
|
|||
// This is the Ramsey model with adjustment costs. Jermann(1998),JME 41, pages 257-275
|
||||
// Olaf Weeken
|
||||
// Bank of England, 13 June, 2005
|
||||
// modified January 20, 2006 by Michel Juillard
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// 1. Variable declaration
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
var c, d, erp1, i, k, m1, r1, rf1, w, y, z, mu;
|
||||
varexo ez;
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// 2. Parameter declaration and calibration
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
parameters alf, chihab, xi, delt, tau, g, rho, zbar, a1, a2, betstar, bet;
|
||||
|
||||
alf = 0.36; // capital share in production function
|
||||
//chihab = 0.819; // habit formation parameter
|
||||
chihab = 0.98; // habit formation parameter
|
||||
xi = 1/4.3; // capital adjustment cost parameter
|
||||
delt = 0.025; // quarterly deprecition rate
|
||||
g = 1.005; //quarterly growth rate (note zero growth =>g=1)
|
||||
tau = 5; // curvature parameter with respect to c
|
||||
rho = 0.95; // AR(1) parameter for technology shock
|
||||
|
||||
a1 = (g-1+delt)^(1/xi);
|
||||
a2 = (g-1+delt)-(((g-1+delt)^(1/xi))/(1-(1/xi)))*((g-1+delt)^(1-(1/xi)));
|
||||
betstar = g/1.011138;
|
||||
bet = betstar/(g^(1-tau));
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// 3. Model declaration
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
model(use_dll);
|
||||
g*k = (1-delt)*k(-1) + ((a1/(1-1/xi))*(g*i/k(-1))^(1-1/xi)+a2)*k(-1);
|
||||
d = y - w - i;
|
||||
w = (1-alf)*y;
|
||||
y = z*g^(-alf)*k(-1)^alf;
|
||||
c = w + d;
|
||||
mu = ((c-chihab*c(-1)/g)^(-tau)-chihab*bet*(c(+1)*g-chihab*c)^(-tau))/1e4;
|
||||
mu = (betstar/g)*mu(+1)*(a1*(g*i/k(-1))^(-1/xi))*(alf*z(+1)*g^(1-alf)*
|
||||
(k^(alf-1))+((1-delt+(a1/(1-1/xi))*(g*i(+1)/k)^(1-1/xi)+a2))/
|
||||
(a1*(g*i(+1)/k)^(-1/xi))-g*i(+1)/k);
|
||||
log(z) = rho*log(z(-1)) + ez;
|
||||
|
||||
m1 = (betstar/g)*mu(+1)/mu;
|
||||
rf1 = 1/m1;
|
||||
r1 = (a1*(g*i/k(-1))^(-1/xi))*(alf*z(+1)*g^(1-alf)*(k^(alf-1))+
|
||||
(1-delt+(a1/(1-1/xi))*(g*i(+1)/k)^(1-1/xi)+a2)/
|
||||
(a1*(g*i(+1)/k)^(-1/xi))-g*i(+1)/k);
|
||||
erp1 = r1 - rf1;
|
||||
|
||||
end;
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// 4. Initial values and steady state
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
initval;
|
||||
m1 = betstar/g;
|
||||
rf1 = (1/m1);
|
||||
r1 = (1/m1);
|
||||
erp1 = r1-rf1;
|
||||
|
||||
z = 1;
|
||||
k = (((g/betstar)-(1-delt))/(alf*g^(1-alf)))^(1/(alf-1));
|
||||
y = (g^(-alf))*k^alf;
|
||||
w = (1-alf)*y;
|
||||
i = (1-(1/g)*(1-delt))*k;
|
||||
d = y - w - i;
|
||||
c = w + d;
|
||||
|
||||
mu = (((c-(chihab*c/g))^(-tau))-chihab*bet*((c*g-chihab*c)^(-tau)))/1e4;
|
||||
|
||||
ez = 0;
|
||||
end;
|
||||
|
||||
resid(1);
|
||||
|
||||
steady;
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// 5. Shock declaration
|
||||
//
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
for i=1:1:100;
|
||||
s = i/10000;
|
||||
shocks;
|
||||
var ez; stderr s;
|
||||
end;
|
||||
|
||||
options_.risky_steadystate = 1;
|
||||
stoch_simul (order=3,irf=0,noprint) erp1, rf1, m1, r1, y, z, c, d, mu, k;
|
||||
oo_.steady_state = oo_.dr.ys;
|
||||
end;
|
Loading…
Reference in New Issue