stepan
/
dynare
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Beautified MATLAB code (Unix newline convention + Emacs indentation), except: AIM, swz, particle 

git-svn-id: https://www.dynare.org/svn/dynare/trunk@3250 ac1d8469-bf42-47a9-8791-bf33cf982152
time-shift
sebastien 2009-12-16 17:17:34 +00:00
parent e6f1a53e60
commit 502e3e1df8
306 changed files with 25732 additions and 25746 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
matlab/AIM/dynAIMsolver1.m
View File

@ -73,7 +73,7 @@ lli=M_.lead_lag_incidence';
theAIM_H(:,find(lli(:)))=jacobia_(:,nonzeros(lli(:)));
condn = 1.e-10;%SPAmalg uses this in zero tests
uprbnd = 1 + 1.e-6;%allow unit roots
% forward only models - AIM must have at least 1 lead and 1 lag.
% forward only models - AIM must have at least 1 lead and 1 lag.
if lags ==0
theAIM_H =[zeros(neq) theAIM_H];
lags=1;
@ -135,8 +135,8 @@ else
if aimcode < 1 || aimcode > 5 % too big exception, use mjdgges
error('Error in AIM: aimcode=%d ; %s', aimcode, err);
end
% if aimcode > 5
% disp(['Error in AIM: aimcode=' sprintf('%d : %s',aimcode, err)]);
% aimcode=5;
% end
% if aimcode > 5
% disp(['Error in AIM: aimcode=' sprintf('%d : %s',aimcode, err)]);
% aimcode=5;
% end
end

8
matlab/AnalyseComputationalEnviroment.m
View File

@ -103,8 +103,8 @@ if (DataInput.Local == 1)
RealNumCPU=-1;
RealNumCPU=GiveCPUnumber(de);
% Trasforming the input data provided in a form [n1:n2] in a single numerical
% value.
% Trasforming the input data provided in a form [n1:n2] in a single numerical
% value.
DataInput.NumCPU=length(DataInput.NumCPU);
@ -192,8 +192,8 @@ if (DataInput.Local == 0)
RealNumCPU=-1;
RealNumCPU=GiveCPUnumber(de);
% Trasforming the input data provided in a form [n1:n2] in a single numerical
% value.
% Trasforming the input data provided in a form [n1:n2] in a single numerical
% value.
DataInput.NumCPU=length(DataInput.NumCPU);

2
matlab/DiffuseKalmanSmoother3_Z.m
View File

@ -264,7 +264,7 @@ if d
r1 = zeros(mm,d);
for t = d:-1:1
for i=pp:-1:1
% if Finf(i,t) > crit & ~(t==d & i>options_.diffuse_d), % use of options_.diffuse_d to be sure of DKF termination
% if Finf(i,t) > crit & ~(t==d & i>options_.diffuse_d), % use of options_.diffuse_d to be sure of DKF termination
if Finf(i,t) > crit
r1(:,t) = Z(i,:)'*v(i,t)/Finf(i,t) + ...
L0(:,:,i,t)'*r0(:,t) + Linf(:,:,i,t)'*r1(:,t);

6
matlab/DiffuseKalmanSmootherH3.m
View File

@ -149,9 +149,9 @@ while newRank & t < smpl
options_.diffuse_d = icc;
end
end,
% if newRank==0,
% options_.diffuse_d=i; % this line is buggy!
% end
% if newRank==0,
% options_.diffuse_d=i; % this line is buggy!
% end
% end new terminiation criteria by M. Ratto
elseif Fstar(i,t) > crit
%% Note that : (1) rank(Pinf)=0 implies that Finf = 0, (2) outside this loop (when for some i and t the condition

2
matlab/DiffuseKalmanSmootherH3_Z.m
View File

@ -265,7 +265,7 @@ if d
r1 = zeros(mm,d);
for t = d:-1:2
for i=pp:-1:1
% if Finf(i,t) > crit & ~(t==d & i>options_.diffuse_d), % use of options_.diffuse_d to be sure of DKF termination
% if Finf(i,t) > crit & ~(t==d & i>options_.diffuse_d), % use of options_.diffuse_d to be sure of DKF termination
if Finf(i,t) > crit
r1(:,t) = Z(i,:)'*v(i,t)/Finf(i,t) + ...
L0(:,:,i,t)'*r0(:,t) + Linf(:,:,i,t)'*r1(:,t);

54
matlab/DiffuseLikelihood1.m
View File

@ -41,21 +41,21 @@ function [LIK, lik] = DiffuseLikelihood1(T,R,Q,Pinf,Pstar,Y,trend,start)
% M. Ratto added lik in output
global bayestopt_ options_
global bayestopt_ options_
mf = bayestopt_.mf;
smpl = size(Y,2);
mm = size(T,2);
pp = size(Y,1);
a = zeros(mm,1);
dF = 1;
QQ = R*Q*transpose(R);
t = 0;
lik = zeros(smpl,1);
LIK = Inf;
notsteady = 1;
crit = options_.kalman_tol;
while rank(Pinf,crit) & t < smpl
mf = bayestopt_.mf;
smpl = size(Y,2);
mm = size(T,2);
pp = size(Y,1);
a = zeros(mm,1);
dF = 1;
QQ = R*Q*transpose(R);
t = 0;
lik = zeros(smpl,1);
LIK = Inf;
notsteady = 1;
crit = options_.kalman_tol;
while rank(Pinf,crit) & t < smpl
t = t+1;
v = Y(:,t)-a(mf)-trend(:,t);
Finf = Pinf(mf,mf);
@ -81,13 +81,13 @@ function [LIK, lik] = DiffuseLikelihood1(T,R,Q,Pinf,Pstar,Y,trend,start)
Pinf = T*(Pinf-Pinf(:,mf)*transpose(Kinf))*transpose(T);
a = T*(a+Kinf*v);
end
end
if t == smpl
end
if t == smpl
error(['There isn''t enough information to estimate the initial' ...
' conditions of the nonstationary variables']);
end
F_singular = 1;
while notsteady & t < smpl
end
F_singular = 1;
while notsteady & t < smpl
t = t+1;
v = Y(:,t)-a(mf)-trend(:,t);
F = Pstar(mf,mf);
@ -109,12 +109,12 @@ function [LIK, lik] = DiffuseLikelihood1(T,R,Q,Pinf,Pstar,Y,trend,start)
Pstar = T*(Pstar-K*Pstar(mf,:))*transpose(T)+QQ; %% ... idem (stephane)
end
notsteady = ~(max(max(abs(Pstar-oldPstar)))<crit);
end
if F_singular == 1
end
if F_singular == 1
error(['The variance of the forecast error remains singular until the' ...
'end of the sample'])
end
if t < smpl
end
if t < smpl
t0 = t+1;
while t < smpl
t = t+1;
@ -123,8 +123,8 @@ function [LIK, lik] = DiffuseLikelihood1(T,R,Q,Pinf,Pstar,Y,trend,start)
lik(t) = transpose(v)*iF*v;
end
lik(t0:smpl) = lik(t0:smpl) + log(dF);
end
% adding log-likelihhod constants
lik = (lik + pp*log(2*pi))/2;
end
% adding log-likelihhod constants
lik = (lik + pp*log(2*pi))/2;
LIK = sum(lik(start:end)); % Minus the log-likelihood.
LIK = sum(lik(start:end)); % Minus the log-likelihood.

52
matlab/DiffuseLikelihood1_Z.m
View File

@ -41,20 +41,20 @@ function [LIK, lik] = DiffuseLikelihood1_Z(T,Z,R,Q,Pinf,Pstar,Y,start)
% M. Ratto added lik in output
global bayestopt_ options_
global bayestopt_ options_
smpl = size(Y,2);
mm = size(T,2);
pp = size(Y,1);
a = zeros(mm,1);
dF = 1;
QQ = R*Q*transpose(R);
t = 0;
lik = zeros(smpl,1);
LIK = Inf;
notsteady = 1;
crit = options_.kalman_tol;
while rank(Pinf,crit) & t < smpl
smpl = size(Y,2);
mm = size(T,2);
pp = size(Y,1);
a = zeros(mm,1);
dF = 1;
QQ = R*Q*transpose(R);
t = 0;
lik = zeros(smpl,1);
LIK = Inf;
notsteady = 1;
crit = options_.kalman_tol;
while rank(Pinf,crit) & t < smpl
t = t+1;
v = Y(:,t)-Z*a;
Finf = Z*Pinf*Z';
@ -81,13 +81,13 @@ function [LIK, lik] = DiffuseLikelihood1_Z(T,Z,R,Q,Pinf,Pstar,Y,start)
Pinf = T*(Pinf-Pinf*Z'*Kinf')*T';
a = T*(a+Kinf*v);
end
end
if t == smpl
end
if t == smpl
error(['There isn''t enough information to estimate the initial' ...
' conditions of the nonstationary variables']);
end
F_singular = 1;
while notsteady & t < smpl
end
F_singular = 1;
while notsteady & t < smpl
t = t+1;
v = Y(:,t)-Z*a;
F = Z*Pstar*Z';
@ -109,12 +109,12 @@ function [LIK, lik] = DiffuseLikelihood1_Z(T,Z,R,Q,Pinf,Pstar,Y,start)
Pstar = T*(Pstar-K*Z*Pstar)*T'+QQ;
end
notsteady = ~(max(max(abs(Pstar-oldPstar)))<crit);
end
if F_singular == 1
end
if F_singular == 1
error(['The variance of the forecast error remains singular until the' ...
'end of the sample'])
end
if t < smpl
end
if t < smpl
t0 = t+1;
while t < smpl
t = t+1;
@ -123,8 +123,8 @@ function [LIK, lik] = DiffuseLikelihood1_Z(T,Z,R,Q,Pinf,Pstar,Y,start)
lik(t) = v'*iF*v;
end
lik(t0:smpl) = lik(t0:smpl) + log(dF);
end
% adding log-likelihhod constants
lik = (lik + pp*log(2*pi))/2;
end
% adding log-likelihhod constants
lik = (lik + pp*log(2*pi))/2;
LIK = sum(lik(start:end)); % Minus the log-likelihood.
LIK = sum(lik(start:end)); % Minus the log-likelihood.

20
matlab/DiffuseLikelihood3.m
View File

@ -123,11 +123,11 @@ while newRank & t < smpl
%disp(['zero F term in DKF for observed ',int2str(i),' ',num2str(Fstar)])
end
end
% if all(abs(Pinf(:))<crit),
% oldRank = 0;
% else
% oldRank = rank(Pinf,crit);
% end
% if all(abs(Pinf(:))<crit),
% oldRank = 0;
% else
% oldRank = rank(Pinf,crit);
% end
if newRank,
oldRank = rank(Pinf,crit1);
else
@ -136,11 +136,11 @@ while newRank & t < smpl
a = T*a;
Pstar = T*Pstar*transpose(T)+QQ;
Pinf = T*Pinf*transpose(T);
% if all(abs(Pinf(:))<crit),
% newRank = 0;
% else
% newRank = rank(Pinf,crit);
% end
% if all(abs(Pinf(:))<crit),
% newRank = 0;
% else
% newRank = rank(Pinf,crit);
% end
if newRank,
newRank = rank(Pinf,crit1); % new crit1 is used
end

54
matlab/DiffuseLikelihoodH1.m
View File

@ -42,21 +42,21 @@ function [LIK, lik] = DiffuseLikelihoodH1(T,R,Q,H,Pinf,Pstar,Y,trend,start)
% M. Ratto added lik in output
global bayestopt_ options_
global bayestopt_ options_
mf = bayestopt_.mf;
smpl = size(Y,2);
mm = size(T,2);
pp = size(Y,1);
a = zeros(mm,1);
dF = 1;
QQ = R*Q*transpose(R);
t = 0;
lik = zeros(smpl,1);
LIK = Inf;
notsteady = 1;
crit = options_.kalman_tol;
while rank(Pinf,crit) & t < smpl
mf = bayestopt_.mf;
smpl = size(Y,2);
mm = size(T,2);
pp = size(Y,1);
a = zeros(mm,1);
dF = 1;
QQ = R*Q*transpose(R);
t = 0;
lik = zeros(smpl,1);
LIK = Inf;
notsteady = 1;
crit = options_.kalman_tol;
while rank(Pinf,crit) & t < smpl
t = t+1;
v = Y(:,t)-a(mf)-trend(:,t);
Finf = Pinf(mf,mf);
@ -82,13 +82,13 @@ function [LIK, lik] = DiffuseLikelihoodH1(T,R,Q,H,Pinf,Pstar,Y,trend,start)
Pinf = T*(Pinf-Pinf(:,mf)*transpose(Kinf))*transpose(T);
a = T*(a+Kinf*v);
end
end
if t == smpl
end
if t == smpl
error(['There isn''t enough information to estimate the initial' ...
' conditions of the nonstationary variables']);
end
F_singular = 1;
while notsteady & t < smpl
end
F_singular = 1;
while notsteady & t < smpl
t = t+1;
v = Y(:,t)-a(mf)-trend(:,t);
F = Pstar(mf,mf)+H;
@ -110,12 +110,12 @@ function [LIK, lik] = DiffuseLikelihoodH1(T,R,Q,H,Pinf,Pstar,Y,trend,start)
Pstar = T*(Pstar-K*Pstar(mf,:))*transpose(T)+QQ; %% ... idem (stephane)
end
notsteady = ~(max(max(abs(Pstar-oldPstar)))<crit);
end
if F_singular == 1
end
if F_singular == 1
error(['The variance of the forecast error remains singular until the' ...
'end of the sample'])
end
if t < smpl
end
if t < smpl
t0 = t+1;
while t < smpl
t = t+1;
@ -124,8 +124,8 @@ function [LIK, lik] = DiffuseLikelihoodH1(T,R,Q,H,Pinf,Pstar,Y,trend,start)
lik(t) = transpose(v)*iF*v;
end
lik(t0:smpl) = lik(t0:smpl) + log(dF);
end
% adding log-likelihhod constants
lik = (lik + pp*log(2*pi))/2;
end
% adding log-likelihhod constants
lik = (lik + pp*log(2*pi))/2;
LIK = sum(lik(start:end)); % Minus the log-likelihood.
LIK = sum(lik(start:end)); % Minus the log-likelihood.

52
matlab/DiffuseLikelihoodH1_Z.m
View File

@ -43,20 +43,20 @@ function [LIK, lik] = DiffuseLikelihoodH1_Z(T,Z,R,Q,H,Pinf,Pstar,Y,start)
% M. Ratto added lik in output
global bayestopt_ options_
global bayestopt_ options_
smpl = size(Y,2);
mm = size(T,2);
pp = size(Y,1);
a = zeros(mm,1);
dF = 1;
QQ = R*Q*transpose(R);
t = 0;
lik = zeros(smpl,1);
LIK = Inf;
notsteady = 1;
crit = options_.kalman_tol;
while rank(Pinf,crit) & t < smpl
smpl = size(Y,2);
mm = size(T,2);
pp = size(Y,1);
a = zeros(mm,1);
dF = 1;
QQ = R*Q*transpose(R);
t = 0;
lik = zeros(smpl,1);
LIK = Inf;
notsteady = 1;
crit = options_.kalman_tol;
while rank(Pinf,crit) & t < smpl
t = t+1;
v = Y(:,t)-Z*a;
Finf = Z*Pinf*Z';
@ -83,13 +83,13 @@ function [LIK, lik] = DiffuseLikelihoodH1_Z(T,Z,R,Q,H,Pinf,Pstar,Y,start)
Pinf = T*(Pinf-Pinf*Z'*Kinf')*T';
a = T*(a+Kinf*v);
end
end
if t == smpl
end
if t == smpl
error(['There isn''t enough information to estimate the initial' ...
' conditions of the nonstationary variables']);
end
F_singular = 1;
while notsteady & t < smpl
end
F_singular = 1;
while notsteady & t < smpl
t = t+1;
v = Y(:,t)-Z*a;
F = Z*Pstar*Z'+H;
@ -111,12 +111,12 @@ function [LIK, lik] = DiffuseLikelihoodH1_Z(T,Z,R,Q,H,Pinf,Pstar,Y,start)
Pstar = T*(Pstar-K*Z*Pstar)*T'+QQ;
end
notsteady = ~(max(max(abs(Pstar-oldPstar)))<crit);
end
if F_singular == 1
end
if F_singular == 1
error(['The variance of the forecast error remains singular until the' ...
'end of the sample'])
end
if t < smpl
end
if t < smpl
t0 = t+1;
while t < smpl
t = t+1;
@ -125,8 +125,8 @@ function [LIK, lik] = DiffuseLikelihoodH1_Z(T,Z,R,Q,H,Pinf,Pstar,Y,start)
lik(t) = v'*iF*v;
end
lik(t0:smpl) = lik(t0:smpl) + log(dF);
end
% adding log-likelihhod constants
lik = (lik + pp*log(2*pi))/2;
end
% adding log-likelihhod constants
lik = (lik + pp*log(2*pi))/2;
LIK = sum(lik(start:end)); % Minus the log-likelihood.
LIK = sum(lik(start:end)); % Minus the log-likelihood.

160
matlab/DsgeLikelihood.m
View File

@ -38,44 +38,44 @@ function [fval,cost_flag,ys,trend_coeff,info] = DsgeLikelihood(xparam1,gend,data
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global bayestopt_ estim_params_ options_ trend_coeff_ M_ oo_
fval = [];
ys = [];
trend_coeff = [];
cost_flag = 1;
nobs = size(options_.varobs,1);
%------------------------------------------------------------------------------
% 1. Get the structural parameters & define penalties
%------------------------------------------------------------------------------
if options_.mode_compute ~= 1 & any(xparam1 < bayestopt_.lb)
global bayestopt_ estim_params_ options_ trend_coeff_ M_ oo_
fval = [];
ys = [];
trend_coeff = [];
cost_flag = 1;
nobs = size(options_.varobs,1);
%------------------------------------------------------------------------------
% 1. Get the structural parameters & define penalties
%------------------------------------------------------------------------------
if options_.mode_compute ~= 1 & any(xparam1 < bayestopt_.lb)
k = find(xparam1 < bayestopt_.lb);
fval = bayestopt_.penalty+sum((bayestopt_.lb(k)-xparam1(k)).^2);
cost_flag = 0;
info = 41;
return;
end
if options_.mode_compute ~= 1 & any(xparam1 > bayestopt_.ub)
end
if options_.mode_compute ~= 1 & any(xparam1 > bayestopt_.ub)
k = find(xparam1 > bayestopt_.ub);
fval = bayestopt_.penalty+sum((xparam1(k)-bayestopt_.ub(k)).^2);
cost_flag = 0;
info = 42;
return;
end
Q = M_.Sigma_e;
H = M_.H;
for i=1:estim_params_.nvx
end
Q = M_.Sigma_e;
H = M_.H;
for i=1:estim_params_.nvx
k =estim_params_.var_exo(i,1);
Q(k,k) = xparam1(i)*xparam1(i);
end
offset = estim_params_.nvx;
if estim_params_.nvn
end
offset = estim_params_.nvx;
if estim_params_.nvn
for i=1:estim_params_.nvn
k = estim_params_.var_endo(i,1);
H(k,k) = xparam1(i+offset)*xparam1(i+offset);
end
offset = offset+estim_params_.nvn;
end
if estim_params_.ncx
end
if estim_params_.ncx
for i=1:estim_params_.ncx
k1 =estim_params_.corrx(i,1);
k2 =estim_params_.corrx(i,2);
@ -95,8 +95,8 @@ function [fval,cost_flag,ys,trend_coeff,info] = DsgeLikelihood(xparam1,gend,data
end
end
offset = offset+estim_params_.ncx;
end
if estim_params_.ncn
end
if estim_params_.ncn
for i=1:estim_params_.ncn
k1 = options_.lgyidx2varobs(estim_params_.corrn(i,1));
k2 = options_.lgyidx2varobs(estim_params_.corrn(i,2));
@ -115,38 +115,38 @@ function [fval,cost_flag,ys,trend_coeff,info] = DsgeLikelihood(xparam1,gend,data
end
end
offset = offset+estim_params_.ncn;
end
if estim_params_.np > 0
end
if estim_params_.np > 0
M_.params(estim_params_.param_vals(:,1)) = xparam1(offset+1:end);
end
M_.Sigma_e = Q;
M_.H = H;
%------------------------------------------------------------------------------
% 2. call model setup & reduction program
%------------------------------------------------------------------------------
[T,R,SteadyState,info] = dynare_resolve(bayestopt_.restrict_var_list,...
end
M_.Sigma_e = Q;
M_.H = H;
%------------------------------------------------------------------------------
% 2. call model setup & reduction program
%------------------------------------------------------------------------------
[T,R,SteadyState,info] = dynare_resolve(bayestopt_.restrict_var_list,...
bayestopt_.restrict_columns,...
bayestopt_.restrict_aux);
if info(1) == 1 || info(1) == 2 || info(1) == 5
if info(1) == 1 || info(1) == 2 || info(1) == 5
fval = bayestopt_.penalty+1;
cost_flag = 0;
return
elseif info(1) == 3 || info(1) == 4 || info(1)==6 ||info(1) == 19 || info(1) == 20 || info(1) == 21
elseif info(1) == 3 || info(1) == 4 || info(1)==6 ||info(1) == 19 || info(1) == 20 || info(1) == 21
fval = bayestopt_.penalty+info(2);
cost_flag = 0;
return
end
bayestopt_.mf = bayestopt_.mf1;
if options_.noconstant
end
bayestopt_.mf = bayestopt_.mf1;
if options_.noconstant
constant = zeros(nobs,1);
else
else
if options_.loglinear
constant = log(SteadyState(bayestopt_.mfys));
else
constant = SteadyState(bayestopt_.mfys);
end
end
if bayestopt_.with_trend
end
if bayestopt_.with_trend
trend_coeff = zeros(nobs,1);
t = options_.trend_coeffs;
for i=1:length(t)
@ -155,30 +155,30 @@ function [fval,cost_flag,ys,trend_coeff,info] = DsgeLikelihood(xparam1,gend,data
end
end
trend = repmat(constant,1,gend)+trend_coeff*[1:gend];
else
else
trend = repmat(constant,1,gend);
end
start = options_.presample+1;
np = size(T,1);
mf = bayestopt_.mf;
no_missing_data_flag = (number_of_observations==gend*nobs);
%------------------------------------------------------------------------------
% 3. Initial condition of the Kalman filter
%------------------------------------------------------------------------------
kalman_algo = options_.kalman_algo;
if options_.lik_init == 1 % Kalman filter
end
start = options_.presample+1;
np = size(T,1);
mf = bayestopt_.mf;
no_missing_data_flag = (number_of_observations==gend*nobs);
%------------------------------------------------------------------------------
% 3. Initial condition of the Kalman filter
%------------------------------------------------------------------------------
kalman_algo = options_.kalman_algo;
if options_.lik_init == 1 % Kalman filter
if kalman_algo ~= 2
kalman_algo = 1;
end
Pstar = lyapunov_symm(T,R*Q*R',options_.qz_criterium,options_.lyapunov_complex_threshold);
Pinf = [];
elseif options_.lik_init == 2 % Old Diffuse Kalman filter
elseif options_.lik_init == 2 % Old Diffuse Kalman filter
if kalman_algo ~= 2
kalman_algo = 1;
end
Pstar = options_.Harvey_scale_factor*eye(np);
Pinf = [];
elseif options_.lik_init == 3 % Diffuse Kalman filter
elseif options_.lik_init == 3 % Diffuse Kalman filter
if kalman_algo ~= 4
kalman_algo = 3;
end
@ -239,17 +239,17 @@ function [fval,cost_flag,ys,trend_coeff,info] = DsgeLikelihood(xparam1,gend,data
dd(k1) = zeros(length(k1),1);
Pinf(1:nk,1:nk) = diag(dd);
end
end
if kalman_algo == 2
end
kalman_tol = options_.kalman_tol;
riccati_tol = options_.riccati_tol;
mf = bayestopt_.mf1;
Y = data-trend;
%------------------------------------------------------------------------------
% 4. Likelihood evaluation
%------------------------------------------------------------------------------
if (kalman_algo==1)% Multivariate Kalman Filter
end
if kalman_algo == 2
end
kalman_tol = options_.kalman_tol;
riccati_tol = options_.riccati_tol;
mf = bayestopt_.mf1;
Y = data-trend;
%------------------------------------------------------------------------------
% 4. Likelihood evaluation
%------------------------------------------------------------------------------
if (kalman_algo==1)% Multivariate Kalman Filter
if no_missing_data_flag
LIK = kalman_filter(T,R,Q,H,Pstar,Y,start,mf,kalman_tol,riccati_tol);
else
@ -260,8 +260,8 @@ function [fval,cost_flag,ys,trend_coeff,info] = DsgeLikelihood(xparam1,gend,data
if isinf(LIK)
kalman_algo = 2;
end
end
if (kalman_algo==2)% Univariate Kalman Filter
end
if (kalman_algo==2)% Univariate Kalman Filter
no_correlation_flag = 1;
if length(H)==1 & H == 0
H = zeros(nobs,1);
@ -277,8 +277,8 @@ function [fval,cost_flag,ys,trend_coeff,info] = DsgeLikelihood(xparam1,gend,data
else
LIK = univariate_kalman_filter_corr(T,R,Q,H,Pstar,Y,start,mf,kalman_tol,riccati_tol,data_index,number_of_observations,no_more_missing_observations);
end
end
if (kalman_algo==3)% Multivariate Diffuse Kalman Filter
end
if (kalman_algo==3)% Multivariate Diffuse Kalman Filter
if no_missing_data_flag
LIK = diffuse_kalman_filter(ST,R1,Q,H,Pinf,Pstar,Y,start,Z,kalman_tol, ...
riccati_tol);
@ -291,8 +291,8 @@ function [fval,cost_flag,ys,trend_coeff,info] = DsgeLikelihood(xparam1,gend,data
if isinf(LIK)
kalman_algo = 4;
end
end
if (kalman_algo==4)% Univariate Diffuse Kalman Filter
end
if (kalman_algo==4)% Univariate Diffuse Kalman Filter
no_correlation_flag = 1;
if length(H)==1 & H == 0
H = zeros(nobs,1);
@ -313,15 +313,15 @@ function [fval,cost_flag,ys,trend_coeff,info] = DsgeLikelihood(xparam1,gend,data
data_index,number_of_observations,...
no_more_missing_observations);
end
end
if imag(LIK) ~= 0
end
if imag(LIK) ~= 0
likelihood = bayestopt_.penalty;
else
else
likelihood = LIK;
end
% ------------------------------------------------------------------------------
% Adds prior if necessary
% ------------------------------------------------------------------------------
lnprior = priordens(xparam1,bayestopt_.pshape,bayestopt_.p6,bayestopt_.p7,bayestopt_.p3,bayestopt_.p4);
fval = (likelihood-lnprior);
options_.kalman_algo = kalman_algo;
end
% ------------------------------------------------------------------------------
% Adds prior if necessary
% ------------------------------------------------------------------------------
lnprior = priordens(xparam1,bayestopt_.pshape,bayestopt_.p6,bayestopt_.p7,bayestopt_.p3,bayestopt_.p4);
fval = (likelihood-lnprior);
options_.kalman_algo = kalman_algo;

165
matlab/DsgeLikelihood_hh.m
View File

@ -38,45 +38,45 @@ function [fval,llik,cost_flag,ys,trend_coeff,info] = DsgeLikelihood_hh(xparam1,g
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global bayestopt_ estim_params_ options_ trend_coeff_ M_ oo_
fval = [];
ys = [];
trend_coeff = [];
llik = NaN;
cost_flag = 1;
nobs = size(options_.varobs,1);
%------------------------------------------------------------------------------
% 1. Get the structural parameters & define penalties
%------------------------------------------------------------------------------
if options_.mode_compute ~= 1 & any(xparam1 < bayestopt_.lb)
global bayestopt_ estim_params_ options_ trend_coeff_ M_ oo_
fval = [];
ys = [];
trend_coeff = [];
llik = NaN;
cost_flag = 1;
nobs = size(options_.varobs,1);
%------------------------------------------------------------------------------
% 1. Get the structural parameters & define penalties
%------------------------------------------------------------------------------
if options_.mode_compute ~= 1 & any(xparam1 < bayestopt_.lb)
k = find(xparam1 < bayestopt_.lb);
fval = bayestopt_.penalty+sum((bayestopt_.lb(k)-xparam1(k)).^2);
cost_flag = 0;
info = 41;
return;
end
if options_.mode_compute ~= 1 & any(xparam1 > bayestopt_.ub)
end
if options_.mode_compute ~= 1 & any(xparam1 > bayestopt_.ub)
k = find(xparam1 > bayestopt_.ub);
fval = bayestopt_.penalty+sum((xparam1(k)-bayestopt_.ub(k)).^2);
cost_flag = 0;
info = 42;
return;
end
Q = M_.Sigma_e;
H = M_.H;
for i=1:estim_params_.nvx
end
Q = M_.Sigma_e;
H = M_.H;
for i=1:estim_params_.nvx
k =estim_params_.var_exo(i,1);
Q(k,k) = xparam1(i)*xparam1(i);
end
offset = estim_params_.nvx;
if estim_params_.nvn
end
offset = estim_params_.nvx;
if estim_params_.nvn
for i=1:estim_params_.nvn
k = estim_params_.var_endo(i,1);
H(k,k) = xparam1(i+offset)*xparam1(i+offset);
end
offset = offset+estim_params_.nvn;
end
if estim_params_.ncx
end
if estim_params_.ncx
for i=1:estim_params_.ncx
k1 =estim_params_.corrx(i,1);
k2 =estim_params_.corrx(i,2);
@ -96,8 +96,8 @@ function [fval,llik,cost_flag,ys,trend_coeff,info] = DsgeLikelihood_hh(xparam1,g
end
end
offset = offset+estim_params_.ncx;
end
if estim_params_.ncn
end
if estim_params_.ncn
for i=1:estim_params_.ncn
k1 = options_.lgyidx2varobs(estim_params_.corrn(i,1));
k2 = options_.lgyidx2varobs(estim_params_.corrn(i,2));
@ -116,38 +116,38 @@ function [fval,llik,cost_flag,ys,trend_coeff,info] = DsgeLikelihood_hh(xparam1,g
end
end
offset = offset+estim_params_.ncn;
end
if estim_params_.np > 0
end
if estim_params_.np > 0
M_.params(estim_params_.param_vals(:,1)) = xparam1(offset+1:end);
end
M_.Sigma_e = Q;
M_.H = H;
%------------------------------------------------------------------------------
% 2. call model setup & reduction program
%------------------------------------------------------------------------------
[T,R,SteadyState,info] = dynare_resolve(bayestopt_.restrict_var_list,...
end
M_.Sigma_e = Q;
M_.H = H;
%------------------------------------------------------------------------------
% 2. call model setup & reduction program
%------------------------------------------------------------------------------
[T,R,SteadyState,info] = dynare_resolve(bayestopt_.restrict_var_list,...
bayestopt_.restrict_columns,...
bayestopt_.restrict_aux);
if info(1) == 1 | info(1) == 2 | info(1) == 5
if info(1) == 1 | info(1) == 2 | info(1) == 5
fval = bayestopt_.penalty+1;
cost_flag = 0;
return
elseif info(1) == 3 | info(1) == 4 | info(1) == 20
elseif info(1) == 3 | info(1) == 4 | info(1) == 20
fval = bayestopt_.penalty+info(2);%^2; % penalty power raised in DR1.m and resol already. GP July'08
cost_flag = 0;
return
end
bayestopt_.mf = bayestopt_.mf1;
if ~options_.noconstant
end
bayestopt_.mf = bayestopt_.mf1;
if ~options_.noconstant
if options_.loglinear == 1
constant = log(SteadyState(bayestopt_.mfys));
else
constant = SteadyState(bayestopt_.mfys);
end
else
else
constant = zeros(nobs,1);
end
if bayestopt_.with_trend == 1
end
if bayestopt_.with_trend == 1
trend_coeff = zeros(nobs,1);
t = options_.trend_coeffs;
for i=1:length(t)
@ -156,30 +156,30 @@ function [fval,llik,cost_flag,ys,trend_coeff,info] = DsgeLikelihood_hh(xparam1,g
end
end
trend = repmat(constant,1,gend)+trend_coeff*[1:gend];
else
else
trend = repmat(constant,1,gend);
end
start = options_.presample+1;
np = size(T,1);
mf = bayestopt_.mf;
no_missing_data_flag = (number_of_observations==gend*nobs);
%------------------------------------------------------------------------------
% 3. Initial condition of the Kalman filter
%------------------------------------------------------------------------------
kalman_algo = options_.kalman_algo;
if options_.lik_init == 1 % Kalman filter
end
start = options_.presample+1;
np = size(T,1);
mf = bayestopt_.mf;
no_missing_data_flag = (number_of_observations==gend*nobs);
%------------------------------------------------------------------------------
% 3. Initial condition of the Kalman filter
%------------------------------------------------------------------------------
kalman_algo = options_.kalman_algo;
if options_.lik_init == 1 % Kalman filter
if kalman_algo ~= 2
kalman_algo = 1;
end
Pstar = lyapunov_symm(T,R*Q*R',options_.qz_criterium,options_.lyapunov_complex_threshold);
Pinf = [];
elseif options_.lik_init == 2 % Old Diffuse Kalman filter
elseif options_.lik_init == 2 % Old Diffuse Kalman filter
if kalman_algo ~= 2
kalman_algo = 1;
end
Pstar = options_.Harvey_scale_factor*eye(np);
Pinf = [];
elseif options_.lik_init == 3 % Diffuse Kalman filter
elseif options_.lik_init == 3 % Diffuse Kalman filter
if kalman_algo ~= 4
kalman_algo = 3;
end
@ -240,8 +240,8 @@ function [fval,llik,cost_flag,ys,trend_coeff,info] = DsgeLikelihood_hh(xparam1,g
dd(k1) = zeros(length(k1),1);
Pinf(1:nk,1:nk) = diag(dd);
end
end
if kalman_algo == 2
end
if kalman_algo == 2
no_correlation_flag = 1;
if length(H)==1
H = zeros(nobs,1);
@ -252,15 +252,15 @@ function [fval,llik,cost_flag,ys,trend_coeff,info] = DsgeLikelihood_hh(xparam1,g
no_correlation_flag = 1;
end
end
end
kalman_tol = options_.kalman_tol;
riccati_tol = options_.riccati_tol;
mf = bayestopt_.mf1;
Y = data-trend;
%------------------------------------------------------------------------------
% 4. Likelihood evaluation
%------------------------------------------------------------------------------
if (kalman_algo==1)% Multivariate Kalman Filter
end
kalman_tol = options_.kalman_tol;
riccati_tol = options_.riccati_tol;
mf = bayestopt_.mf1;
Y = data-trend;
%------------------------------------------------------------------------------
% 4. Likelihood evaluation
%------------------------------------------------------------------------------
if (kalman_algo==1)% Multivariate Kalman Filter
if no_missing_data_flag
[LIK, lik] = kalman_filter(T,R,Q,H,Pstar,Y,start,mf,kalman_tol,riccati_tol);
else
@ -271,15 +271,15 @@ function [fval,llik,cost_flag,ys,trend_coeff,info] = DsgeLikelihood_hh(xparam1,g
if isinf(LIK)
kalman_algo = 2;
end
end
if (kalman_algo==2)% Univariate Kalman Filter
end
if (kalman_algo==2)% Univariate Kalman Filter
if no_correlation_flag
[LIK, lik] = univariate_kalman_filter(T,R,Q,H,Pstar,Y,start,mf,kalman_tol,riccati_tol,data_index,number_of_observations,no_more_missing_observations);
else
[LIK, lik] = univariate_kalman_filter_corr(T,R,Q,H,Pstar,Y,start,mf,kalman_tol,riccati_tol,data_index,number_of_observations,no_more_missing_observations);
end
end
if (kalman_algo==3)% Multivariate Diffuse Kalman Filter
end
if (kalman_algo==3)% Multivariate Diffuse Kalman Filter
if no_missing_data_flag
data1 = data - trend;
if any(any(H ~= 0))
@ -293,8 +293,8 @@ function [fval,llik,cost_flag,ys,trend_coeff,info] = DsgeLikelihood_hh(xparam1,g
else
error(['The diffuse filter is not yet implemented for models with missing observations'])
end
end
if (kalman_algo==4)% Univariate Diffuse Kalman Filter
end
if (kalman_algo==4)% Univariate Diffuse Kalman Filter
data1 = data - trend;
if any(any(H ~= 0))
if ~estim_params_.ncn
@ -305,17 +305,16 @@ function [fval,llik,cost_flag,ys,trend_coeff,info] = DsgeLikelihood_hh(xparam1,g
else
[LIK, lik] = DiffuseLikelihood3_Z(ST,Z,R1,Q,Pinf,Pstar,data1,start);
end
end
if imag(LIK) ~= 0
end
if imag(LIK) ~= 0
likelihood = bayestopt_.penalty;
else
else
likelihood = LIK;
end
% ------------------------------------------------------------------------------
% Adds prior if necessary
% ------------------------------------------------------------------------------
lnprior = priordens(xparam1,bayestopt_.pshape,bayestopt_.p6,bayestopt_.p7,bayestopt_.p3,bayestopt_.p4);
fval = (likelihood-lnprior);
options_.kalman_algo = kalman_algo;
llik=[-lnprior; lik(start:end)];
end
% ------------------------------------------------------------------------------
% Adds prior if necessary
% ------------------------------------------------------------------------------
lnprior = priordens(xparam1,bayestopt_.pshape,bayestopt_.p6,bayestopt_.p7,bayestopt_.p3,bayestopt_.p4);
fval = (likelihood-lnprior);
options_.kalman_algo = kalman_algo;
llik=[-lnprior; lik(start:end)];

106
matlab/DsgeSmoother.m
View File

@ -47,42 +47,42 @@ function [alphahat,etahat,epsilonhat,ahat,SteadyState,trend_coeff,aK,T,R,P,PK,d,
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global bayestopt_ M_ oo_ estim_params_ options_
global bayestopt_ M_ oo_ estim_params_ options_
alphahat = [];
etahat = [];
epsilonhat = [];
ahat = [];
SteadyState = [];
trend_coeff = [];
aK = [];
T = [];
R = [];
P = [];
PK = [];
d = [];
decomp = [];
nobs = size(options_.varobs,1);
smpl = size(Y,2);
alphahat = [];
etahat = [];
epsilonhat = [];
ahat = [];
SteadyState = [];
trend_coeff = [];
aK = [];
T = [];
R = [];
P = [];
PK = [];
d = [];
decomp = [];
nobs = size(options_.varobs,1);
smpl = size(Y,2);
set_all_parameters(xparam1);
set_all_parameters(xparam1);
%------------------------------------------------------------------------------
% 2. call model setup & reduction program
%------------------------------------------------------------------------------
[T,R,SteadyState] = dynare_resolve;
bayestopt_.mf = bayestopt_.mf2;
if options_.noconstant
%------------------------------------------------------------------------------
% 2. call model setup & reduction program
%------------------------------------------------------------------------------
[T,R,SteadyState] = dynare_resolve;
bayestopt_.mf = bayestopt_.mf2;
if options_.noconstant
constant = zeros(nobs,1);
else
else
if options_.loglinear == 1
constant = log(SteadyState(bayestopt_.mfys));
else
constant = SteadyState(bayestopt_.mfys);
end
end
trend_coeff = zeros(nobs,1);
if bayestopt_.with_trend == 1
end
trend_coeff = zeros(nobs,1);
if bayestopt_.with_trend == 1
trend_coeff = zeros(nobs,1);
t = options_.trend_coeffs;
for i=1:length(t)
@ -91,37 +91,37 @@ function [alphahat,etahat,epsilonhat,ahat,SteadyState,trend_coeff,aK,T,R,P,PK,d,
end
end
trend = constant*ones(1,gend)+trend_coeff*(1:gend);
else
else
trend = constant*ones(1,gend);
end
start = options_.presample+1;
np = size(T,1);
mf = bayestopt_.mf;
% ------------------------------------------------------------------------------
% 3. Initial condition of the Kalman filter
% ------------------------------------------------------------------------------
%
% C'est ici qu'il faut déterminer Pinf et Pstar. Si le modèle est stationnaire,
% alors il suffit de poser Pstar comme la solution de l'éuation de Lyapounov et
% Pinf=[].
%
Q = M_.Sigma_e;
H = M_.H;
end
start = options_.presample+1;
np = size(T,1);
mf = bayestopt_.mf;
% ------------------------------------------------------------------------------
% 3. Initial condition of the Kalman filter
% ------------------------------------------------------------------------------
%
% C'est ici qu'il faut déterminer Pinf et Pstar. Si le modèle est stationnaire,
% alors il suffit de poser Pstar comme la solution de l'éuation de Lyapounov et
% Pinf=[].
%
Q = M_.Sigma_e;
H = M_.H;
kalman_algo = options_.kalman_algo;
if options_.lik_init == 1 % Kalman filter
kalman_algo = options_.kalman_algo;
if options_.lik_init == 1 % Kalman filter
if kalman_algo ~= 2
kalman_algo = 1;
end
Pstar = lyapunov_symm(T,R*Q*transpose(R),options_.qz_criterium,options_.lyapunov_complex_threshold);
Pinf = [];
elseif options_.lik_init == 2 % Old Diffuse Kalman filter
elseif options_.lik_init == 2 % Old Diffuse Kalman filter
if kalman_algo ~= 2
kalman_algo = 1;
end
Pstar = options_.Harvey_scale_factor*eye(np);
Pinf = [];
elseif options_.lik_init == 3 % Diffuse Kalman filter
elseif options_.lik_init == 3 % Diffuse Kalman filter
if kalman_algo ~= 4
kalman_algo = 3;
end
@ -183,11 +183,11 @@ function [alphahat,etahat,epsilonhat,ahat,SteadyState,trend_coeff,aK,T,R,P,PK,d,
dd(k1) = zeros(length(k1),1);
Pinf(1:nk,1:nk) = diag(dd);
end
end
% -----------------------------------------------------------------------------
% 4. Kalman smoother
% -----------------------------------------------------------------------------
if any(any(H ~= 0)) % should be replaced by a flag
end
% -----------------------------------------------------------------------------
% 4. Kalman smoother
% -----------------------------------------------------------------------------
if any(any(H ~= 0)) % should be replaced by a flag
if kalman_algo == 1
[alphahat,epsilonhat,etahat,ahat,aK] = ...
DiffuseKalmanSmootherH1(T,R,Q,H,Pinf,Pstar,Y,trend,nobs,np,smpl,mf);
@ -254,7 +254,7 @@ function [alphahat,etahat,epsilonhat,ahat,SteadyState,trend_coeff,aK,T,R,P,PK,d,
P(:,:,i) = QT*squeeze(P(:,:,i))*QT';
end
end
else
else
if kalman_algo == 1
if missing_value
[alphahat,etahat,ahat,aK] = missing_DiffuseKalmanSmoother1(T,R,Q, ...
@ -324,4 +324,4 @@ function [alphahat,etahat,epsilonhat,ahat,SteadyState,trend_coeff,aK,T,R,P,PK,d,
P(:,:,i) = QT*dynare_squeeze(P(:,:,i))*QT';
end
end
end
end

4
matlab/GetOneDraw.m
View File

@ -31,9 +31,9 @@ function [xparams, logpost] = GetOneDraw(type)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
switch type
switch type
case 'posterior'
[xparams, logpost] = metropolis_draw(0);
case 'prior'
xparams = prior_draw(0);
end
end

68
matlab/GetPosteriorParametersStatistics.m
View File

@ -307,25 +307,25 @@ end
%% subfunctions:
%
function fid = TeXBegin(directory,fname,fnum,title)
TeXfile = [directory '/' fname '_Posterior_Mean_' int2str(fnum) '.TeX'];
fidTeX = fopen(TeXfile,'w');
fprintf(fidTeX,'%% TeX-table generated by Dynare.\n');
fprintf(fidTeX,['%% RESULTS FROM METROPOLIS HASTINGS (' title ')\n']);
fprintf(fidTeX,['%% ' datestr(now,0)]);
fprintf(fidTeX,' \n');
fprintf(fidTeX,' \n');
fprintf(fidTeX,'\\begin{table}\n');
fprintf(fidTeX,'\\centering\n');
fprintf(fidTeX,'\\begin{tabular}{l|lcccccc} \n');
fprintf(fidTeX,'\\hline\\hline \\\\ \n');
fprintf(fidTeX,[' & Prior distribution & Prior mean & Prior ' ...
TeXfile = [directory '/' fname '_Posterior_Mean_' int2str(fnum) '.TeX'];
fidTeX = fopen(TeXfile,'w');
fprintf(fidTeX,'%% TeX-table generated by Dynare.\n');
fprintf(fidTeX,['%% RESULTS FROM METROPOLIS HASTINGS (' title ')\n']);
fprintf(fidTeX,['%% ' datestr(now,0)]);
fprintf(fidTeX,' \n');
fprintf(fidTeX,' \n');
fprintf(fidTeX,'\\begin{table}\n');
fprintf(fidTeX,'\\centering\n');
fprintf(fidTeX,'\\begin{tabular}{l|lcccccc} \n');
fprintf(fidTeX,'\\hline\\hline \\\\ \n');
fprintf(fidTeX,[' & Prior distribution & Prior mean & Prior ' ...
's.d. & Posterior mean & Posterior s.d. & HPD inf & HPD sup\\\\ \n']);
fprintf(fidTeX,'\\hline \\\\ \n');
fid = fidTeX;
fprintf(fidTeX,'\\hline \\\\ \n');
fid = fidTeX;
function TeXCore(fid,name,shape,priormean,priorstd,postmean,poststd,hpd)
fprintf(fid,['$%s$ & %s & %7.3f & %6.4f & %7.3f& %6.4f & %7.4f & %7.4f \\\\ \n'],...
fprintf(fid,['$%s$ & %s & %7.3f & %6.4f & %7.3f& %6.4f & %7.4f & %7.4f \\\\ \n'],...
name,...
shape,...
priormean,...
@ -337,27 +337,27 @@ function TeXCore(fid,name,shape,priormean,priorstd,postmean,poststd,hpd)
function TeXEnd(fid,fnum,title)
fprintf(fid,'\\hline\\hline \n');
fprintf(fid,'\\end{tabular}\n ');
fprintf(fid,['\\caption{Results from Metropolis-Hastings (' title ')}\n ']);
fprintf(fid,['\\label{Table:MHPosterior:' int2str(fnum) '}\n']);
fprintf(fid,'\\end{table}\n');
fprintf(fid,'%% End of TeX file.\n');
fclose(fid);
fprintf(fid,'\\hline\\hline \n');
fprintf(fid,'\\end{tabular}\n ');
fprintf(fid,['\\caption{Results from Metropolis-Hastings (' title ')}\n ']);
fprintf(fid,['\\label{Table:MHPosterior:' int2str(fnum) '}\n']);
fprintf(fid,'\\end{table}\n');
fprintf(fid,'%% End of TeX file.\n');
fclose(fid);
function oo = Filloo(oo,name,type,postmean,hpdinterval,postmedian,postvar,postdecile,density)
eval(['oo.posterior_mean.' type '.' name ' = postmean;']);
eval(['oo.posterior_hpdinf.' type '.' name ' = hpdinterval(1);']);
eval(['oo.posterior_hpdsup.' type '.' name ' = hpdinterval(2);']);
eval(['oo.posterior_median.' type '.' name ' = postmedian;']);
eval(['oo.posterior_variance.' type '.' name ' = postvar;']);
eval(['oo.posterior_deciles.' type '.' name ' = postdecile;']);
eval(['oo.posterior_density.' type '.' name ' = density;']);
eval(['oo.posterior_mean.' type '.' name ' = postmean;']);
eval(['oo.posterior_hpdinf.' type '.' name ' = hpdinterval(1);']);
eval(['oo.posterior_hpdsup.' type '.' name ' = hpdinterval(2);']);
eval(['oo.posterior_median.' type '.' name ' = postmedian;']);
eval(['oo.posterior_variance.' type '.' name ' = postvar;']);
eval(['oo.posterior_deciles.' type '.' name ' = postdecile;']);
eval(['oo.posterior_density.' type '.' name ' = density;']);
function [post_mean,hpd_interval,post_var] = Extractoo(oo,name,type)
hpd_interval = zeros(2,1);
eval(['post_mean = oo.posterior_mean.' type '.' name ';']);
eval(['hpd_interval(1) = oo.posterior_hpdinf.' type '.' name ';']);
eval(['hpd_interval(2) = oo.posterior_hpdsup.' type '.' name ';']);
eval(['post_var = oo.posterior_variance.' type '.' name ';']);
hpd_interval = zeros(2,1);
eval(['post_mean = oo.posterior_mean.' type '.' name ';']);
eval(['hpd_interval(1) = oo.posterior_hpdinf.' type '.' name ';']);
eval(['hpd_interval(2) = oo.posterior_hpdsup.' type '.' name ';']);
eval(['post_var = oo.posterior_variance.' type '.' name ';']);

4
matlab/PosteriorFilterSmootherAndForecast.m
View File

@ -170,7 +170,7 @@ for b=1:B
yf(:,IdObs) = yf(:,IdObs)+(gend+[1-maxlag:horizon]')*trend_coeff';
if options_.loglinear == 1
yf = yf+repmat(log(SteadyState'),horizon+maxlag,1);
% yf = exp(yf);
% yf = exp(yf);
else
yf = yf+repmat(SteadyState',horizon+maxlag,1);
end
@ -183,7 +183,7 @@ for b=1:B
trend_coeff',[1,1,1]);
if options_.loglinear == 1
yf1 = yf1 + repmat(log(SteadyState'),[horizon+maxlag,1,1]);
% yf1 = exp(yf1);
% yf1 = exp(yf1);
else
yf1 = yf1 + repmat(SteadyState',[horizon+maxlag,1,1]);
end

2
matlab/PosteriorIRF.m
View File

@ -219,7 +219,7 @@ while b<=B
% $$$ end
% $$$ mu = transpose(AA\transpose(PHI_draw(end,:)));
% $$$ end
% Get rotation
% Get rotation
if dsge_prior_weight > 0
Atheta(oo_.dr.order_var,M_.exo_names_orig_ord) = oo_.dr.ghu*sqrt(M_.Sigma_e);
A0 = Atheta(bayestopt_.mfys,:);

30
matlab/ReshapeMatFiles.m
View File

@ -42,26 +42,26 @@ function ReshapeMatFiles(type, type2)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_ options_
global M_ options_
if nargin==1,
MhDirectoryName = [ CheckPath('metropolis') '/' ];
else
if strcmpi(type2,'posterior')
MhDirectoryName = [CheckPath('metropolis') '/' ];
elseif strcmpi(type2,'gsa')
if options_.opt_gsa.morris==1,
elseif strcmpi(type2,'gsa')
if options_.opt_gsa.morris==1,
MhDirectoryName = [CheckPath('GSA\SCREEN') '/' ];
elseif options_.opt_gsa.morris==2,
elseif options_.opt_gsa.morris==2,
MhDirectoryName = [CheckPath('GSA\IDENTIF') '/' ];
else
else
MhDirectoryName = [CheckPath('GSA') '/' ];
end
else
end
else
MhDirectoryName = [CheckPath('prior') '/' ];
end
end
end
switch type
switch type
case 'irf_dsge'
CAPtype = 'IRF_DSGE';
TYPEsize = [ options_.irf , size(options_.varlist,1) , M_.exo_nbr ];
@ -97,13 +97,13 @@ end
otherwise
disp('ReshapeMatFiles :: Unknown argument!')
return
end
end
TYPEfiles = dir([MhDirectoryName M_.fname '_' type '*.mat']);
NumberOfTYPEfiles = length(TYPEfiles);
B = options_.B;
TYPEfiles = dir([MhDirectoryName M_.fname '_' type '*.mat']);
NumberOfTYPEfiles = length(TYPEfiles);
B = options_.B;
switch TYPEarray
switch TYPEarray
case 4
if NumberOfTYPEfiles > 1
NumberOfPeriodsPerTYPEfiles = ceil(TYPEsize(1)/NumberOfTYPEfiles);
@ -180,4 +180,4 @@ end
% for file = 1:NumberOfTYPEfiles
% delete([MhDirectoryName M_.fname '_' type int2str(file) '.mat'])
% end
end
end

6
matlab/UnivariateSpectralDensity.m
View File

@ -52,15 +52,15 @@ if size(var_list,1) == 0
var_list = M_.endo_names(1:M_.orig_endo_nbr, :);
end
nvar = size(var_list,1);
ivar=zeros(nvar,1);
for i=1:nvar
ivar=zeros(nvar,1);
for i=1:nvar
i_tmp = strmatch(var_list(i,:),M_.endo_names,'exact');
if isempty(i_tmp)
error (['One of the variable specified does not exist']) ;
else
ivar(i) = i_tmp;
end
end
end
f = zeros(nvar,GridSize);
ghx = dr.ghx;
ghu = dr.ghu;

17
matlab/add_auxiliary_variables_to_steadystate.m
View File

@ -19,20 +19,20 @@ function ys1 = add_auxiliary_variables_to_steadystate(ys,aux_vars,fname, ...
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
n = length(aux_vars);
ys1 = [ys;zeros(n,1)];
k = size(ys,1)+1;
aux_lead_nbr = 0;
for i=1:n
n = length(aux_vars);
ys1 = [ys;zeros(n,1)];
k = size(ys,1)+1;
aux_lead_nbr = 0;
for i=1:n
if aux_vars(i).type == 1
ys1(k) = ys(aux_vars(i).orig_index);
elseif aux_vars(i).type == 0
aux_lead_nbr = aux_lead_nbr + 1;
end
k = k+1;
end
end
for i=1:aux_lead_nbr+1;
for i=1:aux_lead_nbr+1;
res = feval([fname '_static'],ys1,...
[exo_steady_state; ...
exo_det_steady_state],params);
@ -42,5 +42,4 @@ function ys1 = add_auxiliary_variables_to_steadystate(ys,aux_vars,fname, ...
ys1(el) = ys1(el)-res(el);
end
end
end
end

10
matlab/autoregressive_process_specification.m
View File

@ -59,9 +59,9 @@ function [InnovationVariance,AutoregressiveParameters] = autoregressive_process_
%
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
AutoregressiveParameters = NaN(p,1);
InnovationVariance = NaN;
switch p
AutoregressiveParameters = NaN(p,1);
InnovationVariance = NaN;
switch p
case 1
AutoregressiveParameters = Rho(1);
case 2
@ -82,5 +82,5 @@ function [InnovationVariance,AutoregressiveParameters] = autoregressive_process_
AutocorrelationMatrix = AutocorrelationMatrix + diag(Rho(i)*ones(p-i,1),-i);
end
AutoregressiveParameters = AutocorrelationMatrix\Rho;
end
InnovationVariance = Variance * (1-AutoregressiveParameters'*Rho);
end
InnovationVariance = Variance * (1-AutoregressiveParameters'*Rho);

28
matlab/bicgstab_.m
View File

@ -17,20 +17,20 @@ function [x,status]=bicgstab_(func,b,x,tole,kmax,varargin)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
status = 0;
r=b-feval(func,x,varargin{:});
rh_0 = r;
rh = r;
rho_0 = 1;
alpha = 1;
w = 1;
v = 0;
p = 0;
k = 0;
rho_1 = rh_0'*r;
tolr = tole*norm(b);
status = 0;
r=b-feval(func,x,varargin{:});
rh_0 = r;
rh = r;
rho_0 = 1;
alpha = 1;
w = 1;
v = 0;
p = 0;
k = 0;
rho_1 = rh_0'*r;
tolr = tole*norm(b);
while norm(r) > tolr & k < kmax
while norm(r) > tolr & k < kmax
k = k+1;
beta = (rho_1/rho_0)*(alpha/w);
p = r+beta*(p-w*v);
@ -43,7 +43,7 @@ function [x,status]=bicgstab_(func,b,x,tole,kmax,varargin)
rho_1 = -w*(rh_0'*t);
x = x+alpha*p+w*r;
r = r-w*t;
end
end
if k == kmax
status = 1;
warning(sprintf('BICSTABN didn''t converge after %d iterations: norm(r) = %g',kmax,norm(r)));

12
matlab/block_mfs_steadystate.m
View File

@ -19,12 +19,12 @@ function [r, g1] = block_mfs_steadystate(y, b)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_ oo_
global M_ oo_
ss = oo_.steady_state;
indx = M_.blocksMFS{b};
ss = oo_.steady_state;
indx = M_.blocksMFS{b};
ss(indx) = y;
x = [oo_.exo_steady_state; oo_.exo_det_steady_state];
ss(indx) = y;
x = [oo_.exo_steady_state; oo_.exo_det_steady_state];
eval(['[r,g1] = ' M_.fname '_static(b, ss, x, M_.params);']);
eval(['[r,g1] = ' M_.fname '_static(b, ss, x, M_.params);']);

36
matlab/bvar_density.m
View File

@ -29,7 +29,7 @@ function bvar_density(maxnlags)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
for nlags = 1:maxnlags
for nlags = 1:maxnlags
[ny, nx, posterior, prior] = bvar_toolbox(nlags);
posterior_int = matrictint(posterior.S, posterior.df, posterior.XXi);
@ -43,7 +43,7 @@ function bvar_density(maxnlags)
fprintf('The marginal log density of the BVAR(%g) model is equal to %10.4f\n', ...
nlags, log_dnsty);
disp(' ')
end
end
function w = matrictint(S, df, XXi)
@ -65,30 +65,30 @@ function w = matrictint(S, df, XXi)
% Original file downloaded from:
% http://sims.princeton.edu/yftp/VARtools/matlab/matrictint.m
k=size(XXi,1);
ny=size(S,1);
[cx,p]=chol(XXi);
[cs,q]=chol(S);
k=size(XXi,1);
ny=size(S,1);
[cx,p]=chol(XXi);
[cs,q]=chol(S);
if any(diag(cx)<100*eps)
if any(diag(cx)<100*eps)
error('singular XXi')
end
if any(diag(cs<100*eps))
end
if any(diag(cs<100*eps))
error('singular S')
end
end
% Matrix-normal component
w1 = 0.5*k*ny*log(2*pi)+ny*sum(log(diag(cx)));
% Matrix-normal component
w1 = 0.5*k*ny*log(2*pi)+ny*sum(log(diag(cx)));
% Inverse-Wishart component
w2 = -df*sum(log(diag(cs))) + 0.5*df*ny*log(2) + ny*(ny-1)*0.25*log(pi) + ggammaln(ny, df);
% Inverse-Wishart component
w2 = -df*sum(log(diag(cs))) + 0.5*df*ny*log(2) + ny*(ny-1)*0.25*log(pi) + ggammaln(ny, df);
w = w1 + w2;
w = w1 + w2;
function lgg = ggammaln(m, df)
if df <= (m-1)
if df <= (m-1)
error('too few df in ggammaln')
else
else
garg = 0.5*(df+(0:-1:1-m));
lgg = sum(gammaln(garg));
end
end

92
matlab/bvar_forecast.m
View File

@ -28,33 +28,33 @@ function bvar_forecast(nlags)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global options_ oo_ M_
global options_ oo_ M_
options_ = set_default_option(options_, 'bvar_replic', 2000);
if options_.forecast == 0
options_ = set_default_option(options_, 'bvar_replic', 2000);
if options_.forecast == 0
error('bvar_forecast: you must specify "forecast" option')
end
[ny, nx, posterior, prior, forecast_data] = bvar_toolbox(nlags);
end
[ny, nx, posterior, prior, forecast_data] = bvar_toolbox(nlags);
sims_no_shock = NaN(options_.forecast, ny, options_.bvar_replic);
sims_with_shocks = NaN(options_.forecast, ny, options_.bvar_replic);
sims_no_shock = NaN(options_.forecast, ny, options_.bvar_replic);
sims_with_shocks = NaN(options_.forecast, ny, options_.bvar_replic);
S_inv_upper_chol = chol(inv(posterior.S));
S_inv_upper_chol = chol(inv(posterior.S));
% Option 'lower' of chol() not available in old versions of
% Matlab, so using transpose
XXi_lower_chol = chol(posterior.XXi)';
% Option 'lower' of chol() not available in old versions of
% Matlab, so using transpose
XXi_lower_chol = chol(posterior.XXi)';
k = ny*nlags+nx;
k = ny*nlags+nx;
% Declaration of the companion matrix
Companion_matrix = diag(ones(ny*(nlags-1),1),-ny);
% Declaration of the companion matrix
Companion_matrix = diag(ones(ny*(nlags-1),1),-ny);
% Number of explosive VAR models sampled
p = 0;
% Loop counter initialization
d = 0;
while d <= options_.bvar_replic
% Number of explosive VAR models sampled
p = 0;
% Loop counter initialization
d = 0;
while d <= options_.bvar_replic
Sigma = rand_inverse_wishart(ny, posterior.df, S_inv_upper_chol);
@ -92,44 +92,44 @@ function bvar_forecast(nlags)
lags_data(end,:) = y;
sims_with_shocks(t, :, d) = y;
end
end
end
if p > 0
if p > 0
disp(' ')
disp(['Some of the VAR models sampled from the posterior distribution'])
disp(['were found to be explosive (' num2str(p/options_.bvar_replic) ' percent).'])
disp(' ')
end
end
% Plot graphs
sims_no_shock_mean = mean(sims_no_shock, 3);
% Plot graphs
sims_no_shock_mean = mean(sims_no_shock, 3);
sort_idx = round((0.5 + [-options_.conf_sig, options_.conf_sig, 0]/2) * options_.bvar_replic);
sort_idx = round((0.5 + [-options_.conf_sig, options_.conf_sig, 0]/2) * options_.bvar_replic);
sims_no_shock_sort = sort(sims_no_shock, 3);
sims_no_shock_down_conf = sims_no_shock_sort(:, :, sort_idx(1));
sims_no_shock_up_conf = sims_no_shock_sort(:, :, sort_idx(2));
sims_no_shock_median = sims_no_shock_sort(:, :, sort_idx(3));
sims_no_shock_sort = sort(sims_no_shock, 3);
sims_no_shock_down_conf = sims_no_shock_sort(:, :, sort_idx(1));
sims_no_shock_up_conf = sims_no_shock_sort(:, :, sort_idx(2));
sims_no_shock_median = sims_no_shock_sort(:, :, sort_idx(3));
sims_with_shocks_sort = sort(sims_with_shocks, 3);
sims_with_shocks_down_conf = sims_with_shocks_sort(:, :, sort_idx(1));
sims_with_shocks_up_conf = sims_with_shocks_sort(:, :, sort_idx(2));
sims_with_shocks_sort = sort(sims_with_shocks, 3);
sims_with_shocks_down_conf = sims_with_shocks_sort(:, :, sort_idx(1));
sims_with_shocks_up_conf = sims_with_shocks_sort(:, :, sort_idx(2));
dynare_graph_init(sprintf('BVAR forecasts (nlags = %d)', nlags), ny, {'b-' 'g-' 'g-' 'r-' 'r-'});
dynare_graph_init(sprintf('BVAR forecasts (nlags = %d)', nlags), ny, {'b-' 'g-' 'g-' 'r-' 'r-'});
for i = 1:ny
for i = 1:ny
dynare_graph([ sims_no_shock_median(:, i) ...
sims_no_shock_up_conf(:, i) sims_no_shock_down_conf(:, i) ...
sims_with_shocks_up_conf(:, i) sims_with_shocks_down_conf(:, i) ], ...
options_.varobs(i, :));
end
end
dynare_graph_close;
dynare_graph_close;
% Compute RMSE
% Compute RMSE
if ~isempty(forecast_data.realized_val)
if ~isempty(forecast_data.realized_val)
sq_err_cumul = zeros(1, ny);
@ -149,20 +149,20 @@ function bvar_forecast(nlags)
for i = 1:size(options_.varobs, 1)
fprintf('%s: %10.4f\n', options_.varobs(i, :), rmse(i));
end
end
end
% Store results
% Store results
DirectoryName = [ M_.fname '/bvar_forecast' ];
if ~isdir(DirectoryName)
DirectoryName = [ M_.fname '/bvar_forecast' ];
if ~isdir(DirectoryName)
if ~isdir(M_.fname)
mkdir(M_.fname);
end
mkdir(DirectoryName);
end
save([ DirectoryName '/simulations.mat'], 'sims_no_shock', 'sims_with_shocks');
end
save([ DirectoryName '/simulations.mat'], 'sims_no_shock', 'sims_with_shocks');
for i = 1:size(options_.varobs, 1)
for i = 1:size(options_.varobs, 1)
name = options_.varobs(i, :);
sims = squeeze(sims_with_shocks(:,i,:));
@ -182,4 +182,4 @@ function bvar_forecast(nlags)
if exist('rmse')
eval(['oo_.bvar.forecast.rmse.' name ' = rmse(i);']);
end
end
end

80
matlab/bvar_irf.m
View File

@ -28,34 +28,34 @@ function bvar_irf(nlags,identification)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global options_ oo_ M_
global options_ oo_ M_
if nargin==1
if nargin==1
identification = 'Cholesky';
end
end
options_ = set_default_option(options_, 'bvar_replic', 2000);
options_ = set_default_option(options_, 'bvar_replic', 2000);
[ny, nx, posterior, prior] = bvar_toolbox(nlags);
[ny, nx, posterior, prior] = bvar_toolbox(nlags);
S_inv_upper_chol = chol(inv(posterior.S));
S_inv_upper_chol = chol(inv(posterior.S));
% Option 'lower' of chol() not available in old versions of
% Matlab, so using transpose
XXi_lower_chol = chol(posterior.XXi)';
% Option 'lower' of chol() not available in old versions of
% Matlab, so using transpose
XXi_lower_chol = chol(posterior.XXi)';
k = ny*nlags+nx;
k = ny*nlags+nx;
% Declaration of the companion matrix
Companion_matrix = diag(ones(ny*(nlags-1),1),-ny);
% Declaration of the companion matrix
Companion_matrix = diag(ones(ny*(nlags-1),1),-ny);
% Number of explosive VAR models sampled
p = 0;
% Number of explosive VAR models sampled
p = 0;
% Initialize a four dimensional array.
sampled_irfs = NaN(ny, ny, options_.irf, options_.bvar_replic);
% Initialize a four dimensional array.
sampled_irfs = NaN(ny, ny, options_.irf, options_.bvar_replic);
for draw=1:options_.bvar_replic
for draw=1:options_.bvar_replic
% Get a covariance matrix from an inverted Wishart distribution.
Sigma = rand_inverse_wishart(ny, posterior.df, S_inv_upper_chol);
@ -91,30 +91,30 @@ function bvar_irf(nlags,identification)
lags_data(:,1:ny) = sampled_irfs(:,:,t,draw) ;
end
end
end
if p > 0
if p > 0
disp(' ')
disp(['Some of the VAR models sampled from the posterior distribution'])
disp(['were found to be explosive (' int2str(p) ' samples).'])
disp(' ')
end
end
posterior_mean_irfs = mean(sampled_irfs,4);
posterior_variance_irfs = var(sampled_irfs, 1, 4);
posterior_mean_irfs = mean(sampled_irfs,4);
posterior_variance_irfs = var(sampled_irfs, 1, 4);
sorted_irfs = sort(sampled_irfs,4);
sort_idx = round((0.5 + [-options_.conf_sig, options_.conf_sig, .0]/2) * options_.bvar_replic);
sorted_irfs = sort(sampled_irfs,4);
sort_idx = round((0.5 + [-options_.conf_sig, options_.conf_sig, .0]/2) * options_.bvar_replic);
posterior_down_conf_irfs = sorted_irfs(:,:,:,sort_idx(1));
posterior_up_conf_irfs = sorted_irfs(:,:,:,sort_idx(2));
posterior_median_irfs = sorted_irfs(:,:,:,sort_idx(3));
posterior_down_conf_irfs = sorted_irfs(:,:,:,sort_idx(1));
posterior_up_conf_irfs = sorted_irfs(:,:,:,sort_idx(2));
posterior_median_irfs = sorted_irfs(:,:,:,sort_idx(3));
number_of_columns = fix(sqrt(ny));
number_of_rows = ceil(ny / number_of_columns) ;
number_of_columns = fix(sqrt(ny));
number_of_rows = ceil(ny / number_of_columns) ;
% Plots of the IRFs
for shock=1:ny
% Plots of the IRFs
for shock=1:ny
figure('Name',['Posterior BVAR Impulse Responses (shock in equation ' int2str(shock) ').']);
for variable=1:ny
subplot(number_of_rows,number_of_columns,variable);
@ -129,17 +129,17 @@ function bvar_irf(nlags,identification)
axis tight
hold off
end
end
end
% Save intermediate results
DirectoryName = [ M_.fname '/bvar_irf' ];
if ~isdir(DirectoryName)
% Save intermediate results
DirectoryName = [ M_.fname '/bvar_irf' ];
if ~isdir(DirectoryName)
mkdir('.',DirectoryName);
end
save([ DirectoryName '/simulations.mat'], 'sampled_irfs');
end
save([ DirectoryName '/simulations.mat'], 'sampled_irfs');
% Save results in oo_
for i=1:ny
% Save results in oo_
for i=1:ny
shock_name = options_.varobs(i, :);
for j=1:ny
variable_name = options_.varobs(j, :);
@ -149,4 +149,4 @@ function bvar_irf(nlags,identification)
eval(['oo_.bvar.irf.Upper_bound.' variable_name '.' shock_name ' = posterior_up_conf_irfs(' int2str(j) ',' int2str(i) ',:);'])
eval(['oo_.bvar.irf.Lower_bound.' variable_name '.' shock_name ' = posterior_down_conf_irfs(' int2str(j) ',' int2str(i) ',:);'])
end
end
end

212
matlab/bvar_toolbox.m
View File

@ -59,95 +59,95 @@ function [ny, nx, posterior, prior, forecast_data] = bvar_toolbox(nlags)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global options_
global options_
% Load dataset
dataset = read_variables(options_.datafile, options_.varobs, [], options_.xls_sheet, options_.xls_range);
options_ = set_default_option(options_, 'nobs', size(dataset,1)-options_.first_obs+1);
% Load dataset
dataset = read_variables(options_.datafile, options_.varobs, [], options_.xls_sheet, options_.xls_range);
options_ = set_default_option(options_, 'nobs', size(dataset,1)-options_.first_obs+1);
% Parameters for prior
options_ = set_default_option(options_, 'bvar_prior_tau', 3);
options_ = set_default_option(options_, 'bvar_prior_decay', 0.5);
options_ = set_default_option(options_, 'bvar_prior_lambda', 5);
options_ = set_default_option(options_, 'bvar_prior_mu', 2);
options_ = set_default_option(options_, 'bvar_prior_omega', 1);
options_ = set_default_option(options_, 'bvar_prior_flat', 0);
options_ = set_default_option(options_, 'bvar_prior_train', 0);
% Parameters for prior
options_ = set_default_option(options_, 'bvar_prior_tau', 3);
options_ = set_default_option(options_, 'bvar_prior_decay', 0.5);
options_ = set_default_option(options_, 'bvar_prior_lambda', 5);
options_ = set_default_option(options_, 'bvar_prior_mu', 2);
options_ = set_default_option(options_, 'bvar_prior_omega', 1);
options_ = set_default_option(options_, 'bvar_prior_flat', 0);
options_ = set_default_option(options_, 'bvar_prior_train', 0);
if options_.first_obs + options_.presample <= nlags
if options_.first_obs + options_.presample <= nlags
error('first_obs+presample should be > nlags (for initializing the VAR)')
end
end
train = options_.bvar_prior_train;
train = options_.bvar_prior_train;
if options_.first_obs + options_.presample - train <= nlags
if options_.first_obs + options_.presample - train <= nlags
error('first_obs+presample-train should be > nlags (for initializating the VAR)')
end
end
idx = options_.first_obs+options_.presample-train-nlags:options_.first_obs+options_.nobs-1;
idx = options_.first_obs+options_.presample-train-nlags:options_.first_obs+options_.nobs-1;
% Prepare dataset
if options_.loglinear & ~options_.logdata
% Prepare dataset
if options_.loglinear & ~options_.logdata
dataset = log(dataset);
end
if options_.prefilter
end
if options_.prefilter
dataset(idx,:) = dataset(idx,:) - ones(length(idx),1)*mean(dataset(idx,:));
end
end
mnprior.tight = options_.bvar_prior_tau;
mnprior.decay = options_.bvar_prior_decay;
mnprior.tight = options_.bvar_prior_tau;
mnprior.decay = options_.bvar_prior_decay;
% Use only initializations lags for the variance prior
vprior.sig = std(dataset(options_.first_obs+options_.presample-nlags:options_.first_obs+options_.presample-1,:))';
vprior.w = options_.bvar_prior_omega;
% Use only initializations lags for the variance prior
vprior.sig = std(dataset(options_.first_obs+options_.presample-nlags:options_.first_obs+options_.presample-1,:))';
vprior.w = options_.bvar_prior_omega;
lambda = options_.bvar_prior_lambda;
mu = options_.bvar_prior_mu;
flat = options_.bvar_prior_flat;
lambda = options_.bvar_prior_lambda;
mu = options_.bvar_prior_mu;
flat = options_.bvar_prior_flat;
ny = size(dataset, 2);
if options_.prefilter | options_.noconstant
ny = size(dataset, 2);
if options_.prefilter | options_.noconstant
nx = 0;
else
else
nx = 1;
end
end
[ydum, xdum, pbreaks] = varprior(ny, nx, nlags, mnprior, vprior);
[ydum, xdum, pbreaks] = varprior(ny, nx, nlags, mnprior, vprior);
ydata = dataset(idx, :);
T = size(ydata, 1);
xdata = ones(T,nx);
ydata = dataset(idx, :);
T = size(ydata, 1);
xdata = ones(T,nx);
% Posterior density
var = rfvar3([ydata; ydum], nlags, [xdata; xdum], [T; T+pbreaks], lambda, mu);
Tu = size(var.u, 1);
% Posterior density
var = rfvar3([ydata; ydum], nlags, [xdata; xdum], [T; T+pbreaks], lambda, mu);
Tu = size(var.u, 1);
posterior.df = Tu - ny*nlags - nx - flat*(ny+1);
posterior.S = var.u' * var.u;
posterior.XXi = var.xxi;
posterior.PhiHat = var.B;
posterior.df = Tu - ny*nlags - nx - flat*(ny+1);
posterior.S = var.u' * var.u;
posterior.XXi = var.xxi;
posterior.PhiHat = var.B;
% Prior density
Tp = train + nlags;
if nx
% Prior density
Tp = train + nlags;
if nx
xdata = xdata(1:Tp, :);
else
else
xdata = [];
end
varp = rfvar3([ydata(1:Tp, :); ydum], nlags, [xdata; xdum], [Tp; Tp + pbreaks], lambda, mu);
Tup = size(varp.u, 1);
end
varp = rfvar3([ydata(1:Tp, :); ydum], nlags, [xdata; xdum], [Tp; Tp + pbreaks], lambda, mu);
Tup = size(varp.u, 1);
prior.df = Tup - ny*nlags - nx - flat*(ny+1);
prior.S = varp.u' * varp.u;
prior.XXi = varp.xxi;
prior.PhiHat = varp.B;
prior.df = Tup - ny*nlags - nx - flat*(ny+1);
prior.S = varp.u' * varp.u;
prior.XXi = varp.xxi;
prior.PhiHat = varp.B;
if prior.df < ny
if prior.df < ny
error('Too few degrees of freedom in the inverse-Wishart part of prior distribution. You should increase training sample size.')
end
end
% Add forecast informations
if nargout >= 5
% Add forecast informations
if nargout >= 5
forecast_data.xdata = ones(options_.forecast, nx);
forecast_data.initval = ydata(end-nlags+1:end, :);
if options_.first_obs + options_.nobs <= size(dataset, 1)
@ -156,7 +156,7 @@ function [ny, nx, posterior, prior, forecast_data] = bvar_toolbox(nlags)
else
forecast_data.realized_val = [];
end
end
end
function [ydum,xdum,breaks]=varprior(nv,nx,lags,mnprior,vprior)
@ -185,7 +185,7 @@ function [ydum,xdum,breaks]=varprior(nv,nx,lags,mnprior,vprior)
% Original file downloaded from:
% http://sims.princeton.edu/yftp/VARtools/matlab/varprior.m
if ~isempty(mnprior)
if ~isempty(mnprior)
xdum = zeros(lags+1,nx,lags,nv);
ydum = zeros(lags+1,nv,lags,nv);
for il = 1:lags
@ -198,13 +198,13 @@ function [ydum,xdum,breaks]=varprior(nv,nx,lags,mnprior,vprior)
xdum = flipdim(xdum,1);
breaks = (lags+1)*[1:(nv*lags)]';
lbreak = breaks(end);
else
else
ydum = [];
xdum = [];
breaks = [];
lbreak = 0;
end
if ~isempty(vprior) & vprior.w>0
end
if ~isempty(vprior) & vprior.w>0
ydum2 = zeros(lags+1,nv,nv);
xdum2 = zeros(lags+1,nx,nv);
ydum2(end,:,:) = diag(vprior.sig);
@ -214,11 +214,11 @@ function [ydum,xdum,breaks]=varprior(nv,nx,lags,mnprior,vprior)
breaks = [breaks;(lags+1)*[1:nv]'+lbreak];
lbreak = breaks(end);
end
end
dimy = size(ydum);
ydum = reshape(permute(ydum,[1 3 2]),dimy(1)*dimy(3),nv);
xdum = reshape(permute(xdum,[1 3 2]),dimy(1)*dimy(3),nx);
breaks = breaks(1:(end-1));
end
dimy = size(ydum);
ydum = reshape(permute(ydum,[1 3 2]),dimy(1)*dimy(3),nv);
xdum = reshape(permute(xdum,[1 3 2]),dimy(1)*dimy(3),nx);
breaks = breaks(1:(end-1));
function var=rfvar3(ydata,lags,xdata,breaks,lambda,mu)
@ -253,40 +253,40 @@ function var=rfvar3(ydata,lags,xdata,breaks,lambda,mu)
% Original file downloaded from:
% http://sims.princeton.edu/yftp/VARtools/matlab/rfvar3.m
[T,nvar] = size(ydata);
nox = isempty(xdata);
if ~nox
[T,nvar] = size(ydata);
nox = isempty(xdata);
if ~nox
[T2,nx] = size(xdata);
else
else
T2 = T;
nx = 0;
xdata = zeros(T2,0);
end
% note that x must be same length as y, even though first part of x will not be used.
% This is so that the lags parameter can be changed without reshaping the xdata matrix.
if T2 ~= T, error('Mismatch of x and y data lengths'),end
if nargin < 4
end
% note that x must be same length as y, even though first part of x will not be used.
% This is so that the lags parameter can be changed without reshaping the xdata matrix.
if T2 ~= T, error('Mismatch of x and y data lengths'),end
if nargin < 4
nbreaks = 0;
breaks = [];
else
else
nbreaks = length(breaks);
end
breaks = [0;breaks;T];
smpl = [];
for nb = 1:nbreaks+1
end
breaks = [0;breaks;T];
smpl = [];
for nb = 1:nbreaks+1
smpl = [smpl;[breaks(nb)+lags+1:breaks(nb+1)]'];
end
Tsmpl = size(smpl,1);
X = zeros(Tsmpl,nvar,lags);
for is = 1:length(smpl)
end
Tsmpl = size(smpl,1);
X = zeros(Tsmpl,nvar,lags);
for is = 1:length(smpl)
X(is,:,:) = ydata(smpl(is)-(1:lags),:)';
end
X = [X(:,:) xdata(smpl,:)];
y = ydata(smpl,:);
% Everything now set up with input data for y=Xb+e
end
X = [X(:,:) xdata(smpl,:)];
y = ydata(smpl,:);
% Everything now set up with input data for y=Xb+e
% Add persistence dummies
if lambda ~= 0 | mu > 0
% Add persistence dummies
if lambda ~= 0 | mu > 0
ybar = mean(ydata(1:lags,:),1);
if ~nox
xbar = mean(xdata(1:lags,:),1);
@ -311,16 +311,16 @@ function var=rfvar3(ydata,lags,xdata,breaks,lambda,mu)
X = [X;xdum];
y = [y;ydum];
end
end
end
% Compute OLS regression and residuals
[vl,d,vr] = svd(X,0);
di = 1./diag(d);
B = (vr.*repmat(di',nvar*lags+nx,1))*vl'*y;
u = y-X*B;
xxi = vr.*repmat(di',nvar*lags+nx,1);
xxi = xxi*xxi';
% Compute OLS regression and residuals
[vl,d,vr] = svd(X,0);
di = 1./diag(d);
B = (vr.*repmat(di',nvar*lags+nx,1))*vl'*y;
u = y-X*B;
xxi = vr.*repmat(di',nvar*lags+nx,1);
xxi = xxi*xxi';
var.B = B;
var.u = u;
var.xxi = xxi;
var.B = B;
var.u = u;
var.xxi = xxi;

152
matlab/calib.m
View File

@ -17,47 +17,47 @@ function M_.Sigma_e = calib(var_indices,targets,var_weights,nar,cova,M_.Sigma_e)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global oo_ M_ vx
global oo_ M_ vx
ncstr = 0;
ni = size(var_indices,1);
for i=1:nar+3
ncstr = 0;
ni = size(var_indices,1);
for i=1:nar+3
ncstr = ncstr + size(var_indices{i},1);
end
if cova
end
if cova
if ncstr < M_.exo_nbr*(M_.exo_nbr+1)/2
error(['number of preset variances is smaller than number of shock' ...
' variances and covariances to be estimated !'])
end
else
else
if ncstr < M_.exo_nbr
error(['number of preset variances is smaller than number of shock' ...
' variances to be estimated !'])
end
end
end
% computes approximate solution at order 1
dr = resol(oo_.steady_state,0,0,1);
% computes approximate solution at order 1
dr = resol(oo_.steady_state,0,0,1);
ghx = dr.ghx;
ghu = dr.ghu;
npred = dr.npred;
nstatic = dr.nstatic;
kstate = dr.kstate;
order = dr.order_var;
iv(order) = [1:M_.endo_nbr];
iv = iv';
nx = size(ghx,2);
ghx = dr.ghx;
ghu = dr.ghu;
npred = dr.npred;
nstatic = dr.nstatic;
kstate = dr.kstate;
order = dr.order_var;
iv(order) = [1:M_.endo_nbr];
iv = iv';
nx = size(ghx,2);
ikx = [nstatic+1:nstatic+npred];
ikx = [nstatic+1:nstatic+npred];
A = zeros(nx,nx);
A(1:npred,:)=ghx(ikx,:);
offset_r = npred;
offset_c = 0;
i0 = find(kstate(:,2) == M_.maximum_lag+1);
n0 = size(i0,1);
for i=M_.maximum_lag:-1:2
A = zeros(nx,nx);
A(1:npred,:)=ghx(ikx,:);
offset_r = npred;
offset_c = 0;
i0 = find(kstate(:,2) == M_.maximum_lag+1);
n0 = size(i0,1);
for i=M_.maximum_lag:-1:2
i1 = find(kstate(:,2) == i);
n1 = size(i1,1);
j = zeros(n1,1);
@ -69,61 +69,61 @@ function M_.Sigma_e = calib(var_indices,targets,var_weights,nar,cova,M_.Sigma_e)
offset_c = offset_c + n0;
i0 = i1;
n0 = n1;
end
ghu1 = [ghu(ikx,:);zeros(nx-npred,M_.exo_nbr)];
end
ghu1 = [ghu(ikx,:);zeros(nx-npred,M_.exo_nbr)];
% IA = speye(nx*nx)-kron(A,A);
% kron_ghu = kron(ghu1,ghu1);
% vx1 such that vec(sigma_x) = vx1 * vec(M_.Sigma_e) (predetermined vars)
% vx1 such that vec(sigma_x) = vx1 * vec(M_.Sigma_e) (predetermined vars)
vx1 = [];
% vx1 = IA\kron_ghu;
IA = [];
kron_ghu = [];
% vx1 = IA\kron_ghu;
IA = [];
kron_ghu = [];
% computes required variables and indices among required variables
iiy = [];
for i=1:nar+3
% computes required variables and indices among required variables
iiy = [];
for i=1:nar+3
if i ~= 3 & ~isempty(var_indices{i})
iiy = union(iiy, iv(var_indices{i}(:,1)));
end
end
if ~isempty(var_indices{2})
end
if ~isempty(var_indices{2})
iiy = union(iiy, iv(var_indices{2}(:,2)));
end
ny = size(iiy,1);
end
ny = size(iiy,1);
for i=1:nar+3
for i=1:nar+3
if i ~= 3 & ~isempty(var_indices{i})
var_indices{i}(:,1) = indnv(iv(var_indices{i}(:,1)),iiy);
end
if i ~= 2 & i ~= 3 & ~isempty(var_indices{i})
var_indices{i} = sub2ind([ny ny],var_indices{i},var_indices{i});
end
end
if ~isempty(var_indices{2})
end
if ~isempty(var_indices{2})
var_indices{2}(:,2) = indnv(iv(var_indices{2}(:,2)),iiy);
var_indices{2} = sub2ind([ny ny],var_indices{2}(:,1),var_indices{2}(:,2));
end
if ~isempty(var_indices{3})
end
if ~isempty(var_indices{3})
var_indices{3} = sub2ind([M_.exo_nbr M_.exo_nbr],var_indices{3}(:,1),var_indices{3}(:,2));
end
if isempty(M_.Sigma_e)
end
if isempty(M_.Sigma_e)
M_.Sigma_e = 0.01*eye(M_.exo_nbr);
b = 0.1*ghu1*ghu1';
else
else
b = ghu1*M_.Sigma_e*ghu1';
M_.Sigma_e = chol(M_.Sigma_e+1e-14*eye(M_.exo_nbr));
end
options=optimset('LargeScale','on','MaxFunEvals',20000*ny,'TolX',1e-4, ...
end
options=optimset('LargeScale','on','MaxFunEvals',20000*ny,'TolX',1e-4, ...
'TolFun',1e-4,'Display','Iter','MaxIter',10000);
% [M_.Sigma_e,f]=fminunc(@calib_obj,M_.Sigma_e,options,A,ghu1,ghx(iiy,:),ghu(iiy,:),targets,var_weights,var_indices,nar);
[M_.Sigma_e,f]=fmincon(@calib_obj,diag(M_.Sigma_e).^2,-eye(M_.exo_nbr),zeros(M_.exo_nbr,1),[],[],[],[],[],options,A,ghu1,ghx(iiy,:),ghu(iiy,:),targets,var_weights,var_indices,nar);
M_.Sigma_e = diag(M_.Sigma_e);
[M_.Sigma_e,f]=fmincon(@calib_obj,diag(M_.Sigma_e).^2,-eye(M_.exo_nbr),zeros(M_.exo_nbr,1),[],[],[],[],[],options,A,ghu1,ghx(iiy,:),ghu(iiy,:),targets,var_weights,var_indices,nar);
M_.Sigma_e = diag(M_.Sigma_e);
objective = calib_obj2(diag(M_.Sigma_e),A,ghu1,ghx(iiy,:),ghu(iiy,:),targets,var_weights,var_indices,nar);
disp('CALIBRATION')
disp('')
if ~isempty(var_indices{1})
objective = calib_obj2(diag(M_.Sigma_e),A,ghu1,ghx(iiy,:),ghu(iiy,:),targets,var_weights,var_indices,nar);
disp('CALIBRATION')
disp('')
if ~isempty(var_indices{1})
disp(sprintf('%16s %14s %14s %14s %14s','Std. Dev','Target','Obtained','Diff'));
str = ' ';
for i=1:size(var_indices{1},1)
@ -131,8 +131,8 @@ vx1 = [];
str = sprintf('%16s: %14.2f %14.2f %14.2f',M_.endo_names(order(iiy(i1)),:),targets{1}(i),objective{1}(i),objective{1}(i)-targets{1}(i));
disp(str);
end
end
if ~isempty(var_indices{2})
end
if ~isempty(var_indices{2})
disp(sprintf('%32s %14s %14s','Correlations','Target','Obtained','Diff'));
str = ' ';
for i=1:size(var_indices{2},1)
@ -141,8 +141,8 @@ vx1 = [];
M_.endo_names(order(iiy(i2)),:),targets{2}(i),objective{2}(i),objective{2}(i)-targets{2}(i));
disp(str);
end
end
if ~isempty(var_indices{3})
end
if ~isempty(var_indices{3})
disp(sprintf('%32s %16s %16s','Constrained shocks (co)variances','Target','Obtained'));
str = ' ';
for i=1:size(var_indices{3},1)
@ -156,9 +156,9 @@ vx1 = [];
end
disp(str);
end
end
flag = 1;
for j=4:nar+3
end
flag = 1;
for j=4:nar+3
if ~isempty(var_indices{j})
if flag
disp(sprintf('%16s %16s %16s','Autocorrelations','Target','Obtained'));
@ -172,22 +172,22 @@ vx1 = [];
disp(str);
end
end
end
end
disp('');
disp('Calibrated variances')
str = ' ';
for i=1:M_.exo_nbr
disp('');
disp('Calibrated variances')
str = ' ';
for i=1:M_.exo_nbr
str = [str sprintf('%16s',M_.exo_name(i,:))];
end
disp(str);
disp('');
str = ' ';
for i=1:M_.exo_nbr
end
disp(str);
disp('');
str = ' ';
for i=1:M_.exo_nbr
str = [str sprintf('%16f',M_.Sigma_e(i,i))];
end
disp(str);
end
disp(str);
% 10/9/02 MJ
% 10/9/02 MJ

55
matlab/calib_obj.m
View File

@ -19,45 +19,45 @@ function f=calib_obj(M_.Sigma_e,A,ghu1,ghx,ghu,targets,var_weights,iy,nar)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global vx fold options_
global vx fold options_
oo_.gamma_y = cell(nar+1,1);
oo_.gamma_y = cell(nar+1,1);
% M_.Sigma_e = M_.Sigma_e'*M_.Sigma_e;
M_.Sigma_e=diag(M_.Sigma_e);
nx = size(ghx,2);
b=ghu1*M_.Sigma_e*ghu1';
vx = [];
if isempty(vx)
M_.Sigma_e=diag(M_.Sigma_e);
nx = size(ghx,2);
b=ghu1*M_.Sigma_e*ghu1';
vx = [];
if isempty(vx)
vx = lyapunov_symm(A,b,options_.qz_criterium,options_.lyapunov_complex_threshold);
else
else
[vx,status] = bicgstab_(@f_var,b(:),vx(:),1e-8,50,A,nx);
if status
vx = lyapunov_symm(A,b,options_.qz_criterium,options_.lyapunov_complex_threshold);
else
vx=reshape(vx,nx,nx);
end
end
oo_.gamma_y{1} = ghx*vx*ghx'+ ghu*M_.Sigma_e*ghu';
f = 0;
if ~isempty(targets{1})
end
oo_.gamma_y{1} = ghx*vx*ghx'+ ghu*M_.Sigma_e*ghu';
f = 0;
if ~isempty(targets{1})
e = targets{1}-sqrt(oo_.gamma_y{1}(iy{1}));
f = e'*(var_weights{1}.*e);
end
end
sy = sqrt(diag(oo_.gamma_y{1}));
sy = sy *sy';
if ~isempty(targets{2})
sy = sqrt(diag(oo_.gamma_y{1}));
sy = sy *sy';
if ~isempty(targets{2})
e = targets{2}-oo_.gamma_y{1}(iy{2})./(sy(iy{2})+1e-10);
f = f+e'*(var_weights{2}.*e);
end
end
if ~isempty(targets{3})
if ~isempty(targets{3})
e = targets{3}-sqrt(M_.Sigma_e(iy{3}));
f = f+e'*(var_weights{3}.*e);
end
end
% autocorrelations
if nar > 0
% autocorrelations
if nar > 0
vxy = (A*vx*ghx'+ghu1*M_.Sigma_e*ghu');
oo_.gamma_y{2} = ghx*vxy./(sy+1e-10);
@ -74,12 +74,11 @@ function f=calib_obj(M_.Sigma_e,A,ghu1,ghx,ghu,targets,var_weights,iy,nar)
f = f+e'*(var_weights{i+3}.*e);
end
end
end
if isempty(fold) | f < 2*fold
end
if isempty(fold) | f < 2*fold
fold = f;
vxold = vx;
end
% 11/04/02 MJ generalized for correlations, autocorrelations and
% constraints on M_.Sigma_e
% 01/25/03 MJ targets std. dev. instead of variances
end
% 11/04/02 MJ generalized for correlations, autocorrelations and
% constraints on M_.Sigma_e
% 01/25/03 MJ targets std. dev. instead of variances

42
matlab/calib_obj2.m
View File

@ -19,31 +19,31 @@ function objective=calib_obj2(M_.Sigma_e,A,ghu1,ghx,ghu,targets,var_weights,iy,n
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global vx fold options_
global vx fold options_
objective = cell (nar+3);
oo_.gamma_y = cell(nar+1,1);
M_.Sigma_e=diag(M_.Sigma_e);
nx = size(ghx,2);
b=ghu1*M_.Sigma_e*ghu1';
vx = lyapunov_symm(A,b,options_.qz_criterium,options_.lyapunov_complex_threshold);
oo_.gamma_y{1} = ghx*vx*ghx'+ ghu*M_.Sigma_e*ghu';
if ~isempty(targets{1})
objective = cell (nar+3);
oo_.gamma_y = cell(nar+1,1);
M_.Sigma_e=diag(M_.Sigma_e);
nx = size(ghx,2);
b=ghu1*M_.Sigma_e*ghu1';
vx = lyapunov_symm(A,b,options_.qz_criterium,options_.lyapunov_complex_threshold);
oo_.gamma_y{1} = ghx*vx*ghx'+ ghu*M_.Sigma_e*ghu';
if ~isempty(targets{1})
objective{1} = sqrt(oo_.gamma_y{1}(iy{1}));
end
end
sy = sqrt(diag(oo_.gamma_y{1}));
sy = sy *sy';
if ~isempty(targets{2})
sy = sqrt(diag(oo_.gamma_y{1}));
sy = sy *sy';
if ~isempty(targets{2})
objective{2} = oo_.gamma_y{1}(iy{2})./(sy(iy{2})+1e-10);
end
end
if ~isempty(targets{3})
if ~isempty(targets{3})
objective{3} = M_.Sigma_e(iy{3});
end
end
% autocorrelations
if nar > 0
% autocorrelations
if nar > 0
vxy = (A*vx*ghx'+ghu1*M_.Sigma_e*ghu');
oo_.gamma_y{2} = ghx*vxy./(sy+1e-10);
@ -58,7 +58,7 @@ function objective=calib_obj2(M_.Sigma_e,A,ghu1,ghx,ghu,targets,var_weights,iy,n
objecitve{i+3} = oo_.gamma_y{i+1}(iy{i+3});
end
end
end
end
% 11/04/02 MJ generalized for correlations, autocorrelations and
% constraints on M_.Sigma_e
% 11/04/02 MJ generalized for correlations, autocorrelations and
% constraints on M_.Sigma_e

54
matlab/check.m
View File

@ -30,34 +30,34 @@ function result = check
global M_ options_ oo_
if options_.block || options_.bytecode
if options_.block || options_.bytecode
error('CHECK: incompatibility with "block" or "bytecode" option')
end
end
temp_options = options_;
tempex = oo_.exo_simul;
if ~options_.initval_file & M_.exo_nbr > 1
temp_options = options_;
tempex = oo_.exo_simul;
if ~options_.initval_file & M_.exo_nbr > 1
oo_.exo_simul = ones(M_.maximum_lead+M_.maximum_lag+1,1)*oo_.exo_steady_state';
end
end
options_.order = 1;
options_.order = 1;
[dr, info] = resol(oo_.steady_state,1);
[dr, info] = resol(oo_.steady_state,1);
oo_.dr = dr;
oo_.dr = dr;
if info(1) ~= 0 & info(1) ~= 3 & info(1) ~= 4
if info(1) ~= 0 & info(1) ~= 3 & info(1) ~= 4
print_info(info, options_.noprint);
end
end
oo_.exo_simul = tempex;
oo_.exo_simul = tempex;
eigenvalues_ = dr.eigval;
nyf = nnz(dr.kstate(:,2)>M_.maximum_endo_lag+1);
[m_lambda,i]=sort(abs(eigenvalues_));
n_explod = nnz(abs(eigenvalues_) > options_.qz_criterium);
eigenvalues_ = dr.eigval;
nyf = nnz(dr.kstate(:,2)>M_.maximum_endo_lag+1);
[m_lambda,i]=sort(abs(eigenvalues_));
n_explod = nnz(abs(eigenvalues_) > options_.qz_criterium);
if options_.noprint == 0
if options_.noprint == 0
disp(' ')
disp('EIGENVALUES:')
disp(sprintf('%16s %16s %16s\n','Modulus','Real','Imaginary'))
@ -74,18 +74,18 @@ global M_ options_ oo_
disp('The rank conditions ISN''T verified!')
end
disp(' ')
end
end
options_ = temp_options;
options_ = temp_options;
% 2/9/99 MJ: line 15, added test for absence of exogenous variable.
% 8/27/2000 MJ: change JACOB call. Added ...,1 to cumsum()
% 6/24/01 MJ: added count of abs(eigenvalues) > 1
% 2/21/02 MJ: count eigenvalues > 1[+1e-5]
% 01/22/03 MJ: warning(warning_state) needs parentheses for Matlab 6.5
% name conflicts with parameters
% 05/21/03 MJ: replace computation by dr1.m and add rank check
% 06/05/03 MJ: corrected bug when M_.maximum_lag > 0
% 2/9/99 MJ: line 15, added test for absence of exogenous variable.
% 8/27/2000 MJ: change JACOB call. Added ...,1 to cumsum()
% 6/24/01 MJ: added count of abs(eigenvalues) > 1
% 2/21/02 MJ: count eigenvalues > 1[+1e-5]
% 01/22/03 MJ: warning(warning_state) needs parentheses for Matlab 6.5
% name conflicts with parameters
% 05/21/03 MJ: replace computation by dr1.m and add rank check
% 06/05/03 MJ: corrected bug when M_.maximum_lag > 0

24
matlab/check_list_of_variables.m
View File

@ -31,8 +31,8 @@ function varlist = check_list_of_variables(options_, M_, varlist)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
msg = 0;
if options_.bvar_dsge && options_.bayesian_irf
msg = 0;
if options_.bvar_dsge && options_.bayesian_irf
if ~isempty(varlist)
for i=1:size(varlist,1)
idx = strmatch(deblank(varlist(i,:)),options_.varobs,'exact');
@ -52,9 +52,9 @@ function varlist = check_list_of_variables(options_, M_, varlist)
end
varlist = options_.varobs;
return
end
end
if isempty(varlist)
if isempty(varlist)
disp(' ')
disp(['You did not declare endogenous variables after the estimation command.'])
cas = [];
@ -131,14 +131,14 @@ function varlist = check_list_of_variables(options_, M_, varlist)
edit([M_.fname '.mod'])
end
disp('')
end
end
function format_text(remain, max_number_of_words_per_line)
index = 0;
line_of_text = [];
while ~isempty(remain)
function format_text(remain, max_number_of_words_per_line)
index = 0;
line_of_text = [];
while ~isempty(remain)
[token, remain] = strtok(remain);
index = index+1;
if isempty(line_of_text)
@ -151,7 +151,7 @@ function varlist = check_list_of_variables(options_, M_, varlist)
index = 0;
line_of_text = [];
end
end
if index<max_number_of_words_per_line
end
if index<max_number_of_words_per_line
disp(line_of_text)
end
end

6
matlab/check_model.m
View File

@ -17,10 +17,10 @@ function check_model()
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_
global M_
xlen = M_.maximum_exo_lag+M_.maximum_exo_lead + 1;
if ~ M_.lead_lag_incidence(M_.maximum_lag+1,:) > 0
xlen = M_.maximum_exo_lag+M_.maximum_exo_lead + 1;
if ~ M_.lead_lag_incidence(M_.maximum_lag+1,:) > 0
error ('RESOL: Error in model specification: some variables don"t appear as current') ;
end

2
matlab/check_name.m
View File

@ -17,4 +17,4 @@ function n = check_name(vartan,varname)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
n = strmatch(varname,vartan,'exact');
n = strmatch(varname,vartan,'exact');

40
matlab/check_posterior_analysis_data.m
View File

@ -17,28 +17,28 @@ function [info,description] = check_posterior_analysis_data(type,M_)
% 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 nargout>1
info = 0;
if nargout>1
description = '';
end
end
%% Get informations about mcmc files.
if ~exist([ M_.dname '/metropolis'],'dir')
%% Get informations about mcmc files.
if ~exist([ M_.dname '/metropolis'],'dir')
disp('check_posterior_analysis_data:: Can''t find any mcmc file!')
return
end
mhname = get_name_of_the_last_mh_file(M_);
mhdate = get_date_of_a_file(mhname);
end
mhname = get_name_of_the_last_mh_file(M_);
mhdate = get_date_of_a_file(mhname);
%% Get informations about _posterior_draws files.
drawsinfo = dir([ M_.dname '/metropolis/' M_.fname '_posterior_draws*.mat']);
if isempty(drawsinfo)
%% Get informations about _posterior_draws files.
drawsinfo = dir([ M_.dname '/metropolis/' M_.fname '_posterior_draws*.mat']);
if isempty(drawsinfo)
info = 1; % select_posterior_draws has to be called first.
if nargout>1
description = 'select_posterior_draws has to be called.';
end
return
else
else
number_of_last_posterior_draws_file = length(drawsinfo);
pddate = get_date_of_a_file([ M_.dname '/metropolis/' M_.fname '_posterior_draws'...
int2str(number_of_last_posterior_draws_file) '.mat']);
@ -54,10 +54,10 @@ function [info,description] = check_posterior_analysis_data(type,M_)
description = 'posterior draws files are up to date.';
end
end
end
end
%% Get informations about posterior data files.
switch type
%% Get informations about posterior data files.
switch type
case 'variance'
generic_post_data_file_name = 'Posterior2ndOrderMoments';
case 'decomposition'
@ -68,15 +68,15 @@ function [info,description] = check_posterior_analysis_data(type,M_)
generic_post_data_file_name = 'PosteriorConditionalVarianceDecomposition';
otherwise
disp('This feature is not yest implemented!')
end
pdfinfo = dir([ M_.dname '/metropolis/' M_.fname '_' generic_post_data_file_name '*']);
if isempty(pdfinfo)
end
pdfinfo = dir([ M_.dname '/metropolis/' M_.fname '_' generic_post_data_file_name '*']);
if isempty(pdfinfo)
info = 4; % posterior draws have to be processed.
if nargout>1
description = 'posterior draws files have to be processed.';
end
return
else
else
number_of_the_last_post_data_file = length(pdfinfo);
name_of_the_last_post_data_file = ...
[ './' M_.dname ...
@ -97,4 +97,4 @@ function [info,description] = check_posterior_analysis_data(type,M_)
description = 'There is nothing to do';
end
end
end
end

42
matlab/check_prior_analysis_data.m
View File

@ -16,29 +16,29 @@ function [info,description] = check_prior_analysis_data(type,M_)
% 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 nargout>1
info = 0;
if nargout>1
description = '';
end
end
%% Get informations about prior draws files.
if ~exist([ M_.dname '/prior/draws'],'dir')
%% Get informations about prior draws files.
if ~exist([ M_.dname '/prior/draws'],'dir')
disp('check_prior_analysis_data:: Can''t find any prior draws file!')
return
end
end
prior_draws_info = dir([ M_.dname '/prior/draws/prior_draws*.mat']);
name_of_the_last_prior_draw_file = prior_draws_info(end).name;
date_of_the_last_prior_draw_file = prior_draws_info(end).datenum;
prior_draws_info = dir([ M_.dname '/prior/draws/prior_draws*.mat']);
name_of_the_last_prior_draw_file = prior_draws_info(end).name;
date_of_the_last_prior_draw_file = prior_draws_info(end).datenum;
%% Get informations about _posterior_draws files.
if isempty(prior_draws_info)
%% Get informations about _posterior_draws files.
if isempty(prior_draws_info)
info = 1;
if nargout>1
description = 'prior_sampler has to be called.';
end
return
else
else
number_of_last_prior_draws_file = length(prior_draws_info);
date_of_the_prior_definition = get_date_of_a_file([ M_.dname '/prior/definition.mat']);
if date_of_the_prior_definition>date_of_the_last_prior_draw_file
@ -53,10 +53,10 @@ function [info,description] = check_prior_analysis_data(type,M_)
description = 'prior draws files are up to date.';
end
end
end
end
%% Get informations about prior data files.
switch type
%% Get informations about prior data files.
switch type
case 'variance'
generic_prior_data_file_name = 'Prior2ndOrderMoments';
case 'decomposition'
@ -67,16 +67,16 @@ function [info,description] = check_prior_analysis_data(type,M_)
generic_prior_data_file_name = 'PriorConditionalVarianceDecomposition';
otherwise
disp(['This feature is not yet implemented!'])
end
CheckPath('prior/moments');
pdfinfo = dir([ M_.dname '/prior/' generic_prior_data_file_name '*']);
if isempty(pdfinfo)
end
CheckPath('prior/moments');
pdfinfo = dir([ M_.dname '/prior/' generic_prior_data_file_name '*']);
if isempty(pdfinfo)
info = 4;
if nargout>1
description = 'prior draws files have to be processed.';
end
return
else
else
number_of_the_last_prior_data_file = length(pdfinfo);
name_of_the_last_prior_data_file = pdinfo(end).name;
pdfdate = pdinfo(end).datenum;
@ -95,4 +95,4 @@ function [info,description] = check_prior_analysis_data(type,M_)
description = 'prior data files are up to date.';
end
end
end
end

2
matlab/compute_model_moments.m
View File

@ -28,4 +28,4 @@ function moments=compute_model_moments(dr,M_,options_)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
moments = th_autocovariances(dr,options_.varlist,M_,options_);
moments = th_autocovariances(dr,options_.varlist,M_,options_);

50
matlab/compute_moments_varendo.m
View File

@ -33,12 +33,12 @@ function oo_ = compute_moments_varendo(type,options_,M_,oo_,var_list_)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
if strcmpi(type,'posterior')
if strcmpi(type,'posterior')
posterior = 1;
if nargin==4
var_list_ = options_.varobs;
end
elseif strcmpi(type,'prior')
elseif strcmpi(type,'prior')
posterior = 0;
if nargin==4
var_list_ = options_.prior_analysis_endo_var_list;
@ -46,33 +46,33 @@ function oo_ = compute_moments_varendo(type,options_,M_,oo_,var_list_)
options_.prior_analysis_var_list = options_.varobs;
end
end
else
else
disp('compute_moments_varendo:: Unknown type!')
error()
end
end
NumberOfEndogenousVariables = rows(var_list_);
NumberOfExogenousVariables = M_.exo_nbr;
list_of_exogenous_variables = M_.exo_names;
NumberOfLags = options_.ar;
Steps = options_.conditional_variance_decomposition;
NumberOfEndogenousVariables = rows(var_list_);
NumberOfExogenousVariables = M_.exo_nbr;
list_of_exogenous_variables = M_.exo_names;
NumberOfLags = options_.ar;
Steps = options_.conditional_variance_decomposition;
% COVARIANCE MATRIX.
if posterior
% COVARIANCE MATRIX.
if posterior
for i=1:NumberOfEndogenousVariables
for j=i:NumberOfEndogenousVariables
oo_ = posterior_analysis('variance',var_list_(i,:),var_list_(j,:),[],options_,M_,oo_);
end
end
else
else
for i=1:NumberOfEndogenousVariables
for j=i:NumberOfEndogenousVariables
oo_ = prior_analysis('variance',var_list_(i,:),var_list_(j,:),[],options_,M_,oo_);
end
end
end
% CORRELATION FUNCTION.
if posterior
end
% CORRELATION FUNCTION.
if posterior
for h=NumberOfLags:-1:1
for i=1:NumberOfEndogenousVariables
for j=1:NumberOfEndogenousVariables
@ -80,7 +80,7 @@ function oo_ = compute_moments_varendo(type,options_,M_,oo_,var_list_)
end
end
end
else
else
for h=NumberOfLags:-1:1
for i=1:NumberOfEndogenousVariables
for j=1:NumberOfEndogenousVariables
@ -88,32 +88,32 @@ function oo_ = compute_moments_varendo(type,options_,M_,oo_,var_list_)
end
end
end
end
% VARIANCE DECOMPOSITION.
if posterior
end
% VARIANCE DECOMPOSITION.
if posterior
for i=1:NumberOfEndogenousVariables
for j=1:NumberOfExogenousVariables
oo_ = posterior_analysis('decomposition',var_list_(i,:),M_.exo_names(j,:),[],options_,M_,oo_);
end
end
else
else
for i=1:NumberOfEndogenousVariables
for j=1:NumberOfExogenousVariables
oo_ = prior_analysis('decomposition',var_list_(i,:),M_.exo_names(j,:),[],options_,M_,oo_);
end
end
end
% CONDITIONAL VARIANCE DECOMPOSITION.
if posterior
end
% CONDITIONAL VARIANCE DECOMPOSITION.
if posterior
for i=1:NumberOfEndogenousVariables
for j=1:NumberOfExogenousVariables
oo_ = posterior_analysis('conditional decomposition',var_list_(i,:),M_.exo_names(j,:),Steps,options_,M_,oo_);
end
end
else
else
for i=1:NumberOfEndogenousVariables
for j=1:NumberOfExogenousVariables
oo_ = prior_analysis('conditional decomposition',var_list_(i,:),M_.exo_names(j,:),Steps,options_,M_,oo_);
end
end
end
end

32
matlab/conditional_variance_decomposition.m
View File

@ -31,26 +31,26 @@ function PackedConditionalVarianceDecomposition = conditional_variance_decomposi
%
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
number_of_state_innovations = ...
number_of_state_innovations = ...
StateSpaceModel.number_of_state_innovations;
transition_matrix = StateSpaceModel.transition_matrix;
number_of_state_equations = ...
transition_matrix = StateSpaceModel.transition_matrix;
number_of_state_equations = ...
StateSpaceModel.number_of_state_equations;
nSteps = length(Steps);
nSteps = length(Steps);
ConditionalVariance = zeros(number_of_state_equations,number_of_state_equations);
ConditionalVariance = repmat(ConditionalVariance,[1 1 nSteps ...
ConditionalVariance = zeros(number_of_state_equations,number_of_state_equations);
ConditionalVariance = repmat(ConditionalVariance,[1 1 nSteps ...
number_of_state_innovations]);
if StateSpaceModel.sigma_e_is_diagonal
if StateSpaceModel.sigma_e_is_diagonal
B = StateSpaceModel.impulse_matrix.* ...
repmat(sqrt(diag(StateSpaceModel.state_innovations_covariance_matrix)'),...
number_of_state_equations,1);
else
else
B = StateSpaceModel.impulse_matrix*chol(StateSpaceModel.state_innovations_covariance_matrix)';
end
end
for i=1:number_of_state_innovations
for i=1:number_of_state_innovations
BB = B(:,i)*B(:,i)';
V = zeros(number_of_state_equations,number_of_state_equations);
m = 1;
@ -61,13 +61,13 @@ function PackedConditionalVarianceDecomposition = conditional_variance_decomposi
m = m+1;
end
end
end
end
ConditionalVariance = ConditionalVariance(SubsetOfVariables,SubsetOfVariables,:,:);
NumberOfVariables = length(SubsetOfVariables);
PackedConditionalVarianceDecomposition = zeros(NumberOfVariables*(NumberOfVariables+1)/2,length(Steps),StateSpaceModel.number_of_state_innovations);
for i=1:number_of_state_innovations
ConditionalVariance = ConditionalVariance(SubsetOfVariables,SubsetOfVariables,:,:);
NumberOfVariables = length(SubsetOfVariables);
PackedConditionalVarianceDecomposition = zeros(NumberOfVariables*(NumberOfVariables+1)/2,length(Steps),StateSpaceModel.number_of_state_innovations);
for i=1:number_of_state_innovations
for h = 1:length(Steps)
PackedConditionalVarianceDecomposition(:,h,i) = vech(ConditionalVariance(:,:,h,i));
end
end
end

68
matlab/conditional_variance_decomposition_mc_analysis.m
View File

@ -19,28 +19,28 @@ function oo_ = conditional_variance_decomposition_mc_analysis(NumberOfSimulation
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
if strcmpi(type,'posterior')
if strcmpi(type,'posterior')
TYPE = 'Posterior';
PATH = [dname '/metropolis/'];
else
else
TYPE = 'Prior';
PATH = [dname '/prior/moments/'];
end
end
indx = check_name(vartan,var);
if isempty(indx)
indx = check_name(vartan,var);
if isempty(indx)
disp([ type '_analysis:: ' var ' is not a stationary endogenous variable!'])
return
end
endogenous_variable_index = sum(1:indx);
exogenous_variable_index = check_name(exonames,exo);
if isempty(exogenous_variable_index)
end
endogenous_variable_index = sum(1:indx);
exogenous_variable_index = check_name(exonames,exo);
if isempty(exogenous_variable_index)
disp([ type '_analysis:: ' exo ' is not a declared exogenous variable!'])
return
end
end
name = [ var '.' exo ];
if isfield(oo_, [ TYPE 'TheoreticalMoments' ])
name = [ var '.' exo ];
if isfield(oo_, [ TYPE 'TheoreticalMoments' ])
eval(['temporary_structure = oo_.' TYPE 'TheoreticalMoments;'])
if isfield(temporary_structure,'dsge')
eval(['temporary_structure = oo_.' TYPE 'TheoreticalMoments.dsge;'])
@ -54,27 +54,27 @@ function oo_ = conditional_variance_decomposition_mc_analysis(NumberOfSimulation
end
end
end
end
end
ListOfFiles = dir([ PATH fname '_' TYPE 'ConditionalVarianceDecomposition*.mat']);
i1 = 1; tmp = zeros(NumberOfSimulations,length(Steps));
for file = 1:length(ListOfFiles)
ListOfFiles = dir([ PATH fname '_' TYPE 'ConditionalVarianceDecomposition*.mat']);
i1 = 1; tmp = zeros(NumberOfSimulations,length(Steps));
for file = 1:length(ListOfFiles)
load([ PATH ListOfFiles(file).name ]);
% 4D-array (endovar,time,exovar,simul)
i2 = i1 + size(Conditional_decomposition_array,4) - 1;
tmp(i1:i2,:) = transpose(dynare_squeeze(Conditional_decomposition_array(endogenous_variable_index,:,exogenous_variable_index,:)));
i1 = i2+1;
end
end
p_mean = NaN(2,length(Steps));
p_mean(1,:) = Steps;
p_median = NaN(1,length(Steps));
p_variance = NaN(1,length(Steps));
p_deciles = NaN(9,length(Steps));
p_density = NaN(2^9,2,length(Steps));
p_hpdinf = NaN(1,length(Steps));
p_hpdsup = NaN(1,length(Steps));
for i=1:length(Steps)
p_mean = NaN(2,length(Steps));
p_mean(1,:) = Steps;
p_median = NaN(1,length(Steps));
p_variance = NaN(1,length(Steps));
p_deciles = NaN(9,length(Steps));
p_density = NaN(2^9,2,length(Steps));
p_hpdinf = NaN(1,length(Steps));
p_hpdsup = NaN(1,length(Steps));
for i=1:length(Steps)
if ~isconst(tmp(:,i))
[pp_mean, pp_median, pp_var, hpd_interval, pp_deciles, pp_density] = ...
posterior_moments(tmp(:,i),1,mh_conf_sig);
@ -86,11 +86,11 @@ function oo_ = conditional_variance_decomposition_mc_analysis(NumberOfSimulation
p_hpdinf(i) = hpd_interval(2);
p_density(:,:,i) = pp_density;
end
end
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.ConditionalVarianceDecomposition.mean.' name ' = p_mean;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.ConditionalVarianceDecomposition.median.' name ' = p_median;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.ConditionalVarianceDecomposition.variance.' name ' = p_variance;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.ConditionalVarianceDecomposition.hpdinf.' name ' = p_hpdinf;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.ConditionalVarianceDecomposition.hpdsup.' name ' = p_hpdsup;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.ConditionalVarianceDecomposition.deciles.' name ' = p_deciles;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.ConditionalVarianceDecomposition.density.' name ' = p_density;']);
end
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.ConditionalVarianceDecomposition.mean.' name ' = p_mean;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.ConditionalVarianceDecomposition.median.' name ' = p_median;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.ConditionalVarianceDecomposition.variance.' name ' = p_variance;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.ConditionalVarianceDecomposition.hpdinf.' name ' = p_hpdinf;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.ConditionalVarianceDecomposition.hpdsup.' name ' = p_hpdsup;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.ConditionalVarianceDecomposition.deciles.' name ' = p_deciles;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.ConditionalVarianceDecomposition.density.' name ' = p_density;']);

66
matlab/correlation_mc_analysis.m
View File

@ -19,31 +19,31 @@ function oo_ = correlation_mc_analysis(SampleSize,type,dname,fname,vartan,nvar,v
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
if strcmpi(type,'posterior')
if strcmpi(type,'posterior')
TYPE = 'Posterior';
PATH = [dname '/metropolis/'];
else
else
TYPE = 'Prior';
PATH = [dname '/prior/moments/'];
end
end
indx1 = check_name(vartan,var1);
if isempty(indx1)
indx1 = check_name(vartan,var1);
if isempty(indx1)
disp([ type '_analysis:: ' var1 ' is not a stationary endogenous variable!'])
return
end
if ~isempty(var2)
end
if ~isempty(var2)
indx2 = check_name(vartan,var2);
if isempty(indx2)
disp([ type '_analysis:: ' var2 ' is not a stationary endogenous variable!'])
return
end
else
else
indx2 = indx1;
var2 = var1;
end
end
if isfield(oo_,[TYPE 'TheoreticalMoments'])
if isfield(oo_,[TYPE 'TheoreticalMoments'])
eval(['temporary_structure = oo_.' TYPE 'TheoreticalMoments;'])
if isfield(temporary_structure,'dsge')
eval(['temporary_structure = oo_.' TYPE 'TheoreticalMoments.dsge;'])
@ -78,19 +78,19 @@ function oo_ = correlation_mc_analysis(SampleSize,type,dname,fname,vartan,nvar,v
else
oo_ = initialize_output_structure(var1,var2,nar,TYPE,oo_);
end
else
else
oo_ = initialize_output_structure(var1,var2,nar,TYPE,oo_);
end
ListOfFiles = dir([ PATH fname '_' TYPE 'Correlations*.mat']);
i1 = 1; tmp = zeros(SampleSize,1);
for file = 1:length(ListOfFiles)
end
ListOfFiles = dir([ PATH fname '_' TYPE 'Correlations*.mat']);
i1 = 1; tmp = zeros(SampleSize,1);
for file = 1:length(ListOfFiles)
load([ PATH ListOfFiles(file).name ]);
i2 = i1 + rows(Correlation_array) - 1;
tmp(i1:i2) = Correlation_array(:,indx1,indx2,nar);
i1 = i2+1;
end
name = [ var1 '.' var2 ];
if ~isconst(tmp)
end
name = [ var1 '.' var2 ];
if ~isconst(tmp)
[p_mean, p_median, p_var, hpd_interval, p_deciles, density] = ...
posterior_moments(tmp,1,mh_conf_sig);
if isfield(oo_,[ TYPE 'TheoreticalMoments'])
@ -108,7 +108,7 @@ function oo_ = correlation_mc_analysis(SampleSize,type,dname,fname,vartan,nvar,v
end
end
end
else
else
if isfield(oo_,'PosteriorTheoreticalMoments')
eval(['temporary_structure = oo_.' TYPE 'TheoreticalMoments;'])
if isfield(temporary_structure,'dsge')
@ -124,29 +124,29 @@ function oo_ = correlation_mc_analysis(SampleSize,type,dname,fname,vartan,nvar,v
end
end
end
end
end
function oo_ = initialize_output_structure(var1,var2,nar,type,oo_)
name = [ var1 '.' var2 ];
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.mean.' name ' = NaN(' int2str(nar) ',1);']);
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.median.' name ' = NaN(' int2str(nar) ',1);']);
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.variance.' name ' = NaN(' int2str(nar) ',1);']);
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.hpdinf.' name ' = NaN(' int2str(nar) ',1);']);
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.hpdsup.' name ' = NaN(' int2str(nar) ',1);']);
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.deciles.' name ' = cell(' int2str(nar) ',1);']);
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.density.' name ' = cell(' int2str(nar) ',1);']);
for i=1:nar
name = [ var1 '.' var2 ];
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.mean.' name ' = NaN(' int2str(nar) ',1);']);
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.median.' name ' = NaN(' int2str(nar) ',1);']);
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.variance.' name ' = NaN(' int2str(nar) ',1);']);
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.hpdinf.' name ' = NaN(' int2str(nar) ',1);']);
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.hpdsup.' name ' = NaN(' int2str(nar) ',1);']);
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.deciles.' name ' = cell(' int2str(nar) ',1);']);
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.density.' name ' = cell(' int2str(nar) ',1);']);
for i=1:nar
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.density.' name '(' int2str(i) ',1) = {NaN};']);
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.deciles.' name '(' int2str(i) ',1) = {NaN};']);
end
end
function oo_ = fill_output_structure(var1,var2,type,oo_,moment,lag,result)
name = [ var1 '.' var2 ];
switch moment
name = [ var1 '.' var2 ];
switch moment
case {'mean','median','variance','hpdinf','hpdsup'}
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.' moment '.' name '(' int2str(lag) ',1) = result;']);
case {'deciles','density'}
eval(['oo_.' type 'TheoreticalMoments.dsge.correlation.' moment '.' name '(' int2str(lag) ',1) = {result};']);
otherwise
disp('fill_output_structure:: Unknown field!')
end
end

38
matlab/covariance_mc_analysis.m
View File

@ -19,31 +19,31 @@ function oo_ = covariance_mc_analysis(NumberOfSimulations,type,dname,fname,varta
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
if strcmpi(type,'posterior')
if strcmpi(type,'posterior')
TYPE = 'Posterior';
PATH = [dname '/metropolis/'];
else
else
TYPE = 'Prior';
PATH = [dname '/prior/moments/'];
end
end
indx1 = check_name(vartan,var1);
if isempty(indx1)
indx1 = check_name(vartan,var1);
if isempty(indx1)
disp([ type '_analysis:: ' var1 ' is not a stationary endogenous variable!'])
return
end
if ~isempty(var2)
end
if ~isempty(var2)
indx2 = check_name(vartan,var2);
if isempty(indx2)
disp([ type '_analysis:: ' var2 ' is not a stationary endogenous variable!'])
return
end
else
else
indx2 = indx1;
var2 = var1;
end
end
if isfield(oo_,[ TYPE 'TheoreticalMoments'])
if isfield(oo_,[ TYPE 'TheoreticalMoments'])
eval(['temporary_structure = oo_.' TYPE 'TheoreticalMoments;'])
if isfield(temporary_structure,'dsge')
eval(['temporary_structure = oo_.' TYPE 'TheoreticalMoments.dsge;'])
@ -66,18 +66,18 @@ function oo_ = covariance_mc_analysis(NumberOfSimulations,type,dname,fname,varta
end
end
end
end
end
ListOfFiles = dir([ PATH fname '_' TYPE '2ndOrderMoments*.mat']);
i1 = 1; tmp = zeros(NumberOfSimulations,1);
for file = 1:length(ListOfFiles)
ListOfFiles = dir([ PATH fname '_' TYPE '2ndOrderMoments*.mat']);
i1 = 1; tmp = zeros(NumberOfSimulations,1);
for file = 1:length(ListOfFiles)
load([ PATH ListOfFiles(file).name ]);
i2 = i1 + rows(Covariance_matrix) - 1;
tmp(i1:i2) = Covariance_matrix(:,symmetric_matrix_index(indx1,indx2,nvar));
i1 = i2+1;
end
name = [var1 '.' var2];
if ~isconst(tmp)
end
name = [var1 '.' var2];
if ~isconst(tmp)
[p_mean, p_median, p_var, hpd_interval, p_deciles, density] = ...
posterior_moments(tmp,1,mh_conf_sig);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.covariance.mean.' name ' = p_mean;']);
@ -87,7 +87,7 @@ function oo_ = covariance_mc_analysis(NumberOfSimulations,type,dname,fname,varta
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.covariance.hpdsup.' name ' = hpd_interval(2);']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.covariance.deciles.' name ' = p_deciles;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.covariance.density.' name ' = density;']);
else
else
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.covariance.mean.' name ' = NaN;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.covariance.median.' name ' = NaN;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.covariance.variance.' name ' = NaN;']);
@ -95,4 +95,4 @@ function oo_ = covariance_mc_analysis(NumberOfSimulations,type,dname,fname,varta
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.covariance.hpdsup.' name ' = NaN;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.covariance.deciles.' name ' = NaN;']);
eval(['oo_.' TYPE 'TheoreticalMoments.dsge.covariance.density.' name ' = NaN;']);
end
end

4
matlab/csminit.m
View File

@ -82,9 +82,9 @@ else
%d=max(1e-10,abs(diag(d)));
%d=abs(diag(d));
%dx = -(v.*(ones(size(v,1),1)*d'))*(v'*g);
% toc
% toc
dx = -H0*g;
% toc
% toc
dxnorm = norm(dx);
if dxnorm > 1e12
disp('Near-singular H problem.')

8
matlab/csolve.m
View File

@ -49,10 +49,10 @@ alpha=1e-3;
%---------------------------------------
%------------ verbose ----------------
verbose=0;% if this is set to zero, all screen output is suppressed
%-------------------------------------
%------------ analyticg --------------
%-------------------------------------
%------------ analyticg --------------
analyticg=1-isempty(gradfun); %if the grad argument is [], numerical derivatives are used.
%-------------------------------------
%-------------------------------------
nv=length(x);
tvec=delta*eye(nv);
done=0;
@ -65,7 +65,7 @@ af0=sum(abs(f0));
af00=af0;
itct=0;
while ~done
% disp([af00-af0 crit*max(1,af0)])
% disp([af00-af0 crit*max(1,af0)])
if itct>3 & af00-af0<crit*max(1,af0) & rem(itct,2)==1
randomize=1;
else

6
matlab/datatomfile.m
View File

@ -39,15 +39,15 @@ if size(var_list,1) == 0
var_list = M_.endo_names(1:M_.orig_endo_nbr,:);
end
n = size(var_list,1);
ivar=zeros(n,1);
for i=1:n
ivar=zeros(n,1);
for i=1:n
i_tmp = strmatch(var_list(i,:),M_.endo_names,'exact');
if isempty(i_tmp)
error (['One of the specified variables does not exist']) ;
else
ivar(i) = i_tmp;
end
end
end

8
matlab/diag_vech.m
View File

@ -25,7 +25,7 @@ function d = diag_vech(Vector)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
m = length(Vector);
n = (sqrt(1+8*m)-1)/2;
k = cumsum(1:n);
d = Vector(k);
m = length(Vector);
n = (sqrt(1+8*m)-1)/2;
k = cumsum(1:n);
d = Vector(k);

94
matlab/disp_dr.m
View File

@ -24,23 +24,23 @@ function disp_dr(dr,order,var_list)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_
global M_
nx =size(dr.ghx,2);
nu =size(dr.ghu,2);
k = find(dr.kstate(:,2) <= M_.maximum_lag+1);
klag = dr.kstate(k,[1 2]);
nx =size(dr.ghx,2);
nu =size(dr.ghu,2);
k = find(dr.kstate(:,2) <= M_.maximum_lag+1);
klag = dr.kstate(k,[1 2]);
k1 = dr.order_var;
k1 = dr.order_var;
if size(var_list,1) == 0
if size(var_list,1) == 0
var_list = M_.endo_names(1:M_.orig_endo_nbr, :);
end
end
nvar = size(var_list,1);
nvar = size(var_list,1);
ivar=zeros(nvar,1);
for i=1:nvar
ivar=zeros(nvar,1);
for i=1:nvar
i_tmp = strmatch(var_list(i,:),M_.endo_names(k1,:),'exact');
if isempty(i_tmp)
disp(var_list(i,:));
@ -48,21 +48,21 @@ function disp_dr(dr,order,var_list)
else
ivar(i) = i_tmp;
end
end
end
disp('POLICY AND TRANSITION FUNCTIONS')
% variable names
str = ' ';
for i=1:nvar
disp('POLICY AND TRANSITION FUNCTIONS')
% variable names
str = ' ';
for i=1:nvar
str = [str sprintf('%16s',M_.endo_names(k1(ivar(i)),:))];
end
disp(str);
%
% constant
%
str = 'Constant ';
flag = 0;
for i=1:nvar
end
disp(str);
%
% constant
%
str = 'Constant ';
flag = 0;
for i=1:nvar
x = dr.ys(k1(ivar(i)));
if order > 1
x = x + dr.ghs2(ivar(i))/2;
@ -73,11 +73,11 @@ function disp_dr(dr,order,var_list)
else
str = [str ' 0'];
end
end
if flag
end
if flag
disp(str)
end
if order > 1
end
if order > 1
str = '(correction) ';
flag = 0;
for i=1:nvar
@ -92,11 +92,11 @@ function disp_dr(dr,order,var_list)
if flag
disp(str)
end
end
%
% ghx
%
for k=1:nx
end
%
% ghx
%
for k=1:nx
flag = 0;
str1 = subst_auxvar(k1(klag(k,1)),klag(k,2)-M_.maximum_lag-2);
str = sprintf('%-20s',str1);
@ -112,11 +112,11 @@ function disp_dr(dr,order,var_list)
if flag
disp(str)
end
end
%
% ghu
%
for k=1:nu
end
%
% ghu
%
for k=1:nu
flag = 0;
str = sprintf('%-20s',M_.exo_names(k,:));
for i=1:nvar
@ -131,9 +131,9 @@ function disp_dr(dr,order,var_list)
if flag
disp(str)
end
end
end
if order > 1
if order > 1
% ghxx
for k = 1:nx
for j = 1:k
@ -207,7 +207,7 @@ function disp_dr(dr,order,var_list)
end
end
end
end
end
end
% Given the index of an endogenous (possibly an auxiliary var), and a
@ -215,13 +215,13 @@ end
% In the case of auxiliary vars for lags, replace by the original variable
% name, and compute the lead/lag accordingly.
function str = subst_auxvar(aux_index, aux_lead_lag)
global M_
global M_
if aux_index <= M_.orig_endo_nbr
if aux_index <= M_.orig_endo_nbr
str = sprintf('%s(%d)', deblank(M_.endo_names(aux_index,:)), aux_lead_lag);
return
end
for i = 1:length(M_.aux_vars)
end
for i = 1:length(M_.aux_vars)
if M_.aux_vars(i).endo_index == aux_index
switch M_.aux_vars(i).type
case 1
@ -234,6 +234,6 @@ function str = subst_auxvar(aux_index, aux_lead_lag)
str = sprintf('%s(%d)', orig_name, M_.aux_vars(i).orig_lead_lag+aux_lead_lag);
return
end
end
error(sprintf('Could not find aux var: %s', M_.endo_names(aux_index, :)))
end
error(sprintf('Could not find aux var: %s', M_.endo_names(aux_index, :)))
end

114
matlab/disp_dr_sparse.m
View File

@ -25,23 +25,23 @@ function disp_dr_sparse(dr,order,var_list)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_
nx = 0;
nu = 0;
k = [];
klag = [];
k1 = [];
nspred = 0;
for i=1:length(M_.block_structure.block)
global M_
nx = 0;
nu = 0;
k = [];
klag = [];
k1 = [];
nspred = 0;
for i=1:length(M_.block_structure.block)
nspred = nspred + M_.block_structure.block(i).dr.nspred;
end;
ghu = zeros(M_.endo_nbr, M_.exo_nbr*(M_.maximum_exo_lag+M_.maximum_exo_lead+1));
ghx = zeros(M_.endo_nbr, nspred);
for i=1:length(M_.block_structure.block)
end;
ghu = zeros(M_.endo_nbr, M_.exo_nbr*(M_.maximum_exo_lag+M_.maximum_exo_lead+1));
ghx = zeros(M_.endo_nbr, nspred);
for i=1:length(M_.block_structure.block)
nx = nx + size(M_.block_structure.block(i).dr.ghx,2);
% M_.block_structure.block(i).dr.ghx
% M_.block_structure.block(i).equation
% M_.block_structure.block(i).variable
% M_.block_structure.block(i).dr.ghx
% M_.block_structure.block(i).equation
% M_.block_structure.block(i).variable
ghx(M_.block_structure.block(i).equation, M_.block_structure.block(i).variable(find(M_.block_structure.block(i).lead_lag_incidence(1: M_.block_structure.block(i).maximum_endo_lag,:))) ) = M_.block_structure.block(i).dr.ghx;
if(M_.block_structure.block(i).exo_nbr)
nu = nu + size(M_.block_structure.block(i).dr.ghu,2);
@ -51,16 +51,16 @@ function disp_dr_sparse(dr,order,var_list)
k = [k ; k_tmp];
klag = [klag ; M_.block_structure.block(i).dr.kstate(k_tmp,[1 2])];
k1 = [k1 ; M_.block_structure.block(i).variable(M_.block_structure.block(i).dr.order_var)'];
end
end
if size(var_list,1) == 0
if size(var_list,1) == 0
var_list = M_.endo_names(1:M_.orig_endo_nbr, :);
end
end
nvar = size(var_list,1);
nvar = size(var_list,1);
ivar=zeros(nvar,1);
for i=1:nvar
ivar=zeros(nvar,1);
for i=1:nvar
i_tmp = strmatch(var_list(i,:),M_.endo_names(k1,:),'exact');
if isempty(i_tmp)
disp(var_list(i,:));
@ -68,21 +68,21 @@ function disp_dr_sparse(dr,order,var_list)
else
ivar(i) = i_tmp;
end
end
end
disp('POLICY AND TRANSITION FUNCTIONS')
% variable names
str = ' ';
for i=1:nvar
disp('POLICY AND TRANSITION FUNCTIONS')
% variable names
str = ' ';
for i=1:nvar
str = [str sprintf('%16s',M_.endo_names(k1(ivar(i)),:))];
end
disp(str);
%
% constant
%
str = 'Constant ';
flag = 0;
for i=1:nvar
end
disp(str);
%
% constant
%
str = 'Constant ';
flag = 0;
for i=1:nvar
x = dr.ys(k1(ivar(i)));
if order > 1
x = x + dr.ghs2(ivar(i))/2;
@ -93,11 +93,11 @@ function disp_dr_sparse(dr,order,var_list)
else
str = [str ' 0'];
end
end
if flag
end
if flag
disp(str)
end
if order > 1
end
if order > 1
str = '(correction) ';
flag = 0;
for i=1:nvar
@ -112,11 +112,11 @@ function disp_dr_sparse(dr,order,var_list)
if flag
disp(str)
end
end
%
% ghx
%
for k=1:nx
end
%
% ghx
%
for k=1:nx
flag = 0;
str1 = subst_auxvar(k1(klag(k,1)),klag(k,2)-M_.maximum_lag-2);
str = sprintf('%-20s',str1);
@ -132,11 +132,11 @@ function disp_dr_sparse(dr,order,var_list)
if flag
disp(str)
end
end
%
% ghu
%
for k=1:nu
end
%
% ghu
%
for k=1:nu
flag = 0;
str = sprintf('%-20s',M_.exo_names(k,:));
for i=1:nvar
@ -151,9 +151,9 @@ function disp_dr_sparse(dr,order,var_list)
if flag
disp(str)
end
end
end
if order > 1
if order > 1
% ghxx
for k = 1:nx
for j = 1:k
@ -227,7 +227,7 @@ function disp_dr_sparse(dr,order,var_list)
end
end
end
end
end
end
% Given the index of an endogenous (possibly an auxiliary var), and a
@ -235,13 +235,13 @@ end
% In the case of auxiliary vars for lags, replace by the original variable
% name, and compute the lead/lag accordingly.
function str = subst_auxvar(aux_index, aux_lead_lag)
global M_
global M_
if aux_index <= M_.orig_endo_nbr
if aux_index <= M_.orig_endo_nbr
str = sprintf('%s(%d)', deblank(M_.endo_names(aux_index,:)), aux_lead_lag);
return
end
for i = 1:length(M_.aux_vars)
end
for i = 1:length(M_.aux_vars)
if M_.aux_vars(i).endo_index == aux_index
switch M_.aux_vars(i).type
case 1
@ -254,6 +254,6 @@ function str = subst_auxvar(aux_index, aux_lead_lag)
str = sprintf('%s(%d)', orig_name, M_.aux_vars(i).orig_lead_lag+aux_lead_lag);
return
end
end
error(sprintf('Could not find aux var: %s', M_.endo_names(aux_index, :)))
end
error(sprintf('Could not find aux var: %s', M_.endo_names(aux_index, :)))
end

12
matlab/disp_identification.m
View File

@ -95,13 +95,13 @@ dyntable('Multi collinearity for moments in J:',strvcat('param','min','mean','ma
strvcat(bayestopt_.name(kokJ)),[mminJ, mmeanJ, mmaxJ],10,10,6);
if disp_pcorr,
for j=1:length(kokP),
dyntable([bayestopt_.name{kokP(j)},' pairwise correlations in the model'],strvcat(' ','min','mean','max'), ...
for j=1:length(kokP),
dyntable([bayestopt_.name{kokP(j)},' pairwise correlations in the model'],strvcat(' ','min','mean','max'), ...
strvcat(bayestopt_.name{jpM{j}}),[pminM{j}' pmeanM{j}' pmaxM{j}'],10,10,3);
end
end
for j=1:length(kokPJ),
dyntable([bayestopt_.name{kokPJ(j)},' pairwise correlations in J moments'],strvcat(' ','min','mean','max'), ...
for j=1:length(kokPJ),
dyntable([bayestopt_.name{kokPJ(j)},' pairwise correlations in J moments'],strvcat(' ','min','mean','max'), ...
strvcat(bayestopt_.name{jpJ{j}}),[pminJ{j}' pmeanJ{j}' pmaxJ{j}'],10,10,3);
end
end
end

26
matlab/disp_model_summary.m
View File

@ -24,19 +24,19 @@ function disp_model_summary(M,dr)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
disp(' ')
disp('MODEL SUMMARY')
disp(' ')
disp([' Number of variables: ' int2str(M.endo_nbr)])
disp([' Number of stochastic shocks: ' int2str(M.exo_nbr)])
disp([' Number of state variables: ' ...
disp(' ')
disp('MODEL SUMMARY')
disp(' ')
disp([' Number of variables: ' int2str(M.endo_nbr)])
disp([' Number of stochastic shocks: ' int2str(M.exo_nbr)])
disp([' Number of state variables: ' ...
int2str(length(find(dr.kstate(:,2) <= M.maximum_lag+1)))])
disp([' Number of jumpers: ' ...
disp([' Number of jumpers: ' ...
int2str(length(find(dr.kstate(:,2) == M.maximum_lag+2)))])
disp([' Number of static variables: ' int2str(dr.nstatic)])
my_title='MATRIX OF COVARIANCE OF EXOGENOUS SHOCKS';
labels = deblank(M.exo_names);
headers = strvcat('Variables',labels);
lh = size(labels,2)+2;
dyntable(my_title,headers,labels,M.Sigma_e,lh,10,6);
disp([' Number of static variables: ' int2str(dr.nstatic)])
my_title='MATRIX OF COVARIANCE OF EXOGENOUS SHOCKS';
labels = deblank(M.exo_names);
headers = strvcat('Variables',labels);
lh = size(labels,2)+2;
dyntable(my_title,headers,labels,M.Sigma_e,lh,10,6);

58
matlab/disp_moments.m
View File

@ -18,42 +18,42 @@ function disp_moments(y,var_list)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_ options_ oo_
global M_ options_ oo_
warning_old_state = warning;
warning off
warning_old_state = warning;
warning off
if options_.hp_filter
if options_.hp_filter
error('STOCH_SIMUL: HP filter is not yet implemented for empirical moments')
end
end
if size(var_list,1) == 0
if size(var_list,1) == 0
var_list = M_.endo_names(1:M_.orig_endo_nbr, :);
end
end
nvar = size(var_list,1);
ivar=zeros(nvar,1);
for i=1:nvar
nvar = size(var_list,1);
ivar=zeros(nvar,1);
for i=1:nvar
i_tmp = strmatch(var_list(i,:),M_.endo_names,'exact');
if isempty(i_tmp)
error (['One of the variable specified does not exist']) ;
else
ivar(i) = i_tmp;
end
end
end
y = y(ivar,options_.drop+M_.maximum_lag+1:end)';
y = y(ivar,options_.drop+M_.maximum_lag+1:end)';
m = mean(y);
y = y - repmat(m,size(y,1),1);
s2 = mean(y.*y);
s = sqrt(s2);
oo_.mean = transpose(m);
oo_.var = y'*y/size(y,1);
m = mean(y);
y = y - repmat(m,size(y,1),1);
s2 = mean(y.*y);
s = sqrt(s2);
oo_.mean = transpose(m);
oo_.var = y'*y/size(y,1);
labels = deblank(M_.endo_names(ivar,:));
labels = deblank(M_.endo_names(ivar,:));
if options_.nomoments == 0
if options_.nomoments == 0
z = [ m' s' s2' (mean(y.^3)./s2.^1.5)' (mean(y.^4)./(s2.*s2)-3)' ];
title='MOMENTS OF SIMULATED VARIABLES';
@ -64,9 +64,9 @@ function disp_moments(y,var_list)
headers=strvcat('VARIABLE','MEAN','STD. DEV.','VARIANCE','SKEWNESS', ...
'KURTOSIS');
dyntable(title,headers,labels,z,size(labels,2)+2,16,6);
end
end
if options_.nocorr == 0
if options_.nocorr == 0
corr = (y'*y/size(y,1))./(s'*s);
title = 'CORRELATION OF SIMULATED VARIABLES';
if options_.hp_filter
@ -75,12 +75,12 @@ function disp_moments(y,var_list)
end
headers = strvcat('VARIABLE',M_.endo_names(ivar,:));
dyntable(title,headers,labels,corr,size(labels,2)+2,8,4);
end
end
ar = options_.ar;
options_ = set_default_option(options_,'ar',5);
ar = options_.ar;
if ar > 0
ar = options_.ar;
options_ = set_default_option(options_,'ar',5);
ar = options_.ar;
if ar > 0
autocorr = [];
for i=1:ar
oo_.autocorr{i} = y(ar+1:end,:)'*y(ar+1-i:end-i,:)./((size(y,1)-ar)*s'*s);
@ -93,6 +93,6 @@ function disp_moments(y,var_list)
end
headers = strvcat('VARIABLE',int2str([1:ar]'));
dyntable(title,headers,labels,autocorr,size(labels,2)+2,8,4);
end
end
warning(warning_old_state);
warning(warning_old_state);

52
matlab/disp_th_moments.m
View File

@ -18,41 +18,41 @@ function disp_th_moments(dr,var_list)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_ oo_ options_
global M_ oo_ options_
if size(var_list,1) == 0
if size(var_list,1) == 0
var_list = M_.endo_names(1:M_.orig_endo_nbr, :);
end
nvar = size(var_list,1);
ivar=zeros(nvar,1);
for i=1:nvar
end
nvar = size(var_list,1);
ivar=zeros(nvar,1);
for i=1:nvar
i_tmp = strmatch(var_list(i,:),M_.endo_names,'exact');
if isempty(i_tmp)
error (['One of the variable specified does not exist']) ;
else
ivar(i) = i_tmp;
end
end
end
[oo_.gamma_y,stationary_vars] = th_autocovariances(dr,ivar,M_,options_);
m = dr.ys(ivar);
non_stationary_vars = setdiff(1:length(ivar),stationary_vars);
ivar1 = intersect(non_stationary_vars,ivar);
m(ivar1) = NaN;
[oo_.gamma_y,stationary_vars] = th_autocovariances(dr,ivar,M_,options_);
m = dr.ys(ivar);
non_stationary_vars = setdiff(1:length(ivar),stationary_vars);
ivar1 = intersect(non_stationary_vars,ivar);
m(ivar1) = NaN;
i1 = find(abs(diag(oo_.gamma_y{1})) > 1e-12);
s2 = diag(oo_.gamma_y{1});
sd = sqrt(s2);
if options_.order == 2
i1 = find(abs(diag(oo_.gamma_y{1})) > 1e-12);
s2 = diag(oo_.gamma_y{1});
sd = sqrt(s2);
if options_.order == 2
m = m+oo_.gamma_y{options_.ar+3};
end
end
z = [ m sd s2 ];
oo_.mean = m;
oo_.var = oo_.gamma_y{1};
z = [ m sd s2 ];
oo_.mean = m;
oo_.var = oo_.gamma_y{1};
if options_.nomoments == 0
if options_.nomoments == 0
title='THEORETICAL MOMENTS';
if options_.hp_filter
title = [title ' (HP filter, lambda = ' int2str(options_.hp_filter) ')'];
@ -82,9 +82,9 @@ function disp_th_moments(dr,var_list)
ivar,dr,M_, ...
options_,oo_);
end
end
end
if options_.nocorr == 0
if options_.nocorr == 0
disp(' ')
title='MATRIX OF CORRELATIONS';
if options_.hp_filter
@ -95,9 +95,9 @@ function disp_th_moments(dr,var_list)
corr = oo_.gamma_y{1}(i1,i1)./(sd(i1)*sd(i1)');
lh = size(labels,2)+2;
dyntable(title,headers,labels,corr,lh,8,4);
end
end
if options_.ar > 0
if options_.ar > 0
disp(' ')
title='COEFFICIENTS OF AUTOCORRELATION';
if options_.hp_filter
@ -112,4 +112,4 @@ function disp_th_moments(dr,var_list)
end
lh = size(labels,2)+2;
dyntable(title,headers,labels,z,lh,8,4);
end
end

32
matlab/display_conditional_variance_decomposition.m
View File

@ -33,28 +33,28 @@ function oo_ = display_conditional_variance_decomposition(Steps, SubsetOfVariabl
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
endo_nbr = M_.endo_nbr;
exo_nbr = M_.exo_nbr;
StateSpaceModel.number_of_state_equations = M_.endo_nbr;
StateSpaceModel.number_of_state_innovations = exo_nbr;
StateSpaceModel.sigma_e_is_diagonal = M_.sigma_e_is_diagonal;
endo_nbr = M_.endo_nbr;
exo_nbr = M_.exo_nbr;
StateSpaceModel.number_of_state_equations = M_.endo_nbr;
StateSpaceModel.number_of_state_innovations = exo_nbr;
StateSpaceModel.sigma_e_is_diagonal = M_.sigma_e_is_diagonal;
iv = (1:endo_nbr)';
ic = dr.nstatic+(1:dr.npred)';
iv = (1:endo_nbr)';
ic = dr.nstatic+(1:dr.npred)';
[StateSpaceModel.transition_matrix,StateSpaceModel.impulse_matrix] = kalman_transition_matrix(dr,iv,ic,[],exo_nbr);
StateSpaceModel.state_innovations_covariance_matrix = M_.Sigma_e;
[StateSpaceModel.transition_matrix,StateSpaceModel.impulse_matrix] = kalman_transition_matrix(dr,iv,ic,[],exo_nbr);
StateSpaceModel.state_innovations_covariance_matrix = M_.Sigma_e;
conditional_decomposition_array = conditional_variance_decomposition(StateSpaceModel,Steps,dr.inv_order_var(SubsetOfVariables ));
conditional_decomposition_array = conditional_variance_decomposition(StateSpaceModel,Steps,dr.inv_order_var(SubsetOfVariables ));
if options_.noprint == 0
if options_.noprint == 0
disp(' ')
disp('CONDITIONAL VARIANCE DECOMPOSITION (in percent)')
end
end
vardec_i = zeros(length(SubsetOfVariables),exo_nbr);
vardec_i = zeros(length(SubsetOfVariables),exo_nbr);
for i=1:length(Steps)
for i=1:length(Steps)
disp(['Period ' int2str(Steps(i)) ':'])
for j=1:exo_nbr
@ -71,6 +71,6 @@ function oo_ = display_conditional_variance_decomposition(Steps, SubsetOfVariabl
deblank(M_.endo_names(SubsetOfVariables,:)),...
vardec_i,lh,8,2);
end
end
end
oo_.conditional_variance_decomposition = conditional_decomposition_array;
oo_.conditional_variance_decomposition = conditional_decomposition_array;

6
matlab/distributions/compute_prior_mode.m
View File

@ -38,8 +38,8 @@ function m = compute_prior_mode(hyperparameters,shape)
%
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
m = NaN ;
switch shape
m = NaN ;
switch shape
case 1
if (hyperparameters(1)>1 && hyperparameters(2)>1)
m = (hyperparameters(1)-1)/(hyperparameters(1)+hyperparameters(2)-2) ;
@ -84,4 +84,4 @@ function m = compute_prior_mode(hyperparameters,shape)
end
otherwise
error('Unknown prior shape!')
end
end

32
matlab/distributions/mode_and_variance_to_mean.m
View File

@ -34,13 +34,13 @@ function [mu, parameters] = mode_and_variance_to_mean(m,s2,distribution,lower_bo
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
% Check input aruments.
if ~(nargin==3 || nargin==5 || nargin==4 )
% Check input aruments.
if ~(nargin==3 || nargin==5 || nargin==4 )
error('mode_and_variance_to mean:: 3 or 5 input arguments are needed!')
end
end
% Set defaults bounds.
if nargin==3
% Set defaults bounds.
if nargin==3
switch distribution
case 1
lower_bound = 0;
@ -57,8 +57,8 @@ function [mu, parameters] = mode_and_variance_to_mean(m,s2,distribution,lower_bo
otherwise
error('Unknown distribution!')
end
end
if nargin==4
end
if nargin==4
switch distribution
case 1
upper_bound = Inf;
@ -71,10 +71,10 @@ function [mu, parameters] = mode_and_variance_to_mean(m,s2,distribution,lower_bo
otherwise
error('Unknown distribution!')
end
end
end
if (distribution==1)% Gamma distribution
if (distribution==1)% Gamma distribution
if m<lower_bound
error('The mode has to be greater than the lower bound!')
end
@ -88,9 +88,9 @@ function [mu, parameters] = mode_and_variance_to_mean(m,s2,distribution,lower_bo
parameters(2) = beta;
mu = alpha*beta + lower_bound ;
return
end
end
if (distribution==2)% Inverse Gamma - 2 distribution
if (distribution==2)% Inverse Gamma - 2 distribution
if m<lower_bound+2*eps
error('The mode has to be greater than the lower bound!')
end
@ -110,9 +110,9 @@ function [mu, parameters] = mode_and_variance_to_mean(m,s2,distribution,lower_bo
parameters(2) = s;
mu = s/(nu-2) + lower_bound;
return
end
end
if (distribution==3)% Inverted Gamma 1 distribution
if (distribution==3)% Inverted Gamma 1 distribution
if m<lower_bound+2*eps
error('The mode has to be greater than the lower bound!')
end
@ -147,9 +147,9 @@ function [mu, parameters] = mode_and_variance_to_mean(m,s2,distribution,lower_bo
parameters(2) = s;
mu = sqrt(.5*s)*gamma(.5*(nu-1))/gamma(.5*nu) + lower_bound ;
return
end
end
if (distribution==4)% Beta distribution
if (distribution==4)% Beta distribution
if m<lower_bound
error('The mode has to be greater than the lower bound!')
end
@ -186,4 +186,4 @@ function [mu, parameters] = mode_and_variance_to_mean(m,s2,distribution,lower_bo
parameters(2) = beta;
mu = alpha/(alpha+beta)*(upper_bound-lower_bound)+lower_bound;
return
end
end

2
matlab/distributions/multivariate_normal_pdf.m
View File

@ -31,6 +31,6 @@ function density = multivariate_normal_pdf(X,Mean,Sigma_upper_chol,n);
%
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
density = (2*pi)^(-.5*n) * ...
density = (2*pi)^(-.5*n) * ...
prod(diag(Sigma_upper_chol))^(-1) * ...
exp(-.5*(X-Mean)*(Sigma_upper_chol\(transpose(Sigma_upper_chol)\transpose(X-Mean))));

8
matlab/distributions/multivariate_student_pdf.m
View File

@ -30,7 +30,7 @@ function density = multivariate_student_pdf(X,Mean,Sigma_upper_chol,df);
%
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
nn = length(X);
t1 = gamma( .5*(nn+df) ) / ( gamma( .5*nn ) * (df*pi)^(.5*nn) ) ;
t2 = t1 / prod(diag(Sigma_upper_chol)) ;
density = t2 / ( 1 + (X-Mean)*(Sigma_upper_chol\(transpose(Sigma_upper_chol)\transpose(X-Mean)))/df )^(.5*(nn+df));
nn = length(X);
t1 = gamma( .5*(nn+df) ) / ( gamma( .5*nn ) * (df*pi)^(.5*nn) ) ;
t2 = t1 / prod(diag(Sigma_upper_chol)) ;
density = t2 / ( 1 + (X-Mean)*(Sigma_upper_chol\(transpose(Sigma_upper_chol)\transpose(X-Mean)))/df )^(.5*(nn+df));

14
matlab/distributions/rand_inverse_wishart.m
View File

@ -41,13 +41,13 @@ function G = rand_inverse_wishart(m, v, H_inv_upper_chol)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
X = randn(v, m) * H_inv_upper_chol;
X = randn(v, m) * H_inv_upper_chol;
% At this point, X'*X is Wishart distributed
% G = inv(X'*X);
% At this point, X'*X is Wishart distributed
% G = inv(X'*X);
% Rather compute inv(X'*X) using the SVD
[U,S,V] = svd(X, 0);
SSi = 1 ./ (diag(S) .^ 2);
G = (V .* repmat(SSi', m, 1)) * V';
% Rather compute inv(X'*X) using the SVD
[U,S,V] = svd(X, 0);
SSi = 1 ./ (diag(S) .^ 2);
G = (V .* repmat(SSi', m, 1)) * V';

8
matlab/distributions/rand_matrix_normal.m
View File

@ -37,7 +37,7 @@ function B = rand_matrix_normal(n, p, M, Omega_lower_chol, Sigma_lower_chol)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
B1 = randn(n * p, 1);
B2 = kron(Omega_lower_chol, Sigma_lower_chol) * B1;
B3 = reshape(B2, n, p);
B = B3 + M;
B1 = randn(n * p, 1);
B2 = kron(Omega_lower_chol, Sigma_lower_chol) * B1;
B3 = reshape(B2, n, p);
B = B3 + M;

2
matlab/distributions/rand_multivariate_normal.m
View File

@ -31,4 +31,4 @@ function draw = rand_multivariate_normal(Mean,Sigma_upper_chol,n)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
draw = Mean + randn(1,n) * Sigma_upper_chol;
draw = Mean + randn(1,n) * Sigma_upper_chol;

4
matlab/distributions/rand_multivariate_student.m
View File

@ -35,5 +35,5 @@ function draw = rand_multivariate_student(Mean,Sigma_upper_chol,df)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
n = length(Mean);
draw = Mean + randn(1,n) * Sigma_upper_chol * sqrt(df/sum(randn(df,1).^2));
n = length(Mean);
draw = Mean + randn(1,n) * Sigma_upper_chol * sqrt(df/sum(randn(df,1).^2));

360
matlab/dr1.m
View File

@ -49,28 +49,28 @@ function [dr,info,M_,options_,oo_] = dr1(dr,task,M_,options_,oo_)
% 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;
info = 0;
if options_.k_order_solver;
if options_.k_order_solver;
dr = set_state_space(dr,M_);
[dr,info] = k_order_pert(dr,M_,options_,oo_);
oo_.dr = dr;
return;
end
end
xlen = M_.maximum_endo_lead + M_.maximum_endo_lag + 1;
klen = M_.maximum_endo_lag + M_.maximum_endo_lead + 1;
iyv = M_.lead_lag_incidence';
iyv = iyv(:);
iyr0 = find(iyv) ;
it_ = M_.maximum_lag + 1 ;
xlen = M_.maximum_endo_lead + M_.maximum_endo_lag + 1;
klen = M_.maximum_endo_lag + M_.maximum_endo_lead + 1;
iyv = M_.lead_lag_incidence';
iyv = iyv(:);
iyr0 = find(iyv) ;
it_ = M_.maximum_lag + 1 ;
if M_.exo_nbr == 0
if M_.exo_nbr == 0
oo_.exo_steady_state = [] ;
end
end
% expanding system for Optimal Linear Regulator
if options_.ramsey_policy
% expanding system for Optimal Linear Regulator
if options_.ramsey_policy
if isfield(M_,'orig_model')
orig_model = M_.orig_model;
M_.endo_nbr = orig_model.endo_nbr;
@ -129,7 +129,7 @@ function [dr,info,M_,options_,oo_] = dr1(dr,task,M_,options_,oo_)
[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];
else
else
klen = M_.maximum_lag + M_.maximum_lead + 1;
iyv = M_.lead_lag_incidence';
iyv = iyv(:);
@ -156,13 +156,13 @@ function [dr,info,M_,options_,oo_] = dr1(dr,task,M_,options_,oo_)
size(jacobia_, 1), size(jacobia_, 2)*size(jacobia_, 2));
end
end
end
end
if options_.debug
if options_.debug
save([M_.fname '_debug.mat'],'jacobia_')
end
end
if ~isreal(jacobia_)
if ~isreal(jacobia_)
if max(max(abs(imag(jacobia_)))) < 1e-15
jacobia_ = real(jacobia_);
else
@ -170,28 +170,28 @@ function [dr,info,M_,options_,oo_] = dr1(dr,task,M_,options_,oo_)
info(2) = sum(sum(imag(jacobia_).^2));
return
end
end
end
dr=set_state_space(dr,M_);
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);
dr=set_state_space(dr,M_);
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;
sdyn = M_.endo_nbr - nstatic;
[junk,cols_b,cols_j] = find(M_.lead_lag_incidence(M_.maximum_endo_lag+1, ...
[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);
b = zeros(M_.endo_nbr,M_.endo_nbr);
b(:,cols_b) = jacobia_(:,cols_j);
if M_.maximum_endo_lead == 0 && options_.order == 1
if M_.maximum_endo_lead == 0 && options_.order == 1
% backward models: simplified code exist only at order == 1
% If required, use AIM solver if not check only
if (options_.aim_solver == 1) && (task == 0)
@ -232,18 +232,18 @@ function [dr,info,M_,options_,oo_] = dr1(dr,task,M_,options_,oo_)
dr.ghu = repmat(1./dr.ys,1,size(dr.ghu,2)).*dr.ghu;
end
return
end
end
%forward--looking models
if nstatic > 0
%forward--looking models
if nstatic > 0
[Q,R] = qr(b(:,1:nstatic));
aa = Q'*jacobia_;
else
else
aa = jacobia_;
end
end
% If required, use AIM solver if not check only
if (options_.aim_solver == 1) && (task == 0)
% If required, use AIM solver if not check only
if (options_.aim_solver == 1) && (task == 0)
if options_.order > 1
error('Option "aim_solver" is incompatible with order >= 2')
end
@ -279,7 +279,7 @@ function [dr,info,M_,options_,oo_] = dr1(dr,task,M_,options_,oo_)
disp(lasterror.message)
error('Problem with AIM solver - Try to remove the "aim_solver" option')
end
else % use original Dynare solver
else % use original Dynare solver
k1 = M_.lead_lag_incidence(find([1:klen] ~= M_.maximum_endo_lag+1),:);
a = aa(:,nonzeros(k1'));
b(:,cols_b) = aa(:,cols_j);
@ -402,10 +402,10 @@ function [dr,info,M_,options_,oo_] = dr1(dr,task,M_,options_,oo_)
dr.ghx = [temp; dr.ghx];
temp = [];
end
end % if not use AIM and ....
end % if not use AIM and ....
% End of if... and if not... main AIM Blocks, continue as per usual...
if options_.loglinear == 1
if options_.loglinear == 1
k = find(dr.kstate(:,2) <= M_.maximum_endo_lag+1);
klag = dr.kstate(k,[1 2]);
k1 = dr.order_var;
@ -413,18 +413,18 @@ function [dr,info,M_,options_,oo_] = dr1(dr,task,M_,options_,oo_)
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
end
if options_.aim_solver ~= 1 && options_.use_qzdiv
if options_.aim_solver ~= 1 && 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
end
%exogenous deterministic variables
if M_.exo_det_nbr > 0
%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));
@ -435,89 +435,89 @@ function [dr,info,M_,options_,oo_] = dr1(dr,task,M_,options_,oo_)
for i = 2:M_.exo_det_length
dr.ghud{i} = -M2*dr.ghud{i-1}(end-nyf+1:end,:);
end
end
end
if options_.order == 1
if options_.order == 1
return
end
end
% Second order
%tempex = oo_.exo_simul ;
% Second order
%tempex = oo_.exo_simul ;
%hessian = real(hessext('ff1_',[z; oo_.exo_steady_state]))' ;
kk = flipud(cumsum(flipud(M_.lead_lag_incidence(M_.maximum_endo_lag+1:end,order_var)),1));
if M_.maximum_endo_lag > 0
%hessian = real(hessext('ff1_',[z; oo_.exo_steady_state]))' ;
kk = flipud(cumsum(flipud(M_.lead_lag_incidence(M_.maximum_endo_lag+1:end,order_var)),1));
if M_.maximum_endo_lag > 0
kk = [cumsum(M_.lead_lag_incidence(1:M_.maximum_endo_lag,order_var),1); kk];
end
kk = kk';
kk = find(kk(:));
nk = size(kk,1) + M_.exo_nbr + M_.exo_det_nbr;
k1 = M_.lead_lag_incidence(:,order_var);
k1 = k1';
k1 = k1(:);
k1 = k1(kk);
k2 = find(k1);
kk1(k1(k2)) = k2;
kk1 = [kk1 length(k1)+1:length(k1)+M_.exo_nbr+M_.exo_det_nbr];
kk = reshape([1:nk^2],nk,nk);
kk1 = kk(kk1,kk1);
%[junk,junk,hessian] = feval([M_.fname '_dynamic'],z, oo_.exo_steady_state);
hessian(:,kk1(:)) = hessian1;
clear hessian1
end
kk = kk';
kk = find(kk(:));
nk = size(kk,1) + M_.exo_nbr + M_.exo_det_nbr;
k1 = M_.lead_lag_incidence(:,order_var);
k1 = k1';
k1 = k1(:);
k1 = k1(kk);
k2 = find(k1);
kk1(k1(k2)) = k2;
kk1 = [kk1 length(k1)+1:length(k1)+M_.exo_nbr+M_.exo_det_nbr];
kk = reshape([1:nk^2],nk,nk);
kk1 = kk(kk1,kk1);
%[junk,junk,hessian] = feval([M_.fname '_dynamic'],z, oo_.exo_steady_state);
hessian(:,kk1(:)) = hessian1;
clear hessian1
%oo_.exo_simul = tempex ;
%clear tempex
%oo_.exo_simul = tempex ;
%clear tempex
n1 = 0;
n2 = np;
zx = zeros(np,np);
zu=zeros(np,M_.exo_nbr);
for i=2:M_.maximum_endo_lag+1
n1 = 0;
n2 = np;
zx = zeros(np,np);
zu=zeros(np,M_.exo_nbr);
for i=2:M_.maximum_endo_lag+1
k1 = sum(kstate(:,2) == i);
zx(n1+1:n1+k1,n2-k1+1:n2)=eye(k1);
n1 = n1+k1;
n2 = n2-k1;
end
kk = flipud(cumsum(flipud(M_.lead_lag_incidence(M_.maximum_endo_lag+1:end,order_var)),1));
k0 = [1:M_.endo_nbr];
gx1 = dr.ghx;
hu = dr.ghu(nstatic+[1:npred],:);
zx = [zx; gx1];
zu = [zu; dr.ghu];
for i=1:M_.maximum_endo_lead
end
kk = flipud(cumsum(flipud(M_.lead_lag_incidence(M_.maximum_endo_lag+1:end,order_var)),1));
k0 = [1:M_.endo_nbr];
gx1 = dr.ghx;
hu = dr.ghu(nstatic+[1:npred],:);
zx = [zx; gx1];
zu = [zu; dr.ghu];
for i=1:M_.maximum_endo_lead
k1 = find(kk(i+1,k0) > 0);
zu = [zu; gx1(k1,1:npred)*hu];
gx1 = gx1(k1,:)*hx;
zx = [zx; gx1];
kk = kk(:,k0);
k0 = k1;
end
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);
end
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 = -sparse_hessian_times_B_kronecker_C(hessian,zx);
rhs = -sparse_hessian_times_B_kronecker_C(hessian,zx);
%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(n,n);
B = zeros(n,n);
A(1:M_.endo_nbr,1:M_.endo_nbr) = jacobia_(:,M_.lead_lag_incidence(M_.maximum_endo_lag+1,order_var));
% variables with the highest lead
k1 = find(kstate(:,2) == M_.maximum_endo_lag+M_.maximum_endo_lead+1);
if M_.maximum_endo_lead > 1
%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(n,n);
B = zeros(n,n);
A(1:M_.endo_nbr,1:M_.endo_nbr) = jacobia_(:,M_.lead_lag_incidence(M_.maximum_endo_lag+1,order_var));
% variables with the highest lead
k1 = find(kstate(:,2) == M_.maximum_endo_lag+M_.maximum_endo_lead+1);
if M_.maximum_endo_lead > 1
k2 = find(kstate(:,2) == M_.maximum_endo_lag+M_.maximum_endo_lead);
[junk,junk,k3] = intersect(kstate(k1,1),kstate(k2,1));
else
else
k2 = [1:M_.endo_nbr];
k3 = kstate(k1,1);
end
% Jacobian with respect to the variables with the highest lead
B(1:M_.endo_nbr,end-length(k2)+k3) = jacobia_(:,kstate(k1,3)+M_.endo_nbr);
offset = M_.endo_nbr;
k0 = [1:M_.endo_nbr];
gx1 = dr.ghx;
for i=1:M_.maximum_endo_lead-1
end
% Jacobian with respect to the variables with the highest lead
B(1:M_.endo_nbr,end-length(k2)+k3) = jacobia_(:,kstate(k1,3)+M_.endo_nbr);
offset = M_.endo_nbr;
k0 = [1:M_.endo_nbr];
gx1 = dr.ghx;
for i=1:M_.maximum_endo_lead-1
k1 = find(kstate(:,2) == M_.maximum_endo_lag+i+1);
[k2,junk,k3] = find(kstate(k1,3));
A(1:M_.endo_nbr,offset+k2) = jacobia_(:,k3+M_.endo_nbr);
@ -536,85 +536,85 @@ function [dr,info,M_,options_,oo_] = dr1(dr,task,M_,options_,oo_)
B(offset+[1:n1],offset-n0+[1:n0]) = -E(k4,:);
k0 = k1;
offset = offset + n1;
end
[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)=...
end
[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])+jacobia_(:,k2)*gx1(k1,1:npred);
C = hx;
D = [rhs; zeros(n-M_.endo_nbr,size(rhs,2))];
C = hx;
D = [rhs; zeros(n-M_.endo_nbr,size(rhs,2))];
dr.ghxx = gensylv(2,A,B,C,D);
dr.ghxx = gensylv(2,A,B,C,D);
%ghxu
%rhs
hu = dr.ghu(nstatic+1:nstatic+npred,:);
%kk = reshape([1:np*np],np,np);
%kk = kk(1:npred,1:npred);
%rhs = -hessian*kron(zx,zu)-f1*dr.ghxx(end-nyf+1:end,kk(:))*kron(hx(1:npred,:),hu(1:npred,:));
%ghxu
%rhs
hu = dr.ghu(nstatic+1:nstatic+npred,:);
%kk = reshape([1:np*np],np,np);
%kk = kk(1:npred,1:npred);
%rhs = -hessian*kron(zx,zu)-f1*dr.ghxx(end-nyf+1:end,kk(:))*kron(hx(1:npred,:),hu(1:npred,:));
rhs = sparse_hessian_times_B_kronecker_C(hessian,zx,zu);
rhs = sparse_hessian_times_B_kronecker_C(hessian,zx,zu);
nyf1 = sum(kstate(:,2) == M_.maximum_endo_lag+2);
hu1 = [hu;zeros(np-npred,M_.exo_nbr)];
%B1 = [B(1:M_.endo_nbr,:);zeros(size(A,1)-M_.endo_nbr,size(B,2))];
[nrhx,nchx] = size(hx);
[nrhu1,nchu1] = size(hu1);
nyf1 = sum(kstate(:,2) == M_.maximum_endo_lag+2);
hu1 = [hu;zeros(np-npred,M_.exo_nbr)];
%B1 = [B(1:M_.endo_nbr,:);zeros(size(A,1)-M_.endo_nbr,size(B,2))];
[nrhx,nchx] = size(hx);
[nrhu1,nchu1] = size(hu1);
B1 = B*A_times_B_kronecker_C(dr.ghxx,hx,hu1);
rhs = -[rhs; zeros(n-M_.endo_nbr,size(rhs,2))]-B1;
B1 = B*A_times_B_kronecker_C(dr.ghxx,hx,hu1);
rhs = -[rhs; zeros(n-M_.endo_nbr,size(rhs,2))]-B1;
%lhs
dr.ghxu = A\rhs;
%lhs
dr.ghxu = A\rhs;
%ghuu
%rhs
kk = reshape([1:np*np],np,np);
kk = kk(1:npred,1:npred);
%ghuu
%rhs
kk = reshape([1:np*np],np,np);
kk = kk(1:npred,1:npred);
rhs = sparse_hessian_times_B_kronecker_C(hessian,zu);
rhs = sparse_hessian_times_B_kronecker_C(hessian,zu);
B1 = A_times_B_kronecker_C(B*dr.ghxx,hu1);
rhs = -[rhs; zeros(n-M_.endo_nbr,size(rhs,2))]-B1;
B1 = A_times_B_kronecker_C(B*dr.ghxx,hu1);
rhs = -[rhs; zeros(n-M_.endo_nbr,size(rhs,2))]-B1;
%lhs
dr.ghuu = A\rhs;
%lhs
dr.ghuu = A\rhs;
dr.ghxx = dr.ghxx(1:M_.endo_nbr,:);
dr.ghxu = dr.ghxu(1:M_.endo_nbr,:);
dr.ghuu = dr.ghuu(1:M_.endo_nbr,:);
dr.ghxx = dr.ghxx(1:M_.endo_nbr,:);
dr.ghxu = dr.ghxu(1:M_.endo_nbr,:);
dr.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 = jacobia_(:,M_.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);
M_.lead_lag_incidenceordered = flipud(cumsum(flipud(M_.lead_lag_incidence(M_.maximum_endo_lag+1:end,order_var)),1));
if M_.maximum_endo_lag > 0
% 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 = jacobia_(:,M_.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);
M_.lead_lag_incidenceordered = flipud(cumsum(flipud(M_.lead_lag_incidence(M_.maximum_endo_lag+1:end,order_var)),1));
if M_.maximum_endo_lag > 0
M_.lead_lag_incidenceordered = [cumsum(M_.lead_lag_incidence(1:M_.maximum_endo_lag,order_var),1); M_.lead_lag_incidenceordered];
end
M_.lead_lag_incidenceordered = M_.lead_lag_incidenceordered';
M_.lead_lag_incidenceordered = M_.lead_lag_incidenceordered(:);
k1 = find(M_.lead_lag_incidenceordered);
M_.lead_lag_incidenceordered(k1) = [1:length(k1)]';
M_.lead_lag_incidenceordered =reshape(M_.lead_lag_incidenceordered,M_.endo_nbr,M_.maximum_endo_lag+M_.maximum_endo_lead+1)';
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],:);
for i=1:M_.maximum_endo_lead
end
M_.lead_lag_incidenceordered = M_.lead_lag_incidenceordered';
M_.lead_lag_incidenceordered = M_.lead_lag_incidenceordered(:);
k1 = find(M_.lead_lag_incidenceordered);
M_.lead_lag_incidenceordered(k1) = [1:length(k1)]';
M_.lead_lag_incidenceordered =reshape(M_.lead_lag_incidenceordered,M_.endo_nbr,M_.maximum_endo_lag+M_.maximum_endo_lead+1)';
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],:);
for i=1:M_.maximum_endo_lead
for j=i:M_.maximum_endo_lead
[junk,k2a,k2] = find(M_.lead_lag_incidence(M_.maximum_endo_lag+j+1,order_var));
[junk,k3a,k3] = ...
@ -641,15 +641,15 @@ function [dr,info,M_,options_,oo_] = dr1(dr,task,M_,options_,oo_)
Guu = hx*Guu;
Guu(end-npred+1:end,:) = Guu(end-npred+1:end,:) + G2;
H = E1 + hx*H;
end
RHS = RHS*M_.Sigma_e(:);
dr.fuu = RHS;
%RHS = -RHS-dr.fbias;
RHS = -RHS;
dr.ghs2 = LHS\RHS;
end
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
% 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);
@ -700,4 +700,4 @@ function [dr,info,M_,options_,oo_] = dr1(dr,task,M_,options_,oo_)
end
end
end
end

444
matlab/dr11_sparse.m
View File

@ -17,26 +17,26 @@ function [dr,info,M_,options_,oo_] = dr11_sparse(dr,task,M_,options_,oo_, jacobi
%
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
%task
info = 0;
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);
nz = nnz(M_.lead_lag_incidence);
%task
info = 0;
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);
nz = nnz(M_.lead_lag_incidence);
sdyn = M_.endo_nbr - nstatic;
k0 = M_.lead_lag_incidence(M_.maximum_endo_lag+1,order_var);
k1 = M_.lead_lag_incidence(find([1:klen] ~= M_.maximum_endo_lag+1),:);
b = jacobia_(:,k0);
sdyn = M_.endo_nbr - nstatic;
k0 = M_.lead_lag_incidence(M_.maximum_endo_lag+1,order_var);
k1 = M_.lead_lag_incidence(find([1:klen] ~= M_.maximum_endo_lag+1),:);
b = jacobia_(:,k0);
if M_.maximum_endo_lead == 0; % backward models
if M_.maximum_endo_lead == 0; % backward models
a = jacobia_(:,nonzeros(k1'));
dr.ghx = zeros(size(a));
m = 0;
@ -63,61 +63,61 @@ function [dr,info,M_,options_,oo_] = dr11_sparse(dr,task,M_,options_,oo_, jacobi
info(2) = temp'*temp;
end
return;
end
%forward--looking models
if nstatic > 0
end
%forward--looking models
if nstatic > 0
[Q,R] = qr(b(:,1:nstatic));
aa = Q'*jacobia_;
else
else
aa = jacobia_;
end
a = aa(:,nonzeros(k1'));
b = aa(:,k0);
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(:)))
end
a = aa(:,nonzeros(k1'));
b = aa(:,k0);
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
end
% buildind D and E
%nd
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);
% buildind D and E
%nd
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)
if ~isempty(kad)
for j = 1:size(kad,1)
d(sdyn+j,kad(j)) = 1 ;
e(sdyn+j,kae(j)) = 1 ;
end
end
%e
%d
end
%e
%d
[ss,tt,w,sdim,dr.eigval,info1] = mjdgges(e,d,options_.qz_criterium);
[ss,tt,w,sdim,dr.eigval,info1] = mjdgges(e,d,options_.qz_criterium);
if info1
if info1
info(1) = 2;
info(2) = info1;
return
end
end
nba = nd-sdim;
nba = nd-sdim;
nyf = sum(kstate(:,2) > M_.maximum_endo_lag+1);
nyf = sum(kstate(:,2) > M_.maximum_endo_lag+1);
if task == 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
@ -125,9 +125,9 @@ function [dr,info,M_,options_,oo_] = dr11_sparse(dr,task,M_,options_,oo_, jacobi
dr.eigval = eig(e,d);
end
return
end
end
if nba ~= nyf
if nba ~= nyf
temp = sort(abs(dr.eigval));
if nba > nyf
temp = temp(nd-nba+1:nd-nyf)-1-options_.qz_criterium;
@ -138,39 +138,39 @@ function [dr,info,M_,options_,oo_] = dr11_sparse(dr,task,M_,options_,oo_, jacobi
end
info(2) = temp'*temp;
return
end
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 condest(w1) > 1e9;
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 condest(w1) > 1e9;
info(1) = 5;
info(2) = condest(w1);
return;
else
else
gx = -w1'\w(n4:nd,n2:nd)';
end
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);
% 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);
hx(k1,:)
gx(k2(nboth+1:end),:)
dr.ghx = [hx(k1,:); gx(k2(nboth+1:end),:)];
dr.ghx
%lead variables actually present in the model
j3 = nonzeros(kstate(:,3));
j4 = find(kstate(:,3));
% derivatives with respect to exogenous variables
disp(['M_.exo_nbr=' int2str(M_.exo_nbr)]);
if M_.exo_nbr
k1 = find(kstate(n4:nd,2) == M_.maximum_endo_lag+1);
k2 = find(kstate(1:n3,2) == M_.maximum_endo_lag+2);
hx(k1,:)
gx(k2(nboth+1:end),:)
dr.ghx = [hx(k1,:); gx(k2(nboth+1:end),:)];
dr.ghx
%lead variables actually present in the model
j3 = nonzeros(kstate(:,3));
j4 = find(kstate(:,3));
% derivatives with respect to exogenous variables
disp(['M_.exo_nbr=' int2str(M_.exo_nbr)]);
if M_.exo_nbr
fu = aa(:,nz+(1:M_.exo_nbr));
a1 = b;
aa1 = [];
@ -179,21 +179,21 @@ function [dr,info,M_,options_,oo_] = dr11_sparse(dr,task,M_,options_,oo_, jacobi
end
dr.ghu = -[aa1 a(:,j3)*gx(j4,1:npred)+a1(:,nstatic+1:nstatic+ ...
npred) a1(:,nstatic+npred+1:end)]\fu;
else
else
dr.ghu = [];
end
end
% static variables
if nstatic > 0
% 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
end
if options_.loglinear == 1
if options_.loglinear == 1
k = find(dr.kstate(:,2) <= M_.maximum_endo_lag+1);
klag = dr.kstate(k,[1 2]);
k1 = dr.order_var;
@ -201,18 +201,18 @@ function [dr,info,M_,options_,oo_] = dr11_sparse(dr,task,M_,options_,oo_, jacobi
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
end
%% Necessary when using Sims' routines for QZ
if options_.use_qzdiv
%% Necessary when using Sims' routines for QZ
if options_.use_qzdiv
gx = real(gx);
hx = real(hx);
dr.ghx = real(dr.ghx);
dr.ghu = real(dr.ghu);
end
end
%exogenous deterministic variables
if M_.exo_det_nbr > 0
%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));
@ -223,87 +223,87 @@ function [dr,info,M_,options_,oo_] = dr11_sparse(dr,task,M_,options_,oo_, jacobi
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
end
if options_.order == 1
return
end
end
% Second order
%tempex = oo_.exo_simul ;
% Second order
%tempex = oo_.exo_simul ;
%hessian = real(hessext('ff1_',[z; oo_.exo_steady_state]))' ;
kk = flipud(cumsum(flipud(M_.lead_lag_incidence(M_.maximum_endo_lag+1:end,order_var)),1));
if M_.maximum_endo_lag > 0
%hessian = real(hessext('ff1_',[z; oo_.exo_steady_state]))' ;
kk = flipud(cumsum(flipud(M_.lead_lag_incidence(M_.maximum_endo_lag+1:end,order_var)),1));
if M_.maximum_endo_lag > 0
kk = [cumsum(M_.lead_lag_incidence(1:M_.maximum_endo_lag,order_var),1); kk];
end
kk = kk';
kk = find(kk(:));
nk = size(kk,1) + M_.exo_nbr + M_.exo_det_nbr;
k1 = M_.lead_lag_incidence(:,order_var);
k1 = k1';
k1 = k1(:);
k1 = k1(kk);
k2 = find(k1);
kk1(k1(k2)) = k2;
kk1 = [kk1 length(k1)+1:length(k1)+M_.exo_nbr+M_.exo_det_nbr];
kk = reshape([1:nk^2],nk,nk);
kk1 = kk(kk1,kk1);
%[junk,junk,hessian] = feval([M_.fname '_dynamic'],z, oo_.exo_steady_state);
hessian(:,kk1(:)) = hessian;
end
kk = kk';
kk = find(kk(:));
nk = size(kk,1) + M_.exo_nbr + M_.exo_det_nbr;
k1 = M_.lead_lag_incidence(:,order_var);
k1 = k1';
k1 = k1(:);
k1 = k1(kk);
k2 = find(k1);
kk1(k1(k2)) = k2;
kk1 = [kk1 length(k1)+1:length(k1)+M_.exo_nbr+M_.exo_det_nbr];
kk = reshape([1:nk^2],nk,nk);
kk1 = kk(kk1,kk1);
%[junk,junk,hessian] = feval([M_.fname '_dynamic'],z, oo_.exo_steady_state);
hessian(:,kk1(:)) = hessian;
%oo_.exo_simul = tempex ;
%clear tempex
%oo_.exo_simul = tempex ;
%clear tempex
n1 = 0;
n2 = np;
zx = zeros(np,np);
zu=zeros(np,M_.exo_nbr);
for i=2:M_.maximum_endo_lag+1
n1 = 0;
n2 = np;
zx = zeros(np,np);
zu=zeros(np,M_.exo_nbr);
for i=2:M_.maximum_endo_lag+1
k1 = sum(kstate(:,2) == i);
zx(n1+1:n1+k1,n2-k1+1:n2)=eye(k1);
n1 = n1+k1;
n2 = n2-k1;
end
kk = flipud(cumsum(flipud(M_.lead_lag_incidence(M_.maximum_endo_lag+1:end,order_var)),1));
k0 = [1:M_.endo_nbr];
gx1 = dr.ghx;
hu = dr.ghu(nstatic+[1:npred],:);
zx = [zx; gx1];
zu = [zu; dr.ghu];
for i=1:M_.maximum_endo_lead
end
kk = flipud(cumsum(flipud(M_.lead_lag_incidence(M_.maximum_endo_lag+1:end,order_var)),1));
k0 = [1:M_.endo_nbr];
gx1 = dr.ghx;
hu = dr.ghu(nstatic+[1:npred],:);
zx = [zx; gx1];
zu = [zu; dr.ghu];
for i=1:M_.maximum_endo_lead
k1 = find(kk(i+1,k0) > 0);
zu = [zu; gx1(k1,1:npred)*hu];
gx1 = gx1(k1,:)*hx;
zx = [zx; gx1];
kk = kk(:,k0);
k0 = k1;
end
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);
end
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 = -sparse_hessian_times_B_kronecker_C(hessian,zx);
rhs = -sparse_hessian_times_B_kronecker_C(hessian,zx);
%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(n,n);
B = zeros(n,n);
A(1:M_.endo_nbr,1:M_.endo_nbr) = jacobia_(:,M_.lead_lag_incidence(M_.maximum_endo_lag+1,order_var));
% variables with the highest lead
k1 = find(kstate(:,2) == M_.maximum_endo_lag+M_.maximum_endo_lead+1);
if M_.maximum_endo_lead > 1
%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(n,n);
B = zeros(n,n);
A(1:M_.endo_nbr,1:M_.endo_nbr) = jacobia_(:,M_.lead_lag_incidence(M_.maximum_endo_lag+1,order_var));
% variables with the highest lead
k1 = find(kstate(:,2) == M_.maximum_endo_lag+M_.maximum_endo_lead+1);
if M_.maximum_endo_lead > 1
k2 = find(kstate(:,2) == M_.maximum_endo_lag+M_.maximum_endo_lead);
[junk,junk,k3] = intersect(kstate(k1,1),kstate(k2,1));
else
else
k2 = [1:M_.endo_nbr];
k3 = kstate(k1,1);
end
% Jacobian with respect to the variables with the highest lead
B(1:M_.endo_nbr,end-length(k2)+k3) = jacobia_(:,kstate(k1,3)+M_.endo_nbr);
offset = M_.endo_nbr;
k0 = [1:M_.endo_nbr];
gx1 = dr.ghx;
for i=1:M_.maximum_endo_lead-1
end
% Jacobian with respect to the variables with the highest lead
B(1:M_.endo_nbr,end-length(k2)+k3) = jacobia_(:,kstate(k1,3)+M_.endo_nbr);
offset = M_.endo_nbr;
k0 = [1:M_.endo_nbr];
gx1 = dr.ghx;
for i=1:M_.maximum_endo_lead-1
k1 = find(kstate(:,2) == M_.maximum_endo_lag+i+1);
[k2,junk,k3] = find(kstate(k1,3));
A(1:M_.endo_nbr,offset+k2) = jacobia_(:,k3+M_.endo_nbr);
@ -322,85 +322,85 @@ function [dr,info,M_,options_,oo_] = dr11_sparse(dr,task,M_,options_,oo_, jacobi
B(offset+[1:n1],offset-n0+[1:n0]) = -E(k4,:);
k0 = k1;
offset = offset + n1;
end
[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)=...
end
[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])+jacobia_(:,k2)*gx1(k1,1:npred);
C = hx;
D = [rhs; zeros(n-M_.endo_nbr,size(rhs,2))];
C = hx;
D = [rhs; zeros(n-M_.endo_nbr,size(rhs,2))];
dr.ghxx = gensylv(2,A,B,C,D);
dr.ghxx = gensylv(2,A,B,C,D);
%ghxu
%rhs
hu = dr.ghu(nstatic+1:nstatic+npred,:);
%kk = reshape([1:np*np],np,np);
%kk = kk(1:npred,1:npred);
%rhs = -hessian*kron(zx,zu)-f1*dr.ghxx(end-nyf+1:end,kk(:))*kron(hx(1:npred,:),hu(1:npred,:));
%ghxu
%rhs
hu = dr.ghu(nstatic+1:nstatic+npred,:);
%kk = reshape([1:np*np],np,np);
%kk = kk(1:npred,1:npred);
%rhs = -hessian*kron(zx,zu)-f1*dr.ghxx(end-nyf+1:end,kk(:))*kron(hx(1:npred,:),hu(1:npred,:));
rhs = sparse_hessian_times_B_kronecker_C(hessian,zx,zu);
rhs = sparse_hessian_times_B_kronecker_C(hessian,zx,zu);
nyf1 = sum(kstate(:,2) == M_.maximum_endo_lag+2);
hu1 = [hu;zeros(np-npred,M_.exo_nbr)];
%B1 = [B(1:M_.endo_nbr,:);zeros(size(A,1)-M_.endo_nbr,size(B,2))];
[nrhx,nchx] = size(hx);
[nrhu1,nchu1] = size(hu1);
nyf1 = sum(kstate(:,2) == M_.maximum_endo_lag+2);
hu1 = [hu;zeros(np-npred,M_.exo_nbr)];
%B1 = [B(1:M_.endo_nbr,:);zeros(size(A,1)-M_.endo_nbr,size(B,2))];
[nrhx,nchx] = size(hx);
[nrhu1,nchu1] = size(hu1);
B1 = B*A_times_B_kronecker_C(dr.ghxx,hx,hu1);
rhs = -[rhs; zeros(n-M_.endo_nbr,size(rhs,2))]-B1;
B1 = B*A_times_B_kronecker_C(dr.ghxx,hx,hu1);
rhs = -[rhs; zeros(n-M_.endo_nbr,size(rhs,2))]-B1;
%lhs
dr.ghxu = A\rhs;
%lhs
dr.ghxu = A\rhs;
%ghuu
%rhs
kk = reshape([1:np*np],np,np);
kk = kk(1:npred,1:npred);
%ghuu
%rhs
kk = reshape([1:np*np],np,np);
kk = kk(1:npred,1:npred);
rhs = sparse_hessian_times_B_kronecker_C(hessian,zu);
rhs = sparse_hessian_times_B_kronecker_C(hessian,zu);
B1 = A_times_B_kronecker_C(B*dr.ghxx,hu1);
rhs = -[rhs; zeros(n-M_.endo_nbr,size(rhs,2))]-B1;
B1 = A_times_B_kronecker_C(B*dr.ghxx,hu1);
rhs = -[rhs; zeros(n-M_.endo_nbr,size(rhs,2))]-B1;
%lhs
dr.ghuu = A\rhs;
%lhs
dr.ghuu = A\rhs;
dr.ghxx = dr.ghxx(1:M_.endo_nbr,:);
dr.ghxu = dr.ghxu(1:M_.endo_nbr,:);
dr.ghuu = dr.ghuu(1:M_.endo_nbr,:);
dr.ghxx = dr.ghxx(1:M_.endo_nbr,:);
dr.ghxu = dr.ghxu(1:M_.endo_nbr,:);
dr.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 = jacobia_(:,M_.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);
M_.lead_lag_incidenceordered = flipud(cumsum(flipud(M_.lead_lag_incidence(M_.maximum_endo_lag+1:end,order_var)),1));
if M_.maximum_endo_lag > 0
% 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 = jacobia_(:,M_.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);
M_.lead_lag_incidenceordered = flipud(cumsum(flipud(M_.lead_lag_incidence(M_.maximum_endo_lag+1:end,order_var)),1));
if M_.maximum_endo_lag > 0
M_.lead_lag_incidenceordered = [cumsum(M_.lead_lag_incidence(1:M_.maximum_endo_lag,order_var),1); M_.lead_lag_incidenceordered];
end
M_.lead_lag_incidenceordered = M_.lead_lag_incidenceordered';
M_.lead_lag_incidenceordered = M_.lead_lag_incidenceordered(:);
k1 = find(M_.lead_lag_incidenceordered);
M_.lead_lag_incidenceordered(k1) = [1:length(k1)]';
M_.lead_lag_incidenceordered =reshape(M_.lead_lag_incidenceordered,M_.endo_nbr,M_.maximum_endo_lag+M_.maximum_endo_lead+1)';
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],:);
for i=1:M_.maximum_endo_lead
end
M_.lead_lag_incidenceordered = M_.lead_lag_incidenceordered';
M_.lead_lag_incidenceordered = M_.lead_lag_incidenceordered(:);
k1 = find(M_.lead_lag_incidenceordered);
M_.lead_lag_incidenceordered(k1) = [1:length(k1)]';
M_.lead_lag_incidenceordered =reshape(M_.lead_lag_incidenceordered,M_.endo_nbr,M_.maximum_endo_lag+M_.maximum_endo_lead+1)';
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],:);
for i=1:M_.maximum_endo_lead
for j=i:M_.maximum_endo_lead
[junk,k2a,k2] = find(M_.lead_lag_incidence(M_.maximum_endo_lag+j+1,order_var));
[junk,k3a,k3] = ...
@ -427,15 +427,15 @@ function [dr,info,M_,options_,oo_] = dr11_sparse(dr,task,M_,options_,oo_, jacobi
Guu = hx*Guu;
Guu(end-npred+1:end,:) = Guu(end-npred+1:end,:) + G2;
H = E1 + hx*H;
end
RHS = RHS*M_.Sigma_e(:);
dr.fuu = RHS;
%RHS = -RHS-dr.fbias;
RHS = -RHS;
dr.ghs2 = LHS\RHS;
end
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
% 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);
@ -486,4 +486,4 @@ function [dr,info,M_,options_,oo_] = dr11_sparse(dr,task,M_,options_,oo_, jacobi
end
end
end
end

36
matlab/dr1_sparse.m
View File

@ -47,27 +47,27 @@ function [dr,info,M_,options_,oo_] = dr1_sparse(dr,task,M_,options_,oo_)
% 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;
info = 0;
options_ = set_default_option(options_,'loglinear',0);
options_ = set_default_option(options_,'noprint',0);
options_ = set_default_option(options_,'olr',0);
options_ = set_default_option(options_,'olr_beta',1);
options_ = set_default_option(options_,'qz_criterium',1.000001);
options_ = set_default_option(options_,'loglinear',0);
options_ = set_default_option(options_,'noprint',0);
options_ = set_default_option(options_,'olr',0);
options_ = set_default_option(options_,'olr_beta',1);
options_ = set_default_option(options_,'qz_criterium',1.000001);
xlen = M_.maximum_endo_lead + M_.maximum_endo_lag + 1;
klen = M_.maximum_endo_lag + M_.maximum_endo_lead + 1;
iyv = M_.lead_lag_incidence';
iyv = iyv(:);
iyr0 = find(iyv) ;
it_ = M_.maximum_lag + 1 ;
xlen = M_.maximum_endo_lead + M_.maximum_endo_lag + 1;
klen = M_.maximum_endo_lag + M_.maximum_endo_lead + 1;
iyv = M_.lead_lag_incidence';
iyv = iyv(:);
iyr0 = find(iyv) ;
it_ = M_.maximum_lag + 1 ;
if M_.exo_nbr == 0
if M_.exo_nbr == 0
oo_.exo_steady_state = [] ;
end
end
% expanding system for Optimal Linear Regulator
if options_.ramsey_policy
% expanding system for Optimal Linear Regulator
if options_.ramsey_policy
if isfield(M_,'orig_model')
orig_model = M_.orig_model;
M_.endo_nbr = orig_model.endo_nbr;
@ -178,7 +178,7 @@ function [dr,info,M_,options_,oo_] = dr1_sparse(dr,task,M_,options_,oo_)
% $$$ M_.endo_names = strvcat(M_.orig_model.endo_names, M_.endo_names(endo_nbr1+k,:));
% $$$ M_.endo_nbr = endo_nbr1+length(k);
% $$$ end
else
else
klen = M_.maximum_lag + M_.maximum_lead + 1;
iyv = M_.lead_lag_incidence';
iyv = iyv(:);
@ -264,5 +264,5 @@ function [dr,info,M_,options_,oo_] = dr1_sparse(dr,task,M_,options_,oo_)
end;
end
end
end
end

160
matlab/dsge_posterior_kernel.m
View File

@ -38,44 +38,44 @@ function [fval,cost_flag,ys,trend_coeff,info] = dsge_posterior_kernel(xparam1,ge
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global bayestopt_ estim_params_ options_ trend_coeff_ M_ oo_
fval = [];
ys = [];
trend_coeff = [];
cost_flag = 1;
nobs = size(options_.varobs,1);
%------------------------------------------------------------------------------
% 1. Get the structural parameters & define penalties
%------------------------------------------------------------------------------
if options_.mode_compute ~= 1 & any(xparam1 < bayestopt_.lb)
global bayestopt_ estim_params_ options_ trend_coeff_ M_ oo_
fval = [];
ys = [];
trend_coeff = [];
cost_flag = 1;
nobs = size(options_.varobs,1);
%------------------------------------------------------------------------------
% 1. Get the structural parameters & define penalties
%------------------------------------------------------------------------------
if options_.mode_compute ~= 1 & any(xparam1 < bayestopt_.lb)
k = find(xparam1 < bayestopt_.lb);
fval = bayestopt_.penalty+sum((bayestopt_.lb(k)-xparam1(k)).^2);
cost_flag = 0;
info = 41;
return;
end
if options_.mode_compute ~= 1 & any(xparam1 > bayestopt_.ub)
end
if options_.mode_compute ~= 1 & any(xparam1 > bayestopt_.ub)
k = find(xparam1 > bayestopt_.ub);
fval = bayestopt_.penalty+sum((xparam1(k)-bayestopt_.ub(k)).^2);
cost_flag = 0;
info = 42;
return;
end
Q = M_.Sigma_e;
H = M_.H;
for i=1:estim_params_.nvx
end
Q = M_.Sigma_e;
H = M_.H;
for i=1:estim_params_.nvx
k =estim_params_.var_exo(i,1);
Q(k,k) = xparam1(i)*xparam1(i);
end
offset = estim_params_.nvx;
if estim_params_.nvn
end
offset = estim_params_.nvx;
if estim_params_.nvn
for i=1:estim_params_.nvn
k = estim_params_.var_endo(i,1);
H(k,k) = xparam1(i+offset)*xparam1(i+offset);
end
offset = offset+estim_params_.nvn;
end
if estim_params_.ncx
end
if estim_params_.ncx
for i=1:estim_params_.ncx
k1 =estim_params_.corrx(i,1);
k2 =estim_params_.corrx(i,2);
@ -95,8 +95,8 @@ function [fval,cost_flag,ys,trend_coeff,info] = dsge_posterior_kernel(xparam1,ge
end
end
offset = offset+estim_params_.ncx;
end
if estim_params_.ncn
end
if estim_params_.ncn
for i=1:estim_params_.ncn
k1 = options_.lgyidx2varobs(estim_params_.corrn(i,1));
k2 = options_.lgyidx2varobs(estim_params_.corrn(i,2));
@ -115,38 +115,38 @@ function [fval,cost_flag,ys,trend_coeff,info] = dsge_posterior_kernel(xparam1,ge
end
end
offset = offset+estim_params_.ncn;
end
if estim_params_.np > 0
end
if estim_params_.np > 0
M_.params(estim_params_.param_vals(:,1)) = xparam1(offset+1:end);
end
M_.Sigma_e = Q;
M_.H = H;
%------------------------------------------------------------------------------
% 2. call model setup & reduction program
%------------------------------------------------------------------------------
[T,R,SteadyState,info] = dynare_resolve(bayestopt_.restrict_var_list,...
end
M_.Sigma_e = Q;
M_.H = H;
%------------------------------------------------------------------------------
% 2. call model setup & reduction program
%------------------------------------------------------------------------------
[T,R,SteadyState,info] = dynare_resolve(bayestopt_.restrict_var_list,...
bayestopt_.restrict_columns,...
bayestopt_.restrict_aux);
if info(1) == 1 | info(1) == 2 | info(1) == 5
if info(1) == 1 | info(1) == 2 | info(1) == 5
fval = bayestopt_.penalty+1;
cost_flag = 0;
return
elseif info(1) == 3 | info(1) == 4 | info(1) == 20
elseif info(1) == 3 | info(1) == 4 | info(1) == 20
fval = bayestopt_.penalty+info(2);%^2; % penalty power raised in DR1.m and resol already. GP July'08
cost_flag = 0;
return
end
bayestopt_.mf = bayestopt_.mf1;
if ~options_.noconstant
end
bayestopt_.mf = bayestopt_.mf1;
if ~options_.noconstant
if options_.loglinear == 1
constant = log(SteadyState(bayestopt_.mfys));
else
constant = SteadyState(bayestopt_.mfys);
end
else
else
constant = zeros(nobs,1);
end
if bayestopt_.with_trend == 1
end
if bayestopt_.with_trend == 1
trend_coeff = zeros(nobs,1);
t = options_.trend_coeffs;
for i=1:length(t)
@ -155,30 +155,30 @@ function [fval,cost_flag,ys,trend_coeff,info] = dsge_posterior_kernel(xparam1,ge
end
end
trend = repmat(constant,1,gend)+trend_coeff*[1:gend];
else
else
trend = repmat(constant,1,gend);
end
start = options_.presample+1;
np = size(T,1);
mf = bayestopt_.mf;
no_missing_data_flag = (number_of_observations==gend*nobs);
%------------------------------------------------------------------------------
% 3. Initial condition of the Kalman filter
%------------------------------------------------------------------------------
kalman_algo = options_.kalman_algo;
if options_.lik_init == 1 % Kalman filter
end
start = options_.presample+1;
np = size(T,1);
mf = bayestopt_.mf;
no_missing_data_flag = (number_of_observations==gend*nobs);
%------------------------------------------------------------------------------
% 3. Initial condition of the Kalman filter
%------------------------------------------------------------------------------
kalman_algo = options_.kalman_algo;
if options_.lik_init == 1 % Kalman filter
if kalman_algo ~= 2
kalman_algo = 1;
end
Pstar = lyapunov_symm(T,R*Q*R',options_.qz_criterium,options_.lyapunov_complex_threshold);
Pinf = [];
elseif options_.lik_init == 2 % Old Diffuse Kalman filter
elseif options_.lik_init == 2 % Old Diffuse Kalman filter
if kalman_algo ~= 2
kalman_algo = 1;
end
Pstar = 10*eye(np);
Pinf = [];
elseif options_.lik_init == 3 % Diffuse Kalman filter
elseif options_.lik_init == 3 % Diffuse Kalman filter
if kalman_algo ~= 4
kalman_algo = 3;
end
@ -239,8 +239,8 @@ function [fval,cost_flag,ys,trend_coeff,info] = dsge_posterior_kernel(xparam1,ge
dd(k1) = zeros(length(k1),1);
Pinf(1:nk,1:nk) = diag(dd);
end
end
if kalman_algo == 2
end
if kalman_algo == 2
no_correlation_flag = 1;
if length(H)==1
H = zeros(nobs,1);
@ -251,15 +251,15 @@ function [fval,cost_flag,ys,trend_coeff,info] = dsge_posterior_kernel(xparam1,ge
no_correlation_flag = 0;
end
end
end
kalman_tol = options_.kalman_tol;
riccati_tol = options_.riccati_tol;
mf = bayestopt_.mf1;
Y = data-trend;
%------------------------------------------------------------------------------
% 4. Likelihood evaluation
%------------------------------------------------------------------------------
if (kalman_algo==1)% Multivariate Kalman Filter
end
kalman_tol = options_.kalman_tol;
riccati_tol = options_.riccati_tol;
mf = bayestopt_.mf1;
Y = data-trend;
%------------------------------------------------------------------------------
% 4. Likelihood evaluation
%------------------------------------------------------------------------------
if (kalman_algo==1)% Multivariate Kalman Filter
if no_missing_data_flag
LIK = kalman_filter(T,R,Q,H,Pstar,Y,start,mf,kalman_tol,riccati_tol);
else
@ -270,15 +270,15 @@ function [fval,cost_flag,ys,trend_coeff,info] = dsge_posterior_kernel(xparam1,ge
if isinf(LIK)
kalman_algo = 2;
end
end
if (kalman_algo==2)% Univariate Kalman Filter
end
if (kalman_algo==2)% Univariate Kalman Filter
if no_correlation_flag
LIK = univariate_kalman_filter(T,R,Q,H,Pstar,Y,start,mf,kalman_tol,riccati_tol,data_index,number_of_observations,no_more_missing_observations);
else
LIK = univariate_kalman_filter_corr(T,R,Q,H,Pstar,Y,start,mf,kalman_tol,riccati_tol,data_index,number_of_observations,no_more_missing_observations);
end
end
if (kalman_algo==3)% Multivariate Diffuse Kalman Filter
end
if (kalman_algo==3)% Multivariate Diffuse Kalman Filter
if no_missing_data_flag
LIK = diffuse_kalman_filter(ST,R1,Q,H,Pinf,Pstar,Y,start,Z,kalman_tol,riccati_tol);
else
@ -288,8 +288,8 @@ function [fval,cost_flag,ys,trend_coeff,info] = dsge_posterior_kernel(xparam1,ge
if isinf(LIK)
kalman_algo = 4;
end
end
if (kalman_algo==4)% Univariate Diffuse Kalman Filter
end
if (kalman_algo==4)% Univariate Diffuse Kalman Filter
if no_correlation_flag
LIK = univariate_diffuse_kalman_filter(ST,R1,Q,H,Pinf,Pstar,Y,start,Z,kalman_tol,riccati_tol,...
data_index,number_of_observations,no_more_missing_observations);
@ -297,15 +297,15 @@ function [fval,cost_flag,ys,trend_coeff,info] = dsge_posterior_kernel(xparam1,ge
LIK = univariate_diffuse_kalman_filter_corr(ST,R1,Q,H,Pinf,Pstar,Y,start,Z,kalman_tol,riccati_tol,...
data_index,number_of_observations,no_more_missing_observations);
end
end
if imag(LIK) ~= 0
end
if imag(LIK) ~= 0
likelihood = bayestopt_.penalty;
else
else
likelihood = LIK;
end
% ------------------------------------------------------------------------------
% Adds prior if necessary
% ------------------------------------------------------------------------------
lnprior = priordens(xparam1,bayestopt_.pshape,bayestopt_.p6,bayestopt_.p7,bayestopt_.p3,bayestopt_.p4);
fval = (likelihood-lnprior);
options_.kalman_algo = kalman_algo;
end
% ------------------------------------------------------------------------------
% Adds prior if necessary
% ------------------------------------------------------------------------------
lnprior = priordens(xparam1,bayestopt_.pshape,bayestopt_.p6,bayestopt_.p7,bayestopt_.p3,bayestopt_.p4);
fval = (likelihood-lnprior);
options_.kalman_algo = kalman_algo;

5
matlab/dy_date.m
View File

@ -17,8 +17,7 @@ function y=dy_date(year,period)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_
y = M_.freq*(year-M_.start_date(1))+period-M_.start_date(2)+1;
global M_
y = M_.freq*(year-M_.start_date(1))+period-M_.start_date(2)+1;

20
matlab/dyn2vec.m
View File

@ -31,15 +31,15 @@ function [z,zss]=dyn2vec(s1,s2)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_ oo_ options_
global M_ oo_ options_
if options_.smpl == 0
if options_.smpl == 0
k = [1:size(oo_.endo_simul,2)];
else
else
k = [M_.maximum_lag+options_.smpl(1):M_.maximum_lag+options_.smpl(2)];
end
end
if nargin == 0
if nargin == 0
if nargout > 0
t = ['DYNARE dyn2vec error: the function doesn''t return values when' ...
' used without input argument'];
@ -49,7 +49,7 @@ function [z,zss]=dyn2vec(s1,s2)
assignin('base',deblank(M_.endo_names(i,:)),oo_.endo_simul(i,k)');
end
return
else
else
j = strmatch(s1,M_.endo_names,'exact');
if ~ isempty(j)
z = oo_.endo_simul(j,k)';
@ -67,17 +67,17 @@ function [z,zss]=dyn2vec(s1,s2)
error (t) ;
end
end
end
end
if nargout == 0
if nargout == 0
if nargin == 1
assignin('base',s1,z);
elseif nargin == 2
assignin('base',s2,z);
end
else
else
zss=oo_.steady_state(j);
end
end
% 02/23/01 MJ redone, incorporating FC's improvements
% 08/24/01 MJ replaced globlize by internal assignin

280
matlab/dyn_ramsey_dynamic_.m
View File

@ -30,118 +30,118 @@ function [J,M_] = dyn_ramsey_dynamic_(ys,lbar,M_,options_,oo_,it_)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
% retrieving model parameters
endo_nbr = M_.endo_nbr;
i_endo_nbr = 1:endo_nbr;
endo_names = M_.endo_names;
% exo_nbr = M_.exo_nbr+M_.exo_det_nbr;
% exo_names = vertcat(M_.exo_names,M_.exo_det_names);
exo_nbr = M_.exo_nbr;
exo_names = M_.exo_names;
i_leadlag = M_.lead_lag_incidence;
max_lead = M_.maximum_lead;
max_endo_lead = M_.maximum_endo_lead;
max_lag = M_.maximum_lag;
max_endo_lag = M_.maximum_endo_lag;
leadlag_nbr = max_lead+max_lag+1;
fname = M_.fname;
% instr_names = options_.olr_inst;
% instr_nbr = size(options_.olr_inst,1);
% retrieving model parameters
endo_nbr = M_.endo_nbr;
i_endo_nbr = 1:endo_nbr;
endo_names = M_.endo_names;
% exo_nbr = M_.exo_nbr+M_.exo_det_nbr;
% exo_names = vertcat(M_.exo_names,M_.exo_det_names);
exo_nbr = M_.exo_nbr;
exo_names = M_.exo_names;
i_leadlag = M_.lead_lag_incidence;
max_lead = M_.maximum_lead;
max_endo_lead = M_.maximum_endo_lead;
max_lag = M_.maximum_lag;
max_endo_lag = M_.maximum_endo_lag;
leadlag_nbr = max_lead+max_lag+1;
fname = M_.fname;
% instr_names = options_.olr_inst;
% instr_nbr = size(options_.olr_inst,1);
% discount factor
beta = options_.planner_discount;
% discount factor
beta = options_.planner_discount;
% storing original values
orig_model.endo_nbr = endo_nbr;
orig_model.orig_endo_nbr = M_.orig_endo_nbr;
orig_model.aux_vars = M_.aux_vars;
orig_model.endo_names = endo_names;
orig_model.lead_lag_incidence = i_leadlag;
orig_model.maximum_lead = max_lead;
orig_model.maximum_endo_lead = max_endo_lead;
orig_model.maximum_lag = max_lag;
orig_model.maximum_endo_lag = max_endo_lag;
% storing original values
orig_model.endo_nbr = endo_nbr;
orig_model.orig_endo_nbr = M_.orig_endo_nbr;
orig_model.aux_vars = M_.aux_vars;
orig_model.endo_names = endo_names;
orig_model.lead_lag_incidence = i_leadlag;
orig_model.maximum_lead = max_lead;
orig_model.maximum_endo_lead = max_endo_lead;
orig_model.maximum_lag = max_lag;
orig_model.maximum_endo_lag = max_endo_lag;
y = repmat(ys,1,max_lag+max_lead+1);
k = find(i_leadlag');
y = repmat(ys,1,max_lag+max_lead+1);
k = find(i_leadlag');
% retrieving derivatives of the objective function
[U,Uy,Uyy] = feval([fname '_objective_static'],ys,zeros(1,exo_nbr), M_.params);
Uy = Uy';
Uyy = reshape(Uyy,endo_nbr,endo_nbr);
% retrieving derivatives of the objective function
[U,Uy,Uyy] = feval([fname '_objective_static'],ys,zeros(1,exo_nbr), M_.params);
Uy = Uy';
Uyy = reshape(Uyy,endo_nbr,endo_nbr);
% retrieving derivatives of original model
[f,fJ,fH] = feval([fname '_dynamic'],y(k),[oo_.exo_simul oo_.exo_det_simul], M_.params, it_);
instr_nbr = endo_nbr - size(f,1);
mult_nbr = endo_nbr-instr_nbr;
% retrieving derivatives of original model
[f,fJ,fH] = feval([fname '_dynamic'],y(k),[oo_.exo_simul oo_.exo_det_simul], M_.params, it_);
instr_nbr = endo_nbr - size(f,1);
mult_nbr = endo_nbr-instr_nbr;
% parameters for expanded model
endo_nbr1 = 2*endo_nbr-instr_nbr+exo_nbr;
max_lead1 = max_lead + max_lag;
max_lag1 = max_lead1;
max_leadlag1 = max_lead1;
% parameters for expanded model
endo_nbr1 = 2*endo_nbr-instr_nbr+exo_nbr;
max_lead1 = max_lead + max_lag;
max_lag1 = max_lead1;
max_leadlag1 = max_lead1;
% adding new variables names
endo_names1 = endo_names;
% adding shocks to endogenous variables
endo_names1 = strvcat(endo_names1, exo_names);
% adding multipliers names
for i=1:mult_nbr;
% adding new variables names
endo_names1 = endo_names;
% adding shocks to endogenous variables
endo_names1 = strvcat(endo_names1, exo_names);
% adding multipliers names
for i=1:mult_nbr;
endo_names1 = strvcat(endo_names1,['mult_' int2str(i)]);
end
end
% expanding matrix of lead/lag incidence
%
% multipliers lead/lag incidence
i_mult = [];
for i=1:leadlag_nbr
% expanding matrix of lead/lag incidence
%
% multipliers lead/lag incidence
i_mult = [];
for i=1:leadlag_nbr
i_mult = [any(fJ(:,nonzeros(i_leadlag(i,:))) ~= 0,2)' ; i_mult];
end
% putting it all together:
% original variables, exogenous variables made endogenous, multipliers
%
% number of original dynamic variables
n_dyn = nnz(i_leadlag);
% numbering columns of dynamic multipliers to be put in the last columns
% of the new Jacobian
i_leadlag1 = [cumsum(i_leadlag(1:max_lag,:),1); ...
end
% putting it all together:
% original variables, exogenous variables made endogenous, multipliers
%
% number of original dynamic variables
n_dyn = nnz(i_leadlag);
% numbering columns of dynamic multipliers to be put in the last columns
% of the new Jacobian
i_leadlag1 = [cumsum(i_leadlag(1:max_lag,:),1); ...
repmat(i_leadlag(max_lag+1,:),leadlag_nbr,1); ...
flipud(cumsum(flipud(i_leadlag(max_lag+2:end,:)),1))];
i_leadlag1 = i_leadlag1';
k = find(i_leadlag1 > 0);
n = length(k);
i_leadlag1(k) = 1:n;
i_leadlag1 = i_leadlag1';
i_mult = i_mult';
k = find(i_mult > 0);
i_mult(k) = n+leadlag_nbr*exo_nbr+(1:length(k));
i_mult = i_mult';
i_leadlag1 = [ i_leadlag1 ...
i_leadlag1 = i_leadlag1';
k = find(i_leadlag1 > 0);
n = length(k);
i_leadlag1(k) = 1:n;
i_leadlag1 = i_leadlag1';
i_mult = i_mult';
k = find(i_mult > 0);
i_mult(k) = n+leadlag_nbr*exo_nbr+(1:length(k));
i_mult = i_mult';
i_leadlag1 = [ i_leadlag1 ...
[zeros(max_lag,exo_nbr);...
reshape(n+(1:leadlag_nbr*exo_nbr),exo_nbr,leadlag_nbr)'; ...
zeros(max_lead,exo_nbr)] ...
[zeros(max_lag,mult_nbr);...
i_mult;...
zeros(max_lead,mult_nbr)]];
i_leadlag1 = i_leadlag1';
k = find(i_leadlag1 > 0);
n = length(k);
i_leadlag1(k) = 1:n;
i_leadlag1 = i_leadlag1';
i_leadlag1 = i_leadlag1';
k = find(i_leadlag1 > 0);
n = length(k);
i_leadlag1(k) = 1:n;
i_leadlag1 = i_leadlag1';
% building Jacobian of expanded model
jacobian = zeros(endo_nbr+mult_nbr,nnz(i_leadlag1)+exo_nbr);
% derivatives of f.o.c. w.r. to endogenous variables
% to be rearranged further down
lbarfH = lbar'*fH;
% indices of Hessian columns
n1 = nnz(i_leadlag)+exo_nbr;
iH = reshape(1:n1^2,n1,n1);
J = zeros(endo_nbr1,nnz(i_leadlag1)+exo_nbr);
% second order derivatives of objective function
J(1:endo_nbr,i_leadlag1(max_leadlag1+1,1:endo_nbr)) = Uyy;
% loop on lead/lags in expanded model
for i=1:2*max_leadlag1 + 1
% building Jacobian of expanded model
jacobian = zeros(endo_nbr+mult_nbr,nnz(i_leadlag1)+exo_nbr);
% derivatives of f.o.c. w.r. to endogenous variables
% to be rearranged further down
lbarfH = lbar'*fH;
% indices of Hessian columns
n1 = nnz(i_leadlag)+exo_nbr;
iH = reshape(1:n1^2,n1,n1);
J = zeros(endo_nbr1,nnz(i_leadlag1)+exo_nbr);
% second order derivatives of objective function
J(1:endo_nbr,i_leadlag1(max_leadlag1+1,1:endo_nbr)) = Uyy;
% loop on lead/lags in expanded model
for i=1:2*max_leadlag1 + 1
% index of variables at the current lag in expanded model
kc = find(i_leadlag1(i,i_endo_nbr) > 0);
t1 = max(1,i-max_leadlag1);
@ -158,82 +158,82 @@ function [J,M_] = dyn_ramsey_dynamic_(ys,lbar,M_,options_,oo_,it_)
J(ir,kc2) = J(ir,kc2) + beta^(j-max_lead-1)...
*reshape(lbarfH(iH(kr1,kc1)),length(kr1),length(kc1));
end
end
% derivatives w.r. aux. variables for lead/lag exogenous shocks
for i=1:leadlag_nbr
end
% derivatives w.r. aux. variables for lead/lag exogenous shocks
for i=1:leadlag_nbr
kc = i_leadlag1(max_lag+i,endo_nbr+(1:exo_nbr));
ir = find(i_leadlag(leadlag_nbr+1-i,:) > 0);
kr1 = i_leadlag(leadlag_nbr+1-i,ir);
J(ir,kc) = beta^(i-max_lead-1)...
*reshape(lbarfH(iH(kr1,n_dyn+(1:exo_nbr))),length(kr1), ...
exo_nbr);
end
% derivatives w.r. Lagrange multipliers
for i=1:leadlag_nbr
end
% derivatives w.r. Lagrange multipliers
for i=1:leadlag_nbr
ic1 = find(i_leadlag(leadlag_nbr+1-i,:) > 0);
kc1 = i_leadlag(leadlag_nbr+1-i,ic1);
ic2 = find(i_leadlag1(max_lag+i,endo_nbr+exo_nbr+(1:mult_nbr)) > 0);
kc2 = i_leadlag1(max_lag+i,endo_nbr+exo_nbr+ic2);
J(ic1,kc2) = beta^(i-max_lead-1)*fJ(ic2,kc1)';
end
end
% Jacobian of original equations
%
% w.r. endogenous variables
ir = endo_nbr+(1:endo_nbr-instr_nbr);
for i=1:leadlag_nbr
% Jacobian of original equations
%
% w.r. endogenous variables
ir = endo_nbr+(1:endo_nbr-instr_nbr);
for i=1:leadlag_nbr
ic1 = find(i_leadlag(i,:) > 0);
kc1 = i_leadlag(i,ic1);
ic2 = find(i_leadlag1(max_lead+i,:) > 0);
kc2 = i_leadlag1(max_lead+i,ic2);
[junk,junk,ic3] = intersect(ic1,ic2);
J(ir,kc2(ic3)) = fJ(:,kc1);
end
% w.r. exogenous variables
J(ir,nnz(i_leadlag1)+(1:exo_nbr)) = fJ(:,nnz(i_leadlag)+(1:exo_nbr));
end
% w.r. exogenous variables
J(ir,nnz(i_leadlag1)+(1:exo_nbr)) = fJ(:,nnz(i_leadlag)+(1:exo_nbr));
% auxiliary variable for exogenous shocks
ir = 2*endo_nbr-instr_nbr+(1:exo_nbr);
kc = i_leadlag1(leadlag_nbr,endo_nbr+(1:exo_nbr));
J(ir,kc) = eye(exo_nbr);
J(ir,nnz(i_leadlag1)+(1:exo_nbr)) = -eye(exo_nbr);
% auxiliary variable for exogenous shocks
ir = 2*endo_nbr-instr_nbr+(1:exo_nbr);
kc = i_leadlag1(leadlag_nbr,endo_nbr+(1:exo_nbr));
J(ir,kc) = eye(exo_nbr);
J(ir,nnz(i_leadlag1)+(1:exo_nbr)) = -eye(exo_nbr);
% eliminating empty columns
% eliminating empty columns
% getting indices of nonzero entries
m = find(i_leadlag1');
n1 = max_lag1*endo_nbr1+1;
n2 = n1+endo_nbr-1;
% getting indices of nonzero entries
m = find(i_leadlag1');
n1 = max_lag1*endo_nbr1+1;
n2 = n1+endo_nbr-1;
n = length(m);
k = 1:size(J,2);
n = length(m);
k = 1:size(J,2);
for i=1:n
for i=1:n
if sum(abs(J(:,i))) < 1e-8
if m(i) < n1 | m(i) > n2
k(i) = 0;
m(i) = 0;
end
end
end
end
J = J(:,nonzeros(k));
i_leadlag1 = zeros(size(i_leadlag1))';
i_leadlag1(nonzeros(m)) = 1:nnz(m);
i_leadlag1 = i_leadlag1';
J = J(:,nonzeros(k));
i_leadlag1 = zeros(size(i_leadlag1))';
i_leadlag1(nonzeros(m)) = 1:nnz(m);
i_leadlag1 = i_leadlag1';
% setting expanded model parameters
% storing original values
M_.endo_nbr = endo_nbr1;
% Consider that there is no auxiliary variable, because otherwise it
% interacts badly with the auxiliary variables from the preprocessor.
M_.orig_endo_nbr = endo_nbr1;
M_.aux_vars = [];
M_.endo_names = endo_names1;
M_.lead_lag_incidence = i_leadlag1;
M_.maximum_lead = max_lead1;
M_.maximum_endo_lead = max_lead1;
M_.maximum_lag = max_lag1;
M_.maximum_endo_lag = max_lag1;
M_.orig_model = orig_model;
% setting expanded model parameters
% storing original values
M_.endo_nbr = endo_nbr1;
% Consider that there is no auxiliary variable, because otherwise it
% interacts badly with the auxiliary variables from the preprocessor.
M_.orig_endo_nbr = endo_nbr1;
M_.aux_vars = [];
M_.endo_names = endo_names1;
M_.lead_lag_incidence = i_leadlag1;
M_.maximum_lead = max_lead1;
M_.maximum_endo_lead = max_lead1;
M_.maximum_lag = max_lag1;
M_.maximum_endo_lag = max_lag1;
M_.orig_model = orig_model;

101
matlab/dyn_ramsey_static_.m
View File

@ -32,24 +32,24 @@ function [resids, rJ,mult] = dyn_ramsey_static_(x,M_,options_,oo_,it_)
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
% recovering usefull fields
endo_nbr = M_.endo_nbr;
exo_nbr = M_.exo_nbr;
fname = M_.fname;
% inst_nbr = M_.inst_nbr;
% i_endo_no_inst = M_.endogenous_variables_without_instruments;
max_lead = M_.maximum_lead;
max_lag = M_.maximum_lag;
beta = options_.planner_discount;
% recovering usefull fields
endo_nbr = M_.endo_nbr;
exo_nbr = M_.exo_nbr;
fname = M_.fname;
% inst_nbr = M_.inst_nbr;
% i_endo_no_inst = M_.endogenous_variables_without_instruments;
max_lead = M_.maximum_lead;
max_lag = M_.maximum_lag;
beta = options_.planner_discount;
% indices of all endogenous variables
i_endo = [1:endo_nbr]';
% indices of endogenous variable except instruments
% i_inst = M_.instruments;
% lead_lag incidence matrix for endogenous variables
i_lag = M_.lead_lag_incidence;
% indices of all endogenous variables
i_endo = [1:endo_nbr]';
% indices of endogenous variable except instruments
% i_inst = M_.instruments;
% lead_lag incidence matrix for endogenous variables
i_lag = M_.lead_lag_incidence;
if options_.steadystate_flag
if options_.steadystate_flag
k_inst = [];
instruments = options_.instruments;
for i = 1:size(instruments,1)
@ -72,67 +72,66 @@ function [resids, rJ,mult] = dyn_ramsey_static_(x,M_,options_,oo_,it_)
error([M_.fname '_steadystate.m doesn''t match the model']);
end
end
end
end
% value and Jacobian of objective function
ex = zeros(1,M_.exo_nbr);
[U,Uy,Uyy] = feval([fname '_objective_static'],x(i_endo),ex, M_.params);
Uy = Uy';
Uyy = reshape(Uyy,endo_nbr,endo_nbr);
% value and Jacobian of objective function
ex = zeros(1,M_.exo_nbr);
[U,Uy,Uyy] = feval([fname '_objective_static'],x(i_endo),ex, M_.params);
Uy = Uy';
Uyy = reshape(Uyy,endo_nbr,endo_nbr);
y = repmat(x(i_endo),1,max_lag+max_lead+1);
% value and Jacobian of dynamic function
k = find(i_lag');
it_ = 1;
y = repmat(x(i_endo),1,max_lag+max_lead+1);
% value and Jacobian of dynamic function
k = find(i_lag');
it_ = 1;
% [f,fJ,fH] = feval([fname '_dynamic'],y(k),ex);
[f,fJ] = feval([fname '_dynamic'],y(k),[oo_.exo_simul oo_.exo_det_simul], M_.params, it_);
% indices of Lagrange multipliers
inst_nbr = endo_nbr - size(f,1);
i_mult = [endo_nbr+1:2*endo_nbr-inst_nbr]';
[f,fJ] = feval([fname '_dynamic'],y(k),[oo_.exo_simul oo_.exo_det_simul], M_.params, it_);
% indices of Lagrange multipliers
inst_nbr = endo_nbr - size(f,1);
i_mult = [endo_nbr+1:2*endo_nbr-inst_nbr]';
% derivatives of Lagrangian with respect to endogenous variables
% derivatives of Lagrangian with respect to endogenous variables
% res1 = Uy;
A = zeros(endo_nbr,endo_nbr-inst_nbr);
for i=1:max_lag+max_lead+1
A = zeros(endo_nbr,endo_nbr-inst_nbr);
for i=1:max_lag+max_lead+1
% select variables present in the model at a given lag
[junk,k1,k2] = find(i_lag(i,:));
% res1(k1) = res1(k1) + beta^(max_lag-i+1)*fJ(:,k2)'*x(i_mult);
% res1(k1) = res1(k1) + beta^(max_lag-i+1)*fJ(:,k2)'*x(i_mult);
A(k1,:) = A(k1,:) + beta^(max_lag-i+1)*fJ(:,k2)';
end
end
% i_inst = var_index(options_.olr_inst);
% k = setdiff(1:size(A,1),i_inst);
% mult = -A(k,:)\Uy(k);
mult = -A\Uy;
mult = -A\Uy;
% resids = [f; Uy(i_inst)+A(i_inst,:)*mult];
resids1 = Uy+A*mult;
resids1 = Uy+A*mult;
% resids = [f; sqrt(resids1'*resids1/endo_nbr)];
[q,r,e] = qr([A Uy]');
if options_.steadystate_flag
[q,r,e] = qr([A Uy]');
if options_.steadystate_flag
resids = [r(end,(endo_nbr-inst_nbr+1:end))'];
else
else
resids = [f; r(end,(endo_nbr-inst_nbr+1:end))'];
end
rJ = [];
return;
end
rJ = [];
return;
% Jacobian of first order conditions
n = nnz(i_lag)+exo_nbr;
iH = reshape(1:n^2,n,n);
rJ = zeros(2*endo_nbr-inst_nbr,2*endo_nbr-inst_nbr);
% Jacobian of first order conditions
n = nnz(i_lag)+exo_nbr;
iH = reshape(1:n^2,n,n);
rJ = zeros(2*endo_nbr-inst_nbr,2*endo_nbr-inst_nbr);
rJ(i_endo,i_endo) = Uyy;
for i=1:max_lag+max_lead+1
rJ(i_endo,i_endo) = Uyy;
for i=1:max_lag+max_lead+1
% select variables present in the model at a given lag
[junk,k1,k2] = find(i_lag(i,:));
k3 = length(k2);
rJ(k1,k1) = rJ(k1,k1) + beta^(max_lag-i+1)*reshape(fH(:,iH(k2,k2))'*x(i_mult),k3,k3);
rJ(k1,i_mult) = rJ(k1,i_mult) + beta^(max_lag-1+1)*fJ(:,k2)';
rJ(i_mult,k1) = rJ(i_mult,k1) + fJ(:,k2);
end
end
% rJ = 1e-3*rJ;
% rJ(209,210) = rJ(209,210)+1-1e-3;

28
matlab/dynare_graph.m
View File

@ -29,28 +29,28 @@ function dynare_graph(y,tit,x)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global dyn_graph
global dyn_graph
if nargin < 3
if nargin < 3
x = (1:size(y,1))';
end
nplot = dyn_graph.plot_nbr + 1;
if nplot > dyn_graph.max_nplot
end
nplot = dyn_graph.plot_nbr + 1;
if nplot > dyn_graph.max_nplot
figure('Name',dyn_graph.figure_name);
nplot = 1;
end
dyn_graph.plot_nbr = nplot;
subplot(dyn_graph.nr,dyn_graph.nc,nplot);
end
dyn_graph.plot_nbr = nplot;
subplot(dyn_graph.nr,dyn_graph.nc,nplot);
line_types = dyn_graph.line_types;
line_type = line_types{1};
for i=1:size(y,2);
line_types = dyn_graph.line_types;
line_type = line_types{1};
for i=1:size(y,2);
if length(line_types) > 1
line_type = line_types{i};
end
plot(x,y(:,i),line_type);
hold on
end
title(tit);
hold off
end
title(tit);
hold off

27
matlab/dynare_graph_init.m
View File

@ -29,24 +29,24 @@ function dynare_graph_init(figure_name,nplot,line_types,line_width)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global dyn_graph options_
global dyn_graph options_
dyn_graph.fh = figure('Name',figure_name);
dyn_graph.figure_name = figure_name;
if nargin > 2
dyn_graph.fh = figure('Name',figure_name);
dyn_graph.figure_name = figure_name;
if nargin > 2
dyn_graph.line_types = line_types;
else
else
dyn_graph.line_types = options_.graphics.line_types;
end
if nargin > 3
end
if nargin > 3
dyn_graph.line_width = line_width;
else
else
dyn_graph.line_width = options_.graphics.line_width;
end
end
dyn_graph.plot_nbr = 0;
dyn_graph.plot_nbr = 0;
switch(nplot)
switch(nplot)
case 1
dyn_graph.nc = 1;
dyn_graph.nr = 1;
@ -74,6 +74,5 @@ function dynare_graph_init(figure_name,nplot,line_types,line_width)
otherwise
dyn_graph.nc = min(nplot,options_.graphics.ncols);
dyn_graph.nr = min(ceil(nplot/dyn_graph.nc),options_.graphics.nrows);
end
dyn_graph.max_nplot = dyn_graph.nc*dyn_graph.nr;
end
dyn_graph.max_nplot = dyn_graph.nc*dyn_graph.nr;

96
matlab/dynare_identification.m
View File

@ -21,20 +21,20 @@ function [pdraws, TAU, GAM, H, JJ] = dynare_identification(options_ident, pdraws
global M_ options_ oo_ bayestopt_ estim_params_
options_ident = set_default_option(options_ident,'load_ident_files',0);
options_ident = set_default_option(options_ident,'useautocorr',1);
options_ident = set_default_option(options_ident,'ar',3);
options_ident = set_default_option(options_ident,'prior_mc',2000);
if nargin==2,
options_ident = set_default_option(options_ident,'load_ident_files',0);
options_ident = set_default_option(options_ident,'useautocorr',1);
options_ident = set_default_option(options_ident,'ar',3);
options_ident = set_default_option(options_ident,'prior_mc',2000);
if nargin==2,
options_ident.prior_mc=size(pdraws0,1);
end
end
iload = options_ident.load_ident_files;
nlags = options_ident.ar;
useautocorr = options_ident.useautocorr;
options_.ar=nlags;
options_.prior_mc = options_ident.prior_mc;
options_.options_ident = options_ident;
iload = options_ident.load_ident_files;
nlags = options_ident.ar;
useautocorr = options_ident.useautocorr;
options_.ar=nlags;
options_.prior_mc = options_ident.prior_mc;
options_.options_ident = options_ident;
options_ = set_default_option(options_,'datafile',[]);
@ -51,8 +51,8 @@ SampleSize = options_ident.prior_mc;
prior_draw(1,bayestopt_);
if ~(exist('sylvester3mr','file')==2),
dynareroot = strrep(which('dynare'),'dynare.m','');
addpath([dynareroot 'gensylv'])
dynareroot = strrep(which('dynare'),'dynare.m','');
addpath([dynareroot 'gensylv'])
end
IdentifDirectoryName = CheckPath('identification');
@ -70,15 +70,15 @@ MaxNumberOfBytes=options_.MaxNumberOfBytes;
if iload <=0,
iteration = 0;
burnin_iteration = 0;
loop_indx = 0;
file_index = 0;
run_index = 0;
iteration = 0;
burnin_iteration = 0;
loop_indx = 0;
file_index = 0;
run_index = 0;
h = waitbar(0,'Monte Carlo identification checks ...');
h = waitbar(0,'Monte Carlo identification checks ...');
while iteration < SampleSize,
while iteration < SampleSize,
loop_indx = loop_indx+1;
if nargin==2,
if burnin_iteration>=50,
@ -95,11 +95,11 @@ while iteration < SampleSize,
if info(1)==0,
oo0=oo_;
% [Aa,Bb] = kalman_transition_matrix(oo0.dr, ...
% bayestopt_.restrict_var_list, ...
% bayestopt_.restrict_columns, ...
% bayestopt_.restrict_aux, M_.exo_nbr);
% tau=[vec(Aa); vech(Bb*M_.Sigma_e*Bb')];
% [Aa,Bb] = kalman_transition_matrix(oo0.dr, ...
% bayestopt_.restrict_var_list, ...
% bayestopt_.restrict_columns, ...
% bayestopt_.restrict_aux, M_.exo_nbr);
% tau=[vec(Aa); vech(Bb*M_.Sigma_e*Bb')];
tau=[oo_.dr.ys(oo_.dr.order_var); vec(A); vech(B*M_.Sigma_e*B')];
if burnin_iteration<50,
burnin_iteration = burnin_iteration + 1;
@ -144,15 +144,15 @@ while iteration < SampleSize,
stoH(:,:,run_index) = H(indH,:);
stoJJ(:,:,run_index) = JJ(indJJ,:);
% use relative changes
% siJ = abs(JJ(indJJ,:).*(1./gam(indJJ)*params));
% siH = abs(H(indH,:).*(1./tau(indH)*params));
% siJ = abs(JJ(indJJ,:).*(1./gam(indJJ)*params));
% siH = abs(H(indH,:).*(1./tau(indH)*params));
% use prior uncertainty
siJ = abs(JJ(indJJ,:));
siH = abs(H(indH,:));
% siJ = abs(JJ(indJJ,:).*(ones(length(indJJ),1)*bayestopt_.p2'));
% siH = abs(H(indH,:).*(ones(length(indH),1)*bayestopt_.p2'));
% siJ = abs(JJ(indJJ,:).*(1./mGAM'*bayestopt_.p2'));
% siH = abs(H(indH,:).*(1./mTAU'*bayestopt_.p2'));
% siJ = abs(JJ(indJJ,:).*(ones(length(indJJ),1)*bayestopt_.p2'));
% siH = abs(H(indH,:).*(ones(length(indH),1)*bayestopt_.p2'));
% siJ = abs(JJ(indJJ,:).*(1./mGAM'*bayestopt_.p2'));
% siH = abs(H(indH,:).*(1./mTAU'*bayestopt_.p2'));
if iteration ==1,
siJmean = siJ./SampleSize;
@ -183,24 +183,24 @@ while iteration < SampleSize,
waitbar(iteration/SampleSize,h)
end
end
end
end
siJmean = siJmean.*(ones(length(indJJ),1)*std(pdraws));
siHmean = siHmean.*(ones(length(indH),1)*std(pdraws));
siJmean = siJmean.*(ones(length(indJJ),1)*std(pdraws));
siHmean = siHmean.*(ones(length(indH),1)*std(pdraws));
siHmean = siHmean./(max(siHmean')'*ones(size(params)));
siJmean = siJmean./(max(siJmean')'*ones(size(params)));
siHmean = siHmean./(max(siHmean')'*ones(size(params)));
siJmean = siJmean./(max(siJmean')'*ones(size(params)));
close(h)
close(h)
save([IdentifDirectoryName '/' M_.fname '_identif'], 'pdraws', 'idemodel', 'idemoments', ...
save([IdentifDirectoryName '/' M_.fname '_identif'], 'pdraws', 'idemodel', 'idemoments', ...
'siHmean', 'siJmean', 'TAU', 'GAM')
else
load([IdentifDirectoryName '/' M_.fname '_identif'], 'pdraws', 'idemodel', 'idemoments', ...
load([IdentifDirectoryName '/' M_.fname '_identif'], 'pdraws', 'idemodel', 'idemoments', ...
'siHmean', 'siJmean', 'TAU', 'GAM')
options_ident.prior_mc=size(pdraws,1);
SampleSize = options_ident.prior_mc;
options_ident.prior_mc=size(pdraws,1);
SampleSize = options_ident.prior_mc;
options_.options_ident = options_ident;
end
@ -352,9 +352,9 @@ for ip=1:nparam,
text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
end
title('Multicollinearity in the moments')
saveas(gcf,[IdentifDirectoryName,'/',M_.fname,'_ident'])
eval(['print -depsc2 ' IdentifDirectoryName '/' M_.fname '_ident']);
eval(['print -dpdf ' IdentifDirectoryName '/' M_.fname '_ident']);
saveas(gcf,[IdentifDirectoryName,'/',M_.fname,'_ident'])
eval(['print -depsc2 ' IdentifDirectoryName '/' M_.fname '_ident']);
eval(['print -dpdf ' IdentifDirectoryName '/' M_.fname '_ident']);
figure,
@ -364,6 +364,6 @@ title('log10 of Condition number in the model')
subplot(222)
hist(log10(idemoments.cond))
title('log10 of Condition number in the moments')
saveas(gcf,[IdentifDirectoryName,'/',M_.fname,'_ident_COND'])
eval(['print -depsc2 ' IdentifDirectoryName '/' M_.fname '_ident_COND']);
eval(['print -dpdf ' IdentifDirectoryName '/' M_.fname '_ident_COND']);
saveas(gcf,[IdentifDirectoryName,'/',M_.fname,'_ident_COND'])
eval(['print -depsc2 ' IdentifDirectoryName '/' M_.fname '_ident_COND']);
eval(['print -dpdf ' IdentifDirectoryName '/' M_.fname '_ident_COND']);

20
matlab/dynare_resolve.m
View File

@ -40,11 +40,11 @@ function [A,B,ys,info] = dynare_resolve(iv,ic,aux)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global oo_ M_
global oo_ M_
[oo_.dr,info] = resol(oo_.steady_state,0);
[oo_.dr,info] = resol(oo_.steady_state,0);
if info(1) > 0
if info(1) > 0
A = [];
if nargout>1
B = [];
@ -53,9 +53,9 @@ function [A,B,ys,info] = dynare_resolve(iv,ic,aux)
end
end
return
end
end
if nargin == 0
if nargin == 0
endo_nbr = M_.endo_nbr;
nstatic = oo_.dr.nstatic;
npred = oo_.dr.npred;
@ -65,12 +65,12 @@ function [A,B,ys,info] = dynare_resolve(iv,ic,aux)
k = find(aux(:,2) > npred);
aux(:,2) = aux(:,2) + nstatic;
aux(k,2) = aux(k,2) + oo_.dr.nfwrd;
end
end
if nargout==1
if nargout==1
A = kalman_transition_matrix(oo_.dr,iv,ic,aux,M_.exo_nbr);
return
end
end
[A,B] = kalman_transition_matrix(oo_.dr,iv,ic,aux,M_.exo_nbr);
ys = oo_.dr.ys;
[A,B] = kalman_transition_matrix(oo_.dr,iv,ic,aux,M_.exo_nbr);
ys = oo_.dr.ys;

76
matlab/dynare_sensitivity.m
View File

@ -234,19 +234,19 @@ if options_gsa.rmse,
if isempty(a),
dynare_MC([],OutputDirectoryName);
options_gsa.load_rmse=0;
% else
% if options_gsa.load_rmse==0,
% disp('You already saved a MC filter/smoother analysis ')
% disp('Do you want to overwrite ?')
% pause;
% if options_gsa.pprior
% delete([OutputDirectoryName,'/',fname_,'_prior_*.mat'])
% else
% delete([OutputDirectoryName,'/',fname_,'_mc_*.mat'])
% end
% dynare_MC([],OutputDirectoryName);
% options_gsa.load_rmse=0;
% end
% else
% if options_gsa.load_rmse==0,
% disp('You already saved a MC filter/smoother analysis ')
% disp('Do you want to overwrite ?')
% pause;
% if options_gsa.pprior
% delete([OutputDirectoryName,'/',fname_,'_prior_*.mat'])
% else
% delete([OutputDirectoryName,'/',fname_,'_mc_*.mat'])
% end
% dynare_MC([],OutputDirectoryName);
% options_gsa.load_rmse=0;
% end
end
end
@ -296,12 +296,12 @@ if options_gsa.glue,
jxj = strmatch(vj,lgy_(dr_.order_var,:),'exact');
js = strmatch(vj,lgy_,'exact');
if ~options_gsa.ppost
% y0=zeros(gend+1,nruns);
% nb = size(stock_filter,3);
% y0 = squeeze(stock_filter(:,jxj,:)) + ...
% kron(stock_ys(js,:),ones(size(stock_filter,1),1));
% Out(j).data = y0';
% Out(j).time = [1:size(y0,1)];
% y0=zeros(gend+1,nruns);
% nb = size(stock_filter,3);
% y0 = squeeze(stock_filter(:,jxj,:)) + ...
% kron(stock_ys(js,:),ones(size(stock_filter,1),1));
% Out(j).data = y0';
% Out(j).time = [1:size(y0,1)];
Out(j).data = jxj;
Out(j).time = [pwd,'/',OutputDirectoryName];
else
@ -316,12 +316,12 @@ if options_gsa.glue,
Lik(j).data = rmse_MC(:,j)';
if ~options_gsa.ppost
% y0 = squeeze(stock_smooth(:,jxj,:)) + ...
% kron(stock_ys(js,:),ones(size(stock_smooth,1),1));
% Out1(j).name = vj;
% Out1(j).ini = 'yes';
% Out1(j).time = [1:size(y0,1)];
% Out1(j).data = y0';
% y0 = squeeze(stock_smooth(:,jxj,:)) + ...
% kron(stock_ys(js,:),ones(size(stock_smooth,1),1));
% Out1(j).name = vj;
% Out1(j).ini = 'yes';
% Out1(j).time = [1:size(y0,1)];
% Out1(j).data = y0';
Out1=Out;
else
Out1=Out;
@ -335,10 +335,10 @@ if options_gsa.glue,
jsmoo=jsmoo+1;
vj=deblank(M_.endo_names(dr_.order_var(j),:));
if ~options_gsa.ppost
% y0 = squeeze(stock_smooth(:,j,:)) + ...
% kron(stock_ys(j,:),ones(size(stock_smooth,1),1));
% Out1(jsmoo).time = [1:size(y0,1)];
% Out1(jsmoo).data = y0';
% y0 = squeeze(stock_smooth(:,j,:)) + ...
% kron(stock_ys(j,:),ones(size(stock_smooth,1),1));
% Out1(jsmoo).time = [1:size(y0,1)];
% Out1(jsmoo).data = y0';
Out1(jsmoo).data = j;
Out1(jsmoo).time = [pwd,'/',OutputDirectoryName];
else
@ -370,9 +370,9 @@ if options_gsa.glue,
Info.order_var=dr_.order_var;
Out=Out1;
if options_gsa.ppost
% Info.dynare=M_.fname;
% Info.order_var=dr_.order_var;
% Out=Out1;
% Info.dynare=M_.fname;
% Info.order_var=dr_.order_var;
% Out=Out1;
Info.TypeofSample='post';
save([OutputDirectoryName,'/',fname_,'_glue_post'], 'Out', 'Sam', 'Lik', 'Obs', 'Rem','Info', 'Exo')
%save([fname_,'_post_glue_smooth'], 'Out', 'Sam', 'Lik', 'Obs', 'Rem','Info')
@ -381,15 +381,15 @@ if options_gsa.glue,
if options_gsa.pprior
Info.TypeofSample='prior';
save([OutputDirectoryName,'/',fname_,'_glue_prior'], 'Out', 'Sam', 'Lik', 'Obs', 'Rem','Info', 'Exo')
% save([OutputDirectoryName,'/',fname_,'_prior_glue'], 'Out', 'Sam', 'Lik', 'Obs', 'Rem')
% Out=Out1;
% save([OutputDirectoryName,'/',fname_,'_prior_glue_smooth'], 'Out', 'Sam', 'Lik', 'Obs', 'Rem')
% save([OutputDirectoryName,'/',fname_,'_prior_glue'], 'Out', 'Sam', 'Lik', 'Obs', 'Rem')
% Out=Out1;
% save([OutputDirectoryName,'/',fname_,'_prior_glue_smooth'], 'Out', 'Sam', 'Lik', 'Obs', 'Rem')
else
Info.TypeofSample='mc';
save([OutputDirectoryName,'/',fname_,'_glue_mc'], 'Out', 'Sam', 'Lik', 'Obs', 'Rem','Info', 'Exo')
% save([OutputDirectoryName,'/',fname_,'_mc_glue'], 'Out', 'Sam', 'Lik', 'Obs', 'Rem')
% Out=Out1;
% save([OutputDirectoryName,'/',fname_,'_mc_glue_smooth'], 'Out', 'Sam', 'Lik', 'Obs', 'Rem')
% save([OutputDirectoryName,'/',fname_,'_mc_glue'], 'Out', 'Sam', 'Lik', 'Obs', 'Rem')
% Out=Out1;
% save([OutputDirectoryName,'/',fname_,'_mc_glue_smooth'], 'Out', 'Sam', 'Lik', 'Obs', 'Rem')
end
end

18
matlab/dynare_solve.m
View File

@ -33,11 +33,11 @@ function [x,info] = dynare_solve(func,x,jacobian_flag,varargin)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global options_
global options_
options_ = set_default_option(options_,'solve_algo',2);
info = 0;
if options_.solve_algo == 0
options_ = set_default_option(options_,'solve_algo',2);
info = 0;
if options_.solve_algo == 0
if exist('OCTAVE_VERSION') || isempty(ver('optim'))
% Note that fsolve() exists under Octave, but has a different syntax
% So we fail for the moment under Octave, until we add the corresponding code
@ -59,10 +59,10 @@ function [x,info] = dynare_solve(func,x,jacobian_flag,varargin)
else
info = 1;
end
elseif options_.solve_algo == 1
elseif options_.solve_algo == 1
nn = size(x,1);
[x,info]=solve1(func,x,1:nn,1:nn,jacobian_flag,1,varargin{:});
elseif options_.solve_algo == 2 || options_.solve_algo == 4
elseif options_.solve_algo == 2 || options_.solve_algo == 4
nn = size(x,1) ;
tolf = options_.solve_tolf ;
@ -118,12 +118,12 @@ function [x,info] = dynare_solve(func,x,jacobian_flag,varargin)
if max(abs(fvec)) > tolf
[x,info]=solve1(func,x,1:nn,1:nn,jacobian_flag, bad_cond_flag, varargin{:});
end
elseif options_.solve_algo == 3
elseif options_.solve_algo == 3
if jacobian_flag
[x,info] = csolve(func,x,func,1e-6,500,varargin{:});
else
[x,info] = csolve(func,x,[],1e-6,500,varargin{:});
end
else
else
error('DYNARE_SOLVE: option solve_algo must be one of [0,1,2,3,4]')
end
end

8
matlab/dynare_squeeze.m
View File

@ -18,9 +18,9 @@ function B = dynare_squeeze(A);
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
sizA = size(A);
dimA = length(sizA);
switch dimA
sizA = size(A);
dimA = length(sizA);
switch dimA
case 1
B = A;
case 2
@ -33,4 +33,4 @@ function B = dynare_squeeze(A);
end
otherwise
B = squeeze(A);
end
end

14
matlab/dynasave.m
View File

@ -29,22 +29,22 @@ function dynasave(s,var_list)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_ oo_
global M_ oo_
if size(var_list,1) == 0
if size(var_list,1) == 0
var_list = M_.endo_names(1:M_.orig_endo_nbr, :);
end
end
n = size(var_list,1);
ivar=zeros(n,1);
for i=1:n
n = size(var_list,1);
ivar=zeros(n,1);
for i=1:n
i_tmp = strmatch(var_list(i,:),M_.endo_names,'exact');
if isempty(i_tmp)
error (['One of the specified variables does not exist']) ;
else
ivar(i) = i_tmp;
end
end
end
% dyn2vec(var_list(1),var_list(1));
eval([var_list(1) '=oo_.endo_simul(ivar(1),:)'';'])

6
matlab/dynatype.m
View File

@ -39,15 +39,15 @@ if size(var_list,1) == 0
end
n = size(var_list,1);
ivar=zeros(n,1);
for i=1:n
ivar=zeros(n,1);
for i=1:n
i_tmp = strmatch(var_list(i,:),M_.endo_names,'exact');
if isempty(i_tmp)
error (['One of the specified variables does not exist']) ;
else
ivar(i) = i_tmp;
end
end
end
for i = 1:n
fprintf(fid,M_.endo_names(ivar(i),:),'\n') ;

10
matlab/dynsec2hms.m
View File

@ -18,8 +18,8 @@ function hms = dynsec2hms(secs)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
secs = round(secs);
s = rem(secs, 60);
m = rem(floor(secs / 60), 60);
h = floor(secs / 3600);
hms = sprintf('%dh%02dm%02ds', h, m, s);
secs = round(secs);
s = rem(secs, 60);
m = rem(floor(secs / 60), 60);
h = floor(secs / 3600);
hms = sprintf('%dh%02dm%02ds', h, m, s);

28
matlab/dyntable.m
View File

@ -18,31 +18,31 @@ function dyntable(title,headers,labels,values,label_width,val_width, ...
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global options_
global options_
if options_.noprint
if options_.noprint
return
end
end
label_width = max(size(deblank(strvcat(headers(1,:),labels)),2)+2, ...
label_width = max(size(deblank(strvcat(headers(1,:),labels)),2)+2, ...
label_width);
val_width = max(size(deblank(headers(2:end,:)),2)+2,val_width);
label_fmt = sprintf('%%-%ds',label_width);
header_fmt = sprintf('%%-%ds',val_width);
val_fmt = sprintf('%%%d.%df',val_width,val_precis);
if length(title) > 0
val_width = max(size(deblank(headers(2:end,:)),2)+2,val_width);
label_fmt = sprintf('%%-%ds',label_width);
header_fmt = sprintf('%%-%ds',val_width);
val_fmt = sprintf('%%%d.%df',val_width,val_precis);
if length(title) > 0
disp(sprintf('\n\n%s\n',title));
end
if length(headers) > 0
end
if length(headers) > 0
hh = sprintf(label_fmt,headers(1,:));
hh = [hh char(32*ones(1,floor(val_width/4)))];
for i=2:size(headers,1)
hh = [hh sprintf(header_fmt,headers(i,:))];
end
disp(hh);
end
for i=1:size(values,1)
end
for i=1:size(values,1)
disp([sprintf(label_fmt,labels(i,:)) sprintf(val_fmt,values(i,:))]);
end
end
% 10/30/02 MJ

4
matlab/erase_compiled_function.m
View File

@ -18,7 +18,7 @@ function erase_compiled_function(func)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
if exist([func '.' mexext])
if exist([func '.' mexext])
clear(func)
delete([func '.' mexext])
end
end

28
matlab/evaluate_likelihood.m
View File

@ -35,16 +35,16 @@ function [llik,parameters] = evaluate_likelihood(parameters)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global options_ M_ bayestopt_ oo_
global options_ M_ bayestopt_ oo_
persistent load_data
persistent gend data data_index number_of_observations no_more_missing_observations
persistent load_data
persistent gend data data_index number_of_observations no_more_missing_observations
if nargin==0
if nargin==0
parameters = 'posterior mode';
end
end
if ischar(parameters)
if ischar(parameters)
switch parameters
case 'posterior mode'
parameters = get_posterior_parameters('mode');
@ -65,9 +65,9 @@ function [llik,parameters] = evaluate_likelihood(parameters)
disp(' ''prior mean''.')
error
end
end
end
if isempty(load_data)
if isempty(load_data)
% Get the data.
n_varobs = size(options_.varobs,1);
rawdata = read_variables(options_.datafile,options_.varobs,[],options_.xls_sheet,options_.xls_range);
@ -131,12 +131,12 @@ function [llik,parameters] = evaluate_likelihood(parameters)
options_.noconstant = 0;
end
load_data = 1;
end
end
pshape_original = bayestopt_.pshape;
bayestopt_.pshape = Inf(size(bayestopt_.pshape));
clear('priordens')%
pshape_original = bayestopt_.pshape;
bayestopt_.pshape = Inf(size(bayestopt_.pshape));
clear('priordens')%
llik = -DsgeLikelihood(parameters,gend,data,data_index,number_of_observations,no_more_missing_observations);
llik = -DsgeLikelihood(parameters,gend,data,data_index,number_of_observations,no_more_missing_observations);
bayestopt_.pshape = pshape_original;
bayestopt_.pshape = pshape_original;

8
matlab/evaluate_posterior_kernel.m
View File

@ -34,8 +34,8 @@ function lpkern = evaluate_posterior_kernel(parameters,llik)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
[ldens,parameters] = evaluate_prior(parameters);
if nargin==1
[ldens,parameters] = evaluate_prior(parameters);
if nargin==1
llik = evaluate_likelihood(parameters);
end
lpkern = ldens+llik;
end
lpkern = ldens+llik;

14
matlab/evaluate_prior.m
View File

@ -33,13 +33,13 @@ function [ldens,parameters] = evaluate_prior(parameters)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global bayestopt_
global bayestopt_
if nargin==0
if nargin==0
parameters = 'posterior mode';
end
end
if ischar(parameters)
if ischar(parameters)
switch parameters
case 'posterior mode'
parameters = get_posterior_parameters('mode');
@ -60,6 +60,6 @@ function [ldens,parameters] = evaluate_prior(parameters)
disp(' ''prior mean''.')
error
end
end
clear('priordens');
ldens = priordens(parameters, bayestopt_.pshape, bayestopt_.p6, bayestopt_.p7, bayestopt_.p3, bayestopt_.p4);
end
clear('priordens');
ldens = priordens(parameters, bayestopt_.pshape, bayestopt_.p6, bayestopt_.p7, bayestopt_.p3, bayestopt_.p4);

130
matlab/extended_path.m
View File

@ -1,68 +1,68 @@
function time_series = extended_path(initial_conditions,sample_size,init)
% Stochastic simulation of a non linear DSGE model using the Extended Path method (Fair and Taylor 1983). A time
% series of size T is obtained by solving T perfect foresight models.
%
% INPUTS
% o initial_conditions [double] m*nlags array, where m is the number of endogenous variables in the model and
% nlags is the maximum number of lags.
% o sample_size [integer] scalar, size of the sample to be simulated.
%
% OUTPUTS
% o time_series [double] m*sample_size array, the simulations.
%
% ALGORITHM
%
% SPECIAL REQUIREMENTS
% series of size T is obtained by solving T perfect foresight models.
%
% INPUTS
% o initial_conditions [double] m*nlags array, where m is the number of endogenous variables in the model and
% nlags is the maximum number of lags.
% o sample_size [integer] scalar, size of the sample to be simulated.
%
% OUTPUTS
% o time_series [double] m*sample_size array, the simulations.
%
% ALGORITHM
%
% SPECIAL REQUIREMENTS
% Copyright (C) 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/>.
global M_ oo_ options_
% Copyright (C) 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/>.
global M_ oo_ options_
% Set default initial conditions.
if isempty(initial_conditions)
% Set default initial conditions.
if isempty(initial_conditions)
initial_conditions = repmat(oo_.steady_state,1,M_.maximum_lag);
end
end
% Copy sample_size to periods.
options_.periods = sample_size;
% Copy sample_size to periods.
options_.periods = sample_size;
% Initialize the exogenous variables.
make_ex_;
% Initialize the exogenous variables.
make_ex_;
% Initialize the endogenous variables.
make_y_;
% Initialize the endogenous variables.
make_y_;
% Initialize the output array.
time_series = NaN(M_.endo_nbr,sample_size+1);
% Initialize the output array.
time_series = NaN(M_.endo_nbr,sample_size+1);
% Set the covariance matrix of the structural innovations.
variances = diag(M_.Sigma_e);
positive_var_indx = find(variances>0);
covariance_matrix = M_.Sigma_e(positive_var_indx,positive_var_indx);
number_of_structural_innovations = length(covariance_matrix);
covariance_matrix_upper_cholesky = chol(covariance_matrix);
% Set the covariance matrix of the structural innovations.
variances = diag(M_.Sigma_e);
positive_var_indx = find(variances>0);
covariance_matrix = M_.Sigma_e(positive_var_indx,positive_var_indx);
number_of_structural_innovations = length(covariance_matrix);
covariance_matrix_upper_cholesky = chol(covariance_matrix);
tdx = M_.maximum_lag+1;
norme = 0;
tdx = M_.maximum_lag+1;
norme = 0;
% Set verbose option
verbose = 0;
% Set verbose option
verbose = 0;
for t=1:sample_size
for t=1:sample_size
shocks = exp(randn(1,number_of_structural_innovations)*covariance_matrix_upper_cholesky-.5*variances(positive_var_indx)');
oo_.exo_simul(tdx,positive_var_indx) = shocks;
info = perfect_foresight_simulation;
@ -87,17 +87,17 @@ function time_series = extended_path(initial_conditions,sample_size,init)
time_series(:,t+1) = oo_.endo_simul(:,tdx);
oo_.endo_simul(:,1:end-1) = oo_.endo_simul(:,2:end);
oo_.endo_simul(:,end) = oo_.steady_state;
end
end
function info = homotopic_steps(tdx,positive_var_indx,shocks,init_weight,step)
global oo_
weight = init_weight;
verbose = 0;
iter = 0;
time = 0;
reduce_step = 0;
while iter<=100 && weight<=1
global oo_
weight = init_weight;
verbose = 0;
iter = 0;
time = 0;
reduce_step = 0;
while iter<=100 && weight<=1
iter = iter+1;
old_weight = weight;
weight = weight+step;
@ -122,15 +122,15 @@ function info = homotopic_steps(tdx,positive_var_indx,shocks,init_weight,step)
step = step*1.5;
end
end
end
if reduce_step
end
if reduce_step
step=step/1.5;
info = homotopic_steps(tdx,positive_var_indx,shocks,old_weight,step);
time = time+info.time;
elseif weight<1 && iter<100
elseif weight<1 && iter<100
oo_.exo_simul(tdx,positive_var_indx) = shocks;
info = perfect_foresight_simulation;
info.time = info.time+time;
else
else
info.time = time;
end
end

6
matlab/f_var.m
View File

@ -17,6 +17,6 @@ function b=f_var(x,a,nx)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
x=reshape(x,nx,nx);
b=x-a*x*a';
b=b(:);
x=reshape(x,nx,nx);
b=x-a*x*a';
b=b(:);

55
matlab/forcst.m
View File

@ -34,23 +34,23 @@ function [yf,int_width]=forcst(dr,y0,horizon,var_list)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_ oo_ options_
global M_ oo_ options_
make_ex_;
yf = simult_(y0,dr,zeros(horizon,M_.exo_nbr),1);
nstatic = dr.nstatic;
npred = dr.npred;
nc = size(dr.ghx,2);
endo_nbr = M_.endo_nbr;
inv_order_var = dr.inv_order_var;
[A,B] = kalman_transition_matrix(dr,nstatic+(1:npred),1:nc,dr.transition_auxiliary_variables,M_.exo_nbr);
make_ex_;
yf = simult_(y0,dr,zeros(horizon,M_.exo_nbr),1);
nstatic = dr.nstatic;
npred = dr.npred;
nc = size(dr.ghx,2);
endo_nbr = M_.endo_nbr;
inv_order_var = dr.inv_order_var;
[A,B] = kalman_transition_matrix(dr,nstatic+(1:npred),1:nc,dr.transition_auxiliary_variables,M_.exo_nbr);
if size(var_list,1) == 0
if size(var_list,1) == 0
var_list = M_.endo_names(1:M_.orig_endo_nbr,:);
end
nvar = size(var_list,1);
ivar=zeros(nvar,1);
for i=1:nvar
end
nvar = size(var_list,1);
ivar=zeros(nvar,1);
for i=1:nvar
i_tmp = strmatch(var_list(i,:),M_.endo_names,'exact');
if isempty(i_tmp)
disp(var_list(i,:));
@ -58,16 +58,16 @@ function [yf,int_width]=forcst(dr,y0,horizon,var_list)
else
ivar(i) = i_tmp;
end
end
end
ghx1 = dr.ghx(inv_order_var(ivar),:);
ghu1 = dr.ghu(inv_order_var(ivar),:);
ghx1 = dr.ghx(inv_order_var(ivar),:);
ghu1 = dr.ghu(inv_order_var(ivar),:);
sigma_u = B*M_.Sigma_e*B';
sigma_u1 = ghu1*M_.Sigma_e*ghu1';
sigma_y = 0;
sigma_u = B*M_.Sigma_e*B';
sigma_u1 = ghu1*M_.Sigma_e*ghu1';
sigma_y = 0;
for i=1:horizon
for i=1:horizon
sigma_y1 = ghx1*sigma_y*ghx1'+sigma_u1;
var_yf(i,:) = diag(sigma_y1)';
if i == horizon
@ -75,14 +75,13 @@ function [yf,int_width]=forcst(dr,y0,horizon,var_list)
end
sigma_u = A*sigma_u*A';
sigma_y = sigma_y+sigma_u;
end
end
fact = norminv((1-options_.conf_sig)/2,0,1);
fact = norminv((1-options_.conf_sig)/2,0,1);
int_width = zeros(horizon,M_.endo_nbr);
for i=1:nvar
int_width = zeros(horizon,M_.endo_nbr);
for i=1:nvar
int_width(:,i) = fact*sqrt(var_yf(:,i));
end
yf = yf(ivar,:);
end
yf = yf(ivar,:);

50
matlab/forcst2.m
View File

@ -17,44 +17,44 @@ function yf=forcst2(y0,horizon,dr,n)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_ options_
global M_ options_
Sigma_e_ = M_.Sigma_e;
endo_nbr = M_.endo_nbr;
exo_nbr = M_.exo_nbr;
ykmin_ = M_.maximum_endo_lag;
Sigma_e_ = M_.Sigma_e;
endo_nbr = M_.endo_nbr;
exo_nbr = M_.exo_nbr;
ykmin_ = M_.maximum_endo_lag;
order = options_.order;
seed = options_.simul_seed;
order = options_.order;
seed = options_.simul_seed;
k1 = [ykmin_:-1:1];
k2 = dr.kstate(find(dr.kstate(:,2) <= ykmin_+1),[1 2]);
k2 = k2(:,1)+(ykmin_+1-k2(:,2))*endo_nbr;
k1 = [ykmin_:-1:1];
k2 = dr.kstate(find(dr.kstate(:,2) <= ykmin_+1),[1 2]);
k2 = k2(:,1)+(ykmin_+1-k2(:,2))*endo_nbr;
it_ = ykmin_ + 1 ;
it_ = ykmin_ + 1 ;
% eliminate shocks with 0 variance
i_exo_var = setdiff([1:exo_nbr],find(diag(Sigma_e_) == 0));
nxs = length(i_exo_var);
% eliminate shocks with 0 variance
i_exo_var = setdiff([1:exo_nbr],find(diag(Sigma_e_) == 0));
nxs = length(i_exo_var);
chol_S = chol(Sigma_e_(i_exo_var,i_exo_var));
chol_S = chol(Sigma_e_(i_exo_var,i_exo_var));
if ~isempty(Sigma_e_)
if ~isempty(Sigma_e_)
e = randn(nxs,n,horizon);
end
end
B1 = dr.ghu(:,i_exo_var)*chol_S';
B1 = dr.ghu(:,i_exo_var)*chol_S';
yf = zeros(endo_nbr,horizon+ykmin_,n);
yf(:,1:ykmin_,:,:) = repmat(y0,[1,1,n]);
yf = zeros(endo_nbr,horizon+ykmin_,n);
yf(:,1:ykmin_,:,:) = repmat(y0,[1,1,n]);
j = ykmin_*endo_nbr;
for i=ykmin_+(1:horizon)
j = ykmin_*endo_nbr;
for i=ykmin_+(1:horizon)
tempx1 = reshape(yf(:,k1,:),[j,n]);
tempx = tempx1(k2,:);
yf(:,i,:) = dr.ghx*tempx+B1*squeeze(e(:,:,i-ykmin_));
k1 = k1+1;
end
end
yf(dr.order_var,:,:) = yf;
yf=permute(yf,[2 1 3]);
yf(dr.order_var,:,:) = yf;
yf=permute(yf,[2 1 3]);

34
matlab/forcst2a.m
View File

@ -17,30 +17,30 @@ function yf=forcst2a(y0,dr,e)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_ options_
global M_ options_
Sigma_e_ = M_.Sigma_e;
endo_nbr = M_.endo_nbr;
exo_nbr = M_.exo_nbr;
ykmin_ = M_.maximum_endo_lag;
Sigma_e_ = M_.Sigma_e;
endo_nbr = M_.endo_nbr;
exo_nbr = M_.exo_nbr;
ykmin_ = M_.maximum_endo_lag;
horizon = size(e,1);
options_ = set_default_option(options_,'simul_seed',0);
order = options_.order;
horizon = size(e,1);
options_ = set_default_option(options_,'simul_seed',0);
order = options_.order;
k1 = [ykmin_:-1:1];
k2 = dr.kstate(find(dr.kstate(:,2) <= ykmin_+1),[1 2]);
k2 = k2(:,1)+(ykmin_+1-k2(:,2))*endo_nbr;
k1 = [ykmin_:-1:1];
k2 = dr.kstate(find(dr.kstate(:,2) <= ykmin_+1),[1 2]);
k2 = k2(:,1)+(ykmin_+1-k2(:,2))*endo_nbr;
yf = zeros(horizon+ykmin_,endo_nbr);
yf(1:ykmin_,:) = y0';
yf = zeros(horizon+ykmin_,endo_nbr);
yf(1:ykmin_,:) = y0';
j = ykmin_*endo_nbr;
for i=ykmin_+(1:horizon)
j = ykmin_*endo_nbr;
for i=ykmin_+(1:horizon)
tempx = yf(k1,:)';
yf(i,:) = tempx(k2)'*dr.ghx';
k1 = k1+1;
end
end
yf(:,dr.order_var) = yf;
yf(:,dr.order_var) = yf;

134
matlab/forcst_unc.m
View File

@ -32,40 +32,40 @@ function forcst_unc(y0,var_list)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_ options_ oo_ estim_params_ bayestopt_
global M_ options_ oo_ estim_params_ bayestopt_
% setting up estim_params_
[xparam1,estim_params_,bayestopt_,lb,ub] = set_prior(estim_params_,M_);
% setting up estim_params_
[xparam1,estim_params_,bayestopt_,lb,ub] = set_prior(estim_params_,M_);
options_.TeX = 0;
options_.nograph = 0;
plot_priors(bayestopt_,M_,options_);
options_.TeX = 0;
options_.nograph = 0;
plot_priors(bayestopt_,M_,options_);
% workspace initialization
if isempty(var_list)
% workspace initialization
if isempty(var_list)
var_list = M_.endo_names(1:M_.orig_endo_nbr,:);
end
n = size(var_list,1);
end
n = size(var_list,1);
periods = options_.forecast;
exo_nbr = M_.exo_nbr;
replic = options_.replic;
order = options_.order;
maximum_lag = M_.maximum_lag;
% params = prior_draw(1);
params = rndprior(bayestopt_);
set_parameters(params);
% eliminate shocks with 0 variance
i_exo_var = setdiff([1:exo_nbr],find(diag(M_.Sigma_e) == 0));
nx = length(i_exo_var);
periods = options_.forecast;
exo_nbr = M_.exo_nbr;
replic = options_.replic;
order = options_.order;
maximum_lag = M_.maximum_lag;
% params = prior_draw(1);
params = rndprior(bayestopt_);
set_parameters(params);
% eliminate shocks with 0 variance
i_exo_var = setdiff([1:exo_nbr],find(diag(M_.Sigma_e) == 0));
nx = length(i_exo_var);
ex0 = zeros(periods,exo_nbr);
yf1 = zeros(periods+M_.maximum_lag,n,replic);
ex0 = zeros(periods,exo_nbr);
yf1 = zeros(periods+M_.maximum_lag,n,replic);
% loops on parameter values
m1 = 0;
m2 = 0;
for i=1:replic
% loops on parameter values
m1 = 0;
m2 = 0;
for i=1:replic
% draw parameter values from the prior
% params = prior_draw(0);
params = rndprior(bayestopt_);
@ -86,11 +86,11 @@ function forcst_unc(y0,var_list)
yf2(:,:,m2) = simult_(y0,dr,ex,order)';
m2 = m2+1;
yf2(:,:,m2) = simult_(y0,dr,-ex,order)';
end
end
oo_.forecast.accept_rate = (replic-m1)/replic;
oo_.forecast.accept_rate = (replic-m1)/replic;
if options_.noprint == 0 & m1 < replic
if options_.noprint == 0 & m1 < replic
disp(' ')
disp(' ')
disp('FORECASTING WITH PARAMETER UNCERTAINTY:')
@ -98,56 +98,56 @@ function forcst_unc(y0,var_list)
' values'],100*oo_.forecast.accept_rate))
disp(' ')
disp(' ')
end
end
% compute moments
yf1 = yf1(:,:,1:m1);
yf2 = yf2(:,:,1:m2);
% compute moments
yf1 = yf1(:,:,1:m1);
yf2 = yf2(:,:,1:m2);
yf_mean = mean(yf1,3);
yf_mean = mean(yf1,3);
yf1 = sort(yf1,3);
yf2 = sort(yf2,3);
yf1 = sort(yf1,3);
yf2 = sort(yf2,3);
sig_lev = options_.conf_sig;
k1 = round((0.5+[-sig_lev, sig_lev]/2)*replic);
% make sure that lower bound is at least the first element
if k1(2) == 0
sig_lev = options_.conf_sig;
k1 = round((0.5+[-sig_lev, sig_lev]/2)*replic);
% make sure that lower bound is at least the first element
if k1(2) == 0
k1(2) = 1;
end
k2 = round((1+[-sig_lev, sig_lev])*replic);
% make sure that lower bound is at least the first element
if k2(2) == 0
end
k2 = round((1+[-sig_lev, sig_lev])*replic);
% make sure that lower bound is at least the first element
if k2(2) == 0
k2(2) = 1;
end
end
% compute shock uncertainty around forecast with mean prior
set_parameters(bayestopt_.p1);
[dr,info] = resol(oo_.steady_state,0);
[yf3,yf3_intv] = forcst(dr,y0,periods,var_list);
yf3_1 = yf3'-[zeros(maximum_lag,n); yf3_intv];
yf3_2 = yf3'+[zeros(maximum_lag,n); yf3_intv];
% compute shock uncertainty around forecast with mean prior
set_parameters(bayestopt_.p1);
[dr,info] = resol(oo_.steady_state,0);
[yf3,yf3_intv] = forcst(dr,y0,periods,var_list);
yf3_1 = yf3'-[zeros(maximum_lag,n); yf3_intv];
yf3_2 = yf3'+[zeros(maximum_lag,n); yf3_intv];
% graphs
% graphs
dynare_graph_init('Forecasts type I',n,{'b-' 'g-' 'g-' 'r-' 'r-'});
for i=1:n
dynare_graph_init('Forecasts type I',n,{'b-' 'g-' 'g-' 'r-' 'r-'});
for i=1:n
dynare_graph([yf_mean(:,i) squeeze(yf1(:,i,k1)) squeeze(yf2(:,i,k2))],...
var_list(i,:));
end
dynare_graph_close;
end
dynare_graph_close;
dynare_graph_init('Forecasts type II',n,{'b-' 'k-' 'k-' 'r-' 'r-'});
for i=1:n
dynare_graph_init('Forecasts type II',n,{'b-' 'k-' 'k-' 'r-' 'r-'});
for i=1:n
dynare_graph([yf_mean(:,i) yf3_1(:,i) yf3_2(:,i) squeeze(yf2(:,i,k2))],...
var_list(i,:));
end
dynare_graph_close;
end
dynare_graph_close;
% saving results
save_results(yf_mean,'oo_.forecast.mean.',var_list);
save_results(yf1(:,:,k1(1)),'oo_.forecast.HPDinf.',var_list);
save_results(yf1(:,:,k1(2)),'oo_.forecast.HPDsup.',var_list);
save_results(yf2(:,:,k2(1)),'oo_.forecast.HPDTotalinf.',var_list);
save_results(yf2(:,:,k2(2)),'oo_.forecast.HPDTotalsup.',var_list);
% saving results
save_results(yf_mean,'oo_.forecast.mean.',var_list);
save_results(yf1(:,:,k1(1)),'oo_.forecast.HPDinf.',var_list);
save_results(yf1(:,:,k1(2)),'oo_.forecast.HPDsup.',var_list);
save_results(yf2(:,:,k2(1)),'oo_.forecast.HPDTotalinf.',var_list);
save_results(yf2(:,:,k2(2)),'oo_.forecast.HPDTotalsup.',var_list);

52
matlab/forecast.m
View File

@ -33,32 +33,32 @@ function info = forecast(var_list,task)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global options_ dr_ oo_ M_
global options_ dr_ oo_ M_
info = 0;
info = 0;
old_options = options_;
old_options = options_;
maximum_lag = M_.maximum_lag;
maximum_lag = M_.maximum_lag;
endo_names = M_.endo_names;
if isempty(var_list)
endo_names = M_.endo_names;
if isempty(var_list)
var_list = endo_names(1:M_.orig_endo_nbr, :);
end
i_var = [];
for i = 1:size(var_list)
end
i_var = [];
for i = 1:size(var_list)
tmp = strmatch(var_list(i,:),endo_names,'exact');
if isempty(tmp)
error([var_list(i,:) ' isn''t and endogenous variable'])
end
i_var = [i_var; tmp];
end
end
n_var = length(i_var);
n_var = length(i_var);
trend = 0;
switch task
trend = 0;
switch task
case 'simul'
horizon = options_.periods;
if horizon == 0
@ -99,11 +99,11 @@ function info = forecast(var_list,task)
end
otherwise
error('Wrong flag value')
end
end
if M_.exo_det_nbr == 0
if M_.exo_det_nbr == 0
[yf,int_width] = forcst(oo_.dr,y0,horizon,var_list);
else
else
exo_det_length = size(oo_.exo_det_simul,1)-M_.maximum_lag;
if horizon > exo_det_length
ex = zeros(horizon,M_.exo_nbr);
@ -116,27 +116,27 @@ function info = forecast(var_list,task)
end
[yf,int_width] = simultxdet(y0,ex,oo_.exo_det_simul,...
options_.order,var_list,M_,oo_,options_);
end
end
if ~isscalar(trend)
if ~isscalar(trend)
yf(i_var_obs,:) = yf(i_var_obs,:) + trend;
end
end
for i=1:n_var
for i=1:n_var
eval(['oo_.forecast.Mean.' var_list(i,:) '= yf(' int2str(i) ',maximum_lag+1:end)'';']);
eval(['oo_.forecast.HPDinf.' var_list(i,:) '= yf(' int2str(i) ',maximum_lag+1:end)''-' ...
' int_width(:,' int2str(i) ');']);
eval(['oo_.forecast.HPDsup.' var_list(i,:) '= yf(' int2str(i) ',maximum_lag+1:end)''+' ...
' int_width(:,' int2str(i) ');']);
end
end
for i=1:M_.exo_det_nbr
for i=1:M_.exo_det_nbr
eval(['oo_.forecast.Exogenous.' M_.exo_det_names(i,:) '= oo_.exo_det_simul(:,' int2str(i) ');']);
end
end
if options_.nograph == 0
if options_.nograph == 0
forecast_graphs(var_list);
end
end
options_ = old_options;
options_ = old_options;

54
matlab/forecast_graphs.m
View File

@ -17,32 +17,32 @@ function forecast_graphs(var_list)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_ oo_ options_
global M_ oo_ options_
nc = 4;
nr = 3;
exo_nbr = M_.exo_nbr;
endo_names = M_.endo_names;
fname = M_.fname;
nc = 4;
nr = 3;
exo_nbr = M_.exo_nbr;
endo_names = M_.endo_names;
fname = M_.fname;
% $$$ varobs = options_.varobs;
% $$$ y = oo_.SmoothedVariables;
% $$$ ys = oo_.dr.ys;
% $$$ gend = size(y,2);
yf = oo_.forecast.Mean;
hpdinf = oo_.forecast.HPDinf;
hpdsup = oo_.forecast.HPDsup;
if isempty(var_list)
yf = oo_.forecast.Mean;
hpdinf = oo_.forecast.HPDinf;
hpdsup = oo_.forecast.HPDsup;
if isempty(var_list)
varlist = endo_names(1:M_.orig_endo_nbr,:);
end
i_var = [];
for i = 1:size(var_list)
end
i_var = [];
for i = 1:size(var_list)
tmp = strmatch(var_list(i,:),endo_names,'exact');
if isempty(tmp)
error([var_list(i,:) ' isn''t and endogenous variable'])
end
i_var = [i_var; tmp];
end
nvar = length(i_var);
end
nvar = length(i_var);
% $$$ % build trend for smoothed variables if necessary
% $$$ trend = zeros(size(varobs,1),10);
@ -51,18 +51,18 @@ function forecast_graphs(var_list)
% $$$ trend = trend_coeffs*(gend-9:gend);
% $$$ end
% create subdirectory <fname>/graphs if id doesn't exist
if ~exist(fname, 'dir')
% create subdirectory <fname>/graphs if id doesn't exist
if ~exist(fname, 'dir')
mkdir('.',fname);
end
if ~exist([fname '/graphs'])
end
if ~exist([fname '/graphs'])
mkdir(fname,'graphs');
end
end
m = 1;
n_fig = 1;
figure('Name','Forecasts (I)')
for j= 1:nvar
m = 1;
n_fig = 1;
figure('Name','Forecasts (I)')
for j= 1:nvar
if m > nc*nr;
eval(['print -depsc ' fname '/graphs/forcst' int2str(n_fig) ...
'.eps;'])
@ -88,8 +88,8 @@ function forecast_graphs(var_list)
title(vn,'Interpreter','none');
hold off
m = m + 1;
end
end
if m > 1
if m > 1
eval(['print -deps ' fname '/graphs/forcst' int2str(n_fig) '.eps;'])
end
end

30
matlab/formdata.m
View File

@ -28,12 +28,12 @@ function formdata(fname,date)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_ oo_
fid = fopen([fname '_endo.frm'],'w');
n=size(oo_.endo_simul,1);
t=size(oo_.endo_simul,2);
SN=upper(cellstr(M_.endo_names));
for i=1:n
global M_ oo_
fid = fopen([fname '_endo.frm'],'w');
n=size(oo_.endo_simul,1);
t=size(oo_.endo_simul,2);
SN=upper(cellstr(M_.endo_names));
for i=1:n
str=strvcat(SN(i));
fprintf(fid,'USER: x x DATAFILE: x %s\n',str);
fprintf(fid,'PER: 1 YEAR: %s FRAC: 1 NOBS: %d CLINES: 0 DLINES: ???\n',date,t);
@ -50,14 +50,14 @@ function formdata(fname,date)
%else
% fprintf(fid,'\n');
end;
end;
fclose(fid);
end;
fclose(fid);
fid = fopen([fname '_exo.frm'],'w');
n=size(oo_.exo_simul,2);
t=size(oo_.exo_simul,1);
SN=upper(cellstr(M_.exo_names));
for i=1:n
fid = fopen([fname '_exo.frm'],'w');
n=size(oo_.exo_simul,2);
t=size(oo_.exo_simul,1);
SN=upper(cellstr(M_.exo_names));
for i=1:n
str=strvcat(SN(i));
fprintf(fid,'USER: x x DATAFILE: x %s\n',str);
fprintf(fid,'PER: 1 YEAR: %s FRAC: 1 NOBS: %d CLINES: 0 DLINES: ???\n',date,t);
@ -74,6 +74,6 @@ function formdata(fname,date)
%else
% fprintf(fid,'\n');
end;
end;
fclose(fid);
end;
fclose(fid);
return;

34
matlab/gensylv/sylvester3.m
View File

@ -18,27 +18,27 @@ function x=sylvester3(a,b,c,d)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
n = size(a,1);
m = size(c,1);
if n == 1
n = size(a,1);
m = size(c,1);
if n == 1
x=d./(a*ones(1,m)+b*c);
return
end
if m == 1
end
if m == 1
x = (a+c*b)\d;
return;
end
x=zeros(n,m);
[u,t]=schur(c);
if exist('OCTAVE_VERSION')
end
x=zeros(n,m);
[u,t]=schur(c);
if exist('OCTAVE_VERSION')
[aa,bb,qq,zz]=qz(full(a),full(b));
d=qq'*d*u;
else
else
[aa,bb,qq,zz]=qz(full(a),full(b),'real'); % available in Matlab version 6.0
d=qq*d*u;
end
i = 1;
while i < m
end
i = 1;
while i < m
if t(i+1,i) == 0
if i == 1
c = zeros(n,1);
@ -61,12 +61,12 @@ function x=sylvester3(a,b,c,d)
x(:,i+1) = z(n+1:end);
i = i + 2;
end
end
if i == m
end
if i == m
c = bb*(x(:,1:m-1)*t(1:m-1,m));
x(:,m)=(aa+bb*t(m,m))\(d(:,m)-c);
end
x=zz*x*u';
end
x=zz*x*u';
% 01/25/03 MJ corrected bug for i==m (sign of c in x determination)
% 01/31/03 MJ added 'real' to qz call

18
matlab/gensylv/sylvester3a.m
View File

@ -18,17 +18,17 @@ function x=sylvester3a(x0,a,b,c,d)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
a_1 = inv(a);
b = a_1*b;
d = a_1*d;
e = 1;
iter = 1;
while e > 1e-8 & iter < 500
a_1 = inv(a);
b = a_1*b;
d = a_1*d;
e = 1;
iter = 1;
while e > 1e-8 & iter < 500
x = d-b*x0*c;
e = max(max(abs(x-x0)));
x0 = x;
iter = iter + 1;
end
if iter == 500
end
if iter == 500
warning('sylvester3a : Only accuracy of %10.8f is achieved after 500 iterations')
end
end

56
matlab/gensylv/sylvester3mr.m
View File

@ -18,40 +18,40 @@ function x=sylvester3mr(a,b,c,d)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
n = size(a,1);
m = size(c,1);
if length(size(d))==2,
n = size(a,1);
m = size(c,1);
if length(size(d))==2,
x=sylvester3(a,b,c,d);
return
end
p = size(d,3);
if n == 1
end
p = size(d,3);
if n == 1
for j=1:p,
x(:,:,j)=d(:,:,j)./(a*ones(1,m)+b*c);
end
return
end
if m == 1
end
if m == 1
invacb = inv(a+c*b);
x = invacb*d;
return;
end
x=zeros(n,m,p);
[u,t]=schur(c);
if exist('OCTAVE_VERSION')
end
x=zeros(n,m,p);
[u,t]=schur(c);
if exist('OCTAVE_VERSION')
[aa,bb,qq,zz]=qz(full(a),full(b));
for j=1:p,
d(:,:,j)=qq'*d(:,:,j)*u;
end
else
else
[aa,bb,qq,zz]=qz(full(a),full(b),'real'); % available in Matlab version 6.0
for j=1:p,
d(:,:,j)=qq*d(:,:,j)*u;
end
end
i = 1;
c = zeros(n,1,p);
while i < m
end
i = 1;
c = zeros(n,1,p);
while i < m
if t(i+1,i) == 0
if i == 1
c = zeros(n,1,p);
@ -60,8 +60,8 @@ function x=sylvester3mr(a,b,c,d)
c(:,:,j) = bb*(x(:,1:i-1,j)*t(1:i-1,i));
end
end
% aabbtinv = inv(aa+bb*t(i,i));
% x(:,i,:)=aabbtinv*squeeze(d(:,i,:)-c);
% aabbtinv = inv(aa+bb*t(i,i));
% x(:,i,:)=aabbtinv*squeeze(d(:,i,:)-c);
x(:,i,:)=(aa+bb*t(i,i))\squeeze(d(:,i,:)-c);
i = i+1;
else
@ -74,27 +74,27 @@ function x=sylvester3mr(a,b,c,d)
c1(:,:,j) = bb*(x(:,1:i-1,j)*t(1:i-1,i+1));
end
end
% bigmatinv = inv([aa+bb*t(i,i) bb*t(i+1,i); bb*t(i,i+1) aa+bb*t(i+1,i+1)]);
% z = bigmatinv * squeeze([d(:,i,:)-c;d(:,i+1,:)-c1]);
% bigmatinv = inv([aa+bb*t(i,i) bb*t(i+1,i); bb*t(i,i+1) aa+bb*t(i+1,i+1)]);
% z = bigmatinv * squeeze([d(:,i,:)-c;d(:,i+1,:)-c1]);
bigmat = ([aa+bb*t(i,i) bb*t(i+1,i); bb*t(i,i+1) aa+bb*t(i+1,i+1)]);
z = bigmat\squeeze([d(:,i,:)-c;d(:,i+1,:)-c1]);
x(:,i,:) = z(1:n,:);
x(:,i+1,:) = z(n+1:end,:);
i = i + 2;
end
end
if i == m
end
if i == m
for j=1:p,
c(:,:,j) = bb*(x(:,1:m-1,j)*t(1:m-1,m));
end
% aabbtinv = inv(aa+bb*t(m,m));
% x(:,m,:)=aabbtinv*squeeze(d(:,m,:)-c);
% aabbtinv = inv(aa+bb*t(m,m));
% x(:,m,:)=aabbtinv*squeeze(d(:,m,:)-c);
aabbt = (aa+bb*t(m,m));
x(:,m,:)=aabbt\squeeze(d(:,m,:)-c);
end
for j=1:p,
end
for j=1:p,
x(:,:,j)=zz*x(:,:,j)*u';
end
end
% 01/25/03 MJ corrected bug for i==m (sign of c in x determination)
% 01/31/03 MJ added 'real' to qz call

54
matlab/getH.m
View File

@ -96,14 +96,14 @@ k = find(kstate(:,2) > M_.maximum_endo_lag+2 & kstate(:,3));
kk = find(kstate(:,2) > M_.maximum_endo_lag+2 & ~kstate(:,3));
nauxe = 0;
if ~isempty(k),
ax(:,k)= -a(:,kstate(k,3));
ax(:,kk)= 0;
dax(:,k,:)= -da(:,kstate(k,3),:);
dax(:,kk,:)= 0;
nauxe=size(ax,2);
GAM1 = [ax GAM1];
Dg1 = cat(2,dax,Dg1);
clear ax
ax(:,k)= -a(:,kstate(k,3));
ax(:,kk)= 0;
dax(:,k,:)= -da(:,kstate(k,3),:);
dax(:,kk,:)= 0;
nauxe=size(ax,2);
GAM1 = [ax GAM1];
Dg1 = cat(2,dax,Dg1);
clear ax
end
@ -127,13 +127,13 @@ naux = 0;
k = find(kstate(:,2) < M_.maximum_endo_lag+1 & kstate(:,4));
kk = find(kstate(:,2) < M_.maximum_endo_lag+1 );
if ~isempty(k),
ax(:,k)= -a(:,kstate(k,4));
ax = ax(:,kk);
dax(:,k,:)= -da(:,kstate(k,4),:);
dax = dax(:,kk,:);
naux = size(ax,2);
GAM2 = [GAM2 ax];
Dg2 = cat(2,Dg2,dax);
ax(:,k)= -a(:,kstate(k,4));
ax = ax(:,kk);
dax(:,k,:)= -da(:,kstate(k,4),:);
dax = dax(:,kk,:);
naux = size(ax,2);
GAM2 = [GAM2 ax];
Dg2 = cat(2,Dg2,dax);
end
GAM0 = blkdiag(GAM0,eye(naux));
@ -298,18 +298,18 @@ else % generalized sylvester equation
end
H(:,j+length(indexo)) = [x(:); vech(y)];
end
% for j=1:param_nbr,
% disp(['Derivatives w.r.t. ',M_.param_names(indx(j),:),', ',int2str(j),'/',int2str(param_nbr)])
% elem = (Dg0(:,:,j)-Dg1(:,:,j)*A);
% d = Dg2(:,:,j)-elem*A;
% x=sylvester3(a,b,c,d);
% % x=sylvester3a(x,a,b,c,d);
% y = inva * (Dg3(:,:,j)-(elem-GAM1*x)*B);
% y = y*B'+B*y';
% x = x(nauxe+1:end,nauxe+1:end);
% y = y(nauxe+1:end,nauxe+1:end);
% H(:,j) = [x(:); vech(y)];
% end
% for j=1:param_nbr,
% disp(['Derivatives w.r.t. ',M_.param_names(indx(j),:),', ',int2str(j),'/',int2str(param_nbr)])
% elem = (Dg0(:,:,j)-Dg1(:,:,j)*A);
% d = Dg2(:,:,j)-elem*A;
% x=sylvester3(a,b,c,d);
% % x=sylvester3a(x,a,b,c,d);
% y = inva * (Dg3(:,:,j)-(elem-GAM1*x)*B);
% y = y*B'+B*y';
% x = x(nauxe+1:end,nauxe+1:end);
% y = y(nauxe+1:end,nauxe+1:end);
% H(:,j) = [x(:); vech(y)];
% end
H = [[zeros(M_.endo_nbr,length(indexo)) Hss]; H];
end

38
matlab/getJJ.m
View File

@ -22,9 +22,9 @@ if nargin<8 | isempty(indexo), indexo = [];, end,
if nargin<10 | isempty(nlags), nlags=3; end,
if nargin<11 | isempty(useautocorr), useautocorr=0; end,
if useautocorr,
if useautocorr,
warning('off','MATLAB:divideByZero')
end
end
if kronflag == -1,
fun = 'thet2tau';
params0 = M_.params;
@ -37,29 +37,29 @@ if kronflag == -1,
assignin('base','oo_', oo_);
else
[H, dA, dOm, dYss] = getH(A, B, M_,oo_,kronflag,indx,indexo);
% if isempty(H),
% JJ = [];
% GAM = [];
% return
% end
% if isempty(H),
% JJ = [];
% GAM = [];
% return
% end
m = length(A);
GAM = lyapunov_symm(A,B*M_.Sigma_e*B',options_.qz_criterium,options_.lyapunov_complex_threshold,1);
k = find(abs(GAM) < 1e-12);
GAM(k) = 0;
% if useautocorr,
% if useautocorr,
sdy = sqrt(diag(GAM));
sy = sdy*sdy';
% end
% end
% BB = dOm*0;
% for j=1:length(indx),
% BB(:,:,j)= dA(:,:,j)*GAM*A'+A*GAM*dA(:,:,j)'+dOm(:,:,j);
% end
% XX = lyapunov_symm_mr(A,BB,options_.qz_criterium,options_.lyapunov_complex_threshold,0);
% BB = dOm*0;
% for j=1:length(indx),
% BB(:,:,j)= dA(:,:,j)*GAM*A'+A*GAM*dA(:,:,j)'+dOm(:,:,j);
% end
% XX = lyapunov_symm_mr(A,BB,options_.qz_criterium,options_.lyapunov_complex_threshold,0);
for j=1:length(indexo),
dum = lyapunov_symm(A,dOm(:,:,j),options_.qz_criterium,options_.lyapunov_complex_threshold,2);
% dum = XX(:,:,j);
% dum = XX(:,:,j);
k = find(abs(dum) < 1e-12);
dum(k) = 0;
if useautocorr
@ -84,7 +84,7 @@ else
nexo = length(indexo);
for j=1:length(indx),
dum = lyapunov_symm(A,dA(:,:,j+nexo)*GAM*A'+A*GAM*dA(:,:,j+nexo)'+dOm(:,:,j+nexo),options_.qz_criterium,options_.lyapunov_complex_threshold,2);
% dum = XX(:,:,j);
% dum = XX(:,:,j);
k = find(abs(dum) < 1e-12);
dum(k) = 0;
if useautocorr
@ -113,7 +113,7 @@ else
JJ = [ [zeros(length(mf),nexo) dYss(mf,:)]; JJ];
if nargout >2,
% sy=sy(mf,mf);
% sy=sy(mf,mf);
options_.ar=nlags;
[GAM,stationary_vars] = th_autocovariances(oo_.dr,oo_.dr.order_var(mf),M_,options_);
sy=sqrt(diag(GAM{1}));
@ -134,6 +134,6 @@ else
gam = [oo_.dr.ys(oo_.dr.order_var(mf)); gam];
end
if useautocorr,
if useautocorr,
warning('on','MATLAB:divideByZero')
end
end

12
matlab/get_date_of_a_file.m
View File

@ -18,11 +18,11 @@ function [d1,d2] = get_date_of_a_file(filename)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
info = dir(filename);
if isempty(info)
info = dir(filename);
if isempty(info)
error(['get_date_of_a_file:: I''m not able to find ' filename '!'])
end
d1 = info.datenum;
if nargout>1
end
d1 = info.datenum;
if nargout>1
d2 = info.date;
end
end

20
matlab/get_moments_size.m
View File

@ -28,18 +28,18 @@ function s=get_moments_size(options)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_
global M_
n = size(options.varlist,1);
n = size(options.varlist,1);
if n == 0
if n == 0
n = M_.endo_nbr;
end
end
n2 = n*n;
n2 = n*n;
s = n; % mean
s = s + n; % std errors
s = s + n2; % variance
s = s + n2; % correlations
s = s + options.ar*n2; % auto-correlations
s = n; % mean
s = s + n; % std errors
s = s + n2; % variance
s = s + n2; % correlations
s = s + options.ar*n2; % auto-correlations

Some files were not shown because too many files have changed in this diff Show More