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

Remove workaround for errors in MEX files 

Because at some point throwing exceptions from MEX files (with mexErrMsgTxt())
was not working under Windows 64-bit, we had designed a workaround to avoid
using exceptions.

Most MEX files were returning an error code as their first (or sometimes last)
argument, and that code would have to be checked from the MATLAB code.

Since this workaround is no longer needed, this commit removes it. As a
consequence, the interface of many MEX files is modified.

For some background, see https://www.dynare.org/pipermail/dev/2010-September/000895.html
time-shift
Sébastien Villemot 2020-01-10 17:55:57 +01:00
parent 8624b4f004
commit 7e770f69e7
No known key found for this signature in database
GPG Key ID: 2CECE9350ECEBE4A
53 changed files with 529 additions and 700 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
matlab/DsgeSmoother.m
View File

@ -58,7 +58,7 @@ function [alphahat,etahat,epsilonhat,ahat,SteadyState,trend_coeff,aK,T,R,P,PK,de
% SPECIAL REQUIREMENTS
% None
% Copyright (C) 2006-2018 Dynare Team
% Copyright (C) 2006-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -185,8 +185,7 @@ elseif options_.lik_init == 3 % Diffuse Kalman filter
end
[Pstar,Pinf] = compute_Pinf_Pstar(mf,T,R,Q,options_.qz_criterium);
elseif options_.lik_init == 4 % Start from the solution of the Riccati equation.
[err, Pstar] = kalman_steady_state(transpose(T),R*Q*transpose(R),transpose(build_selection_matrix(mf,np,vobs)),H);
mexErrCheck('kalman_steady_state',err);
Pstar = kalman_steady_state(transpose(T),R*Q*transpose(R),transpose(build_selection_matrix(mf,np,vobs)),H);
Pinf = [];
if kalman_algo~=2
kalman_algo = 1;

4
matlab/block_bytecode_mfs_steadystate.m
View File

@ -2,7 +2,7 @@ function [r, g1] = block_bytecode_mfs_steadystate(y, b, y_all, exo, params, M)
% Wrapper around the *_static.m file, for use with dynare_solve,
% when block_mfs option is given to steady.
% Copyright (C) 2009-2012 Dynare Team
% Copyright (C) 2009-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -21,4 +21,4 @@ function [r, g1] = block_bytecode_mfs_steadystate(y, b, y_all, exo, params, M)
indx = M.block_structure_stat.block(b).variable;
y_all(indx) = y;
[chk, r, g1] = bytecode( y_all, exo, params, y_all, 1, y_all, 'evaluate', 'static', ['block = ' int2str(b) ]);
[r, g1] = bytecode( y_all, exo, params, y_all, 1, y_all, 'evaluate', 'static', ['block = ' int2str(b) ]);

4
matlab/bytecode_steadystate.m
View File

@ -2,7 +2,7 @@ function [r, g1] = bytecode_steadystate(y, exo, params)
% Wrapper around the *_static.m file, for use with dynare_solve,
% when block_mfs option is given to steady.
% Copyright (C) 2009-2011 Dynare Team
% Copyright (C) 2009-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -19,4 +19,4 @@ function [r, g1] = bytecode_steadystate(y, exo, params)
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
eval('[chk, r, g1] = bytecode( y, exo, params, y, 1, exo, ''evaluate'', ''static'');');
eval('[r, g1] = bytecode( y, exo, params, y, 1, exo, ''evaluate'', ''static'');');

10
matlab/dr_block.m
View File

@ -34,7 +34,7 @@ function [dr,info,M_,options_,oo_] = dr_block(dr,task,M_,options_,oo_,varargin)
% none.
%
% Copyright (C) 2010-2017 Dynare Team
% Copyright (C) 2010-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -71,12 +71,10 @@ else
Size = 1;
end
if (options_.bytecode)
[chck, zz, data]= bytecode('dynamic','evaluate', z, zx, M_.params, dr.ys, 1, data);
[zz, data]= bytecode('dynamic','evaluate', z, zx, M_.params, dr.ys, 1, data);
else
[r, data] = feval([M_.fname '.dynamic'], options_, M_, oo_, z', zx, M_.params, dr.ys, M_.maximum_lag+1, data);
chck = 0;
end
mexErrCheck('bytecode', chck);
dr.full_rank = 1;
dr.eigval = [];
dr.nd = 0;
@ -440,7 +438,7 @@ for i = 1:Size
D = [[aa(row_indx,index_0m) zeros(n_dynamic,n_both) aa(row_indx,index_p)] ; [zeros(n_both, n_pred) eye(n_both) zeros(n_both, n_both + n_fwrd)]];
E = [-aa(row_indx,[index_m index_0p]) ; [zeros(n_both, n_both + n_pred) eye(n_both, n_both + n_fwrd) ] ];
[err, ss, tt, w, sdim, data(i).eigval, info1] = mjdgges(E,D,options_.qz_criterium,options_.qz_zero_threshold);
[ss, tt, w, sdim, data(i).eigval, info1] = mjdgges(E,D,options_.qz_criterium,options_.qz_zero_threshold);
if (verbose)
disp('eigval');
@ -591,7 +589,7 @@ for i = 1:Size
elseif options_.sylvester_fp
ghx_other = gensylv_fp(A_, B_, C_, D_, i, options_.sylvester_fixed_point_tol);
else
[err, ghx_other] = gensylv(1, A_, B_, C_, -D_);
ghx_other = gensylv(1, A_, B_, C_, -D_);
end
if options_.aim_solver ~= 1
% Necessary when using Sims' routines for QZ

27
matlab/dsge_likelihood.m
View File

@ -115,7 +115,7 @@ function [fval,info,exit_flag,DLIK,Hess,SteadyState,trend_coeff,Model,DynareOpti
%! @end deftypefn
%@eod:
% Copyright (C) 2004-2019 Dynare Team
% Copyright (C) 2004-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -150,7 +150,9 @@ if DynareOptions.estimation_dll
[fval,exit_flag,SteadyState,trend_coeff,info,params,H,Q] ...
= logposterior(xparam1,DynareDataset, DynareOptions,Model, ...
EstimatedParameters,BayesInfo,DynareResults);
mexErrCheck('logposterior', exit_flag);
if exit_flag
error("Error encountered in logposterior")
end
Model.params = params;
if ~isequal(Model.H,0)
Model.H = H;
@ -455,12 +457,14 @@ switch DynareOptions.lik_init
if kalman_algo ~= 2
kalman_algo = 1;
end
if isequal(H,0)
[err,Pstar] = kalman_steady_state(transpose(T),R*Q*transpose(R),transpose(build_selection_matrix(Z,mm,length(Z))));
else
[err,Pstar] = kalman_steady_state(transpose(T),R*Q*transpose(R),transpose(build_selection_matrix(Z,mm,length(Z))),H);
end
if err
try
if isequal(H,0)
Pstar = kalman_steady_state(transpose(T),R*Q*transpose(R),transpose(build_selection_matrix(Z,mm,length(Z))));
else
Pstar = kalman_steady_state(transpose(T),R*Q*transpose(R),transpose(build_selection_matrix(Z,mm,length(Z))),H);
end
catch ME
disp(ME.message)
disp(['dsge_likelihood:: I am not able to solve the Riccati equation, so I switch to lik_init=1!']);
DynareOptions.lik_init = 1;
Pstar=lyapunov_solver(T,R,Q,DynareOptions);
@ -647,8 +651,7 @@ singularity_has_been_detected = false;
if ((kalman_algo==1) || (kalman_algo==3))% Multivariate Kalman Filter
if no_missing_data_flag
if DynareOptions.block
[err, LIK] = block_kalman_filter(T,R,Q,H,Pstar,Y,start,Z,kalman_tol,riccati_tol, Model.nz_state_var, Model.n_diag, Model.nobs_non_statevar);
mexErrCheck('block_kalman_filter', err);
LIK = block_kalman_filter(T,R,Q,H,Pstar,Y,start,Z,kalman_tol,riccati_tol, Model.nz_state_var, Model.n_diag, Model.nobs_non_statevar);
elseif DynareOptions.fast_kalman_filter
if diffuse_periods
%kalman_algo==3 requires no diffuse periods (stationary
@ -677,8 +680,8 @@ if ((kalman_algo==1) || (kalman_algo==3))% Multivariate Kalman Filter
end
else
if 0 %DynareOptions.block
[err, LIK,lik] = block_kalman_filter(DatasetInfo.missing.aindex,DatasetInfo.missing.number_of_observations,DatasetInfo.missing.no_more_missing_observations,...
T,R,Q,H,Pstar,Y,start,Z,kalman_tol,riccati_tol, Model.nz_state_var, Model.n_diag, Model.nobs_non_statevar);
[LIK,lik] = block_kalman_filter(DatasetInfo.missing.aindex,DatasetInfo.missing.number_of_observations,DatasetInfo.missing.no_more_missing_observations,...
T,R,Q,H,Pstar,Y,start,Z,kalman_tol,riccati_tol, Model.nz_state_var, Model.n_diag, Model.nobs_non_statevar);
else
[LIK,lik] = missing_observations_kalman_filter(DatasetInfo.missing.aindex,DatasetInfo.missing.number_of_observations,DatasetInfo.missing.no_more_missing_observations,Y,diffuse_periods+1,size(Y,2), ...
a, Pstar, ...

5
matlab/dyn_first_order_solver.m
View File

@ -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 (C) 2001-2018 Dynare Team
% Copyright (C) 2001-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -187,8 +187,7 @@ else
E(row_indx_de_1,index_e1) = -aa(row_indx,index_e);
E(row_indx_de_2,index_e2) = eye(nboth);
[err, ss, tt, w, sdim, dr.eigval, info1] = mjdgges(E, D, DynareOptions.qz_criterium, DynareOptions.qz_zero_threshold);
mexErrCheck('mjdgges', err);
[ss, tt, w, sdim, dr.eigval, info1] = mjdgges(E, D, DynareOptions.qz_criterium, DynareOptions.qz_zero_threshold);
if info1
if info1 == -30

10
matlab/dyn_ramsey_static.m
View File

@ -18,7 +18,7 @@ function [steady_state,params,check] = dyn_ramsey_static(ys_init,M,options_,oo)
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2003-2018 Dynare Team
% Copyright (C) 2003-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -156,8 +156,8 @@ Uyy = reshape(Uyy,endo_nbr,endo_nbr);
% set multipliers and auxiliary variables that
% depends on multipliers to 0 to compute residuals
if (options_.bytecode)
[chck, res, junk] = bytecode('static',xx,[oo.exo_steady_state oo.exo_det_steady_state], ...
params, 'evaluate');
[res, junk] = bytecode('static',xx,[oo.exo_steady_state oo.exo_det_steady_state], ...
params, 'evaluate');
fJ = junk.g1;
else
[res,fJ] = feval([fname '.static'],xx,[oo.exo_steady_state oo.exo_det_steady_state], ...
@ -194,8 +194,8 @@ end
function result = check_static_model(ys,M,options_,oo)
result = false;
if (options_.bytecode)
[chck, res, ~] = bytecode('static',ys,[oo.exo_steady_state oo.exo_det_steady_state], ...
M.params, 'evaluate');
[res, ~] = bytecode('static',ys,[oo.exo_steady_state oo.exo_det_steady_state], ...
M.params, 'evaluate');
else
res = feval([M.fname '.static'],ys,[oo.exo_steady_state oo.exo_det_steady_state], ...
M.params);

3
matlab/dyn_risky_steadystate_solver.m
View File

@ -341,8 +341,7 @@ if nargout > 1
nu2 = exo_nbr*(exo_nbr+1)/2;
nu3 = exo_nbr*(exo_nbr+1)*(exo_nbr+2)/3;
M_np.NZZDerivatives = [nnz(d1_np); nnz(d2_np); nnz(d3_np)];
[err, dynpp_derivs] = k_order_perturbation(dr_np,M_np,options,d1_np,d2_np,d3_np);
mexErrCheck('k_order_perturbation', err);
dynpp_derivs = k_order_perturbation(dr_np,M_np,options,d1_np,d2_np,d3_np);
g_0 = dynpp_derivs.g_0;
g_1 = dynpp_derivs.g_1;
g_2 = dynpp_derivs.g_2;

23
matlab/dyn_second_order_solver.m
View File

@ -36,7 +36,7 @@ function dr = dyn_second_order_solver(jacobia,hessian_mat,dr,M,threads_BC)
%! @end deftypefn
%@eod:
% Copyright (C) 2001-2019 Dynare Team
% Copyright (C) 2001-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -85,29 +85,23 @@ zu = [zeros(length(ic),M.exo_nbr);
dr.ghx(klead~=0,:)*dr.ghu(ic,:);
eye(M.exo_nbr);
zeros(M.exo_det_nbr,M.exo_nbr)];
[rhs, err] = sparse_hessian_times_B_kronecker_C(hessian_mat(:,kk2(kk1,kk1)),zx,threads_BC); %hessian_mat: reordering to DR order
mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
rhs = sparse_hessian_times_B_kronecker_C(hessian_mat(:,kk2(kk1,kk1)),zx,threads_BC); %hessian_mat: reordering to DR order
rhs = -rhs;
[err, dr.ghxx] = gensylv(2,A,B,C,rhs);
mexErrCheck('gensylv', err);
dr.ghxx = gensylv(2,A,B,C,rhs);
%% ghxu
%rhs
[rhs, err] = sparse_hessian_times_B_kronecker_C(hessian_mat(:,kk2(kk1,kk1)),zx,zu,threads_BC); %hessian_mat: reordering to DR order
mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
[abcOut,err] = A_times_B_kronecker_C(dr.ghxx, dr.ghx(ic,:), dr.ghu(ic,:));
mexErrCheck('A_times_B_kronecker_C', err);
rhs = sparse_hessian_times_B_kronecker_C(hessian_mat(:,kk2(kk1,kk1)),zx,zu,threads_BC); %hessian_mat: reordering to DR order
abcOut = A_times_B_kronecker_C(dr.ghxx, dr.ghx(ic,:), dr.ghu(ic,:));
rhs = -rhs-B*abcOut;
%lhs
dr.ghxu = A\rhs;
%% ghuu
%rhs
[rhs, err] = sparse_hessian_times_B_kronecker_C(hessian_mat(:,kk2(kk1,kk1)),zu,threads_BC); %hessian_mat: reordering to DR order
mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
[B1, err] = A_times_B_kronecker_C(B*dr.ghxx,dr.ghu(ic,:));
mexErrCheck('A_times_B_kronecker_C', err);
rhs = sparse_hessian_times_B_kronecker_C(hessian_mat(:,kk2(kk1,kk1)),zu,threads_BC); %hessian_mat: reordering to DR order
B1 = A_times_B_kronecker_C(B*dr.ghxx,dr.ghu(ic,:));
rhs = -rhs-B1;
%lhs
dr.ghuu = A\rhs;
@ -120,8 +114,7 @@ LHS = zeros(M.endo_nbr,M.endo_nbr);
LHS(:,kcurr~=0) = jacobia(:,nonzeros(kcurr));
RHS = zeros(M.endo_nbr,M.exo_nbr^2);
E = eye(M.endo_nbr);
[B1, err] = sparse_hessian_times_B_kronecker_C(hessian_mat(:,kk2(nonzeros(klead),nonzeros(klead))), dr.ghu(klead~=0,:),threads_BC); %hessian_mat:focus only on forward variables and reorder to DR order
mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
B1 = sparse_hessian_times_B_kronecker_C(hessian_mat(:,kk2(nonzeros(klead),nonzeros(klead))), dr.ghu(klead~=0,:),threads_BC); %hessian_mat:focus only on forward variables and reorder to DR order
RHS = RHS + jacobia(:,nonzeros(klead))*dr.ghuu(klead~=0,:)+B1;
% LHS
LHS = LHS + jacobia(:,nonzeros(klead))*(E(klead~=0,:)+[O1(klead~=0,:) dr.ghx(klead~=0,:) O2(klead~=0,:)]);

19
matlab/dynare_solve_block_or_bytecode.m
View File

@ -1,5 +1,5 @@
function [x,info] = dynare_solve_block_or_bytecode(y, exo, params, options, M)
% Copyright (C) 2010-2017 Dynare Team
% Copyright (C) 2010-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -51,9 +51,10 @@ if options.block && ~options.bytecode
end
elseif options.bytecode
if options.solve_algo > 4
[check, x] = bytecode('static', x, exo, params);
% mexErrCheck('bytecode', check);
if check
try
x = bytecode('static', x, exo, params);
catch ME
disp(ME.message);
info = 1;
return
end
@ -73,10 +74,12 @@ elseif options.bytecode
end
x(M.block_structure_stat.block(b).variable) = y;
else
[chk, nulldev, nulldev1, x] = bytecode( x, exo, params, ...
x, 1, x, 'evaluate', 'static', ...
['block = ' int2str(b)]);
if chk
try
[nulldev, nulldev1, x] = bytecode(x, exo, params, ...
x, 1, x, 'evaluate', 'static', ...
['block = ' int2str(b)]);
catch ME
disp(ME.message);
info = 1;
return
end

12
matlab/ep/extended_path_core.m
View File

@ -4,7 +4,7 @@ function [y, info_convergence, endogenousvariablespaths] = extended_path_core(pe
debug,bytecode_flag,order,M,pfm,algo,solve_algo,stack_solve_algo,...
olmmcp,options,oo,initialguess)
% Copyright (C) 2016-2019 Dynare Team
% Copyright (C) 2016-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -41,7 +41,13 @@ if debug
end
if bytecode_flag && ~ep.stochastic.order
[flag, tmp] = bytecode('dynamic', endo_simul, exo_simul, M_.params, endo_simul, periods);
try
tmp = bytecode('dynamic', endo_simul, exo_simul, M_.params, endo_simul, periods);
flag = false;
catch ME
disp(ME.message);
flag = true;
end
else
flag = true;
end
@ -86,4 +92,4 @@ else
y = NaN(size(endo_nbr,1));
end
endogenousvariablespaths = tmp.endo_simul;
endogenousvariablespaths = tmp.endo_simul;

32
matlab/evaluate_planner_objective.m
View File

@ -11,7 +11,7 @@ function planner_objective_value = evaluate_planner_objective(M,options,oo)
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2007-2018 Dynare Team
% Copyright (C) 2007-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -57,21 +57,16 @@ ys = oo.dr.ys;
%second order terms
Uyy = full(Uyy);
[Uyygygy, err] = A_times_B_kronecker_C(Uyy,gy,gy);
mexErrCheck('A_times_B_kronecker_C', err);
[Uyygugu, err] = A_times_B_kronecker_C(Uyy,gu,gu);
mexErrCheck('A_times_B_kronecker_C', err);
[Uyygygu, err] = A_times_B_kronecker_C(Uyy,gy,gu);
mexErrCheck('A_times_B_kronecker_C', err);
Uyygygy = A_times_B_kronecker_C(Uyy,gy,gy);
Uyygugu = A_times_B_kronecker_C(Uyy,gu,gu);
Uyygygu = A_times_B_kronecker_C(Uyy,gy,gu);
Wbar =U/(1-beta); %steady state welfare
Wy = Uy*gy/(eye(nspred)-beta*Gy);
Wu = Uy*gu+beta*Wy*Gu;
Wyy = Uyygygy/(eye(nspred*nspred)-beta*kron(Gy,Gy));
[Wyygugu, err] = A_times_B_kronecker_C(Wyy,Gu,Gu);
mexErrCheck('A_times_B_kronecker_C', err);
[Wyygygu,err] = A_times_B_kronecker_C(Wyy,Gy,Gu);
mexErrCheck('A_times_B_kronecker_C', err);
Wyygugu = A_times_B_kronecker_C(Wyy,Gu,Gu);
Wyygygu = A_times_B_kronecker_C(Wyy,Gy,Gu);
Wuu = Uyygugu+beta*Wyygugu;
Wyu = Uyygygu+beta*Wyygygu;
Wss = beta*Wuu*M.Sigma_e(:)/(1-beta); % at period 0, we are in steady state, so the deviation term only starts in period 1, thus the beta in front
@ -93,20 +88,15 @@ end
yhat1 = yhat1(dr.order_var(nstatic+(1:nspred)),1)-dr.ys(dr.order_var(nstatic+(1:nspred)));
u = oo.exo_simul(1,:)';
[Wyyyhatyhat1, err] = A_times_B_kronecker_C(Wyy,yhat1,yhat1);
mexErrCheck('A_times_B_kronecker_C', err);
[Wuuuu, err] = A_times_B_kronecker_C(Wuu,u,u);
mexErrCheck('A_times_B_kronecker_C', err);
[Wyuyhatu1, err] = A_times_B_kronecker_C(Wyu,yhat1,u);
mexErrCheck('A_times_B_kronecker_C', err);
Wyyyhatyhat1 = A_times_B_kronecker_C(Wyy,yhat1,yhat1);
Wuuuu = A_times_B_kronecker_C(Wuu,u,u);
Wyuyhatu1 = A_times_B_kronecker_C(Wyu,yhat1,u);
planner_objective_value(1) = Wbar+Wy*yhat1+Wu*u+Wyuyhatu1 ...
+ 0.5*(Wyyyhatyhat1 + Wuuuu+Wss);
if options.ramsey_policy
yhat2 = yhat2(dr.order_var(nstatic+(1:nspred)),1)-dr.ys(dr.order_var(nstatic+(1:nspred)));
[Wyyyhatyhat2, err] = A_times_B_kronecker_C(Wyy,yhat2,yhat2);
mexErrCheck('A_times_B_kronecker_C', err);
[Wyuyhatu2, err] = A_times_B_kronecker_C(Wyu,yhat2,u);
mexErrCheck('A_times_B_kronecker_C', err);
Wyyyhatyhat2 = A_times_B_kronecker_C(Wyy,yhat2,yhat2);
Wyuyhatu2 = A_times_B_kronecker_C(Wyu,yhat2,u);
planner_objective_value(2) = Wbar+Wy*yhat2+Wu*u+Wyuyhatu2 ...
+ 0.5*(Wyyyhatyhat2 + Wuuuu+Wss);
end

7
matlab/evaluate_static_model.m
View File

@ -20,7 +20,7 @@ function [residuals,check1,jacob] = evaluate_static_model(ys,exo_ss,params,M,opt
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2001-2017 Dynare Team
% Copyright (C) 2001-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -39,9 +39,8 @@ function [residuals,check1,jacob] = evaluate_static_model(ys,exo_ss,params,M,opt
check1 = 0;
if options.bytecode
[check1, residuals] = bytecode('evaluate','static',ys,...
exo_ss, params, ys, 1);
mexErrCheck('bytecode', check1);
residuals = bytecode('evaluate','static',ys,...
exo_ss, params, ys, 1);
else
fh_static = str2func([M.fname '.static']);
if options.block

5
matlab/evaluate_steady_state.m
View File

@ -22,7 +22,7 @@ function [ys,params,info] = evaluate_steady_state(ys_init,M,options,oo,steadysta
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2001-2018 Dynare Team
% Copyright (C) 2001-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -307,8 +307,7 @@ if M.static_and_dynamic_models_differ
z = repmat(ys,1,M.maximum_lead + M.maximum_lag + 1);
zx = repmat([exo_ss'], M.maximum_lead + M.maximum_lag + 1, 1);
if options.bytecode
[chck, r, ~]= bytecode('dynamic','evaluate', z, zx, params, ys, 1);
mexErrCheck('bytecode', chck);
[r, ~]= bytecode('dynamic','evaluate', z, zx, params, ys, 1);
elseif options.block
[r, oo.dr] = feval([M.fname '.dynamic'], z', zx, params, ys, M.maximum_lag+1, oo.dr);
else

44
matlab/get_perturbation_params_derivs.m
View File

@ -97,7 +97,7 @@ function DERIVS = get_perturbation_params_derivs(M, options, estim_params, oo, i
% * sylvester3a
% * get_perturbation_params_derivs_numerical_objective
% =========================================================================
% Copyright (C) 2019 Dynare Team
% Copyright (C) 2019-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -821,9 +821,9 @@ if order > 1
dghx(kcurr~=0,:,jp);
dghx(klead~=0,:,jp)*oo.dr.ghx(idx_states,:) + oo.dr.ghx(klead~=0,:)*dghx(idx_states,:,jp);
zeros(M.exo_nbr,M.nspred)];
[dRHS_1, err] = sparse_hessian_times_B_kronecker_C(dg2(:,k2yy0ex0(kyy0,kyy0)+(jp-1)*yy0ex0_nbr^2),zx(1:yy0_nbr,:),threads_BC); mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
[dRHS_2, err] = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(kyy0,kyy0)),dzx(1:yy0_nbr,:,jp),zx(1:yy0_nbr,:),threads_BC); mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
[dRHS_3, err] = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(kyy0,kyy0)),zx(1:yy0_nbr,:),dzx(1:yy0_nbr,:,jp),threads_BC); mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
dRHS_1 = sparse_hessian_times_B_kronecker_C(dg2(:,k2yy0ex0(kyy0,kyy0)+(jp-1)*yy0ex0_nbr^2),zx(1:yy0_nbr,:),threads_BC);
dRHS_2 = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(kyy0,kyy0)),dzx(1:yy0_nbr,:,jp),zx(1:yy0_nbr,:),threads_BC);
dRHS_3 = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(kyy0,kyy0)),zx(1:yy0_nbr,:),dzx(1:yy0_nbr,:,jp),threads_BC);
dG_x_x(:,:,jp) = kron(dghx(idx_states,:,jp),oo.dr.ghx(idx_states,:)) + kron(oo.dr.ghx(idx_states,:),dghx(idx_states,:,jp));
dRHSghxx(:,:,jp) = -( (dRHS_1+dRHS_2+dRHS_3) + dA(:,:,jp)*oo.dr.ghxx + dB(:,:,jp)*oo.dr.ghxx*G_x_x + B*oo.dr.ghxx*dG_x_x(:,:,jp) );
end
@ -838,9 +838,9 @@ if order > 1
oo.dr.ghu(kcurr~=0,:);
oo.dr.ghx(klead~=0,:)*oo.dr.ghu(idx_states,:);
eye(M.exo_nbr)];
[abcOutxu,err] = A_times_B_kronecker_C(oo.dr.ghxx,oo.dr.ghx(idx_states,:),oo.dr.ghu(idx_states,:)); mexErrCheck('A_times_B_kronecker_C', err); %auxiliary expressions for dghxu
[abcOutuu, err] = A_times_B_kronecker_C(oo.dr.ghxx,oo.dr.ghu(idx_states,:)); mexErrCheck('A_times_B_kronecker_C', err); %auxiliary expressions for dghuu
[RHSs2, err] = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(nonzeros(klead),nonzeros(klead))), oo.dr.ghu(klead~=0,:),threads_BC); mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
abcOutxu = A_times_B_kronecker_C(oo.dr.ghxx,oo.dr.ghx(idx_states,:),oo.dr.ghu(idx_states,:)); %auxiliary expressions for dghxu
abcOutuu = A_times_B_kronecker_C(oo.dr.ghxx,oo.dr.ghu(idx_states,:)); %auxiliary expressions for dghuu
RHSs2 = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(nonzeros(klead),nonzeros(klead))), oo.dr.ghu(klead~=0,:),threads_BC);
RHSs2 = RHSs2 + g1(:,nonzeros(klead))*oo.dr.ghuu(klead~=0,:);
dzu = zeros(size(zu,1),size(zu,2),modparam_nbr);
dghxu = zeros(M.endo_nbr,M.nspred*M.exo_nbr,modparam_nbr);
@ -852,25 +852,25 @@ if order > 1
dghx(klead~=0,:,jp)*oo.dr.ghu(idx_states,:) + oo.dr.ghx(klead~=0,:)*dghu(idx_states,:,jp);
zeros(M.exo_nbr,M.exo_nbr)];
%compute dghxu
[dRHS_1, err] = sparse_hessian_times_B_kronecker_C(dg2(:,k2yy0ex0(kyy0ex0,kyy0ex0)+(jp-1)*yy0ex0_nbr^2),zx,zu,threads_BC); mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
[dRHS_2, err] = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(kyy0ex0,kyy0ex0)),dzx(:,:,jp),zu,threads_BC); mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
[dRHS_3, err] = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(kyy0ex0,kyy0ex0)),zx,dzu(:,:,jp),threads_BC); mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
[dabcOut_1,err] = A_times_B_kronecker_C(dghxx(:,:,jp),oo.dr.ghx(idx_states,:),oo.dr.ghu(idx_states,:)); mexErrCheck('A_times_B_kronecker_C', err);
[dabcOut_2,err] = A_times_B_kronecker_C(oo.dr.ghxx,dghx(idx_states,:,jp),oo.dr.ghu(idx_states,:)); mexErrCheck('A_times_B_kronecker_C', err);
[dabcOut_3,err] = A_times_B_kronecker_C(oo.dr.ghxx,oo.dr.ghx(idx_states,:),dghu(idx_states,:,jp)); mexErrCheck('A_times_B_kronecker_C', err);
dRHS_1 = sparse_hessian_times_B_kronecker_C(dg2(:,k2yy0ex0(kyy0ex0,kyy0ex0)+(jp-1)*yy0ex0_nbr^2),zx,zu,threads_BC);
dRHS_2 = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(kyy0ex0,kyy0ex0)),dzx(:,:,jp),zu,threads_BC);
dRHS_3 = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(kyy0ex0,kyy0ex0)),zx,dzu(:,:,jp),threads_BC);
dabcOut_1 = A_times_B_kronecker_C(dghxx(:,:,jp),oo.dr.ghx(idx_states,:),oo.dr.ghu(idx_states,:));
dabcOut_2 = A_times_B_kronecker_C(oo.dr.ghxx,dghx(idx_states,:,jp),oo.dr.ghu(idx_states,:));
dabcOut_3 = A_times_B_kronecker_C(oo.dr.ghxx,oo.dr.ghx(idx_states,:),dghu(idx_states,:,jp));
dghxu(:,:,jp) = -invA * ( dA(:,:,jp)*oo.dr.ghxu + (dRHS_1+dRHS_2+dRHS_3) + dB(:,:,jp)*abcOutxu + B*(dabcOut_1+dabcOut_2+dabcOut_3) );
%compute dghuu
[dRHS_1, err] = sparse_hessian_times_B_kronecker_C(dg2(:,k2yy0ex0(kyy0ex0,kyy0ex0)+(jp-1)*yy0ex0_nbr^2),zu,threads_BC); mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
[dRHS_2, err] = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(kyy0ex0,kyy0ex0)),dzu(:,:,jp),zu,threads_BC); mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
[dRHS_3, err] = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(kyy0ex0,kyy0ex0)),zu,dzu(:,:,jp),threads_BC); mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
[dabcOut_1, err] = A_times_B_kronecker_C(dghxx(:,:,jp),oo.dr.ghu(idx_states,:)); mexErrCheck('A_times_B_kronecker_C', err);
[dabcOut_2, err] = A_times_B_kronecker_C(oo.dr.ghxx,dghu(idx_states,:,jp),oo.dr.ghu(idx_states,:)); mexErrCheck('A_times_B_kronecker_C', err);
[dabcOut_3, err] = A_times_B_kronecker_C(oo.dr.ghxx,oo.dr.ghu(idx_states,:),dghu(idx_states,:,jp)); mexErrCheck('A_times_B_kronecker_C', err);
dRHS_1 = sparse_hessian_times_B_kronecker_C(dg2(:,k2yy0ex0(kyy0ex0,kyy0ex0)+(jp-1)*yy0ex0_nbr^2),zu,threads_BC);
dRHS_2 = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(kyy0ex0,kyy0ex0)),dzu(:,:,jp),zu,threads_BC);
dRHS_3 = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(kyy0ex0,kyy0ex0)),zu,dzu(:,:,jp),threads_BC);
dabcOut_1 = A_times_B_kronecker_C(dghxx(:,:,jp),oo.dr.ghu(idx_states,:));
dabcOut_2 = A_times_B_kronecker_C(oo.dr.ghxx,dghu(idx_states,:,jp),oo.dr.ghu(idx_states,:));
dabcOut_3 = A_times_B_kronecker_C(oo.dr.ghxx,oo.dr.ghu(idx_states,:),dghu(idx_states,:,jp));
dghuu(:,:,jp) = -invA * ( dA(:,:,jp)*oo.dr.ghuu + (dRHS_1+dRHS_2+dRHS_3) + dB(:,:,jp)*abcOutuu + B*(dabcOut_1+dabcOut_2+dabcOut_3) );
%compute dghs2
[dRHS_1, err] = sparse_hessian_times_B_kronecker_C(dg2(:,k2yy0ex0(nonzeros(klead),nonzeros(klead))+(jp-1)*yy0ex0_nbr^2), oo.dr.ghu(klead~=0,:),threads_BC); mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
[dRHS_2, err] = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(nonzeros(klead),nonzeros(klead))), dghu(klead~=0,:,jp), oo.dr.ghu(klead~=0,:),threads_BC); mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
[dRHS_3, err] = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(nonzeros(klead),nonzeros(klead))), oo.dr.ghu(klead~=0,:), dghu(klead~=0,:,jp),threads_BC); mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
dRHS_1 = sparse_hessian_times_B_kronecker_C(dg2(:,k2yy0ex0(nonzeros(klead),nonzeros(klead))+(jp-1)*yy0ex0_nbr^2), oo.dr.ghu(klead~=0,:),threads_BC);
dRHS_2 = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(nonzeros(klead),nonzeros(klead))), dghu(klead~=0,:,jp), oo.dr.ghu(klead~=0,:),threads_BC);
dRHS_3 = sparse_hessian_times_B_kronecker_C(g2(:,k2yy0ex0(nonzeros(klead),nonzeros(klead))), oo.dr.ghu(klead~=0,:), dghu(klead~=0,:,jp),threads_BC);
dghs2(:,stderrparam_nbr+corrparam_nbr+jp) = -invS * ( dS(:,:,jp)*oo.dr.ghs2 + ( (dRHS_1+dRHS_2+dRHS_3) + dg1(:,nonzeros(klead),jp)*oo.dr.ghuu(klead~=0,:) + g1(:,nonzeros(klead))*dghuu(klead~=0,:,jp) )*M.Sigma_e(:) );
end
%add contributions by dSigma_e to dghs2

7
matlab/k_order_pert.m
View File

@ -1,7 +1,7 @@
function [dr,info] = k_order_pert(dr,M,options)
% Compute decision rules using the k-order DLL from Dynare++
% Copyright (C) 2009-2018 Dynare Team
% Copyright (C) 2009-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -30,8 +30,9 @@ if M.maximum_endo_lead == 0 && order>1
'backward models'])
end
[err, dynpp_derivs, dyn_derivs] = k_order_perturbation(dr,M,options);
if err
try
[dynpp_derivs, dyn_derivs] = k_order_perturbation(dr,M,options);
catch
info(1)=9;
return
end

5
matlab/mex/k_order_perturbation.m
View File

@ -1,4 +1,4 @@
% [err, dynpp_derivs, dyn_derivs] = k_order_perturbation(dr,DynareModel,DynareOptions,g1,g2,g3)
% [dynpp_derivs, dyn_derivs] = k_order_perturbation(dr,DynareModel,DynareOptions,g1,g2,g3)
% computes a k_order_petrubation solution for k=1,2,3
%
% INPUTS
@ -10,7 +10,6 @@
% g3: matrix Third order derivatives of the model (optional)
%
% OUTPUTS
% err: double error code
% dynpp_derivs struct Derivatives of the decision rule in Dynare++ format.
% The tensors are folded and the Taylor coefficients (1/n!) are
% included.
@ -29,7 +28,7 @@
% dynare/mex/sources/k_order_perturbation.cc and it uses code provided by
% dynare++
% Copyright (C) 2013-2017 Dynare Team
% Copyright (C) 2013-2020 Dynare Team
%
% This file is part of Dynare.
%

42
matlab/mexErrCheck.m
View File

@ -1,42 +0,0 @@
function mexErrCheck(mexFunctionName, err)
% function mexErrCheck(mexFunctionName, err)
% this function halts processing if err is equal to 1.
%
% INPUTS
% mexFunctionName [char] Name of the mexFunction
% err [double] error code returned from mexFunction
%
% OUTPUTS
% none.
%
% ALGORITHM
% ...
%
% SPECIAL REQUIREMENTS
% none.
%
% Copyright (C) 2010 Dynare Team
%
% This file is part of Dynare.
%
% Dynare is free software: you can redistribute it and/or modify
% it under the terms of the GNU General Public License as published by
% the Free Software Foundation, either version 3 of the License, or
% (at your option) any later version.
%
% Dynare is distributed in the hope that it will be useful,
% but WITHOUT ANY WARRANTY; without even the implied warranty of
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
% GNU General Public License for more details.
%
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
if ~ischar(mexFunctionName) || ~isscalar(err)
error('The first argument must be a char and the second a scalar');
end
if err
error(['Error encountered in: ' mexFunctionName '.']);
end

7
matlab/missing/mex/gensylv/gensylv.m
View File

@ -1,5 +1,5 @@
function [err, E] = gensylv(kron_prod,A,B,C0,D)
%function [err, E] = gensylv(fake,A,B,C,D)
function E = gensylv(kron_prod,A,B,C0,D)
%function E = gensylv(fake,A,B,C,D)
% Solves a Sylvester equation.
%
% INPUTS
@ -19,7 +19,7 @@ function [err, E] = gensylv(kron_prod,A,B,C0,D)
% SPECIAL REQUIREMENTS
% none.
% Copyright (C) 1996-2017 Dynare Team
% Copyright (C) 1996-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -42,4 +42,3 @@ end
x0 = sylvester3(A,B,C,D);
E = sylvester3a(x0,A,B,C,D);
err = 0;

6
matlab/missing/mex/kronecker/A_times_B_kronecker_C.m
View File

@ -1,4 +1,4 @@
function [D, err] = A_times_B_kronecker_C(A,B,C)
function D = A_times_B_kronecker_C(A,B,C)
%@info:
%! @deftypefn {Function File} {[@var{D}, @var{err}] =} A_times_B_kronecker_C (@var{A},@var{B},@var{C})
@ -41,7 +41,7 @@ function [D, err] = A_times_B_kronecker_C(A,B,C)
%! @end deftypefn
%@eod:
% Copyright (C) 1996-2012 Dynare Team
% Copyright (C) 1996-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -109,4 +109,4 @@ else
D = A * kron(B,B);
end
end
err = 0;

13
matlab/missing/mex/kronecker/sparse_hessian_times_B_kronecker_C.m
View File

@ -1,7 +1,7 @@
function [D, err] = sparse_hessian_times_B_kronecker_C(varargin)
function D = sparse_hessian_times_B_kronecker_C(varargin)
%@info:
%! @deftypefn {Function File} {[@var{D}, @var{err}] =} sparse_hessian_times_B_kronecker_C (@var{A},@var{B},@var{C},@var{fake})
%! @deftypefn {Function File} {@var{D} =} sparse_hessian_times_B_kronecker_C (@var{A},@var{B},@var{C},@var{fake})
%! @anchor{kronecker/sparse_hessian_times_B_kronecker_C}
%! @sp 1
%! Computes A*kron(B,C) where A is hessian matrix in sparse format.
@ -24,8 +24,6 @@ function [D, err] = sparse_hessian_times_B_kronecker_C(varargin)
%! @table @ @var
%! @item D
%! mA*(nC*nB) or mA*(nB*nB) matrix of doubles.
%! @item err
%! Integer scalar equal to zero (if all goes well).
%! @end table
%! @sp 2
%! @strong{Remarks}
@ -45,7 +43,7 @@ function [D, err] = sparse_hessian_times_B_kronecker_C(varargin)
%! @end deftypefn
%@eod:
% Copyright (C) 1996-2012 Dynare Team
% Copyright (C) 1996-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -71,10 +69,9 @@ fake = varargin{nargin};
switch nargin
case 4
[D, fake] = A_times_B_kronecker_C(A,B,C,fake);
D = A_times_B_kronecker_C(A,B,C,fake);
case 3
[D, fake] = A_times_B_kronecker_C(A,B,C);
D = A_times_B_kronecker_C(A,B,C);
otherwise
error('Two or Three input arguments required!')
end
err = 0;

7
matlab/missing/mex/mjdgges/mjdgges.m
View File

@ -1,4 +1,4 @@
function [err, ss, tt, zz, sdim, eigval, info] = mjdgges(e, d, qz_criterium, zhreshold)
function [ss, tt, zz, sdim, eigval, info] = mjdgges(e, d, qz_criterium, zhreshold)
%
% INPUTS
% e [double] real square (n*n) matrix.
@ -8,7 +8,6 @@ function [err, ss, tt, zz, sdim, eigval, info] = mjdgges(e, d, qz_criterium, zhr
% detecting eigenvalues too close to 0/0)
%
% OUTPUTS
% err [integer] scalar: 1 indicates failure, 0 indicates success
% ss [double] (n*n) quasi-triangular matrix.
% tt [double] (n*n) quasi-triangular matrix.
% zz [double] (n*n) orthogonal matrix.
@ -19,7 +18,7 @@ function [err, ss, tt, zz, sdim, eigval, info] = mjdgges(e, d, qz_criterium, zhr
% SPECIAL REQUIREMENTS
% none.
% Copyright (C) 1996-2018 Dynare Team
% Copyright (C) 1996-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -66,5 +65,3 @@ try
catch
info = 1; % Not as precise as lapack's info!
end
err = 0;

18
matlab/model_diagnostics.m
View File

@ -16,7 +16,7 @@ function model_diagnostics(M,options,oo)
% none.
%
% Copyright (C) 1996-2018 Dynare Team
% Copyright (C) 1996-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -107,11 +107,11 @@ exo = [oo.exo_steady_state; oo.exo_det_steady_state];
for b=1:nb
if options.bytecode
if nb == 1
[chk, res, jacob] = bytecode(dr.ys, exo, M.params, dr.ys, 1, exo, ...
'evaluate', 'static');
[res, jacob] = bytecode(dr.ys, exo, M.params, dr.ys, 1, exo, ...
'evaluate', 'static');
else
[chk, res, jacob] = bytecode(dr.ys, exo, M.params, dr.ys, 1, exo, ...
'evaluate', 'static',['block=' ...
[res, jacob] = bytecode(dr.ys, exo, M.params, dr.ys, 1, exo, ...
'evaluate', 'static',['block=' ...
int2str(b)]);
end
else
@ -204,8 +204,8 @@ z = repmat(dr.ys,1,klen);
if ~options.block
if options.order == 1
if (options.bytecode)
[chck, ~, loc_dr] = bytecode('dynamic','evaluate', z,exo_simul, ...
M.params, dr.ys, 1);
[~, loc_dr] = bytecode('dynamic','evaluate', z,exo_simul, ...
M.params, dr.ys, 1);
jacobia_ = [loc_dr.g1 loc_dr.g1_x loc_dr.g1_xd];
else
[~,jacobia_] = feval([M.fname '.dynamic'],z(iyr0),exo_simul, ...
@ -213,8 +213,8 @@ if ~options.block
end
elseif options.order >= 2
if (options.bytecode)
[chck, ~, loc_dr] = bytecode('dynamic','evaluate', z,exo_simul, ...
M.params, dr.ys, 1);
[~, loc_dr] = bytecode('dynamic','evaluate', z,exo_simul, ...
M.params, dr.ys, 1);
jacobia_ = [loc_dr.g1 loc_dr.g1_x];
else
[~,jacobia_,hessian1] = feval([M.fname '.dynamic'],z(iyr0),...

5
matlab/ms-sbvar/ms_compute_mdd.m
View File

@ -14,7 +14,7 @@ function [options_, oo_]=ms_compute_mdd(M_, options_, oo_)
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2011-2013 Dynare Team
% Copyright (C) 2011-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -51,8 +51,7 @@ if options_.ms.use_mean_center
end
% compute mdd
[err] = ms_sbvar_command_line(opt);
mexErrCheck('ms_compute_mdd',err);
ms_sbvar_command_line(opt);
% grab the muller/bridge log mdd from the output file
mull_exp = 'Muller \w+\(\w+\) \= (\d+.\d+e\+\d+)';

5
matlab/ms-sbvar/ms_compute_probabilities.m
View File

@ -14,7 +14,7 @@ function [options_, oo_]=ms_compute_probabilities(M_, options_, oo_)
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2011 Dynare Team
% Copyright (C) 2011-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -53,8 +53,7 @@ else
end
% compute probabilities
[err] = ms_sbvar_command_line(opt);
mexErrCheck('ms_compute_probabilities',err);
ms_sbvar_command_line(opt);
% now we want to plot the probabilities for each chain
if ischar(prob_out_file)

5
matlab/ms-sbvar/ms_estimation.m
View File

@ -14,7 +14,7 @@ function [options_, oo_]=ms_estimation(M_, options_, oo_)
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2011-2017 Dynare Team
% Copyright (C) 2011-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -73,8 +73,7 @@ opt = [opt ' -random_tol_obj ' num2str(options_.ms.random_function_convergence_c
opt = [opt ' -random_tol_parms ' num2str(options_.ms.random_parameter_convergence_criterion)];
% estimation
[err] = ms_sbvar_command_line(opt);
mexErrCheck('ms_estimation', err);
ms_sbvar_command_line(opt);
[options_, oo_] = set_ms_estimation_file(options_.ms.output_file_tag, options_, oo_);
end

5
matlab/ms-sbvar/ms_forecast.m
View File

@ -14,7 +14,7 @@ function [options_, oo_]=ms_forecast(M_, options_, oo_)
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2011-2017 Dynare Team
% Copyright (C) 2011-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -75,8 +75,7 @@ else
end
% forecast
[err] = ms_sbvar_command_line(opt);
mexErrCheck('ms_forecast',err);
ms_sbvar_command_line(opt);
% Plot Forecasts
if options_.ms.regimes

5
matlab/ms-sbvar/ms_irf.m
View File

@ -15,7 +15,7 @@ function [options_, oo_]=ms_irf(varlist, M_, options_, oo_)
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2011-2017 Dynare Team
% Copyright (C) 2011-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -77,8 +77,7 @@ else
end
% irf
[err] = ms_sbvar_command_line(opt);
mexErrCheck('ms_irf',err);
ms_sbvar_command_line(opt);
% Plot IRFs
if options_.ms.regimes

5
matlab/ms-sbvar/ms_sbvar_setup.m
View File

@ -11,7 +11,7 @@ function ms_sbvar_setup(options_)
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2003-2017 Dynare Team
% Copyright (C) 2003-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -428,6 +428,5 @@ fclose(fidForC);
%======================================================================
ms_write_markov_file(markov_file,options_)
create_init_file = [matlab_filename,' ',markov_file,' ',options_.ms.file_tag];
[err] = ms_sbvar_create_init_file(create_init_file);
mexErrCheck('ms_sbvar_create_init_file',err);
ms_sbvar_create_init_file(create_init_file);
end

5
matlab/ms-sbvar/ms_simulation.m
View File

@ -14,7 +14,7 @@ function [options_, oo_]=ms_simulation(M_, options_, oo_)
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2011-2013 Dynare Team
% Copyright (C) 2011-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -50,6 +50,5 @@ if options_.ms.save_draws
end
% simulation
[err] = ms_sbvar_command_line(opt);
mexErrCheck('ms_simulation',err);
ms_sbvar_command_line(opt);
end

5
matlab/ms-sbvar/ms_variance_decomposition.m
View File

@ -14,7 +14,7 @@ function [options_, oo_]=ms_variance_decomposition(M_, options_, oo_)
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2011-2017 Dynare Team
% Copyright (C) 2011-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -78,8 +78,7 @@ if options_.ms.error_bands
end
% variance_decomposition
[err] = ms_sbvar_command_line(opt);
mexErrCheck('ms_variance_decomposition',err);
ms_sbvar_command_line(opt);
if options_.ms.regime || options_.ms.regimes
outfile = [outfile 'regime_'];

8
matlab/partial_information/add_auxiliary_variables_to_steadystate.m
View File

@ -2,7 +2,7 @@ function ys1 = add_auxiliary_variables_to_steadystate(ys,aux_vars,fname, ...
exo_steady_state, exo_det_steady_state,params, byte_code)
% Add auxiliary variables to the steady state vector
% Copyright (C) 2009-2017 Dynare Team
% Copyright (C) 2009-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -23,9 +23,9 @@ ys1 = [ys;zeros(n,1)];
for i=1:n+1
if byte_code
[info, res] = bytecode('static','evaluate',ys1,...
[exo_steady_state; ...
exo_det_steady_state],params);
res = bytecode('static','evaluate',ys1,...
[exo_steady_state; ...
exo_det_steady_state],params);
else
res = feval([fname '.static'],ys1,...
[exo_steady_state; ...

19
matlab/perfect-foresight-models/det_cond_forecast.m
View File

@ -12,7 +12,7 @@ function data_set = det_cond_forecast(varargin)
% dataset [dseries] Returns a dseries containing the forecasted endgenous variables and shocks
%
% Copyright (C) 2013-2018 Dynare Team
% Copyright (C) 2013-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -158,13 +158,12 @@ else
if options_.bytecode
save_options_dynatol_f = options_.dynatol.f;
options_.dynatol.f = 1e-7;
[Info, endo, exo] = bytecode('extended_path', plan, oo_.endo_simul, oo_.exo_simul, M_.params, oo_.steady_state, options_.periods);
[endo, exo] = bytecode('extended_path', plan, oo_.endo_simul, oo_.exo_simul, M_.params, oo_.steady_state, options_.periods);
options_.dynatol.f = save_options_dynatol_f;
if Info == 0
oo_.endo_simul = endo;
oo_.exo_simul = exo;
end
oo_.endo_simul = endo;
oo_.exo_simul = exo;
endo = endo';
endo_l = size(endo(1+M_.maximum_lag:end,:),1);
jrng = dates(plan.date(1)):dates(plan.date(1)+endo_l);
@ -473,14 +472,12 @@ if pf && ~surprise
end
data1 = M_;
if (options_.bytecode)
[chck, zz, data1]= bytecode('dynamic','evaluate', z, zx, M_.params, oo_.steady_state, k, data1);
[zz, data1]= bytecode('dynamic','evaluate', z, zx, M_.params, oo_.steady_state, k, data1);
else
[zz, g1b] = feval([M_.fname '.dynamic'], z', zx, M_.params, oo_.steady_state, k);
data1.g1_x = g1b(:,end - M_.exo_nbr + 1:end);
data1.g1 = g1b(:,1 : end - M_.exo_nbr);
chck = 0;
end
mexErrCheck('bytecode', chck);
end
if k == 1
g1(1:M_.endo_nbr,-M_.endo_nbr + [cur_indx lead_indx]) = data1.g1(:,M_.nspred + 1:end);
@ -745,14 +742,12 @@ else
end
data1 = M_;
if (options_.bytecode)
[chck, zz, data1]= bytecode('dynamic','evaluate', z, zx, M_.params, oo_.steady_state, k, data1);
[zz, data1]= bytecode('dynamic','evaluate', z, zx, M_.params, oo_.steady_state, k, data1);
else
[zz, g1b] = feval([M_.fname '.dynamic'], z', zx, M_.params, oo_.steady_state, k);
data1.g1_x = g1b(:,end - M_.exo_nbr + 1:end);
data1.g1 = g1b(:,1 : end - M_.exo_nbr);
chck = 0;
end
mexErrCheck('bytecode', chck);
end
if k == 1
g1(1:M_.endo_nbr,-M_.endo_nbr + [cur_indx lead_indx]) = data1.g1(:,M_.nspred + 1:end);

40
matlab/perfect-foresight-models/perfect_foresight_solver_core.m
View File

@ -11,7 +11,7 @@ function [oo_, maxerror] = perfect_foresight_solver_core(M_, options_, oo_)
% - oo_ [struct] contains results
% - maxerror [double] contains the maximum absolute error
% Copyright (C) 2015-2019 Dynare Team
% Copyright (C) 2015-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -50,18 +50,14 @@ end
if options_.block
if options_.bytecode
try
[info, tmp] = bytecode('dynamic', oo_.endo_simul, oo_.exo_simul, M_.params, repmat(oo_.steady_state,1, periods+2), periods);
catch
info = 1;
end
if info
oo_.deterministic_simulation.status = false;
else
oo_.endo_simul = tmp;
oo_.endo_simul = bytecode('dynamic', oo_.endo_simul, oo_.exo_simul, M_.params, repmat(oo_.steady_state,1, periods+2), periods);
oo_.deterministic_simulation.status = true;
end
if options_.no_homotopy
mexErrCheck('bytecode', info);
catch ME
disp(ME.message)
if options_.no_homotopy
error('Error in bytecode')
end
oo_.deterministic_simulation.status = false;
end
else
oo_ = feval([M_.fname '.dynamic'], options_, M_, oo_);
@ -69,18 +65,14 @@ if options_.block
else
if options_.bytecode
try
[info, tmp] = bytecode('dynamic', oo_.endo_simul, oo_.exo_simul, M_.params, repmat(oo_.steady_state, 1, periods+2), periods);
catch
info = 1;
end
if info
oo_.deterministic_simulation.status = false;
else
oo_.endo_simul = tmp;
oo_.endo_simul = bytecode('dynamic', oo_.endo_simul, oo_.exo_simul, M_.params, repmat(oo_.steady_state, 1, periods+2), periods);
oo_.deterministic_simulation.status = true;
end
if options_.no_homotopy
mexErrCheck('bytecode', info);
catch ME
disp(ME.message)
if options_.no_homotopy
error('Error in bytecode')
end
oo_.deterministic_simulation.status = false;
end
else
if M_.maximum_endo_lead == 0 % Purely backward model
@ -128,7 +120,7 @@ if nargout>1
maxerror = oo_.deterministic_simulation.error;
else
if options_.bytecode
[~, residuals]= bytecode('dynamic','evaluate', oo_.endo_simul, oo_.exo_simul, M_.params, oo_.steady_state, 1);
residuals = bytecode('dynamic','evaluate', oo_.endo_simul, oo_.exo_simul, M_.params, oo_.steady_state, 1);
else
if M_.maximum_lag > 0
y0 = oo_.endo_simul(:, M_.maximum_lag);

5
matlab/resid.m
View File

@ -12,7 +12,7 @@ function z = resid(junk)
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2001-2018 Dynare Team
% Copyright (C) 2001-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -79,8 +79,7 @@ if options_.block && ~options_.bytecode
z(idx) = r;
end
elseif options_.bytecode
[check, z] = bytecode('evaluate','static');
mexErrCheck('bytecode', check);
z = bytecode('evaluate','static');
else
z = feval([M_.fname '.static'],...
oo_.steady_state,...

54
matlab/simult_.m
View File

@ -17,7 +17,7 @@ function y_=simult_(M_,options_,y0,dr,ex_,iorder)
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2001-2019 Dynare Team
% Copyright (C) 2001-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -53,10 +53,9 @@ end
if options_.k_order_solver && ~options_.pruning % Call dynare++ routines.
ex_ = [zeros(M_.maximum_lag,M_.exo_nbr); ex_];
[err, y_] = dynare_simul_(options_.order,M_.nstatic,M_.npred,M_.nboth,M_.nfwrd,exo_nbr, ...
y_(dr.order_var,1),ex_',M_.Sigma_e,options_.DynareRandomStreams.seed, ...
dr.ys(dr.order_var),dr);
mexErrCheck('dynare_simul_', err);
y_ = dynare_simul_(options_.order,M_.nstatic,M_.npred,M_.nboth,M_.nfwrd,exo_nbr, ...
y_(dr.order_var,1),ex_',M_.Sigma_e,options_.DynareRandomStreams.seed, ...
dr.ys(dr.order_var),dr);
y_(dr.order_var,:) = y_;
else
if options_.block
@ -98,12 +97,9 @@ else
yhat1 = y__(order_var(k2))-dr.ys(order_var(k2));
yhat2 = y_(order_var(k2),i-1)-dr.ys(order_var(k2));
epsilon = ex_(i-1,:)';
[abcOut1, err] = A_times_B_kronecker_C(.5*dr.ghxx,yhat1);
mexErrCheck('A_times_B_kronecker_C', err);
[abcOut2, err] = A_times_B_kronecker_C(.5*dr.ghuu,epsilon);
mexErrCheck('A_times_B_kronecker_C', err);
[abcOut3, err] = A_times_B_kronecker_C(dr.ghxu,yhat1,epsilon);
mexErrCheck('A_times_B_kronecker_C', err);
abcOut1 = A_times_B_kronecker_C(.5*dr.ghxx,yhat1);
abcOut2 = A_times_B_kronecker_C(.5*dr.ghuu,epsilon);
abcOut3 = A_times_B_kronecker_C(dr.ghxu,yhat1,epsilon);
y_(order_var,i) = constant + dr.ghx*yhat2 + dr.ghu*epsilon ...
+ abcOut1 + abcOut2 + abcOut3;
y__(order_var) = dr.ys(order_var) + dr.ghx*yhat1 + dr.ghu*epsilon;
@ -112,12 +108,9 @@ else
for i = 2:iter+M_.maximum_lag
yhat = y_(order_var(k2),i-1)-dr.ys(order_var(k2));
epsilon = ex_(i-1,:)';
[abcOut1, err] = A_times_B_kronecker_C(.5*dr.ghxx,yhat);
mexErrCheck('A_times_B_kronecker_C', err);
[abcOut2, err] = A_times_B_kronecker_C(.5*dr.ghuu,epsilon);
mexErrCheck('A_times_B_kronecker_C', err);
[abcOut3, err] = A_times_B_kronecker_C(dr.ghxu,yhat,epsilon);
mexErrCheck('A_times_B_kronecker_C', err);
abcOut1 = A_times_B_kronecker_C(.5*dr.ghxx,yhat);
abcOut2 = A_times_B_kronecker_C(.5*dr.ghuu,epsilon);
abcOut3 = A_times_B_kronecker_C(dr.ghxu,yhat,epsilon);
y_(dr.order_var,i) = constant + dr.ghx*yhat + dr.ghu*epsilon ...
+ abcOut1 + abcOut2 + abcOut3;
end
@ -150,30 +143,21 @@ else
u = ex_(i-1,:)';
%construct terms of order 2 from second order part, based
%on linear component yhat1
[gyy, err] = A_times_B_kronecker_C(ghxx,yhat1);
mexErrCheck('A_times_B_kronecker_C', err);
[guu, err] = A_times_B_kronecker_C(ghuu,u);
mexErrCheck('A_times_B_kronecker_C', err);
[gyu, err] = A_times_B_kronecker_C(ghxu,yhat1,u);
mexErrCheck('A_times_B_kronecker_C', err);
gyy = A_times_B_kronecker_C(ghxx,yhat1);
guu = A_times_B_kronecker_C(ghuu,u);
gyu = A_times_B_kronecker_C(ghxu,yhat1,u);
%construct terms of order 3 from second order part, based
%on order 2 component yhat2
[gyy12, err] = A_times_B_kronecker_C(ghxx,yhat1,yhat2);
mexErrCheck('A_times_B_kronecker_C', err);
[gy2u, err] = A_times_B_kronecker_C(ghxu,yhat2,u);
mexErrCheck('A_times_B_kronecker_C', err);
gyy12 = A_times_B_kronecker_C(ghxx,yhat1,yhat2);
gy2u = A_times_B_kronecker_C(ghxu,yhat2,u);
%construct terms of order 3, all based on first order component yhat1
y2a = kron(yhat1,yhat1);
[gyyy, err] = A_times_B_kronecker_C(ghxxx,y2a,yhat1);
mexErrCheck('A_times_B_kronecker_C', err);
gyyy = A_times_B_kronecker_C(ghxxx,y2a,yhat1);
u2a = kron(u,u);
[guuu, err] = A_times_B_kronecker_C(ghuuu,u2a,u);
mexErrCheck('A_times_B_kronecker_C', err);
guuu = A_times_B_kronecker_C(ghuuu,u2a,u);
yu = kron(yhat1,u);
[gyyu, err] = A_times_B_kronecker_C(ghxxu,yhat1,yu);
mexErrCheck('A_times_B_kronecker_C', err);
[gyuu, err] = A_times_B_kronecker_C(ghxuu,yu,u);
mexErrCheck('A_times_B_kronecker_C', err);
gyyu = A_times_B_kronecker_C(ghxxu,yhat1,yu);
gyuu = A_times_B_kronecker_C(ghxuu,yu,u);
%add all terms of order 3, linear component based on third
%order yhat3
yhat3 = ghx*yhat3 +gyy12 ... % prefactor is 1/2*2=1, see (65) Appendix Andreasen et al.

12
matlab/solve_perfect_foresight_model.m
View File

@ -1,6 +1,6 @@
function [flag,endo_simul,err] = solve_perfect_foresight_model(endo_simul,exo_simul,pfm)
% Copyright (C) 2012-2017 Dynare Team
% Copyright (C) 2012-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -33,7 +33,13 @@ if pfm.verbose
end
if pfm.use_bytecode
[flag, endo_simul]=bytecode(Y, exo_simul, pfm.params);
try
endo_simul=bytecode(Y, exo_simul, pfm.params);
flag = 0;
catch ME
disp(ME.message);
flag = 1;
end
return
end
@ -120,4 +126,4 @@ if nan_flag
end
if pfm.verbose
disp (['-----------------------------------------------------']) ;
end
end

10
matlab/stochastic_solvers.m
View File

@ -24,7 +24,7 @@ function [dr, info] = stochastic_solvers(dr, task, M_, options_, oo_)
% info=6 -> The jacobian matrix evaluated at the steady state is complex.
% info=9 -> k_order_pert was unable to compute the solution
% Copyright (C) 1996-2019 Dynare Team
% Copyright (C) 1996-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -111,8 +111,8 @@ it_ = M_.maximum_lag + 1;
z = repmat(dr.ys,1,klen);
if local_order == 1
if (options_.bytecode)
[chck, ~, loc_dr] = bytecode('dynamic','evaluate', z,exo_simul, ...
M_.params, dr.ys, 1);
[~, loc_dr] = bytecode('dynamic','evaluate', z,exo_simul, ...
M_.params, dr.ys, 1);
jacobia_ = [loc_dr.g1 loc_dr.g1_x loc_dr.g1_xd];
else
[~,jacobia_] = feval([M_.fname '.dynamic'],z(iyr0),exo_simul, ...
@ -120,8 +120,8 @@ if local_order == 1
end
elseif local_order == 2
if (options_.bytecode)
[chck, ~, loc_dr] = bytecode('dynamic','evaluate', z,exo_simul, ...
M_.params, dr.ys, 1);
[~, loc_dr] = bytecode('dynamic','evaluate', z,exo_simul, ...
M_.params, dr.ys, 1);
jacobia_ = [loc_dr.g1 loc_dr.g1_x];
else
[~,jacobia_,hessian1] = feval([M_.fname '.dynamic'],z(iyr0),...

30
mex/sources/block_kalman_filter/block_kalman_filter.cc
View File

@ -1,5 +1,5 @@
/*
* Copyright © 2007-2019 Dynare Team
* Copyright © 2007-2020 Dynare Team
*
* This file is part of Dynare.
*
@ -143,10 +143,10 @@ det(const double *F, int dim, const lapack_int *ipiv)
BlockKalmanFilter::BlockKalmanFilter(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
if (nlhs > 3)
DYN_MEX_FUNC_ERR_MSG_TXT("block_kalman_filter provides at most 3 output argument.");
if (nlhs > 2)
mexErrMsgTxt("block_kalman_filter provides at most 2 output argument.");
if (nrhs != 13 && nrhs != 16)
DYN_MEX_FUNC_ERR_MSG_TXT("block_kalman_filter requires exactly \n 13 input arguments for standard Kalman filter \nor\n 16 input arguments for missing observations Kalman filter.");
mexErrMsgTxt("block_kalman_filter requires exactly \n 13 input arguments for standard Kalman filter \nor\n 16 input arguments for missing observations Kalman filter.");
if (nrhs == 16)
missing_observations = true;
else
@ -154,13 +154,13 @@ BlockKalmanFilter::BlockKalmanFilter(int nlhs, mxArray *plhs[], int nrhs, const
if (missing_observations)
{
if (!mxIsCell(prhs[0]))
DYN_MEX_FUNC_ERR_MSG_TXT("the first input argument of block_missing_observations_kalman_filter must be a Cell Array.");
mexErrMsgTxt("the first input argument of block_missing_observations_kalman_filter must be a Cell Array.");
pdata_index = prhs[0];
if (!mxIsDouble(prhs[1]))
DYN_MEX_FUNC_ERR_MSG_TXT("the second input argument of block_missing_observations_kalman_filter must be a scalar.");
mexErrMsgTxt("the second input argument of block_missing_observations_kalman_filter must be a scalar.");
number_of_observations = ceil(mxGetScalar(prhs[1]));
if (!mxIsDouble(prhs[2]))
DYN_MEX_FUNC_ERR_MSG_TXT("the third input argument of block_missing_observations_kalman_filter must be a scalar.");
mexErrMsgTxt("the third input argument of block_missing_observations_kalman_filter must be a scalar.");
no_more_missing_observations = ceil(mxGetScalar(prhs[2]));
pT = mxDuplicateArray(prhs[3]);
pR = mxDuplicateArray(prhs[4]);
@ -218,7 +218,7 @@ BlockKalmanFilter::BlockKalmanFilter(int nlhs, mxArray *plhs[], int nrhs, const
if (missing_observations)
if (mxGetNumberOfElements(pdata_index) != static_cast<unsigned int>(smpl))
DYN_MEX_FUNC_ERR_MSG_TXT("the number of element in the cell array passed to block_missing_observation_kalman_filter as first argument has to be equal to the smpl size");
mexErrMsgTxt("the number of element in the cell array passed to block_missing_observation_kalman_filter as first argument has to be equal to the smpl size");
i_nz_state_var = std::make_unique<int[]>(n);
for (int i = 0; i < n; i++)
@ -436,7 +436,7 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[])
{
mexPrintf("error: F singular\n");
LIK = Inf;
if (nlhs == 3)
if (nlhs == 2)
for (int i = t; i < smpl; i++)
lik[i] = Inf;
// info = 0
@ -817,17 +817,15 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[])
void
BlockKalmanFilter::return_results_and_clean(int nlhs, mxArray *plhs[])
{
plhs[0] = mxCreateDoubleScalar(0);
if (nlhs >= 2)
if (nlhs >= 1)
{
plhs[1] = mxCreateDoubleMatrix(1, 1, mxREAL);
double *pind = mxGetPr(plhs[1]);
plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
double *pind = mxGetPr(plhs[0]);
pind[0] = LIK;
}
if (nlhs == 3)
plhs[2] = plik;
if (nlhs == 2)
plhs[1] = plik;
else
mxDestroyArray(plik);

339
mex/sources/bytecode/bytecode.cc
View File

@ -1,5 +1,5 @@
/*
* Copyright © 2007-2017 Dynare Team
* Copyright © 2007-2020 Dynare Team
*
* This file is part of Dynare.
*
@ -21,37 +21,6 @@
#include "ErrorHandling.hh"
#include <ctime>
#include <math.h>
#ifdef DYN_MEX_FUNC_ERR_MSG_TXT
# undef DYN_MEX_FUNC_ERR_MSG_TXT
#endif // DYN_MEX_FUNC_ERR_MSG_TXT
#define DYN_MEX_FUNC_ERR_MSG_TXT(str) \
do { \
mexPrintf("%s\n", str); \
if (nlhs > 0) \
{ \
plhs[0] = mxCreateDoubleScalar(1); \
if (nlhs > 1) \
{ \
double *pind; \
plhs[1] = mxCreateDoubleMatrix(int (row_y), int (col_y), mxREAL); \
pind = mxGetPr(plhs[1]); \
if (evaluate) \
{ \
for (unsigned int i = 0; i < row_y*col_y; i++) \
pind[i] = 0; \
} \
else \
{ \
for (unsigned int i = 0; i < row_y*col_y; i++) \
pind[i] = yd[i]; \
} \
for (int i = 2; i < nlhs; i++) \
plhs[i] = mxCreateDoubleScalar(1); \
} \
} \
return; \
} while (0)
#ifdef DEBUG_EX
@ -492,13 +461,13 @@ main(int nrhs, const char *prhs[])
}
catch (GeneralExceptionHandling &feh)
{
DYN_MEX_FUNC_ERR_MSG_TXT(feh.GetErrorMsg().c_str());
mexErrMsgTxt(feh.GetErrorMsg().c_str());
}
if (!count_array_argument)
{
int field = mxGetFieldNumber(M_, "params");
if (field < 0)
DYN_MEX_FUNC_ERR_MSG_TXT("params is not a field of M_");
mexErrMsgTxt("params is not a field of M_");
params = mxGetPr(mxGetFieldByNumber(M_, 0, field));
}
@ -510,14 +479,14 @@ main(int nrhs, const char *prhs[])
if (extended_path_struct == NULL)
{
string tmp = "The 'extended_path' option must be followed by the extended_path descriptor";
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
mxArray *date_str = mxGetField(extended_path_struct, 0, "date_str");
if (date_str == NULL)
{
string tmp = "date_str";
tmp.insert(0, "The extended_path description structure does not contain the member: ");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
int nb_periods = mxGetM(date_str) * mxGetN(date_str);
@ -526,28 +495,28 @@ main(int nrhs, const char *prhs[])
{
string tmp = "constrained_vars_";
tmp.insert(0, "The extended_path description structure does not contain the member: ");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
mxArray *constrained_paths_ = mxGetField(extended_path_struct, 0, "constrained_paths_");
if (constrained_paths_ == NULL)
{
string tmp = "constrained_paths_";
tmp.insert(0, "The extended_path description structure does not contain the member: ");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
mxArray *constrained_int_date_ = mxGetField(extended_path_struct, 0, "constrained_int_date_");
if (constrained_int_date_ == NULL)
{
string tmp = "constrained_int_date_";
tmp.insert(0, "The extended_path description structure does not contain the member: ");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
mxArray *constrained_perfect_foresight_ = mxGetField(extended_path_struct, 0, "constrained_perfect_foresight_");
if (constrained_perfect_foresight_ == NULL)
{
string tmp = "constrained_perfect_foresight_";
tmp.insert(0, "The extended_path description structure does not contain the member: ");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
mxArray *shock_var_ = mxGetField(extended_path_struct, 0, "shock_vars_");
@ -555,28 +524,28 @@ main(int nrhs, const char *prhs[])
{
string tmp = "shock_vars_";
tmp.insert(0, "The extended_path description structure does not contain the member: ");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
mxArray *shock_paths_ = mxGetField(extended_path_struct, 0, "shock_paths_");
if (shock_paths_ == NULL)
{
string tmp = "shock_paths_";
tmp.insert(0, "The extended_path description structure does not contain the member: ");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
mxArray *shock_int_date_ = mxGetField(extended_path_struct, 0, "shock_int_date_");
if (shock_int_date_ == NULL)
{
string tmp = "shock_int_date_";
tmp.insert(0, "The extended_path description structure does not contain the member: ");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
mxArray *shock_str_date_ = mxGetField(extended_path_struct, 0, "shock_str_date_");
if (shock_str_date_ == NULL)
{
string tmp = "shock_str_date_";
tmp.insert(0, "The extended_path description structure does not contain the member: ");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
int nb_constrained = mxGetM(constrained_vars_) * mxGetN(constrained_vars_);
int nb_controlled = 0;
@ -588,7 +557,7 @@ main(int nrhs, const char *prhs[])
nb_controlled = mxGetM(controlled_varexo) * mxGetN(controlled_varexo);
if (nb_controlled != nb_constrained)
{
DYN_MEX_FUNC_ERR_MSG_TXT("The number of exogenized variables and the number of exogenous controlled variables should be equal.");
mexErrMsgTxt("The number of exogenized variables and the number of exogenous controlled variables should be equal.");
}
}
double *controlled_varexo_value = NULL;
@ -637,7 +606,7 @@ main(int nrhs, const char *prhs[])
string tmp1 = oss.str();
tmp.append(tmp1);
tmp.append(")");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
(sconditional_extended_path[i]).per_value.resize(nb_local_periods);
(sconditional_extended_path[i]).value.resize(nb_periods);
@ -680,7 +649,7 @@ main(int nrhs, const char *prhs[])
string tmp1 = oss.str();
tmp.append(tmp1);
tmp.append(")");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
(sextended_path[i]).per_value.resize(nb_local_periods);
(sextended_path[i]).value.resize(nb_periods);
@ -702,7 +671,7 @@ main(int nrhs, const char *prhs[])
if (info)
{
string tmp = "Can not allocated memory to store the date_str in the extended path descriptor";
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
dates.push_back(string(buf)); //string(Dates[i]);
mxFree(buf);
@ -715,7 +684,7 @@ main(int nrhs, const char *prhs[])
{
string tmp = plan;
tmp.insert(0, "Can't find the plan: ");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
size_t n_plan = mxGetN(plan_struct);
splan.resize(n_plan);
@ -738,7 +707,7 @@ main(int nrhs, const char *prhs[])
string tmp = name;
tmp.insert(0, "the variable '");
tmp.append("' defined as var in plan is not an exogenous or a deterministic exogenous\n");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
}
tmp = mxGetField(plan_struct, i, "var");
@ -756,7 +725,7 @@ main(int nrhs, const char *prhs[])
string tmp = name;
tmp.insert(0, "the variable '");
tmp.append("' defined as exo in plan is not an endogenous variable\n");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
}
tmp = mxGetField(plan_struct, i, "per_value");
@ -793,7 +762,7 @@ main(int nrhs, const char *prhs[])
{
string tmp = pfplan;
tmp.insert(0, "Can't find the pfplan: ");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
size_t n_plan = mxGetN(pfplan_struct);
spfplan.resize(n_plan);
@ -816,7 +785,7 @@ main(int nrhs, const char *prhs[])
string tmp = name;
tmp.insert(0, "the variable '");
tmp.append("' defined as var in pfplan is not an exogenous or a deterministic exogenous\n");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
}
tmp = mxGetField(pfplan_struct, i, "exo");
@ -834,7 +803,7 @@ main(int nrhs, const char *prhs[])
string tmp = name;
tmp.insert(0, "the variable '");
tmp.append("' defined as exo in pfplan is not an endogenous variable\n");
DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
mexErrMsgTxt(tmp.c_str());
}
}
tmp = mxGetField(pfplan_struct, i, "per_value");
@ -866,20 +835,20 @@ main(int nrhs, const char *prhs[])
int field_steady_state = mxGetFieldNumber(oo_, "steady_state");
if (field_steady_state < 0)
DYN_MEX_FUNC_ERR_MSG_TXT("steady_state is not a field of oo_");
mexErrMsgTxt("steady_state is not a field of oo_");
int field_exo_steady_state = mxGetFieldNumber(oo_, "exo_steady_state");
if (field_exo_steady_state < 0)
DYN_MEX_FUNC_ERR_MSG_TXT("exo_steady_state is not a field of oo_");
mexErrMsgTxt("exo_steady_state is not a field of oo_");
if (!steady_state)
{
int field_endo_simul = mxGetFieldNumber(oo_, "endo_simul");
if (field_endo_simul < 0)
DYN_MEX_FUNC_ERR_MSG_TXT("endo_simul is not a field of oo_");
mexErrMsgTxt("endo_simul is not a field of oo_");
int field_exo_simul = mxGetFieldNumber(oo_, "exo_simul");
if (field_exo_simul < 0)
DYN_MEX_FUNC_ERR_MSG_TXT("exo_simul is not a field of oo_");
mexErrMsgTxt("exo_simul is not a field of oo_");
if (!count_array_argument)
{
@ -897,17 +866,17 @@ main(int nrhs, const char *prhs[])
if (field >= 0)
y_kmin = int (floor(*(mxGetPr(mxGetFieldByNumber(M_, 0, field)))));
else
DYN_MEX_FUNC_ERR_MSG_TXT("maximum_lag is not a field of M_");
mexErrMsgTxt("maximum_lag is not a field of M_");
field = mxGetFieldNumber(M_, "maximum_lead");
if (field >= 0)
y_kmax = int (floor(*(mxGetPr(mxGetFieldByNumber(M_, 0, field)))));
else
DYN_MEX_FUNC_ERR_MSG_TXT("maximum_lead is not a field of M_");
mexErrMsgTxt("maximum_lead is not a field of M_");
field = mxGetFieldNumber(M_, "maximum_endo_lag");
if (field >= 0)
y_decal = max(0, y_kmin-int (floor(*(mxGetPr(mxGetFieldByNumber(M_, 0, field))))));
else
DYN_MEX_FUNC_ERR_MSG_TXT("maximum_endo_lag is not a field of M_");
mexErrMsgTxt("maximum_endo_lag is not a field of M_");
if (!count_array_argument)
{
@ -915,7 +884,7 @@ main(int nrhs, const char *prhs[])
if (field >= 0)
periods = int (floor(*(mxGetPr(mxGetFieldByNumber(options_, 0, field)))));
else
DYN_MEX_FUNC_ERR_MSG_TXT("options_ is not a field of options_");
mexErrMsgTxt("options_ is not a field of options_");
}
if (!steady_yd)
@ -948,7 +917,7 @@ main(int nrhs, const char *prhs[])
if (field >= 0)
verbose = int (*mxGetPr((mxGetFieldByNumber(options_, 0, field))));
else
DYN_MEX_FUNC_ERR_MSG_TXT("verbosity is not a field of options_");
mexErrMsgTxt("verbosity is not a field of options_");
if (verbose)
print_it = true;
if (!steady_state)
@ -961,34 +930,34 @@ main(int nrhs, const char *prhs[])
else
{
if (!steady_state)
DYN_MEX_FUNC_ERR_MSG_TXT("simul is not a field of options_");
mexErrMsgTxt("simul is not a field of options_");
else
DYN_MEX_FUNC_ERR_MSG_TXT("steady is not a field of options_");
mexErrMsgTxt("steady is not a field of options_");
}
field = mxGetFieldNumber(temporaryfield, "maxit");
if (field < 0)
{
if (!steady_state)
DYN_MEX_FUNC_ERR_MSG_TXT("maxit is not a field of options_.simul");
mexErrMsgTxt("maxit is not a field of options_.simul");
else
DYN_MEX_FUNC_ERR_MSG_TXT("maxit is not a field of options_.steady");
mexErrMsgTxt("maxit is not a field of options_.steady");
}
int maxit_ = int (floor(*(mxGetPr(mxGetFieldByNumber(temporaryfield, 0, field)))));
field = mxGetFieldNumber(options_, "slowc");
if (field < 0)
DYN_MEX_FUNC_ERR_MSG_TXT("slows is not a field of options_");
mexErrMsgTxt("slows is not a field of options_");
double slowc = double (*(mxGetPr(mxGetFieldByNumber(options_, 0, field))));
field = mxGetFieldNumber(options_, "markowitz");
if (field < 0)
DYN_MEX_FUNC_ERR_MSG_TXT("markowitz is not a field of options_");
mexErrMsgTxt("markowitz is not a field of options_");
double markowitz_c = double (*(mxGetPr(mxGetFieldByNumber(options_, 0, field))));
field = mxGetFieldNumber(options_, "minimal_solving_periods");
if (field < 0)
DYN_MEX_FUNC_ERR_MSG_TXT("minimal_solving_periods is not a field of options_");
mexErrMsgTxt("minimal_solving_periods is not a field of options_");
int minimal_solving_periods = int (*(mxGetPr(mxGetFieldByNumber(options_, 0, field))));
field = mxGetFieldNumber(options_, "stack_solve_algo");
if (field < 0)
DYN_MEX_FUNC_ERR_MSG_TXT("stack_solve_algo is not a field of options_");
mexErrMsgTxt("stack_solve_algo is not a field of options_");
int stack_solve_algo = int (*(mxGetPr(mxGetFieldByNumber(options_, 0, field))));
int solve_algo;
double solve_tolf;
@ -999,12 +968,12 @@ main(int nrhs, const char *prhs[])
if (field >= 0)
solve_algo = int (*(mxGetPr(mxGetFieldByNumber(options_, 0, field))));
else
DYN_MEX_FUNC_ERR_MSG_TXT("solve_algo is not a field of options_");
mexErrMsgTxt("solve_algo is not a field of options_");
field = mxGetFieldNumber(options_, "solve_tolf");
if (field >= 0)
solve_tolf = *(mxGetPr(mxGetFieldByNumber(options_, 0, field)));
else
DYN_MEX_FUNC_ERR_MSG_TXT("solve_tolf is not a field of options_");
mexErrMsgTxt("solve_tolf is not a field of options_");
}
else
{
@ -1014,19 +983,19 @@ main(int nrhs, const char *prhs[])
if (field >= 0)
dynatol = mxGetFieldByNumber(options_, 0, field);
else
DYN_MEX_FUNC_ERR_MSG_TXT("dynatol is not a field of options_");
mexErrMsgTxt("dynatol is not a field of options_");
field = mxGetFieldNumber(dynatol, "f");
if (field >= 0)
solve_tolf = *mxGetPr((mxGetFieldByNumber(dynatol, 0, field)));
else
DYN_MEX_FUNC_ERR_MSG_TXT("f is not a field of options_.dynatol");
mexErrMsgTxt("f is not a field of options_.dynatol");
}
field = mxGetFieldNumber(M_, "fname");
mxArray *mxa;
if (field >= 0)
mxa = mxGetFieldByNumber(M_, 0, field);
else
DYN_MEX_FUNC_ERR_MSG_TXT("fname is not a field of M_");
mexErrMsgTxt("fname is not a field of M_");
size_t buflen = mxGetM(mxa) * mxGetN(mxa) + 1;
char *fname;
fname = static_cast<char *>(mxCalloc(buflen+1, sizeof(char)));
@ -1044,11 +1013,11 @@ main(int nrhs, const char *prhs[])
}
catch (GeneralExceptionHandling &feh)
{
DYN_MEX_FUNC_ERR_MSG_TXT(feh.GetErrorMsg().c_str());
mexErrMsgTxt(feh.GetErrorMsg().c_str());
}
#else
if (stack_solve_algo == 7 && !steady_state)
DYN_MEX_FUNC_ERR_MSG_TXT("bytecode has not been compiled with CUDA option. Bytecode Can't use options_.stack_solve_algo=7\n");
mexErrMsgTxt("bytecode has not been compiled with CUDA option. Bytecode Can't use options_.stack_solve_algo=7\n");
#endif
size_t size_of_direction = col_y*row_y*sizeof(double);
double *y = static_cast<double *>(mxMalloc(size_of_direction));
@ -1085,7 +1054,6 @@ main(int nrhs, const char *prhs[])
mxFree(fname);
int nb_blocks = 0;
double *pind;
bool no_error = true;
if (extended_path)
{
@ -1095,7 +1063,7 @@ main(int nrhs, const char *prhs[])
}
catch (GeneralExceptionHandling &feh)
{
DYN_MEX_FUNC_ERR_MSG_TXT(feh.GetErrorMsg().c_str());
mexErrMsgTxt(feh.GetErrorMsg().c_str());
}
}
else
@ -1106,7 +1074,7 @@ main(int nrhs, const char *prhs[])
}
catch (GeneralExceptionHandling &feh)
{
DYN_MEX_FUNC_ERR_MSG_TXT(feh.GetErrorMsg().c_str());
mexErrMsgTxt(feh.GetErrorMsg().c_str());
}
}
@ -1116,42 +1084,21 @@ main(int nrhs, const char *prhs[])
#endif
clock_t t1 = clock();
if (!steady_state && !evaluate && no_error && print)
if (!steady_state && !evaluate && print)
mexPrintf("Simulation Time=%f milliseconds\n", 1000.0*(double (t1)-double (t0))/double (CLOCKS_PER_SEC));
#ifndef DEBUG_EX
bool dont_store_a_structure = false;
if (nlhs > 0)
{
plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
pind = mxGetPr(plhs[0]);
if (no_error)
pind[0] = 0;
else
pind[0] = 1;
if (nlhs > 1)
if (block >= 0)
{
if (block >= 0)
if (evaluate)
{
if (evaluate)
{
vector<double> residual = interprete.get_residual();
plhs[1] = mxCreateDoubleMatrix(int (residual.size()/double (col_y)), int (col_y), mxREAL);
pind = mxGetPr(plhs[1]);
for (i = 0; i < residual.size(); i++)
pind[i] = residual[i];
}
else
{
int out_periods;
if (extended_path)
out_periods = max_periods + y_kmin;
else
out_periods = row_y;
plhs[1] = mxCreateDoubleMatrix(out_periods, int (col_y), mxREAL);
pind = mxGetPr(plhs[1]);
for (i = 0; i < out_periods*col_y; i++)
pind[i] = y[i];
}
vector<double> residual = interprete.get_residual();
plhs[0] = mxCreateDoubleMatrix(int (residual.size()/double (col_y)), int (col_y), mxREAL);
pind = mxGetPr(plhs[0]);
for (i = 0; i < residual.size(); i++)
pind[i] = residual[i];
}
else
{
@ -1159,99 +1106,111 @@ main(int nrhs, const char *prhs[])
if (extended_path)
out_periods = max_periods + y_kmin;
else
out_periods = col_y;
plhs[1] = mxCreateDoubleMatrix(int (row_y), out_periods, mxREAL);
pind = mxGetPr(plhs[1]);
if (evaluate)
out_periods = row_y;
plhs[0] = mxCreateDoubleMatrix(out_periods, int (col_y), mxREAL);
pind = mxGetPr(plhs[0]);
for (i = 0; i < out_periods*col_y; i++)
pind[i] = y[i];
}
}
else
{
int out_periods;
if (extended_path)
out_periods = max_periods + y_kmin;
else
out_periods = col_y;
plhs[0] = mxCreateDoubleMatrix(int (row_y), out_periods, mxREAL);
pind = mxGetPr(plhs[0]);
if (evaluate)
{
vector<double> residual = interprete.get_residual();
for (i = 0; i < residual.size(); i++)
pind[i] = residual[i];
}
else
for (i = 0; i < row_y*out_periods; i++)
pind[i] = y[i];
}
if (nlhs > 1)
{
if (evaluate)
{
int jacob_field_number = 0, jacob_exo_field_number = 0, jacob_exo_det_field_number = 0, jacob_other_endo_field_number = 0;
if (!block_structur)
{
vector<double> residual = interprete.get_residual();
for (i = 0; i < residual.size(); i++)
pind[i] = residual[i];
const char *field_names[] = {"g1", "g1_x", "g1_xd", "g1_o"};
jacob_field_number = 0;
jacob_exo_field_number = 1;
jacob_exo_det_field_number = 2;
jacob_other_endo_field_number = 3;
mwSize dims[1] = {static_cast<mwSize>(nb_blocks) };
plhs[1] = mxCreateStructArray(1, dims, 4, field_names);
}
else if (!mxIsStruct(block_structur))
{
plhs[1] = interprete.get_jacob(0);
//mexCallMATLAB(0,NULL, 1, &plhs[1], "disp");
dont_store_a_structure = true;
}
else
for (i = 0; i < row_y*out_periods; i++)
pind[i] = y[i];
}
if (nlhs > 2)
{
if (evaluate)
{
int jacob_field_number = 0, jacob_exo_field_number = 0, jacob_exo_det_field_number = 0, jacob_other_endo_field_number = 0;
if (!block_structur)
plhs[1] = block_structur;
jacob_field_number = mxAddField(plhs[1], "g1");
if (jacob_field_number == -1)
mexErrMsgTxt("Fatal error in bytecode: in main, cannot add extra field jacob to the structArray\n");
jacob_exo_field_number = mxAddField(plhs[1], "g1_x");
if (jacob_exo_field_number == -1)
mexErrMsgTxt("Fatal error in bytecode: in main, cannot add extra field jacob_exo to the structArray\n");
jacob_exo_det_field_number = mxAddField(plhs[1], "g1_xd");
if (jacob_exo_det_field_number == -1)
mexErrMsgTxt("Fatal error in bytecode: in main, cannot add extra field jacob_exo_det to the structArray\n");
jacob_other_endo_field_number = mxAddField(plhs[1], "g1_o");
if (jacob_other_endo_field_number == -1)
mexErrMsgTxt("Fatal error in bytecode: in main, cannot add extra field jacob_other_endo to the structArray\n");
}
if (!dont_store_a_structure)
{
for (int i = 0; i < nb_blocks; i++)
{
const char *field_names[] = {"g1", "g1_x", "g1_xd", "g1_o"};
jacob_field_number = 0;
jacob_exo_field_number = 1;
jacob_exo_det_field_number = 2;
jacob_other_endo_field_number = 3;
mwSize dims[1] = {static_cast<mwSize>(nb_blocks) };
plhs[2] = mxCreateStructArray(1, dims, 4, field_names);
}
else if (!mxIsStruct(block_structur))
{
plhs[2] = interprete.get_jacob(0);
//mexCallMATLAB(0,NULL, 1, &plhs[2], "disp");
dont_store_a_structure = true;
}
else
{
plhs[2] = block_structur;
jacob_field_number = mxAddField(plhs[2], "g1");
if (jacob_field_number == -1)
DYN_MEX_FUNC_ERR_MSG_TXT("Fatal error in bytecode: in main, cannot add extra field jacob to the structArray\n");
jacob_exo_field_number = mxAddField(plhs[2], "g1_x");
if (jacob_exo_field_number == -1)
DYN_MEX_FUNC_ERR_MSG_TXT("Fatal error in bytecode: in main, cannot add extra field jacob_exo to the structArray\n");
jacob_exo_det_field_number = mxAddField(plhs[2], "g1_xd");
if (jacob_exo_det_field_number == -1)
DYN_MEX_FUNC_ERR_MSG_TXT("Fatal error in bytecode: in main, cannot add extra field jacob_exo_det to the structArray\n");
jacob_other_endo_field_number = mxAddField(plhs[2], "g1_o");
if (jacob_other_endo_field_number == -1)
DYN_MEX_FUNC_ERR_MSG_TXT("Fatal error in bytecode: in main, cannot add extra field jacob_other_endo to the structArray\n");
}
if (!dont_store_a_structure)
{
for (int i = 0; i < nb_blocks; i++)
mxSetFieldByNumber(plhs[1], i, jacob_field_number, interprete.get_jacob(i));
if (!steady_state)
{
mxSetFieldByNumber(plhs[2], i, jacob_field_number, interprete.get_jacob(i));
if (!steady_state)
{
mxSetFieldByNumber(plhs[2], i, jacob_exo_field_number, interprete.get_jacob_exo(i));
mxSetFieldByNumber(plhs[2], i, jacob_exo_det_field_number, interprete.get_jacob_exo_det(i));
mxSetFieldByNumber(plhs[2], i, jacob_other_endo_field_number, interprete.get_jacob_other_endo(i));
}
mxSetFieldByNumber(plhs[1], i, jacob_exo_field_number, interprete.get_jacob_exo(i));
mxSetFieldByNumber(plhs[1], i, jacob_exo_det_field_number, interprete.get_jacob_exo_det(i));
mxSetFieldByNumber(plhs[1], i, jacob_other_endo_field_number, interprete.get_jacob_other_endo(i));
}
}
}
else
}
else
{
plhs[1] = mxCreateDoubleMatrix(int (row_x), int (col_x), mxREAL);
pind = mxGetPr(plhs[1]);
for (i = 0; i < row_x*col_x; i++)
{
plhs[2] = mxCreateDoubleMatrix(int (row_x), int (col_x), mxREAL);
pind = mxGetPr(plhs[2]);
for (i = 0; i < row_x*col_x; i++)
{
pind[i] = x[i];
}
}
if (nlhs > 3)
{
plhs[3] = mxCreateDoubleMatrix(int (row_y), int (col_y), mxREAL);
pind = mxGetPr(plhs[3]);
for (i = 0; i < row_y*col_y; i++)
pind[i] = y[i];
if (nlhs > 4)
{
mxArray *GlobalTemporaryTerms = interprete.get_Temporary_Terms();
size_t nb_temp_terms = mxGetM(GlobalTemporaryTerms);
plhs[4] = mxCreateDoubleMatrix(int (nb_temp_terms), 1, mxREAL);
pind = mxGetPr(plhs[4]);
double *tt = mxGetPr(GlobalTemporaryTerms);
for (i = 0; i < nb_temp_terms; i++)
pind[i] = tt[i];
}
pind[i] = x[i];
}
}
if (nlhs > 2)
{
plhs[2] = mxCreateDoubleMatrix(int (row_y), int (col_y), mxREAL);
pind = mxGetPr(plhs[2]);
for (i = 0; i < row_y*col_y; i++)
pind[i] = y[i];
if (nlhs > 3)
{
mxArray *GlobalTemporaryTerms = interprete.get_Temporary_Terms();
size_t nb_temp_terms = mxGetM(GlobalTemporaryTerms);
plhs[3] = mxCreateDoubleMatrix(int (nb_temp_terms), 1, mxREAL);
pind = mxGetPr(plhs[3]);
double *tt = mxGetPr(GlobalTemporaryTerms);
for (i = 0; i < nb_temp_terms; i++)
pind[i] = tt[i];
}
}
}
}
#else

9
mex/sources/bytecode/testing/mex_interface.hh
View File

@ -1,5 +1,5 @@
/*
* Copyright © 2007-2017 Dynare Team
* Copyright © 2007-2020 Dynare Team
*
* This file is part of Dynare.
*
@ -29,13 +29,6 @@
#include <algorithm>
using namespace std;
#if !defined(DYN_MEX_FUNC_ERR_MSG_TXT)
# define DYN_MEX_FUNC_ERR_MSG_TXT(str) \
do { \
mexPrintf("%s\n", str); \
} while (0)
#endif
typedef unsigned int mwIndex;
typedef unsigned int mwSize;

37
mex/sources/dynare_simul_/dynare_simul_.cc
View File

@ -1,6 +1,6 @@
/*
* Copyright © 2005-2011 Ondra Kamenik
* Copyright © 2019 Dynare Team
* Copyright © 2019-2020 Dynare Team
*
* This file is part of Dynare.
*
@ -51,8 +51,8 @@ extern "C" {
mexFunction(int nlhs, mxArray *plhs[],
int nhrs, const mxArray *prhs[])
{
if (nhrs != 12 || nlhs != 2)
DYN_MEX_FUNC_ERR_MSG_TXT("dynare_simul_ must have at exactly 12 input parameters and 2 output arguments.\n");
if (nhrs != 12 || nlhs != 1)
mexErrMsgTxt("dynare_simul_ must have at exactly 12 input parameters and 1 output argument.");
int order = static_cast<int>(mxGetScalar(prhs[0]));
int nstat = static_cast<int>(mxGetScalar(prhs[1]));
@ -74,22 +74,22 @@ extern "C" {
int ny = nstat + npred + nboth + nforw;
if (ny != static_cast<int>(ystart_dim[0]))
DYN_MEX_FUNC_ERR_MSG_TXT("ystart has wrong number of rows.\n");
mexErrMsgTxt("ystart has wrong number of rows.\n");
if (1 != ystart_dim[1])
DYN_MEX_FUNC_ERR_MSG_TXT("ystart has wrong number of cols.\n");
mexErrMsgTxt("ystart has wrong number of cols.\n");
int nper = shocks_dim[1];
if (nexog != static_cast<int>(shocks_dim[0]))
DYN_MEX_FUNC_ERR_MSG_TXT("shocks has a wrong number of rows.\n");
mexErrMsgTxt("shocks has a wrong number of rows.\n");
if (nexog != static_cast<int>(vcov_dim[0]))
DYN_MEX_FUNC_ERR_MSG_TXT("vcov has a wrong number of rows.\n");
mexErrMsgTxt("vcov has a wrong number of rows.\n");
if (nexog != static_cast<int>(vcov_dim[1]))
DYN_MEX_FUNC_ERR_MSG_TXT("vcov has a wrong number of cols.\n");
mexErrMsgTxt("vcov has a wrong number of cols.\n");
if (ny != static_cast<int>(ysteady_dim[0]))
DYN_MEX_FUNC_ERR_MSG_TXT("ysteady has wrong number of rows.\n");
mexErrMsgTxt("ysteady has wrong number of rows.\n");
if (1 != ysteady_dim[1])
DYN_MEX_FUNC_ERR_MSG_TXT("ysteady has wrong number of cols.\n");
mexErrMsgTxt("ysteady has wrong number of cols.\n");
plhs[1] = mxCreateDoubleMatrix(ny, nper, mxREAL);
plhs[0] = mxCreateDoubleMatrix(ny, nper, mxREAL);
try
{
@ -102,13 +102,13 @@ extern "C" {
{
const mxArray *gk_m = mxGetField(dr, 0, ("g_" + std::to_string(dim)).c_str());
if (!gk_m)
DYN_MEX_FUNC_ERR_MSG_TXT(("Can't find field `g_" + std::to_string(dim) + "' in structured passed as last argument").c_str());
mexErrMsgTxt(("Can't find field `g_" + std::to_string(dim) + "' in structured passed as last argument").c_str());
ConstTwoDMatrix gk(gk_m);
FFSTensor ft(ny, npred+nboth+nexog, dim);
if (ft.ncols() != gk.ncols())
DYN_MEX_FUNC_ERR_MSG_TXT(("Wrong number of columns for folded tensor: got " + std::to_string(gk.ncols()) + " but i want " + std::to_string(ft.ncols()) + '\n').c_str());
mexErrMsgTxt(("Wrong number of columns for folded tensor: got " + std::to_string(gk.ncols()) + " but i want " + std::to_string(ft.ncols()) + '\n').c_str());
if (ft.nrows() != gk.nrows())
DYN_MEX_FUNC_ERR_MSG_TXT(("Wrong number of rows for folded tensor: got " + std::to_string(gk.nrows()) + " but i want " + std::to_string(ft.nrows()) + '\n').c_str());
mexErrMsgTxt(("Wrong number of rows for folded tensor: got " + std::to_string(gk.nrows()) + " but i want " + std::to_string(ft.nrows()) + '\n').c_str());
ft.zeros();
ft.add(1.0, gk);
pol.insert(std::make_unique<UFSTensor>(ft));
@ -123,21 +123,20 @@ extern "C" {
// simulate and copy the results
TwoDMatrix res_mat{dr.simulate(DecisionRule::emethod::horner, nper,
ConstVector{ystart}, sr)};
TwoDMatrix res_tmp_mat{plhs[1]};
TwoDMatrix res_tmp_mat{plhs[0]};
res_tmp_mat = const_cast<const TwoDMatrix &>(res_mat);
}
catch (const KordException &e)
{
DYN_MEX_FUNC_ERR_MSG_TXT("Caught Kord exception.");
mexErrMsgTxt("Caught Kord exception.");
}
catch (const TLException &e)
{
DYN_MEX_FUNC_ERR_MSG_TXT("Caught TL exception.");
mexErrMsgTxt("Caught TL exception.");
}
catch (SylvException &e)
{
DYN_MEX_FUNC_ERR_MSG_TXT("Caught Sylv exception.");
mexErrMsgTxt("Caught Sylv exception.");
}
plhs[0] = mxCreateDoubleScalar(0);
}
};

16
mex/sources/dynmex.h
View File

@ -1,5 +1,5 @@
/*
* Copyright © 2009-2019 Dynare Team
* Copyright © 2009-2020 Dynare Team
*
* This file is part of Dynare.
*
@ -26,20 +26,6 @@
#include <mex.h>
/*
* Fix for trac ticket Ticket #137
*/
#if !defined(DYN_MEX_FUNC_ERR_MSG_TXT)
# define DYN_MEX_FUNC_ERR_MSG_TXT(str) \
do { \
mexPrintf("%s\n", str); \
int i; \
for (i = 0; i < nlhs; i++) \
plhs[i] = mxCreateDoubleScalar(1); \
return; \
} while (0)
#endif
#if defined(MATLAB_MEX_FILE) && MATLAB_VERSION < 0x0805
# define mxIsScalar(x) (mxGetM(x) == 1 && mxGetN(x) == 1)
#endif

29
mex/sources/gensylv/gensylv.cc
View File

@ -1,6 +1,6 @@
/*
* Copyright © 2005-2011 Ondra Kamenik
* Copyright © 2019 Dynare Team
* Copyright © 2019-2020 Dynare Team
*
* This file is part of Dynare.
*
@ -51,8 +51,8 @@ extern "C" {
mexFunction(int nlhs, mxArray *plhs[],
int nhrs, const mxArray *prhs[])
{
if (nhrs != 5 || nlhs > 3 || nlhs < 2)
DYN_MEX_FUNC_ERR_MSG_TXT("Gensylv: Must have exactly 5 input args and either 2 or 3 output args.");
if (nhrs != 5 || nlhs > 2 || nlhs < 1)
mexErrMsgTxt("Gensylv: Must have exactly 5 input args and either 1 or 2 output args.");
auto order = static_cast<int>(mxGetScalar(prhs[0]));
const mxArray *const A = prhs[1];
@ -65,17 +65,17 @@ extern "C" {
const mwSize *const Ddims = mxGetDimensions(D);
if (Adims[0] != Adims[1])
DYN_MEX_FUNC_ERR_MSG_TXT("Matrix A must be a square matrix.");
mexErrMsgTxt("Matrix A must be a square matrix.");
if (Adims[0] != Bdims[0])
DYN_MEX_FUNC_ERR_MSG_TXT("Matrix A and matrix B must have the same number of rows.");
mexErrMsgTxt("Matrix A and matrix B must have the same number of rows.");
if (Adims[0] != Ddims[0])
DYN_MEX_FUNC_ERR_MSG_TXT("Matrix A and matrix B must have the same number of rows.");
mexErrMsgTxt("Matrix A and matrix B must have the same number of rows.");
if (Cdims[0] != Cdims[1])
DYN_MEX_FUNC_ERR_MSG_TXT("Matrix C must be square.");
mexErrMsgTxt("Matrix C must be square.");
if (Bdims[0] < Bdims[1])
DYN_MEX_FUNC_ERR_MSG_TXT("Matrix B must not have more columns than rows.");
mexErrMsgTxt("Matrix B must not have more columns than rows.");
if (Ddims[1] != static_cast<mwSize>(power(Cdims[0], order)))
DYN_MEX_FUNC_ERR_MSG_TXT("Matrix D has wrong number of columns.");
mexErrMsgTxt("Matrix D has wrong number of columns.");
auto n = static_cast<int>(Adims[0]);
auto m = static_cast<int>(Cdims[0]);
@ -88,16 +88,15 @@ extern "C" {
// solve (or solve and check)
try
{
if (nlhs == 2)
if (nlhs == 1)
gen_sylv_solve(order, n, m, zero_cols, Avec, Bvec, Cvec, Xvec);
else if (nlhs == 3)
plhs[2] = gen_sylv_solve_and_check(order, n, m, zero_cols, Avec, Bvec, Cvec, Dvec, Xvec);
else if (nlhs == 2)
plhs[1] = gen_sylv_solve_and_check(order, n, m, zero_cols, Avec, Bvec, Cvec, Dvec, Xvec);
}
catch (const SylvException &e)
{
DYN_MEX_FUNC_ERR_MSG_TXT(e.getMessage().c_str());
mexErrMsgTxt(e.getMessage().c_str());
}
plhs[1] = X;
plhs[0] = mxCreateDoubleScalar(0);
plhs[0] = X;
}
};

85
mex/sources/k_order_perturbation/k_order_perturbation.cc
View File

@ -1,5 +1,5 @@
/*
* Copyright © 2008-2019 Dynare Team
* Copyright © 2008-2020 Dynare Team
*
* This file is part of Dynare.
*
@ -82,8 +82,8 @@ extern "C" {
mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
if (nrhs < 3 || nlhs < 2 || nlhs > 3)
DYN_MEX_FUNC_ERR_MSG_TXT("Must have at least 3 input parameters and takes 2 or 3 output parameters.");
if (nrhs < 3 || nlhs < 1 || nlhs > 2)
mexErrMsgTxt("Must have at least 3 input parameters and takes 1 or 2 output parameters.");
// Give explicit names to input arguments
const mxArray *dr_mx = prhs[0];
@ -101,11 +101,11 @@ extern "C" {
// Extract various fields from options_
const int kOrder = get_int_field(options_mx, "order");
if (kOrder < 1)
DYN_MEX_FUNC_ERR_MSG_TXT("options_.order must be at least 1");
mexErrMsgTxt("options_.order must be at least 1");
const mxArray *use_dll_mx = mxGetField(options_mx, 0, "use_dll");
if (!(use_dll_mx && mxIsLogicalScalar(use_dll_mx)))
DYN_MEX_FUNC_ERR_MSG_TXT("options_.use_dll should be a logical scalar");
mexErrMsgTxt("options_.use_dll should be a logical scalar");
bool use_dll = static_cast<bool>(mxGetScalar(use_dll_mx));
double qz_criterium = 1+1e-6;
@ -115,31 +115,31 @@ extern "C" {
const mxArray *threads_mx = mxGetField(options_mx, 0, "threads");
if (!threads_mx)
DYN_MEX_FUNC_ERR_MSG_TXT("Can't find field options_.threads");
mexErrMsgTxt("Can't find field options_.threads");
const mxArray *num_threads_mx = mxGetField(threads_mx, 0, "k_order_perturbation");
if (!(num_threads_mx && mxIsScalar(num_threads_mx) && mxIsNumeric(num_threads_mx)))
DYN_MEX_FUNC_ERR_MSG_TXT("options_.threads.k_order_perturbation be a numeric scalar");
mexErrMsgTxt("options_.threads.k_order_perturbation be a numeric scalar");
int num_threads = static_cast<int>(mxGetScalar(num_threads_mx));
// Extract various fields from M_
const mxArray *fname_mx = mxGetField(M_mx, 0, "fname");
if (!(fname_mx && mxIsChar(fname_mx) && mxGetM(fname_mx) == 1))
DYN_MEX_FUNC_ERR_MSG_TXT("M_.fname should be a character string");
mexErrMsgTxt("M_.fname should be a character string");
std::string fname{mxArrayToString(fname_mx)};
const mxArray *params_mx = mxGetField(M_mx, 0, "params");
if (!(params_mx && mxIsDouble(params_mx)))
DYN_MEX_FUNC_ERR_MSG_TXT("M_.params should be a double precision array");
mexErrMsgTxt("M_.params should be a double precision array");
Vector modParams{ConstVector{params_mx}};
if (!modParams.isFinite())
DYN_MEX_FUNC_ERR_MSG_TXT("M_.params contains NaN or Inf");
mexErrMsgTxt("M_.params contains NaN or Inf");
const mxArray *sigma_e_mx = mxGetField(M_mx, 0, "Sigma_e");
if (!(sigma_e_mx && mxIsDouble(sigma_e_mx) && mxGetM(sigma_e_mx) == mxGetN(sigma_e_mx)))
DYN_MEX_FUNC_ERR_MSG_TXT("M_.Sigma_e should be a double precision square matrix");
mexErrMsgTxt("M_.Sigma_e should be a double precision square matrix");
TwoDMatrix vCov{ConstTwoDMatrix{sigma_e_mx}};
if (!vCov.isFinite())
DYN_MEX_FUNC_ERR_MSG_TXT("M_.Sigma_e contains NaN or Inf");
mexErrMsgTxt("M_.Sigma_e contains NaN or Inf");
const int nStat = get_int_field(M_mx, "nstatic");
const int nPred = get_int_field(M_mx, "npred");
@ -153,42 +153,42 @@ extern "C" {
const mxArray *lead_lag_incidence_mx = mxGetField(M_mx, 0, "lead_lag_incidence");
if (!(lead_lag_incidence_mx && mxIsDouble(lead_lag_incidence_mx) && mxGetM(lead_lag_incidence_mx) == 3
&& mxGetN(lead_lag_incidence_mx) == static_cast<size_t>(nEndo)))
DYN_MEX_FUNC_ERR_MSG_TXT("M_.lead_lag_incidence should be a double precision matrix with 3 rows and M_.endo_nbr columns");
mexErrMsgTxt("M_.lead_lag_incidence should be a double precision matrix with 3 rows and M_.endo_nbr columns");
ConstTwoDMatrix llincidence{lead_lag_incidence_mx};
const mxArray *nnzderivatives_mx = mxGetField(M_mx, 0, "NNZDerivatives");
if (!(nnzderivatives_mx && mxIsDouble(nnzderivatives_mx)))
DYN_MEX_FUNC_ERR_MSG_TXT("M_.NNZDerivatives should be a double precision array");
mexErrMsgTxt("M_.NNZDerivatives should be a double precision array");
ConstVector NNZD{nnzderivatives_mx};
if (NNZD.length() < kOrder || NNZD[kOrder-1] == -1)
DYN_MEX_FUNC_ERR_MSG_TXT("The derivatives were not computed for the required order. Make sure that you used the right order option inside the `stoch_simul' command");
mexErrMsgTxt("The derivatives were not computed for the required order. Make sure that you used the right order option inside the `stoch_simul' command");
const mxArray *endo_names_mx = mxGetField(M_mx, 0, "endo_names");
if (!(endo_names_mx && mxIsCell(endo_names_mx) && mxGetNumberOfElements(endo_names_mx) == static_cast<size_t>(nEndo)))
DYN_MEX_FUNC_ERR_MSG_TXT("M_.endo_names should be a cell array of M_.endo_nbr elements");
mexErrMsgTxt("M_.endo_names should be a cell array of M_.endo_nbr elements");
std::vector<std::string> endoNames = DynareMxArrayToString(endo_names_mx);
const mxArray *exo_names_mx = mxGetField(M_mx, 0, "exo_names");
if (!(exo_names_mx && mxIsCell(exo_names_mx) && mxGetNumberOfElements(exo_names_mx) == static_cast<size_t>(nExog)))
DYN_MEX_FUNC_ERR_MSG_TXT("M_.exo_names should be a cell array of M_.exo_nbr elements");
mexErrMsgTxt("M_.exo_names should be a cell array of M_.exo_nbr elements");
std::vector<std::string> exoNames = DynareMxArrayToString(exo_names_mx);
const mxArray *dynamic_tmp_nbr_mx = mxGetField(M_mx, 0, "dynamic_tmp_nbr");
if (!(dynamic_tmp_nbr_mx && mxIsDouble(dynamic_tmp_nbr_mx) && mxGetNumberOfElements(dynamic_tmp_nbr_mx) >= static_cast<size_t>(kOrder+1)))
DYN_MEX_FUNC_ERR_MSG_TXT("M_.dynamic_tmp_nbr should be a double precision array with strictly more elements than the order of derivation");
mexErrMsgTxt("M_.dynamic_tmp_nbr should be a double precision array with strictly more elements than the order of derivation");
int ntt = std::accumulate(mxGetPr(dynamic_tmp_nbr_mx), mxGetPr(dynamic_tmp_nbr_mx)+kOrder+1, 0);
// Extract various fields from dr
const mxArray *ys_mx = mxGetField(dr_mx, 0, "ys"); // and not in order of dr.order_var
if (!(ys_mx && mxIsDouble(ys_mx)))
DYN_MEX_FUNC_ERR_MSG_TXT("dr.ys should be a double precision array");
mexErrMsgTxt("dr.ys should be a double precision array");
Vector ySteady{ConstVector{ys_mx}};
if (!ySteady.isFinite())
DYN_MEX_FUNC_ERR_MSG_TXT("dr.ys contains NaN or Inf");
mexErrMsgTxt("dr.ys contains NaN or Inf");
const mxArray *order_var_mx = mxGetField(dr_mx, 0, "order_var");
if (!(order_var_mx && mxIsDouble(order_var_mx) && mxGetNumberOfElements(order_var_mx) == static_cast<size_t>(nEndo)))
DYN_MEX_FUNC_ERR_MSG_TXT("dr.order_var should be a double precision array of M_.endo_nbr elements");
mexErrMsgTxt("dr.order_var should be a double precision array of M_.endo_nbr elements");
std::vector<int> dr_order(nEndo);
std::transform(mxGetPr(order_var_mx), mxGetPr(order_var_mx)+nEndo, dr_order.begin(),
[](double x) { return static_cast<int>(x)-1; });
@ -241,7 +241,7 @@ extern "C" {
const char *g_fieldnames_c[kOrder+1];
for (int i = 0; i <= kOrder; i++)
g_fieldnames_c[i] = g_fieldnames[i].c_str();
plhs[1] = mxCreateStructMatrix(1, 1, kOrder+1, g_fieldnames_c);
plhs[0] = mxCreateStructMatrix(1, 1, kOrder+1, g_fieldnames_c);
// Fill that structure
for (int i = 0; i <= kOrder; i++)
@ -251,10 +251,10 @@ extern "C" {
const ConstVector &vec = t.getData();
assert(vec.skip() == 1);
std::copy_n(vec.base(), vec.length(), mxGetPr(tmp));
mxSetField(plhs[1], 0, ("g_" + std::to_string(i)).c_str(), tmp);
mxSetField(plhs[0], 0, ("g_" + std::to_string(i)).c_str(), tmp);
}
if (nlhs > 2)
if (nlhs > 1)
{
/* Return as 3rd argument a struct containing derivatives in Dynare
format (unfolded matrices, without Taylor coefficient) up to 3rd
@ -264,51 +264,50 @@ extern "C" {
size_t nfields = (kOrder == 1 ? 2 : (kOrder == 2 ? 6 : 12));
const char *c_fieldnames[] = { "gy", "gu", "gyy", "gyu", "guu", "gss",
"gyyy", "gyyu", "gyuu", "guuu", "gyss", "guss" };
plhs[2] = mxCreateStructMatrix(1, 1, nfields, c_fieldnames);
plhs[1] = mxCreateStructMatrix(1, 1, nfields, c_fieldnames);
copy_derivatives(plhs[2], Symmetry{1, 0, 0, 0}, derivs, "gy");
copy_derivatives(plhs[2], Symmetry{0, 1, 0, 0}, derivs, "gu");
copy_derivatives(plhs[1], Symmetry{1, 0, 0, 0}, derivs, "gy");
copy_derivatives(plhs[1], Symmetry{0, 1, 0, 0}, derivs, "gu");
if (kOrder >= 2)
{
copy_derivatives(plhs[2], Symmetry{2, 0, 0, 0}, derivs, "gyy");
copy_derivatives(plhs[2], Symmetry{0, 2, 0, 0}, derivs, "guu");
copy_derivatives(plhs[2], Symmetry{1, 1, 0, 0}, derivs, "gyu");
copy_derivatives(plhs[2], Symmetry{0, 0, 0, 2}, derivs, "gss");
copy_derivatives(plhs[1], Symmetry{2, 0, 0, 0}, derivs, "gyy");
copy_derivatives(plhs[1], Symmetry{0, 2, 0, 0}, derivs, "guu");
copy_derivatives(plhs[1], Symmetry{1, 1, 0, 0}, derivs, "gyu");
copy_derivatives(plhs[1], Symmetry{0, 0, 0, 2}, derivs, "gss");
}
if (kOrder >= 3)
{
copy_derivatives(plhs[2], Symmetry{3, 0, 0, 0}, derivs, "gyyy");
copy_derivatives(plhs[2], Symmetry{0, 3, 0, 0}, derivs, "guuu");
copy_derivatives(plhs[2], Symmetry{2, 1, 0, 0}, derivs, "gyyu");
copy_derivatives(plhs[2], Symmetry{1, 2, 0, 0}, derivs, "gyuu");
copy_derivatives(plhs[2], Symmetry{1, 0, 0, 2}, derivs, "gyss");
copy_derivatives(plhs[2], Symmetry{0, 1, 0, 2}, derivs, "guss");
copy_derivatives(plhs[1], Symmetry{3, 0, 0, 0}, derivs, "gyyy");
copy_derivatives(plhs[1], Symmetry{0, 3, 0, 0}, derivs, "guuu");
copy_derivatives(plhs[1], Symmetry{2, 1, 0, 0}, derivs, "gyyu");
copy_derivatives(plhs[1], Symmetry{1, 2, 0, 0}, derivs, "gyuu");
copy_derivatives(plhs[1], Symmetry{1, 0, 0, 2}, derivs, "gyss");
copy_derivatives(plhs[1], Symmetry{0, 1, 0, 2}, derivs, "guss");
}
}
}
catch (const KordException &e)
{
e.print();
DYN_MEX_FUNC_ERR_MSG_TXT(("dynare:k_order_perturbation: Caught Kord exception: " + e.get_message()).c_str());
mexErrMsgTxt(("dynare:k_order_perturbation: Caught Kord exception: " + e.get_message()).c_str());
}
catch (const TLException &e)
{
e.print();
DYN_MEX_FUNC_ERR_MSG_TXT("dynare:k_order_perturbation: Caught TL exception");
mexErrMsgTxt("dynare:k_order_perturbation: Caught TL exception");
}
catch (SylvException &e)
{
e.printMessage();
DYN_MEX_FUNC_ERR_MSG_TXT("dynare:k_order_perturbation: Caught Sylv exception");
mexErrMsgTxt("dynare:k_order_perturbation: Caught Sylv exception");
}
catch (const DynareException &e)
{
DYN_MEX_FUNC_ERR_MSG_TXT(("dynare:k_order_perturbation: Caught KordDynare exception: " + e.message()).c_str());
mexErrMsgTxt(("dynare:k_order_perturbation: Caught KordDynare exception: " + e.message()).c_str());
}
catch (const ogu::Exception &e)
{
DYN_MEX_FUNC_ERR_MSG_TXT(("dynare:k_order_perturbation: Caught general exception: " + e.message()).c_str());
mexErrMsgTxt(("dynare:k_order_perturbation: Caught general exception: " + e.message()).c_str());
}
plhs[0] = mxCreateDoubleScalar(0);
} // end of mexFunction()
} // end of extern C

47
mex/sources/kalman_steady_state/kalman_steady_state.cc
View File

@ -1,5 +1,5 @@
/*
* Copyright © 2009-2019 Dynare Team.
* Copyright © 2009-2020 Dynare Team.
*
* This file is part of Dynare.
*
@ -76,10 +76,10 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
// Check the number of arguments and set some flags.
bool measurement_error_flag = true;
if (nrhs < 3 || 4 < nrhs)
DYN_MEX_FUNC_ERR_MSG_TXT("kalman_steady_state accepts either 3 or 4 input arguments!");
mexErrMsgTxt("kalman_steady_state accepts either 3 or 4 input arguments!");
if (nlhs < 1 || 2 < nlhs)
DYN_MEX_FUNC_ERR_MSG_TXT("kalman_steady_state requires at least 1, but no more than 2, output arguments!");
if (nlhs != 1)
mexErrMsgTxt("kalman_steady_state accepts exactly one output argument!");
if (nrhs == 3)
measurement_error_flag = false;
@ -87,30 +87,30 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
// Check the type of the input arguments and get the size of the matrices.
lapack_int n = mxGetM(prhs[0]);
if (static_cast<size_t>(n) != mxGetN(prhs[0]))
DYN_MEX_FUNC_ERR_MSG_TXT("kalman_steady_state: The first input argument (T) must be a square matrix!");
mexErrMsgTxt("kalman_steady_state: The first input argument (T) must be a square matrix!");
if (mxIsNumeric(prhs[0]) == 0 || mxIsComplex(prhs[0]) == 1)
DYN_MEX_FUNC_ERR_MSG_TXT("kalman_steady_state: The first input argument (T) must be a real matrix!");
mexErrMsgTxt("kalman_steady_state: The first input argument (T) must be a real matrix!");
lapack_int q = mxGetM(prhs[1]);
if (static_cast<size_t>(q) != mxGetN(prhs[1]))
DYN_MEX_FUNC_ERR_MSG_TXT("kalman_steady_state: The second input argument (QQ) must be a square matrix!");
mexErrMsgTxt("kalman_steady_state: The second input argument (QQ) must be a square matrix!");
if (mxIsNumeric(prhs[1]) == 0 || mxIsComplex(prhs[1]) == 1)
DYN_MEX_FUNC_ERR_MSG_TXT("kalman_steady_state: The second input argument (QQ) must be a real matrix!");
mexErrMsgTxt("kalman_steady_state: The second input argument (QQ) must be a real matrix!");
if (q != n)
DYN_MEX_FUNC_ERR_MSG_TXT("kalman_steady_state: The size of the second input argument (QQ) must match the size of the first argument (T)!");
mexErrMsgTxt("kalman_steady_state: The size of the second input argument (QQ) must match the size of the first argument (T)!");
lapack_int p = mxGetN(prhs[2]);
if (mxGetM(prhs[2]) != static_cast<size_t>(n))
DYN_MEX_FUNC_ERR_MSG_TXT("kalman_steady_state: The number of rows of the third argument (Z) must match the number of rows of the first argument (T)!");
mexErrMsgTxt("kalman_steady_state: The number of rows of the third argument (Z) must match the number of rows of the first argument (T)!");
if (mxIsNumeric(prhs[2]) == 0 || mxIsComplex(prhs[2]) == 1)
DYN_MEX_FUNC_ERR_MSG_TXT("kalman_steady_state: The third input argument (Z) must be a real matrix!");
mexErrMsgTxt("kalman_steady_state: The third input argument (Z) must be a real matrix!");
if (measurement_error_flag)
{
if (mxGetM(prhs[3]) != mxGetN(prhs[3]))
DYN_MEX_FUNC_ERR_MSG_TXT("kalman_steady_state: The fourth input argument (H) must be a square matrix!");
mexErrMsgTxt("kalman_steady_state: The fourth input argument (H) must be a square matrix!");
if (mxGetM(prhs[3]) != static_cast<size_t>(p))
DYN_MEX_FUNC_ERR_MSG_TXT("kalman_steady_state: The number of rows of the fourth input argument (H) must match the number of rows of the third input argument!");
mexErrMsgTxt("kalman_steady_state: The number of rows of the fourth input argument (H) must match the number of rows of the third input argument!");
if (mxIsNumeric(prhs[3]) == 0 || mxIsComplex(prhs[3]) == 1)
DYN_MEX_FUNC_ERR_MSG_TXT("kalman_steady_state: The fifth input argument (H) must be a real matrix!");
mexErrMsgTxt("kalman_steady_state: The fifth input argument (H) must be a real matrix!");
}
// Get input matrices.
const double *T = mxGetPr(prhs[0]);
@ -147,8 +147,8 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
auto DWORK = std::make_unique<double[]>(LDWORK);
auto BWORK = std::make_unique<lapack_int[]>(nn);
// Initialize the output of the mex file
plhs[1] = mxCreateDoubleMatrix(n, n, mxREAL);
double *P = mxGetPr(plhs[1]);
plhs[0] = mxCreateDoubleMatrix(n, n, mxREAL);
double *P = mxGetPr(plhs[0]);
// Call the slicot routine
sb02od("D", // We want to solve a discrete Riccati equation.
"B", // Matrices Z and H are given.
@ -164,25 +164,24 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
case 0:
break;
case 1:
DYN_MEX_FUNC_ERR_MSG_TXT("The computed extended matrix pencil is singular, possibly due to rounding errors.\n");
mexErrMsgTxt("The computed extended matrix pencil is singular, possibly due to rounding errors.");
break;
case 2:
DYN_MEX_FUNC_ERR_MSG_TXT("The QZ (or QR) algorithm failed!\n");
mexErrMsgTxt("The QZ (or QR) algorithm failed!");
break;
case 3:
DYN_MEX_FUNC_ERR_MSG_TXT("The reordering of the (generalized) eigenvalues failed!\n");
mexErrMsgTxt("The reordering of the (generalized) eigenvalues failed!");
break;
case 4:
DYN_MEX_FUNC_ERR_MSG_TXT("After reordering, roundoff changed values of some complex eigenvalues so that leading eigenvalues\n in the (generalized) Schur form no longer satisfy the stability condition; this could also be caused due to scaling.");
mexErrMsgTxt("After reordering, roundoff changed values of some complex eigenvalues so that leading eigenvalues\n in the (generalized) Schur form no longer satisfy the stability condition; this could also be caused due to scaling.");
break;
case 5:
DYN_MEX_FUNC_ERR_MSG_TXT("The computed dimension of the solution does not equal n!\n");
mexErrMsgTxt("The computed dimension of the solution does not equal n!");
break;
case 6:
DYN_MEX_FUNC_ERR_MSG_TXT("A singular matrix was encountered during the computation of the solution matrix P!\n");
mexErrMsgTxt("A singular matrix was encountered during the computation of the solution matrix P!");
break;
default:
DYN_MEX_FUNC_ERR_MSG_TXT("Unknown problem!\n");
mexErrMsgTxt("Unknown problem!");
}
plhs[0] = mxCreateDoubleScalar(0);
}

15
mex/sources/kronecker/A_times_B_kronecker_C.cc
View File

@ -1,5 +1,5 @@
/*
* Copyright © 2007-2019 Dynare Team
* Copyright © 2007-2020 Dynare Team
*
* This file is part of Dynare.
*
@ -68,8 +68,11 @@ void
mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
// Check input and output:
if (nrhs > 3 || nrhs < 2)
DYN_MEX_FUNC_ERR_MSG_TXT("A_times_B_kronecker_C takes 2 or 3 input arguments and provides 2 output arguments.");
if (nrhs > 3 || nrhs < 2 || nlhs != 1)
{
mexErrMsgTxt("A_times_B_kronecker_C takes 2 or 3 input arguments and provides 1 output argument.");
return; // Needed to shut up some GCC warnings
}
// Get & Check dimensions (columns and rows):
size_t mA = mxGetM(prhs[0]);
@ -82,12 +85,12 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
mC = mxGetM(prhs[2]);
nC = mxGetN(prhs[2]);
if (mB*mC != nA)
DYN_MEX_FUNC_ERR_MSG_TXT("Input dimension error!");
mexErrMsgTxt("Input dimension error!");
}
else // A·(B⊗B) is to be computed.
{
if (mB*mB != nA)
DYN_MEX_FUNC_ERR_MSG_TXT("Input dimension error!");
mexErrMsgTxt("Input dimension error!");
}
// Get input matrices:
const double *A = mxGetPr(prhs[0]);
@ -108,6 +111,4 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
full_A_times_kronecker_B_B(A, B, D, mA, nA, mB, nB);
else
full_A_times_kronecker_B_C(A, B, C, D, mA, nA, mB, nB, mC, nC);
plhs[1] = mxCreateDoubleScalar(0);
}

17
mex/sources/kronecker/sparse_hessian_times_B_kronecker_C.cc
View File

@ -1,5 +1,5 @@
/*
* Copyright © 2007-2019 Dynare Team
* Copyright © 2007-2020 Dynare Team
*
* This file is part of Dynare.
*
@ -135,11 +135,14 @@ void
mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
// Check input and output:
if (nrhs > 4 || nrhs < 3)
DYN_MEX_FUNC_ERR_MSG_TXT("sparse_hessian_times_B_kronecker_C takes 3 or 4 input arguments and provides 2 output arguments.");
if (nrhs > 4 || nrhs < 3 || nlhs != 1)
{
mexErrMsgTxt("sparse_hessian_times_B_kronecker_C takes 3 or 4 input arguments and provides 1 output argument.");
return; // Needed to shut up some GCC warnings
}
if (!mxIsSparse(prhs[0]))
DYN_MEX_FUNC_ERR_MSG_TXT("sparse_hessian_times_B_kronecker_C: First input must be a sparse (dynare) hessian matrix.");
mexErrMsgTxt("sparse_hessian_times_B_kronecker_C: First input must be a sparse (dynare) hessian matrix.");
// Get & Check dimensions (columns and rows):
size_t mA = mxGetM(prhs[0]);
@ -152,12 +155,12 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
mC = mxGetM(prhs[2]);
nC = mxGetN(prhs[2]);
if (mB*mC != nA)
DYN_MEX_FUNC_ERR_MSG_TXT("Input dimension error!");
mexErrMsgTxt("Input dimension error!");
}
else // A·(B⊗B) is to be computed.
{
if (mB*mB != nA)
DYN_MEX_FUNC_ERR_MSG_TXT("Input dimension error!");
mexErrMsgTxt("Input dimension error!");
}
// Get input matrices:
int numthreads;
@ -185,6 +188,4 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
sparse_hessian_times_B_kronecker_B(isparseA, jsparseA, vsparseA, B, D, mA, nA, mB, nB, numthreads);
else
sparse_hessian_times_B_kronecker_C(isparseA, jsparseA, vsparseA, B, C, D, mA, nA, mB, nB, mC, nC, numthreads);
plhs[1] = mxCreateDoubleScalar(0);
}

30
mex/sources/mjdgges/mjdgges.F08
View File

@ -60,8 +60,8 @@ subroutine mexFunction(nlhs, plhs, nrhs, prhs) bind(c, name='mexFunction')
real(real64), dimension(:), allocatable, target :: vsl_target
#endif
if (nrhs < 2 .or. nrhs > 4 .or. nlhs /= 7) then
call mexErrMsgTxt("MJDGGES: takes 2, 3 or 4 input arguments and exactly 7 output arguments.")
if (nrhs < 2 .or. nrhs > 4 .or. nlhs /= 6) then
call mexErrMsgTxt("MJDGGES: takes 2, 3 or 4 input arguments and exactly 6 output arguments.")
return
end if
@ -95,24 +95,24 @@ subroutine mexFunction(nlhs, plhs, nrhs, prhs) bind(c, name='mexFunction')
zhreshold = 1e-6_real64
end if
plhs(1) = mxCreateDoubleMatrix(n1, n1, mxREAL)
plhs(2) = mxCreateDoubleMatrix(n1, n1, mxREAL)
plhs(3) = mxCreateDoubleMatrix(n1, n1, mxREAL)
plhs(4) = mxCreateDoubleMatrix(n1, n1, mxREAL)
plhs(5) = mxCreateDoubleMatrix(1_mwSize, 1_mwSize, mxREAL)
plhs(6) = mxCreateDoubleMatrix(n1, 1_mwSize, mxCOMPLEX)
plhs(7) = mxCreateDoubleMatrix(1_mwSize, 1_mwSize, mxREAL)
plhs(4) = mxCreateDoubleMatrix(1_mwSize, 1_mwSize, mxREAL)
plhs(5) = mxCreateDoubleMatrix(n1, 1_mwSize, mxCOMPLEX)
plhs(6) = mxCreateDoubleMatrix(1_mwSize, 1_mwSize, mxREAL)
s => mxGetPr(plhs(2))
t => mxGetPr(plhs(3))
sdim => mxGetPr(plhs(5))
s => mxGetPr(plhs(1))
t => mxGetPr(plhs(2))
sdim => mxGetPr(plhs(4))
#if MX_HAS_INTERLEAVED_COMPLEX
gev => mxGetComplexDoubles(plhs(6))
gev => mxGetComplexDoubles(plhs(5))
#else
gev_r => mxGetPr(plhs(6))
gev_i => mxGetPi(plhs(6))
gev_r => mxGetPr(plhs(5))
gev_i => mxGetPi(plhs(5))
#endif
info => mxGetPr(plhs(7))
z => mxGetPr(plhs(4))
info => mxGetPr(plhs(6))
z => mxGetPr(plhs(3))
#if defined(MATLAB_MEX_FILE) && MATLAB_VERSION < 0x0904
! The left Schur vectors (VSL) are normally not computed, since JOBVSL="N".
! But old MKL versions (at least the one shipped with MATLAB R2009b/7.9,
@ -162,6 +162,4 @@ subroutine mexFunction(nlhs, plhs, nrhs, prhs) bind(c, name='mexFunction')
! error number (only if no other error)
if (any(abs(alpha_r) <= zhreshold .and. abs(beta) <= zhreshold) .and. info_bl == 0) &
info = 30
plhs(1) = mxCreateDoubleScalar(0._real64)
end subroutine mexFunction

18
mex/sources/ms-sbvar/mex_top_level.cc
View File

@ -1,5 +1,5 @@
/*
* Copyright © 2010-2017 Dynare Team
* Copyright © 2010-2020 Dynare Team
*
* This file is part of Dynare.
*
@ -42,8 +42,8 @@ mexFunction(int nlhs, mxArray *plhs[],
/*
* Check args
*/
if (nrhs != 1 || !mxIsChar(prhs[0]) || nlhs != 1)
DYN_MEX_FUNC_ERR_MSG_TXT("Error in MS-SBVAR MEX file: this function takes 1 string input argument and returns 1 output argument.");
if (nrhs != 1 || !mxIsChar(prhs[0]) || nlhs != 0)
mexErrMsgTxt("Error in MS-SBVAR MEX file: this function takes 1 string input argument and returns no output argument.");
/*
* Allocate memory
@ -52,24 +52,24 @@ mexFunction(int nlhs, mxArray *plhs[],
argument = static_cast<char *>(mxCalloc(mxGetN(prhs[0])+1, sizeof(char)));
args = static_cast<char **>(mxCalloc(maxnargs, sizeof(char *)));
if (argument == NULL || args == NULL)
DYN_MEX_FUNC_ERR_MSG_TXT("Error in MS-SBVAR MEX file: could not allocate memory. (1)");
mexErrMsgTxt("Error in MS-SBVAR MEX file: could not allocate memory. (1)");
/*
* Create argument string from prhs and parse to create args / nargs
*/
if (!(args[nargs] = static_cast<char *>(mxCalloc(strlen(mainarg)+1, sizeof(char)))))
DYN_MEX_FUNC_ERR_MSG_TXT("Error in MS-SBVAR MEX file: could not allocate memory. (2)");
mexErrMsgTxt("Error in MS-SBVAR MEX file: could not allocate memory. (2)");
strncpy(args[nargs++], mainarg, strlen(mainarg));
if (mxGetString(prhs[0], argument, mxGetN(prhs[0])+1))
DYN_MEX_FUNC_ERR_MSG_TXT("Error in MS-SBVAR MEX file: error using mxGetString.\n");
mexErrMsgTxt("Error in MS-SBVAR MEX file: error using mxGetString.\n");
beginarg = &argument[0];
while ((n = strcspn(beginarg, " ")))
{
if (!(args[nargs] = static_cast<char *>(mxCalloc(n+1, sizeof(char)))))
DYN_MEX_FUNC_ERR_MSG_TXT("Error in MS-SBVAR MEX file: could not allocate memory. (3)");
mexErrMsgTxt("Error in MS-SBVAR MEX file: could not allocate memory. (3)");
strncpy(args[nargs++], beginarg, n);
beginarg += (isspace(beginarg[n]) || isblank(beginarg[n]) ? ++n : n);
@ -85,7 +85,7 @@ mexFunction(int nlhs, mxArray *plhs[],
}
catch (const char *str)
{
DYN_MEX_FUNC_ERR_MSG_TXT(str);
mexErrMsgTxt(str);
}
/*
@ -94,6 +94,4 @@ mexFunction(int nlhs, mxArray *plhs[],
for (n = 0; n < nargs; n++)
mxFree(args[n]);
mxFree(args);
plhs[0] = mxCreateDoubleScalar(0);
}

26
mex/sources/sobol/qmc_sequence.cc
View File

@ -1,7 +1,7 @@
/*
** Computes Quasi Monte-Carlo sequence.
**
** Copyright © 2010-2017 Dynare Team
** Copyright © 2010-2020 Dynare Team
**
** This file is part of Dynare (can be used outside Dynare).
**
@ -52,23 +52,23 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
** Check the number of input and output arguments.
*/
if (nrhs < 3 || nrhs > 5)
DYN_MEX_FUNC_ERR_MSG_TXT("qmc_sequence:: Five, four or three input arguments are required!");
mexErrMsgTxt("qmc_sequence:: Five, four or three input arguments are required!");
if (nlhs == 0)
DYN_MEX_FUNC_ERR_MSG_TXT("qmc_sequence:: At least one output argument is required!");
mexErrMsgTxt("qmc_sequence:: At least one output argument is required!");
/*
** Test the first input argument and assign it to dimension.
*/
if (!mxIsNumeric(prhs[0]))
DYN_MEX_FUNC_ERR_MSG_TXT("qmc_sequence:: First input (dimension) has to be a positive integer!");
mexErrMsgTxt("qmc_sequence:: First input (dimension) has to be a positive integer!");
int dimension = static_cast<int>(mxGetScalar(prhs[0]));
/*
** Test the second input argument and assign it to seed.
*/
if (!(mxIsNumeric(prhs[1]) && mxIsClass(prhs[1], "int64")))
DYN_MEX_FUNC_ERR_MSG_TXT("qmc_sequence:: Second input (seed) has to be an integer [int64]!");
mexErrMsgTxt("qmc_sequence:: Second input (seed) has to be an integer [int64]!");
int64_T seed = static_cast<int64_T>(mxGetScalar(prhs[1]));
/*
@ -83,22 +83,22 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
error_flag_3 = 1;
if (error_flag_3 == 1)
DYN_MEX_FUNC_ERR_MSG_TXT("qmc_sequence:: Third input (type of QMC sequence) has to be an integer equal to 0, 1 or 2!");
mexErrMsgTxt("qmc_sequence:: Third input (type of QMC sequence) has to be an integer equal to 0, 1 or 2!");
/*
** Test dimension ≥ 2 when type==2
*/
if (type == 2 && dimension < 2)
DYN_MEX_FUNC_ERR_MSG_TXT("qmc_sequence:: First input (dimension) has to be greater than 1 for a uniform QMC on an hypershere!");
mexErrMsgTxt("qmc_sequence:: First input (dimension) has to be greater than 1 for a uniform QMC on an hypershere!");
else if (dimension > DIM_MAX)
DYN_MEX_FUNC_ERR_MSG_TXT(("qmc_sequence:: First input (dimension) has to be smaller than " + to_string(DIM_MAX) + " !").c_str());
mexErrMsgTxt(("qmc_sequence:: First input (dimension) has to be smaller than " + to_string(DIM_MAX) + " !").c_str());
/*
** Test the optional fourth input argument and assign it to sequence_size.
*/
if (nrhs > 3 && !mxIsNumeric(prhs[3]))
DYN_MEX_FUNC_ERR_MSG_TXT("qmc_sequence:: Fourth input (qmc sequence size) has to be a positive integer!");
mexErrMsgTxt("qmc_sequence:: Fourth input (qmc sequence size) has to be a positive integer!");
int sequence_size;
if (nrhs > 3)
@ -110,17 +110,17 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
** Test the optional fifth input argument and assign it to lower_and_upper_bounds.
*/
if (nrhs > 4 && type == 0 && mxGetN(prhs[4]) != 2) // Sequence of uniformly distributed numbers in an hypercube
DYN_MEX_FUNC_ERR_MSG_TXT("qmc_sequence:: The fifth input argument must be an array with two columns!");
mexErrMsgTxt("qmc_sequence:: The fifth input argument must be an array with two columns!");
if (nrhs > 4 && type == 0 && static_cast<int>(mxGetM(prhs[4])) != dimension)
DYN_MEX_FUNC_ERR_MSG_TXT("qmc_sequence:: The fourth input argument must be an array with a number of lines equal to dimension (first input argument)!");
mexErrMsgTxt("qmc_sequence:: The fourth input argument must be an array with a number of lines equal to dimension (first input argument)!");
if (nrhs > 4 && type == 1 && !(static_cast<int>(mxGetN(prhs[4])) == dimension
&& static_cast<int>(mxGetM(prhs[4])) == dimension)) // Sequence of normally distributed numbers
DYN_MEX_FUNC_ERR_MSG_TXT("qmc_sequence:: The fifth input argument must be a squared matrix (whose dimension is given by the first input argument)!");
mexErrMsgTxt("qmc_sequence:: The fifth input argument must be a squared matrix (whose dimension is given by the first input argument)!");
if (nrhs > 4 && type == 2 && !(mxGetN(prhs[4]) == 1 && mxGetM(prhs[4]) == 1)) // Sequence of uniformly distributed numbers on a hypershere
DYN_MEX_FUNC_ERR_MSG_TXT("qmc_sequence:: The fifth input argument must be a positive scalar!");
mexErrMsgTxt("qmc_sequence:: The fifth input argument must be a positive scalar!");
const double *lower_bounds = nullptr, *upper_bounds = nullptr;
int unit_hypercube_flag = 1;

6
tests/kalman_steady_state/test1.m
View File

@ -17,8 +17,7 @@ for i=1:100
Z(1,1) = 1;
Z(2,3) = 1;
Z(3,6) = 1;
[err P] = kalman_steady_state(transpose(T),QQ,transpose(Z),H);
mexErrCheck('kalman_steady_state',err);
P = kalman_steady_state(transpose(T),QQ,transpose(Z),H);
end
% Without measurment errors.
@ -35,6 +34,5 @@ for i=1:100
Z(1,1) = 1;
Z(2,3) = 1;
Z(3,6) = 1;
[err P] = kalman_steady_state(transpose(T),QQ,transpose(Z),H);
mexErrCheck('kalman_steady_state',err);
P = kalman_steady_state(transpose(T),QQ,transpose(Z),H);
end

22
tests/kronecker/test_kron.m
View File

@ -1,5 +1,5 @@
function info = test_kron(test,number_of_threads)
% Copyright (C) 2007-2010 Dynare Team
% Copyright (C) 2007-2020 Dynare Team
%
% This file is part of Dynare.
%
@ -52,14 +52,12 @@ if test == 1
disp('')
disp('Computation of A*kron(B,B) with the mex file (v1):')
tic
[err, D1] = sparse_hessian_times_B_kronecker_C(A,B,number_of_threads);
mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
D1 = sparse_hessian_times_B_kronecker_C(A,B,number_of_threads);
toc
disp('')
disp('Computation of A*kron(B,B) with the mex file (v2):')
tic
[err, D2] = sparse_hessian_times_B_kronecker_C(A,B,B,number_of_threads);
mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
D2 = sparse_hessian_times_B_kronecker_C(A,B,B,number_of_threads);
toc
disp('');
disp(['Difference between D1 and D2 = ' num2str(max(max(abs(D1-D2))))]);
@ -120,14 +118,12 @@ if test==2
disp(' ')
disp('Computation of A*kron(B,B) with the mex file (v1):')
tic
[err, D1] = sparse_hessian_times_B_kronecker_C(hessian,zx,number_of_threads);
mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
D1 = sparse_hessian_times_B_kronecker_C(hessian,zx,number_of_threads);
toc
disp(' ')
disp('Computation of A*kron(B,B) with the mex file (v2):')
tic
[err, D2] = sparse_hessian_times_B_kronecker_C(hessian,zx,zx,number_of_threads);
mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
D2 = sparse_hessian_times_B_kronecker_C(hessian,zx,zx,number_of_threads);
toc
disp(' ');
disp(['Difference between D1 and D2 = ' num2str(max(max(abs(D1-D2))))]);
@ -167,8 +163,7 @@ if test==3
disp('Test with full format matrix -- 1(a)')
D1 = A*kron(B,C);
tic
[err, D2] = A_times_B_kronecker_C(A,B,C,number_of_threads);
mexErrCheck('A_times_B_kronecker_C', err);
D2 = A_times_B_kronecker_C(A,B,C,number_of_threads);
toc
disp(['Difference between D1 and D2 = ' num2str(max(max(abs(D1-D2))))]);
if max(max(abs(D1-D2)))>1e-10
@ -177,8 +172,7 @@ if test==3
disp('Test with full format matrix -- 1(b)')
D1 = A*kron(B,B);
tic
[err, D2] = A_times_B_kronecker_C(A,B,number_of_threads);
mexErrCheck('A_times_B_kronecker_C', err);
D2 = A_times_B_kronecker_C(A,B,number_of_threads);
toc
disp(['Difference between D1 and D2 = ' num2str(max(max(abs(D1-D2))))]);
if max(max(abs(D1-D2)))>1e-10
@ -187,4 +181,4 @@ if test==3
if ~(test3_1 && test3_2)
info = 0;
end
end
end