diff --git a/matlab/DsgeSmoother.m b/matlab/DsgeSmoother.m
index 470d573e7..2c7854ab8 100644
--- a/matlab/DsgeSmoother.m
+++ b/matlab/DsgeSmoother.m
@@ -227,7 +227,7 @@ elseif options_.lik_init == 5 % Old diffuse Kalman filter only for th
end
R_tmp = R(stable, :);
T_tmp = T(stable,stable);
- Pstar_tmp=lyapunov_solver(T_tmp,R_tmp,Q,DynareOptions);
+ Pstar_tmp=lyapunov_solver(T_tmp,R_tmp,Q,options_);
Pstar(stable, stable) = Pstar_tmp;
Pinf = [];
end
diff --git a/matlab/WriteShockDecomp2Excel.m b/matlab/WriteShockDecomp2Excel.m
index 8b14aaeb0..2ddbffe56 100644
--- a/matlab/WriteShockDecomp2Excel.m
+++ b/matlab/WriteShockDecomp2Excel.m
@@ -1,5 +1,5 @@
-function WriteShockDecomp2Excel(z,shock_names,endo_names,i_var,initial_date,DynareModel,DynareOptions,opts_decomp)
-%function WriteShockDecomp2Excel(z,shock_names,endo_names,i_var,initial_date,DynareModel,DynareOptions)
+function WriteShockDecomp2Excel(z,shock_names,endo_names,i_var,initial_date,M_,options_,opts_decomp)
+% WriteShockDecomp2Excel(z,shock_names,endo_names,i_var,initial_date,M_,options_,opts_decomp)
% Saves the results from the shock_decomposition command to xls
%
% Inputs
@@ -8,10 +8,11 @@ function WriteShockDecomp2Excel(z,shock_names,endo_names,i_var,initial_date,Dyna
% endo_names [exo_nbr*string length] variable names from M_.endo_names
% i_var [n_var*1] vector indices of requested variables in M_.endo_names and z
% initial_date [dseries object] first period of decomposition to plot
-% DynareModel [structure] Dynare model structure
-% DynareOptions [structure] Dynare options structure
+% M_ [structure] Dynare model structure
+% options_ [structure] Dynare options structure
+% opts_decomp [structure] decomposition options structure
-% Copyright © 2016-2022 Dynare Team
+% Copyright © 2016-2023 Dynare Team
%
% This file is part of Dynare.
%
@@ -28,16 +29,16 @@ function WriteShockDecomp2Excel(z,shock_names,endo_names,i_var,initial_date,Dyna
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see .
-OutputDirectoryName = CheckPath('Output',DynareModel.dname);
+OutputDirectoryName = CheckPath('Output',M_.dname);
-SteadyState=zeros(DynareModel.endo_nbr,1);
+SteadyState=zeros(M_.endo_nbr,1);
fig_mode='';
fig_mode1='';
fig_name='';
screen_shocks=0;
-use_shock_groups = DynareOptions.plot_shock_decomp.use_shock_groups;
+use_shock_groups = options_.plot_shock_decomp.use_shock_groups;
if use_shock_groups
- shock_groups = DynareModel.shock_groups.(use_shock_groups);
+ shock_groups = M_.shock_groups.(use_shock_groups);
shock_ind = fieldnames(shock_groups);
end
@@ -120,9 +121,9 @@ for j=1:nvar
fig_name1 = strrep(fig_name1,'.','');
if ~ismac
- STATUS = xlswrite([OutputDirectoryName,filesep,DynareModel.fname,'_shock_decomposition',fig_mode,fig_name1],d0,endo_names{i_var(j)});
+ STATUS = xlswrite([OutputDirectoryName,filesep,M_.fname,'_shock_decomposition',fig_mode,fig_name1],d0,endo_names{i_var(j)});
else
- writetable(cell2table(d0), [OutputDirectoryName,filesep,DynareModel.fname,'_shock_decomposition',fig_mode,fig_name1 '.xls'], 'Sheet', endo_names{i_var(j)},'WriteVariableNames',false);
+ writetable(cell2table(d0), [OutputDirectoryName,filesep,M_.fname,'_shock_decomposition',fig_mode,fig_name1 '.xls'], 'Sheet', endo_names{i_var(j)},'WriteVariableNames',false);
end
warning_config;
diff --git a/matlab/backward/backward_model_forecast.m b/matlab/backward/backward_model_forecast.m
index dd032ca42..1fda6eeb1 100644
--- a/matlab/backward/backward_model_forecast.m
+++ b/matlab/backward/backward_model_forecast.m
@@ -1,5 +1,5 @@
function forecasts = backward_model_forecast(initialcondition, listofvariables, periods, withuncertainty)
-
+%function forecasts = backward_model_forecast(initialcondition, listofvariables, periods, withuncertainty)
% Returns unconditional forecasts.
%
% INPUTS
diff --git a/matlab/backward/backward_model_inversion.m b/matlab/backward/backward_model_inversion.m
index 2b11559aa..b7b2149f2 100644
--- a/matlab/backward/backward_model_inversion.m
+++ b/matlab/backward/backward_model_inversion.m
@@ -1,5 +1,5 @@
-function [endogenousvariables, exogenousvariables] = backward_model_inversion(constraints, exogenousvariables, initialconditions, endo_names, exo_names, freeinnovations, DynareModel, DynareOptions, DynareOutput)
-
+function [endogenousvariables, exogenousvariables] = backward_model_inversion(constraints, exogenousvariables, initialconditions, endo_names, exo_names, freeinnovations, M_, options_, oo_)
+% [endogenousvariables, exogenousvariables] = backward_model_inversion(constraints, exogenousvariables, initialconditions, endo_names, exo_names, freeinnovations, M_, options_, oo_)
% INPUTS
% - constraints [dseries] with N constrained endogenous variables from t1 to t2.
% - exogenousvariables [dseries] with Q exogenous variables.
@@ -7,6 +7,9 @@ function [endogenousvariables, exogenousvariables] = backward_model_inversion(co
% - endo_names [cell] list of endogenous variable names.
% - exo_names [cell] list of exogenous variable names.
% - freeinstruments [cell] list of exogenous variable names used to control the constrained endogenous variables.
+% - M_ [structure] describing the model
+% - options_ [structure] describing the options
+% - oo_ [structure] storing the results
%
% OUTPUTS
% - endogenous [dseries]
@@ -33,7 +36,7 @@ function [endogenousvariables, exogenousvariables] = backward_model_inversion(co
% Get indices for the free innovations.
freeinnovations_id = zeros(length(freeinnovations), 1);
-if length(freeinnovations).
-if DynareModel.maximum_lead
- error('Model defined in %s.mod is not backward.', DynareModel.fname)
+if M_.maximum_lead
+ error('Model defined in %s.mod is not backward.', M_.fname)
end
-if ~DynareModel.maximum_lag
- error('Model defined in %s.mod is not backward.', DynareModel.fname)
+if ~M_.maximum_lag
+ error('Model defined in %s.mod is not backward.', M_.fname)
end
if nargin<6
innovations = [];
end
-[initialconditions, samplesize, innovations, DynareOptions, DynareModel, DynareOutput, endonames, exonames, dynamic_resid, dynamic_g1] = ...
- simul_backward_model_init(initialconditions, samplesize, DynareOptions, DynareModel, DynareOutput, innovations);
+[initialconditions, samplesize, innovations, options_, M_, oo_, endonames, exonames, dynamic_resid, dynamic_g1] = ...
+ simul_backward_model_init(initialconditions, samplesize, options_, M_, oo_, innovations);
-[ysim, xsim, errorflag] = simul_backward_linear_model_(initialconditions, samplesize, DynareOptions, DynareModel, DynareOutput, innovations, dynamic_resid, dynamic_g1);
+[ysim, xsim, errorflag] = simul_backward_linear_model_(initialconditions, samplesize, options_, M_, oo_, innovations, dynamic_resid, dynamic_g1);
-simulations = [dseries(ysim', initialconditions.init, endonames(1:DynareModel.orig_endo_nbr)), dseries(xsim, initialconditions.init, exonames)];
+simulations = [dseries(ysim', initialconditions.init, endonames(1:M_.orig_endo_nbr)), dseries(xsim, initialconditions.init, exonames)];
diff --git a/matlab/backward/simul_backward_linear_model_.m b/matlab/backward/simul_backward_linear_model_.m
index 64c7a1196..21670d9e7 100644
--- a/matlab/backward/simul_backward_linear_model_.m
+++ b/matlab/backward/simul_backward_linear_model_.m
@@ -1,22 +1,22 @@
-function [ysim, xsim, errorflag] = simul_backward_linear_model_(initialconditions, samplesize, DynareOptions, DynareModel, DynareOutput, innovations, dynamic_resid, dynamic_g1)
-
+function [ysim, xsim, errorflag] = simul_backward_linear_model_(initialconditions, samplesize, options_, M_, oo_, innovations, dynamic_resid, dynamic_g1)
+% [ysim, xsim, errorflag] = simul_backward_linear_model_(initialconditions, samplesize, options_, M_, oo_, innovations, dynamic_resid, dynamic_g1)
% Simulates a stochastic linear backward looking model.
%
% INPUTS
% - initialconditions [dseries] initial conditions for the endogenous variables.
% - samplesize [integer] scalar, number of periods for the simulation.
-% - DynareOptions [struct] Dynare's options_ global structure.
-% - DynareModel [struct] Dynare's M_ global structure.
-% - DynareOutput [struct] Dynare's oo_ global structure.
+% - options_ [struct] Dynare's options_ global structure.
+% - M_ [struct] Dynare's M_ global structure.
+% - oo_ [struct] Dynare's oo_ global structure.
% - innovations [double] T*q matrix, innovations to be used for the simulation.
%
% OUTPUTS
-% - DynareOutput [struct] Dynare's oo_ global structure.
+% - oo_ [struct] Dynare's oo_ global structure.
% - errorflag [logical] scalar, equal to false iff the simulation did not fail.
%
% REMARKS
-% [1] The innovations used for the simulation are saved in DynareOutput.exo_simul, and the resulting paths for the endogenous
-% variables are saved in DynareOutput.endo_simul.
+% [1] The innovations used for the simulation are saved in oo_.exo_simul, and the resulting paths for the endogenous
+% variables are saved in oo_.endo_simul.
% [2] The last input argument is not mandatory. If absent we use random draws and rescale them with the informations provided
% through the shocks block.
% [3] If the first input argument is empty, the endogenous variables are initialized with 0, or if available with the informations
@@ -42,17 +42,17 @@ function [ysim, xsim, errorflag] = simul_backward_linear_model_(initialcondition
errorflag = false;
if ~isempty(innovations)
- DynareOutput.exo_simul(initialconditions.nobs+(1:samplesize),:) = innovations;
+ oo_.exo_simul(initialconditions.nobs+(1:samplesize),:) = innovations;
end
% Get coefficients
-y = [zeros(2*DynareModel.endo_nbr,1); NaN(DynareModel.endo_nbr,1)];
-x = zeros(DynareModel.exo_nbr, 1);
-[cst, T_order, T] = dynamic_resid(y, x, DynareModel.params, DynareOutput.steady_state);
-jacob = dynamic_g1(y, x, DynareModel.params, DynareOutput.steady_state, DynareModel.dynamic_g1_sparse_rowval, DynareModel.dynamic_g1_sparse_colval, DynareModel.dynamic_g1_sparse_colptr, T_order, T);
+y = [zeros(2*M_.endo_nbr,1); NaN(M_.endo_nbr,1)];
+x = zeros(M_.exo_nbr, 1);
+[cst, T_order, T] = dynamic_resid(y, x, M_.params, oo_.steady_state);
+jacob = dynamic_g1(y, x, M_.params, oo_.steady_state, M_.dynamic_g1_sparse_rowval, M_.dynamic_g1_sparse_colval, M_.dynamic_g1_sparse_colptr, T_order, T);
try
- A0inv = inv(jacob(:,DynareModel.endo_nbr+(1:DynareModel.endo_nbr)));
+ A0inv = inv(jacob(:,M_.endo_nbr+(1:M_.endo_nbr)));
catch
errorflag = true;
ysim = [];
@@ -60,13 +60,13 @@ catch
return
end
-A1 = jacob(:,1:DynareModel.endo_nbr);
-B = jacob(:,3*DynareModel.endo_nbr+1:end);
+A1 = jacob(:,1:M_.endo_nbr);
+B = jacob(:,3*M_.endo_nbr+1:end);
% Simulations
for it = initialconditions.nobs+(1:samplesize)
- DynareOutput.endo_simul(:,it) = -A0inv*(cst + A1*DynareOutput.endo_simul(:,it-1) + B*DynareOutput.exo_simul(it,:)');
+ oo_.endo_simul(:,it) = -A0inv*(cst + A1*oo_.endo_simul(:,it-1) + B*oo_.exo_simul(it,:)');
end
-ysim = DynareOutput.endo_simul(1:DynareModel.orig_endo_nbr,:);
-xsim = DynareOutput.exo_simul;
+ysim = oo_.endo_simul(1:M_.orig_endo_nbr,:);
+xsim = oo_.exo_simul;
diff --git a/matlab/backward/simul_backward_model_init.m b/matlab/backward/simul_backward_model_init.m
index 99a771127..f7f8d4a14 100644
--- a/matlab/backward/simul_backward_model_init.m
+++ b/matlab/backward/simul_backward_model_init.m
@@ -1,5 +1,5 @@
-function [initialconditions, samplesize, innovations, DynareOptions, DynareModel, DynareOutput, endonames, exonames, dynamic_resid, dynamic_g1, y] = ...
- simul_backward_model_init(initialconditions, samplesize, DynareOptions, DynareModel, DynareOutput, innovations)
+function [initialconditions, samplesize, innovations, options_, M_, oo_, endonames, exonames, dynamic_resid, dynamic_g1, y] = ...
+ simul_backward_model_init(initialconditions, samplesize, options_, M_, oo_, innovations)
% Initialization of the routines simulating backward models.
@@ -21,7 +21,7 @@ function [initialconditions, samplesize, innovations, DynareOptions, DynareModel
% along with Dynare. If not, see .
% Test if the model is backward.
-if DynareModel.maximum_lead
+if M_.maximum_lead
error('simul_backward_nonlinear_model:: The specified model is not backward looking!')
end
@@ -30,39 +30,39 @@ if ~(isdseries(initialconditions) || isempty(initialconditions))
error('First input argument must be a dseries object or an empty array!')
end
-% If initialconditions is empty instantiates a dseries object with the informations available in DynareModel.endo_histval.
+% If initialconditions is empty instantiates a dseries object with the informations available in M_.endo_histval.
if isempty(initialconditions)
- yinitdata = zeros(DynareModel.orig_endo_nbr, DynareModel.orig_maximum_lag);
- yinitdata(:,1) = DynareModel.endo_histval(1:DynareModel.orig_endo_nbr);
- xinitdata = zeros(DynareModel.exo_nbr, DynareModel.orig_maximum_lag);
- if DynareModel.orig_maximum_endo_lag>1
- for i = 1:length(DynareModel.aux_vars)
- if DynareModel.aux_vars(i).type==1
- yinitdata(DynareModel.aux_vars(i).orig_index, abs(DynareModel.aux_vars(i).orig_lead_lag)+1) = ...
- DynareModel.endo_histval(DynareModel.orig_endo_nbr+i);
+ yinitdata = zeros(M_.orig_endo_nbr, M_.orig_maximum_lag);
+ yinitdata(:,1) = M_.endo_histval(1:M_.orig_endo_nbr);
+ xinitdata = zeros(M_.exo_nbr, M_.orig_maximum_lag);
+ if M_.orig_maximum_endo_lag>1
+ for i = 1:length(M_.aux_vars)
+ if M_.aux_vars(i).type==1
+ yinitdata(M_.aux_vars(i).orig_index, abs(M_.aux_vars(i).orig_lead_lag)+1) = ...
+ M_.endo_histval(M_.orig_endo_nbr+i);
end
end
yinitdata = flip(yinitdata, 2);
end
- if DynareModel.orig_maximum_exo_lag>0
- for i = 1:length(DynareModel.aux_vars)
- if DynareModel.aux_vars(i).type==3
- xinitdata(DynareModel.aux_vars(i).orig_index, abs(DynareModel.aux_vars(i).orig_lead_lag)+1) = ...
- DynareModel.endo_histval(DynareModel.orig_endo_nbr+i);
+ if M_.orig_maximum_exo_lag>0
+ for i = 1:length(M_.aux_vars)
+ if M_.aux_vars(i).type==3
+ xinitdata(M_.aux_vars(i).orig_index, abs(M_.aux_vars(i).orig_lead_lag)+1) = ...
+ M_.endo_histval(M_.orig_endo_nbr+i);
end
end
xinitdata = flip(xinitdata, 2);
end
initialconditions = dseries([transpose(yinitdata) transpose(xinitdata)], '1Y', ...
- vertcat(DynareModel.endo_names(1:DynareModel.orig_endo_nbr), DynareModel.exo_names));
+ vertcat(M_.endo_names(1:M_.orig_endo_nbr), M_.exo_names));
end
-[initialconditions, info] = checkdatabase(initialconditions, DynareModel, false, true);
+[initialconditions, info] = checkdatabase(initialconditions, M_, false, true);
% Test if the first argument contains all the lagged endogenous variables
-endonames = DynareModel.endo_names;
+endonames = M_.endo_names;
missingendogenousvariables = setdiff(endonames, initialconditions.name);
-endolags = get_lags_on_endogenous_variables(DynareModel);
+endolags = get_lags_on_endogenous_variables(M_);
endolags_ = endolags(find(endolags));
endowithlagnames = endonames(find(endolags));
if ~isempty(missingendogenousvariables)
@@ -103,9 +103,9 @@ if missinginitialcondition
end
% If the model has lags on the exogenous variables, test if we have corresponding initial conditions.
-exonames = DynareModel.exo_names;
+exonames = M_.exo_names;
missingexogenousvariables = setdiff(exonames, initialconditions.name);
-exolags = get_lags_on_exogenous_variables(DynareModel);
+exolags = get_lags_on_exogenous_variables(M_);
exolags_ = exolags(find(exolags));
exowithlagnames = exonames(find(exolags));
if ~isempty(missingexogenousvariables)
@@ -147,52 +147,52 @@ end
if nargin<6 || isempty(innovations)
% Set the covariance matrix of the structural innovations.
- variances = diag(DynareModel.Sigma_e);
- number_of_shocks = length(DynareModel.Sigma_e);
+ variances = diag(M_.Sigma_e);
+ number_of_shocks = length(M_.Sigma_e);
positive_var_indx = find(variances>0);
effective_number_of_shocks = length(positive_var_indx);
- covariance_matrix = DynareModel.Sigma_e(positive_var_indx,positive_var_indx);
+ covariance_matrix = M_.Sigma_e(positive_var_indx,positive_var_indx);
covariance_matrix_upper_cholesky = chol(covariance_matrix);
% Set seed to its default state.
- if DynareOptions.bnlms.set_dynare_seed_to_default
- DynareOptions=set_dynare_seed_local_options(DynareOptions,'default');
+ if options_.bnlms.set_dynare_seed_to_default
+ options_=set_dynare_seed_local_options(options_,'default');
end
% Simulate structural innovations.
- switch DynareOptions.bnlms.innovation_distribution
+ switch options_.bnlms.innovation_distribution
case 'gaussian'
- DynareOutput.bnlms.shocks = randn(samplesize,effective_number_of_shocks)*covariance_matrix_upper_cholesky;
+ oo_.bnlms.shocks = randn(samplesize,effective_number_of_shocks)*covariance_matrix_upper_cholesky;
otherwise
- error(['simul_backward_nonlinear_model:: ' DynareOptions.bnlms.innovation_distribution ' distribution for the structural innovations is not (yet) implemented!'])
+ error(['simul_backward_nonlinear_model:: ' options_.bnlms.innovation_distribution ' distribution for the structural innovations is not (yet) implemented!'])
end
- % Put the simulated innovations in DynareOutput.exo_simul.
- DynareOutput.exo_simul = zeros(samplesize,number_of_shocks);
- DynareOutput.exo_simul(:,positive_var_indx) = DynareOutput.bnlms.shocks;
- innovations = DynareOutput.exo_simul;
+ % Put the simulated innovations in oo_.exo_simul.
+ oo_.exo_simul = zeros(samplesize,number_of_shocks);
+ oo_.exo_simul(:,positive_var_indx) = oo_.bnlms.shocks;
+ innovations = oo_.exo_simul;
else
- DynareOutput.exo_simul = innovations; % innovations
+ oo_.exo_simul = innovations; % innovations
end
% Initialization of the returned simulations.
-DynareOutput.endo_simul = NaN(DynareModel.endo_nbr, samplesize+initialconditions.nobs);
+oo_.endo_simul = NaN(M_.endo_nbr, samplesize+initialconditions.nobs);
for i=1:length(endonames)
if ismember(endonames{i}, initialconditions.name)
- DynareOutput.endo_simul(i,1:initialconditions.nobs) = transpose(initialconditions{endonames{i}}.data);
+ oo_.endo_simul(i,1:initialconditions.nobs) = transpose(initialconditions{endonames{i}}.data);
end
end
% Initialization of the array for the exogenous variables.
-DynareOutput.exo_simul = [NaN(initialconditions.nobs, DynareModel.exo_nbr); DynareOutput.exo_simul ];
+oo_.exo_simul = [NaN(initialconditions.nobs, M_.exo_nbr); oo_.exo_simul ];
for i=1:length(exonames)
if ismember(exonames{i}, initialconditions.name)
- DynareOutput.exo_simul(1:initialconditions.nobs, i) = initialconditions{exonames{i}}.data;
+ oo_.exo_simul(1:initialconditions.nobs, i) = initialconditions{exonames{i}}.data;
end
end
if nargout>8
% Get function handles to the dynamic model routines.
- dynamic_resid = str2func([DynareModel.fname,'.sparse.dynamic_resid']);
- dynamic_g1 = str2func([DynareModel.fname,'.sparse.dynamic_g1']);
+ dynamic_resid = str2func([M_.fname,'.sparse.dynamic_resid']);
+ dynamic_g1 = str2func([M_.fname,'.sparse.dynamic_g1']);
% initialization of vector y.
- y = NaN(3*DynareModel.endo_nbr,1);
+ y = NaN(3*M_.endo_nbr,1);
end
diff --git a/matlab/backward/simul_backward_nonlinear_model.m b/matlab/backward/simul_backward_nonlinear_model.m
index db069b682..cbe9695e6 100644
--- a/matlab/backward/simul_backward_nonlinear_model.m
+++ b/matlab/backward/simul_backward_nonlinear_model.m
@@ -1,13 +1,13 @@
-function [simulations, errorflag] = simul_backward_nonlinear_model(initialconditions, samplesize, DynareOptions, DynareModel, DynareOutput, innovations)
-% function simulations = simul_backward_nonlinear_model(initialconditions, samplesize, DynareOptions, DynareModel, DynareOutput, innovations)
+function [simulations, errorflag] = simul_backward_nonlinear_model(initialconditions, samplesize, options_, M_, oo_, innovations)
+% function simulations = simul_backward_nonlinear_model(initialconditions, samplesize, options_, M_, oo_, innovations)
% Simulates a stochastic non linear backward looking model with arbitrary precision (a deterministic solver is used).
%
% INPUTS
% - initial_conditions [dseries] initial conditions for the endogenous variables.
% - sample_size [integer] scalar, number of periods for the simulation.
-% - DynareOptions [struct] Dynare's options_ global structure.
-% - DynareModel [struct] Dynare's M_ global structure.
-% - DynareOutput [struct] Dynare's oo_ global structure.
+% - options_ [struct] Dynare's options_ global structure.
+% - M_ [struct] Dynare's M_ global structure.
+% - oo_ [struct] Dynare's oo_ global structure.
% - innovations [double] T*q matrix, innovations to be used for the simulation.
%
% OUTPUTS
@@ -15,8 +15,8 @@ function [simulations, errorflag] = simul_backward_nonlinear_model(initialcondit
% - errorflag [logical] scalar, equal to false iff the simulation did not fail.
%
% REMARKS
-% [1] The innovations used for the simulation are saved in DynareOutput.exo_simul, and the resulting paths for the endogenous
-% variables are saved in DynareOutput.endo_simul.
+% [1] The innovations used for the simulation are saved in oo_.exo_simul, and the resulting paths for the endogenous
+% variables are saved in oo_.endo_simul.
% [2] The last input argument is not mandatory. If absent we use random draws and rescale them with the informations provided
% through the shocks block.
% [3] If the first input argument is empty, the endogenous variables are initialized with 0, or if available with the informations
@@ -39,21 +39,21 @@ function [simulations, errorflag] = simul_backward_nonlinear_model(initialcondit
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see .
-if DynareModel.maximum_lead
- error('Model defined in %s.mod is not backward.', DynareModel.fname)
+if M_.maximum_lead
+ error('Model defined in %s.mod is not backward.', M_.fname)
end
-if ~DynareModel.maximum_lag
- error('Model defined in %s.mod is not backward.', DynareModel.fname)
+if ~M_.maximum_lag
+ error('Model defined in %s.mod is not backward.', M_.fname)
end
if nargin<6
innovations = [];
end
-[initialconditions, samplesize, innovations, DynareOptions, DynareModel, DynareOutput, endonames, exonames, dynamic_resid, dynamic_g1] = ...
- simul_backward_model_init(initialconditions, samplesize, DynareOptions, DynareModel, DynareOutput, innovations);
+[initialconditions, samplesize, innovations, options_, M_, oo_, endonames, exonames, dynamic_resid, dynamic_g1] = ...
+ simul_backward_model_init(initialconditions, samplesize, options_, M_, oo_, innovations);
-[ysim, xsim, errorflag] = simul_backward_nonlinear_model_(initialconditions, samplesize, DynareOptions, DynareModel, DynareOutput, innovations, dynamic_resid, dynamic_g1);
+[ysim, xsim, errorflag] = simul_backward_nonlinear_model_(initialconditions, samplesize, options_, M_, oo_, innovations, dynamic_resid, dynamic_g1);
-simulations = [dseries(ysim', initialconditions.init, endonames(1:DynareModel.orig_endo_nbr)), dseries(xsim, initialconditions.init, exonames)];
+simulations = [dseries(ysim', initialconditions.init, endonames(1:M_.orig_endo_nbr)), dseries(xsim, initialconditions.init, exonames)];
diff --git a/matlab/backward/simul_backward_nonlinear_model_.m b/matlab/backward/simul_backward_nonlinear_model_.m
index e72f4c316..3aa4d180d 100644
--- a/matlab/backward/simul_backward_nonlinear_model_.m
+++ b/matlab/backward/simul_backward_nonlinear_model_.m
@@ -1,22 +1,24 @@
-function [ysim, xsim, errorflag] = simul_backward_nonlinear_model_(initialconditions, samplesize, DynareOptions, DynareModel, DynareOutput, innovations, dynamic_resid, dynamic_g1)
-
+function [ysim, xsim, errorflag] = simul_backward_nonlinear_model_(initialconditions, samplesize, options_, M_, oo_, innovations, dynamic_resid, dynamic_g1)
+% [ysim, xsim, errorflag] = simul_backward_nonlinear_model_(initialconditions, samplesize, options_, M_, oo_, innovations, dynamic_resid, dynamic_g1)
% Simulates a stochastic non linear backward looking model with arbitrary precision (a deterministic solver is used).
%
% INPUTS
% - initial_conditions [dseries] initial conditions for the endogenous variables.
% - sample_size [integer] scalar, number of periods for the simulation.
-% - DynareOptions [struct] Dynare's options_ global structure.
-% - DynareModel [struct] Dynare's M_ global structure.
-% - DynareOutput [struct] Dynare's oo_ global structure.
+% - options_ [struct] Dynare's options_ global structure.
+% - M_ [struct] Dynare's M_ global structure.
+% - oo_ [struct] Dynare's oo_ global structure.
% - innovations [double] T*q matrix, innovations to be used for the simulation.
+% - dynamic_resid
+% - dynamic_g1
%
% OUTPUTS
-% - DynareOutput [struct] Dynare's oo_ global structure.
+% - oo_ [struct] Dynare's oo_ global structure.
% - errorflag [logical] scalar, equal to false iff the simulation did not fail.
%
% REMARKS
-% [1] The innovations used for the simulation are saved in DynareOutput.exo_simul, and the resulting paths for the endogenous
-% variables are saved in DynareOutput.endo_simul.
+% [1] The innovations used for the simulation are saved in oo_.exo_simul, and the resulting paths for the endogenous
+% variables are saved in oo_.endo_simul.
% [2] The last input argument is not mandatory. If absent we use random draws and rescale them with the informations provided
% through the shocks block.
% [3] If the first input argument is empty, the endogenous variables are initialized with 0, or if available with the informations
@@ -43,18 +45,18 @@ debug = false;
errorflag = false;
if ~isempty(innovations)
- DynareOutput.exo_simul(initialconditions.nobs+(1:samplesize),:) = innovations;
+ oo_.exo_simul(initialconditions.nobs+(1:samplesize),:) = innovations;
end
-if ismember(DynareOptions.solve_algo, [12,14])
- [funcs, feedback_vars_idxs] = setup_time_recursive_block_simul(DynareModel);
+if ismember(options_.solve_algo, [12,14])
+ [funcs, feedback_vars_idxs] = setup_time_recursive_block_simul(M_);
end
function [r, J] = block_wrapper(z, feedback_vars_idx, func, y_dynamic, x, sparse_rowval, sparse_colval, sparse_colptr, T)
% NB: do as few computations as possible inside this function, since it is
% called a very large number of times
y_dynamic(feedback_vars_idx) = z;
- [~, ~, r, J] = feval(func, y_dynamic, x, DynareModel.params, DynareOutput.steady_state, ...
+ [~, ~, r, J] = feval(func, y_dynamic, x, M_.params, oo_.steady_state, ...
sparse_rowval, sparse_colval, sparse_colptr, T);
end
@@ -63,21 +65,21 @@ for it = initialconditions.nobs+(1:samplesize)
if debug
dprintf('Period t = %s.', num2str(it-initialconditions.nobs));
end
- y_ = DynareOutput.endo_simul(:,it-1);
+ y_ = oo_.endo_simul(:,it-1);
y = y_; % A good guess for the initial conditions is the previous values for the endogenous variables.
- x = DynareOutput.exo_simul(it,:);
+ x = oo_.exo_simul(it,:);
try
- if ismember(DynareOptions.solve_algo, [12,14])
- T = NaN(DynareModel.block_structure.dyn_tmp_nbr);
- y_dynamic = [y_; y; NaN(DynareModel.endo_nbr, 1)];
- for blk = 1:length(DynareModel.block_structure.block)
- sparse_rowval = DynareModel.block_structure.block(blk).g1_sparse_rowval;
- sparse_colval = DynareModel.block_structure.block(blk).g1_sparse_colval;
- sparse_colptr = DynareModel.block_structure.block(blk).g1_sparse_colptr;
- if DynareModel.block_structure.block(blk).Simulation_Type ~= 1 % Not an evaluate forward block
+ if ismember(options_.solve_algo, [12,14])
+ T = NaN(M_.block_structure.dyn_tmp_nbr);
+ y_dynamic = [y_; y; NaN(M_.endo_nbr, 1)];
+ for blk = 1:length(M_.block_structure.block)
+ sparse_rowval = M_.block_structure.block(blk).g1_sparse_rowval;
+ sparse_colval = M_.block_structure.block(blk).g1_sparse_colval;
+ sparse_colptr = M_.block_structure.block(blk).g1_sparse_colptr;
+ if M_.block_structure.block(blk).Simulation_Type ~= 1 % Not an evaluate forward block
[z, errorflag, ~, ~, errorcode] = dynare_solve(@block_wrapper, y_dynamic(feedback_vars_idxs{blk}), ...
- DynareOptions.simul.maxit, DynareOptions.dynatol.f, ...
- DynareOptions.dynatol.x, DynareOptions, ...
+ options_.simul.maxit, options_.dynatol.f, ...
+ options_.dynatol.x, options_, ...
feedback_vars_idxs{blk}, funcs{blk}, y_dynamic, x, sparse_rowval, sparse_colval, sparse_colptr, T);
if errorflag
error('Nonlinear solver routine failed with errorcode=%i in block %i and period %i.', errorcode, blk, it)
@@ -86,44 +88,44 @@ for it = initialconditions.nobs+(1:samplesize)
end
%% Compute endogenous if the block is of type evaluate or if there are recursive variables in a solve block.
%% Also update the temporary terms vector.
- [y_dynamic, T] = feval(funcs{blk}, y_dynamic, x, DynareModel.params, ...
- DynareOutput.steady_state, sparse_rowval, sparse_colval, ...
+ [y_dynamic, T] = feval(funcs{blk}, y_dynamic, x, M_.params, ...
+ oo_.steady_state, sparse_rowval, sparse_colval, ...
sparse_colptr, T);
end
- DynareOutput.endo_simul(:,it) = y_dynamic(DynareModel.endo_nbr+(1:DynareModel.endo_nbr));
+ oo_.endo_simul(:,it) = y_dynamic(M_.endo_nbr+(1:M_.endo_nbr));
else
- [DynareOutput.endo_simul(:,it), errorflag, ~, ~, errorcode] = ...
+ [oo_.endo_simul(:,it), errorflag, ~, ~, errorcode] = ...
dynare_solve(@dynamic_backward_model_for_simulation, y, ...
- DynareOptions.simul.maxit, DynareOptions.dynatol.f, DynareOptions.dynatol.x, ...
- DynareOptions, dynamic_resid, dynamic_g1, y_, x, DynareModel.params, DynareOutput.steady_state, DynareModel.dynamic_g1_sparse_rowval, DynareModel.dynamic_g1_sparse_colval, DynareModel.dynamic_g1_sparse_colptr);
+ options_.simul.maxit, options_.dynatol.f, options_.dynatol.x, ...
+ options_, dynamic_resid, dynamic_g1, y_, x, M_.params, oo_.steady_state, M_.dynamic_g1_sparse_rowval, M_.dynamic_g1_sparse_colval, M_.dynamic_g1_sparse_colptr);
if errorflag
error('Nonlinear solver routine failed with errorcode=%i in period %i.', errorcode, it)
end
end
catch Error
errorflag = true;
- DynareOutput.endo_simul = DynareOutput.endo_simul(:, 1:it-1);
+ oo_.endo_simul = oo_.endo_simul(:, 1:it-1);
dprintf('Newton failed on iteration i = %s.', num2str(it-initialconditions.nobs));
- ytm = DynareOutput.endo_simul(:,end);
- xtt = DynareOutput.exo_simul(it,:);
+ ytm = oo_.endo_simul(:,end);
+ xtt = oo_.exo_simul(it,:);
skipline()
dprintf('Values of the endogenous variables before the nonlinear solver failure')
dprintf('----------------------------------------------------------------------')
skipline()
- dyntable(DynareOptions, '', {'VARIABLES','VALUES'}, DynareModel.endo_names(1:DynareModel.orig_endo_nbr), ytm(1:DynareModel.orig_endo_nbr), [], [], 6)
+ dyntable(options_, '', {'VARIABLES','VALUES'}, M_.endo_names(1:M_.orig_endo_nbr), ytm(1:M_.orig_endo_nbr), [], [], 6)
skipline()
dprintf('Values of the exogenous variables before the nonlinear solver failure')
dprintf('---------------------------------------------------------------------')
skipline()
- dyntable(DynareOptions, '', {'VARIABLES','VALUES'}, DynareModel.exo_names, transpose(DynareOutput.exo_simul(it,:)), [], [], 6)
+ dyntable(options_, '', {'VARIABLES','VALUES'}, M_.exo_names, transpose(oo_.exo_simul(it,:)), [], [], 6)
skipline(2)
%
% Get equation tags if any
%
- if isfield(DynareModel, 'equations_tags')
- etags = cell(DynareModel.orig_endo_nbr, 1);
- for i = 1:DynareModel.orig_endo_nbr
- equations_tags = DynareModel.equations_tags(cellfun(@(x) isequal(x, i), DynareModel.equations_tags(:,1)), :);
+ if isfield(M_, 'equations_tags')
+ etags = cell(M_.orig_endo_nbr, 1);
+ for i = 1:M_.orig_endo_nbr
+ equations_tags = M_.equations_tags(cellfun(@(x) isequal(x, i), M_.equations_tags(:,1)), :);
name = equations_tags(strcmpi(equations_tags(:,2), 'name'),:);
if isempty(name)
eqtags{i} = int2str(i);
@@ -136,31 +138,31 @@ for it = initialconditions.nobs+(1:samplesize)
end
end
else
- etags = split(int2str(1:DynareModel.orig_endo_nbr), ' ');
+ etags = split(int2str(1:M_.orig_endo_nbr), ' ');
end
%
% Evaluate and check the residuals
%
- [r, J] = dynamic_backward_model_for_simulation(ytm, dynamic_resid, dynamic_g1, ytm, x, DynareModel.params, DynareOutput.steady_state, DynareModel.dynamic_g1_sparse_rowval, DynareModel.dynamic_g1_sparse_colval, DynareModel.dynamic_g1_sparse_colptr);
+ [r, J] = dynamic_backward_model_for_simulation(ytm, dynamic_resid, dynamic_g1, ytm, x, M_.params, oo_.steady_state, M_.dynamic_g1_sparse_rowval, M_.dynamic_g1_sparse_colval, M_.dynamic_g1_sparse_colptr);
residuals_evaluating_to_nan = isnan(r);
residuals_evaluating_to_inf = isinf(r);
residuals_evaluating_to_complex = ~isreal(r);
if any(residuals_evaluating_to_nan)
dprintf('Following equations are evaluating to NaN:')
skipline()
- display_names_of_problematic_equations(DynareModel, eqtags, residuals_evaluating_to_nan);
+ display_names_of_problematic_equations(M_, eqtags, residuals_evaluating_to_nan);
skipline()
end
if any(residuals_evaluating_to_inf)
dprintf('Following equations are evaluating to Inf:')
skipline()
- display_names_of_problematic_equations(DynareModel, eqtags, residuals_evaluating_to_inf);
+ display_names_of_problematic_equations(M_, eqtags, residuals_evaluating_to_inf);
skipline()
end
if any(residuals_evaluating_to_complex)
dprintf('Following equations are evaluating to a complex number:')
skipline()
- display_names_of_problematic_equations(DynareModel, eqtags, residuals_evaluating_to_complex);
+ display_names_of_problematic_equations(M_, eqtags, residuals_evaluating_to_complex);
skipline()
end
dprintf('Newton failed in period %s with the following error message:', char(initialconditions.lastdate+(it-initialconditions.nobs)));
@@ -173,20 +175,20 @@ for it = initialconditions.nobs+(1:samplesize)
end
end
-ysim = DynareOutput.endo_simul(1:DynareModel.orig_endo_nbr,:);
-xsim = DynareOutput.exo_simul;
+ysim = oo_.endo_simul(1:M_.orig_endo_nbr,:);
+xsim = oo_.exo_simul;
end
-function display_names_of_problematic_equations(DynareModel, eqtags, TruthTable)
-for i=1:DynareModel.orig_endo_nbr
+function display_names_of_problematic_equations(M_, eqtags, TruthTable)
+for i=1:M_.orig_endo_nbr
if TruthTable(i)
dprintf(' - %s', eqtags{i})
end
end
-for i=DynareModel.orig_endo_nbr+1:DynareModel.endo_nbr
+for i=M_.orig_endo_nbr+1:M_.endo_nbr
if TruthTable(i)
- dprintf(' - Auxiliary equation for %s', DynareModel.endo_names{i})
+ dprintf(' - Auxiliary equation for %s', M_.endo_names{i})
end
end
end
diff --git a/matlab/compute_trend_coefficients.m b/matlab/compute_trend_coefficients.m
index 2dbed2ae2..59c2a9188 100644
--- a/matlab/compute_trend_coefficients.m
+++ b/matlab/compute_trend_coefficients.m
@@ -1,12 +1,12 @@
-function [trend_addition, trend_coeff]=compute_trend_coefficients(M_,DynareOptions,nvarobs,ntobs)
-% [trend_addition, trend_coeff]=compute_trend_coefficients(M_,DynareOptions,nvarobs,ntobs)
+function [trend_addition, trend_coeff]=compute_trend_coefficients(M_,options_,nvarobs,ntobs)
+% [trend_addition, trend_coeff]=compute_trend_coefficients(M_,options_,nvarobs,ntobs)
% Computes the trend coefficiencts and the trend, accounting for
% prefiltering
%
% INPUTS
% M_ [structure] describing the model; called in the eval
% statement
-% DynareOptions [structure] describing the options
+% options_ [structure] describing the options
% nvarobs [scalar] number of observed variables
% ntobs [scalar] length of data sample for estimation
%
@@ -18,7 +18,7 @@ function [trend_addition, trend_coeff]=compute_trend_coefficients(M_,DynareOptio
% SPECIAL REQUIREMENTS
% none
-% Copyright © 2014-2016 Dynare Team
+% Copyright © 2014-2023 Dynare Team
%
% This file is part of Dynare.
%
@@ -37,13 +37,13 @@ function [trend_addition, trend_coeff]=compute_trend_coefficients(M_,DynareOptio
trend_coeff = zeros(nvarobs,1);
-t = DynareOptions.trend_coeffs;
+t = options_.trend_coeffs;
for i=1:length(t)
if ~isempty(t{i})
trend_coeff(i) = eval(t{i});
end
end
-trend_addition=trend_coeff*[DynareOptions.first_obs:DynareOptions.first_obs+ntobs-1];
-if DynareOptions.prefilter
+trend_addition=trend_coeff*[options_.first_obs:options_.first_obs+ntobs-1];
+if options_.prefilter
trend_addition = bsxfun(@minus,trend_addition,mean(trend_addition,2));
end
diff --git a/matlab/convergence_diagnostics/geweke_chi2_test.m b/matlab/convergence_diagnostics/geweke_chi2_test.m
index 7afee0098..0ef388d0f 100644
--- a/matlab/convergence_diagnostics/geweke_chi2_test.m
+++ b/matlab/convergence_diagnostics/geweke_chi2_test.m
@@ -1,5 +1,5 @@
-function results_struct = geweke_chi2_test(results1,results2,results_struct,options)
-% results_struct = geweke_chi2_test(results1,results2,results_struct,options)
+function results_struct = geweke_chi2_test(results1,results2,results_struct,options_)
+% results_struct = geweke_chi2_test(results1,results2,results_struct,options_)
% PURPOSE: computes Geweke's chi-squared test for two sets of MCMC sample draws
%
% INPUTS
@@ -10,7 +10,7 @@ function results_struct = geweke_chi2_test(results1,results2,results_struct,opti
% std, NSE_iid, RNE_iid, and tapered NSE and RNE
% for chain part 2
% results_struct [structure] results structure generated by geweke_moments
-% Dynareoptions [structure]
+% options_ [structure]
%
% OUTPUTS
% results_struct [structure] containing the following fields:
@@ -57,7 +57,7 @@ function results_struct = geweke_chi2_test(results1,results2,results_struct,opti
% based on code by James P. LeSage, who in turn
% drew on MATLAB programs written by Siddartha Chib
-for k=1:length(options.convergence.geweke.taper_steps)+1
+for k=1:length(options_.convergence.geweke.taper_steps)+1
NSE=[results1(:,3+(k-1)*2) results2(:,3+(k-1)*2)];
means=[results1(:,1) results2(:,1)];
diff_Means=means(:,1)-means(:,2);
diff --git a/matlab/convergence_diagnostics/geweke_moments.m b/matlab/convergence_diagnostics/geweke_moments.m
index 2a97ff51f..e6736132c 100644
--- a/matlab/convergence_diagnostics/geweke_moments.m
+++ b/matlab/convergence_diagnostics/geweke_moments.m
@@ -1,11 +1,11 @@
-function [results_vec, results_struct] = geweke_moments(draws,Dynareoptions)
-%[results_vec, results_struct] = geweke_moments(draws,Dynareoptions)
+function [results_vec, results_struct] = geweke_moments(draws,options_)
+%[results_vec, results_struct] = geweke_moments(draws,options_)
% PURPOSE: computes Gewke's convergence diagnostics NSE and RNE
% (numerical std error and relative numerical efficiencies)
% INPUTS
% draws [ndraws by 1 vector]
-% Dynareoptions [structure]
+% options_ [structure]
%
% OUTPUTS
% results_vec
@@ -22,7 +22,7 @@ function [results_vec, results_struct] = geweke_moments(draws,Dynareoptions)
% SPECIAL REQUIREMENTS
% None.
-% Copyright © 2013-2017 Dynare Team
+% Copyright © 2013-2023 Dynare Team
%
% This file is part of Dynare.
%
@@ -56,7 +56,7 @@ function [results_vec, results_struct] = geweke_moments(draws,Dynareoptions)
ndraw = size(draws,1);
n_groups=100;
-taper_steps=Dynareoptions.convergence.geweke.taper_steps;
+taper_steps=options_.convergence.geweke.taper_steps;
results_vec=zeros(1,4+2*length(taper_steps));
ns = floor(ndraw/n_groups); %step_size
diff --git a/matlab/dyn_first_order_solver.m b/matlab/dyn_first_order_solver.m
index 66306d645..8ec20650a 100644
--- a/matlab/dyn_first_order_solver.m
+++ b/matlab/dyn_first_order_solver.m
@@ -1,12 +1,12 @@
-function [dr, info] = dyn_first_order_solver(jacobia, DynareModel, dr, DynareOptions, task)
-
+function [dr, info] = dyn_first_order_solver(jacobia, M_, dr, options_, task)
+% [dr, info] = dyn_first_order_solver(jacobia, M_, dr, options_, task)
% Computes the first order reduced form of a DSGE model.
%
% INPUTS
% - jacobia [double] matrix, the jacobian of the dynamic model.
-% - DynareModel [struct] Matlab's structre describing the model, M_ global.
+% - M_ [struct] Matlab's structre describing the model
% - dr [struct] Matlab's structure describing the reduced form model.
-% - DynareOptions [struct] Matlab's structure containing the current state of the options, oo_ global.
+% - options_ [struct] Matlab's structure containing the current state of the options
% - task [integer] scalar, if task = 0 then decision rules are computed and if task = 1 then only eigenvales are computed.
%
% OUTPUTS
@@ -21,7 +21,7 @@ function [dr, info] = dyn_first_order_solver(jacobia, DynareModel, dr, DynareOpt
% info=5 -> Blanchard and Kahn conditions are not satisfied: indeterminacy due to rank failure,
% info=7 -> One of the eigenvalues is close to 0/0 (infinity of complex solutions)
-% Copyright © 2001-2020 Dynare Team
+% Copyright © 2001-2023 Dynare Team
%
% This file is part of Dynare.
%
@@ -53,24 +53,24 @@ if ~nargin
return
end
-exo_nbr = DynareModel.exo_nbr;
+exo_nbr = M_.exo_nbr;
if isempty(reorder_jacobian_columns)
- maximum_lag = DynareModel.maximum_endo_lag;
- nfwrd = DynareModel.nfwrd;
- nboth = DynareModel.nboth;
- npred = DynareModel.npred;
- nstatic = DynareModel.nstatic;
- ndynamic = DynareModel.ndynamic;
- nsfwrd = DynareModel.nsfwrd;
+ maximum_lag = M_.maximum_endo_lag;
+ nfwrd = M_.nfwrd;
+ nboth = M_.nboth;
+ npred = M_.npred;
+ nstatic = M_.nstatic;
+ ndynamic = M_.ndynamic;
+ nsfwrd = M_.nsfwrd;
k1 = 1:(npred+nboth);
k2 = 1:(nfwrd+nboth);
order_var = dr.order_var;
nd = npred+nfwrd+2*nboth;
- lead_lag_incidence = DynareModel.lead_lag_incidence;
+ lead_lag_incidence = M_.lead_lag_incidence;
nz = nnz(lead_lag_incidence);
lead_id = find(lead_lag_incidence(maximum_lag+2,:));
@@ -141,12 +141,12 @@ B(:,cols_b) = aa(:,index_c); % Jacobian matrix for contemporaneous endogeneous
C = aa(:,index_p); % Jacobain matrix for led endogeneous variables
info = 0;
-if task ~= 1 && (DynareOptions.dr_cycle_reduction || DynareOptions.dr_logarithmic_reduction)
- if n_current < DynareModel.endo_nbr
- if DynareOptions.dr_cycle_reduction
+if task ~= 1 && (options_.dr_cycle_reduction || options_.dr_logarithmic_reduction)
+ if n_current < M_.endo_nbr
+ if options_.dr_cycle_reduction
error(['The cycle reduction algorithme can''t be used when the ' ...
'coefficient matrix for current variables isn''t invertible'])
- elseif DynareOptions.dr_logarithmic_reduction
+ elseif options_.dr_logarithmic_reduction
error(['The logarithmic reduction algorithme can''t be used when the ' ...
'coefficient matrix for current variables isn''t invertible'])
end
@@ -154,10 +154,10 @@ if task ~= 1 && (DynareOptions.dr_cycle_reduction || DynareOptions.dr_logarithmi
A1 = [aa(row_indx,index_m ) zeros(ndynamic,nfwrd)];
B1 = [aa(row_indx,index_0m) aa(row_indx,index_0p) ];
C1 = [zeros(ndynamic,npred) aa(row_indx,index_p)];
- if DynareOptions.dr_cycle_reduction
- [ghx, info] = cycle_reduction(A1, B1, C1, DynareOptions.dr_cycle_reduction_tol);
+ if options_.dr_cycle_reduction
+ [ghx, info] = cycle_reduction(A1, B1, C1, options_.dr_cycle_reduction_tol);
else
- [ghx, info] = logarithmic_reduction(C1, B1, A1, DynareOptions.dr_logarithmic_reduction_tol, DynareOptions.dr_logarithmic_reduction_maxiter);
+ [ghx, info] = logarithmic_reduction(C1, B1, A1, options_.dr_logarithmic_reduction_tol, options_.dr_logarithmic_reduction_maxiter);
end
if info
% cycle_reduction or logarithmic redution failed and set info
@@ -174,7 +174,7 @@ else
E(row_indx_de_1,index_e1) = -aa(row_indx,index_e);
E(row_indx_de_2,index_e2) = eye(nboth);
- [ss, tt, w, sdim, dr.eigval, info1] = mjdgges(E, D, DynareOptions.qz_criterium, DynareOptions.qz_zero_threshold);
+ [ss, tt, w, sdim, dr.eigval, info1] = mjdgges(E, D, options_.qz_criterium, options_.qz_zero_threshold);
if info1
if info1 == -30
@@ -204,10 +204,10 @@ else
if nba ~= nsfwrd
temp = sort(abs(dr.eigval));
if nba > nsfwrd
- temp = temp(nd-nba+1:nd-nsfwrd)-1-DynareOptions.qz_criterium;
+ temp = temp(nd-nba+1:nd-nsfwrd)-1-options_.qz_criterium;
info(1) = 3;
elseif nba < nsfwrd
- temp = temp(nd-nsfwrd+1:nd-nba)-1-DynareOptions.qz_criterium;
+ temp = temp(nd-nsfwrd+1:nd-nba)-1-options_.qz_criterium;
info(1) = 4;
end
info(2) = temp'*temp;
@@ -262,7 +262,7 @@ if nstatic > 0
b11 = b(1:nstatic, nstatic+1:end);
temp(:,index_m) = temp(:,index_m)-A(1:nstatic,:);
temp = b10\(temp-b11*ghx);
- if DynareOptions.debug
+ if options_.debug
if any(any(~isfinite(temp)))
fprintf('\ndyn_first_order_solver: infinite/NaN elements encountered when solving for the static variables\n')
fprintf('dyn_first_order_solver: This often arises if there is a singularity.\n\n')
@@ -288,7 +288,7 @@ end
dr.ghx = ghx;
dr.ghu = ghu;
-if DynareOptions.aim_solver ~= 1
+if options_.aim_solver ~= 1
% Necessary when using Sims' routines for QZ
dr.ghx = real(ghx);
dr.ghu = real(ghu);
diff --git a/matlab/endogenous_prior_restrictions.m b/matlab/endogenous_prior_restrictions.m
index efb52b2c6..8d045cf43 100644
--- a/matlab/endogenous_prior_restrictions.m
+++ b/matlab/endogenous_prior_restrictions.m
@@ -1,11 +1,11 @@
-function [info, info_irf, info_moment, data_irf, data_moment] = endogenous_prior_restrictions(T,R,Model,DynareOptions,dr, endo_steady_state, exo_steady_state, exo_det_steady_state)
-%[info, info_irf, info_moment, data_irf, data_moment] = endogenous_prior_restrictions(T,R,Model,DynareOptions,dr, endo_steady_state, exo_steady_state, exo_det_steady_state)
+function [info, info_irf, info_moment, data_irf, data_moment] = endogenous_prior_restrictions(T,R,M_,options_,dr, endo_steady_state, exo_steady_state, exo_det_steady_state)
+%[info, info_irf, info_moment, data_irf, data_moment] = endogenous_prior_restrictions(T,R,M_,options_,dr, endo_steady_state, exo_steady_state, exo_det_steady_state)
% Check for prior (sign) restrictions on irf's and theoretical moments
% INPUTS
% T [double] n*n state space matrix
% R [double] n*k matrix of shocks
-% Model [structure]
-% DynareOptions [structure]
+% M_ [structure]
+% options_ [structure]
% dr [structure] Reduced form model.
% endo_steady_state [vector] steady state value for endogenous variables
% exo_steady_state [vector] steady state value for exogenous variables
@@ -41,17 +41,17 @@ info_moment=[];
data_irf=[];
data_moment=[];
-endo_prior_restrictions.irf= DynareOptions.endogenous_prior_restrictions.irf;
-endo_prior_restrictions.moment= DynareOptions.endogenous_prior_restrictions.moment;
+endo_prior_restrictions.irf= options_.endogenous_prior_restrictions.irf;
+endo_prior_restrictions.moment= options_.endogenous_prior_restrictions.moment;
if ~isempty(endo_prior_restrictions.irf)
data_irf=cell(size(endo_prior_restrictions.irf,1),1);
- if DynareOptions.order>1
+ if options_.order>1
error('The algorithm for prior (sign) restrictions on irf''s is currently restricted to first-order decision rules')
end
- varlist = Model.endo_names(dr.order_var);
+ varlist = M_.endo_names(dr.order_var);
if isempty(T)
- [T,R,SteadyState,infox,dr, Model.params] = dynare_resolve(Model,DynareOptions,dr, endo_steady_state, exo_steady_state, exo_det_steady_state);
+ [T,R,SteadyState,infox,dr, M_.params] = dynare_resolve(M_,options_,dr, endo_steady_state, exo_steady_state, exo_det_steady_state);
else % check if T and R are given in the restricted form!!!
if size(T,1)endo_prior_restrictions.irf{j,4}(1)) && (RR(iendo,iexo)1
+ if options_.order>1
error('The algorithm for prior (sign) restrictions on moments is currently restricted to first-order decision rules')
end
data_moment=cell(size(endo_prior_restrictions.moment,1),1);
@@ -130,15 +130,15 @@ if ~isempty(endo_prior_restrictions.moment)
nvar = size(var_list_,1);
ivar=zeros(nvar,1);
for i=1:nvar
- i_tmp = strmatch(var_list_(i,:), Model.endo_names, 'exact');
+ 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
- DynareOptions.ar = max(abs(NTmin),NTmax);
- [gamma_y,stationary_vars] = th_autocovariances(dr, ivar, Model, DynareOptions,1);
+ options_.ar = max(abs(NTmin),NTmax);
+ [gamma_y,stationary_vars] = th_autocovariances(dr, ivar, M_, options_,1);
for t=NTmin:NTmax
RR = gamma_y{abs(t)+1};
if t==0
diff --git a/matlab/evaluate_likelihood.m b/matlab/evaluate_likelihood.m
index 25b4735b6..9b017689a 100644
--- a/matlab/evaluate_likelihood.m
+++ b/matlab/evaluate_likelihood.m
@@ -5,22 +5,22 @@ function [llik,parameters] = evaluate_likelihood(parameters,M_,estim_params_,oo_
% INPUTS
% o parameters a string ('posterior mode','posterior mean','posterior median','prior mode','prior mean') or a vector of values for
% the (estimated) parameters of the model.
-% o M_ [structure] Definition of the model
-% o estim_params_ [structure] characterizing parameters to be estimated
-% o oo_ [structure] Storage of results
-% o options_ [structure] Options
-% o bayestopt_ [structure] describing the priors
+% o M_ [structure] Definition of the model
+% o estim_params_ [structure] characterizing parameters to be estimated
+% o oo_ [structure] Storage of results
+% o options_ [structure] Options
+% o bayestopt_ [structure] describing the priors
%
% OUTPUTS
-% o ldens [double] value of the sample logged density at parameters.
-% o parameters [double] vector of values for the estimated parameters.
+% o ldens [double] value of the sample logged density at parameters.
+% o parameters [double] vector of values for the estimated parameters.
%
% SPECIAL REQUIREMENTS
% None
%
% REMARKS
% [1] This function cannot evaluate the likelihood of a dsge-var model...
-% [2] This function use persistent variables for the dataset and the description of the missing observations. Consequently, if this function
+% [2] This function use persistent variables for the dataset_ and the description of the missing observations. Consequently, if this function
% is called more than once (by changing the value of parameters) the sample *must not* change.
% Copyright © 2009-2023 Dynare Team
@@ -40,7 +40,7 @@ function [llik,parameters] = evaluate_likelihood(parameters,M_,estim_params_,oo_
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see .
-persistent dataset dataset_info
+persistent dataset_ dataset_info
if nargin==0
parameters = 'posterior mode';
@@ -69,8 +69,8 @@ if ischar(parameters)
end
end
-if isempty(dataset)
- [dataset, dataset_info] = makedataset(options_);
+if isempty(dataset_)
+ [dataset_, dataset_info] = makedataset(options_);
end
options_=select_qz_criterium_value(options_);
@@ -88,9 +88,9 @@ end
if options_.occbin.likelihood.status && options_.occbin.likelihood.inversion_filter
- llik = -occbin.IVF_posterior(parameters,dataset,dataset_info,options_,M_,estim_params_,bayestopt_,bounds,oo_.dr, oo_.steady_state,oo_.exo_steady_state,oo_.exo_det_steady_state);
+ llik = -occbin.IVF_posterior(parameters,dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,bounds,oo_.dr, oo_.steady_state,oo_.exo_steady_state,oo_.exo_det_steady_state);
else
- llik = -dsge_likelihood(parameters,dataset,dataset_info,options_,M_,estim_params_,bayestopt_,bounds,oo_.dr, oo_.steady_state,oo_.exo_steady_state,oo_.exo_det_steady_state);
+ llik = -dsge_likelihood(parameters,dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,bounds,oo_.dr, oo_.steady_state,oo_.exo_steady_state,oo_.exo_det_steady_state);
end
ldens = evaluate_prior(parameters,M_,estim_params_,oo_,options_,bayestopt_);
llik = llik - ldens;
\ No newline at end of file
diff --git a/matlab/get_error_message.m b/matlab/get_error_message.m
index 120d79908..581fb3f90 100644
--- a/matlab/get_error_message.m
+++ b/matlab/get_error_message.m
@@ -1,16 +1,16 @@
-function message = get_error_message(info, DynareOptions)
+function message = get_error_message(info, options_)
% Returns error messages
%
% INPUTS
% info [double] vector returned by resol.m
-% DynareOptions [structure] --> options_
+% options_ [structure] Dynare options
% OUTPUTS
% message [string] corresponding error message
%
% SPECIAL REQUIREMENTS
% none
-% Copyright © 2005-2020 Dynare Team
+% Copyright © 2005-2023 Dynare Team
%
% This file is part of Dynare.
%
@@ -43,7 +43,7 @@ switch info(1)
case 6
message = 'The Jacobian matrix evaluated at the steady state contains elements that are not real or are infinite.';
case 7
- message = sprintf('One of the eigenvalues is close to 0/0 (the absolute value of numerator and denominator is smaller than %5.4f!\n If you believe that the model has a unique solution you can try to reduce the value of qz_zero_threshold.',DynareOptions.qz_zero_threshold);
+ message = sprintf('One of the eigenvalues is close to 0/0 (the absolute value of numerator and denominator is smaller than %5.4f!\n If you believe that the model has a unique solution you can try to reduce the value of qz_zero_threshold.',options_.qz_zero_threshold);
case 8
if size(info,2)>=2 && info(2)~=0
global M_;
@@ -66,7 +66,7 @@ switch info(1)
case 19
message = 'The steadystate file did not compute the steady state';
case 20
- if DynareOptions.linear
+ if options_.linear
message = sprintf('Impossible to find the steady state (the sum of squared residuals of the static equations is %5.4f). Either the model doesn''t have a steady state or there are an infinity of steady states. Check whether your model is truly linear or whether there is a mistake in linearization.', info(2));
else
message = sprintf('Impossible to find the steady state (the sum of squared residuals of the static equations is %5.4f). Either the model doesn''t have a steady state, there are an infinity of steady states, or the guess values are too far from the solution', info(2));
diff --git a/matlab/graph_decomp.m b/matlab/graph_decomp.m
index 2d4ef77aa..7553bf189 100644
--- a/matlab/graph_decomp.m
+++ b/matlab/graph_decomp.m
@@ -1,5 +1,5 @@
-function []=graph_decomp(z,shock_names,endo_names,i_var,initial_date,DynareModel,DynareOptions)
-%function []=graph_decomp(z,shock_names,endo_names,i_var,initial_date,DynareModel,DynareOptions)
+function []=graph_decomp(z,shock_names,endo_names,i_var,initial_date,M_,options_)
+% []=graph_decomp(z,shock_names,endo_names,i_var,initial_date,M_,options_)
% Plots the results from the shock_decomposition command
%
% Inputs
@@ -8,10 +8,10 @@ function []=graph_decomp(z,shock_names,endo_names,i_var,initial_date,DynareModel
% endo_names [exo_nbr*string length] variable names from M_.endo_names
% i_var [n_var*1] vector indices of requested variables in M_.endo_names and z
% initial_date [dseries object] first period of decomposition to plot
-% DynareModel [structure] Dynare model structure
-% DynareOptions [structure] Dynare options structure
+% M_ [structure] Dynare model structure
+% options_ [structure] Dynare options structure
-% Copyright © 2010-2018 Dynare Team
+% Copyright © 2010-2023 Dynare Team
%
% This file is part of Dynare.
%
@@ -28,10 +28,10 @@ function []=graph_decomp(z,shock_names,endo_names,i_var,initial_date,DynareModel
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see .
-if ~DynareOptions.plot_shock_decomp.expand
- GraphDirectoryName = CheckPath('graphs',DynareModel.dname);
+if ~options_.plot_shock_decomp.expand
+ GraphDirectoryName = CheckPath('graphs',M_.dname);
end
-new_colormap = DynareOptions.plot_shock_decomp.colormap;
+new_colormap = options_.plot_shock_decomp.colormap;
% number of components equals number of shocks + 1 (initial conditions)
comp_nbr = size(z,2)-1;
@@ -41,7 +41,7 @@ fig_mode='';
fig_mode1='';
% fig_name='';
% screen_shocks=0;
-opts_decomp = DynareOptions.plot_shock_decomp;
+opts_decomp = options_.plot_shock_decomp;
if isfield(opts_decomp,'steady_state')
SteadyState = opts_decomp.steady_state;
end
@@ -59,13 +59,13 @@ end
fig_name_long = opts_decomp.fig_name;
-use_shock_groups = DynareOptions.plot_shock_decomp.use_shock_groups;
+use_shock_groups = options_.plot_shock_decomp.use_shock_groups;
screen_shocks = opts_decomp.screen_shocks;
if ~isempty(use_shock_groups) || comp_nbr<=18
screen_shocks=0;
end
if use_shock_groups
- shock_groups = DynareModel.shock_groups.(use_shock_groups);
+ shock_groups = M_.shock_groups.(use_shock_groups);
shock_ind = fieldnames(shock_groups);
end
if screen_shocks
@@ -96,8 +96,8 @@ end
nvar = length(i_var);
%% write LaTeX-Header
-if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.plot_shock_decomp.graph_format))) && ~DynareOptions.plot_shock_decomp.expand
- fidTeX = fopen([GraphDirectoryName, filesep, DynareModel.fname '_shock_decomp' fig_mode1 fig_name '.tex'],'w');
+if options_.TeX && any(strcmp('eps',cellstr(options_.plot_shock_decomp.graph_format))) && ~options_.plot_shock_decomp.expand
+ fidTeX = fopen([GraphDirectoryName, filesep, M_.fname '_shock_decomp' fig_mode1 fig_name '.tex'],'w');
fprintf(fidTeX,'%% TeX eps-loader file generated by Dynare''s graph_decomp.m.\n');
fprintf(fidTeX,['%% ' datestr(now,0) '\n']);
fprintf(fidTeX,' \n');
@@ -143,12 +143,12 @@ for j=1:nvar
if ymax-ymin < 1e-6
continue
end
- fhandle = dyn_figure(DynareOptions.plot_shock_decomp.nodisplay,'Name',[preamble_txt fig_name_long strrep(fig_mode1, '_', ' ') ': ' endo_names{i_var(j)} '.'], 'PaperPositionMode', 'auto','PaperOrientation','landscape','renderermode','auto');
+ fhandle = dyn_figure(options_.plot_shock_decomp.nodisplay,'Name',[preamble_txt fig_name_long strrep(fig_mode1, '_', ' ') ': ' endo_names{i_var(j)} '.'], 'PaperPositionMode', 'auto','PaperOrientation','landscape','renderermode','auto');
set(fhandle,'position' ,[50 50 1500 750])
ax=axes('Position',[0.1 0.1 0.6 0.8],'box','on');
% plot(ax,x(2:end),z1(end,:),'k-','LineWidth',2)
% axis(ax,[xmin xmax ymin ymax]);
- if strcmp('aoa',DynareOptions.plot_shock_decomp.type)
+ if strcmp('aoa',options_.plot_shock_decomp.type)
bgap = 0.15;
else
bgap = 0;
@@ -210,17 +210,17 @@ for j=1:nvar
ht = text(0.3,y1+0.3*height,labels(i,:),'Interpreter','none');
hold on
if interactive && (~isoctave && ~isempty(use_shock_groups))
- mydata.fig_name = DynareOptions.plot_shock_decomp.fig_name(2:end);
- mydata.use_shock_groups = DynareOptions.plot_shock_decomp.use_shock_groups;
+ mydata.fig_name = options_.plot_shock_decomp.fig_name(2:end);
+ mydata.use_shock_groups = options_.plot_shock_decomp.use_shock_groups;
mydata.shock_group = shock_groups.(shock_ind{i});
- mydata.shock_decomp = DynareOptions.shock_decomp;
- mydata.plot_shock_decomp = DynareOptions.plot_shock_decomp;
- mydata.first_obs = DynareOptions.first_obs;
- mydata.nobs = DynareOptions.nobs;
- mydata.plot_shock_decomp.zfull = DynareOptions.plot_shock_decomp.zfull(i_var(j),:,:);
+ mydata.shock_decomp = options_.shock_decomp;
+ mydata.plot_shock_decomp = options_.plot_shock_decomp;
+ mydata.first_obs = options_.first_obs;
+ mydata.nobs = options_.nobs;
+ mydata.plot_shock_decomp.zfull = options_.plot_shock_decomp.zfull(i_var(j),:,:);
mydata.endo_names = endo_names(i_var(j));
- mydata.endo_names_tex = DynareModel.endo_names_tex(i_var(j));
- mydata.exo_names = DynareModel.exo_names;
+ mydata.endo_names_tex = M_.endo_names_tex(i_var(j));
+ mydata.exo_names = M_.exo_names;
if ~isempty(mydata.shock_group.shocks)
c = uicontextmenu;
hl.UIContextMenu=c;
@@ -242,28 +242,28 @@ for j=1:nvar
colormap(new_colormap)
end
hold off
- if ~DynareOptions.plot_shock_decomp.expand
+ if ~options_.plot_shock_decomp.expand
- dyn_saveas(fhandle,[GraphDirectoryName, filesep, DynareModel.fname,preamble_figname,endo_names{i_var(j)},fig_mode1,fig_name],DynareOptions.plot_shock_decomp.nodisplay,DynareOptions.plot_shock_decomp.graph_format);
- if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.plot_shock_decomp.graph_format)))
+ dyn_saveas(fhandle,[GraphDirectoryName, filesep, M_.fname,preamble_figname,endo_names{i_var(j)},fig_mode1,fig_name],options_.plot_shock_decomp.nodisplay,options_.plot_shock_decomp.graph_format);
+ if options_.TeX && any(strcmp('eps',cellstr(options_.plot_shock_decomp.graph_format)))
fprintf(fidTeX,'\\begin{figure}[H]\n');
fprintf(fidTeX,'\\centering \n');
- fprintf(fidTeX,'\\includegraphics[width=0.8\\textwidth]{%s/graphs/%s%s}\n',DynareModel.fname,DynareModel.fname,[preamble_figname endo_names{i_var(j)} fig_mode1 fig_name]);
+ fprintf(fidTeX,'\\includegraphics[width=0.8\\textwidth]{%s/graphs/%s%s}\n',M_.fname,M_.fname,[preamble_figname endo_names{i_var(j)} fig_mode1 fig_name]);
fprintf(fidTeX,'\\label{Fig:shock_decomp:%s}\n',[fig_mode endo_names{i_var(j)} fig_name]);
- fprintf(fidTeX,['\\caption{' preamble_txt fig_name_long strrep(fig_mode1, '_', ' ') ': $ %s $.}\n'],DynareModel.endo_names_tex{i_var(j)});
+ fprintf(fidTeX,['\\caption{' preamble_txt fig_name_long strrep(fig_mode1, '_', ' ') ': $ %s $.}\n'],M_.endo_names_tex{i_var(j)});
fprintf(fidTeX,'\\end{figure}\n');
fprintf(fidTeX,' \n');
end
else
- if ~isempty(DynareOptions.plot_shock_decomp.filepath)
- dyn_saveas(fhandle,[DynareOptions.plot_shock_decomp.filepath, filesep, DynareModel.fname,preamble_figname,endo_names{i_var(j)},fig_mode1,fig_name],DynareOptions.plot_shock_decomp.nodisplay,DynareOptions.plot_shock_decomp.graph_format);
+ if ~isempty(options_.plot_shock_decomp.filepath)
+ dyn_saveas(fhandle,[options_.plot_shock_decomp.filepath, filesep, M_.fname,preamble_figname,endo_names{i_var(j)},fig_mode1,fig_name],options_.plot_shock_decomp.nodisplay,options_.plot_shock_decomp.graph_format);
end
end
end
%% write LaTeX-Footer
-if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.plot_shock_decomp.graph_format))) && ~DynareOptions.plot_shock_decomp.expand
+if options_.TeX && any(strcmp('eps',cellstr(options_.plot_shock_decomp.graph_format))) && ~options_.plot_shock_decomp.expand
fprintf(fidTeX,' \n');
fprintf(fidTeX,'%% End of TeX file.\n');
fclose(fidTeX);
diff --git a/matlab/graph_decomp_detail.m b/matlab/graph_decomp_detail.m
index 8bb86a19e..dde4a90db 100644
--- a/matlab/graph_decomp_detail.m
+++ b/matlab/graph_decomp_detail.m
@@ -1,5 +1,5 @@
-function []=graph_decomp_detail(z,shock_names,endo_names,i_var,initial_date,DynareModel,DynareOptions)
-%function []=graph_decomp_detail(z,shock_names,endo_names,i_var,initial_date,DynareModel,DynareOptions)
+function []=graph_decomp_detail(z,shock_names,endo_names,i_var,initial_date,M_,options_)
+% []=graph_decomp_detail(z,shock_names,endo_names,i_var,initial_date,M_,options_)
% Plots the results from the shock_decomposition command
%
% Inputs
@@ -8,10 +8,10 @@ function []=graph_decomp_detail(z,shock_names,endo_names,i_var,initial_date,Dyna
% endo_names [exo_nbr*string length] variable names from M_.endo_names
% i_var [n_var*1] vector indices of requested variables in M_.endo_names and z
% initial_date [dseries object] first period of decomposition to plot
-% DynareModel [structure] Dynare model structure
-% DynareOptions [structure] Dynare options structure
+% M_ [structure] Dynare model structure
+% options_ [structure] Dynare options structure
-% Copyright © 2010-2018 Dynare Team
+% Copyright © 2010-2023 Dynare Team
%
% This file is part of Dynare.
%
@@ -28,25 +28,25 @@ function []=graph_decomp_detail(z,shock_names,endo_names,i_var,initial_date,Dyna
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see .
-if ~DynareOptions.plot_shock_decomp.expand
- GraphDirectoryName = CheckPath('graphs',DynareModel.dname);
+if ~options_.plot_shock_decomp.expand
+ GraphDirectoryName = CheckPath('graphs',M_.dname);
end
% interactive = 0;
fig_mode='';
fig_mode1='';
% fig_name='';
% screen_shocks=0;
-initval = DynareOptions.plot_shock_decomp.initval;
-use_shock_groups = DynareOptions.plot_shock_decomp.use_shock_groups;
+initval = options_.plot_shock_decomp.initval;
+use_shock_groups = options_.plot_shock_decomp.use_shock_groups;
if use_shock_groups
- shock_groups = DynareModel.shock_groups.(use_shock_groups);
+ shock_groups = M_.shock_groups.(use_shock_groups);
shock_ind = fieldnames(shock_groups);
end
% number of components equals number of shocks + 1 (initial conditions)
comp_nbr = size(z,2)-1;
-opts_decomp = DynareOptions.plot_shock_decomp;
+opts_decomp = options_.plot_shock_decomp;
interactive = opts_decomp.interactive;
if ~isempty(opts_decomp.type)
@@ -62,7 +62,7 @@ else
end
max_nrows = opts_decomp.max_nrows;
screen_shocks = opts_decomp.screen_shocks;
-if ~isempty(DynareOptions.plot_shock_decomp.use_shock_groups) || comp_nbr<=18
+if ~isempty(options_.plot_shock_decomp.use_shock_groups) || comp_nbr<=18
screen_shocks=0;
end
fig_name_long = opts_decomp.fig_name;
@@ -118,8 +118,8 @@ end
nvar = length(i_var);
%% write LaTeX-Header
-if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.plot_shock_decomp.graph_format))) && ~DynareOptions.plot_shock_decomp.expand
- fidTeX = fopen([GraphDirectoryName, filesep, DynareModel.fname '_shock_decomp' fig_mode1 fig_name '_detail.tex'],'w');
+if options_.TeX && any(strcmp('eps',cellstr(options_.plot_shock_decomp.graph_format))) && ~options_.plot_shock_decomp.expand
+ fidTeX = fopen([GraphDirectoryName, filesep, M_.fname '_shock_decomp' fig_mode1 fig_name '_detail.tex'],'w');
fprintf(fidTeX,'%% TeX eps-loader file generated by Dynare''s graph_decomp_detail.m.\n');
fprintf(fidTeX,['%% ' datestr(now,0) '\n']);
fprintf(fidTeX,' \n');
@@ -178,7 +178,7 @@ for j=1:nvar
continue
end
for jf = 1:nfigs
- fhandle = dyn_figure(DynareOptions.plot_shock_decomp.nodisplay,'Name',[preamble_txt fig_name_long strrep(fig_mode1, '_', ' ') ': ' endo_names{i_var(j)} ' (detail).'],'position',[200 100 650 850], 'PaperPositionMode', 'auto','PaperOrientation','portrait','renderermode','auto');
+ fhandle = dyn_figure(options_.plot_shock_decomp.nodisplay,'Name',[preamble_txt fig_name_long strrep(fig_mode1, '_', ' ') ': ' endo_names{i_var(j)} ' (detail).'],'position',[200 100 650 850], 'PaperPositionMode', 'auto','PaperOrientation','portrait','renderermode','auto');
a0=zeros(1,4);
a0(3)=inf;
a0(4)=-inf;
@@ -216,17 +216,17 @@ for j=1:nvar
set(gca,'ylim',a0(3:4))
hold on, h1=plot(x(2:end),z1(end,:),'k-','LineWidth',2);
if interactive && (~isoctave && ~isempty(use_shock_groups))
- mydata.fig_name = DynareOptions.plot_shock_decomp.fig_name(2:end);
- mydata.use_shock_groups = DynareOptions.plot_shock_decomp.use_shock_groups;
+ mydata.fig_name = options_.plot_shock_decomp.fig_name(2:end);
+ mydata.use_shock_groups = options_.plot_shock_decomp.use_shock_groups;
mydata.shock_group = shock_groups.(shock_ind{ic});
- mydata.shock_decomp = DynareOptions.shock_decomp;
- mydata.plot_shock_decomp = DynareOptions.plot_shock_decomp;
- mydata.first_obs = DynareOptions.first_obs;
- mydata.nobs = DynareOptions.nobs;
- mydata.plot_shock_decomp.zfull = DynareOptions.plot_shock_decomp.zfull(i_var(j),:,:);
+ mydata.shock_decomp = options_.shock_decomp;
+ mydata.plot_shock_decomp = options_.plot_shock_decomp;
+ mydata.first_obs = options_.first_obs;
+ mydata.nobs = options_.nobs;
+ mydata.plot_shock_decomp.zfull = options_.plot_shock_decomp.zfull(i_var(j),:,:);
mydata.endo_names = endo_names(i_var(j));
- mydata.endo_names_tex = DynareModel.endo_names_tex(i_var(j));
- mydata.exo_names = DynareModel.exo_names;
+ mydata.endo_names_tex = M_.endo_names_tex(i_var(j));
+ mydata.exo_names = M_.exo_names;
if ~isempty(mydata.shock_group.shocks)
c = uicontextmenu;
hax.UIContextMenu=c;
@@ -271,28 +271,28 @@ for j=1:nvar
else
suffix = ['_detail'];
end
- if ~DynareOptions.plot_shock_decomp.expand
- dyn_saveas(fhandle,[GraphDirectoryName, filesep, DynareModel.fname, ...
- preamble_figname, endo_names{i_var(j)}, fig_mode1,fig_name suffix],DynareOptions.plot_shock_decomp.nodisplay,DynareOptions.plot_shock_decomp.graph_format);
- if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.plot_shock_decomp.graph_format)))
+ if ~options_.plot_shock_decomp.expand
+ dyn_saveas(fhandle,[GraphDirectoryName, filesep, M_.fname, ...
+ preamble_figname, endo_names{i_var(j)}, fig_mode1,fig_name suffix],options_.plot_shock_decomp.nodisplay,options_.plot_shock_decomp.graph_format);
+ if options_.TeX && any(strcmp('eps',cellstr(options_.plot_shock_decomp.graph_format)))
fprintf(fidTeX,'\\begin{figure}[H]\n');
fprintf(fidTeX,'\\centering \n');
- fprintf(fidTeX,'\\includegraphics[width=0.8\\textwidth]{%s/graphs/%s%s}\n',DynareModel.fname,DynareModel.fname,[preamble_figname endo_names{i_var(j)} fig_mode1 fig_name suffix]);
+ fprintf(fidTeX,'\\includegraphics[width=0.8\\textwidth]{%s/graphs/%s%s}\n',M_.fname,M_.fname,[preamble_figname endo_names{i_var(j)} fig_mode1 fig_name suffix]);
fprintf(fidTeX,'\\label{Fig:shock_decomp_detail:%s}\n',[fig_mode endo_names{i_var(j)} fig_name suffix]);
- fprintf(fidTeX,['\\caption{' preamble_txt fig_name_long strrep(fig_mode1, '_', ' ') ': $ %s $ (detail).}\n'], DynareModel.endo_names_tex{i_var(j)});
+ fprintf(fidTeX,['\\caption{' preamble_txt fig_name_long strrep(fig_mode1, '_', ' ') ': $ %s $ (detail).}\n'], M_.endo_names_tex{i_var(j)});
fprintf(fidTeX,'\\end{figure}\n');
fprintf(fidTeX,' \n');
end
else
- if ~isempty(DynareOptions.plot_shock_decomp.filepath)
- dyn_saveas(fhandle,[DynareOptions.plot_shock_decomp.filepath, filesep, DynareModel.fname,preamble_figname,endo_names{i_var(j)},fig_mode1,fig_name suffix],DynareOptions.plot_shock_decomp.nodisplay,DynareOptions.plot_shock_decomp.graph_format);
+ if ~isempty(options_.plot_shock_decomp.filepath)
+ dyn_saveas(fhandle,[options_.plot_shock_decomp.filepath, filesep, M_.fname,preamble_figname,endo_names{i_var(j)},fig_mode1,fig_name suffix],options_.plot_shock_decomp.nodisplay,options_.plot_shock_decomp.graph_format);
end
end
end
end
%% write LaTeX-Footer
-if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.plot_shock_decomp.graph_format))) && ~DynareOptions.plot_shock_decomp.expand
+if options_.TeX && any(strcmp('eps',cellstr(options_.plot_shock_decomp.graph_format))) && ~options_.plot_shock_decomp.expand
fprintf(fidTeX,' \n');
fprintf(fidTeX,'%% End of TeX file.\n');
fclose(fidTeX);
diff --git a/matlab/initial_estimation_checks.m b/matlab/initial_estimation_checks.m
index 62b4921d6..fd03649ee 100644
--- a/matlab/initial_estimation_checks.m
+++ b/matlab/initial_estimation_checks.m
@@ -7,7 +7,7 @@ function oo_ = initial_estimation_checks(objective_function,xparam1,dataset_,dat
% xparam1 [vector] of parameters to be estimated
% dataset_ [dseries] object storing the dataset
% dataset_info [structure] storing informations about the sample.
-% M_ [structure] decribing the model
+% M_ [structure] describing the model
% estim_params_ [structure] characterizing parameters to be estimated
% options_ [structure] describing the options
% bayestopt_ [structure] describing the priors
diff --git a/matlab/lyapunov_solver.m b/matlab/lyapunov_solver.m
index 8dcb3b9e6..172687007 100644
--- a/matlab/lyapunov_solver.m
+++ b/matlab/lyapunov_solver.m
@@ -1,5 +1,5 @@
-function P=lyapunov_solver(T,R,Q,DynareOptions)
-% function P=lyapunov_solver(T,R,Q,DynareOptions)
+function P=lyapunov_solver(T,R,Q,options_)
+% function P=lyapunov_solver(T,R,Q,options_)
% Solves the Lyapunov equation P-T*P*T' = R*Q*R' arising in a state-space
% system, where P is the variance of the states
%
@@ -7,7 +7,7 @@ function P=lyapunov_solver(T,R,Q,DynareOptions)
% T [double] n*n matrix.
% R [double] n*m matrix.
% Q [double] m*m matrix.
-% DynareOptions [structure] Dynare options
+% options_ [structure] Dynare options
%
% Outputs
% P [double] n*n matrix.
@@ -15,11 +15,11 @@ function P=lyapunov_solver(T,R,Q,DynareOptions)
% Algorithms
% Default, if none of the other algorithms is selected:
% Reordered Schur decomposition (Bartels-Stewart algorithm)
-% DynareOptions.lyapunov_fp == true
+% options_.lyapunov_fp == true
% iteration-based fixed point algorithm
-% DynareOptions.lyapunov_db == true
+% options_.lyapunov_db == true
% doubling algorithm
-% DynareOptions.lyapunov_srs == true
+% options_.lyapunov_srs == true
% Square-root solver for discrete-time Lyapunov equations (requires Matlab System Control toolbox
% or Octave control package)
@@ -40,14 +40,14 @@ function P=lyapunov_solver(T,R,Q,DynareOptions)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see .
-if DynareOptions.lyapunov_fp
- P = lyapunov_symm(T,R*Q*R',DynareOptions.lyapunov_fixed_point_tol,DynareOptions.qz_criterium,DynareOptions.lyapunov_complex_threshold, 3, DynareOptions.debug);
-elseif DynareOptions.lyapunov_db
- [P, errorflag] = disclyap_fast(T,R*Q*R',DynareOptions.lyapunov_doubling_tol);
+if options_.lyapunov_fp
+ P = lyapunov_symm(T,R*Q*R',options_.lyapunov_fixed_point_tol,options_.qz_criterium,options_.lyapunov_complex_threshold, 3, options_.debug);
+elseif options_.lyapunov_db
+ [P, errorflag] = disclyap_fast(T,R*Q*R',options_.lyapunov_doubling_tol);
if errorflag %use Schur-based method
- P = lyapunov_symm(T,R*Q*R',DynareOptions.lyapunov_fixed_point_tol,DynareOptions.qz_criterium,DynareOptions.lyapunov_complex_threshold, [], DynareOptions.debug);
+ P = lyapunov_symm(T,R*Q*R',options_.lyapunov_fixed_point_tol,options_.qz_criterium,options_.lyapunov_complex_threshold, [], options_.debug);
end
-elseif DynareOptions.lyapunov_srs
+elseif options_.lyapunov_srs
% works only with Matlab System Control toolbox or Octave control package,
if isoctave
if ~user_has_octave_forge_package('control')
@@ -62,7 +62,7 @@ elseif DynareOptions.lyapunov_srs
R_P = dlyapchol(T,chol_Q);
P = R_P' * R_P;
else
- P = lyapunov_symm(T,R*Q*R',DynareOptions.lyapunov_fixed_point_tol,DynareOptions.qz_criterium,DynareOptions.lyapunov_complex_threshold, [], DynareOptions.debug);
+ P = lyapunov_symm(T,R*Q*R',options_.lyapunov_fixed_point_tol,options_.qz_criterium,options_.lyapunov_complex_threshold, [], options_.debug);
end
return % --*-- Unit tests --*--
@@ -92,7 +92,7 @@ tmp2=randn(m_large,m_large);
Q_large=tmp2*tmp2';
R_large=randn(n_large,m_large);
-% DynareOptions.lyapunov_fp == 1
+% options_.lyapunov_fp == 1
options_.lyapunov_fp = true;
try
Pstar1_small = lyapunov_solver(T_small,R_small,Q_small,options_);
@@ -102,7 +102,7 @@ catch
t(1) = 0;
end
-% Dynareoptions.lyapunov_db == 1
+% options_.lyapunov_db == 1
options_.lyapunov_fp = false;
options_.lyapunov_db = true;
try
@@ -113,7 +113,7 @@ catch
t(2) = 0;
end
-% Dynareoptions.lyapunov_srs == 1
+% options_.lyapunov_srs == 1
if (isoctave && user_has_octave_forge_package('control')) || (~isoctave && user_has_matlab_license('control_toolbox'))
options_.lyapunov_db = false;
options_.lyapunov_srs = true;
diff --git a/matlab/maximize_prior_density.m b/matlab/maximize_prior_density.m
index 4e7543410..191ac064c 100644
--- a/matlab/maximize_prior_density.m
+++ b/matlab/maximize_prior_density.m
@@ -1,5 +1,5 @@
function [xparams,lpd,hessian_mat] = ...
- maximize_prior_density(iparams, prior_shape, prior_hyperparameter_1, prior_hyperparameter_2, prior_inf_bound, prior_sup_bound,DynareOptions,DynareModel,BayesInfo,EstimatedParams,DynareResults)
+ maximize_prior_density(iparams, prior_shape, prior_hyperparameter_1, prior_hyperparameter_2, prior_inf_bound, prior_sup_bound,options_,M_,bayestopt_,estim_params_,oo_)
% Maximizes the logged prior density using Chris Sims' optimization routine.
%
% INPUTS
@@ -9,13 +9,18 @@ function [xparams,lpd,hessian_mat] = ...
% prior_hyperparameter_2 [double] vector, second hyperparameter.
% prior_inf_bound [double] vector, prior's lower bound.
% prior_sup_bound [double] vector, prior's upper bound.
+% options_ [structure] describing the options
+% bayestopt_ [structure] describing the priors
+% M_ [structure] describing the model
+% estim_params_ [structure] characterizing parameters to be estimated
+% oo_ [structure] storing the results
%
% OUTPUTS
% xparams [double] vector, prior mode.
% lpd [double] scalar, value of the logged prior density at the mode.
% hessian_mat [double] matrix, Hessian matrix at the prior mode.
-% Copyright © 2009-2017 Dynare Team
+% Copyright © 2009-2023 Dynare Team
%
% This file is part of Dynare.
%
@@ -33,9 +38,9 @@ function [xparams,lpd,hessian_mat] = ...
% along with Dynare. If not, see .
[xparams, lpd, exitflag, hessian_mat]=dynare_minimize_objective('minus_logged_prior_density', ...
- iparams, DynareOptions.mode_compute, DynareOptions, [prior_inf_bound, prior_sup_bound], ...
- BayesInfo.name, BayesInfo, [], ...
+ iparams, options_.mode_compute, options_, [prior_inf_bound, prior_sup_bound], ...
+ bayestopt_.name, bayestopt_, [], ...
prior_shape, prior_hyperparameter_1, prior_hyperparameter_2, prior_inf_bound, prior_sup_bound, ...
- DynareOptions,DynareModel,EstimatedParams,DynareResults);
+ options_,M_,estim_params_,oo_);
lpd = -lpd;
diff --git a/matlab/mex/k_order_welfare.m b/matlab/mex/k_order_welfare.m
index b50d48a77..3cdf8a9e0 100644
--- a/matlab/mex/k_order_welfare.m
+++ b/matlab/mex/k_order_welfare.m
@@ -1,10 +1,10 @@
-% W = k_order_welfare(dr, DynareModel, DynareOptions)
+% W = k_order_welfare(dr, M_, options_)
% computes a k-th order approximation of welfare
%
% INPUTS
% dr: struct describing the reduced form solution of the model.
-% DynareModel: struct jobs's parameters
-% DynareOptions: struct job's options
+% M_: struct jobs's parameters
+% options_: struct job's options
%
% OUTPUTS
%
diff --git a/matlab/minus_logged_prior_density.m b/matlab/minus_logged_prior_density.m
index d8dfd5f64..ef61fd9c5 100644
--- a/matlab/minus_logged_prior_density.m
+++ b/matlab/minus_logged_prior_density.m
@@ -1,13 +1,19 @@
-function [fval,info,exit_flag,fake_1,fake_2] = minus_logged_prior_density(xparams,pshape,p6,p7,p3,p4,DynareOptions,DynareModel,EstimatedParams,DynareResults)
+function [fval,info,exit_flag,fake_1,fake_2] = minus_logged_prior_density(xparams,pshape,p6,p7,p3,p4,options_,M_,estim_params_,oo_)
+% [fval,info,exit_flag,fake_1,fake_2] = minus_logged_prior_density(xparams,pshape,p6,p7,p3,p4,options_,M_,estim_params_,oo_)
% Evaluates minus the logged prior density.
%
% INPUTS
-% xparams [double] vector of parameters.
-% pshape [integer] vector specifying prior densities shapes.
-% p6 [double] vector, first hyperparameter.
-% p7 [double] vector, second hyperparameter.
-% p3 [double] vector, prior's lower bound.
-% p4 [double] vector, prior's upper bound.
+% xparams [double] vector of parameters.
+% pshape [integer] vector specifying prior densities shapes.
+% p6 [double] vector, first hyperparameter.
+% p7 [double] vector, second hyperparameter.
+% p3 [double] vector, prior's lower bound.
+% p4 [double] vector, prior's upper bound.
+% prior_sup_bound [double] vector, prior's upper bound.
+% options_ [structure] describing the options
+% M_ [structure] describing the model
+% estim_params_ [structure] characterizing parameters to be estimated
+% oo_ [structure] storing the results
%
% OUTPUTS
% f [double] value of minus the logged prior density.
@@ -41,7 +47,7 @@ info = zeros(4,1);
%------------------------------------------------------------------------------
% Return, with endogenous penalty, if some parameters are smaller than the lower bound of the prior domain.
-if ~isequal(DynareOptions.mode_compute,1) && any(xparamsp4)
+if ~isequal(options_.mode_compute,1) && any(xparams>p4)
k = find(xparams>p4);
fval = Inf;
exit_flag = 0;
@@ -61,13 +67,13 @@ if ~isequal(DynareOptions.mode_compute,1) && any(xparams>p4)
end
% Get the diagonal elements of the covariance matrices for the structural innovations (Q) and the measurement error (H).
-DynareModel = set_all_parameters(xparams,EstimatedParams,DynareModel);
+M_ = set_all_parameters(xparams,estim_params_,M_);
-Q = DynareModel.Sigma_e;
-H = DynareModel.H;
+Q = M_.Sigma_e;
+H = M_.H;
% Test if Q is positive definite.
-if ~issquare(Q) || EstimatedParams.ncx || isfield(EstimatedParams,'calibrated_covariances')
+if ~issquare(Q) || estim_params_.ncx || isfield(estim_params_,'calibrated_covariances')
% Try to compute the cholesky decomposition of Q (possible iff Q is positive definite)
[Q_is_positive_definite, penalty] = ispd(Q);
if ~Q_is_positive_definite
@@ -78,22 +84,22 @@ if ~issquare(Q) || EstimatedParams.ncx || isfield(EstimatedParams,'calibrated_co
info(4) = penalty;
return
end
- if isfield(EstimatedParams,'calibrated_covariances')
+ if isfield(estim_params_,'calibrated_covariances')
correct_flag=check_consistency_covariances(Q);
if ~correct_flag
- penalty = sum(Q(EstimatedParams.calibrated_covariances.position).^2);
+ penalty = sum(Q(estim_params_.calibrated_covariances.position).^2);
fval = Inf;
exit_flag = 0;
info(1) = 71;
info(4) = penalty;
- return
+ return4
end
end
end
% Test if H is positive definite.
-if ~issquare(H) || EstimatedParams.ncn || isfield(EstimatedParams,'calibrated_covariances_ME')
+if ~issquare(H) || estim_params_.ncn || isfield(estim_params_,'calibrated_covariances_ME')
[H_is_positive_definite, penalty] = ispd(H);
if ~H_is_positive_definite
% The variance-covariance matrix of the measurement errors is not definite positive. We have to compute the eigenvalues of this matrix in order to build the endogenous penalty.
@@ -103,10 +109,10 @@ if ~issquare(H) || EstimatedParams.ncn || isfield(EstimatedParams,'calibrated_co
info(4) = penalty;
return
end
- if isfield(EstimatedParams,'calibrated_covariances_ME')
+ if isfield(estim_params_,'calibrated_covariances_ME')
correct_flag=check_consistency_covariances(H);
if ~correct_flag
- penalty = sum(H(EstimatedParams.calibrated_covariances_ME.position).^2);
+ penalty = sum(H(estim_params_.calibrated_covariances_ME.position).^2);
fval = Inf;
exit_flag = 0;
info(1) = 72;
@@ -121,7 +127,7 @@ end
% 2. Check BK and steady state
%-----------------------------
-[~,info] = resol(0,DynareModel,DynareOptions,DynareResults.dr,DynareResults.steady_state, DynareResults.exo_steady_state, DynareResults.exo_det_steady_state);
+[~,info] = resol(0,M_,options_,oo_.dr,oo_.steady_state, oo_.exo_steady_state, oo_.exo_det_steady_state);
% Return, with endogenous penalty when possible, if dynare_resolve issues an error code (defined in resol).
if info(1)
diff --git a/matlab/model_inversion.m b/matlab/model_inversion.m
index 06e45cdd1..dcdb50e00 100644
--- a/matlab/model_inversion.m
+++ b/matlab/model_inversion.m
@@ -1,16 +1,16 @@
function [endogenousvariables, exogenousvariables] = model_inversion(constraints, ...
exogenousvariables, ...
- initialconditions, DynareModel, DynareOptions, DynareOutput)
+ initialconditions, M_, options_, oo_)
% function [endogenousvariables, exogenousvariables] = model_inversion(constraints, ...
% exogenousvariables, ...
-% initialconditions, DynareModel, DynareOptions, DynareOutput)
+% initialconditions, M_, options_, oo_)
% INPUTS
% - constraints [dseries] with N constrained endogenous variables from t1 to t2.
% - exogenousvariables [dseries] with Q exogenous variables.
% - initialconditions [dseries] with M endogenous variables starting before t1 (M initialcond must contain at least the state variables).
-% - DynareModel [struct] M_, Dynare global structure containing informations related to the model.
-% - DynareOptions [struct] options_, Dynare global structure containing all the options.
-% - DynareOutput [struct] oo_, Dynare global structure containing all the options.
+% - M_ [struct] Dynare global structure containing informations related to the model.
+% - options_ [struct] Dynare global structure containing all the options.
+% - oo_ [struct] Dynare global structure containing all the options.
%
% OUTPUTS
% - endogenousvariables [dseries]
@@ -18,7 +18,7 @@ function [endogenousvariables, exogenousvariables] = model_inversion(constraints
%
% REMARKS
-% Copyright © 2018-2021 Dynare Team
+% Copyright © 2018-2023 Dynare Team
%
% This file is part of Dynare.
%
@@ -51,7 +51,7 @@ if ~isempty(initialconditions) && ~isdseries(initialconditions)
error('model_inversion: Third input argument must be a dseries object!')
end
-if ~isstruct(DynareModel)
+if ~isstruct(M_)
error('model_inversion: Last input argument must be structures (M_)!')
end
@@ -71,29 +71,29 @@ if exogenousvariables.vobs>constraints.vobs
observed_exogenous_variables_flag = true;
end
-if DynareModel.maximum_lag
+if M_.maximum_lag
% Add auxiliary variables in initialconditions object.
- initialconditions = checkdatabase(initialconditions, DynareModel, true, false);
+ initialconditions = checkdatabase(initialconditions, M_, true, false);
end
% Get the list of endogenous and exogenous variables.
-endo_names = DynareModel.endo_names;
-exo_names = DynareModel.exo_names;
+endo_names = M_.endo_names;
+exo_names = M_.exo_names;
exogenousvariables = exogenousvariables{exo_names{:}};
% Use specidalized routine if the model is backward looking.
-if ~DynareModel.maximum_lead
- if DynareModel.maximum_lag
+if ~M_.maximum_lead
+ if M_.maximum_lag
[endogenousvariables, exogenousvariables] = ...
backward_model_inversion(constraints, exogenousvariables, initialconditions, ...
endo_names, exo_names, freeinnovations, ...
- DynareModel, DynareOptions, DynareOutput);
+ M_, options_, oo_);
else
[endogenousvariables, exogenousvariables] = ...
static_model_inversion(constraints, exogenousvariables, ...
endo_names, exo_names, freeinnovations, ...
- DynareModel, DynareOptions, DynareOutput);
+ M_, options_, oo_);
end
return
end
diff --git a/matlab/non_linear_dsge_likelihood.m b/matlab/non_linear_dsge_likelihood.m
index 632585cbc..a7b13c179 100644
--- a/matlab/non_linear_dsge_likelihood.m
+++ b/matlab/non_linear_dsge_likelihood.m
@@ -1,5 +1,5 @@
-function [fval,info,exit_flag,DLIK,Hess,ys,trend_coeff,M_,options_,bayestopt_,dr] = non_linear_dsge_likelihood(xparam1,dataset_,dataset_info,options_,M_,EstimatedParameters,bayestopt_,BoundsInfo,dr, endo_steady_state, exo_steady_state, exo_det_steady_state)
-% [fval,info,exit_flag,DLIK,Hess,ys,trend_coeff,M_,options_,bayestopt_,dr] = non_linear_dsge_likelihood(xparam1,dataset_,dataset_info,options_,M_,EstimatedParameters,bayestopt_,BoundsInfo,dr, endo_steady_state, exo_steady_state, exo_det_steady_state)
+function [fval,info,exit_flag,DLIK,Hess,ys,trend_coeff,M_,options_,bayestopt_,dr] = non_linear_dsge_likelihood(xparam1,dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,BoundsInfo,dr, endo_steady_state, exo_steady_state, exo_det_steady_state)
+% [fval,info,exit_flag,DLIK,Hess,ys,trend_coeff,M_,options_,bayestopt_,dr] = non_linear_dsge_likelihood(xparam1,dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,BoundsInfo,dr, endo_steady_state, exo_steady_state, exo_det_steady_state)
% Evaluates the posterior kernel of a dsge model using a non linear filter.
%
% INPUTS
@@ -8,7 +8,7 @@ function [fval,info,exit_flag,DLIK,Hess,ys,trend_coeff,M_,options_,bayestopt_,dr
% - dataset_info [struct] Matlab's structure describing the dataset
% - options_ [struct] Matlab's structure describing the options
% - M_ [struct] Matlab's structure describing the M_
-% - EstimatedParameters [struct] Matlab's structure describing the estimated_parameters
+% - estim_params_ [struct] Matlab's structure describing the estimated_parameters
% - bayestopt_ [struct] Matlab's structure describing the priors
% - BoundsInfo [struct] Matlab's structure specifying the bounds on the paramater values
% - dr [structure] Reduced form model.
@@ -71,9 +71,9 @@ end
% 1. Get the structural parameters & define penalties
%------------------------------------------------------------------------------
-M_ = set_all_parameters(xparam1,EstimatedParameters,M_);
+M_ = set_all_parameters(xparam1,estim_params_,M_);
-[fval,info,exit_flag,Q,H]=check_bounds_and_definiteness_estimation(xparam1, M_, EstimatedParameters, BoundsInfo);
+[fval,info,exit_flag,Q,H]=check_bounds_and_definiteness_estimation(xparam1, M_, estim_params_, BoundsInfo);
if info(1)
return
end
diff --git a/matlab/optimization/mr_gstep.m b/matlab/optimization/mr_gstep.m
index a7f39a604..6a403ea7a 100644
--- a/matlab/optimization/mr_gstep.m
+++ b/matlab/optimization/mr_gstep.m
@@ -3,13 +3,14 @@ function [f0, x, ig] = mr_gstep(h1,x,bounds,func0,penalty,htol0,Verbose,Save_fil
%
% Gibbs type step in optimisation
%
-% varargin{1} --> DynareDataset
-% varargin{2} --> DatasetInfo
-% varargin{3} --> DynareOptions
-% varargin{4} --> Model
-% varargin{5} --> EstimatedParameters
-% varargin{6} --> BayesInfo
-% varargin{1} --> DynareResults
+% varargin{1} --> dataset_
+% varargin{2} --> dataset_info
+% varargin{3} --> options_
+% varargin{4} --> M_
+% varargin{5} --> estim_params_
+% varargin{6} --> bayestopt_
+% varargin{7} --> BoundsInfo
+% varargin{8} --> oo_
% Copyright © 2006-2020 Dynare Team
%
diff --git a/matlab/optimization/mr_hessian.m b/matlab/optimization/mr_hessian.m
index 133cb2800..f13bdd63f 100644
--- a/matlab/optimization/mr_hessian.m
+++ b/matlab/optimization/mr_hessian.m
@@ -29,14 +29,14 @@ function [hessian_mat, gg, htol1, ihh, hh_mat0, hh1, hess_info] = mr_hessian(x,f
% - Save_files indicator whether files should be saved
% - varargin other inputs
% e.g. in dsge_likelihood
-% varargin{1} --> DynareDataset
-% varargin{2} --> DatasetInfo
-% varargin{3} --> DynareOptions
-% varargin{4} --> Model
-% varargin{5} --> EstimatedParameters
-% varargin{6} --> BayesInfo
-% varargin{7} --> Bounds
-% varargin{8} --> DynareResults
+% varargin{1} --> dataset_
+% varargin{2} --> dataset_info
+% varargin{3} --> options_
+% varargin{4} --> M_
+% varargin{5} --> estim_params_
+% varargin{6} --> bayestopt_
+% varargin{7} --> BoundsInfo
+% varargin{8} --> oo_
%
% Outputs
% - hessian_mat hessian
diff --git a/matlab/optimization/newrat.m b/matlab/optimization/newrat.m
index 4f1108ca5..d1d75f3b3 100644
--- a/matlab/optimization/newrat.m
+++ b/matlab/optimization/newrat.m
@@ -28,14 +28,14 @@ function [xparam1, hh, gg, fval, igg, hess_info] = newrat(func0, x, bounds, anal
% - parameter_names [cell] names of parameters for error messages
% - varargin other inputs
% e.g. in dsge_likelihood and others:
-% varargin{1} --> DynareDataset
-% varargin{2} --> DatasetInfo
-% varargin{3} --> DynareOptions
-% varargin{4} --> Model
-% varargin{5} --> EstimatedParameters
-% varargin{6} --> BayesInfo
-% varargin{7} --> Bounds
-% varargin{8} --> DynareResults
+% varargin{1} --> dataset_
+% varargin{2} --> dataset_info
+% varargin{3} --> options_
+% varargin{4} --> M_
+% varargin{5} --> estim_params_
+% varargin{6} --> bayestopt_
+% varargin{7} --> BoundsInfo
+% varargin{8} --> oo_
%
% Outputs
% - xparam1 parameter vector at optimum
diff --git a/matlab/optimization/simplex_optimization_routine.m b/matlab/optimization/simplex_optimization_routine.m
index 4a05e5227..931d9785d 100644
--- a/matlab/optimization/simplex_optimization_routine.m
+++ b/matlab/optimization/simplex_optimization_routine.m
@@ -15,13 +15,14 @@ function [x,fval,exitflag] = simplex_optimization_routine(objective_function,x,o
% for verbose output
% o varargin [cell of structures] Structures to be passed to the objective function.
%
-% varargin{1} --> DynareDataset
-% varargin{2} --> DatasetInfo
-% varargin{3} --> DynareOptions
-% varargin{4} --> Model
-% varargin{5} --> EstimatedParameters
-% varargin{6} --> BayesInfo
-% varargin{1} --> DynareResults
+% varargin{1} --> dataset_
+% varargin{2} --> dataset_info
+% varargin{3} --> options_
+% varargin{4} --> M_
+% varargin{5} --> estim_params_
+% varargin{6} --> bayestopt_
+% varargin{7} --> BoundsInfo
+% varargin{8} --> oo_
%
% OUTPUTS
% o x [double] n*1 vector, estimate of the optimal inputs.
diff --git a/matlab/optimize_prior.m b/matlab/optimize_prior.m
index cd03c734f..261b6bb9d 100644
--- a/matlab/optimize_prior.m
+++ b/matlab/optimize_prior.m
@@ -1,8 +1,15 @@
-function optimize_prior(DynareOptions, ModelInfo, DynareResults, BayesInfo, EstimationInfo)
-
+function optimize_prior(options_, M_, oo_, bayestopt_, estim_params_)
+% optimize_prior(options_, M_, oo_, bayestopt_, estim_params_)
% This routine computes the mode of the prior density using an optimization algorithm.
+%
+% INPUTS
+% options_ [structure] describing the options
+% M_ [structure] describing the model
+% oo_ [structure] storing the results
+% bayestopt_ [structure] describing the priors
+% estim_params_ [structure] characterizing parameters to be estimated
-% Copyright © 2015-2017 Dynare Team
+% Copyright © 2015-2023 Dynare Team
%
% This file is part of Dynare.
%
@@ -20,16 +27,16 @@ function optimize_prior(DynareOptions, ModelInfo, DynareResults, BayesInfo, Esti
% along with Dynare. If not, see .
% Initialize to the prior mean
-DynareResults.dr = set_state_space(DynareResults.dr,ModelInfo);
-xparam1 = BayesInfo.p1;
+oo_.dr = set_state_space(oo_.dr,M_);
+xparam1 = bayestopt_.p1;
% Pertubation of the initial condition.
look_for_admissible_initial_condition = 1; scale = 1.0; iter = 0;
while look_for_admissible_initial_condition
xinit = xparam1+scale*randn(size(xparam1));
- if all(xinit(:)>BayesInfo.p3) && all(xinit(:)bayestopt_.p3) && all(xinit(:).
-if DynareOptions.stack_solve_algo < 0 || DynareOptions.stack_solve_algo > 7
+if options_.stack_solve_algo < 0 || options_.stack_solve_algo > 7
error('perfect_foresight_solver:ArgCheck','PERFECT_FORESIGHT_SOLVER: stack_solve_algo must be between 0 and 7')
end
-if ~DynareOptions.block && ~DynareOptions.bytecode && DynareOptions.stack_solve_algo ~= 0 ...
- && DynareOptions.stack_solve_algo ~= 1 && DynareOptions.stack_solve_algo ~= 6 ...
- && DynareOptions.stack_solve_algo ~= 7
+if ~options_.block && ~options_.bytecode && options_.stack_solve_algo ~= 0 ...
+ && options_.stack_solve_algo ~= 1 && options_.stack_solve_algo ~= 6 ...
+ && options_.stack_solve_algo ~= 7
error('perfect_foresight_solver:ArgCheck','PERFECT_FORESIGHT_SOLVER: you must use stack_solve_algo={0,1,6,7} when not using block nor bytecode option')
end
-if DynareOptions.block && ~DynareOptions.bytecode && DynareOptions.stack_solve_algo == 5
+if options_.block && ~options_.bytecode && options_.stack_solve_algo == 5
error('perfect_foresight_solver:ArgCheck','PERFECT_FORESIGHT_SOLVER: you can''t use stack_solve_algo = 5 without bytecode option')
end
-if isempty(DynareResults.endo_simul) || any(size(DynareResults.endo_simul) ~= [ DynareModel.endo_nbr, DynareModel.maximum_lag+DynareOptions.periods+DynareModel.maximum_lead ])
+if isempty(oo_.endo_simul) || any(size(oo_.endo_simul) ~= [ M_.endo_nbr, M_.maximum_lag+options_.periods+M_.maximum_lead ])
- if DynareOptions.initval_file
- fprintf('PERFECT_FORESIGHT_SOLVER: ''oo_.endo_simul'' has wrong size. Check whether your initval-file provides %d periods.',DynareModel.maximum_endo_lag+DynareOptions.periods+DynareModel.maximum_endo_lead)
+ if options_.initval_file
+ fprintf('PERFECT_FORESIGHT_SOLVER: ''oo_.endo_simul'' has wrong size. Check whether your initval-file provides %d periods.',M_.maximum_endo_lag+options_.periods+M_.maximum_endo_lead)
error('perfect_foresight_solver:ArgCheck','PERFECT_FORESIGHT_SOLVER: ''oo_.endo_simul'' has wrong size. Did you run ''perfect_foresight_setup'' ?')
else
error('perfect_foresight_solver:ArgCheck','PERFECT_FORESIGHT_SOLVER: ''oo_.endo_simul'' has wrong size. Did you run ''perfect_foresight_setup'' ?')
end
end
-if (DynareModel.exo_nbr > 0) && ...
- (isempty(DynareResults.exo_simul) || any(size(DynareResults.exo_simul) ~= [ DynareModel.maximum_lag+DynareOptions.periods+DynareModel.maximum_lead, DynareModel.exo_nbr ]))
- if DynareOptions.initval_file
- fprintf('PERFECT_FORESIGHT_SOLVER: ''oo_.exo_simul'' has wrong size. Check whether your initval-file provides %d periods.',DynareModel.maximum_endo_lag+DynareOptions.periods+DynareModel.maximum_endo_lead)
+if (M_.exo_nbr > 0) && ...
+ (isempty(oo_.exo_simul) || any(size(oo_.exo_simul) ~= [ M_.maximum_lag+options_.periods+M_.maximum_lead, M_.exo_nbr ]))
+ if options_.initval_file
+ fprintf('PERFECT_FORESIGHT_SOLVER: ''oo_.exo_simul'' has wrong size. Check whether your initval-file provides %d periods.',M_.maximum_endo_lag+options_.periods+M_.maximum_endo_lead)
error('perfect_foresight_solver:ArgCheck','PERFECT_FORESIGHT_SOLVER: ''oo_.exo_simul'' has wrong size.')
else
error('perfect_foresight_solver:ArgCheck','PERFECT_FORESIGHT_SOLVER: ''oo_.exo_simul'' has wrong size. Did you run ''perfect_foresight_setup'' ?')
diff --git a/matlab/print_info.m b/matlab/print_info.m
index 7afed6575..5b54af3f6 100644
--- a/matlab/print_info.m
+++ b/matlab/print_info.m
@@ -1,17 +1,18 @@
-function print_info(info, noprint, DynareOptions)
+function print_info(info, noprint, options_)
+% print_info(info, noprint, options_)
% Prints error messages
%
% INPUTS
% info [double] vector returned by resol.m
% noprint [integer] equal to 0 if the error message has to be printed.
-% DynareOptions [structure] --> options_
+% options_ [structure] Dynare options
% OUTPUTS
% none
%
% SPECIAL REQUIREMENTS
% none
-% Copyright © 2005-2020 Dynare Team
+% Copyright © 2005-2023 Dynare Team
%
% This file is part of Dynare.
%
@@ -28,6 +29,6 @@ function print_info(info, noprint, DynareOptions)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see .
if ~noprint
- message = get_error_message(info, DynareOptions);
+ message = get_error_message(info, options_);
error(message);
end
\ No newline at end of file
diff --git a/matlab/print_table_prior.m b/matlab/print_table_prior.m
index 34dd6a403..b8c7a2337 100644
--- a/matlab/print_table_prior.m
+++ b/matlab/print_table_prior.m
@@ -1,8 +1,14 @@
-function print_table_prior(lb, ub, DynareOptions, ModelInfo, BayesInfo, EstimationInfo)
-
+function print_table_prior(lb, ub, options_, M_, bayestopt_, estim_params_)
+% print_table_prior(lb, ub, options_, M_, bayestopt_, estim_params_)
% This routine prints in the command window some descriptive statistics about the prior distribution.
+% Inputs:
+% o lb [double] lower bound
+% o ub [double] upper bound
+% o M_ [structure] Definition of the model
+% o bayestopt_ [structure] describing the priors
+% o estim_params_ [structure] characterizing parameters to be estimated
-% Copyright © 2015-2017 Dynare Team
+% Copyright © 2015-2023 Dynare Team
%
% This file is part of Dynare.
%
@@ -28,7 +34,7 @@ PriorNames = strvcat(PriorNames,'Inverted Gamma -- 2');
PriorNames = strvcat(PriorNames,'Dirichlet');
PriorNames = strvcat(PriorNames,'Weibull');
-n = size(BayesInfo.name,1); % Numbe rof estimated parameters.
+n = size(bayestopt_.name,1); % Numbe rof estimated parameters.
l1 = printline(10, '-');
T1 = strvcat(l1, 'PARAMETER ');
@@ -38,15 +44,15 @@ l2 = printline(133, '-');
T2 = strvcat(l2, sprintf('Prior shape \t Prior mean \t Prior mode \t Prior std. \t Prior lb \t Prior ub \t Prior HPD lb \t Prior HPH ub'));
T2 = strvcat(T2, l2);
-prior_trunc_backup = DynareOptions.prior_trunc ;
-DynareOptions.prior_trunc = (1-DynareOptions.prior_interval)/2 ;
-PriorIntervals = prior_bounds(BayesInfo, DynareOptions.prior_trunc) ;
-DynareOptions.prior_trunc = prior_trunc_backup ;
+prior_trunc_backup = options_.prior_trunc ;
+options_.prior_trunc = (1-options_.prior_interval)/2 ;
+PriorIntervals = prior_bounds(bayestopt_, options_.prior_trunc) ;
+options_.prior_trunc = prior_trunc_backup ;
RESIZE = false;
-for i=1:size(BayesInfo.name,1)
- [Name,tmp] = get_the_name(i,1,ModelInfo,EstimationInfo,DynareOptions);
+for i=1:size(bayestopt_.name,1)
+ [Name,tmp] = get_the_name(i,1,M_,estim_params_,options_);
if length(Name)>size(T1,2)
resize = true;
else
@@ -59,14 +65,14 @@ for i=1:size(BayesInfo.name,1)
T1(1,:) = l1;
T1(3,:) = l1;
end
- PriorShape = PriorNames(BayesInfo.pshape(i),:);
- PriorMean = BayesInfo.p1(i);
- PriorMode = BayesInfo.p5(i);
- PriorStandardDeviation = BayesInfo.p2(i);
- switch BayesInfo.pshape(i)
+ PriorShape = PriorNames(bayestopt_.pshape(i),:);
+ PriorMean = bayestopt_.p1(i);
+ PriorMode = bayestopt_.p5(i);
+ PriorStandardDeviation = bayestopt_.p2(i);
+ switch bayestopt_.pshape(i)
case { 1 , 5 }
- LowerBound = BayesInfo.p3(i);
- UpperBound = BayesInfo.p4(i);
+ LowerBound = bayestopt_.p3(i);
+ UpperBound = bayestopt_.p4(i);
if ~isinf(lb(i))
LowerBound=max(LowerBound,lb(i));
end
@@ -74,7 +80,7 @@ for i=1:size(BayesInfo.name,1)
UpperBound=min(UpperBound,ub(i));
end
case { 2 , 4 , 6 , 8}
- LowerBound = BayesInfo.p3(i);
+ LowerBound = bayestopt_.p3(i);
if ~isinf(lb(i))
LowerBound=max(LowerBound,lb(i));
end
@@ -84,18 +90,18 @@ for i=1:size(BayesInfo.name,1)
UpperBound = Inf;
end
case 3
- if isinf(BayesInfo.p3(i)) && isinf(lb(i))
+ if isinf(bayestopt_.p3(i)) && isinf(lb(i))
LowerBound = -Inf;
else
- LowerBound = BayesInfo.p3(i);
+ LowerBound = bayestopt_.p3(i);
if ~isinf(lb(i))
LowerBound=max(LowerBound,lb(i));
end
end
- if isinf(BayesInfo.p4(i)) && isinf(ub(i))
+ if isinf(bayestopt_.p4(i)) && isinf(ub(i))
UpperBound = Inf;
else
- UpperBound = BayesInfo.p4(i);
+ UpperBound = bayestopt_.p4(i);
if ~isinf(ub(i))
UpperBound=min(UpperBound,ub(i));
end
diff --git a/matlab/static_model_inversion.m b/matlab/static_model_inversion.m
index 9549d3777..edc2ad300 100644
--- a/matlab/static_model_inversion.m
+++ b/matlab/static_model_inversion.m
@@ -1,11 +1,14 @@
-function [endogenousvariables, exogenousvariables] = static_model_inversion(constraints, exogenousvariables, endo_names, exo_names, freeinnovations, DynareModel, DynareOptions, DynareOutput)
-
+function [endogenousvariables, exogenousvariables] = static_model_inversion(constraints, exogenousvariables, endo_names, exo_names, freeinnovations, M_, options_, oo_)
+% [endogenousvariables, exogenousvariables] = static_model_inversion(constraints, exogenousvariables, endo_names, exo_names, freeinnovations, M_, options_, oo_)
% INPUTS
% - constraints [dseries] with N constrained endogenous variables from t1 to t2.
% - exogenousvariables [dseries] with Q exogenous variables.
% - endo_names [cell] list of endogenous variable names.
% - exo_names [cell] list of exogenous variable names.
% - freeinstruments [cell] list of exogenous variable names used to control the constrained endogenous variables.
+% - M_ [structure] Definition of the model
+% - options_ [structure] Options
+% - oo_ [structure] Storage of results
%
% OUTPUTS
% - endogenous [dseries]
@@ -32,7 +35,7 @@ function [endogenousvariables, exogenousvariables] = static_model_inversion(cons
% Get indices for the free innovations.
freeinnovations_id = zeros(length(freeinnovations), 1);
-if length(freeinnovations)2 && strcmp(datafile(end-1:end),'.m')) || (length(datafile)>4 && strcmp(datafile(end-3:end),'.mat'))))
- DynareDataset = dseries(datafile);
+ dataset_ = dseries(datafile);
else
if length(datafile)>2 && strcmp(datafile(end-1:end),'.m')
% Load an m file with the old interface.
- DynareDataset = load_m_file_data_legacy(datafile, DynareOptions.varobs);
+ dataset_ = load_m_file_data_legacy(datafile, options_.varobs);
elseif length(datafile)>4 && strcmp(datafile(end-3:end),'.mat')
% Load a mat file with the old interface.
- DynareDataset = load_mat_file_data_legacy(datafile, DynareOptions.varobs);
+ dataset_ = load_mat_file_data_legacy(datafile, options_.varobs);
end
end
else
- DynareDataset = dseriesobjectforuserdataset;
+ dataset_ = dseriesobjectforuserdataset;
clear('dseriesobjectforuserdataset');
end
-if size(unique(DynareDataset.name),1)~=size(DynareDataset.name,1)
+if size(unique(dataset_.name),1)~=size(dataset_.name,1)
error('makedataset: the data set must not contain two variables with the same name and must not contain empty/non-named columns.')
end
% Select a subset of the variables.
-DynareDataset = DynareDataset{DynareOptions.varobs{:}};
+dataset_ = dataset_{options_.varobs{:}};
% Apply log function if needed.
-if DynareOptions.loglinear && ~DynareOptions.logdata
- DynareDataset = DynareDataset.log();
+if options_.loglinear && ~options_.logdata
+ dataset_ = dataset_.log();
end
% Test if an initial period (different from its default value) is explicitely defined in the datafile.
-if isequal(DynareDataset.init, dates(1,1))
+if isequal(dataset_.init, dates(1,1))
dataset_default_initial_period = 1;
else
dataset_default_initial_period = 0;
end
% Test if an initial period (different from its default value) is explicitely defined in the mod file with the set_time command.
-if ~isdates(DynareOptions.initial_period) && isnan(DynareOptions.initial_period)
+if ~isdates(options_.initial_period) && isnan(options_.initial_period)
set_time_default_initial_period = 1;
else
set_time_default_initial_period = 0;
@@ -164,42 +162,42 @@ if ~set_time_default_initial_period && dataset_default_initial_period
% Overwrite the initial period in dataset (it was set to default).
% Note that the updates of freq and time members are auto-magically
% done by dseries::subsasgn overloaded method.
- DynareDataset.init = DynareOptions.initial_period;
+ dataset_.init = options_.initial_period;
end
if set_time_default_initial_period && ~dataset_default_initial_period
% Overwrite the global initial period defined by set_time (it was set to default).
- DynareOptions.initial_period = DynareDataset.init;
+ options_.initial_period = dataset_.init;
end
if ~set_time_default_initial_period && ~dataset_default_initial_period
% Check if dataset.init and options_.initial_period are identical.
- if DynareOptions.initial_periodDynareDataset.dates(end)
- error(sprintf('makedataset: last_obs (%s) cannot be greater than the last date in the dataset (%s)!',char(lastobs),char(DynareDataset.dates(end))))
+ if lastobs>dataset_.dates(end)
+ error(sprintf('makedataset: last_obs (%s) cannot be greater than the last date in the dataset (%s)!',char(lastobs),char(dataset_.dates(end))))
end
else
- % ... or check that nobs is smaller than the number of observations in DynareDataset.
- if nobs>DynareDataset.nobs
- error(sprintf('makedataset: nobs (%s) cannot be greater than the last date in the dataset (%s)!', num2str(nobs), num2str(DynareDataset.nobs)))
+ % ... or check that nobs is smaller than the number of observations in dataset_.
+ if nobs>dataset_.nobs
+ error(sprintf('makedataset: nobs (%s) cannot be greater than the last date in the dataset (%s)!', num2str(nobs), num2str(dataset_.nobs)))
end
end
% Select a subsample.
-DynareDataset = DynareDataset(FIRSTOBS:lastobs);
+dataset_ = dataset_(FIRSTOBS:lastobs);
-% Initialize DatasetInfo structure.
-DatasetInfo = struct('missing', struct('state', NaN, 'aindex', [], 'vindex', [], 'number_of_observations', NaN, 'no_more_missing_observations', NaN), ...
+% Initialize dataset_info structure.
+dataset_info = struct('missing', struct('state', NaN, 'aindex', [], 'vindex', [], 'number_of_observations', NaN, 'no_more_missing_observations', NaN), ...
'descriptive', struct('mean', [], 'covariance', [], 'correlation', [], 'autocovariance', []));
-% Fill DatasetInfo.missing if some observations are missing
-DatasetInfo.missing.state = isanynan(DynareDataset.data);
-if DatasetInfo.missing.state
- [DatasetInfo.missing.aindex, DatasetInfo.missing.number_of_observations, DatasetInfo.missing.no_more_missing_observations, DatasetInfo.missing.vindex] = ...
- describe_missing_data(DynareDataset.data);
+% Fill dataset_info.missing if some observations are missing
+dataset_info.missing.state = isanynan(dataset_.data);
+if dataset_info.missing.state
+ [dataset_info.missing.aindex, dataset_info.missing.number_of_observations, dataset_info.missing.no_more_missing_observations, dataset_info.missing.vindex] = ...
+ describe_missing_data(dataset_.data);
else
- DatasetInfo.missing.aindex = num2cell(transpose(repmat(1:DynareDataset.vobs,DynareDataset.nobs,1)),1);
- DatasetInfo.missing.no_more_missing_observations = 1;
+ dataset_info.missing.aindex = num2cell(transpose(repmat(1:dataset_.vobs,dataset_.nobs,1)),1);
+ dataset_info.missing.no_more_missing_observations = 1;
end
% Compute the empirical mean of the observed variables.
-DatasetInfo.descriptive.mean = nanmean(DynareDataset.data,1);
+dataset_info.descriptive.mean = nanmean(dataset_.data,1);
% Compute the empirical covariance matrix of the observed variables.
-DatasetInfo.descriptive.covariance = nancovariance(DynareDataset.data);
+dataset_info.descriptive.covariance = nancovariance(dataset_.data);
% Compute the empirical correlation matrix of the observed variables.
-normalization_matrix = diag(1./sqrt(diag(DatasetInfo.descriptive.covariance)));
-DatasetInfo.descriptive.correlation = normalization_matrix*DatasetInfo.descriptive.covariance*normalization_matrix;
+normalization_matrix = diag(1./sqrt(diag(dataset_info.descriptive.covariance)));
+dataset_info.descriptive.correlation = normalization_matrix*dataset_info.descriptive.covariance*normalization_matrix;
% Compute autocorrelation function.
-DatasetInfo.descriptive.autocovariance = nanautocovariance(DynareDataset.data, DynareOptions.ar);
+dataset_info.descriptive.autocovariance = nanautocovariance(dataset_.data, options_.ar);
% Save raw data.
-DatasetInfo.rawdata = DynareDataset.data;
+dataset_info.rawdata = dataset_.data;
% Prefilter the data if needed (remove the mean).
-if isequal(DynareOptions.prefilter, 1)
- DynareDataset = DynareDataset.detrend();
+if isequal(options_.prefilter, 1)
+ dataset_ = dataset_.detrend();
end