# Breaking features in version 4.6

Version 4.6 brings many improvements but also some breaking changes. The most important of them concerns Dynare internals that will affect users who expand Dynare with their own Matlab code.

We most strongly encourage you modify your own code to comply with the new version. Relying on an older version of Dynare to run your own code may seem as a gain of time in the short term but will lead to more problems later. Note also that possible bugs found later in version 4.5.7 won't be fixed in that version. We expect users to run version 4.6 from now on.

## Changes related to Dynare commands

- In order to allow for interpretable expressions within
`moment_calibration`

and`irf_calibration`

-blocks, upper and lower bounds now need to be separated by a comma. For example, a range between zero and one

```
irf_calibration;
y(1:4), e_ys, [0 1];
end;
```

now needs to be specified as

```
irf_calibration;
y(1:4), e_ys, [0, 1];
end;
```

- The results of the
`conditional_forecast`

command are now saved in the output structure`oo_`

under`oo_.conditional_forecast`

. They are not saved to hard-disk in a file called`conditional_forecasts.mat`

anymore. Code needs to be adjusted to reference the structure subfield instead of loading it from the disk. - The Dynare macro-processor now allows for nested arrays, i.e. defining arrays that contain other arrays. As a consequence, the old ambiguous syntax needed to be replaced by something unambiguous. In Dynare
`4.5`

,`[1:2]`

was equivalent to`1:2`

. Both definitions created an array of integers. In Dynare`4.6`

this has changed.`1:2`

still creates an array of integers, while`[1:2]`

will create an array*within*an array. This implies that in most cases the squared brackets around ranges need to be removed if algebra is performed on the array members. For example, in Dynare`4.5`

you could sum integers by writing

```
@#define a = 3
@#for i in [1:4]
@#define b = i+a
@#endfor
```

This will not work in Dynare `4.6`

, because now your are adding an integer `a`

to a an array of integers in `i`

. The error message will typically be something along the lines of

```
Macro-processing error: backtrace...
- Type mismatch for operands of + operator
- binary operation: "model_name.mod" line x, col x-xx
```

The correct code in Dynare `4.6`

would be

```
@#define a = 3
@#for i in 1:4
@#define b = i+a
@#endfor
```

Note the deleted brackets in the definition of the range `1:4`

.

- The Dynare macro-processor now performs division with doubles instead of integers. For example,
`3/2`

used to result in`1`

, now it results in`1.5`

. To restore the old behavior, one needs to replace

`a/b`

by

`floor(a/b)`

- The
`ramsey_policy`

-command is now deprecated. It is superseded by calls to`ramsey_policy`

,`stoch_simul`

, and`evaluate_planner_objective`

. This allows for better control of the individual elements going into the computations. For example, to achieve the same results as previously with

`ramsey_policy(planner_discount=0.99,order=1,instruments=(r),periods=500,irf=25);`

the new syntax is

```
ramsey_model(planner_discount=0.99,instruments=(r));
stoch_simul(order=1,periods=500,irf=25);
evaluate_planner_objective;
```

The `ramsey_model`

-command sets up the Ramsey problem, while `stoch_simul`

solves the model with perturbation techniques, conducts stochastic simulations, and computes IRFs. Finally, `evaluate_planner_objective`

computes and displays the value of the `planner_objective`

.

## Changes related to Dynare internals

- Dynare has phased out the use of global variables in
`stoch_simul`

and its related subfunctions like`simult_`

,`irf`

, and`discretionary_policy`

(see e043c609). In case you looped over`stoch_simul`

using a call to

`info = stoch_simul(var_list_);`

you now need to now add the previous three global variables `M_, options_, oo_`

as the first inputs:

`[info, oo_, options_] = stoch_simul(M_, options_, oo_, var_list_);`

Previous calls to `simult_`

like

`y_sim_one_shock = simult_(y0,oo_.dr,temp_shock_mat,options_.order);`

need to add the previous two global variables `M_,options_`

as their first two inputs:

`y_sim_one_shock = simult_(M_,options_,y0,oo_.dr,temp_shock_mat,options_.order);`

- List of names have been converted from character arrays to cell arrays of strings. This affects
`M_.endo_names`

,`M_.exo_names`

,`M_.param_names`

,`oo_.var_list`

, and`options_.varobs`

. For that reason, you may have to replace round by curly brackets. - In addition, Dynare 4.6 has phased out the use of global variables in user-defined steady state files (see 0c01c314). Instead, the model structure
`M_`

and the options-structure`options_`

are now passed as input arguments, while the parameter vector`params`

has become an output argument. - Related to the previous three changes, user-defined steady state files need to be adjusted for i) the interface change related to globals and ii) for the reading out of variables and parameters to be compatible with the cell arrays. In case you are using legacy files, you will generally encounter the error message

Error using Modelname_steadystate Too many input arguments.

Error in evaluate_steady_state_file (line 49) [ys,params1,check] = h_steadystate(ys_init, exo_ss,M,options); and

or

Error using eval Must be a string scalar or character vector.

Error in Model_name_steadystate (line 21) eval([ paramname ' = M_.params(' int2str(ii) ');']);

In Dynare 4.5.7, the interface for `_steady_state.m`

-files used to be

```
function [ys,check] = NK_baseline_steadystate(ys,exo)
% function [ys,check] = NK_baseline_steadystate(ys,exo)
% computes the steady state for the NK_baseline.mod and uses a numerical
% solver to do so
% Inputs:
% - ys [vector] vector of initial values for the steady state of
% the endogenous variables
% - exo [vector] vector of values for the exogenous variables
%
% Output:
% - ys [vector] vector of steady state values fpr the the endogenous variables
% - check [scalar] set to 0 if steady state computation worked and to
% 1 of not (allows to impos restriction on parameters)
global M_
% read out parameters to access them with their name
NumberOfParameters = M_.param_nbr;
for ii = 1:NumberOfParameters
paramname = deblank(M_.param_names(ii,:));
eval([ paramname ' = M_.params(' int2str(ii) ');']);
end
% initialize indicator
check = 0;
```

In Dynare 4.6 instead the required interface is

```
function [ys,params,check] = NK_baseline_steadystate(ys,exo,M_,options_)
% function [ys,params,check] = NK_baseline_steadystate(ys,exo,M_,options_)
% computes the steady state for the NK_baseline.mod and uses a numerical
% solver to do so
% Inputs:
% - ys [vector] vector of initial values for the steady state of
% the endogenous variables
% - exo [vector] vector of values for the exogenous variables
% - M_ [structure] Dynare model structure
% - options [structure] Dynare options structure
%
% Output:
% - ys [vector] vector of steady state values for the the endogenous variables
% - params [vector] vector of parameter values
% - check [scalar] set to 0 if steady state computation worked and to
% 1 of not (allows to impose restrictions on parameters)
% read out parameters to access them with their name
NumberOfParameters = M_.param_nbr;
for ii = 1:NumberOfParameters
paramname = M_.param_names{ii};
eval([ paramname ' = M_.params(' int2str(ii) ');']);
end
% initialize indicator
check = 0;
```

Note the interface change in the first line and the use of curly brackets within the loop.

For writing back the steady state to `ys`

and the parameters to `params`

, the code at the bottom of the steady state file used to be

```
for iter = 1:length(M_.params) %update parameters set in the file
eval([ 'M_.params(' num2str(iter) ') = ' M_.param_names(iter,:) ';' ])
end
NumberOfEndogenousVariables = M_.orig_endo_nbr; %auxiliary variables are set automatically
for ii = 1:NumberOfEndogenousVariables
varname = deblank(M_.endo_names(ii,:));
eval(['ys(' int2str(ii) ') = ' varname ';']);
end
```

It now needs to be replaced by

```
params=NaN(NumberOfParameters,1);
for iter = 1:length(M_.params) %update parameters set in the file
eval([ 'params(' num2str(iter) ') = ' M_.param_names{iter} ';' ])
end
NumberOfEndogenousVariables = M_.orig_endo_nbr; %auxiliary variables are set automatically
for ii = 1:NumberOfEndogenousVariables
varname = M_.endo_names{ii};
eval(['ys(' int2str(ii) ') = ' varname ';']);
end
```

Note that you now need to span the full parameter vector `params`

first and that again curly brackets are used within the loops.

- The names of most functions related to
`identification`

have changed to become more expressive. See 666c9b80